Further caching in the CompleteParseASTFactory.

core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/CompleteParseASTTest.java

@@ -798,11 +798,9 @@ public class CompleteParseASTTest extends CompleteParseBaseTest
 			IASTField field1 = (IASTField) j.next();			
 			// Note : this used to be considered a variable, not a field
 			IASTField field2 = (IASTField)i.next(); 
-			
-			assertEquals( callback.getReferences().size(), 1 );
-			Iterator references = callback.getReferences().iterator();
-			assertEquals( ((IASTReference)references.next()).getReferencedElement(), classA );
 			assertTrue (field1.getVisiblity() == field2.getVisiblity());
+			assertAllReferences( 1, createTaskList( new Task( classA )));
+			
 		}catch (Exception e){
 			fail();
 		}

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/ast/IASTExpression.java

@@ -276,7 +276,7 @@ public interface IASTExpression extends ISourceElementCallbackDelegate, IASTNode
 	public IASTNewExpressionDescriptor getNewExpressionDescriptor(); 
 	
 	public long evaluateExpression() throws ASTExpressionEvaluationException;
-	public void reconcileReferences() throws ASTNotImplementedException;
+	public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException;
 	public void purgeReferences() throws ASTNotImplementedException;
 	/**
 	 * @param manager TODO

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ExpressionParser.java

@@ -753,6 +753,8 @@ public class ExpressionParser implements IExpressionParser, IParserData {
 				}
 				continue;	            
 	        }
+	        if( nameDuple != null )
+	        	nameDuple.freeReferences( astFactory.getReferenceManager() );
 	        backup(mark);
 	        return result;
 		}

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Parser.java

@@ -2218,12 +2218,13 @@ public abstract class Parser extends ExpressionParser implements IParser
                         	{
 								IToken newMark = mark();
 								consume( IToken.tLPAREN );
-
+								ITokenDuple queryName = null;
 	                        	try
 	                        	{
 	                        		try
                                     {
-                                        if( ! astFactory.queryIsTypeName( parameterScope, name(parameterScope, CompletionKind.TYPE_REFERENCE, Key.EMPTY ) ) )
+                                        queryName = name(parameterScope, CompletionKind.TYPE_REFERENCE, Key.EMPTY );
+										if( ! astFactory.queryIsTypeName( parameterScope, queryName ) )
                                         	failed = true;
                                     }
                                     catch (Exception e)
@@ -2236,6 +2237,8 @@ public abstract class Parser extends ExpressionParser implements IParser
 	                        		failed = true; 
 	                        	}
 	                        	
+	                        	if( queryName != null )
+	                        		queryName.freeReferences(astFactory.getReferenceManager());
 								backup( newMark );
                         	}
                         }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ASTBinaryExpression.java

@@ -67,10 +67,10 @@ public class ASTBinaryExpression extends ASTUnaryExpression {
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.core.parser.ast.IASTExpression#reconcileReferences()
 	 */
-	public void reconcileReferences() throws ASTNotImplementedException {
+	public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException {
-		super.reconcileReferences();
+		super.reconcileReferences(manager);
-		rhs.reconcileReferences();
+		rhs.reconcileReferences(manager);
-		reconcileSubExpression((ASTExpression) rhs);
+		reconcileSubExpression((ASTExpression) rhs, manager);
 	}
 
 	/* (non-Javadoc)

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ASTClassSpecifier.java

@@ -198,11 +198,7 @@ public class ASTClassSpecifier extends ASTScope implements IASTClassSpecifier
      */
     public void exitScope(ISourceElementRequestor requestor, IReferenceManager manager)
     {
-    	Iterator i = resolvedCrossReferences.iterator();
+    	manager.processReferences( this.resolvedCrossReferences, requestor );
-    	while( i.hasNext() )
-    	{
-    		((IASTReference)i.next()).acceptElement( requestor, manager );
-    	}
         try
         {
             requestor.exitClassSpecifier(this);
@@ -335,7 +331,7 @@ public class ASTClassSpecifier extends ASTScope implements IASTClassSpecifier
 			for( int i = 0; i < references.size(); ++i )
 			{
 				IASTReference r = (IASTReference)references.get(i);
-				resolvedCrossReferences.add( cache.getReference(r.getOffset(), r.getReferencedElement()));	
+				resolvedCrossReferences.add( r );	
 			}
 		}
 		

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ASTConditionalExpression.java

@@ -70,10 +70,10 @@ public class ASTConditionalExpression extends ASTBinaryExpression {
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.core.parser.ast.IASTExpression#reconcileReferences()
 	 */
-	public void reconcileReferences() throws ASTNotImplementedException {
+	public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException {
-		super.reconcileReferences();
+		super.reconcileReferences(manager);
-		thirdExpression.reconcileReferences();
+		thirdExpression.reconcileReferences(manager);
-		reconcileSubExpression((ASTExpression) thirdExpression);
+		reconcileSubExpression((ASTExpression) thirdExpression, manager);
 	}
 
 	/* (non-Javadoc)

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ASTExpression.java

@@ -71,7 +71,7 @@ public abstract class ASTExpression extends ASTNode implements IASTExpression
     {
 		try
         {
-            reconcileReferences();
+            reconcileReferences(manager);
         }
         catch (ASTNotImplementedException e)
         {
@@ -129,11 +129,11 @@ public abstract class ASTExpression extends ASTNode implements IASTExpression
     /* (non-Javadoc)
      * @see org.eclipse.cdt.core.parser.ast.IASTExpression#reconcileReferences()
      */
-    public void reconcileReferences() throws ASTNotImplementedException
+    public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException
     {
     }
     
-    protected void reconcileSubExpression(ASTExpression subExpression)
+    protected void reconcileSubExpression(ASTExpression subExpression, IReferenceManager manager)
     {
         if( subExpression != null && subExpression.getReferences() != null )
         {
@@ -142,7 +142,10 @@ public abstract class ASTExpression extends ASTNode implements IASTExpression
         	{
         		IASTReference aReference = (IASTReference)subExp.next();
         		if( aReference != null && references.contains( aReference ) )
+        		{
         			subExp.remove();
+        			manager.returnReference( aReference );
+        		}
         	}   		
         }
     }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ASTUnaryExpression.java

@@ -54,9 +54,9 @@ public class ASTUnaryExpression extends ASTExpression {
 	/* (non-Javadoc)
 	 * @see org.eclipse.cdt.core.parser.ast.IASTExpression#reconcileReferences()
 	 */
-	public void reconcileReferences() throws ASTNotImplementedException {
+	public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException {
-		lhs.reconcileReferences();
+		lhs.reconcileReferences(manager);
-		reconcileSubExpression((ASTExpression) lhs);
+		reconcileSubExpression((ASTExpression) lhs, manager);
 	}
 	
 	/* (non-Javadoc)

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/CompleteParseASTFactory.java

@@ -1215,7 +1215,10 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto
 				{
 					IASTReference r = (IASTReference) refs.next();
 					if( r.getName().equals( idExpression ) )
+					{
 						refs.remove();
+						cache.returnReference(r);
+					}
 				}
 			}
 		}
@@ -2471,11 +2474,9 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto
 				functionParameters.add(param.getSymbol().getTypeInfo());
 			}
 			
-			List functionReferences = new ArrayList();
-			
 			functionDeclaration = (IParameterizedSymbol) lookupQualifiedName( ownerScope, nameDuple, 
 																			  isConstructor ? TypeInfo.t_constructor : TypeInfo.t_function, 
-																			  functionParameters, functionReferences, false, 
+																			  functionParameters, null, false, 
 																			  isFriend ? LookupType.FORFRIENDSHIP : LookupType.FORDEFINITION );
 			
 			previouslyDeclared = ( functionDeclaration != null ) && functionDeclaration.isType( isConstructor ? TypeInfo.t_constructor : TypeInfo.t_function );
@@ -2884,8 +2885,7 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto
 		newSymbol.setIsForwardDeclaration(isStatic);
 		boolean previouslyDeclared = false;
 		if( !isStatic && !image.equals( EMPTY_STRING ) ){
-			List fieldReferences = new ArrayList();		
+			ISymbol fieldDeclaration = lookupQualifiedName(ownerScope, image, null, false, LookupType.FORDEFINITION);                
-			ISymbol fieldDeclaration = lookupQualifiedName(ownerScope, image, fieldReferences, false, LookupType.FORDEFINITION);                
 			
 			if( fieldDeclaration != null && newSymbol.getType() == fieldDeclaration.getType() )
 			{
@@ -3456,26 +3456,14 @@ public class CompleteParseASTFactory extends BaseASTFactory implements IASTFacto
         while( i.hasNext() )
         {	
         	UnresolvedReferenceDuple duple = (UnresolvedReferenceDuple) i.next();
-        	ISymbol s = null;
         	
-        	List subReferences = new ArrayList();
         	try
 			{
-        		s = lookupQualifiedName( duple.getScope(), duple.getName(), subReferences, false );
+        		lookupQualifiedName( duple.getScope(), duple.getName(), references, false );
         	}
         	catch( ASTSemanticException ase )
 			{
         	}
-        	
-        	if( s != null && subReferences != null && !subReferences.isEmpty())
-        		for( int j = 0; j < subReferences.size(); ++j )
-        		{
-        			IASTReference r = (IASTReference) subReferences.get(j);
-        			references.add( cache.getReference( r.getOffset(), r.getReferencedElement()));
-        		}
-
-        	
-        	
         }
         
         astImplementation.setProcessingUnresolvedReferences( false );

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/complete/ReferenceCache.java

@@ -10,7 +10,6 @@
  ***********************************************************************/
 package org.eclipse.cdt.internal.core.parser.ast.complete;
 
-import java.util.Collections;
 import java.util.List;
 
 import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate;
@@ -57,12 +56,32 @@ public class ReferenceCache implements IReferenceManager {
 		ASTReference [] createReferenceArray( int size );
 	}
 	
-	private static final int DEFAULT_CACHE_SIZE = 16;
+	private static final int DEFAULT_CACHE_SIZE = 64;
 
 	private boolean[] classReferencesAvailable;
 	private ASTReference[] classReferences;
 	private boolean[] variableReferencesAvailable;
 	private ASTReference[] variableReferences;
+	private boolean[] fieldReferencesAvailable;
+	private ASTReference[] fieldReferences;
+	private boolean[] functionReferencesAvailable;
+	private ASTReference[] functionReferences;
+	private boolean[] methodReferencesAvailable;
+	private ASTReference[] methodReferences;
+	private boolean[] enumerationReferencesAvailable;
+	private ASTReference[] enumerationReferences;
+	private boolean[] enumeratorReferencesAvailable;
+	private ASTReference[] enumeratorReferences;
+	private boolean[] namespaceReferencesAvailable;
+	private ASTReference[] namespaceReferences;
+	private boolean[] typedefReferencesAvailable;
+	private ASTReference[] typedefReferences;
+	private boolean[] parameterReferencesAvailable;
+	private ASTReference[] parameterReferences;
+	private boolean[] templateParameterReferencesAvailable;
+	private ASTReference[] templateParameterReferences;
+	
+	
 	
 	private abstract static class BaseReferenceFactory implements IReferenceFactory
 	{
@@ -71,6 +90,28 @@ public class ReferenceCache implements IReferenceManager {
 		}
 	}
 
+	private static final IReferenceFactory TYPEDEFREF_FACTORY = 
+		new BaseReferenceFactory() {
+		public ASTReference createReference() { return new ASTTypedefReference(); }
+	};
+
+	private static final IReferenceFactory NAMESPACEREF_FACTORY = 
+		new BaseReferenceFactory() {
+		public ASTReference createReference() { return new ASTNamespaceReference(); }
+	};
+	
+	private static final IReferenceFactory PARMREF_FACTORY = 
+		new BaseReferenceFactory() {
+		public ASTReference createReference() { return new ASTParameterReference(); }
+	};
+	
+	private static final IReferenceFactory TEMPPARMREF_FACTORY = 
+		new BaseReferenceFactory() {
+		public ASTReference createReference() { return new ASTTemplateParameterReference(); }
+	};
+
+
+	
 	private static final IReferenceFactory CLASSREF_FACTORY = 
 		new BaseReferenceFactory() {
 		public ASTReference createReference() { return new ASTClassReference(); }
@@ -78,6 +119,24 @@ public class ReferenceCache implements IReferenceManager {
 
 	};
 	
+	private static final IReferenceFactory FUNCTIONREF_FACTORY = 
+		new BaseReferenceFactory() {
+
+			public ASTReference createReference() {
+				return new ASTFunctionReference();
+			} 
+		
+	};
+
+	private static final IReferenceFactory METHODREF_FACTORY = 
+		new BaseReferenceFactory() {
+
+			public ASTReference createReference() {
+				return new ASTMethodReference();
+			} 
+		
+	};
+
 	private static final IReferenceFactory VARIABLEREF_FACTORY = 
 		new BaseReferenceFactory()	{
 
@@ -87,17 +146,77 @@ public class ReferenceCache implements IReferenceManager {
 		
 	};
 	
+	private static final IReferenceFactory FIELDREF_FACTORY = new BaseReferenceFactory()
+	{
+		public ASTReference createReference()
+		{
+			return new ASTFieldReference();
+		}
+	};
+
+	private static final IReferenceFactory ENUMSPECREF_FACTORY = new BaseReferenceFactory()
+	{
+		public ASTReference createReference()
+		{
+			return new ASTEnumerationReference();
+		}
+	};
+
+	private static final IReferenceFactory ENUMERATORREF_FACTORY = new BaseReferenceFactory()
+	{
+		public ASTReference createReference()
+		{
+			return new ASTEnumeratorReference();
+		}
+	};
+
 	
 	{
 		classReferences = CLASSREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
 		variableReferences = VARIABLEREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		fieldReferences = FIELDREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		functionReferences = FUNCTIONREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		methodReferences = METHODREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		enumerationReferences = ENUMSPECREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		enumeratorReferences = ENUMERATORREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		namespaceReferences = NAMESPACEREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		typedefReferences = TYPEDEFREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		parameterReferences = PARMREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
+		templateParameterReferences = TEMPPARMREF_FACTORY.createReferenceArray(DEFAULT_CACHE_SIZE);
 		classReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
 		variableReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		fieldReferencesAvailable = new boolean[ DEFAULT_CACHE_SIZE ];
+		functionReferencesAvailable = new boolean[ DEFAULT_CACHE_SIZE ];
+		methodReferencesAvailable = new boolean[ DEFAULT_CACHE_SIZE ];
+		enumerationReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		enumeratorReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		templateParameterReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		namespaceReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		typedefReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
+		parameterReferencesAvailable = new boolean[DEFAULT_CACHE_SIZE];
 		for (int i = 0; i < DEFAULT_CACHE_SIZE; ++i) {
 			classReferencesAvailable[i] = true;
 			variableReferencesAvailable[i] = true;
+			fieldReferencesAvailable[i] = true;
+			functionReferencesAvailable[i] = true;
+			methodReferencesAvailable[i] = true;
+			enumerationReferencesAvailable[i] = true;
+			enumeratorReferencesAvailable[i] = true;
+			namespaceReferencesAvailable[i] = true;
+			typedefReferencesAvailable[i] = true;
+			parameterReferencesAvailable[i] = true;
+			templateParameterReferencesAvailable[i] = true;
+			methodReferences[i] = METHODREF_FACTORY.createReference();
 			classReferences[i] =  CLASSREF_FACTORY.createReference();
 			variableReferences[i] = VARIABLEREF_FACTORY.createReference();
+			fieldReferences[i] = FIELDREF_FACTORY.createReference();
+			functionReferences[i] = FUNCTIONREF_FACTORY.createReference();
+			enumerationReferences[i] = ENUMSPECREF_FACTORY.createReference();
+			enumeratorReferences[i] = ENUMERATORREF_FACTORY.createReference();
+			typedefReferences[i] = TYPEDEFREF_FACTORY.createReference();
+			namespaceReferences[i] = NAMESPACEREF_FACTORY.createReference();
+			parameterReferences[i] = PARMREF_FACTORY.createReference();
+			templateParameterReferences[i] = TEMPPARMREF_FACTORY.createReference();
 		}
 	}
 
@@ -113,7 +232,50 @@ public class ReferenceCache implements IReferenceManager {
 			returnReference( variableReferencesAvailable, variableReferences, reference );
 			return;
 		}
-		
+		if( reference instanceof IASTFieldReference )
+		{
+			returnReference( fieldReferencesAvailable, fieldReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTFunctionReference )
+		{
+			returnReference( functionReferencesAvailable, functionReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTMethodReference )
+		{
+			returnReference( methodReferencesAvailable, methodReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTEnumerationReference )
+		{
+			returnReference( enumerationReferencesAvailable, enumerationReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTEnumeratorReference )
+		{
+			returnReference( enumeratorReferencesAvailable, enumeratorReferences, reference );
+			return;
+		}			
+		if( reference instanceof IASTNamespaceReference )
+		{
+			returnReference( namespaceReferencesAvailable, namespaceReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTTypedefReference )
+		{
+			returnReference( typedefReferencesAvailable, typedefReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTParameterReference )
+		{
+			returnReference( parameterReferencesAvailable, parameterReferences, reference );
+			return;
+		}
+		if( reference instanceof IASTTemplateParameterReference)
+		{
+			returnReference( templateParameterReferencesAvailable, templateParameterReferences, reference );
+		}
 	}
 
 	/**
@@ -235,8 +397,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getTypedefReference(int offset,
-			IASTTypedefDeclaration declaration) {
+			IASTTypedefDeclaration referencedElement) {
-		return new ASTTypedefReference(offset, declaration);
+		for (int i = 0; i < typedefReferencesAvailable.length; ++i) {
+			if (typedefReferencesAvailable[i]) {
+				typedefReferencesAvailable[i] = false;
+				typedefReferences[i].initialize(offset, referencedElement);
+				return typedefReferences[i];
+			}
+		}
+		int currentSize = typedefReferences.length;
+		GrowResult g = growArrays( typedefReferences, typedefReferencesAvailable, TYPEDEFREF_FACTORY);
+		typedefReferencesAvailable = g.getAvailables();
+		typedefReferences = g.getReferences();
+		typedefReferencesAvailable[currentSize] = false;
+		typedefReferences[currentSize].initialize(offset, referencedElement);
+		return typedefReferences[currentSize];
 	}
 
 	/**
@@ -259,7 +434,6 @@ public class ReferenceCache implements IReferenceManager {
 		variableReferencesAvailable[currentSize] = false;
 		variableReferences[currentSize].initialize(offset, referencedElement);
 		return variableReferences[currentSize];
-
 	}
 
 	/**
@@ -268,8 +442,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getParameterReference(int offset,
-			IASTParameterDeclaration declaration) {
+			IASTParameterDeclaration referencedElement) {
-		return new ASTParameterReference(offset, declaration);
+		for (int i = 0; i < parameterReferencesAvailable.length; ++i) {
+			if (parameterReferencesAvailable[i]) {
+				parameterReferencesAvailable[i] = false;
+				parameterReferences[i].initialize(offset, referencedElement);
+				return parameterReferences[i];
+			}
+		}
+		int currentSize = parameterReferences.length;
+		GrowResult g = growArrays( parameterReferences, parameterReferencesAvailable, PARMREF_FACTORY);
+		parameterReferencesAvailable = g.getAvailables();
+		parameterReferences = g.getReferences();
+		parameterReferencesAvailable[currentSize] = false;
+		parameterReferences[currentSize].initialize(offset, referencedElement);
+		return parameterReferences[currentSize];
 	}
 
 	/**
@@ -278,8 +465,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getTemplateParameterReference(int offset,
-			IASTTemplateParameter parameter) {
+			IASTTemplateParameter referencedElement) {
-		return new ASTTemplateParameterReference(offset, parameter);
+		for (int i = 0; i < templateParameterReferencesAvailable.length; ++i) {
+			if (templateParameterReferencesAvailable[i]) {
+				templateParameterReferencesAvailable[i] = false;
+				templateParameterReferences[i].initialize(offset, referencedElement);
+				return templateParameterReferences[i];
+			}
+		}
+		int currentSize = templateParameterReferences.length;
+		GrowResult g = growArrays( templateParameterReferences, templateParameterReferencesAvailable, TEMPPARMREF_FACTORY);
+		templateParameterReferencesAvailable = g.getAvailables();
+		templateParameterReferences = g.getReferences();
+		templateParameterReferencesAvailable[currentSize] = false;
+		templateParameterReferences[currentSize].initialize(offset, referencedElement);
+		return templateParameterReferences[currentSize];
 	}
 
 	/**
@@ -288,8 +488,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getNamespaceReference(int offset,
-			IASTNamespaceDefinition definition) {
+			IASTNamespaceDefinition referencedElement) {
-		return new ASTNamespaceReference(offset, definition);
+		for (int i = 0; i < namespaceReferencesAvailable.length; ++i) {
+			if (namespaceReferencesAvailable[i]) {
+				namespaceReferencesAvailable[i] = false;
+				namespaceReferences[i].initialize(offset, referencedElement);
+				return namespaceReferences[i];
+			}
+		}
+		int currentSize = namespaceReferences.length;
+		GrowResult g = growArrays( namespaceReferences, namespaceReferencesAvailable, NAMESPACEREF_FACTORY);
+		namespaceReferencesAvailable = g.getAvailables();
+		namespaceReferences = g.getReferences();
+		namespaceReferencesAvailable[currentSize] = false;
+		namespaceReferences[currentSize].initialize(offset, referencedElement);
+		return namespaceReferences[currentSize];
 	}
 
 	/**
@@ -298,8 +511,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getEnumerationReference(int offset,
-			IASTEnumerationSpecifier specifier) {
+			IASTEnumerationSpecifier referencedElement) {
-		return new ASTEnumerationReference(offset, specifier);
+		for (int i = 0; i < enumerationReferencesAvailable.length; ++i) {
+			if (enumerationReferencesAvailable[i]) {
+				enumerationReferencesAvailable[i] = false;
+				enumerationReferences[i].initialize(offset, referencedElement);
+				return enumerationReferences[i];
+			}
+		}
+		int currentSize = enumerationReferences.length;
+		GrowResult g = growArrays( enumerationReferences, enumerationReferencesAvailable, ENUMSPECREF_FACTORY );
+		enumerationReferencesAvailable = g.getAvailables();
+		enumerationReferences = g.getReferences();
+		enumerationReferencesAvailable[currentSize] = false;
+		enumerationReferences[currentSize].initialize(offset, referencedElement);
+		return enumerationReferences[currentSize];
 	}
 
 	/**
@@ -308,8 +534,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	private IASTReference getEnumeratorReference(int offset,
-			IASTEnumerator enumerator) {
+			IASTEnumerator referencedElement ) {
-		return new ASTEnumeratorReference(offset, enumerator);
+		for (int i = 0; i < enumeratorReferencesAvailable.length; ++i) {
+			if (enumeratorReferencesAvailable[i]) {
+				enumeratorReferencesAvailable[i] = false;
+				enumeratorReferences[i].initialize(offset, referencedElement);
+				return enumeratorReferences[i];
+			}
+		}
+		int currentSize = enumeratorReferences.length;
+		GrowResult g = growArrays( enumeratorReferences, enumeratorReferencesAvailable, ENUMERATORREF_FACTORY );
+		enumeratorReferencesAvailable = g.getAvailables();
+		enumeratorReferences = g.getReferences();
+		enumeratorReferencesAvailable[currentSize] = false;
+		enumeratorReferences[currentSize].initialize(offset, referencedElement);
+		return enumeratorReferences[currentSize];
 	}
 
 	/**
@@ -317,8 +556,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @param method
 	 * @return
 	 */
-	private IASTReference getMethodReference(int offset, IASTMethod method) {
+	private IASTReference getMethodReference(int offset, IASTMethod referencedElement ) {
-		return new ASTMethodReference(offset, method);
+		for (int i = 0; i < methodReferencesAvailable.length; ++i) {
+			if (methodReferencesAvailable[i]) {
+				methodReferencesAvailable[i] = false;
+				methodReferences[i].initialize(offset, referencedElement);
+				return methodReferences[i];
+			}
+		}
+		int currentSize = methodReferences.length;
+		GrowResult g = growArrays( methodReferences, methodReferencesAvailable, METHODREF_FACTORY );
+		methodReferencesAvailable = g.getAvailables();
+		methodReferences = g.getReferences();
+		methodReferencesAvailable[currentSize] = false;
+		methodReferences[currentSize].initialize(offset, referencedElement);
+		return methodReferences[currentSize];
 	}
 
 	/**
@@ -326,8 +578,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @param function
 	 * @return
 	 */
-	private IASTReference getFunctionReference(int offset, IASTFunction function) {
+	private IASTReference getFunctionReference(int offset, IASTFunction referencedElement ) {
-		return new ASTFunctionReference(offset, function);
+		for (int i = 0; i < functionReferencesAvailable.length; ++i) {
+			if (functionReferencesAvailable[i]) {
+				functionReferencesAvailable[i] = false;
+				functionReferences[i].initialize(offset, referencedElement);
+				return functionReferences[i];
+			}
+		}
+		int currentSize = functionReferences.length;
+		GrowResult g = growArrays( functionReferences, functionReferencesAvailable, FUNCTIONREF_FACTORY );
+		functionReferencesAvailable = g.getAvailables();
+		functionReferences = g.getReferences();
+		functionReferencesAvailable[currentSize] = false;
+		functionReferences[currentSize].initialize(offset, referencedElement);
+		return functionReferences[currentSize];
 	}
 
 	/**
@@ -335,8 +600,21 @@ public class ReferenceCache implements IReferenceManager {
 	 * @param field
 	 * @return
 	 */
-	private IASTReference getFieldReference(int offset, IASTField field) {
+	private IASTReference getFieldReference(int offset, IASTField referencedElement) {
-		return new ASTFieldReference(offset, field);
+		for (int i = 0; i < fieldReferencesAvailable.length; ++i) {
+			if (fieldReferencesAvailable[i]) {
+				fieldReferencesAvailable[i] = false;
+				fieldReferences[i].initialize(offset, referencedElement);
+				return fieldReferences[i];
+			}
+		}
+		int currentSize = fieldReferences.length;
+		GrowResult g = growArrays( fieldReferences, fieldReferencesAvailable, FIELDREF_FACTORY );
+		fieldReferencesAvailable = g.getAvailables();
+		fieldReferences = g.getReferences();
+		fieldReferencesAvailable[currentSize] = false;
+		fieldReferences[currentSize].initialize(offset, referencedElement);
+		return fieldReferences[currentSize];
 	}
 
 	/* (non-Javadoc)
@@ -344,7 +622,7 @@ public class ReferenceCache implements IReferenceManager {
 	 */
 	public void processReferences(List references, ISourceElementRequestor requestor)
 	{
-		if( references == null || references == Collections.EMPTY_LIST || references.isEmpty() )
+		if( references == null || references.isEmpty() )
 			return;
 	    
 	    for( int i = 0; i < references.size(); ++i )
@@ -361,18 +639,20 @@ public class ReferenceCache implements IReferenceManager {
 		protected int offset;
 		private static final String EMPTY_STRING = ""; //$NON-NLS-1$
 
-		public void reset() {
+		public abstract void reset();
+		
+		protected void resetOffset() {
 			offset = 0;
 		}
 
 		/**
 		 * @param offset2
-		 * @param referencedElement
+		 * @param re 
 		 */
-		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+		public abstract void initialize(int o, ISourceElementCallbackDelegate re );
-		}
 
-		public void initialize(int o) {
+
+		protected void initialize(int o) {
 			this.offset = o;
 		}
 
@@ -448,7 +728,7 @@ public class ReferenceCache implements IReferenceManager {
 		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ASTReference#reset()
 		 */
 		public void reset() {
-			super.reset();
+			super.resetOffset();
 			reference = null;
 		}
 		/**
@@ -491,7 +771,7 @@ public class ReferenceCache implements IReferenceManager {
 	public static class ASTEnumerationReference extends ASTReference
 			implements
 				IASTEnumerationReference {
-		private final IASTEnumerationSpecifier referencedElement;
+		private IASTEnumerationSpecifier referencedElement;
 		/**
 		 * @param offset
 		 * @param specifier
@@ -502,6 +782,14 @@ public class ReferenceCache implements IReferenceManager {
 			referencedElement = specifier;
 		}
 
+		/**
+		 * 
+		 */
+		public ASTEnumerationReference() {
+			super( 0 );
+			referencedElement = null;
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -522,13 +810,29 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate re) {
+			initialize(o);
+			this.referencedElement = (IASTEnumerationSpecifier) re; 
+		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			super.resetOffset();
+			this.referencedElement = null;
+		}
 	}
 
 	public static class ASTEnumeratorReference extends ASTReference
 			implements
 				IASTEnumeratorReference {
 
-		private final IASTEnumerator enumerator;
+		private IASTEnumerator enumerator;
 		/**
 		 * @param offset
 		 * @param enumerator
@@ -538,6 +842,14 @@ public class ReferenceCache implements IReferenceManager {
 			this.enumerator = enumerator;
 		}
 
+		/**
+		 * 
+		 */
+		public ASTEnumeratorReference() {
+			super( 0 );
+			enumerator = null;
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -558,12 +870,28 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			this.enumerator = (IASTEnumerator) referencedElement;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			super.resetOffset();
+			this.enumerator = null;
+		}
 	}
 	public static class ASTFieldReference extends ASTReference
 			implements
 				IASTReference,
 				IASTFieldReference {
-		private final IASTField referencedElement;
+		private IASTField referencedElement;
 		/**
 		 * @param offset
 		 * @param field
@@ -572,6 +900,13 @@ public class ReferenceCache implements IReferenceManager {
 			super(offset);
 			referencedElement = field;
 		}
+		/**
+		 * 
+		 */
+		public ASTFieldReference() {
+			super(0);
+			referencedElement = null;
+		}
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -592,13 +927,27 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate re) {
+			initialize(o);
+			this.referencedElement = (IASTField) re;
+		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.referencedElement = null;
+		}
 	}
 	
 	public static class ASTFunctionReference extends ASTReference
 			implements
 				IASTReference,
 				IASTFunctionReference {
-		private final IASTFunction declaration;
+		private IASTFunction declaration;
 		/**
 		 * @param offset
 		 */
@@ -607,6 +956,13 @@ public class ReferenceCache implements IReferenceManager {
 			super(offset);
 			this.declaration = referencedDeclaration;
 		}
+		/**
+		 * 
+		 */
+		public ASTFunctionReference() {
+			super(0);
+			declaration = null;
+		}
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -627,11 +983,25 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			this.declaration = (IASTFunction) referencedElement;
+		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.declaration = null;			
+		}
 	}
 	public static class ASTMethodReference extends ASTReference
 			implements
 				IASTMethodReference {
-		private final IASTMethod method;
+		private IASTMethod method;
 		/**
 		 * @param offset
 		 */
@@ -639,6 +1009,13 @@ public class ReferenceCache implements IReferenceManager {
 			super(offset);
 			this.method = method;
 		}
+		/**
+		 * 
+		 */
+		public ASTMethodReference() {
+			super(0);
+			this.method = null;
+		}
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -659,11 +1036,25 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			this.method = (IASTMethod) referencedElement;
+		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.method= null;
+		}
 	}
 	public static class ASTNamespaceReference extends ASTReference
 			implements
 				IASTNamespaceReference {
-		private final IASTNamespaceDefinition reference;
+		private IASTNamespaceDefinition reference;
 
 		/**
 		 * @param offset
@@ -675,6 +1066,14 @@ public class ReferenceCache implements IReferenceManager {
 			reference = definition;
 		}
 
+		/**
+		 * 
+		 */
+		public ASTNamespaceReference() {
+			super(0);
+			reference = null;
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -695,12 +1094,28 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			this.reference = (IASTNamespaceDefinition) referencedElement;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.reference = null;
+		}
 	}
 
 	public static class ASTParameterReference extends ASTReference
 			implements
 				IASTParameterReference {
-		private final IASTParameterDeclaration parm;
+		private IASTParameterDeclaration parm;
 
 		/**
 		 * @param offset
@@ -712,6 +1127,14 @@ public class ReferenceCache implements IReferenceManager {
 			parm = declaration;
 		}
 
+		/**
+		 * 
+		 */
+		public ASTParameterReference() {
+			super(0);
+			parm = null;
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -732,11 +1155,27 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			initialize(o);
+			this.parm = (IASTParameterDeclaration) referencedElement; 
+		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.parm = null;
+		}
 	}
 	public static class ASTTemplateParameterReference extends ASTReference
 			implements
 				IASTTemplateParameterReference {
-		private final IASTTemplateParameter parameter;
+		private IASTTemplateParameter parameter;
 		/**
 		 * @param offset
 		 */
@@ -746,6 +1185,14 @@ public class ReferenceCache implements IReferenceManager {
 			parameter = param;
 		}
 
+		/**
+		 * 
+		 */
+		public ASTTemplateParameterReference() {
+			super(0);
+			parameter = null;
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -766,11 +1213,27 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			parameter = (IASTTemplateParameter) referencedElement;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			resetOffset();
+			this.parameter = null;
+		}
 	}
 	public static class ASTTypedefReference extends ASTReference
 			implements
 				IASTTypedefReference {
-		private final IASTTypedefDeclaration referencedItem;
+		private IASTTypedefDeclaration referencedItem;
 		/**
 		 * @param offset
 		 */
@@ -779,6 +1242,13 @@ public class ReferenceCache implements IReferenceManager {
 			super(offset);
 			this.referencedItem = referencedItem;
 		}
+		/**
+		 * 
+		 */
+		public ASTTypedefReference() {
+			super( 0 );
+			this.referencedItem = null;
+		}
 		/*
 		 * (non-Javadoc)
 		 * 
@@ -799,6 +1269,20 @@ public class ReferenceCache implements IReferenceManager {
 				/* do nothing */
 			}
 		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#initialize(int, org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate)
+		 */
+		public void initialize(int o, ISourceElementCallbackDelegate referencedElement) {
+			super.initialize(o);
+			referencedItem = (IASTTypedefDeclaration) referencedElement;
+		}
+		/* (non-Javadoc)
+		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
+		 */
+		public void reset() {
+			super.resetOffset();
+			referencedItem = null;
+		}
 	}
 	public static class ASTVariableReference extends ASTReference
 			implements
@@ -825,7 +1309,7 @@ public class ReferenceCache implements IReferenceManager {
 		 * @see org.eclipse.cdt.internal.core.parser.ast.complete.ReferenceCache.ASTReference#reset()
 		 */
 		public void reset() {
-			super.reset();
+			super.resetOffset();
 			referencedElement = null;
 		}
 		/**
@@ -860,7 +1344,16 @@ public class ReferenceCache implements IReferenceManager {
 	 * @return
 	 */
 	public boolean isBalanced() {
-		return isBalanced( classReferencesAvailable ) && isBalanced( variableReferencesAvailable );
+		return isBalanced( classReferencesAvailable ) && 
+			isBalanced( variableReferencesAvailable ) && 
+			isBalanced( fieldReferencesAvailable ) &&
+			isBalanced( functionReferencesAvailable ) &&
+			isBalanced( methodReferencesAvailable ) &&
+			isBalanced( enumerationReferencesAvailable ) && 
+			isBalanced( enumeratorReferencesAvailable ) &&
+			isBalanced( parameterReferencesAvailable ) &&
+			isBalanced( templateParameterReferencesAvailable ) &&
+			isBalanced( typedefReferencesAvailable);
 	}
 
 	/**

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ast/expression/ASTExpression.java

@@ -197,7 +197,7 @@ public class ASTExpression implements IASTExpression {
     /* (non-Javadoc)
      * @see org.eclipse.cdt.core.parser.ast.IASTExpression#reconcileReferences()
      */
-    public void reconcileReferences() throws ASTNotImplementedException
+    public void reconcileReferences(IReferenceManager manager) throws ASTNotImplementedException
     {
     	throw new ASTNotImplementedException();
     }