Attachment #62811 for bug #167098

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java (-2 / +5 lines)
8	* Contributors:	8	* Contributors:
9	* IBM - Initial API and implementation	9	* IBM - Initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
		11	* Bryan Wilkinson (QNX)
11	*******************************************************************************/	12	*******************************************************************************/
12	/*	13	/*
13	* Created on Mar 11, 2005	14	* Created on Mar 11, 2005
Lines 1107-1116 Link Here
1107	assertTrue( B2 instanceof ICPPSpecialization );	1108	assertTrue( B2 instanceof ICPPSpecialization );
1108	assertSame( ((ICPPSpecialization)B2).getSpecializedBinding(), B );	1109	assertSame( ((ICPPSpecialization)B2).getSpecializedBinding(), B );
1109		1110
1110	//we might want this to be a specialization of a specialization, but for now, this is easier
1111	ICPPMethod f1 = (ICPPMethod) col.getName(20).resolveBinding();	1111	ICPPMethod f1 = (ICPPMethod) col.getName(20).resolveBinding();
1112	assertTrue( f1 instanceof ICPPSpecialization );	1112	assertTrue( f1 instanceof ICPPSpecialization );
1113	assertSame( ((ICPPSpecialization)f1).getSpecializedBinding(), f );	1113	assertTrue( ((ICPPSpecialization)f1).getSpecializedBinding() instanceof ICPPMethod );
		1114	ICPPMethod f2 = (ICPPMethod) ((ICPPSpecialization)f1).getSpecializedBinding();
		1115	assertTrue( f2 instanceof ICPPSpecialization );
		1116	assertSame( ((ICPPSpecialization)f2).getSpecializedBinding(), f );
1114		1117
1115	IFunctionType ft = f1.getType();	1118	IFunctionType ft = f1.getType();
1116	assertTrue( ft.getReturnType() instanceof IBasicType );	1119	assertTrue( ft.getReturnType() instanceof IBasicType );

Lines 72-78 Link Here

(-)parser/org/eclipse/cdt/internal/index/tests/IndexCPPBindingResolutionTest.java (-1 / +1 lines)
72	// class Int {};	72	// class Int {};
73	// Int a,b;	73	// Int a,b;
74	// Int c= left(a,b);	74	// Int c= left(a,b);
75	public void _testSimpleFunctionTemplate() {	75	public void testSimpleFunctionTemplate() {
76	IBinding b0 = getBindingFromASTName("sanity();", 6);	76	IBinding b0 = getBindingFromASTName("sanity();", 6);
77	IBinding b1 = getBindingFromASTName("left(a,b)", 4);	77	IBinding b1 = getBindingFromASTName("left(a,b)", 4);
78	}	78	}




	}

	public Object clone() {
		return new PDOMQualifierTypeClone(this);
	}
	
	private static class PDOMQualifierTypeClone implements IQualifierType, ITypeContainer, IIndexType {
		private final IQualifierType delegate;
		private IType type = null;
		
		public PDOMQualifierTypeClone(IQualifierType qualifier) {
			this.delegate = qualifier;
		}
		public IType getType() throws DOMException {
			if (type == null) {
				return delegate.getType();
			}
			return type;
		}
		public boolean isConst() throws DOMException {
			return delegate.isConst();
		}
		public boolean isVolatile() throws DOMException {
			return delegate.isVolatile();
		}
		public boolean isSameType(IType type) {
		    if( type instanceof ITypedef )
		        return type.isSameType( this );
		    if( !( type instanceof IQualifierType ) ) 
		        return false;
		    
		    IQualifierType pt = (IQualifierType) type;
		    try {
				if( isConst() == pt.isConst() && isVolatile() == pt.isVolatile() ) {
					IType myType= getType();
				    return myType != null && myType.isSameType( pt.getType() );
				}
			} catch (DOMException e) {
			}
		    return false;
		}
		public void setType(IType type) {
			this.type = type;
		}
		public Object clone() {
			return new PDOMQualifierTypeClone(this);
		}
	}
}




import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.internal.core.index.IIndexFragment;
import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;

		return null;
	}
	
	public final IScope getScope() {
		try {
			IBinding parent = getParentBinding(); 
			if(parent instanceof IScope) {

		try {
			PDOMNode node = this;
			while (node != null) {
				if (node instanceof PDOMBinding && !(node instanceof ICPPTemplateInstance)) {							
					result.add(0, ((PDOMBinding)node).getName());
				}
				node = node.getParentNode();




/*******************************************************************************
 * Copyright (c) 2006, 2007 QNX Software Systems and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	}

	public Object clone() {
		return new PDOMPointerTypeClone(this);
	}
	
	protected static class PDOMPointerTypeClone implements IPointerType, ITypeContainer, IIndexType {
		protected final IPointerType delegate;
		private IType type = null;
		
		public PDOMPointerTypeClone(IPointerType pointer) {
			this.delegate = pointer;
		}
		public IType getType() throws DOMException {
			if (type == null) {
				return delegate.getType();
			}
			return type;
		}
		public boolean isConst() throws DOMException {
			return delegate.isConst();
		}
		public boolean isVolatile() throws DOMException {
			return delegate.isVolatile();
		}
		public boolean isSameType(IType type) {
			if( type instanceof ITypedef )
			    return ((ITypedef)type).isSameType( this );
			
			if( !( type instanceof IPointerType )) 
			    return false;
			
			IPointerType rhs = (IPointerType) type;
			try {
				if (isConst() == rhs.isConst() && isVolatile() == rhs.isVolatile()) {
					IType type1= getType();
					if (type1 != null) {
						return type1.isSameType(rhs.getType());
					}
				}
			} catch (DOMException e) {
			}
			return false;
		}
		public void setType(IType type) {
			this.type = type;
		}
		public Object clone() {
			return new PDOMPointerTypeClone(this);
		}
	}
}




		}
	}

	public String toString() {
		try {
			Database db = pdom.getDB();
			int bindingRec = db.getInt(record + BINDING_REC_OFFSET);
			PDOMBinding binding = pdom.getBinding(bindingRec);
			return binding != null ? binding.getName() : null;
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return null;
		}
	}
	
	private byte getFlags(int mask) throws CoreException {
		return (byte) (pdom.getDB().getByte(record + FLAGS) & mask);
	}




/*******************************************************************************
 * Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	}
	
	public Object clone() {
		return new PDOMArrayTypeClone(this);
	}
	
	private static class PDOMArrayTypeClone implements IIndexType, IArrayType, ITypeContainer {
		private final IArrayType delegate;
		private IType type = null;
		
		public PDOMArrayTypeClone(IArrayType array) {
			this.delegate = array;
		}
		public boolean isSameType(IType type) {
			if( type instanceof ITypedef )
			    return ((ITypedef)type).isSameType( this );
			
			if( !( type instanceof IArrayType )) 
			    return false;
			
			try {
				IType type1= this.getType();
				if( type1 == null )
				    return false;
				
				IArrayType rhs = (IArrayType) type;
				return type1.isSameType( rhs.getType() );
			} catch (DOMException e) {
			}
			return false;
		}
		public IASTExpression getArraySizeExpression() throws DOMException {
			return delegate.getArraySizeExpression();
		}
		public IType getType() throws DOMException {
			if (type == null) {
				return delegate.getType();
			}
			return type;
		}
		public void setType(IType type) {
			this.type = type;
		}
		public Object clone() {
			return new PDOMArrayTypeClone(this);
		}
	}
}

Lines 31-36 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMLinkage.java (-20 / +35 lines)
31	import org.eclipse.cdt.core.dom.ast.IType;	31	import org.eclipse.cdt.core.dom.ast.IType;
32	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;	32	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;
33	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceScope;	33	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceScope;
		34	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
34	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;	35	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
35	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;	36	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
36	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;	37	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
Lines 191-201 Link Here
191	* @throws CoreException	192	* @throws CoreException
192	*/	193	*/
193	protected PDOMNode getAdaptedParent(IBinding binding, boolean createFileLocalScope, boolean addParent) throws CoreException {	194	protected PDOMNode getAdaptedParent(IBinding binding, boolean createFileLocalScope, boolean addParent) throws CoreException {
		195	IBinding scopeBinding = null;
		196
		197	if (binding instanceof ICPPTemplateInstance) {
		198	scopeBinding = ((ICPPTemplateInstance)binding).getTemplateDefinition();
		199	} else {
194	try {	200	try {
195	IScope scope = binding.getScope();	201	IScope scope = binding.getScope();
196	if (scope == null) {	202	if (scope == null) {
197	if (binding instanceof IIndexBinding) {	203	if (binding instanceof ICPPDeferredTemplateInstance) {
198	IIndexBinding ib= (IIndexBinding) binding;	204	ICPPDeferredTemplateInstance deferred = (ICPPDeferredTemplateInstance) binding;
		205	ICPPTemplateDefinition template = deferred.getTemplateDefinition();
		206	scope = template.getScope();
		207	}
		208
		209	IIndexBinding ib = (binding instanceof IIndexBinding) ? (IIndexBinding) binding : null;
		210
		211	if (ib == null && binding instanceof ICPPSpecialization) {
		212	IBinding spec = ((ICPPSpecialization)binding).getSpecializedBinding();
		213	if (spec instanceof IIndexBinding) {
		214	ib = (IIndexBinding) spec;
		215	}
		216	}
		217
		218	if (ib != null) {
199	// don't adapt file local bindings from other fragments to this one.	219	// don't adapt file local bindings from other fragments to this one.
200	if (ib.isFileLocal()) {	220	if (ib.isFileLocal()) {
201	return null;	221	return null;
Lines 204-216 Link Here
204	return this;	224	return this;
205	}	225	}
206		226
207	if (binding instanceof ICPPDeferredTemplateInstance) {	227	return null;
208	ICPPDeferredTemplateInstance deferred = (ICPPDeferredTemplateInstance) binding;
209	ICPPTemplateDefinition template = deferred.getTemplateDefinition();
210	scope = template.getScope();
211	} else {
212	return null;
213	}
214	}	228	}
215		229
216	if(scope instanceof IIndexScope) {	230	if(scope instanceof IIndexScope) {
Lines 245-251 Link Here
245	return this;	259	return this;
246	}	260	}
247	else {	261	else {
248	IBinding scopeBinding = null;
249	if (scope instanceof CPPClassSpecializationScope) {	262	if (scope instanceof CPPClassSpecializationScope) {
250	scopeBinding = ((CPPClassSpecializationScope)scope).getClassType();	263	scopeBinding = ((CPPClassSpecializationScope)scope).getClassType();
251	} else {	264	} else {
Lines 254-273 Link Here
254	scopeBinding = ((IASTName) scopeName).resolveBinding();	267	scopeBinding = ((IASTName) scopeName).resolveBinding();
255	}	268	}
256	}	269	}
257	if (scopeBinding != null) {
258	PDOMBinding scopePDOMBinding = null;
259	if (addParent) {
260	scopePDOMBinding = addBinding(scopeBinding);
261	} else {
262	scopePDOMBinding = adaptBinding(scopeBinding);
263	}
264	if (scopePDOMBinding != null)
265	return scopePDOMBinding;
266	}
267	}	270	}
268	} catch (DOMException e) {	271	} catch (DOMException e) {
269	throw new CoreException(Util.createStatus(e));	272	throw new CoreException(Util.createStatus(e));
270	}	273	}
		274	}
		275
		276	if (scopeBinding != null) {
		277	PDOMBinding scopePDOMBinding = null;
		278	if (addParent) {
		279	scopePDOMBinding = addBinding(scopeBinding);
		280	} else {
		281	scopePDOMBinding = adaptBinding(scopeBinding);
		282	}
		283	if (scopePDOMBinding != null)
		284	return scopePDOMBinding;
		285	}
271	return null;	286	return null;
272	}	287	}
273		288





import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTConversionName;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPConstructor;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.parser.util.ArrayUtil;
import org.eclipse.cdt.core.parser.util.CharArrayObjectMap;
import org.eclipse.cdt.core.parser.util.CharArrayUtils;
import org.eclipse.cdt.core.parser.util.ObjectMap;
import org.eclipse.cdt.core.parser.util.ObjectSet;
import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
import org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope;


 * @author aniefer
 */
public class CPPClassSpecializationScope implements ICPPClassScope, IASTInternalScope {
	private static final char[] CONSTRUCTOR_KEY = "!!!CTOR!!!".toCharArray();  //$NON-NLS-1$

	private CharArrayObjectMap bindings;
	private ObjectMap instanceMap = ObjectMap.EMPTY_MAP;
	final private ICPPSpecialization specialization;
	private ICPPSpecialization specialization;
	private boolean isFullyCached = false;
	private boolean doneConstructors = false;
	
	/**
	 * @param instance
	 */
	public CPPClassSpecializationScope( ICPPSpecialization specialization ) {
		this.specialization = specialization;
	}
	
	/**
	 * @param instance
	 */
	public CPPClassSpecializationScope(CPPClassInstance instance ) {
		this.specialization = instance;
	}

	private ICPPClassType getOriginalClass(){
		return (ICPPClassType) specialization.getSpecializedBinding();
	}
	
	private IBinding getInstance(IBinding binding) {
		if( instanceMap.containsKey( binding ) ) {
			return (IBinding) instanceMap.get( binding );
		} else if (!(binding instanceof ICPPClassTemplatePartialSpecialization)) {
			IBinding spec = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
			if( instanceMap == ObjectMap.EMPTY_MAP )
				instanceMap = new ObjectMap(2);
			instanceMap.put( binding, spec );
			return spec;
		}
		return null;
	}
	
	public IBinding getBinding( IASTName name, boolean forceResolve ) throws DOMException {
		char [] c = name.toCharArray();
		
	    if( CharArrayUtils.equals( c, specialization.getNameCharArray() ) )
	    	if (!CPPClassScope.isConstructorReference( name ))
	    		return specialization;

		ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
		IScope classScope = specialized.getCompositeScope();
		IBinding[] bindings = classScope != null ? classScope.find(name.toString()) : null;
		
		if (bindings == null) return null;
    	
		IBinding[] specs = new IBinding[0];
		for (int i = 0; i < bindings.length; i++) {
			specs = (IBinding[]) ArrayUtil.append(IBinding.class, specs, getInstance(bindings[i]));
		}
		specs = (IBinding[]) ArrayUtil.trim(IBinding.class, specs);
    	return CPPSemantics.resolveAmbiguities( name, specs );
	    	while( obj != null ){
	    		if( obj instanceof IASTName ){
	    			IASTName n = (IASTName) obj;
	    			if( n instanceof ICPPASTQualifiedName ){
    					IASTName [] ns = ((ICPPASTQualifiedName)n).getNames();
    					n = ns[ ns.length - 1 ];
    				}
	    			if( instanceMap.containsKey( n ) ){
	    				binding = (IBinding) instanceMap.get( n );
	    			} else {
		    			binding = CPPClassScope.shouldResolve(forceResolve, n, name) ? n.resolveBinding() : n.getBinding();
		    			if (binding instanceof ICPPClassTemplatePartialSpecialization ){
		    			    binding = null;
		    			}
		    			if( binding != null ){
		    				binding = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
		    				if( instanceMap == ObjectMap.EMPTY_MAP )
		    					instanceMap = new ObjectMap(2);
			        		instanceMap.put( n, binding );
		    			}
	    			}
	    		} else if( obj instanceof IBinding ){
	    			if( instanceMap.containsKey( obj ) ){
	    				binding = (IBinding) instanceMap.get( obj );
	    			} else {
	    				binding = CPPTemplates.createSpecialization( this, (IBinding) obj, specialization.getArgumentMap()  );
	    				if( instanceMap == ObjectMap.EMPTY_MAP )
	    					instanceMap = new ObjectMap(2);
		        		instanceMap.put( obj, binding );
	    			}
	    		}
	    		if( binding != null ){
	    			if( i == -1 )
	    				return binding;
    				bs = (IBinding[]) ArrayUtil.append( IBinding.class, bs, binding );
    				binding = null;
	    		}
	    		if( i != -1 && ++i < set.size() ){
	    			obj = set.keyAt( i );
	    		} else {
	    			obj = null;
	    		}
	    	}
	    	bs = (IBinding[]) ArrayUtil.trim( IBinding.class, bs );
	    	if( bs.length  == 1 )
	    		return bs[0];
	    	return CPPSemantics.resolveAmbiguities( name, bs );
	    }
		return null;
	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope#getImplicitMethods()
	 */
	public ICPPMethod[] getImplicitMethods() {
		//implicit methods shouldn't have implicit specializations
		return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#getScopeName()
	 */
	public IName getScopeName() {
		if (specialization instanceof ICPPInternalBinding)
			return (IASTName) ((ICPPInternalBinding)specialization).getDefinition();
		//TODO: get the scope name for non-internal bindings
		return null;
	}

	protected ICPPConstructor [] getConstructors() throws DOMException {
		ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
		ICPPConstructor[] bindings = specialized.getConstructors();
		
		if (bindings == null) return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
			bindings = new CharArrayObjectMap(1);		
		char [] c = name.toCharArray();
		
		IASTNode parent = name.getParent();
		if( parent instanceof IASTDeclarator && CPPVisitor.isConstructor( this, (IASTDeclarator) parent ) ){
			c = CONSTRUCTOR_KEY;
		}
		Object o = bindings.get( c );
		if( o != null ){
		    if( o instanceof ObjectSet ){
		    	((ObjectSet)o).put( name );
		    } else {
		    	ObjectSet temp = new ObjectSet( 2 );
		    	temp.put( o );
		    	temp.put( name );
		        bindings.put( c, temp );
		    }
		} else {
		    bindings.put( c, name );
		}
	}

	protected ICPPConstructor [] getConstructors( ){
		if( bindings == null ) 
			return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
		
    	ICPPConstructor[] specs = new ICPPConstructor[0];
		for (int i = 0; i < bindings.length; i++) {
			specs = (ICPPConstructor[]) ArrayUtil.append(ICPPConstructor.class, specs, getInstance(bindings[i]));
				ctors = ((ICPPClassType)specialization.getSpecializedBinding()).getConstructors();
				for (int i = 0; i < ctors.length; i++) {
					addBinding( ctors[i] );
				}
				doneConstructors = true;
			} catch (DOMException e) {
			}
		}
		ICPPConstructor[] ctors =  CPPClassScope.getConstructors( bindings, true );
		for (int i = 0; i < ctors.length; i++) {
			if( instanceMap.containsKey( ctors[i] ) ){
				ctors[i] = (ICPPConstructor) instanceMap.get( ctors[i] );
			} else {
				IBinding b = CPPTemplates.createSpecialization( this, ctors[i], specialization.getArgumentMap() ); 
				if( instanceMap == ObjectMap.EMPTY_MAP )
					instanceMap = new ObjectMap(2);
        		instanceMap.put( ctors[i], b );
        		ctors[i] = (ICPPConstructor) b;
			}
		}
		return (ICPPConstructor[]) ArrayUtil.trim(ICPPConstructor.class, specs);
	}
	
	protected ICPPMethod[] getConversionOperators() {
		ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
			return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
		
		ICPPMethod [] result = null;
		
		if (!(specialized instanceof ICPPInternalClassType)) {
			return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
	    	int j = ( values[i] instanceof ObjectSet ) ? 0 : -1;
	    	ObjectSet set = ( values[i] instanceof ObjectSet ) ? (ObjectSet) values[i] : null;
	    	Object obj = ( set != null ) ? set.keyAt( j ) : values[i];
	    	IBinding binding = null;
	    	while( obj != null ){
	    		if( obj instanceof IASTName ){
	    			IASTName n = (IASTName) obj;
	    			if( n instanceof ICPPASTQualifiedName ){
    					IASTName [] ns = ((ICPPASTQualifiedName)n).getNames();
    					n = ns[ ns.length - 1 ];
    				}
	    			
	    			if (n instanceof ICPPASTConversionName) {
		    			if( instanceMap.containsKey( n ) ){
		    				binding = (IBinding) instanceMap.get( n );
		    			} else {
			    			binding = n.resolveBinding();
			    			if( binding != null ){
			    				binding = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
			    				if( instanceMap == ObjectMap.EMPTY_MAP )
			    					instanceMap = new ObjectMap(2);
				        		instanceMap.put( n, binding );
			    			}
		    			}
	    			}
	    		} 
	    		if( binding != null ){
    				result = (ICPPMethod[]) ArrayUtil.append( ICPPMethod.class, result, binding );
    				binding = null;
	    		}
	    		if( j != -1 && ++j < set.size() ){
	    			obj = set.keyAt( j );
	    		} else {
	    			obj = null;
	    		}
	    	}
		}
 		
		ICPPMethod[] bindings = ((ICPPInternalClassType)specialized).getConversionOperators();
		
		if (bindings == null) return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
		
    	ICPPMethod[] specs = new ICPPMethod[0];
		for (int i = 0; i < bindings.length; i++) {
			specs = (ICPPMethod[]) ArrayUtil.append(ICPPMethod.class, specs, getInstance(bindings[i]));
		}
		return (ICPPMethod[]) ArrayUtil.trim(ICPPMethod.class, specs);
		isFullyCached = b;
	}

	/* (non-Javadoc)

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)
	 */
	public IBinding[] find(String name) throws DOMException {
		return find(name, false);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)
	 */
	public IBinding[] find(String name, boolean prefixLookup) throws DOMException {		
		ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
		IBinding[] bindings = specialized.getCompositeScope().find(name.toString(), prefixLookup);
		
		if (bindings == null) return null;
		
		IBinding[] specs = new IBinding[0];
		for (int i = 0; i < bindings.length; i++) {
			specs = (IBinding[]) ArrayUtil.append(IBinding.class, specs, getInstance(bindings[i]));
		}
    	return (IBinding[]) ArrayUtil.trim(IBinding.class, specs);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope#isFullyCached()
	 */
	public boolean isFullyCached() throws DOMException {
		ICPPScope origScope = (ICPPScope) getOriginalClass().getCompositeScope();
		if (!ASTInternal.isFullyCached(origScope)) {
			CPPSemantics.LookupData data = new CPPSemantics.LookupData();
			try {
				CPPSemantics.lookupInScope( data, origScope, null );
			} catch (DOMException e) {
			}
		}
		return true;
		IASTNode[] nds= ASTInternal.getDeclarationsOfBinding(cls);

		if( nds != null && nds.length > 0 )
			return nds[0];

		return null;
	}

    /* (non-Javadoc)
     * @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#removeBinding(org.eclipse.cdt.core.dom.ast.IBinding)
     */
	public void removeBinding(IBinding binding) {
	    char [] name = binding.getNameCharArray();
	    if( ! bindings.containsKey( name ) )
	        return;
	    
	    Object obj = bindings.get( name );
	    if( obj instanceof ObjectSet ){
	        ObjectSet set = (ObjectSet) obj;
	        set.remove( binding );
	        if( set.size() == 0 )
	            bindings.remove( name, 0, name.length );
	    } else {
	        bindings.remove( name, 0, name.length );
	    }
	
		if( instanceMap != null && instanceMap.containsKey( binding ) )
			instanceMap.remove( binding );
		isFullyCached = false;
	}

	public void flushCache() {
		if( bindings != null )
			bindings.clear();
		isFullyCached = false;
	}

	public void addBinding(IBinding binding) {
        if( bindings == null )
            bindings = new CharArrayObjectMap(1);
        char [] c = (binding instanceof ICPPConstructor) ? CONSTRUCTOR_KEY : binding.getNameCharArray();
        Object o = bindings.get( c );
        if( o != null ){
            if( o instanceof ObjectSet ){
                ((ObjectSet)o).put( binding );
            } else {
                ObjectSet set = new ObjectSet(2);
                set.put( o );
                set.put( binding );
                bindings.put( c, set );
            }
        } else {
            bindings.put( c, binding );
        }
	}
	
	//this scope does not cache its own names
	public void setFullyCached(boolean b) {}
	public void flushCache() {}
	public void addName(IASTName name) {}
	public IASTNode getPhysicalNode() {return null;}
	public void removeBinding(IBinding binding) {}
	public void addBinding(IBinding binding) {}
}

Lines 690-697 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplates.java (-3 / +3 lines)
690	}	690	}
691	} else if( type instanceof ICPPTemplateParameter && argMap.containsKey( type ) ){	691	} else if( type instanceof ICPPTemplateParameter && argMap.containsKey( type ) ){
692	newType = (IType) argMap.get( type );	692	newType = (IType) argMap.get( type );
693	} else if( type instanceof CPPDeferredClassInstance ){	693	} else if( type instanceof ICPPInternalDeferredClassInstance ){
694	newType = ((CPPDeferredClassInstance)type).instantiate( argMap );	694	newType = ((ICPPInternalDeferredClassInstance)type).instantiate( argMap );
695	} else if( type instanceof ICPPInternalUnknown ){	695	} else if( type instanceof ICPPInternalUnknown ){
696	IBinding binding;	696	IBinding binding;
697	try {	697	try {
Lines 1145-1151 Link Here
1145	}	1145	}
1146	return false;	1146	return false;
1147	}	1147	}
1148	static protected boolean deduceTemplateArgument( ObjectMap map, IType p, IType a ) throws DOMException {	1148	static public boolean deduceTemplateArgument( ObjectMap map, IType p, IType a ) throws DOMException {
1149	boolean pIsAReferenceType = ( p instanceof ICPPReferenceType );	1149	boolean pIsAReferenceType = ( p instanceof ICPPReferenceType );
1150	p = getParameterTypeForDeduction( p );	1150	p = getParameterTypeForDeduction( p );
1151	a = getArgumentTypeForDeduction( a, pIsAReferenceType );	1151	a = getArgumentTypeForDeduction( a, pIsAReferenceType );

Lines 58-64 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassInstance.java (-1 / +4 lines)
58	IBinding base = bindings[i].getBaseClass();	58	IBinding base = bindings[i].getBaseClass();
59	if (bindings[i] instanceof CPPBaseClause && base instanceof IType) {	59	if (bindings[i] instanceof CPPBaseClause && base instanceof IType) {
60	IType specBase = CPPTemplates.instantiateType((IType) base, argumentMap);	60	IType specBase = CPPTemplates.instantiateType((IType) base, argumentMap);
61	((CPPBaseClause)bindings[i]).setBaseClass((ICPPClassType)specBase);	61	specBase = CPPSemantics.getUltimateType(specBase, false);
		62	if (specBase instanceof ICPPClassType) {
		63	((CPPBaseClause)bindings[i]).setBaseClass((ICPPClassType)specBase);
		64	}
62	}	65	}
63	}	66	}
64	return bindings;	67	return bindings;

Lines 1-5 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2006 IBM Corporation and others.	2	* Copyright (c) 2005, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 122-128 Link Here
122	if( template instanceof IProblemBinding )	122	if( template instanceof IProblemBinding )
123	return template;	123	return template;
124	if( template != null && template instanceof ICPPClassTemplatePartialSpecialization ){	124	if( template != null && template instanceof ICPPClassTemplatePartialSpecialization ){
125	return ((CPPTemplateDefinition)template).instantiate( arguments );	125	return ((ICPPInternalTemplateInstantiator)template).instantiate( arguments );
126	}	126	}
127		127
128	return CPPTemplates.instantiateTemplate( this, arguments, null );	128	return CPPTemplates.instantiateTemplate( this, arguments, null );




						IASTNode parent = ASTInternal.getPhysicalNodeOfScope(scope);
						if (parent == null) {
							IBinding[] bindings = scope.find(data.astName.toString(), data.prefixLookup);
							bindings = appendClassType(bindings, scope, data);
							mergeResults(data, bindings, true);
							useASTResults = false;
						} else {

		}
	}

	private static IBinding[] appendClassType(IBinding[] bindings, ICPPScope scope, CPPSemantics.LookupData data) throws DOMException {
		if (scope instanceof ICPPClassScope) {
			IBinding binding = ((ICPPClassScope)scope).getClassType();
			char[] c = binding.getNameCharArray();
			char[] n = data.astName.toCharArray();
			if ((data.prefixLookup && CharArrayUtils.equals(c, 0, n.length, n, true))
					|| (!data.prefixLookup && CharArrayUtils.equals(c, n))) {
				return (IBinding[]) ArrayUtil.append(IBinding.class, bindings, binding);
			}
		}
		return bindings;
	}
	
	private static IScope getParentScope(IScope scope, IASTTranslationUnit unit) throws DOMException {
		IScope parentScope= scope.getParent();
		// the index cannot return the translation unit as parent scope

				//is circular inheritance
				if( ! data.inheritanceChain.containsKey( parent ) ){
					//is this name define in this scope?
					if( ASTInternal.isFullyCached(parent) && data.astName != null && !data.contentAssist )
						inherited = parent.getBinding( data.astName, true );
					else if (ASTInternal.getPhysicalNodeOfScope(parent) == null) {
							&& ASTInternal.getPhysicalNodeOfScope(parent) == null)
						inherited = parent.find(data.astName.toString(), data.prefixLookup);
						inherited = appendClassType((IBinding[]) inherited, parent, data);
					} else
						inherited = lookupInScope( data, parent, null );
					
					if( inherited == null || data.contentAssist ){

					}
				} else if (ASTInternal.getPhysicalNodeOfScope(temp) == null) {
					IBinding[] bindings = temp.find(data.astName.toString(), data.prefixLookup);
					bindings = appendClassType(bindings, temp, data);
					if (bindings != null && bindings.length > 0) {
						mergeResults( data, bindings, true );
						found = true;

Lines 1-5 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPFunction.java (-2 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2006 IBM Corporation and others.	2	* Copyright (c) 2004, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 496-502 Link Here
496	}	496	}
497		497
498	static public boolean hasStorageClass( ICPPInternalFunction function, int storage ){	498	static public boolean hasStorageClass( ICPPInternalFunction function, int storage ){
499	ICPPASTFunctionDeclarator dtor = (ICPPASTFunctionDeclarator) function.getDefinition();	499	IASTNode def = function.getDefinition();
		500	while (def instanceof IASTName) {
		501	def = def.getParent();
		502	}
		503	ICPPASTFunctionDeclarator dtor = (ICPPASTFunctionDeclarator) def;
500	ICPPASTFunctionDeclarator[] ds = (ICPPASTFunctionDeclarator[]) function.getDeclarations();	504	ICPPASTFunctionDeclarator[] ds = (ICPPASTFunctionDeclarator[]) function.getDeclarations();
501	int i = -1;	505	int i = -1;
502	do{	506	do{

Lines 103-109 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassTemplateSpecialization.java (-1 / +1 lines)
103	if( template instanceof IProblemBinding )	103	if( template instanceof IProblemBinding )
104	return template;	104	return template;
105	if( template != null && template instanceof ICPPClassTemplatePartialSpecialization ){	105	if( template != null && template instanceof ICPPClassTemplatePartialSpecialization ){
106	return ((CPPTemplateDefinition)template).instantiate( arguments );	106	return ((ICPPInternalTemplateInstantiator)template).instantiate( arguments );
107	}	107	}
108		108
109	return CPPTemplates.instantiateTemplate( this, arguments, argumentMap );	109	return CPPTemplates.instantiateTemplate( this, arguments, argumentMap );




/*******************************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 * IBM - Initial API and implementation
 * Bryan Wilkinson (QNX)
 *******************************************************************************/
/*
 * Created on Apr 22, 2005

	}
	public boolean isStatic(boolean resolveAll) {
		//TODO resolveAll
		IBinding f = getSpecializedBinding();
		if( f instanceof ICPPInternalFunction)
			return ((ICPPInternalFunction)f).isStatic( resolveAll );
		return CPPFunction.hasStorageClass( this, IASTDeclSpecifier.sc_static );
	}


Lines 80-86 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassSpecialization.java (-2 / +5 lines)
80	IBinding base = bindings[i].getBaseClass();	80	IBinding base = bindings[i].getBaseClass();
81	if (bindings[i] instanceof CPPBaseClause && base instanceof IType) {	81	if (bindings[i] instanceof CPPBaseClause && base instanceof IType) {
82	IType specBase = CPPTemplates.instantiateType((IType) base, argumentMap);	82	IType specBase = CPPTemplates.instantiateType((IType) base, argumentMap);
83	((CPPBaseClause)bindings[i]).setBaseClass((ICPPClassType)specBase);	83	specBase = CPPSemantics.getUltimateType(specBase, false);
		84	if (specBase instanceof ICPPClassType) {
		85	((CPPBaseClause)bindings[i]).setBaseClass((ICPPClassType)specBase);
		86	}
84	}	87	}
85	}	88	}
86	return bindings;	89	return bindings;
Lines 217-223 Link Here
217	if (scope != null && scope.getClassType() == this) {	220	if (scope != null && scope.getClassType() == this) {
218	//explicit specialization: can use composite type specifier scope	221	//explicit specialization: can use composite type specifier scope
219	specScope = scope;	222	specScope = scope;
220	} else if (scope != null) {	223	} else {
221	//implicit specialization: must specialize bindings in scope	224	//implicit specialization: must specialize bindings in scope
222	specScope = new CPPClassSpecializationScope(this);	225	specScope = new CPPClassSpecializationScope(this);
223	}	226	}

Lines 1-5 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPDeferredClassInstance.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.	2	* Copyright (c) 2005, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 34-40 Link Here
34	* @author aniefer	34	* @author aniefer
35	*/	35	*/
36	public class CPPDeferredClassInstance extends CPPInstance implements	36	public class CPPDeferredClassInstance extends CPPInstance implements
37	ICPPClassType, ICPPDeferredTemplateInstance {	37	ICPPClassType, ICPPDeferredTemplateInstance, ICPPInternalDeferredClassInstance {
38		38
39	public IType [] arguments = null;	39	public IType [] arguments = null;
40	public ICPPClassTemplate classTemplate = null;	40	public ICPPClassTemplate classTemplate = null;
Lines 160-166 Link Here
160	classTemplate = (ICPPClassTemplate) argMap.get( classTemplate );	160	classTemplate = (ICPPClassTemplate) argMap.get( classTemplate );
161	}	161	}
162		162
163	return (IType) ((ICPPInternalTemplate)classTemplate).instantiate( newArgs );	163	return (IType) ((ICPPInternalTemplateInstantiator)classTemplate).instantiate( newArgs );
164	}	164	}
165		165
166	/* (non-Javadoc)	166	/* (non-Javadoc)

Lines 11-16 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPClassSpecialization.java (-42 / +185 lines)
11	package org.eclipse.cdt.internal.core.pdom.dom.cpp;	11	package org.eclipse.cdt.internal.core.pdom.dom.cpp;
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
		14	import java.util.Collections;
14	import java.util.List;	15	import java.util.List;
15		16
16	import org.eclipse.cdt.core.CCorePlugin;	17	import org.eclipse.cdt.core.CCorePlugin;
Lines 30-38 Link Here
30	import org.eclipse.cdt.core.dom.ast.cpp.ICPPField;	31	import org.eclipse.cdt.core.dom.ast.cpp.ICPPField;
31	import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;	32	import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
32	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	33	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
		34	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
33	import org.eclipse.cdt.core.index.IIndexBinding;	35	import org.eclipse.cdt.core.index.IIndexBinding;
		36	import org.eclipse.cdt.core.parser.util.ArrayUtil;
		37	import org.eclipse.cdt.core.parser.util.ObjectMap;
34	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassScope;	38	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassScope;
35	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;	39	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;
		40	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
36	import org.eclipse.cdt.internal.core.index.IIndexScope;	41	import org.eclipse.cdt.internal.core.index.IIndexScope;
37	import org.eclipse.cdt.internal.core.index.IIndexType;	42	import org.eclipse.cdt.internal.core.index.IIndexType;
38	import org.eclipse.cdt.internal.core.pdom.PDOM;	43	import org.eclipse.cdt.internal.core.pdom.PDOM;
Lines 40-45 Link Here
40	import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector;	45	import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector;
41	import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;	46	import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;
42	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;	47	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
		48	import org.eclipse.cdt.internal.core.pdom.dom.PDOMName;
43	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	49	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
44	import org.eclipse.core.runtime.CoreException;	50	import org.eclipse.core.runtime.CoreException;
45		51
Lines 50-61 Link Here
50	class PDOMCPPClassSpecialization extends PDOMCPPSpecialization implements	56	class PDOMCPPClassSpecialization extends PDOMCPPSpecialization implements
51	ICPPClassType, ICPPClassScope, IPDOMMemberOwner, IIndexType, IIndexScope {	57	ICPPClassType, ICPPClassScope, IPDOMMemberOwner, IIndexType, IIndexScope {
52		58
53	private static final int MEMBERLIST = PDOMCPPSpecialization.RECORD_SIZE + 0;	59	private static final int FIRSTBASE = PDOMCPPSpecialization.RECORD_SIZE + 0;
		60	private static final int MEMBERLIST = PDOMCPPSpecialization.RECORD_SIZE + 4;
54		61
55	/**	62	/**
56	* The size in bytes of a PDOMCPPClassSpecialization record in the database.	63	* The size in bytes of a PDOMCPPClassSpecialization record in the database.
57	*/	64	*/
58	protected static final int RECORD_SIZE = PDOMCPPSpecialization.RECORD_SIZE + 4;	65	protected static final int RECORD_SIZE = PDOMCPPSpecialization.RECORD_SIZE + 8;
59		66
60	public PDOMCPPClassSpecialization(PDOM pdom, PDOMNode parent, ICPPClassType classType, PDOMBinding specialized)	67	public PDOMCPPClassSpecialization(PDOM pdom, PDOMNode parent, ICPPClassType classType, PDOMBinding specialized)
61	throws CoreException {	68	throws CoreException {
Lines 79-90 Link Here
79	return PDOMCPPLinkage.CPP_CLASS_SPECIALIZATION;	86	return PDOMCPPLinkage.CPP_CLASS_SPECIALIZATION;
80	}	87	}
81		88
		89	public PDOMCPPBase getFirstBase() throws CoreException {
		90	int rec = pdom.getDB().getInt(record + FIRSTBASE);
		91	return rec != 0 ? new PDOMCPPBase(pdom, rec) : null;
		92	}
		93
		94	private void setFirstBase(PDOMCPPBase base) throws CoreException {
		95	int rec = base != null ? base.getRecord() : 0;
		96	pdom.getDB().putInt(record + FIRSTBASE, rec);
		97	}
		98
		99	public void addBase(PDOMCPPBase base) throws CoreException {
		100	PDOMCPPBase firstBase = getFirstBase();
		101	base.setNextBase(firstBase);
		102	setFirstBase(base);
		103	}
		104
		105	public void removeBase(PDOMName pdomName) throws CoreException {
		106	PDOMCPPBase base= getFirstBase();
		107	PDOMCPPBase predecessor= null;
		108	int nameRec= pdomName.getRecord();
		109	while (base != null) {
		110	PDOMName name = base.getBaseClassSpecifierNameImpl();
		111	if (name != null && name.getRecord() == nameRec) {
		112	break;
		113	}
		114	predecessor= base;
		115	base= base.getNextBase();
		116	}
		117	if (base != null) {
		118	if (predecessor != null) {
		119	predecessor.setNextBase(base.getNextBase());
		120	}
		121	else {
		122	setFirstBase(base.getNextBase());
		123	}
		124	base.delete();
		125	}
		126	}
		127
82	public IField findField(String name) throws DOMException { fail(); return null; }	128	public IField findField(String name) throws DOMException { fail(); return null; }
83	public ICPPMethod[] getAllDeclaredMethods() throws DOMException { fail(); return null; }	129	public ICPPMethod[] getAllDeclaredMethods() throws DOMException { fail(); return null; }
84		130
85	public ICPPBase[] getBases() throws DOMException {	131	public ICPPBase[] getBases() throws DOMException {
86	//TODO Get bases	132	if (!(this instanceof ICPPTemplateDefinition) &&
87	return ICPPBase.EMPTY_BASE_ARRAY;	133	getSpecializedBinding() instanceof ICPPTemplateDefinition) {
		134	//this is an explicit specialization
		135	try {
		136	List list = new ArrayList();
		137	for (PDOMCPPBase base = getFirstBase(); base != null; base = base.getNextBase())
		138	list.add(base);
		139	Collections.reverse(list);
		140	ICPPBase[] bases = (ICPPBase[])list.toArray(new ICPPBase[list.size()]);
		141	return bases;
		142	} catch (CoreException e) {
		143	CCorePlugin.log(e);
		144	}
		145	} else {
		146	//this is an implicit specialization
		147	ICPPBase[] pdomBases = ((ICPPClassType) getSpecializedBinding()).getBases();
		148
		149	if (pdomBases != null) {
		150	ICPPBase[] result = new ICPPBase[pdomBases.length];
		151
		152	for (int i = 0; i < pdomBases.length; i++) {
		153	PDOMCPPBase pdomBase = (PDOMCPPBase) pdomBases[i];
		154	IType type = (IType) pdomBase.getBaseClass();
		155	type = CPPTemplates.instantiateType(type, getArgumentMap());
		156	type = CPPSemantics.getUltimateType(type, false);
		157	if (type instanceof IBinding) {
		158	result[i] = pdomBase.createSpecialization((IBinding)type);
		159	}
		160	}
		161
		162	return (ICPPBase[]) ArrayUtil.trim(ICPPBase.class, result);
		163	}
		164	}
		165
		166	return new ICPPBase[0];
88	}	167	}
89		168
90	private static class ConstructorCollector implements IPDOMVisitor {	169	private static class ConstructorCollector implements IPDOMVisitor {
Lines 103-115 Link Here
103		182
104	public ICPPConstructor[] getConstructors() throws DOMException {	183	public ICPPConstructor[] getConstructors() throws DOMException {
105	try {	184	try {
106	if (hasDefinition()) {	185	ConstructorCollector visitor= new ConstructorCollector();
107	ConstructorCollector visitor= new ConstructorCollector();	186	accept(visitor);
108	accept(visitor);	187	return visitor.getConstructors();
109	return visitor.getConstructors();
110	} else {
111	return ((ICPPClassType)getSpecializedBinding()).getConstructors();
112	}
113	} catch (CoreException e) {	188	} catch (CoreException e) {
114	CCorePlugin.log(e);	189	CCorePlugin.log(e);
115	return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;	190	return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
Lines 125-140 Link Here
125	public ICPPClassType[] getNestedClasses() throws DOMException { fail(); return null; }	200	public ICPPClassType[] getNestedClasses() throws DOMException { fail(); return null; }
126		201
127	public IScope getCompositeScope() throws DOMException {	202	public IScope getCompositeScope() throws DOMException {
128	try {	203	return this;
129	if (hasDefinition()) {
130	return this;
131	} else {
132	return ((ICPPClassType)getSpecializedBinding()).getCompositeScope();
133	}
134	} catch (CoreException e) {
135	CCorePlugin.log(e);
136	return null;
137	}
138	}	204	}
139		205
140	public int getKey() throws DOMException {	206	public int getKey() throws DOMException {
Lines 160-198 Link Here
160	return this;	226	return this;
161	}	227	}
162		228
		229	private class SpecializationFinder implements IPDOMVisitor {
		230	private ObjectMap specMap;
		231	public SpecializationFinder(IBinding[] specialized) {
		232	specMap = new ObjectMap(specialized.length);
		233	for (int i = 0; i < specialized.length; i++) {
		234	specMap.put(specialized[i], null);
		235	}
		236	}
		237	public boolean visit(IPDOMNode node) throws CoreException {
		238	if (node instanceof ICPPSpecialization) {
		239	IBinding specialized = ((ICPPSpecialization)node).getSpecializedBinding();
		240	if (specMap.containsKey(specialized)) {
		241	ICPPSpecialization specialization = (ICPPSpecialization) specMap.get(node);
		242	if (specialization == null) {
		243	specMap.remove(specialized);
		244	specMap.put(specialized, node);
		245	}
		246	}
		247	}
		248	return false;
		249	}
		250	public void leave(IPDOMNode node) throws CoreException {
		251	}
		252	public ICPPSpecialization[] getSpecializations() {
		253	ICPPSpecialization[] result = new ICPPSpecialization[specMap.size()];
		254	for (int i = 0; i < specMap.size(); i++) {
		255	ICPPSpecialization specialization = (ICPPSpecialization) specMap.getAt(i);
		256	if (specialization != null) {
		257	result[i] = specialization;
		258	} else {
		259	result[i] = CPPTemplates.createSpecialization(
		260	PDOMCPPClassSpecialization.this, (IBinding) specMap
		261	.keyAt(i), getArgumentMap());
		262	}
		263	}
		264	return result;
		265	}
		266	}
		267
163	public IBinding[] find(String name) throws DOMException {	268	public IBinding[] find(String name) throws DOMException {
164	return find(name, false);	269	return find(name, false);
165	}	270	}
166		271
167	public IBinding[] find(String name, boolean prefixLookup)	272	public IBinding[] find(String name, boolean prefixLookup)
168	throws DOMException {	273	throws DOMException {
169	try {	274	if (!(this instanceof ICPPTemplateDefinition) &&
170	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);	275	getSpecializedBinding() instanceof ICPPTemplateDefinition) {
171	accept(visitor);	276	//this is an explicit specialization
172	return visitor.getBindings();	277	try {
173	} catch (CoreException e) {	278	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);
174	CCorePlugin.log(e);	279	accept(visitor);
		280	return visitor.getBindings();
		281	} catch (CoreException e) {
		282	CCorePlugin.log(e);
		283	}
		284	} else {
		285	//this is an implicit specialization
		286	try {
		287	IBinding[] specialized = ((ICPPClassType) getSpecializedBinding())
		288	.getCompositeScope().find(name.toString(), prefixLookup);
		289	SpecializationFinder visitor = new SpecializationFinder(specialized);
		290	accept(visitor);
		291	return visitor.getSpecializations();
		292	} catch (CoreException e) {
		293	CCorePlugin.log(e);
		294	}
175	}	295	}
176	return null;	296	return null;
177	}	297	}
178		298
179	public IBinding getBinding(IASTName name, boolean resolve)	299	public IBinding getBinding(IASTName name, boolean resolve)
180	throws DOMException {	300	throws DOMException {
181	try {	301	if (!(this instanceof ICPPTemplateDefinition) &&
182	if (getDBName().equals(name.toCharArray())) {	302	getSpecializedBinding() instanceof ICPPTemplateDefinition) {
183	if (CPPClassScope.isConstructorReference(name)){	303	//this is an explicit specialization
184	return CPPSemantics.resolveAmbiguities(name, getConstructors());	304	try {
185	}	305	if (getDBName().equals(name.toCharArray())) {
186	//9.2 ... The class-name is also inserted into the scope of the class itself	306	if (CPPClassScope.isConstructorReference(name)){
187	return this;	307	return CPPSemantics.resolveAmbiguities(name, getConstructors());
188	}	308	}
189		309	//9.2 ... The class-name is also inserted into the scope of the class itself
190	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray());	310	return this;
191	accept(visitor);	311	}
192	return CPPSemantics.resolveAmbiguities(name, visitor.getBindings());	312
193	} catch (CoreException e) {	313	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray());
194	CCorePlugin.log(e);	314	accept(visitor);
		315	return CPPSemantics.resolveAmbiguities(name, visitor.getBindings());
		316	} catch (CoreException e) {
		317	CCorePlugin.log(e);
		318	}
		319	} else {
		320	//this is an implicit specialization
		321	try {
		322	if (getDBName().equals(name.toCharArray())) {
		323	if (!CPPClassScope.isConstructorReference(name)){
		324	//9.2 ... The class-name is also inserted into the scope of the class itself
		325	return this;
		326	}
		327	}
		328
		329	IBinding[] specialized = ((ICPPClassType) getSpecializedBinding())
		330	.getCompositeScope().find(name.toString());
		331	SpecializationFinder visitor = new SpecializationFinder(specialized);
		332	accept(visitor);
		333	return CPPSemantics.resolveAmbiguities(name, visitor.getSpecializations());
		334	} catch (CoreException e) {
		335	CCorePlugin.log(e);
		336	}
195	}	337	}
		338
196	return null;	339	return null;
197	}	340	}
198		341




/*******************************************************************************
 * Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Bryan Wilkinson (QNX)
 *******************************************************************************/ 

package org.eclipse.cdt.internal.core.pdom.dom.cpp;

	}

	public Object clone() {
		return new PDOMCPPReferenceTypeClone(this);
	}
	
	private static class PDOMCPPReferenceTypeClone implements ICPPReferenceType, ITypeContainer, IIndexType {
		private final ICPPReferenceType delegate;
		private IType type = null;
		
		public PDOMCPPReferenceTypeClone(ICPPReferenceType reference) {
			this.delegate = reference;
		}
		public IType getType() throws DOMException {
			if (type == null) {
				return delegate.getType();
			}
			return type;
		}
		public boolean isSameType(IType type) {
			if( type instanceof ITypedef )
			    return type.isSameType(this);
			
			if( !( type instanceof ICPPReferenceType )) 
			    return false;
			
			ICPPReferenceType rhs = (ICPPReferenceType) type;
			try {
				IType type1= getType();
				if (type1 != null) {
					return type1.isSameType(rhs.getType());
				}
			} catch (DOMException e) {
			}
			return false;
		}
		public void setType(IType type) {
			this.type = type;
		}
		public Object clone() {
			return new PDOMCPPReferenceTypeClone(this);
		}
	}
}

Lines 27-32 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionInstance.java (-1 / +2 lines)
27	import org.eclipse.cdt.internal.core.index.IIndexType;	27	import org.eclipse.cdt.internal.core.index.IIndexType;
28	import org.eclipse.cdt.internal.core.pdom.PDOM;	28	import org.eclipse.cdt.internal.core.pdom.PDOM;
29	import org.eclipse.cdt.internal.core.pdom.db.Database;	29	import org.eclipse.cdt.internal.core.pdom.db.Database;
		30	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
30	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	31	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
31	import org.eclipse.core.runtime.CoreException;	32	import org.eclipse.core.runtime.CoreException;
32		33
Lines 60-66 Link Here
60	*/	61	*/
61	protected static final int RECORD_SIZE = PDOMCPPInstance.RECORD_SIZE + 12;	62	protected static final int RECORD_SIZE = PDOMCPPInstance.RECORD_SIZE + 12;
62		63
63	public PDOMCPPFunctionInstance(PDOM pdom, PDOMNode parent, ICPPFunction function, PDOMCPPFunctionTemplate instantiated)	64	public PDOMCPPFunctionInstance(PDOM pdom, PDOMNode parent, ICPPFunction function, PDOMBinding instantiated)
64	throws CoreException {	65	throws CoreException {
65	super(pdom, parent, (ICPPTemplateInstance) function, instantiated);	66	super(pdom, parent, (ICPPTemplateInstance) function, instantiated);
66		67




import org.eclipse.cdt.core.dom.ast.cpp.ICPPField;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.parser.util.ObjectMap;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalDeferredClassInstance;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalTemplateInstantiator;
import org.eclipse.cdt.internal.core.index.IIndexType;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
import org.eclipse.core.runtime.CoreException;


 * 
 */
class PDOMCPPDeferredClassInstance extends PDOMCPPInstance implements
		ICPPClassType, IIndexType, ICPPDeferredTemplateInstance, ICPPInternalDeferredClassInstance {

	/**
	 * The size in bytes of a PDOMCPPDeferredClassInstance record in the database.
	 */
	protected static final int RECORD_SIZE = PDOMCPPInstance.RECORD_SIZE + 0;
	
	public PDOMCPPDeferredClassInstance(PDOM pdom, PDOMNode parent, ICPPClassType classType, PDOMBinding instantiated)
			throws CoreException {
		super(pdom, parent, (ICPPTemplateInstance) classType, instantiated);
	}

	public ICPPMethod[] getMethods() throws DOMException { fail(); return null; }
	public ICPPClassType[] getNestedClasses() throws DOMException { fail(); return null; }
	public Object clone() {fail();return null;}
	
	/**
	 * @param argMap
	 * @return
	 */
	public IType instantiate(ObjectMap argMap) {
		IType[] arguments = getArguments();
		
		IType [] newArgs = new IType[ arguments.length ];
		int size = arguments.length;
		for( int i = 0; i < size; i++ ){
			newArgs[i] = CPPTemplates.instantiateType( arguments[i], argMap );
		}
		
		return (IType) ((ICPPInternalTemplateInstantiator)getTemplateDefinition()).instantiate( newArgs );
	}
}





import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPBase;
import org.eclipse.cdt.internal.core.pdom.PDOM;

	public void delete() throws CoreException {
		pdom.getDB().free(record);
	}
	
	private static class PDOMCPPBaseSpecialization implements ICPPBase {
		private PDOMCPPBase base;
		private IBinding baseClass;
		
		public PDOMCPPBaseSpecialization(PDOMCPPBase base, IBinding baseClass) {
			this.base = base;
			this.baseClass = baseClass;
		}
		public IBinding getBaseClass() throws DOMException {
			return baseClass;
		}
		public IName getBaseClassSpecifierName() {
			return base.getBaseClassSpecifierName();
		}
		public int getVisibility() throws DOMException {
			return base.getVisibility();
		}
		public boolean isVirtual() throws DOMException {
			return base.isVirtual();
		}
	}
	
	public ICPPBase createSpecialization(IBinding baseClass) {
		return new PDOMCPPBaseSpecialization(this, baseClass);
	}
}




/*******************************************************************************
 * Copyright (c) 2006, 2007 QNX Software Systems and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.cdt.internal.core.pdom.dom.cpp;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.ILinkage;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.ITypedef;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
import org.eclipse.cdt.internal.core.Util;
import org.eclipse.cdt.internal.core.dom.parser.ITypeContainer;
import org.eclipse.cdt.internal.core.index.IIndexType;

		return false;
	}

	public Object clone() { fail(); return null; }
	public void setType(IType type) { fail(); }

	public Object clone() {
		return new PDOMCPPTypedefClone(this);
	}
	
	private static class PDOMCPPTypedefClone implements ITypedef, ITypeContainer, IIndexType, ICPPBinding {
		protected final ITypedef delegate;
		private IType type = null;
		
		public PDOMCPPTypedefClone(ITypedef typedef) {
			this.delegate = typedef;
		}
		public IType getType() throws DOMException {
			if (type == null) {
				return delegate.getType();
			}
			return type;
		}
		public ILinkage getLinkage() throws CoreException {
			return delegate.getLinkage();
		}
		public String getName() {
			return delegate.getName();
		}
		public char[] getNameCharArray() {
			return delegate.getNameCharArray();
		}
		public IScope getScope() throws DOMException {
			return delegate.getScope();
		}
		public Object getAdapter(Class adapter) {
			return delegate.getAdapter(adapter);
		}
		public boolean isSameType(IType type) {
			try {
				IType myrtype = getType();
				if (myrtype == null)
					return false;
				
				if (type instanceof ITypedef) {
					type= ((ITypedef)type).getType();
				}
				return myrtype.isSameType(type);
			} catch (DOMException e) {
			}
			return false;
		}
		public void setType(IType type) {
			this.type = type;
		}
		public String[] getQualifiedName() throws DOMException {
			return ((ICPPBinding)delegate).getQualifiedName();
		}
		public char[][] getQualifiedNameCharArray() throws DOMException {
			return ((ICPPBinding)delegate).getQualifiedNameCharArray();
		}
		public boolean isGloballyQualified() throws DOMException {
			return ((ICPPBinding)delegate).isGloballyQualified();
		}
		public Object clone() {
			return new PDOMCPPTypedefClone(this);
		}
	}
}




import org.eclipse.cdt.core.dom.IPDOMNode;
import org.eclipse.cdt.core.dom.IPDOMVisitor;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionTemplate;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateScope;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalTemplateInstantiator;
import org.eclipse.cdt.internal.core.index.IIndexScope;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;
import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector;
import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
import org.eclipse.core.runtime.CoreException;

 */
public class PDOMCPPFunctionTemplate extends PDOMCPPFunction implements
		ICPPFunctionTemplate, ICPPInternalTemplateInstantiator,
		IPDOMMemberOwner, ICPPTemplateScope, IIndexScope {

	private static final int TEMPLATE_PARAMS = PDOMCPPFunction.RECORD_SIZE + 0;
	private static final int INSTANCES = PDOMCPPFunction.RECORD_SIZE + 4;

	}

	public IBinding instantiate(IType[] arguments) {
		return CPPTemplates.instantiateTemplate(this, arguments, null);
	}

	public void addChild(PDOMNode child) throws CoreException {

		list = new PDOMNodeLinkedList(pdom, record + INSTANCES, getLinkageImpl());
		list.accept(visitor);
	}

	public ICPPTemplateDefinition getTemplateDefinition() throws DOMException {
		return this;
	}

	public IBinding[] find(String name) throws DOMException {
		return find(name, false);
	}

	public IBinding[] find(String name, boolean prefixLookup)
			throws DOMException {
		try {
			BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);
			PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl());
			list.accept(visitor);
			
			return visitor.getBindings();
		} catch (CoreException e) {
			CCorePlugin.log(e);
		}
		return null;
	}

	public IBinding getBinding(IASTName name, boolean resolve)
			throws DOMException {
		try {
			BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray());
			PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl());
			list.accept(visitor);
			
			return CPPSemantics.resolveAmbiguities(name, visitor.getBindings());
		} catch (CoreException e) {
			CCorePlugin.log(e);
		}
		return null;
	}

	public IIndexBinding getScopeBinding() {
		return this;
	}
}




import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPScope;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.parser.util.ObjectMap;
import org.eclipse.cdt.internal.core.Util;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;
import org.eclipse.cdt.internal.core.pdom.dom.IPDOMOverloader;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNotImplementedError;
import org.eclipse.core.runtime.CoreException;

	protected static final int RECORD_SIZE = PDOMCPPClassTemplate.RECORD_SIZE + 16;
	
	public PDOMCPPClassTemplatePartialSpecialization(PDOM pdom,
			PDOMNode parent, ICPPClassTemplatePartialSpecialization partial, PDOMCPPClassTemplate primary) throws CoreException {
		super(pdom, parent, partial);
		pdom.getDB().putInt(record + PRIMARY, primary.getRecord());
		primary.addPartial(this);
			((PDOMCPPClassTemplate)primary).addPartial(this);
		} else if (primary instanceof PDOMCPPClassTemplateSpecialization) {
			((PDOMCPPClassTemplateSpecialization)primary).addPartial(this);
		}
		
		try {
			Integer memento = PDOMCPPOverloaderUtil.getSignatureMemento(partial);

	}

	public IBinding instantiate(IType[] args) {
		ICPPSpecialization instance = getInstance( args );
		if( instance != null ){
			return instance;
		}
		
		IType [] specArgs = getArguments();
		if( specArgs.length != args.length ){
			return null;
		}
		
		ObjectMap argMap = new ObjectMap( specArgs.length );
		int numSpecArgs = specArgs.length;
		for( int i = 0; i < numSpecArgs; i++ ){
			IType spec = specArgs[i];
			IType arg = args[i];
			
			//If the argument is a template parameter, we can't instantiate yet, defer for later
			if( CPPTemplates.typeContainsTemplateParameter( arg ) ){
				return deferredInstance( args );
			}
			try {
				if( !CPPTemplates.deduceTemplateArgument( argMap,  spec, arg ) )
					return null;
			} catch (DOMException e) {
				return null;
			}
		}
		
		ICPPTemplateParameter [] params = getTemplateParameters();
		int numParams = params.length;
		for( int i = 0; i < numParams; i++ ){
			if( params[i] instanceof IType && !argMap.containsKey( params[i] ) )
				return null;
		}
		
		return (ICPPTemplateInstance) CPPTemplates.createInstance( (ICPPScope) getScope(), this, argMap, args );
	}

	public ObjectMap getArgumentMap() {

Lines 19-24 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFieldSpecialization.java (-1 / +2 lines)
19	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	19	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
20	import org.eclipse.cdt.internal.core.Util;	20	import org.eclipse.cdt.internal.core.Util;
21	import org.eclipse.cdt.internal.core.pdom.PDOM;	21	import org.eclipse.cdt.internal.core.pdom.PDOM;
		22	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
22	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	23	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
23	import org.eclipse.core.runtime.CoreException;	24	import org.eclipse.core.runtime.CoreException;
24		25
Lines 37-43 Link Here
37	protected static final int RECORD_SIZE = PDOMCPPSpecialization.RECORD_SIZE + 4;	38	protected static final int RECORD_SIZE = PDOMCPPSpecialization.RECORD_SIZE + 4;
38		39
39	public PDOMCPPFieldSpecialization(PDOM pdom, PDOMNode parent,	40	public PDOMCPPFieldSpecialization(PDOM pdom, PDOMNode parent,
40	ICPPField field, PDOMCPPField specialized)	41	ICPPField field, PDOMBinding specialized)
41	throws CoreException {	42	throws CoreException {
42	super(pdom, parent, (ICPPSpecialization) field, specialized);	43	super(pdom, parent, (ICPPSpecialization) field, specialized);
43		44

Lines 20-25 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPSpecialization.java (-6 / +19 lines)
20	import org.eclipse.cdt.core.dom.ast.IBinding;	20	import org.eclipse.cdt.core.dom.ast.IBinding;
21	import org.eclipse.cdt.core.dom.ast.IType;	21	import org.eclipse.cdt.core.dom.ast.IType;
22	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	22	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
		23	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
		24	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
23	import org.eclipse.cdt.core.parser.util.ObjectMap;	25	import org.eclipse.cdt.core.parser.util.ObjectMap;
24	import org.eclipse.cdt.internal.core.pdom.PDOM;	26	import org.eclipse.cdt.internal.core.pdom.PDOM;
25	import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;	27	import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;
Lines 135-150 Link Here
135	return pdom.getDB().getInt(record + SIGNATURE_MEMENTO);	137	return pdom.getDB().getInt(record + SIGNATURE_MEMENTO);
136	}	138	}
137		139
138	private static IType[] getArguments(ObjectMap argMap) {	140	private IType[] getArguments() {
139	IType[] args = new IType[argMap.size()];	141	if (!(this instanceof ICPPTemplateDefinition)
140	for (int i = 0; i < argMap.size(); i++) {	142	&& getSpecializedBinding() instanceof ICPPTemplateDefinition) {
141	args[i] = (IType) argMap.getAt(i);	143	ICPPTemplateDefinition template = (ICPPTemplateDefinition) getSpecializedBinding();
		144	try {
		145	ICPPTemplateParameter[] params = template.getTemplateParameters();
		146	ObjectMap argMap = getArgumentMap();
		147	IType[] args = new IType[argMap.size()];
		148	for (int i = 0; i < argMap.size(); i++) {
		149	args[i] = (IType) argMap.get(params[i]);
		150	}
		151	return args;
		152	} catch (DOMException e) {
		153	}
142	}	154	}
143	return args;	155
		156	return IType.EMPTY_TYPE_ARRAY;
144	}	157	}
145		158
146	public boolean matchesArguments(IType[] arguments) {	159	public boolean matchesArguments(IType[] arguments) {
147	IType [] args = getArguments(getArgumentMap());	160	IType [] args = getArguments();
148	if( args.length == arguments.length ){	161	if( args.length == arguments.length ){
149	int i = 0;	162	int i = 0;
150	for(; i < args.length; i++) {	163	for(; i < args.length; i++) {




import org.eclipse.cdt.core.dom.ast.cpp.ICPPPointerToMemberType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPReferenceType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateNonTypeParameter;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;

import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier;
import org.eclipse.cdt.internal.core.Util;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBlockScope;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassSpecializationScope;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalFunction;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.db.IBTreeComparator;

	public static final int CPP_CLASS_SPECIALIZATION= PDOMLinkage.LAST_NODE_TYPE + 30;
	public static final int CPP_CLASS_TEMPLATE_SPECIALIZATION= PDOMLinkage.LAST_NODE_TYPE + 31;
	
	private class ConfigureTemplate implements Runnable {
		PDOMBinding template;
		ICPPTemplateDefinition binding;
		
		public ConfigureTemplate(PDOMBinding template, ICPPTemplateDefinition binding) {
			this.template = template;
			this.binding = binding;
		}
		
		public void run() {
			try {
				ICPPTemplateParameter[] params = binding.getTemplateParameters();
				for (int i = 0; i < params.length; i++) {
					addBinding(params[i]);
				}
			} catch (CoreException e) {
			} catch (DOMException e) {
			} finally {
				template = null;
				binding = null;
			}
		}
	}
	
	private class ConfigurePartialSpecialization implements Runnable {
		PDOMCPPClassTemplatePartialSpecialization partial;
		ICPPClassTemplatePartialSpecialization binding;

	private boolean shouldAddParent(IBinding binding) throws CoreException {
		if (binding instanceof ICPPTemplateParameter) {
			return true;
		} else if (binding instanceof ICPPClassTemplatePartialSpecialization) {
			return true;
		} else if (binding instanceof ICPPSpecialization) {
			return true;
				IScope scope = binding.getScope();
				if (scope instanceof CPPClassSpecializationScope)
					return true;
			} catch (DOMException e) {
			}
		}
		return false;
	}

		if (binding instanceof ICPPSpecialization) {
			IBinding specialized = ((ICPPSpecialization)binding).getSpecializedBinding();
			PDOMBinding pdomSpecialized = addBinding(specialized);
			if (pdomSpecialized == null) return null;
			
			if (binding instanceof ICPPDeferredTemplateInstance) {
				if (binding instanceof ICPPFunction && pdomSpecialized instanceof ICPPFunctionTemplate) {
					pdomBinding = new PDOMCPPDeferredFunctionInstance(pdom,
							parent, (ICPPFunction) binding, pdomSpecialized);	
							(PDOMCPPFunctionTemplate) pdomSpecialized);	
				} else if (binding instanceof ICPPClassType && pdomSpecialized instanceof ICPPClassTemplate) {
					pdomBinding = new PDOMCPPDeferredClassInstance(pdom,
							parent, (ICPPClassType) binding, pdomSpecialized);
							(PDOMCPPClassTemplate) pdomSpecialized);
				}
			} else if (binding instanceof ICPPTemplateInstance) {
				if (binding instanceof ICPPFunction && pdomSpecialized instanceof ICPPFunction) {
					pdomBinding = new PDOMCPPFunctionInstance(pdom, parent,
							(ICPPFunction) binding, pdomSpecialized);
				} else if (binding instanceof ICPPClassType && pdomSpecialized instanceof ICPPClassType) {
				} else if (binding instanceof ICPPClassType && pdomSpecialized instanceof PDOMCPPClassTemplate) {
					pdomBinding = new PDOMCPPClassInstance(pdom, parent,
							(ICPPClassType) binding, pdomSpecialized);
				} else if (binding instanceof ICPPClassType && pdomSpecialized instanceof PDOMCPPClassTemplateSpecialization) {
					pdomBinding = new PDOMCPPClassInstance(pdom, parent,
							(ICPPClassType) binding, pdomSpecialized);
				}
			} else if (binding instanceof ICPPClassTemplatePartialSpecialization && pdomSpecialized instanceof PDOMCPPClassTemplate) {
				pdomBinding = new PDOMCPPClassTemplatePartialSpecialization(
						pdom, parent, (ICPPClassTemplatePartialSpecialization) binding,
						(PDOMCPPClassTemplate) pdomSpecialized);
			} else if (binding instanceof ICPPField) {
			} else if (binding instanceof ICPPField && pdomSpecialized instanceof PDOMCPPField) {
				pdomBinding = new PDOMCPPFieldSpecialization(pdom, parent,
						(ICPPField) binding, pdomSpecialized);
			} else if (binding instanceof ICPPConstructor) {
				pdomBinding = new PDOMCPPConstructorSpecialization(pdom, parent,
						(ICPPConstructor) binding, pdomSpecialized);

			PDOMCPPClassTemplatePartialSpecialization pdomSpec = (PDOMCPPClassTemplatePartialSpecialization) pdomBinding;
			ICPPClassTemplatePartialSpecialization spec = (ICPPClassTemplatePartialSpecialization) binding;
			postProcesses.add(postProcesses.size(), new ConfigurePartialSpecialization(pdomSpec, spec));
		} 
		if (pdomBinding instanceof PDOMCPPFunctionTemplate && binding instanceof ICPPFunction) {
			PDOMCPPFunctionTemplate pdomTemplate = (PDOMCPPFunctionTemplate) pdomBinding;
			ICPPFunction function = (ICPPFunction) binding;
			postProcesses.add(postProcesses.size(), new ConfigureFunctionTemplate(pdomTemplate, function));
		}
		if ((pdomBinding instanceof PDOMCPPClassTemplate || pdomBinding instanceof PDOMCPPFunctionTemplate) &&
				binding instanceof ICPPTemplateDefinition) {
			ICPPTemplateDefinition template = (ICPPTemplateDefinition) binding;
			postProcesses.add(postProcesses.size(), new ConfigureTemplate(pdomBinding, template));
		}
	}
	
	private void addImplicitMethods(PDOMBinding type, ICPPClassType binding) throws CoreException {

	}

	public PDOMNode addType(PDOMNode parent, IType type) throws CoreException {
		if (type instanceof IProblemBinding) {
			return null;
				return null;
			}
			if (type instanceof ICPPBasicType) {
				return new PDOMCPPBasicType(pdom, parent, (ICPPBasicType)type);
			}
			if (type instanceof ICPPClassType) {
				return addBinding((ICPPClassType) type);
			} 
			if (type instanceof IEnumeration) {
				return addBinding((IEnumeration) type);
			} 
			if (type instanceof ITypedef) {
				return addBinding((ITypedef) type);
			}
			if (type instanceof ICPPReferenceType) {
				return new PDOMCPPReferenceType(pdom, parent, (ICPPReferenceType)type);
			}
			if (type instanceof ICPPPointerToMemberType) {
				return new PDOMCPPPointerToMemberType(pdom, parent, (ICPPPointerToMemberType)type);
			}
			if (type instanceof ICPPTemplateTypeParameter) {
				return addBinding((ICPPTemplateTypeParameter) type);
			}
			
			return super.addType(parent, type); 
		} finally {
			handlePostProcesses();
		}
		if (type instanceof ICPPBasicType) {
			return new PDOMCPPBasicType(pdom, parent, (ICPPBasicType) type);
		}
		if (type instanceof ICPPClassType) {
			return addBinding((ICPPClassType) type);
		}
		if (type instanceof IEnumeration) {
			return addBinding((IEnumeration) type);
		}
		if (type instanceof ITypedef) {
			return addBinding((ITypedef) type);
		}
		if (type instanceof ICPPReferenceType) {
			return new PDOMCPPReferenceType(pdom, parent,
					(ICPPReferenceType) type);
		}
		if (type instanceof ICPPPointerToMemberType) {
			return new PDOMCPPPointerToMemberType(pdom, parent,
					(ICPPPointerToMemberType) type);
		}
		if (type instanceof ICPPTemplateTypeParameter) {
			return addBinding((ICPPTemplateTypeParameter) type);
		}

		return super.addType(parent, type); 
	}

	private void handlePostProcesses() {

					PDOMCPPBase pdomBase = new PDOMCPPBase(pdom, pdomName, baseNode.isVirtual(), baseNode.getVisibility());
					ownerClass.addBase(pdomBase);
					pdomName.setIsBaseSpecifier(true);
				} else if (derivedClassBinding instanceof PDOMCPPClassSpecialization) {
					PDOMCPPClassSpecialization ownerClass = (PDOMCPPClassSpecialization)derivedClassBinding;
					PDOMCPPBase pdomBase = new PDOMCPPBase(pdom, pdomName, baseNode.isVirtual(), baseNode.getVisibility());
					ownerClass.addBase(pdomBase);
					pdomName.setIsBaseSpecifier(true);
				}
			}
		}

				if (derivedClassBinding instanceof PDOMCPPClassType) {
					PDOMCPPClassType ownerClass = (PDOMCPPClassType)derivedClassBinding;
					ownerClass.removeBase(pdomName);
				} else if (derivedClassBinding instanceof PDOMCPPClassSpecialization) {
					PDOMCPPClassSpecialization ownerClass = (PDOMCPPClassSpecialization)derivedClassBinding;
					ownerClass.removeBase(pdomName);
				}
			}
		}




package org.eclipse.cdt.internal.core.pdom.dom.cpp;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import org.eclipse.cdt.core.CCorePlugin;

import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.index.IndexFilter;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassScope;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPDeferredClassInstance;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalTemplateInstantiator;

		}
	}
	
	public ICPPTemplateParameter[] getTemplateParameters() {
		try {
			PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + PARAMETERS, getLinkageImpl());
			TemplateParameterCollector visitor = new TemplateParameterCollector();

			};
			
			BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), filter, prefixLookup, !prefixLookup);
			accept(visitor);
			return visitor.getBindings();
		} catch (CoreException e) {
			CCorePlugin.log(e);

	}

	public ICPPSpecialization deferredInstance(IType[] arguments) {
		ICPPSpecialization instance = getInstance( arguments );
		if( instance == null ){
			instance = new CPPDeferredClassInstance( this, arguments );
		}
		return instance;
	}

	private static class InstanceFinder implements IPDOMVisitor {

			return ((PDOMCPPClassTemplate)template).instantiate( arguments );	
		}
		
		return CPPTemplates.instantiateTemplate(this, arguments, null);
	}
}




 *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom.dom.cpp;

import java.util.ArrayList;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.IPDOMNode;
import org.eclipse.cdt.core.dom.IPDOMVisitor;


	private static final int INSTANCES = PDOMCPPClassSpecialization.RECORD_SIZE + 0;
	private static final int SPECIALIZATIONS = PDOMCPPClassSpecialization.RECORD_SIZE + 4;
	private static final int FIRST_PARTIAL = PDOMCPPClassSpecialization.RECORD_SIZE + 8;
	
	/**
	 * The size in bytes of a PDOMCPPClassTemplateSpecialization record in the database.
	 */
	protected static final int RECORD_SIZE = PDOMCPPClassSpecialization.RECORD_SIZE + 8;
	
	public PDOMCPPClassTemplateSpecialization(PDOM pdom, PDOMNode parent, ICPPClassTemplate template, PDOMBinding specialized)
			throws CoreException {

	public int getNodeType() {
		return PDOMCPPLinkage.CPP_CLASS_TEMPLATE_SPECIALIZATION;
	}
	
	private PDOMCPPClassTemplatePartialSpecialization getFirstPartial() throws CoreException {
		int value = pdom.getDB().getInt(record + FIRST_PARTIAL);
		return value != 0 ? new PDOMCPPClassTemplatePartialSpecialization(pdom, value) : null;
	}
	
	public void addPartial(PDOMCPPClassTemplatePartialSpecialization partial) throws CoreException {
		PDOMCPPClassTemplatePartialSpecialization first = getFirstPartial();
		partial.setNextPartial(first);
		pdom.getDB().putInt(record + FIRST_PARTIAL, partial.getRecord());
	}
		
	public ICPPClassTemplatePartialSpecialization[] getPartialSpecializations() throws DOMException {
		return ((ICPPClassTemplate)getSpecializedBinding()).getPartialSpecializations();
			ArrayList partials = new ArrayList();
			for (PDOMCPPClassTemplatePartialSpecialization partial = getFirstPartial();
					partial != null;
					partial = partial.getNextPartial()) {
				partials.add(partial);
			}
			
			return (ICPPClassTemplatePartialSpecialization[]) partials
					.toArray(new ICPPClassTemplatePartialSpecialization[partials
							.size()]);
		} catch (CoreException e) {
			CCorePlugin.log(e);
			return new ICPPClassTemplatePartialSpecialization[0];
		}
	}

	public ICPPTemplateParameter[] getTemplateParameters() throws DOMException {

			return ((PDOMCPPClassTemplate)template).instantiate( arguments );	
		}
		
		return CPPTemplates.instantiateTemplate(this, arguments, getArgumentMap());
	}
	
	public void addMember(PDOMNode member) throws CoreException {
		if (member instanceof ICPPTemplateInstance) {
			PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + INSTANCES, getLinkageImpl());
			list.addMember(member);
		} else if (member instanceof ICPPSpecialization) {
			if (this.equals(((ICPPSpecialization)member).getSpecializedBinding())) {
				PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + SPECIALIZATIONS, getLinkageImpl());
				list.addMember(member);
			} else {
				super.addMember(member);
			}
		} else {
			super.addMember(member);
		}




/*******************************************************************************
 * Copyright (c) 2006, 2007 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Bryan Wilkinson (QNX)
 *******************************************************************************/ 

package org.eclipse.cdt.internal.core.pdom.dom.cpp;

		}
		return null;
	}
	
	public Object clone() {
		return new PDOMCPPPointerToMemberTypeClone(this);
	}
	
	private static class PDOMCPPPointerToMemberTypeClone extends PDOMPointerType.PDOMPointerTypeClone implements ICPPPointerToMemberType {
		public PDOMCPPPointerToMemberTypeClone(ICPPPointerToMemberType pointer) {
			super(pointer);
		}
		public ICPPClassType getMemberOfClass() {
			return ((ICPPPointerToMemberType)delegate).getMemberOfClass();
		}
		public Object clone() {
			return new PDOMCPPPointerToMemberTypeClone(this);
		}
	}
}

Lines 13-18 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPDeferredFunctionInstance.java (-1 / +2 lines)
13	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;	13	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;
14	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;	14	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
15	import org.eclipse.cdt.internal.core.pdom.PDOM;	15	import org.eclipse.cdt.internal.core.pdom.PDOM;
		16	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
16	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	17	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
17	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
18		19
Lines 28-34 Link Here
28	*/	29	*/
29	protected static final int RECORD_SIZE = PDOMCPPFunctionInstance.RECORD_SIZE + 0;	30	protected static final int RECORD_SIZE = PDOMCPPFunctionInstance.RECORD_SIZE + 0;
30		31
31	public PDOMCPPDeferredFunctionInstance(PDOM pdom, PDOMNode parent, ICPPFunction function, PDOMCPPFunctionTemplate instantiated)	32	public PDOMCPPDeferredFunctionInstance(PDOM pdom, PDOMNode parent, ICPPFunction function, PDOMBinding instantiated)
32	throws CoreException {	33	throws CoreException {
33	super(pdom, parent, function, instantiated);	34	super(pdom, parent, function, instantiated);
34	}	35	}




import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPField;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.parser.util.ArrayUtil;
import org.eclipse.cdt.core.parser.util.ObjectMap;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassScope;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
import org.eclipse.cdt.internal.core.index.IIndexScope;
import org.eclipse.cdt.internal.core.index.IIndexType;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;
import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector;
import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;

	public int getNodeType() {
		return PDOMCPPLinkage.CPP_CLASS_INSTANCE;
	}
	
	public ICPPBase[] getBases() throws DOMException {		
		ICPPBase[] pdomBases = ((ICPPClassType) getTemplateDefinition()).getBases();

		if (pdomBases != null) {
			ICPPBase[] result = new ICPPBase[pdomBases.length];
			
			for (int i = 0; i < pdomBases.length; i++) {
				PDOMCPPBase pdomBase = (PDOMCPPBase) pdomBases[i];
				IType type = (IType) pdomBase.getBaseClass();
				type = CPPTemplates.instantiateType(type, getArgumentMap());
				type = CPPSemantics.getUltimateType(type, false);
				if (type instanceof IBinding) {
					result[i] = pdomBase.createSpecialization((IBinding)type);
				}
			}
			
			return (ICPPBase[]) ArrayUtil.trim(ICPPBase.class, result);
		}
		
		return new ICPPBase[0];
	}
	
	private static class ConstructorCollector implements IPDOMVisitor {

		return this;
	}
	
	private class SpecializationFinder implements IPDOMVisitor {
		private ObjectMap specMap;
		public SpecializationFinder(IBinding[] specialized) {
			specMap = new ObjectMap(specialized.length);
			for (int i = 0; i < specialized.length; i++) {
				specMap.put(specialized[i], null);
			}
		}
		public boolean visit(IPDOMNode node) throws CoreException {
			if (node instanceof ICPPSpecialization) {
				IBinding specialized = ((ICPPSpecialization)node).getSpecializedBinding();
				if (specMap.containsKey(specialized)) {
					ICPPSpecialization specialization = (ICPPSpecialization) specMap.get(node);
					if (specialization == null) {
						specMap.remove(specialized);
						specMap.put(specialized, node);
					}
				}
			}
			return false;
		}
		public void leave(IPDOMNode node) throws CoreException {
		}
		public ICPPSpecialization[] getSpecializations() {
			ICPPSpecialization[] result = new ICPPSpecialization[specMap.size()];
			for (int i = 0; i < specMap.size(); i++) {
				ICPPSpecialization specialization = (ICPPSpecialization) specMap.getAt(i);
				if (specialization != null) {
					result[i] = specialization;
				} else {
					result[i] = CPPTemplates.createSpecialization(
							PDOMCPPClassInstance.this, (IBinding) specMap
									.keyAt(i), getArgumentMap());
				}
			}
			return result;
		}
	}
	
	public IBinding[] find(String name) throws DOMException {
		return find(name, false);
	}

	public IBinding[] find(String name, boolean prefixLookup)
			throws DOMException {
		try {						
			IBinding[] specialized = ((ICPPClassType) getTemplateDefinition())
					.getCompositeScope().find(name.toString(), prefixLookup);			
			SpecializationFinder visitor = new SpecializationFinder(specialized);
			accept(visitor);
			return visitor.getSpecializations();
		} catch (CoreException e) {
			CCorePlugin.log(e);
		}
		return null;
	}
	
	public IBinding getBinding(IASTName name, boolean resolve)
			throws DOMException {
		try {			
		    if (getDBName().equals(name.toCharArray())) {
		        if (!CPPClassScope.isConstructorReference(name)){
		        	//9.2 ... The class-name is also inserted into the scope of the class itself
		        	return this;
		        }
	            //9.2 ... The class-name is also inserted into the scope of the class itself
	            return this;
		    }
			
			IBinding[] specialized = ((ICPPClassType) getTemplateDefinition())
					.getCompositeScope().find(name.toString());			
			SpecializationFinder visitor = new SpecializationFinder(specialized);
			accept(visitor);
			return CPPSemantics.resolveAmbiguities(name, visitor.getSpecializations());
		} catch (CoreException e) {
			CCorePlugin.log(e);
		}

Lines 187-193 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPClassType.java (-2 / +2 lines)
187	}	187	}
188	}	188	}
189		189
190	protected void acceptInHierarchy(Set visited, IPDOMVisitor visitor) throws CoreException {	190	private void acceptInHierarchy(Set visited, IPDOMVisitor visitor) throws CoreException {
191	if (visited.contains(this))	191	if (visited.contains(this))
192	return;	192	return;
193	visited.add(this);	193	visited.add(this);
Lines 391-397 Link Here
391	public IBinding[] find(String name, boolean prefixLookup) throws DOMException {	391	public IBinding[] find(String name, boolean prefixLookup) throws DOMException {
392	try {	392	try {
393	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);	393	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);
394	acceptInHierarchy(new HashSet(), visitor);	394	accept(visitor);
395	return visitor.getBindings();	395	return visitor.getBindings();
396	} catch (CoreException e) {	396	} catch (CoreException e) {
397	CCorePlugin.log(e);	397	CCorePlugin.log(e);




import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.parser.util.ObjectMap;

			buffer.append(getTemplateArgString(partial.getArguments(), false));
		} else if (binding instanceof ICPPSpecialization) {
			ICPPSpecialization spec = (ICPPSpecialization) binding;
			if (!(spec instanceof ICPPTemplateDefinition)
					&& spec.getSpecializedBinding() instanceof ICPPTemplateDefinition) {
				ICPPTemplateDefinition template = (ICPPTemplateDefinition) spec.getSpecializedBinding();
				ICPPTemplateParameter[] params = template.getTemplateParameters();
				ObjectMap argMap = spec.getArgumentMap();
				IType[] args = new IType[params.length];
				for (int i = 0; i < params.length; i++) {
					args[i] = (IType) argMap.get(params[i]);
				}
				buffer.append(getTemplateArgString(args, false));	
			}
			buffer.append(getTemplateArgString(args, false));
		} 
		
		if (binding instanceof IFunction) {

Lines 1-5 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPBinding.java (-2 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006 Symbian Corporation and others.	2	* Copyright (c) 2006, 2007 Symbian Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 18-23 Link Here
18	import org.eclipse.cdt.core.CCorePlugin;	18	import org.eclipse.cdt.core.CCorePlugin;
19	import org.eclipse.cdt.core.dom.ast.DOMException;	19	import org.eclipse.cdt.core.dom.ast.DOMException;
20	import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;	20	import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding;
		21	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
21	import org.eclipse.cdt.internal.core.pdom.PDOM;	22	import org.eclipse.cdt.internal.core.pdom.PDOM;
22	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;	23	import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
23	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	24	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
Lines 57-63 Link Here
57	try {	58	try {
58	PDOMNode node = this;	59	PDOMNode node = this;
59	while (node != null) {	60	while (node != null) {
60	if (node instanceof PDOMBinding) {	61	if (node instanceof PDOMBinding && !(node instanceof ICPPTemplateInstance)) {
61	result.add(0, ((PDOMBinding)node).getName().toCharArray());	62	result.add(0, ((PDOMBinding)node).getName().toCharArray());
62	}	63	}
63	node = node.getParentNode();	64	node = node.getParentNode();

Lines 7-12 Link Here

(-)parser/org/eclipse/cdt/internal/core/index/composite/cpp/TemplateInstanceUtil.java (-3 / +5 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation	9	* Andrew Ferguson (Symbian) - Initial implementation
		10	* Bryan Wilkinson (QNX)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.index.composite.cpp;	12	package org.eclipse.cdt.internal.core.index.composite.cpp;
12		13
Lines 17-23 Link Here
17	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	18	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
18	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;	19	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
19	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;	20	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
20	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
21	import org.eclipse.cdt.core.index.IIndexBinding;	21	import org.eclipse.cdt.core.index.IIndexBinding;
22	import org.eclipse.cdt.core.parser.util.ObjectMap;	22	import org.eclipse.cdt.core.parser.util.ObjectMap;
23	import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;	23	import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;
Lines 33-40 Link Here
33	ObjectMap result= new ObjectMap(preresult.size());	33	ObjectMap result= new ObjectMap(preresult.size());
34	Object[] keys= preresult.keyArray();	34	Object[] keys= preresult.keyArray();
35	for(int i=0; i<keys.length; i++) {	35	for(int i=0; i<keys.length; i++) {
36	ICPPTemplateParameter param= (ICPPTemplateParameter) preresult.get(keys[i]);	36	IType type= (IType) preresult.get(keys[i]);
37	result.put(keys[i], cf.getCompositeBinding((IIndexFragmentBinding)param));	37	result.put(
		38	cf.getCompositeBinding((IIndexFragmentBinding)keys[i]),
		39	cf.getCompositeBinding((IIndexFragmentBinding)type));
38	}	40	}
39	return result;	41	return result;
40	}	42	}

Lines 7-12 Link Here

(-)parser/org/eclipse/cdt/internal/core/index/composite/cpp/InternalTemplateInstantiatorUtil.java (-1 / +7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Andrew Ferguson (Symbian) - Initial implementation	9	* Andrew Ferguson (Symbian) - Initial implementation
		10	* Bryan Wilkinson (QNX)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.index.composite.cpp;	12	package org.eclipse.cdt.internal.core.index.composite.cpp;
12		13
Lines 31-36 Link Here
31		32
32	public static IBinding instantiate(IType[] arguments, ICompositesFactory cf, IIndexBinding rbinding) {	33	public static IBinding instantiate(IType[] arguments, ICompositesFactory cf, IIndexBinding rbinding) {
33	IBinding ins= ((ICPPInternalTemplateInstantiator)rbinding).instantiate(arguments);	34	IBinding ins= ((ICPPInternalTemplateInstantiator)rbinding).instantiate(arguments);
34	return (IBinding) cf.getCompositeBinding((IIndexFragmentBinding)ins);	35	if (ins instanceof IIndexFragmentBinding) {
		36	return (IBinding) cf.getCompositeBinding((IIndexFragmentBinding)ins);
		37	} else {
		38	//instantiation of an index template can result in a non-index binding
		39	return ins;
		40	}
35	}	41	}
36	}	42	}




 * Contributors:
 * Andrew Ferguson (Symbian) - Initial implementation
 * Markus Schorn (Wind River Systems)
 * Bryan Wilkinson (QNX)
 *******************************************************************************/
package org.eclipse.cdt.internal.core.index.composite;


	public boolean isFileLocal() throws CoreException {
		return rbinding instanceof IIndexBinding ? ((IIndexBinding)rbinding).isFileLocal() : true;
	}
	
	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj instanceof IIndexFragmentBinding)
			return rbinding.equals(obj);
		if (obj instanceof CompositeIndexBinding)
			return rbinding.equals(((CompositeIndexBinding)obj).rbinding);
		
		return super.equals(obj);
	}
}

Lines 73-79 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/PDOM.java (-1 / +2 lines)
73	public class PDOM extends PlatformObject implements IIndexFragment, IPDOM {	73	public class PDOM extends PlatformObject implements IIndexFragment, IPDOM {
74	protected Database db;	74	protected Database db;
75		75
76	public static final int VERSION = 27;	76	public static final int VERSION = 28;
77	// 0 - the beginning of it all	77	// 0 - the beginning of it all
78	// 1 - first change to kick off upgrades	78	// 1 - first change to kick off upgrades
79	// 2 - added file inclusions	79	// 2 - added file inclusions
Lines 102-107 Link Here
102	// 25 - change ordering of bindings (175275)	102	// 25 - change ordering of bindings (175275)
103	// 26 - add properties storage	103	// 26 - add properties storage
104	// 27 - templates: classes, functions, limited nesting support, only template type parameters	104	// 27 - templates: classes, functions, limited nesting support, only template type parameters
		105	// 28 - templates: class instance/specialization base classes
105		106
106	public static final int LINKAGES = Database.DATA_AREA;	107	public static final int LINKAGES = Database.DATA_AREA;
107	public static final int FILE_INDEX = Database.DATA_AREA + 4;	108	public static final int FILE_INDEX = Database.DATA_AREA + 4;




/*******************************************************************************
 * Copyright (c) 2007 QNX Software Systems and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * QNX - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.cpp;

import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.parser.util.ObjectMap;

/**
 * @author Bryan Wilkinson
 * 
 */
public interface ICPPInternalDeferredClassInstance {
	
	/**
	 * instantiate the original template
	 * @return
	 */
	public IType instantiate(ObjectMap argMap);
}




import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.model.ICContainer;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.core.model.ITranslationUnit;

					buffer.append('>');
					result = buffer.toString();
				} else if (element instanceof ICPPSpecialization) {
					ICPPSpecialization spec = (ICPPSpecialization) element;
					PDOMNode parent = ((PDOMNode)element).getParentNode();
					PDOMNode grandParent = parent != null ? parent.getParentNode() : null;
					boolean showArgs = parentOfSpec == null || grandParent == null || !parentOfSpec.equals(grandParent);
					showArgs = showArgs && ((element instanceof ICPPClassType || element instanceof ICPPFunction)
							&& !(element instanceof ICPPTemplateDefinition)); 
					
					StringBuffer buffer = null;
					buffer = new StringBuffer("Spec: "); //$NON-NLS-1$
					buffer.append(result);
					
					if (!(spec instanceof ICPPTemplateDefinition)
							&& spec.getSpecializedBinding() instanceof ICPPTemplateDefinition) {
						ICPPTemplateDefinition template = (ICPPTemplateDefinition) spec.getSpecializedBinding();
						try {
							ICPPTemplateParameter[] params = template.getTemplateParameters();
							buffer.append('<');
							ObjectMap argMap = ((ICPPSpecialization) element).getArgumentMap();
							for (int i = 0; i < params.length; i++) {
								if (i > 0)
									buffer.append(',');
								buffer.append(ASTTypeUtil.getType((IType) argMap.get(params[i])));
							}
							buffer.append('>');
						} catch (DOMException e) {
						}
						buffer.append('>');
					}
					
					result = buffer.toString();

Return to bug 167098

Lines 1038-1043 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPSemantics.java (-4 / +19 lines)
1038	IASTNode parent = ASTInternal.getPhysicalNodeOfScope(scope);	1038	IASTNode parent = ASTInternal.getPhysicalNodeOfScope(scope);
1039	if (parent == null) {	1039	if (parent == null) {
1040	IBinding[] bindings = scope.find(data.astName.toString(), data.prefixLookup);	1040	IBinding[] bindings = scope.find(data.astName.toString(), data.prefixLookup);
		1041	bindings = appendClassType(bindings, scope, data);
1041	mergeResults(data, bindings, true);	1042	mergeResults(data, bindings, true);
1042	useASTResults = false;	1043	useASTResults = false;
1043	} else {	1044	} else {
Lines 1158-1163 Link Here
1158	}	1159	}
1159	}	1160	}
1160		1161
		1162	private static IBinding[] appendClassType(IBinding[] bindings, ICPPScope scope, CPPSemantics.LookupData data) throws DOMException {
		1163	if (scope instanceof ICPPClassScope) {
		1164	IBinding binding = ((ICPPClassScope)scope).getClassType();
		1165	char[] c = binding.getNameCharArray();
		1166	char[] n = data.astName.toCharArray();
		1167	if ((data.prefixLookup && CharArrayUtils.equals(c, 0, n.length, n, true))
		1168	\|\| (!data.prefixLookup && CharArrayUtils.equals(c, n))) {
		1169	return (IBinding[]) ArrayUtil.append(IBinding.class, bindings, binding);
		1170	}
		1171	}
		1172	return bindings;
		1173	}
		1174
1161	private static IScope getParentScope(IScope scope, IASTTranslationUnit unit) throws DOMException {	1175	private static IScope getParentScope(IScope scope, IASTTranslationUnit unit) throws DOMException {
1162	IScope parentScope= scope.getParent();	1176	IScope parentScope= scope.getParent();
1163	// the index cannot return the translation unit as parent scope	1177	// the index cannot return the translation unit as parent scope
Lines 1213-1224 Link Here
1213	//is circular inheritance	1227	//is circular inheritance
1214	if( ! data.inheritanceChain.containsKey( parent ) ){	1228	if( ! data.inheritanceChain.containsKey( parent ) ){
1215	//is this name define in this scope?	1229	//is this name define in this scope?
1216	if( data.astName != null && !data.contentAssist && ASTInternal.isFullyCached(parent) )	1230	if( ASTInternal.isFullyCached(parent) && data.astName != null && !data.contentAssist )
1217	inherited = parent.getBinding( data.astName, true );	1231	inherited = parent.getBinding( data.astName, true );
1218	else if (ASTInternal.getPhysicalNodeOfScope(lookIn) != null	1232	else if (ASTInternal.getPhysicalNodeOfScope(parent) == null) {
1219	&& ASTInternal.getPhysicalNodeOfScope(parent) == null)
1220	inherited = parent.find(data.astName.toString(), data.prefixLookup);	1233	inherited = parent.find(data.astName.toString(), data.prefixLookup);
1221	else	1234	inherited = appendClassType((IBinding[]) inherited, parent, data);
		1235	} else
1222	inherited = lookupInScope( data, parent, null );	1236	inherited = lookupInScope( data, parent, null );
1223		1237
1224	if( inherited == null \|\| data.contentAssist ){	1238	if( inherited == null \|\| data.contentAssist ){
Lines 1617-1622 Link Here
1617	}	1631	}
1618	} else if (ASTInternal.getPhysicalNodeOfScope(temp) == null) {	1632	} else if (ASTInternal.getPhysicalNodeOfScope(temp) == null) {
1619	IBinding[] bindings = temp.find(data.astName.toString(), data.prefixLookup);	1633	IBinding[] bindings = temp.find(data.astName.toString(), data.prefixLookup);
		1634	bindings = appendClassType(bindings, temp, data);
1620	if (bindings != null && bindings.length > 0) {	1635	if (bindings != null && bindings.length > 0) {
1621	mergeResults( data, bindings, true );	1636	mergeResults( data, bindings, true );
1622	found = true;	1637	found = true;

Lines 134-144 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMQualifierType.java (-5 / +43 lines)
134	}	134	}
135		135
136	public Object clone() {	136	public Object clone() {
137	try {	137	return new PDOMQualifierTypeClone(this);
138	return super.clone();	138	}
139	} catch (CloneNotSupportedException e) {	139
140	CCorePlugin.log(e);	140	private static class PDOMQualifierTypeClone implements IQualifierType, ITypeContainer, IIndexType {
141	return null;	141	private final IQualifierType delegate;
		142	private IType type = null;
		143
		144	public PDOMQualifierTypeClone(IQualifierType qualifier) {
		145	this.delegate = qualifier;
		146	}
		147	public IType getType() throws DOMException {
		148	if (type == null) {
		149	return delegate.getType();
		150	}
		151	return type;
		152	}
		153	public boolean isConst() throws DOMException {
		154	return delegate.isConst();
		155	}
		156	public boolean isVolatile() throws DOMException {
		157	return delegate.isVolatile();
		158	}
		159	public boolean isSameType(IType type) {
		160	if( type instanceof ITypedef )
		161	return type.isSameType( this );
		162	if( !( type instanceof IQualifierType ) )
		163	return false;
		164
		165	IQualifierType pt = (IQualifierType) type;
		166	try {
		167	if( isConst() == pt.isConst() && isVolatile() == pt.isVolatile() ) {
		168	IType myType= getType();
		169	return myType != null && myType.isSameType( pt.getType() );
		170	}
		171	} catch (DOMException e) {
		172	}
		173	return false;
		174	}
		175	public void setType(IType type) {
		176	this.type = type;
		177	}
		178	public Object clone() {
		179	return new PDOMQualifierTypeClone(this);
142	}	180	}
143	}	181	}
144	}	182	}

Lines 195-200 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMName.java (+12 lines)
195	}	195	}
196	}	196	}
197		197
		198	public String toString() {
		199	try {
		200	Database db = pdom.getDB();
		201	int bindingRec = db.getInt(record + BINDING_REC_OFFSET);
		202	PDOMBinding binding = pdom.getBinding(bindingRec);
		203	return binding != null ? binding.getName() : null;
		204	} catch (CoreException e) {
		205	CCorePlugin.log(e);
		206	return null;
		207	}
		208	}
		209
198	private byte getFlags(int mask) throws CoreException {	210	private byte getFlags(int mask) throws CoreException {
199	return (byte) (pdom.getDB().getByte(record + FLAGS) & mask);	211	return (byte) (pdom.getDB().getByte(record + FLAGS) & mask);
200	}	212	}

Lines 17-40 Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPClassSpecializationScope.java (-272 / +87 lines)
17		17
18	import org.eclipse.cdt.core.dom.IName;	18	import org.eclipse.cdt.core.dom.IName;
19	import org.eclipse.cdt.core.dom.ast.DOMException;	19	import org.eclipse.cdt.core.dom.ast.DOMException;
20	import org.eclipse.cdt.core.dom.ast.IASTDeclarator;
21	import org.eclipse.cdt.core.dom.ast.IASTName;	20	import org.eclipse.cdt.core.dom.ast.IASTName;
22	import org.eclipse.cdt.core.dom.ast.IASTNode;	21	import org.eclipse.cdt.core.dom.ast.IASTNode;
23	import org.eclipse.cdt.core.dom.ast.IBinding;	22	import org.eclipse.cdt.core.dom.ast.IBinding;
24	import org.eclipse.cdt.core.dom.ast.IScope;	23	import org.eclipse.cdt.core.dom.ast.IScope;
25	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTConversionName;
26	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
27	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope;	24	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope;
28	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;	25	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
29	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;	26	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
30	import org.eclipse.cdt.core.dom.ast.cpp.ICPPConstructor;	27	import org.eclipse.cdt.core.dom.ast.cpp.ICPPConstructor;
31	import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;	28	import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
		29	import org.eclipse.cdt.core.dom.ast.cpp.ICPPScope;
32	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	30	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
33	import org.eclipse.cdt.core.parser.util.ArrayUtil;	31	import org.eclipse.cdt.core.parser.util.ArrayUtil;
34	import org.eclipse.cdt.core.parser.util.CharArrayObjectMap;
35	import org.eclipse.cdt.core.parser.util.CharArrayUtils;	32	import org.eclipse.cdt.core.parser.util.CharArrayUtils;
36	import org.eclipse.cdt.core.parser.util.ObjectMap;	33	import org.eclipse.cdt.core.parser.util.ObjectMap;
37	import org.eclipse.cdt.core.parser.util.ObjectSet;
38	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;	34	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
39	import org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope;	35	import org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope;
40		36
Lines 42-152 Link Here
42	* @author aniefer	38	* @author aniefer
43	*/	39	*/
44	public class CPPClassSpecializationScope implements ICPPClassScope, IASTInternalScope {	40	public class CPPClassSpecializationScope implements ICPPClassScope, IASTInternalScope {
45	private static final char[] CONSTRUCTOR_KEY = "!!!CTOR!!!".toCharArray(); //$NON-NLS-1$
46
47	private CharArrayObjectMap bindings;
48	private ObjectMap instanceMap = ObjectMap.EMPTY_MAP;	41	private ObjectMap instanceMap = ObjectMap.EMPTY_MAP;
49		42	final private ICPPSpecialization specialization;
50	private ICPPSpecialization specialization;
51	private boolean isFullyCached = false;
52	private boolean doneConstructors = false;
53		43
54	/**	44	/**
55	* @param instance	45	* @param instance
56	*/	46	*/
57	public CPPClassSpecializationScope(CPPClassSpecialization specialization ) {	47	public CPPClassSpecializationScope( ICPPSpecialization specialization ) {
58	this.specialization = specialization;	48	this.specialization = specialization;
59	}	49	}
60
61	/**
62	* @param instance
63	*/
64	public CPPClassSpecializationScope(CPPClassInstance instance ) {
65	this.specialization = instance;
66	}
67		50
68	private ICPPClassType getOriginalClass(){	51	private ICPPClassType getOriginalClass(){
69	return (ICPPClassType) specialization.getSpecializedBinding();	52	return (ICPPClassType) specialization.getSpecializedBinding();
70	}	53	}
71	public boolean isFullyCached(){	54
72	if( !isFullyCached ){	55	private IBinding getInstance(IBinding binding) {
73	CPPSemantics.LookupData data = new CPPSemantics.LookupData();	56	if( instanceMap.containsKey( binding ) ) {
74	try {	57	return (IBinding) instanceMap.get( binding );
75	CPPSemantics.lookupInScope( data, this, null );	58	} else if (!(binding instanceof ICPPClassTemplatePartialSpecialization)) {
76	} catch (DOMException e) {	59	IBinding spec = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
77	}	60	if( instanceMap == ObjectMap.EMPTY_MAP )
		61	instanceMap = new ObjectMap(2);
		62	instanceMap.put( binding, spec );
		63	return spec;
78	}	64	}
79	return true;	65	return null;
80	}	66	}
81		67
82	public IBinding getBinding( IASTName name, boolean forceResolve ) {	68	public IBinding getBinding( IASTName name, boolean forceResolve ) throws DOMException {
83	char [] c = name.toCharArray();	69	char [] c = name.toCharArray();
84	if( bindings == null )	70
85	return null;	71	if( CharArrayUtils.equals( c, specialization.getNameCharArray() ) )
86		72	if (!CPPClassScope.isConstructorReference( name ))
87	if( CharArrayUtils.equals( c, specialization.getNameCharArray() ) ){	73	return specialization;
88	if (CPPClassScope.isConstructorReference( name ))	74
89	c = CONSTRUCTOR_KEY;	75	ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
90	else	76	IScope classScope = specialized.getCompositeScope();
91	return specialization;	77	IBinding[] bindings = classScope != null ? classScope.find(name.toString()) : null;
92	}	78
93		79	if (bindings == null) return null;
94	Object cache = bindings.get( c );	80
95	if( cache != null ){	81	IBinding[] specs = new IBinding[0];
96	int i = ( cache instanceof ObjectSet ) ? 0 : -1;	82	for (int i = 0; i < bindings.length; i++) {
97	ObjectSet set = ( cache instanceof ObjectSet ) ? (ObjectSet) cache : null;	83	specs = (IBinding[]) ArrayUtil.append(IBinding.class, specs, getInstance(bindings[i]));
98	Object obj = ( set != null ) ? set.keyAt( i ) : cache;	84	}
99	IBinding [] bs = null;	85	specs = (IBinding[]) ArrayUtil.trim(IBinding.class, specs);
100	IBinding binding = null;	86	return CPPSemantics.resolveAmbiguities( name, specs );
101	while( obj != null ){
102	if( obj instanceof IASTName ){
103	IASTName n = (IASTName) obj;
104	if( n instanceof ICPPASTQualifiedName ){
105	IASTName [] ns = ((ICPPASTQualifiedName)n).getNames();
106	n = ns[ ns.length - 1 ];
107	}
108	if( instanceMap.containsKey( n ) ){
109	binding = (IBinding) instanceMap.get( n );
110	} else {
111	binding = CPPClassScope.shouldResolve(forceResolve, n, name) ? n.resolveBinding() : n.getBinding();
112	if (binding instanceof ICPPClassTemplatePartialSpecialization ){
113	binding = null;
114	}
115	if( binding != null ){
116	binding = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
117	if( instanceMap == ObjectMap.EMPTY_MAP )
118	instanceMap = new ObjectMap(2);
119	instanceMap.put( n, binding );
120	}
121	}
122	} else if( obj instanceof IBinding ){
123	if( instanceMap.containsKey( obj ) ){
124	binding = (IBinding) instanceMap.get( obj );
125	} else {
126	binding = CPPTemplates.createSpecialization( this, (IBinding) obj, specialization.getArgumentMap() );
127	if( instanceMap == ObjectMap.EMPTY_MAP )
128	instanceMap = new ObjectMap(2);
129	instanceMap.put( obj, binding );
130	}
131	}
132	if( binding != null ){
133	if( i == -1 )
134	return binding;
135	bs = (IBinding[]) ArrayUtil.append( IBinding.class, bs, binding );
136	binding = null;
137	}
138	if( i != -1 && ++i < set.size() ){
139	obj = set.keyAt( i );
140	} else {
141	obj = null;
142	}
143	}
144	bs = (IBinding[]) ArrayUtil.trim( IBinding.class, bs );
145	if( bs.length == 1 )
146	return bs[0];
147	return CPPSemantics.resolveAmbiguities( name, bs );
148	}
149	return null;
150	}	87	}
151		88
152	/* (non-Javadoc)	89	/* (non-Javadoc)
Lines 160-287 Link Here
160	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope#getImplicitMethods()	97	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope#getImplicitMethods()
161	*/	98	*/
162	public ICPPMethod[] getImplicitMethods() {	99	public ICPPMethod[] getImplicitMethods() {
163	// TODO Auto-generated method stub	100	//implicit methods shouldn't have implicit specializations
164	return null;	101	return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
165	}	102	}
166		103
167	/* (non-Javadoc)	104	/* (non-Javadoc)
168	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#getScopeName()	105	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#getScopeName()
169	*/	106	*/
170	public IName getScopeName() {	107	public IName getScopeName() {
171	return (IASTName) ((ICPPInternalBinding)specialization).getDefinition();	108	if (specialization instanceof ICPPInternalBinding)
		109	return (IASTName) ((ICPPInternalBinding)specialization).getDefinition();
		110	//TODO: get the scope name for non-internal bindings
		111	return null;
172	}	112	}
173		113
174	public void addName(IASTName name) {	114	protected ICPPConstructor [] getConstructors() throws DOMException {
175	if( name instanceof ICPPASTQualifiedName )	115	ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
176	return;	116	ICPPConstructor[] bindings = specialized.getConstructors();
177		117
178	if( bindings == null )	118	if (bindings == null) return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
179	bindings = new CharArrayObjectMap(1);
180	char [] c = name.toCharArray();
181
182	IASTNode parent = name.getParent();
183	if( parent instanceof IASTDeclarator && CPPVisitor.isConstructor( this, (IASTDeclarator) parent ) ){
184	c = CONSTRUCTOR_KEY;
185	}
186	Object o = bindings.get( c );
187	if( o != null ){
188	if( o instanceof ObjectSet ){
189	((ObjectSet)o).put( name );
190	} else {
191	ObjectSet temp = new ObjectSet( 2 );
192	temp.put( o );
193	temp.put( name );
194	bindings.put( c, temp );
195	}
196	} else {
197	bindings.put( c, name );
198	}
199	}
200
201	protected ICPPConstructor [] getConstructors( ){
202	if( bindings == null )
203	return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
204		119
205	if( !doneConstructors ){	120	ICPPConstructor[] specs = new ICPPConstructor[0];
206	ICPPConstructor[] ctors;	121	for (int i = 0; i < bindings.length; i++) {
207	try {	122	specs = (ICPPConstructor[]) ArrayUtil.append(ICPPConstructor.class, specs, getInstance(bindings[i]));
208	ctors = ((ICPPClassType)specialization.getSpecializedBinding()).getConstructors();
209	for (int i = 0; i < ctors.length; i++) {
210	addBinding( ctors[i] );
211	}
212	doneConstructors = true;
213	} catch (DOMException e) {
214	}
215	}
216	ICPPConstructor[] ctors = CPPClassScope.getConstructors( bindings, true );
217	for (int i = 0; i < ctors.length; i++) {
218	if( instanceMap.containsKey( ctors[i] ) ){
219	ctors[i] = (ICPPConstructor) instanceMap.get( ctors[i] );
220	} else {
221	IBinding b = CPPTemplates.createSpecialization( this, ctors[i], specialization.getArgumentMap() );
222	if( instanceMap == ObjectMap.EMPTY_MAP )
223	instanceMap = new ObjectMap(2);
224	instanceMap.put( ctors[i], b );
225	ctors[i] = (ICPPConstructor) b;
226	}
227	}	123	}
228	return ctors;	124	return (ICPPConstructor[]) ArrayUtil.trim(ICPPConstructor.class, specs);
229	}	125	}
230		126
231	protected ICPPMethod[] getConversionOperators() {	127	protected ICPPMethod[] getConversionOperators() {
232	if( bindings == null )	128	ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
233	return ICPPConstructor.EMPTY_CONSTRUCTOR_ARRAY;
234
235	ICPPMethod [] result = null;
236		129
237	Object[] values = bindings.valueArray();	130	if (!(specialized instanceof ICPPInternalClassType)) {
238	for (int i = 0; i < values.length; i++) {	131	return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
239	int j = ( values[i] instanceof ObjectSet ) ? 0 : -1;
240	ObjectSet set = ( values[i] instanceof ObjectSet ) ? (ObjectSet) values[i] : null;
241	Object obj = ( set != null ) ? set.keyAt( j ) : values[i];
242	IBinding binding = null;
243	while( obj != null ){
244	if( obj instanceof IASTName ){
245	IASTName n = (IASTName) obj;
246	if( n instanceof ICPPASTQualifiedName ){
247	IASTName [] ns = ((ICPPASTQualifiedName)n).getNames();
248	n = ns[ ns.length - 1 ];
249	}
250
251	if (n instanceof ICPPASTConversionName) {
252	if( instanceMap.containsKey( n ) ){
253	binding = (IBinding) instanceMap.get( n );
254	} else {
255	binding = n.resolveBinding();
256	if( binding != null ){
257	binding = CPPTemplates.createSpecialization( this, binding, specialization.getArgumentMap() );
258	if( instanceMap == ObjectMap.EMPTY_MAP )
259	instanceMap = new ObjectMap(2);
260	instanceMap.put( n, binding );
261	}
262	}
263	}
264	}
265	if( binding != null ){
266	result = (ICPPMethod[]) ArrayUtil.append( ICPPMethod.class, result, binding );
267	binding = null;
268	}
269	if( j != -1 && ++j < set.size() ){
270	obj = set.keyAt( j );
271	} else {
272	obj = null;
273	}
274	}
275	}	132	}
		133
		134	ICPPMethod[] bindings = ((ICPPInternalClassType)specialized).getConversionOperators();
276		135
277	return (ICPPMethod[]) ArrayUtil.trim( ICPPMethod.class, result );	136	if (bindings == null) return ICPPMethod.EMPTY_CPPMETHOD_ARRAY;
278	}	137
279		138	ICPPMethod[] specs = new ICPPMethod[0];
280	/* (non-Javadoc)	139	for (int i = 0; i < bindings.length; i++) {
281	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#setFullyCached(boolean)	140	specs = (ICPPMethod[]) ArrayUtil.append(ICPPMethod.class, specs, getInstance(bindings[i]));
282	*/	141	}
283	public void setFullyCached(boolean b) {	142	return (ICPPMethod[]) ArrayUtil.trim(ICPPMethod.class, specs);
284	isFullyCached = b;
285	}	143	}
286		144
287	/* (non-Javadoc)	145	/* (non-Javadoc)
Lines 303-391 Link Here
303	/* (non-Javadoc)	161	/* (non-Javadoc)
304	* @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)	162	* @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)
305	*/	163	*/
306	public IBinding[] find(String name) {	164	public IBinding[] find(String name) throws DOMException {
307	return find(name, false);	165	return find(name, false);
308	}	166	}
309		167
310	/* (non-Javadoc)	168	/* (non-Javadoc)
311	* @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)	169	* @see org.eclipse.cdt.core.dom.ast.IScope#find(java.lang.String)
312	*/	170	*/
313	public IBinding[] find(String name, boolean prefixLookup) {	171	public IBinding[] find(String name, boolean prefixLookup) throws DOMException {
314	if( name != null ) {}	172	ICPPClassType specialized = (ICPPClassType) specialization.getSpecializedBinding();
315	return null;	173	IBinding[] bindings = specialized.getCompositeScope().find(name.toString(), prefixLookup);
		174
		175	if (bindings == null) return null;
		176
		177	IBinding[] specs = new IBinding[0];
		178	for (int i = 0; i < bindings.length; i++) {
		179	specs = (IBinding[]) ArrayUtil.append(IBinding.class, specs, getInstance(bindings[i]));
		180	}
		181	return (IBinding[]) ArrayUtil.trim(IBinding.class, specs);
316	}	182	}
317		183
318	/* (non-Javadoc)	184	/* (non-Javadoc)
319	* @see org.eclipse.cdt.core.dom.ast.IScope#getPhysicalNode()	185	* @see org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope#isFullyCached()
320	*/	186	*/
321	public IASTNode getPhysicalNode() throws DOMException {	187	public boolean isFullyCached() throws DOMException {
322	ICPPClassType cls = getOriginalClass();	188	ICPPScope origScope = (ICPPScope) getOriginalClass().getCompositeScope();
323	ICPPClassScope scope = (ICPPClassScope)cls.getCompositeScope();	189	if (!ASTInternal.isFullyCached(origScope)) {
324		190	CPPSemantics.LookupData data = new CPPSemantics.LookupData();
325	IASTNode node= ASTInternal.getPhysicalNodeOfScope(scope);	191	try {
326	if (node != null) {	192	CPPSemantics.lookupInScope( data, origScope, null );
327	return node;	193	} catch (DOMException e) {
		194	}
328	}	195	}
329		196	return true;
330	IASTNode[] nds= ASTInternal.getDeclarationsOfBinding(cls);
331
332	if( nds != null && nds.length > 0 )
333	return nds[0];
334
335	return null;
336	}
337
338	/* (non-Javadoc)
339	* @see org.eclipse.cdt.core.dom.ast.cpp.ICPPScope#removeBinding(org.eclipse.cdt.core.dom.ast.IBinding)
340	*/
341	public void removeBinding(IBinding binding) {
342	char [] name = binding.getNameCharArray();
343	if( ! bindings.containsKey( name ) )
344	return;
345
346	Object obj = bindings.get( name );
347	if( obj instanceof ObjectSet ){
348	ObjectSet set = (ObjectSet) obj;
349	set.remove( binding );
350	if( set.size() == 0 )
351	bindings.remove( name, 0, name.length );
352	} else {
353	bindings.remove( name, 0, name.length );
354	}
355
356	if( instanceMap != null && instanceMap.containsKey( binding ) )
357	instanceMap.remove( binding );
358	isFullyCached = false;
359	}
360
361	public void flushCache() {
362	if( bindings != null )
363	bindings.clear();
364	isFullyCached = false;
365	}
366
367	public void addBinding(IBinding binding) {
368	if( bindings == null )
369	bindings = new CharArrayObjectMap(1);
370	char [] c = (binding instanceof ICPPConstructor) ? CONSTRUCTOR_KEY : binding.getNameCharArray();
371	Object o = bindings.get( c );
372	if( o != null ){
373	if( o instanceof ObjectSet ){
374	((ObjectSet)o).put( binding );
375	} else {
376	ObjectSet set = new ObjectSet(2);
377	set.put( o );
378	set.put( binding );
379	bindings.put( c, set );
380	}
381	} else {
382	bindings.put( c, binding );
383	}
384	}	197	}
385		198
386	public IBinding getInstance( IBinding binding ){	199	//this scope does not cache its own names
387	if( instanceMap != null && instanceMap.containsKey( binding ) )	200	public void setFullyCached(boolean b) {}
388	return (IBinding) instanceMap.get( binding );	201	public void flushCache() {}
389	return null;	202	public void addName(IASTName name) {}
390	}	203	public IASTNode getPhysicalNode() {return null;}
		204	public void removeBinding(IBinding binding) {}
		205	public void addBinding(IBinding binding) {}
391	}	206	}

Lines 17-32 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPFunctionTemplate.java (-2 / +50 lines)
17	import org.eclipse.cdt.core.dom.IPDOMNode;	17	import org.eclipse.cdt.core.dom.IPDOMNode;
18	import org.eclipse.cdt.core.dom.IPDOMVisitor;	18	import org.eclipse.cdt.core.dom.IPDOMVisitor;
19	import org.eclipse.cdt.core.dom.ast.DOMException;	19	import org.eclipse.cdt.core.dom.ast.DOMException;
		20	import org.eclipse.cdt.core.dom.ast.IASTName;
20	import org.eclipse.cdt.core.dom.ast.IBinding;	21	import org.eclipse.cdt.core.dom.ast.IBinding;
21	import org.eclipse.cdt.core.dom.ast.IType;	22	import org.eclipse.cdt.core.dom.ast.IType;
22	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;	23	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
23	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionTemplate;	24	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionTemplate;
24	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	25	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
		26	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
25	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;	27	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
26	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;	28	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
		29	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateScope;
		30	import org.eclipse.cdt.core.index.IIndexBinding;
		31	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPSemantics;
		32	import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplates;
27	import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalTemplateInstantiator;	33	import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalTemplateInstantiator;
		34	import org.eclipse.cdt.internal.core.index.IIndexScope;
28	import org.eclipse.cdt.internal.core.pdom.PDOM;	35	import org.eclipse.cdt.internal.core.pdom.PDOM;
29	import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;	36	import org.eclipse.cdt.internal.core.pdom.db.PDOMNodeLinkedList;
		37	import org.eclipse.cdt.internal.core.pdom.dom.BindingCollector;
30	import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;	38	import org.eclipse.cdt.internal.core.pdom.dom.IPDOMMemberOwner;
31	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;	39	import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode;
32	import org.eclipse.core.runtime.CoreException;	40	import org.eclipse.core.runtime.CoreException;
Lines 37-43 Link Here
37	*/	45	*/
38	public class PDOMCPPFunctionTemplate extends PDOMCPPFunction implements	46	public class PDOMCPPFunctionTemplate extends PDOMCPPFunction implements
39	ICPPFunctionTemplate, ICPPInternalTemplateInstantiator,	47	ICPPFunctionTemplate, ICPPInternalTemplateInstantiator,
40	IPDOMMemberOwner {	48	IPDOMMemberOwner, ICPPTemplateScope, IIndexScope {
41		49
42	private static final int TEMPLATE_PARAMS = PDOMCPPFunction.RECORD_SIZE + 0;	50	private static final int TEMPLATE_PARAMS = PDOMCPPFunction.RECORD_SIZE + 0;
43	private static final int INSTANCES = PDOMCPPFunction.RECORD_SIZE + 4;	51	private static final int INSTANCES = PDOMCPPFunction.RECORD_SIZE + 4;
Lines 140-146 Link Here
140	}	148	}
141		149
142	public IBinding instantiate(IType[] arguments) {	150	public IBinding instantiate(IType[] arguments) {
143	return getInstance(arguments);	151	return CPPTemplates.instantiateTemplate(this, arguments, null);
144	}	152	}
145		153
146	public void addChild(PDOMNode child) throws CoreException {	154	public void addChild(PDOMNode child) throws CoreException {
Lines 167-170 Link Here
167	list = new PDOMNodeLinkedList(pdom, record + INSTANCES, getLinkageImpl());	175	list = new PDOMNodeLinkedList(pdom, record + INSTANCES, getLinkageImpl());
168	list.accept(visitor);	176	list.accept(visitor);
169	}	177	}
		178
		179	public ICPPTemplateDefinition getTemplateDefinition() throws DOMException {
		180	return this;
		181	}
		182
		183	public IBinding[] find(String name) throws DOMException {
		184	return find(name, false);
		185	}
		186
		187	public IBinding[] find(String name, boolean prefixLookup)
		188	throws DOMException {
		189	try {
		190	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray(), null, prefixLookup, !prefixLookup);
		191	PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl());
		192	list.accept(visitor);
		193
		194	return visitor.getBindings();
		195	} catch (CoreException e) {
		196	CCorePlugin.log(e);
		197	}
		198	return null;
		199	}
		200
		201	public IBinding getBinding(IASTName name, boolean resolve)
		202	throws DOMException {
		203	try {
		204	BindingCollector visitor = new BindingCollector(getLinkageImpl(), name.toCharArray());
		205	PDOMNodeLinkedList list = new PDOMNodeLinkedList(pdom, record + TEMPLATE_PARAMS, getLinkageImpl());
		206	list.accept(visitor);
		207
		208	return CPPSemantics.resolveAmbiguities(name, visitor.getBindings());
		209	} catch (CoreException e) {
		210	CCorePlugin.log(e);
		211	}
		212	return null;
		213	}
		214
		215	public IIndexBinding getScopeBinding() {
		216	return this;
		217	}
170	}	218	}

Added Link Here

(-)parser/org/eclipse/cdt/internal/core/dom/parser/cpp/ICPPInternalDeferredClassInstance.java (+27 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* QNX - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.dom.parser.cpp;
12
13	import org.eclipse.cdt.core.dom.ast.IType;
14	import org.eclipse.cdt.core.parser.util.ObjectMap;
15
16	/**
17	* @author Bryan Wilkinson
18	*
19	*/
20	public interface ICPPInternalDeferredClassInstance {
21
22	/**
23	* instantiate the original template
24	* @return
25	*/
26	public IType instantiate(ObjectMap argMap);
27	}

Lines 34-44 Link Here

(-)src/org/eclipse/cdt/internal/ui/IndexLabelProvider.java (-15 / +16 lines)
34	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;	34	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplatePartialSpecialization;
35	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;	35	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
36	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;	36	import org.eclipse.cdt.core.dom.ast.cpp.ICPPDeferredTemplateInstance;
37	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
38	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;	37	import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace;
39	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;	38	import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
40	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;	39	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
41	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;	40	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
		41	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
42	import org.eclipse.cdt.core.model.ICContainer;	42	import org.eclipse.cdt.core.model.ICContainer;
43	import org.eclipse.cdt.core.model.ICProject;	43	import org.eclipse.cdt.core.model.ICProject;
44	import org.eclipse.cdt.core.model.ITranslationUnit;	44	import org.eclipse.cdt.core.model.ITranslationUnit;
Lines 97-122 Link Here
97	buffer.append('>');	97	buffer.append('>');
98	result = buffer.toString();	98	result = buffer.toString();
99	} else if (element instanceof ICPPSpecialization) {	99	} else if (element instanceof ICPPSpecialization) {
100	PDOMNode parentOfSpec = ((PDOMNode)((ICPPSpecialization)element).getSpecializedBinding()).getParentNode();	100	ICPPSpecialization spec = (ICPPSpecialization) element;
101	PDOMNode parent = ((PDOMNode)element).getParentNode();
102	PDOMNode grandParent = parent != null ? parent.getParentNode() : null;
103	boolean showArgs = parentOfSpec == null \|\| grandParent == null \|\| !parentOfSpec.equals(grandParent);
104	showArgs = showArgs && ((element instanceof ICPPClassType \|\| element instanceof ICPPFunction)
105	&& !(element instanceof ICPPTemplateDefinition));
106		101
107	StringBuffer buffer = null;	102	StringBuffer buffer = null;
108	buffer = new StringBuffer("Spec: "); //$NON-NLS-1$	103	buffer = new StringBuffer("Spec: "); //$NON-NLS-1$
109	buffer.append(result);	104	buffer.append(result);
110		105
111	if (showArgs) {	106	if (!(spec instanceof ICPPTemplateDefinition)
112	buffer.append('<');	107	&& spec.getSpecializedBinding() instanceof ICPPTemplateDefinition) {
113	ObjectMap argMap = ((ICPPSpecialization) element).getArgumentMap();	108	ICPPTemplateDefinition template = (ICPPTemplateDefinition) spec.getSpecializedBinding();
114	for (int i = 0; i < argMap.size(); i++) {	109	try {
115	if (i > 0)	110	ICPPTemplateParameter[] params = template.getTemplateParameters();
116	buffer.append(',');	111	buffer.append('<');
117	buffer.append(ASTTypeUtil.getType((IType) argMap.getAt(i)));	112	ObjectMap argMap = ((ICPPSpecialization) element).getArgumentMap();
		113	for (int i = 0; i < params.length; i++) {
		114	if (i > 0)
		115	buffer.append(',');
		116	buffer.append(ASTTypeUtil.getType((IType) argMap.get(params[i])));
		117	}
		118	buffer.append('>');
		119	} catch (DOMException e) {
118	}	120	}
119	buffer.append('>');
120	}	121	}
121		122
122	result = buffer.toString();	123	result = buffer.toString();