Description Ross 2007-06-18 17:35:02 EDT

Build ID: M20070212-1330

Steps To Reproduce:
I can only reproduce this on my java code base, although it occurs on every site including Windows Vista, Ubuntu, Red Hat and using Java 1.5 and 1.6 and different versions of Eclipse (including 3.3R4). We can't pin what file causes it, though, because it is inconsistent, but the error's the same.

More information:
We cannot figure out how to get around this bug, so coding and testing for our project is blocked, and we have a deadline in a month, which is why I gave this a high severity. The following is the error Eclipse gives us:

Internal compiler error java.lang.NullPointerException at 
 org.eclipse.jdt.internal.compiler.ast.FieldReference.resolveType
 (FieldReference.java:557) at 
 org.eclipse.jdt.internal.compiler.ast.MessageSend.resolveType
 (MessageSend.java:310) at 
 org.eclipse.jdt.internal.compiler.ast.MessageSend.resolveType
 (MessageSend.java:310) at 
 org.eclipse.jdt.internal.compiler.ast.ForeachStatement.resolve
 (ForeachStatement.java:353) at 
 org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolveStat
 ements(AbstractMethodDeclaration.java:432) at 
 org.eclipse.jdt.internal.compiler.ast.MethodDeclaration.resolveStatements
 (MethodDeclaration.java:190) at 
 org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolve
 (AbstractMethodDeclaration.java:403) at 
 org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve
 (TypeDeclaration.java:1047) at 
 org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve
 (TypeDeclaration.java:1088) at 
 org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve
 (TypeDeclaration.java:976) at 
 org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve
 (TypeDeclaration.java:1094) at 
 org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve
 (CompilationUnitDeclaration.java:353) at 
 org.eclipse.jdt.internal.compiler.Compiler.process(Compiler.java:596) at 
 org.eclipse.jdt.internal.compiler.Compiler.compile(Compiler.java:411) at 
 org.eclipse.jdt.internal.core.builder.AbstractImageBuilder.compile
 (AbstractImageBuilder.java:353) at 
 org.eclipse.jdt.internal.core.builder.BatchImageBuilder.compile
 (BatchImageBuilder.java:171) at 
 org.eclipse.jdt.internal.core.builder.AbstractImageBuilder.compile
 (AbstractImageBuilder.java:290) at 
 org.eclipse.jdt.internal.core.builder.BatchImageBuilder.build
 (BatchImageBuilder.java:59) at 
 org.eclipse.jdt.internal.core.builder.JavaBuilder.buildAll(JavaBuilder.java:
 241) at org.eclipse.jdt.internal.core.builder.JavaBuilder.build
 (JavaBuilder.java:169) at org.eclipse.core.internal.events.BuildManager
 $2.run(BuildManager.java:603) at org.eclipse.core.runtime.SafeRunner.run
 (SafeRunner.java:37) at 
 org.eclipse.core.internal.events.BuildManager.basicBuild
 (BuildManager.java:167) at 
 org.eclipse.core.internal.events.BuildManager.basicBuild
 (BuildManager.java:201) at org.eclipse.core.internal.events.BuildManager
 $1.run(BuildManager.java:230) at org.eclipse.core.runtime.SafeRunner.run
 (SafeRunner.java:37) at 
 org.eclipse.core.internal.events.BuildManager.basicBuild
 (BuildManager.java:233) at 
 org.eclipse.core.internal.events.BuildManager.basicBuildLoop
 (BuildManager.java:252) at 
 org.eclipse.core.internal.events.BuildManager.build(BuildManager.java:
 285) at org.eclipse.core.internal.events.AutoBuildJob.doBuild
 (AutoBuildJob.java:154) at org.eclipse.core.internal.events.AutoBuildJob.run
 (AutoBuildJob.java:217) at org.eclipse.core.internal.jobs.Worker.run
 (Worker.java:58)

The code base has a heavy and complex use of generics. The odd thing is the error occurs in the code that has not changed much for months. Here is the code for the file it seems to break on for most of us:

package util.graph;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import util.ArrayCollection;
import util.Grouping;
import util.HashGrouping;
import util.IdentityHashGrouping;
import util.MultiMap;
import util.Tag;
import util.VariaticFunction;
import util.pair.PairedList;

public abstract class RecursiveExpressionGraph<
		G extends RecursiveExpressionGraph<G,V,L>,
		V extends RecursiveExpressionVertex<G,V,L>, L>
		extends ExpressionGraph<G,V,L> {
	protected final Grouping<V> mGrouping = new IdentityHashGrouping<V>();
	
	public RecursiveExpressionGraph() {super(4);}

	public void trimInsignificant() {
		super.trimInsignificant();
		Collection<V> trimmed = new ArrayCollection<V>();
		for (V rep : mGrouping.getRepresentatives())
			if (!getVertices().contains(rep))
				trimmed.add(rep);
		for (V rep : trimmed)
			mGrouping.ungroup(rep);
	}
	
	public V createPlaceHolder() {
		return makeHolderVertex();
	}
	public V createPlaceHolder(L label) {
		return makeHolderVertex(label);
	}
	
	protected abstract V makeHolderVertex();
	protected abstract V makeHolderVertex(L label);
	
	protected interface IVertex<G extends RecursiveExpressionGraph<G,V,L>,
			V extends IVertex<G,V,L>,L> extends ExpressionGraph.IVertex<G,V,L>,
			RecursiveExpressionVertex<G,V,L> {
		public void setParents(Set<V> parents);
		public Set<V> getParents();
		public PairedList<Tag,Object> getTags();
		public void setTags(PairedList<Tag,Object> tags);
	}
	
	protected static abstract class HolderVertex
			<G extends RecursiveExpressionGraph<G,V,L>,
			V extends IVertex<G,V,L>, L> extends ExpressionGraph.Vertex<G,V,L>
			implements IVertex<G,V,L> {
		protected V mReplacement = null;
		
		public HolderVertex(L label) {super(label);}
		
		public L getLabel() {
			return mReplacement == null ? super.getLabel()
					: mReplacement.getLabel();
		}
		
		public boolean hasChildren() {
			return mReplacement != null && mReplacement.hasChildren();
		}
		public boolean hasChildren(V... children) {
			return mReplacement != null && mReplacement.hasChildren(children);
		}
		public boolean hasChildren(List<? extends V> children) {
			return mReplacement != null && mReplacement.hasChildren(children);
		}
		public List<? extends V> getChildren() {
			return mReplacement == null ? Collections.<V>emptyList()
					: mReplacement.getChildren();
		}
		public V getChild(int i) {
			return mReplacement == null ? getChildren().get(i)
					: mReplacement.getChild(i);
		}
		public int getChildCount() {
			return mReplacement == null ? 0 : mReplacement.getChildCount();
		}
		
		public <E> E evaluate(VariaticFunction<L,E,E> evaluator) {
			return mReplacement == null ? evaluator.get(getLabel())
					: mReplacement.evaluate(evaluator);
		}
		public <E> E evaluateVertex(VariaticFunction<? super V,E,E> evaluator) {
			return mReplacement == null ? evaluator.get(getSelf())
					: mReplacement.evaluateVertex(evaluator);
		}
		
		public boolean isPlaceHolder() {return mReplacement == null;}
		
		public void replaceWith(V replacement) {
			if (mReplacement != null)
				throw new IllegalStateException();
			if (replacement.isPlaceHolder())
				throw new IllegalArgumentException();
			boolean hadParents = replacement.hasParents();
			mReplacement = replacement;
			replacement.addParents(mParents);
			mParents = replacement.getParents();
			mReplacement.getTags().addAll(mTags);
			mTags = mReplacement.getTags();
			getGraph().mGrouping.group(mReplacement, getSelf());
			Grouping<V> grouping = null;
			if (hadParents) {
				grouping = new HashGrouping<V>();
				if (mergeParents(grouping)) {
					applyGrouping(grouping);
					grouping = null;
				}
			}
			for (V similar
					: getGraph().mTracker.get(replacement.getChildCount())
					.get(replacement.getLabel())) {
				if (similar.equals(replacement))
					continue;
				if (grouping == null)
					grouping = new HashGrouping<V>();
				if (merge(replacement, similar, grouping)) {
					mergeParents(grouping);
					applyGrouping(grouping);
					break;
				}
			}
		}
		
		protected boolean mergeParents(Grouping<V> grouping) {
			List<MultiMap<L,V>> tracker = getGraph().mTracker;
			boolean anyChange = false;
			for (boolean changed = true; changed; ) {
				changed = false;
				for (int arity = 1; arity < tracker.size(); arity++)
					for (Set<? extends V> verts
							: tracker.get(arity).valueSets()) {
						if (verts.size() <= 1)
							continue;
						for (V left : verts)
							for (V right : verts) {
								if (grouping.isGrouped(left, right))
									continue;
								boolean same = true;
								for (int child = arity; child-- != 0; )
									if (!grouping.isGrouped(
											left.getChild(child),
											right.getChild(child))) {
										same = false;
										break;
									}
								if (same)
									changed |= grouping.group(left, right);
							}
					}
				anyChange |= changed;
			}
			return anyChange;
		}
		
		protected boolean merge(V left, V right, Grouping<V> grouping) {
			if (grouping.isGrouped(left, right))
				return true;
			if (left.isPlaceHolder() || right.isPlaceHolder())
				return false;
			if (left.getChildCount() != right.getChildCount())
				return false;
			if (!left.hasLabel(right.getLabel()))
				return false;
			grouping.group(left, right);
			for (int child = 0; child < left.getChildCount(); child++)
				if (!merge(left.getChild(child), right.getChild(child),
						grouping))
					return false;
			return true;
		}
		
		protected void applyGrouping(Grouping<V> grouping) {
			G graph = getGraph();
			List<MultiMap<L,V>> tracker = graph.mTracker;
			Set<V> vertices = graph.mVertices;
			Map<L,V> leaves = graph.mLeaves;
			Grouping<V> masterGrouping = graph.mGrouping;
			for (V rep : grouping.getRepresentatives())
				for (V friend : grouping.getGroup(rep))
					if (!rep.equals(friend)) {
						vertices.remove(friend);
						if (friend.isLeaf())
							leaves.remove(friend);
						tracker.get(friend.getChildCount())
								.removeValue(friend.getLabel(), friend);
						if (friend.unmakeSignificant())
							rep.makeSignificant();
						rep.addParents(friend.getParents());
						rep.getTags().addAll(friend.getTags());
						for (V associate : masterGrouping.getGroup(friend)) {
							associate.setParents(rep.getParents());
							associate.setTags(rep.getTags());
						}
						masterGrouping.group(rep, friend);
					}
		}
		
		public String toString() {
			return mReplacement == null ? super.toString()
					: mReplacement.toString();
		}
	}
	
	protected static abstract class LeafVertex
			<G extends RecursiveExpressionGraph<G,V,L>,
			V extends IVertex<G,V,L>, L>
			extends ExpressionGraph.LeafVertex<G,V,L> implements IVertex<G,V,L>
			{
		public LeafVertex(L label) {super(label);}
		
		public boolean isPlaceHolder() {return false;}
		public void replaceWith(V replacement) {
			throw new UnsupportedOperationException();
		}
	}
	
	protected static abstract class UniVertex
			<G extends RecursiveExpressionGraph<G,V,L>,
			V extends IVertex<G,V,L>, L>
			extends ExpressionGraph.UniVertex<G,V,L> implements IVertex<G,V,L> {
		public UniVertex(L label, V child) {super(label, child);}
		
		public boolean isPlaceHolder() {return false;}
		public void replaceWith(V replacement) {
			throw new UnsupportedOperationException();
		}
	}
	
	protected static abstract class MultiVertex
			<G extends RecursiveExpressionGraph<G,V,L>,
			V extends IVertex<G,V,L>, L>
			extends ExpressionGraph.MultiVertex<G,V,L> implements IVertex<G,V,L>
			{
		public MultiVertex(L label, V[] children) {super(label, children);}
		
		public boolean isPlaceHolder() {return false;}
		public void replaceWith(V replacement) {
			throw new UnsupportedOperationException();
		}
	}
}