core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPTemplateDefinition.java - cdt/org.eclipse.cdt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2014 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
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Andrew Niefer (IBM Corporation) - Initial API and implementation
  *    Markus Schorn (Wind River Systems)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.cpp;

 import org.eclipse.cdt.core.dom.ILinkage;
 import org.eclipse.cdt.core.dom.ast.ASTNodeProperty;
 import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
 import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
 import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
 import org.eclipse.cdt.core.dom.ast.IASTElaboratedTypeSpecifier;
 import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
 import org.eclipse.cdt.core.dom.ast.IASTName;
 import org.eclipse.cdt.core.dom.ast.IASTNode;
 import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
 import org.eclipse.cdt.core.dom.ast.IBinding;
 import org.eclipse.cdt.core.dom.ast.IScope;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTElaboratedTypeSpecifier;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateParameter;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument;
 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.index.IIndex;
 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.Linkage;
 import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
 import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
 import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
 import org.eclipse.core.runtime.PlatformObject;

 public abstract class CPPTemplateDefinition extends PlatformObject implements ICPPTemplateDefinition, ICPPInternalTemplate {
 	public static final class CPPTemplateProblem extends ProblemBinding implements ICPPTemplateDefinition {
 		public CPPTemplateProblem(IASTNode node, int id, char[] arg) {
 			super(node, id, arg);
 		}

 		@Override
 		public ICPPTemplateParameter[] getTemplateParameters() {
 			return ICPPTemplateParameter.EMPTY_TEMPLATE_PARAMETER_ARRAY;
 		}
 	}

 	protected IASTName[] declarations;
 	protected IASTName definition;

 	private ICPPTemplateParameter[] templateParameters;
 	private ObjectMap instances;

 	private ICPPClassTemplate indexBinding;
 	private boolean checkedIndex;


 	public CPPTemplateDefinition(IASTName name) {
 		if (name != null) {
 			ASTNodeProperty prop = name.getPropertyInParent();
 			if (prop == ICPPASTQualifiedName.SEGMENT_NAME) {
 				prop = name.getParent().getPropertyInParent();
 			}
 			if (prop == IASTCompositeTypeSpecifier.TYPE_NAME) {
 				definition = name;
 			} else if (prop == IASTElaboratedTypeSpecifier.TYPE_NAME) {
 				declarations = new IASTName[] { name };
 			} else {
 				IASTNode parent = name.getParent();
 				while (!(parent instanceof IASTDeclaration))
 					parent = parent.getParent();
 				if (parent instanceof IASTFunctionDefinition) {
 					definition = name;
 				} else {
 					declarations = new IASTName[] { name };
 				}
 			}
 		}
 	}

 	@Override
 	public final void addInstance(ICPPTemplateArgument[] arguments, ICPPTemplateInstance instance) {
 		if (instances == null)
 			instances = new ObjectMap(2);
 		String key= ASTTypeUtil.getArgumentListString(arguments, true);
 		instances.put(key, instance);
 	}

 	@Override
 	public final ICPPTemplateInstance getInstance(ICPPTemplateArgument[] arguments) {
 		if (instances != null) {
 			String key= ASTTypeUtil.getArgumentListString(arguments, true);
 			ICPPTemplateInstance cand = (ICPPTemplateInstance) instances.get(key);
 			if (cand != null)
 				return cand;
 		}

 		final ICPPClassTemplate ib = getIndexBinding();
 		if (ib instanceof ICPPInstanceCache) {
 			ICPPTemplateInstance cand= ((ICPPInstanceCache) ib).getInstance(arguments);
 			if (cand instanceof IIndexBinding) {
 				if (getTemplateName().getTranslationUnit().getIndexFileSet().containsDeclaration((IIndexBinding) cand)) {
 					return cand;
 				}
 			} else {
 				return cand;
 			}
 		}
 		return null;
 	}

 	protected ICPPClassTemplate getIndexBinding() {
 		if (!checkedIndex) {
 			checkedIndex= true;
 			IASTName name= getTemplateName();
 			if (name != null) {
 				IASTTranslationUnit tu = name.getTranslationUnit();
 				if (tu != null) {
 					IIndex index= tu.getIndex();
 					if (index != null) {
 						IIndexBinding ib = index.adaptBinding(this);
 						if (ib instanceof ICPPClassTemplate)
 							indexBinding= (ICPPClassTemplate) ib;
 					}
 				}
 			}
 		}
 		return indexBinding;
 	}

 	@Override
 	public ICPPTemplateInstance[] getAllInstances() {
 		if (instances != null) {
 			ICPPTemplateInstance[] result= new ICPPTemplateInstance[instances.size()];
 			for (int i= 0; i < instances.size(); i++) {
 				result[i]= (ICPPTemplateInstance) instances.getAt(i);
 			}
 			return result;
 		}
 		return ICPPTemplateInstance.EMPTY_TEMPLATE_INSTANCE_ARRAY;
 	}

 	public IASTName getTemplateName() {
 		if (definition != null)
 			return definition;
 		if (declarations != null && declarations.length > 0)
 			return declarations[0];
 		return null;
 	}

 	@Override
 	public String getName() {
 		return new String(getNameCharArray());
 	}

 	@Override
 	public char[] getNameCharArray() {
 		return getTemplateName().getSimpleID();
 	}

 	@Override
 	public IScope getScope() {
 		return CPPVisitor.getContainingScope(getTemplateName());
 	}

 	@Override
 	public String[] getQualifiedName() {
 		return CPPVisitor.getQualifiedName(this);
 	}

 	@Override
 	public char[][] getQualifiedNameCharArray() {
 		return CPPVisitor.getQualifiedNameCharArray(this);
 	}

 	@Override
 	public boolean isGloballyQualified() {
 		return true;
 	}

 	@Override
 	public ICPPTemplateParameter[] getTemplateParameters() {
 		if (templateParameters == null) {
 			ICPPTemplateParameter[] result = ICPPTemplateParameter.EMPTY_TEMPLATE_PARAMETER_ARRAY;
 			ICPPASTTemplateDeclaration template = CPPTemplates.getTemplateDeclaration(getTemplateName());
 			if (template != null) {
 				ICPPASTTemplateParameter[] params = template.getTemplateParameters();
 				for (ICPPASTTemplateParameter param : params) {
 					IBinding p= CPPTemplates.getTemplateParameterName(param).resolveBinding();
 					if (p instanceof ICPPTemplateParameter) {
 						result = ArrayUtil.append(result, (ICPPTemplateParameter) p);
 					}
 				}
 			}
 			templateParameters = ArrayUtil.trim(result);
 		}
 		return templateParameters;
 	}

 	@Override
 	public void addDefinition(IASTNode node) {
 	    if (node instanceof ICPPASTCompositeTypeSpecifier) {
 	        node = ((ICPPASTCompositeTypeSpecifier) node).getName();
 	        if (node instanceof ICPPASTQualifiedName) {
 	            node = ((ICPPASTQualifiedName) node).getLastName();
 	        }
 	    }
 		if (!(node instanceof IASTName))
 			return;
 		updateTemplateParameterBindings((IASTName) node);
 		definition = (IASTName) node;
 	}

 	@Override
 	public void addDeclaration(IASTNode node) {
 	    if (node instanceof ICPPASTElaboratedTypeSpecifier) {
 	        node = ((ICPPASTElaboratedTypeSpecifier) node).getName();
 	        if (node instanceof ICPPASTQualifiedName) {
 	            node = ((ICPPASTQualifiedName) node).getLastName();
 	        }
 	    }
 		if (!(node instanceof IASTName))
 			return;
 		IASTName declName = (IASTName) node;
 		updateTemplateParameterBindings(declName);
 		if (declarations == null) {
 	        declarations = new IASTName[] { declName };
 		} else {
 	        // Keep the lowest offset declaration in [0].
 			if (declarations.length > 0 && ((ASTNode) node).getOffset() < ((ASTNode) declarations[0]).getOffset()) {
 				declarations = ArrayUtil.prepend(IASTName.class, declarations, declName);
 			} else {
 				declarations = ArrayUtil.append(IASTName.class, declarations, declName);
 			}
 	    }
 	}

 	@Override
 	public IBinding resolveTemplateParameter(ICPPTemplateParameter templateParameter) {
 		int pos= templateParameter.getParameterPosition();

     	int tdeclLen= declarations == null ? 0 : declarations.length;
     	for (int i= -1; i < tdeclLen; i++) {
     		IASTName tdecl;
     		if (i == -1) {
     			tdecl= definition;
     			if (tdecl == null)
     				continue;
     		} else {
     			tdecl= declarations[i];
     			if (tdecl == null)
     				break;
     		}

     		ICPPASTTemplateParameter[] params = CPPTemplates.getTemplateDeclaration(tdecl).getTemplateParameters();
     		if (pos < params.length) {
     			final IASTName oName = CPPTemplates.getTemplateParameterName(params[pos]);
     			return oName.resolvePreBinding();
     		}
     	}
     	return templateParameter;
 	}

 	final protected void updateTemplateParameterBindings(IASTName name) {
     	final ICPPASTTemplateDeclaration templateDeclaration = CPPTemplates.getTemplateDeclaration(name);
     	if (templateDeclaration == null)
     		return;

 		ICPPASTTemplateParameter[] updateParams = templateDeclaration.getTemplateParameters();
     	int k= 0;
     	int tdeclLen= declarations == null ? 0 : declarations.length;
     	for (int i= -1; i < tdeclLen && k < updateParams.length; i++) {
     		IASTName tdecl;
     		if (i == -1) {
     			tdecl= definition;
     			if (tdecl == null)
     				continue;
     		} else {
     			tdecl= declarations[i];
     			if (tdecl == null)
     				break;
     		}

     		ICPPASTTemplateParameter[] params = CPPTemplates.getTemplateDeclaration(tdecl).getTemplateParameters();
     		int end= Math.min(params.length, updateParams.length);
     		for (; k < end; k++) {
     			final IASTName oName = CPPTemplates.getTemplateParameterName(params[k]);
     			IBinding b= oName.resolvePreBinding();
     			IASTName n = CPPTemplates.getTemplateParameterName(updateParams[k]);
     			n.setBinding(b);
     			ASTInternal.addDeclaration(b, n);
     		}
     	}
     }

 	@Override
 	public IASTNode[] getDeclarations() {
 		return declarations;
 	}

 	@Override
 	public IASTNode getDefinition() {
 		return definition;
 	}

 	@Override
 	public ILinkage getLinkage() {
 		return Linkage.CPP_LINKAGE;
 	}

 	@Override
 	public final IBinding getOwner() {
 		IASTName templateName= getTemplateName();
 		if (templateName == null)
 			return null;

 		return CPPVisitor.findNameOwner(templateName, false);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2014 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
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Andrew Niefer (IBM Corporation) - Initial API and implementation
	* Markus Schorn (Wind River Systems)
	*******************************************************************************/
	package org.eclipse.cdt.internal.core.dom.parser.cpp;

	import org.eclipse.cdt.core.dom.ILinkage;
	import org.eclipse.cdt.core.dom.ast.ASTNodeProperty;
	import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
	import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
	import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
	import org.eclipse.cdt.core.dom.ast.IASTElaboratedTypeSpecifier;
	import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
	import org.eclipse.cdt.core.dom.ast.IASTName;
	import org.eclipse.cdt.core.dom.ast.IASTNode;
	import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
	import org.eclipse.cdt.core.dom.ast.IBinding;
	import org.eclipse.cdt.core.dom.ast.IScope;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTElaboratedTypeSpecifier;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateParameter;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate;
	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument;
	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.index.IIndex;
	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.Linkage;
	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
	import org.eclipse.cdt.internal.core.dom.parser.ASTNode;
	import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding;
	import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPTemplates;
	import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
	import org.eclipse.core.runtime.PlatformObject;

	public abstract class CPPTemplateDefinition extends PlatformObject implements ICPPTemplateDefinition, ICPPInternalTemplate {
	public static final class CPPTemplateProblem extends ProblemBinding implements ICPPTemplateDefinition {
	public CPPTemplateProblem(IASTNode node, int id, char[] arg) {
	super(node, id, arg);
	}

	@Override
	public ICPPTemplateParameter[] getTemplateParameters() {
	return ICPPTemplateParameter.EMPTY_TEMPLATE_PARAMETER_ARRAY;
	}
	}

	protected IASTName[] declarations;
	protected IASTName definition;

	private ICPPTemplateParameter[] templateParameters;
	private ObjectMap instances;

	private ICPPClassTemplate indexBinding;
	private boolean checkedIndex;


	public CPPTemplateDefinition(IASTName name) {
	if (name != null) {
	ASTNodeProperty prop = name.getPropertyInParent();
	if (prop == ICPPASTQualifiedName.SEGMENT_NAME) {
	prop = name.getParent().getPropertyInParent();
	}
	if (prop == IASTCompositeTypeSpecifier.TYPE_NAME) {
	definition = name;
	} else if (prop == IASTElaboratedTypeSpecifier.TYPE_NAME) {
	declarations = new IASTName[] { name };
	} else {
	IASTNode parent = name.getParent();
	while (!(parent instanceof IASTDeclaration))
	parent = parent.getParent();
	if (parent instanceof IASTFunctionDefinition) {
	definition = name;
	} else {
	declarations = new IASTName[] { name };
	}
	}
	}
	}

	@Override
	public final void addInstance(ICPPTemplateArgument[] arguments, ICPPTemplateInstance instance) {
	if (instances == null)
	instances = new ObjectMap(2);
	String key= ASTTypeUtil.getArgumentListString(arguments, true);
	instances.put(key, instance);
	}

	@Override
	public final ICPPTemplateInstance getInstance(ICPPTemplateArgument[] arguments) {
	if (instances != null) {
	String key= ASTTypeUtil.getArgumentListString(arguments, true);
	ICPPTemplateInstance cand = (ICPPTemplateInstance) instances.get(key);
	if (cand != null)
	return cand;
	}

	final ICPPClassTemplate ib = getIndexBinding();
	if (ib instanceof ICPPInstanceCache) {
	ICPPTemplateInstance cand= ((ICPPInstanceCache) ib).getInstance(arguments);
	if (cand instanceof IIndexBinding) {
	if (getTemplateName().getTranslationUnit().getIndexFileSet().containsDeclaration((IIndexBinding) cand)) {
	return cand;
	}
	} else {
	return cand;
	}
	}
	return null;
	}

	protected ICPPClassTemplate getIndexBinding() {
	if (!checkedIndex) {
	checkedIndex= true;
	IASTName name= getTemplateName();
	if (name != null) {
	IASTTranslationUnit tu = name.getTranslationUnit();
	if (tu != null) {
	IIndex index= tu.getIndex();
	if (index != null) {
	IIndexBinding ib = index.adaptBinding(this);
	if (ib instanceof ICPPClassTemplate)
	indexBinding= (ICPPClassTemplate) ib;
	}
	}
	}
	}
	return indexBinding;
	}

	@Override
	public ICPPTemplateInstance[] getAllInstances() {
	if (instances != null) {
	ICPPTemplateInstance[] result= new ICPPTemplateInstance[instances.size()];
	for (int i= 0; i < instances.size(); i++) {
	result[i]= (ICPPTemplateInstance) instances.getAt(i);
	}
	return result;
	}
	return ICPPTemplateInstance.EMPTY_TEMPLATE_INSTANCE_ARRAY;
	}

	public IASTName getTemplateName() {
	if (definition != null)
	return definition;
	if (declarations != null && declarations.length > 0)
	return declarations[0];
	return null;
	}

	@Override
	public String getName() {
	return new String(getNameCharArray());
	}

	@Override
	public char[] getNameCharArray() {
	return getTemplateName().getSimpleID();
	}

	@Override
	public IScope getScope() {
	return CPPVisitor.getContainingScope(getTemplateName());
	}

	@Override
	public String[] getQualifiedName() {
	return CPPVisitor.getQualifiedName(this);
	}

	@Override
	public char[][] getQualifiedNameCharArray() {
	return CPPVisitor.getQualifiedNameCharArray(this);
	}

	@Override
	public boolean isGloballyQualified() {
	return true;
	}

	@Override
	public ICPPTemplateParameter[] getTemplateParameters() {
	if (templateParameters == null) {
	ICPPTemplateParameter[] result = ICPPTemplateParameter.EMPTY_TEMPLATE_PARAMETER_ARRAY;
	ICPPASTTemplateDeclaration template = CPPTemplates.getTemplateDeclaration(getTemplateName());
	if (template != null) {
	ICPPASTTemplateParameter[] params = template.getTemplateParameters();
	for (ICPPASTTemplateParameter param : params) {
	IBinding p= CPPTemplates.getTemplateParameterName(param).resolveBinding();
	if (p instanceof ICPPTemplateParameter) {
	result = ArrayUtil.append(result, (ICPPTemplateParameter) p);
	}
	}
	}
	templateParameters = ArrayUtil.trim(result);
	}
	return templateParameters;
	}

	@Override
	public void addDefinition(IASTNode node) {
	if (node instanceof ICPPASTCompositeTypeSpecifier) {
	node = ((ICPPASTCompositeTypeSpecifier) node).getName();
	if (node instanceof ICPPASTQualifiedName) {
	node = ((ICPPASTQualifiedName) node).getLastName();
	}
	}
	if (!(node instanceof IASTName))
	return;
	updateTemplateParameterBindings((IASTName) node);
	definition = (IASTName) node;
	}

	@Override
	public void addDeclaration(IASTNode node) {
	if (node instanceof ICPPASTElaboratedTypeSpecifier) {
	node = ((ICPPASTElaboratedTypeSpecifier) node).getName();
	if (node instanceof ICPPASTQualifiedName) {
	node = ((ICPPASTQualifiedName) node).getLastName();
	}
	}
	if (!(node instanceof IASTName))
	return;
	IASTName declName = (IASTName) node;
	updateTemplateParameterBindings(declName);
	if (declarations == null) {
	declarations = new IASTName[] { declName };
	} else {
	// Keep the lowest offset declaration in [0].
	if (declarations.length > 0 && ((ASTNode) node).getOffset() < ((ASTNode) declarations[0]).getOffset()) {
	declarations = ArrayUtil.prepend(IASTName.class, declarations, declName);
	} else {
	declarations = ArrayUtil.append(IASTName.class, declarations, declName);
	}
	}
	}

	@Override
	public IBinding resolveTemplateParameter(ICPPTemplateParameter templateParameter) {
	int pos= templateParameter.getParameterPosition();

	int tdeclLen= declarations == null ? 0 : declarations.length;
	for (int i= -1; i < tdeclLen; i++) {
	IASTName tdecl;
	if (i == -1) {
	tdecl= definition;
	if (tdecl == null)
	continue;
	} else {
	tdecl= declarations[i];
	if (tdecl == null)
	break;
	}

	ICPPASTTemplateParameter[] params = CPPTemplates.getTemplateDeclaration(tdecl).getTemplateParameters();
	if (pos < params.length) {
	final IASTName oName = CPPTemplates.getTemplateParameterName(params[pos]);
	return oName.resolvePreBinding();
	}
	}
	return templateParameter;
	}

	final protected void updateTemplateParameterBindings(IASTName name) {
	final ICPPASTTemplateDeclaration templateDeclaration = CPPTemplates.getTemplateDeclaration(name);
	if (templateDeclaration == null)
	return;

	ICPPASTTemplateParameter[] updateParams = templateDeclaration.getTemplateParameters();
	int k= 0;
	int tdeclLen= declarations == null ? 0 : declarations.length;
	for (int i= -1; i < tdeclLen && k < updateParams.length; i++) {
	IASTName tdecl;
	if (i == -1) {
	tdecl= definition;
	if (tdecl == null)
	continue;
	} else {
	tdecl= declarations[i];
	if (tdecl == null)
	break;
	}

	ICPPASTTemplateParameter[] params = CPPTemplates.getTemplateDeclaration(tdecl).getTemplateParameters();
	int end= Math.min(params.length, updateParams.length);
	for (; k < end; k++) {
	final IASTName oName = CPPTemplates.getTemplateParameterName(params[k]);
	IBinding b= oName.resolvePreBinding();
	IASTName n = CPPTemplates.getTemplateParameterName(updateParams[k]);
	n.setBinding(b);
	ASTInternal.addDeclaration(b, n);
	}
	}
	}

	@Override
	public IASTNode[] getDeclarations() {
	return declarations;
	}

	@Override
	public IASTNode getDefinition() {
	return definition;
	}

	@Override
	public ILinkage getLinkage() {
	return Linkage.CPP_LINKAGE;
	}

	@Override
	public final IBinding getOwner() {
	IASTName templateName= getTemplateName();
	if (templateName == null)
	return null;

	return CPPVisitor.findNameOwner(templateName, false);
	}
	}