From fc1e9a42257bf4668d24f9d5ab12ef8ff9324ebf Mon Sep 17 00:00:00 2001 From: Thomas Corbat Date: Sun, 25 Nov 2012 14:49:14 -0800 Subject: [PATCH] Bug 374694. Implementation of alias templates. --- .../core/parser/tests/ast2/AST2BaseTest.java | 28 +- .../core/parser/tests/ast2/AST2CPPTests.java | 25 +- .../parser/tests/ast2/AST2TemplateTests.java | 541 ++++++++++++++++++ .../pdom/tests/CPPClassTemplateTests.java | 248 ++++++++ .../rewrite/ASTWriterTemplateTestSource.awts | 8 +- .../.settings/.api_filters | 33 ++ .../dom/ast/cpp/ICPPASTAliasDeclaration.java | 78 +++ .../cdt/core/dom/ast/cpp/ICPPASTTypeId.java | 6 + .../core/dom/ast/cpp/ICPPAliasTemplate.java | 27 + .../ast/cpp/ICPPAliasTemplateInstance.java | 27 + .../cdt/core/dom/ast/cpp/ICPPNodeFactory.java | 6 + .../core/dom/parser/ITypeMarshalBuffer.java | 2 + .../parser/cpp/CPPASTAliasDeclaration.java | 105 ++++ .../core/dom/parser/cpp/CPPAliasTemplate.java | 134 +++++ .../parser/cpp/CPPAliasTemplateInstance.java | 140 +++++ .../core/dom/parser/cpp/CPPNodeFactory.java | 6 + .../dom/parser/cpp/GNUCPPSourceParser.java | 25 +- .../parser/cpp/semantics/CPPSemantics.java | 5 + .../parser/cpp/semantics/CPPTemplates.java | 28 +- .../dom/parser/cpp/semantics/CPPVisitor.java | 33 ++ .../rewrite/astwriter/DeclarationWriter.java | 20 + .../core/index/IIndexCPPBindingConstants.java | 2 + .../pdom/dom/cpp/PDOMCPPAliasTemplate.java | 118 ++++ .../core/pdom/dom/cpp/PDOMCPPLinkage.java | 17 + 24 files changed, 1643 insertions(+), 19 deletions(-) create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTAliasDeclaration.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplate.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplateInstance.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAliasDeclaration.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplate.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplateInstance.java create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPAliasTemplate.java diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2BaseTest.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2BaseTest.java index 814b5d1b62f..451fecd522f 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2BaseTest.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2BaseTest.java @@ -366,6 +366,14 @@ public class AST2BaseTest extends BaseTestCase { assertEquals(num, count); } + protected void assertSameType(IType expected, IType actual) { + assertNotNull(expected); + assertNotNull(actual); + assertTrue("Expected same types, but the types were: '" + + ASTTypeUtil.getType(expected, false) + "' and '" + ASTTypeUtil.getType(actual, false) + "'", + expected.isSameType(actual)); + } + protected void isExpressionStringEqual(IASTInitializerClause exp, String str) { String expressionString = ASTStringUtil.getExpressionString((IASTExpression) exp); assertEquals(str, expressionString); @@ -526,7 +534,25 @@ public class AST2BaseTest extends BaseTestCase { binding instanceof IProblemBinding); return (IProblemBinding) binding; } - + + public IProblemBinding assertProblem(String context, int len, int problemId) { + IProblemBinding problemBinding = assertProblem(context, len); + assertEquals(problemId, problemBinding.getID()); + return problemBinding; + } + + public IProblemBinding assertProblem(String context, String name) { + IBinding binding= binding(context, name); + assertTrue("Non-ProblemBinding for name: " + name, binding instanceof IProblemBinding); + return (IProblemBinding) binding; + } + + public IProblemBinding assertProblem(String context, String name, int problemId) { + IProblemBinding problemBinding = assertProblem(context, name); + assertEquals(problemId, problemBinding.getID()); + return problemBinding; + } + public T assertNonProblem(String section, int len) { if (len <= 0) len= section.length() + len; diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java index 80574be3204..56ba6205b56 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java @@ -259,6 +259,12 @@ public class AST2CPPTests extends AST2BaseTest { assertEquals(declNames.length, i); assertEquals(defNames.length, j); } + + protected void assertSameType(IType first, IType second){ + assertNotNull(first); + assertNotNull(second); + assertTrue("Expected types to be the same, but first was: '" + first.toString() + "' and second was: '" + second + "'", first.isSameType(second)); + } // #define CURLOPTTYPE_OBJECTPOINT 10000 // #define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number @@ -9868,7 +9874,7 @@ public class AST2CPPTests extends AST2BaseTest { assertEquals(expectOverride, declarator.isOverride()); assertEquals(expectFinal, declarator.isFinal()); } - + // struct Base { // }; // struct S final : public Base { @@ -9893,9 +9899,8 @@ public class AST2CPPTests extends AST2BaseTest { assertInstance(sDefinition, ICPPASTCompositeTypeSpecifier.class); assertTrue(((ICPPASTCompositeTypeSpecifier)sDefinition).isFinal()); } - - - // struct S{ + + // struct S { // template // void foo(T t) final { // } @@ -9915,8 +9920,8 @@ public class AST2CPPTests extends AST2BaseTest { assertFalse(fooTemplate.isOverride()); assertTrue(fooTemplate.isFinal()); } - - // void foo(){ + + // void foo() { // int final, override; // final = 4; // override = 2; @@ -9924,17 +9929,17 @@ public class AST2CPPTests extends AST2BaseTest { public void testFinalAndOverrideVariables() throws Exception { parseAndCheckBindings(); } - - // struct S{ + + // struct S { // int i; // }; - // void foo(struct S final){ + // void foo(struct S final) { // final.i = 23; // } public void testFinalParameter() throws Exception { parseAndCheckBindings(); } - + // struct S1 {}; // S1 s1; // const int i= 1; diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java index baa07538965..4b6bb4ef192 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2TemplateTests.java @@ -11,6 +11,7 @@ * Bryan Wilkinson (QNX) * Andrew Ferguson (Symbian) * Sergey Prigogin (Google) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.core.parser.tests.ast2; @@ -50,6 +51,7 @@ import org.eclipse.cdt.core.dom.ast.IPointerType; import org.eclipse.cdt.core.dom.ast.IProblemBinding; import org.eclipse.cdt.core.dom.ast.IQualifierType; import org.eclipse.cdt.core.dom.ast.IScope; +import org.eclipse.cdt.core.dom.ast.ISemanticProblem; import org.eclipse.cdt.core.dom.ast.IType; import org.eclipse.cdt.core.dom.ast.ITypedef; import org.eclipse.cdt.core.dom.ast.IVariable; @@ -58,6 +60,8 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNamedTypeSpecifier; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTQualifiedName; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUnaryExpression; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPBase; import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope; @@ -87,6 +91,8 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable; import org.eclipse.cdt.core.parser.util.ObjectMap; import org.eclipse.cdt.internal.core.dom.parser.Value; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTNameBase; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPReferenceType; import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPDeferredClassInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalUnknownScope; @@ -6143,4 +6149,539 @@ public class AST2TemplateTests extends AST2BaseTest { public void testAddressAsTemplateArgument_391190() throws Exception { parseAndCheckBindings(getAboveComment(), CPP, true); } + + // template struct CT { + // const static int const_min= 1; + // }; + // void test(int off) { + // off < CT::const_min || off > CT::const_min; + // } + public void testTemplateIDAmbiguity_393959() throws Exception { + parseAndCheckBindings(getAboveComment(), CPP, true); + } + + // template class CT { + // void m() { + // template using Alias= T; // nesting level 1 + // Alias x; + // } + // }; + public void testNestedAliasDeclarationNestingLevel() throws Exception { + final String code = getAboveComment(); + BindingAssertionHelper bh= new BindingAssertionHelper(code, true); + + ICPPAliasTemplate templateParameterAlias = bh.assertNonProblem("Alias=", "Alias", ICPPAliasTemplate.class); + ICPPTemplateParameter aliasParameterT= templateParameterAlias.getTemplateParameters()[0]; + assertEquals(1, aliasParameterT.getTemplateNestingLevel()); + + ICPPAliasTemplateInstance aliasIntInstance = bh.assertNonProblem("Alias", ICPPAliasTemplateInstance.class); + IType typeOfAliasIntInstance = aliasIntInstance.getType(); + assertTrue(typeOfAliasIntInstance instanceof ICPPBasicType); + assertEquals(((ICPPBasicType)typeOfAliasIntInstance).getKind(), IBasicType.Kind.eInt); + + parseAndCheckBindings(code); + } + + // template class CT; + // template using Alias= CT; // nesting level 0 + // template class CT { // nesting level 0 + // typedef Alias TYPE; + // }; + public void testAliasDeclarationNestingLevel() throws Exception { + final String code = getAboveComment(); + BindingAssertionHelper bh= new BindingAssertionHelper(code, true); + + ICPPAliasTemplate templateParameterAlias = bh.assertNonProblem("Alias=", "Alias", ICPPAliasTemplate.class); + ICPPTemplateParameter aliasParameterT = templateParameterAlias.getTemplateParameters()[0]; + assertEquals(0, aliasParameterT.getTemplateNestingLevel()); + + ICPPTemplateDefinition templateCT = bh.assertNonProblem("CT {", "CT", ICPPTemplateDefinition.class); + ICPPTemplateParameter templateParameterT = templateCT.getTemplateParameters()[0]; + assertEquals(0, templateParameterT.getTemplateNestingLevel()); + + parseAndCheckBindings(code); + } + + // struct S { + // int x; + // }; + // using Alias = S; + // void foo() { + // Alias myA; + // myA.x = 42; + // } + public void testSimpleAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPClassType S = (ICPPClassType) collector.getName(0).resolveBinding(); + ICPPField x = (ICPPField) collector.getName(1).resolveBinding(); + ITypedef Alias = (ITypedef) collector.getName(2).resolveBinding(); + IFunction foo = (IFunction) collector.getName(4).resolveBinding(); + IVariable myA = (IVariable) collector.getName(6).resolveBinding(); + + assertInstances(collector, S, 2); + assertInstances(collector, x, 2); + assertInstances(collector, Alias, 2); + assertInstances(collector, foo, 1); + assertInstances(collector, myA, 2); + } + + // template + // struct S { + // T x; + // }; + // using Alias = S; + // void foo() { + // Alias myA; + // myA.x = 42; + // } + public void testSpecifiedTemplateAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPClassType S = (ICPPClassType) collector.getName(1).resolveBinding(); + ICPPField x = (ICPPField) collector.getName(3).resolveBinding(); + ITypedef Alias = (ITypedef) collector.getName(4).resolveBinding(); + IVariable myA = (IVariable) collector.getName(9).resolveBinding(); + ICPPSpecialization xRef = (ICPPSpecialization) collector.getName(11).resolveBinding(); + + assertInstances(collector, S, 2); + assertInstances(collector, Alias, 2); + assertInstances(collector, myA, 2); + assertEquals(x, xRef.getSpecializedBinding()); + } + + // template + // using Alias = int; + // void foo() { + // Alias myA; + // myA = 42; + // } + public void testTemplatedAliasBasicType() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPAliasTemplate Alias = (ICPPAliasTemplate) collector.getName(1).resolveBinding(); + ICPPAliasTemplateInstance AliasFloatInstance = (ICPPAliasTemplateInstance) collector.getName(3).resolveBinding(); + assertInstances(collector, Alias, 2); + assertSameType(AliasFloatInstance, new CPPBasicType(IBasicType.Kind.eInt, 0)); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S; + // void foo() { + // TAlias myA; + // myA.t = 42; + // } + public void testTemplatedAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPClassType S = (ICPPClassType) collector.getName(1).resolveBinding(); + ICPPField t = (ICPPField) collector.getName(3).resolveBinding(); + ICPPTemplateParameter T = (ICPPTemplateParameter) collector.getName(4).resolveBinding(); + ICPPTemplateParameter TRef = (ICPPTemplateParameter) collector.getName(8).resolveBinding(); + ICPPAliasTemplate TAlias = (ICPPAliasTemplate) collector.getName(5).resolveBinding(); + ICPPVariable myA = (ICPPVariable) collector.getName(12).resolveBinding(); + ICPPSpecialization tRef = (ICPPSpecialization) collector.getName(14).resolveBinding(); + + assertInstances(collector, S, 2); + assertInstances(collector, T, 2); + assertEquals(T, TRef); + assertInstances(collector, TAlias, 2); + assertInstances(collector, myA, 2); + assertEquals(t, tRef.getSpecializedBinding()); + ICPPDeferredClassInstance aliasedType = (ICPPDeferredClassInstance) TAlias.getType(); + assertEquals(S, aliasedType.getClassTemplate()); + } + + // template + // struct S { + // T1 t1; + // T2 t2; + // T3 t3; + // }; + // template + // using TAlias = S; + // void foo() { + // TAlias myA; + // myA.t1 = 42; + // myA.t2 = 42.0f; + // myA.t3 = true; + // } + public void testTemplatedAliasDeclarationMultipleParameters() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPField t1 = (ICPPField) collector.getName(5).resolveBinding(); + ICPPField t2 = (ICPPField) collector.getName(7).resolveBinding(); + ICPPField t3 = (ICPPField) collector.getName(9).resolveBinding(); + + ICPPTemplateParameter P1 = (ICPPTemplateParameter) collector.getName(10).resolveBinding(); + ICPPTemplateParameter P2 = (ICPPTemplateParameter) collector.getName(11).resolveBinding(); + + ICPPTemplateParameter P1Ref = (ICPPTemplateParameter) collector.getName(16).resolveBinding(); + ICPPTemplateParameter P2Ref = (ICPPTemplateParameter) collector.getName(15).resolveBinding(); + + ICPPAliasTemplateInstance TAliasInstance = (ICPPAliasTemplateInstance) collector.getName(18).resolveBinding(); + ICPPTemplateInstance aliasedTypeInstance = (ICPPTemplateInstance) TAliasInstance.getType(); + + ICPPSpecialization t1Ref = (ICPPSpecialization) collector.getName(22).resolveBinding(); + ICPPSpecialization t2Ref = (ICPPSpecialization) collector.getName(24).resolveBinding(); + ICPPSpecialization t3Ref = (ICPPSpecialization) collector.getName(26).resolveBinding(); + + assertEquals(P1, P1Ref); + assertEquals(P2, P2Ref); + + assertEquals(t1, t1Ref.getSpecializedBinding()); + assertEquals(t2, t2Ref.getSpecializedBinding()); + assertEquals(t3, t3Ref.getSpecializedBinding()); + assertSameType(new CPPBasicType(IBasicType.Kind.eInt, 0), aliasedTypeInstance.getTemplateArguments()[0].getTypeValue()); + assertSameType(new CPPBasicType(IBasicType.Kind.eFloat, 0), aliasedTypeInstance.getTemplateArguments()[1].getTypeValue()); + assertSameType(new CPPBasicType(IBasicType.Kind.eBoolean, 0), aliasedTypeInstance.getTemplateArguments()[2].getTypeValue()); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S

; + // void foo() { + // TAlias > myA; + // myA.t = S(); + // } + public void testTemplatedAliasDeclarationTemplateArgument() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPField t = (ICPPField) collector.getName(3).resolveBinding(); + IType TAliasSInt = (IType) collector.getName(10).resolveBinding(); + ICPPSpecialization tRef = (ICPPSpecialization) collector.getName(16).resolveBinding(); + + assertEquals(t, tRef.getSpecializedBinding()); + assertSameType(TAliasSInt, (IType)tRef.getOwner()); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S

; + // void foo() { + // S > myA; + // myA.t = S(); + // } + public void testTemplatedAliasAsTemplateArgument() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPField t = (ICPPField) collector.getName(3).resolveBinding(); + ICPPTemplateInstance STAliasInt = (ICPPTemplateInstance) collector.getName(10).resolveBinding(); + ICPPSpecialization tRef = (ICPPSpecialization) collector.getName(16).resolveBinding(); + + assertEquals(t, tRef.getSpecializedBinding()); + assertEquals(STAliasInt, tRef.getOwner()); + } + + // template + // struct S { + // int buff [Size]; + // }; + // template + // using TAlias = S; + // void foo() { + // TAlias<5, 4> myA; + // myA.buff[0] = 1; + // } + public void testTemplatedAliasDeclarationValueArgument() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPField buff = (ICPPField) collector.getName(3).resolveBinding(); + ICPPSpecialization buffRef = (ICPPSpecialization) collector.getName(17).resolveBinding(); + + assertEquals(buff, buffRef.getSpecializedBinding()); + assertEquals(buffRef.getTemplateParameterMap().getArgument(0).getNonTypeValue().numericalValue(), new Long(4)); + assertEquals(buffRef.getTemplateParameterMap().getArgument(1).getNonTypeValue().numericalValue(), new Long(5)); + } + + // template + // struct S { + // T buff [Size]; + // }; + // template + // using TAlias = S; + // void foo() { + // TAlias<> myA; + // myA.buff[0] = 1; + // } + public void testTemplatedAliasDefaultArguments() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPField buff = (ICPPField) collector.getName(4).resolveBinding(); + ICPPAliasTemplateInstance myA = (ICPPAliasTemplateInstance) collector.getName(14).resolveBinding(); + ICPPSpecialization buffRef = (ICPPSpecialization) collector.getName(18).resolveBinding(); + + assertEquals(buff, buffRef.getSpecializedBinding()); + assertSameType(buffRef.getTemplateParameterMap().getArgument(0).getTypeValue(), new CPPBasicType(IBasicType.Kind.eInt, 0)); + assertEquals(buffRef.getTemplateParameterMap().getArgument(1).getNonTypeValue().numericalValue(), new Long(5)); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S >; + // void foo() { + // TAlias myA; + // myA.t = S(); + // } + public void testTemplatedAliasTemplateArgument() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPField t = (ICPPField) collector.getName(3).resolveBinding(); + ICPPSpecialization tRef = (ICPPSpecialization) collector.getName(17).resolveBinding(); + ICPPClassSpecialization Sint = (ICPPClassSpecialization) collector.getName(18).resolveBinding(); + + assertEquals(t, tRef.getSpecializedBinding()); + assertSameType(tRef.getTemplateParameterMap().getArgument(0).getTypeValue(), Sint); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S; + // void bar(TAlias arg){ + // } + // void foo() { + // TAlias myA; + // bar(myA); + // S myS; + // bar(myS); + // } + public void testTemplatedAliasAsFunctionParameter() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPFunction bar = (ICPPFunction) collector.getName(9).resolveBinding(); + ICPPFunction barRefAlias = (ICPPFunction) collector.getName(17).resolveBinding(); + ICPPFunction barRefSInt = (ICPPFunction) collector.getName(22).resolveBinding(); + + assertEquals(bar, barRefAlias); + assertEquals(bar, barRefSInt); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S; + // void bar(S arg){ + // } + // void foo() { + // TAlias myA; + // bar(myA); + // } + public void testTemplatedAliasAsFunctionArgument() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPFunction bar = (ICPPFunction) collector.getName(9).resolveBinding(); + ICPPFunction barRefAlias = (ICPPFunction) collector.getName(17).resolveBinding(); + + assertEquals(bar, barRefAlias); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S; + // void bar(S arg){ + // } + // void bar(TAlias arg){ + // } + public void testTemplatedAliasRedefinitionOfSameFunction() throws Exception { + BindingAssertionHelper bh= getAssertionHelper(); + bh.assertNonProblem("bar(S", "bar", ICPPFunction.class); + bh.assertProblem("bar(TAlias", "bar", ISemanticProblem.BINDING_INVALID_REDEFINITION); + } + + // template struct vector{}; + // template struct Alloc{}; + // template using Vec = vector >; + // template class TT> + // void f(TT); + // template class TT> + // void g(TT >); + // void foo(){ + // Vec v; + // g(v); + // f(v); + // } + public void testTemplatedAliasDeduction() throws Exception { + BindingAssertionHelper bh= getAssertionHelper(); + bh.assertNonProblem("g(v)", "g", ICPPFunction.class); + bh.assertProblem("f(v)", "f", ISemanticProblem.BINDING_NOT_FOUND); + } + + // using function = void (&)(int); + // void foo(int) { + // function f = &foo; + // } + public void testSimpleFunctionAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ITypedef function = (ITypedef) collector.getName(0).resolveBinding(); + ICPPFunction foo = (ICPPFunction) collector.getName(2).resolveBinding(); + + assertInstances(collector, function, 2); + assertInstances(collector, foo, 2); + assertSameType(((ICPPReferenceType)function.getType()).getType(), foo.getType()); + } + + // template + // struct S { + // T t; + // }; + // template + // using TAlias = S&; + // void foo() { + // S myS; + // TAlias myA = myS; + // myA.t = 42; + // } + public void testTemplatedAliasForTemplateReference() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + ICPPClassSpecialization SInt = (ICPPClassSpecialization) collector.getName(10).resolveBinding(); + ICPPAliasTemplateInstance TAliasInt = (ICPPAliasTemplateInstance) collector.getName(13).resolveBinding(); + assertSameType(new CPPReferenceType(SInt, false), TAliasInt); + + } + + // template + // using function = void (int); + // void foo(int) { + // function f = &foo; + // } + public void testSimpleFunctionTemplateAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPAliasTemplate function = (ICPPAliasTemplate) collector.getName(1).resolveBinding(); + ICPPFunction foo = (ICPPFunction) collector.getName(3).resolveBinding(); + ICPPAliasTemplateInstance functionInt = (ICPPAliasTemplateInstance) collector.getName(5).resolveBinding(); + + assertInstances(collector, function, 2); + assertInstances(collector, foo, 2); + assertSameType(foo.getType(),functionInt); + } + + // template + // using function = void (&)(int); + // void foo(int) { + // function f = &foo; + // } + public void testSimpleFunctionReferenceTemplateAliasDeclaration() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPAliasTemplate function = (ICPPAliasTemplate) collector.getName(1).resolveBinding(); + ICPPFunction foo = (ICPPFunction) collector.getName(3).resolveBinding(); + ICPPAliasTemplateInstance functionInt = (ICPPAliasTemplateInstance) collector.getName(5).resolveBinding(); + + assertInstances(collector, function, 2); + assertInstances(collector, foo, 2); + assertSameType(new CPPReferenceType(foo.getType(), false),functionInt.getType()); + } + + // template + // struct S { + // T t; + // }; + // template class TA> + // using TAlias = S; + // void foo() { + // TAlias > myA; + // myA.t = S(); + // } + public void testTemplatedAliasTemplateParameter() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPField t = (ICPPField) collector.getName(3).resolveBinding(); + ICPPSpecialization tRef = (ICPPSpecialization) collector.getName(17).resolveBinding(); + ICPPClassSpecialization Sint = (ICPPClassSpecialization) collector.getName(18).resolveBinding(); + + assertEquals(t, tRef.getSpecializedBinding()); + assertSameType(tRef.getTemplateParameterMap().getArgument(0).getTypeValue(), Sint); + } + + // namespace NS { + // template + // struct S { + // T t; + // }; + // template + // using Alias = S; + // } + // using namespace NS; + // Alias intAlias; + public void testAliasDeclarationContext() throws Exception { + final String code = getAboveComment(); + IASTTranslationUnit ast = parseAndCheckBindings(code); + CPPNameCollector collector = new CPPNameCollector(); + ast.accept(collector); + + ICPPAliasTemplateInstance AliasInt = (ICPPAliasTemplateInstance) collector.getName(11).resolveBinding(); + assertEquals("Alias", AliasInt.getName()); + assertEquals("NS", AliasInt.getQualifiedName()[0]); + assertEquals("Alias", AliasInt.getQualifiedName()[1]); + + ICPPNamespace namespaceNS = (ICPPNamespace) collector.getName(0).resolveBinding(); + assertEquals(namespaceNS, AliasInt.getOwner()); + + assertTrue(AliasInt.getScope() instanceof ICPPTemplateScope); + } } diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/internal/pdom/tests/CPPClassTemplateTests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/internal/pdom/tests/CPPClassTemplateTests.java index 52c117f25ba..a96517f71b0 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/internal/pdom/tests/CPPClassTemplateTests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/internal/pdom/tests/CPPClassTemplateTests.java @@ -7,6 +7,7 @@ * * Contributors: * Andrew Ferguson (Symbian) - Initial implementation + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.pdom.tests; @@ -21,10 +22,16 @@ import org.eclipse.cdt.core.dom.ast.IField; import org.eclipse.cdt.core.dom.ast.IFunctionType; import org.eclipse.cdt.core.dom.ast.IPointerType; import org.eclipse.cdt.core.dom.ast.IType; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType; import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplateInstance; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; +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.ICPPTemplateTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateTypeParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable; import org.eclipse.cdt.core.index.IndexFilter; @@ -34,7 +41,9 @@ import org.eclipse.cdt.core.testplugin.CProjectHelper; import org.eclipse.cdt.core.testplugin.CTestPlugin; import org.eclipse.cdt.core.testplugin.util.TestSourceReader; import org.eclipse.cdt.internal.core.CCoreInternals; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType; import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper; +import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPDeferredClassInstance; import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding; import org.eclipse.cdt.internal.core.pdom.PDOM; import org.eclipse.cdt.internal.core.pdom.indexer.IndexerPreferences; @@ -316,6 +325,245 @@ public class CPPClassTemplateTests extends PDOMTestBase { } } + // template + // struct S { + // xT x; + // }; + // template + // using A = S; + public void testSimpleAliasDefinition() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(1, aliasParameters.length); + + assertTrue(aliasParameters[0] instanceof ICPPTemplateTypeParameter); + ICPPTemplateTypeParameter templateParameterAT= (ICPPTemplateTypeParameter) aliasParameters[0]; + assertEquals("aT", templateParameterAT.getName()); + assertNull(templateParameterAT.getDefault()); + assertEquals(0, templateParameterAT.getTemplateNestingLevel()); + + assertDeclarationCount(pdom, "S", 1); + IIndexFragmentBinding[] bindingS= pdom.findBindings(new char[][] {{'S'}}, IndexFilter.ALL_DECLARED, npm()); + IType aliasedType = aliasA.getType(); + assertTrue(aliasedType instanceof ICPPDeferredClassInstance); + ICPPDeferredClassInstance deferredClassInstanceS= (ICPPDeferredClassInstance) aliasedType; + assertEquals(1, bindingA.length); + assertEquals(bindingS[0], deferredClassInstanceS.getSpecializedBinding()); + } + + // struct D { + // }; + // template + // struct S { + // xT x; + // }; + // template + // using A = S; + public void testSimpleAliasDefinitionDefaultTemplateArgument() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(2, aliasParameters.length); + + assertTrue(aliasParameters[0] instanceof ICPPTemplateTypeParameter); + ICPPTemplateTypeParameter templateParameterAT1= (ICPPTemplateTypeParameter) aliasParameters[0]; + assertEquals("aT1", templateParameterAT1.getName()); + assertNull(templateParameterAT1.getDefault()); + assertEquals(0, templateParameterAT1.getTemplateNestingLevel()); + + assertTrue(aliasParameters[1] instanceof ICPPTemplateTypeParameter); + ICPPTemplateTypeParameter templateParameterAT2= (ICPPTemplateTypeParameter) aliasParameters[1]; + assertEquals("aT2", templateParameterAT2.getName()); + IType aT2DefaultArgument = templateParameterAT2.getDefault(); + assertNotNull(aT2DefaultArgument); + assertDeclarationCount(pdom, "D", 1); + IIndexFragmentBinding[] bindingD= pdom.findBindings(new char[][] {{'D'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingD.length); + assertTrue(bindingD[0] instanceof IType); + assertTrue(((IType)bindingD[0]).isSameType(aT2DefaultArgument)); + assertEquals(0, templateParameterAT2.getTemplateNestingLevel()); + + assertDeclarationCount(pdom, "S", 1); + IIndexFragmentBinding[] bindingS= pdom.findBindings(new char[][] {{'S'}}, IndexFilter.ALL_DECLARED, npm()); + IType aliasedType = aliasA.getType(); + assertTrue(aliasedType instanceof ICPPDeferredClassInstance); + ICPPDeferredClassInstance deferredClassInstanceS= (ICPPDeferredClassInstance) aliasedType; + assertEquals(1, bindingS.length); + assertEquals(bindingS[0], deferredClassInstanceS.getSpecializedBinding()); + } + + // template + // struct S { + // xT x; + // }; + // template + // using A = S; + public void testSimpleAliasDefinitionValueTemplateArguments() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(2, aliasParameters.length); + + assertTrue(aliasParameters[0] instanceof ICPPTemplateNonTypeParameter); + ICPPTemplateNonTypeParameter templateParameterAT1= (ICPPTemplateNonTypeParameter) aliasParameters[0]; + assertEquals("aT1", templateParameterAT1.getName()); + assertNull(templateParameterAT1.getDefaultValue()); + assertEquals(0, templateParameterAT1.getTemplateNestingLevel()); + + assertTrue(aliasParameters[1] instanceof ICPPTemplateNonTypeParameter); + ICPPTemplateNonTypeParameter templateParameterAT2= (ICPPTemplateNonTypeParameter) aliasParameters[1]; + assertEquals("aT2", templateParameterAT2.getName()); + ICPPTemplateArgument aT2DefaultArgument = templateParameterAT2.getDefaultValue(); + assertNotNull(aT2DefaultArgument); + assertTrue(new CPPBasicType(IBasicType.Kind.eInt, 0).isSameType(aT2DefaultArgument.getTypeOfNonTypeValue())); + assertEquals(5, aT2DefaultArgument.getNonTypeValue().numericalValue().longValue()); + assertEquals(0, templateParameterAT2.getTemplateNestingLevel()); + + assertDeclarationCount(pdom, "S", 1); + IIndexFragmentBinding[] bindingS= pdom.findBindings(new char[][] {{'S'}}, IndexFilter.ALL_DECLARED, npm()); + IType aliasedType = aliasA.getType(); + assertTrue(aliasedType instanceof ICPPDeferredClassInstance); + ICPPDeferredClassInstance deferredClassInstanceS= (ICPPDeferredClassInstance) aliasedType; + assertEquals(1, bindingS.length); + assertEquals(bindingS[0], deferredClassInstanceS.getSpecializedBinding()); + } + + // template + // struct S { + // T t; + // }; + // template class TT> + // using A = S; + public void testSimpleAliasTemplateParameter() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(1, aliasParameters.length); + + assertTrue(aliasParameters[0] instanceof ICPPTemplateTemplateParameter); + ICPPTemplateTemplateParameter templateParameterTT= (ICPPTemplateTemplateParameter) aliasParameters[0]; + assertEquals("TT", templateParameterTT.getName()); + assertNull(templateParameterTT.getDefaultValue()); + assertEquals(0, templateParameterTT.getTemplateNestingLevel()); + } + + // struct B{}; + // template + // struct S { + // xT x; + // }; + // template + // using A = S; + // A aB; + // S sB; + public void testSimpleAliasReference() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(1, aliasParameters.length); + + assertReferenceCount(pdom, "S", 2); + assertReferenceCount(pdom, "A", 1); + assertDeclarationCount(pdom, "aB", 1); + assertDeclarationCount(pdom, "sB", 1); + + IIndexFragmentBinding[] bindingVarSB= pdom.findBindings(new char[][] {"sB".toCharArray()}, IndexFilter.ALL, npm()); + assertEquals(1, bindingVarSB.length); + assertTrue(bindingVarSB[0] instanceof ICPPVariable); + ICPPVariable variableSB = (ICPPVariable) bindingVarSB[0]; + IType varSBType = variableSB.getType(); + assertTrue(varSBType instanceof ICPPClassSpecialization); + ICPPClassSpecialization templateInstanceSB = (ICPPClassSpecialization) varSBType; + + IIndexFragmentBinding[] bindingVarAB= pdom.findBindings(new char[][] {"aB".toCharArray()}, IndexFilter.ALL, npm()); + assertEquals(1, bindingVarAB.length); + assertTrue(bindingVarAB[0] instanceof ICPPVariable); + ICPPVariable variableAB = (ICPPVariable) bindingVarAB[0]; + IType varABType = variableAB.getType(); + assertTrue(varABType instanceof ICPPAliasTemplateInstance); + ICPPAliasTemplateInstance aliasInstanceAB = (ICPPAliasTemplateInstance) varABType; + assertTrue(varABType.isSameType(templateInstanceSB)); + assertTrue(aliasInstanceAB.getTemplateDefinition().isSameType(aliasA)); + assertEquals("A", aliasInstanceAB.getName()); + } + + // template class CT { + // template using A= T; // nesting level 1 + // A x; + // }; + public void testPDOMNestedAliasDeclarationNestingLevel() throws Exception { + IIndexFragmentBinding[] bindingCT = pdom.findBindings(new char[][] { "CT".toCharArray() }, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingCT.length); + assertTrue(bindingCT[0] instanceof ICPPClassTemplate); + ICPPClassTemplate templateCT = (ICPPClassTemplate) bindingCT[0]; + + IField[] fields = templateCT.getFields(); + assertEquals(1, fields.length); + IField x = fields[0]; + IType xType = x.getType(); + assertTrue(xType instanceof ICPPAliasTemplateInstance); + + ICPPAliasTemplateInstance aliasInstance = (ICPPAliasTemplateInstance) xType; + ICPPAliasTemplate alias = aliasInstance.getTemplateDefinition(); + ICPPTemplateParameter[] aliasParameters = alias.getTemplateParameters(); + assertEquals(1, aliasParameters.length); + ICPPTemplateParameter aliasParameterT = aliasParameters[0]; + assertEquals(1, aliasParameterT.getTemplateNestingLevel()); + } + + // template class CT; + // template using A= CT; // nesting level 0 + // template class CT { // nesting level 0 + // typedef Alias TYPE; + // }; + public void testPDOMAliasDeclarationNestingLevel() throws Exception { + assertDeclarationCount(pdom, "A", 1); + IIndexFragmentBinding[] bindingA= pdom.findBindings(new char[][] {{'A'}}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingA.length); + assertTrue(bindingA[0] instanceof ICPPAliasTemplate); + ICPPAliasTemplate aliasA= (ICPPAliasTemplate) bindingA[0]; + ICPPTemplateParameter[] aliasParameters= aliasA.getTemplateParameters(); + assertEquals(1, aliasParameters.length); + + assertTrue(aliasParameters[0] instanceof ICPPTemplateTypeParameter); + ICPPTemplateTypeParameter templateParameterT= (ICPPTemplateTypeParameter) aliasParameters[0]; + assertEquals("T", templateParameterT.getName()); + assertNull(templateParameterT.getDefault()); + assertEquals(0, templateParameterT.getTemplateNestingLevel()); + + assertDeclarationCount(pdom, "CT", 2); + IIndexFragmentBinding[] bindingCT= pdom.findBindings(new char[][] {"CT".toCharArray()}, IndexFilter.ALL_DECLARED, npm()); + assertEquals(1, bindingCT.length); + assertTrue(bindingCT[0] instanceof ICPPClassTemplate); + ICPPClassTemplate templateCT= (ICPPClassTemplate) bindingCT[0]; + ICPPTemplateParameter[] ctParameters= templateCT.getTemplateParameters(); + assertEquals(1, ctParameters.length); + + assertTrue(ctParameters[0] instanceof ICPPTemplateTypeParameter); + ICPPTemplateTypeParameter templateParameterTofCT= (ICPPTemplateTypeParameter) ctParameters[0]; + assertEquals("T", templateParameterTofCT.getName()); + assertNull(templateParameterTofCT.getDefault()); + assertEquals(0, templateParameterTofCT.getTemplateNestingLevel()); + } + + + @Override protected void assertInstance(Object o, Class c) { assertNotNull(o); diff --git a/core/org.eclipse.cdt.core.tests/resources/rewrite/ASTWriterTemplateTestSource.awts b/core/org.eclipse.cdt.core.tests/resources/rewrite/ASTWriterTemplateTestSource.awts index 32ff7264c82..7d68787a8a4 100644 --- a/core/org.eclipse.cdt.core.tests/resources/rewrite/ASTWriterTemplateTestSource.awts +++ b/core/org.eclipse.cdt.core.tests/resources/rewrite/ASTWriterTemplateTestSource.awts @@ -10,4 +10,10 @@ void f(T* p) T::template adjust<100>(); } - +//![temp.alias] Template alias declaration +//%CPP +template struct S +{ +}; +template using Alias = S; +Alias sInt; diff --git a/core/org.eclipse.cdt.core/.settings/.api_filters b/core/org.eclipse.cdt.core/.settings/.api_filters index 45301b0d6a8..8e961d02a2d 100644 --- a/core/org.eclipse.cdt.core/.settings/.api_filters +++ b/core/org.eclipse.cdt.core/.settings/.api_filters @@ -68,6 +68,13 @@ + + + + + + + @@ -82,6 +89,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTAliasDeclaration.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTAliasDeclaration.java new file mode 100644 index 00000000000..9cc57d8e179 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTAliasDeclaration.java @@ -0,0 +1,78 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.core.dom.ast.cpp; + +import org.eclipse.cdt.core.dom.ast.ASTNodeProperty; +import org.eclipse.cdt.core.dom.ast.IASTDeclaration; +import org.eclipse.cdt.core.dom.ast.IASTName; +import org.eclipse.cdt.core.dom.ast.IASTNameOwner; + +/** + * This interface represents a C++ alias declaration. + * e.g. struct Type {}; using Alias = Type; + * + * @noextend This interface is not intended to be extended by clients. + * @noimplement This interface is not intended to be implemented by clients. + */ +public interface ICPPASTAliasDeclaration extends IASTDeclaration, IASTNameOwner { + public static final ICPPASTAliasDeclaration[] EMPTY_USINGDIRECTIVE_ARRAY = new ICPPASTAliasDeclaration[0]; + + /** + * ALIAS_NAME is the name that is brought into local + * scope. + */ + public static final ASTNodeProperty ALIAS_NAME = new ASTNodeProperty( + "ICPPASTAliasDeclaration.ALIAS_NAME - New alias name introduced"); //$NON-NLS-1$ + + /** + * MAPPING_TYPE represents the pre-existing type id which + * the new symbol aliases. + */ + public static final ASTNodeProperty TARGET_TYPEID = new ASTNodeProperty( + "ICPPASTAliasDeclaration.TARGET_TYPEID - Pre-existing type ID the new symbol aliases"); //$NON-NLS-1$ + + /** + * Get the alias name. + * + * @return IASTName + */ + public IASTName getAlias(); + + /** + * Set the alias name. + * + * @param aliasName + * IASTName + */ + public void setAlias(IASTName aliasName); + + /** + * Get the mapping type id. + * + * @return ICPPASTTypeId + */ + public ICPPASTTypeId getMappingTypeId(); + + /** + * Set the mapping type id. + * + * @param mappingTypeId + * ICPPASTTypeId + */ + public void setMappingTypeId(ICPPASTTypeId mappingTypeId); + + @Override + public ICPPASTAliasDeclaration copy(); + + @Override + public ICPPASTAliasDeclaration copy(CopyStyle style); +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTTypeId.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTTypeId.java index cab1df9c5ef..1d82361d481 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTTypeId.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPASTTypeId.java @@ -7,6 +7,7 @@ * * Contributors: * Markus Schorn - initial API and implementation + * Thomas Corbat (IFS) - Added copy methods *******************************************************************************/ package org.eclipse.cdt.core.dom.ast.cpp; @@ -20,4 +21,9 @@ import org.eclipse.cdt.core.dom.ast.IASTTypeId; * @since 5.2 */ public interface ICPPASTTypeId extends IASTTypeId, ICPPASTPackExpandable { + @Override + public ICPPASTTypeId copy(); + + @Override + public ICPPASTTypeId copy(CopyStyle style); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplate.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplate.java new file mode 100644 index 00000000000..b138b979a84 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplate.java @@ -0,0 +1,27 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.core.dom.ast.cpp; + +import org.eclipse.cdt.core.dom.ast.IType; + +/** + * Represents an alias template (14.5.7). + * Experimental API. May change without notice. + * @noimplement This interface is not intended to be implemented by clients. + * @noextend This interface is not intended to be extended by clients. + */ +public interface ICPPAliasTemplate extends IType, ICPPTemplateDefinition { + /** + * Returns the aliased type. + */ + public IType getType(); +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplateInstance.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplateInstance.java new file mode 100644 index 00000000000..550013d3558 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPAliasTemplateInstance.java @@ -0,0 +1,27 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.core.dom.ast.cpp; + +import org.eclipse.cdt.core.dom.ast.ITypedef; + +/** + * Represents an instance of an alias template (14.5.7). + * Experimental API. May change without notice. + * @noextend This interface is not intended to be extended by clients. + * @noimplement This interface is not intended to be implemented by clients. + */ +public interface ICPPAliasTemplateInstance extends ITypedef, ICPPBinding { + /** + * Returns the the alias template specialized by this instance. + */ + public ICPPAliasTemplate getTemplateDefinition(); +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPNodeFactory.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPNodeFactory.java index 3348938c563..a5fbc83e3e5 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPNodeFactory.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/dom/ast/cpp/ICPPNodeFactory.java @@ -8,6 +8,7 @@ * Contributors: * Mike Kucera (IBM Corporation) - initial API and implementation * Markus Schorn (Wind River Systems) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.core.dom.ast.cpp; @@ -354,4 +355,9 @@ public interface ICPPNodeFactory extends INodeFactory { @Override public ICPPASTWhileStatement newWhileStatement(IASTExpression condition, IASTStatement body); + + /** + * @noreference This method is not intended to be referenced by clients. + */ + public ICPPASTAliasDeclaration newAliasDeclaration(IASTName aliasName, ICPPASTTypeId aliasedType); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ITypeMarshalBuffer.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ITypeMarshalBuffer.java index 8b465ba06c9..d3c7b188e17 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ITypeMarshalBuffer.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ITypeMarshalBuffer.java @@ -7,6 +7,7 @@ * * Contributors: * Markus Schorn - initial API and implementation + * Thomas Corbat *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser; @@ -34,6 +35,7 @@ public interface ITypeMarshalBuffer { final static byte UNKNOWN_MEMBER= 12; final static byte UNKNOWN_MEMBER_CLASS_INSTANCE= 13; final static byte DEFERRED_CLASS_INSTANCE= 14; + final static byte ALIAS_TEMPLATE = 15; final static byte EVAL_BINARY= 1, diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAliasDeclaration.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAliasDeclaration.java new file mode 100644 index 00000000000..a1cbff32b7a --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAliasDeclaration.java @@ -0,0 +1,105 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.internal.core.dom.parser.cpp; + +import org.eclipse.cdt.core.dom.ast.ASTVisitor; +import org.eclipse.cdt.core.dom.ast.IASTName; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTypeId; +import org.eclipse.cdt.internal.core.dom.parser.ASTNode; + +public class CPPASTAliasDeclaration extends ASTNode implements ICPPASTAliasDeclaration { + private IASTName aliasName; + private ICPPASTTypeId mappingTypeId; + + public CPPASTAliasDeclaration(IASTName aliasName, ICPPASTTypeId mappingTypeId){ + setAlias(aliasName); + setMappingTypeId(mappingTypeId); + } + + @Override + public int getRoleForName(IASTName name) { + if (aliasName == name) return r_definition; + if (mappingTypeId == name) return r_reference; + return r_unclear; + } + + @Override + public IASTName getAlias() { + return aliasName; + } + + @Override + public void setAlias(IASTName aliasName) { + assertNotFrozen(); + this.aliasName = aliasName; + if (aliasName != null) { + aliasName.setParent(this); + aliasName.setPropertyInParent(ALIAS_NAME); + } + } + + @Override + public ICPPASTTypeId getMappingTypeId() { + return mappingTypeId; + } + + @Override + public void setMappingTypeId(ICPPASTTypeId mappingTypeId) { + assertNotFrozen(); + this.mappingTypeId = mappingTypeId; + if (mappingTypeId != null) { + mappingTypeId.setParent(this); + mappingTypeId.setPropertyInParent(TARGET_TYPEID); + } + } + + @Override + public ICPPASTAliasDeclaration copy() { + return copy(CopyStyle.withoutLocations); + } + + @Override + public ICPPASTAliasDeclaration copy(CopyStyle style) { + CPPASTAliasDeclaration copy = new CPPASTAliasDeclaration( + aliasName == null ? null : aliasName.copy(style), + mappingTypeId == null ? null : mappingTypeId.copy(style)); + copy.setOffsetAndLength(this); + if (style == CopyStyle.withLocations) { + copy.setCopyLocation(this); + } + return copy; + } + + @Override + public boolean accept(ASTVisitor action) { + if (action.shouldVisitDeclarations) { + switch (action.visit(this)) { + case ASTVisitor.PROCESS_ABORT: return false; + case ASTVisitor.PROCESS_SKIP: return true; + default: break; + } + } + + if (aliasName != null && !aliasName.accept(action)) return false; + if (mappingTypeId != null && !mappingTypeId.accept(action)) return false; + + if (action.shouldVisitDeclarations) { + switch (action.leave(this)) { + case ASTVisitor.PROCESS_ABORT: return false; + case ASTVisitor.PROCESS_SKIP: return true; + default: break; + } + } + return true; + } +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplate.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplate.java new file mode 100644 index 00000000000..a4a3c3276cf --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplate.java @@ -0,0 +1,134 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.internal.core.dom.parser.cpp; + +import org.eclipse.cdt.core.dom.ILinkage; +import org.eclipse.cdt.core.dom.ast.ASTTypeUtil; +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.IScope; +import org.eclipse.cdt.core.dom.ast.IType; +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.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; +import org.eclipse.cdt.core.parser.util.ArrayUtil; +import org.eclipse.cdt.internal.core.dom.Linkage; +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 class CPPAliasTemplate extends PlatformObject implements ICPPAliasTemplate { + private IASTName aliasName; + private IType aliasedType; + private ICPPTemplateParameter[] templateParameters; + + public CPPAliasTemplate(IASTName aliasName){ + this.aliasName = aliasName; + aliasName.setBinding(this); + } + + @Override + public IType getType() { + return aliasedType; + } + + public void setType(IType type) { + this.aliasedType = type; + } + + @Override + public String getName() { + return new String(getNameCharArray()); + } + + @Override + public char[] getNameCharArray() { + return aliasName.getSimpleID(); + } + + @Override + public ILinkage getLinkage() { + return Linkage.CPP_LINKAGE; + } + + @Override + public IBinding getOwner() { + return CPPVisitor.findDeclarationOwner(aliasName, true); + } + + @Override + public IScope getScope() throws DOMException { + return CPPVisitor.getContainingScope(aliasName.getParent()); + } + + @Override + public boolean isSameType(IType type) { + if(type == null){ + return false; + } + IType aliasedType = getType(); + return type.isSameType(aliasedType); + } + + @Override + public Object clone() { + IType t = null; + try { + t = (IType) super.clone(); + } catch (CloneNotSupportedException e) { + //not going to happen + } + return t; + } + + @Override + public String[] getQualifiedName() throws DOMException { + return CPPVisitor.getQualifiedName(this); + } + + @Override + public char[][] getQualifiedNameCharArray() throws DOMException { + return CPPVisitor.getQualifiedNameCharArray(this); + } + + @Override + public boolean isGloballyQualified() throws DOMException { + return true; + } + + @Override + public ICPPTemplateParameter[] getTemplateParameters() { + if (templateParameters == null) { + ICPPASTTemplateDeclaration template = CPPTemplates.getTemplateDeclaration(aliasName); + if (template == null) + return ICPPTemplateParameter.EMPTY_TEMPLATE_PARAMETER_ARRAY; + ICPPASTTemplateParameter[] params = template.getTemplateParameters(); + IBinding p = null; + ICPPTemplateParameter[] result = null; + for (ICPPASTTemplateParameter param : params) { + p= CPPTemplates.getTemplateParameterName(param).resolveBinding(); + if (p instanceof ICPPTemplateParameter) { + result = ArrayUtil.append(ICPPTemplateParameter.class, result, (ICPPTemplateParameter) p); + } + } + templateParameters = ArrayUtil.trim(ICPPTemplateParameter.class, result); + } + return templateParameters; + } + + @Override + public String toString() { + return ASTTypeUtil.getQualifiedName(this) + " -> " + ASTTypeUtil.getType(aliasedType, true); //$NON-NLS-1$ + } +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplateInstance.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplateInstance.java new file mode 100644 index 00000000000..4435b4020dc --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPAliasTemplateInstance.java @@ -0,0 +1,140 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.internal.core.dom.parser.cpp; + +import org.eclipse.cdt.core.dom.ILinkage; +import org.eclipse.cdt.core.dom.ast.ASTTypeUtil; +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.IType; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplateInstance; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding; +import org.eclipse.cdt.internal.core.dom.Linkage; +import org.eclipse.cdt.internal.core.dom.parser.ISerializableType; +import org.eclipse.cdt.internal.core.dom.parser.ITypeMarshalBuffer; +import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.PlatformObject; + +public class CPPAliasTemplateInstance extends PlatformObject + implements ICPPAliasTemplateInstance, ISerializableType { + private final char[] name; + private final IType aliasedType; + private final ICPPAliasTemplate aliasTemplate; + + public CPPAliasTemplateInstance(char[] name, IType aliasedType, ICPPAliasTemplate aliasTemplate) { + this.name = name; + this.aliasedType = aliasedType; + this.aliasTemplate = aliasTemplate; + } + + @Override + public ICPPAliasTemplate getTemplateDefinition() { + return aliasTemplate; + } + + @Override + public boolean isSameType(IType other) { + if (other == aliasedType) + return true; + if (aliasedType != null) { + return aliasedType.isSameType(other); + } + return false; + } + + @Override + public IType getType() { + return aliasedType; + } + + @Override + public Object clone() { + try { + return super.clone(); + } catch (CloneNotSupportedException e) { + } + return null; + } + + @Override + public String getName() { + return new String(getNameCharArray()); + } + + @Override + public char[] getNameCharArray() { + if (name != null) { + return name; + } + return new char[0]; + } + + @Override + public ILinkage getLinkage() { + return Linkage.CPP_LINKAGE; + } + + @Override + public IBinding getOwner() { + if (aliasTemplate != null) { + return aliasTemplate.getOwner(); + } + return null; + } + + @Override + public IScope getScope() throws DOMException { + if (aliasTemplate != null) { + return aliasTemplate.getScope(); + } + return null; + } + + @Override + public void marshal(ITypeMarshalBuffer buffer) throws CoreException { + int firstByte = ITypeMarshalBuffer.ALIAS_TEMPLATE; + buffer.putByte((byte) firstByte); + buffer.putCharArray(name); + buffer.marshalType(aliasedType); + buffer.marshalBinding(aliasTemplate); + } + + public static IType unmarshal(int firstByte, ITypeMarshalBuffer buffer) throws CoreException { + char[] name = buffer.getCharArray(); + IType unmarshalledAliasedTypeInstance = buffer.unmarshalType(); + ICPPAliasTemplate unmarshalledAlias = (ICPPAliasTemplate)buffer.unmarshalBinding(); + return new CPPAliasTemplateInstance(name, unmarshalledAliasedTypeInstance, unmarshalledAlias); + } + + @Override + public String toString() { + return ASTTypeUtil.getQualifiedName(this) + " -> " + ASTTypeUtil.getType(aliasedType, true); //$NON-NLS-1$ + } + + @Override + public String[] getQualifiedName() { + return CPPVisitor.getQualifiedName(this); + } + + @Override + public char[][] getQualifiedNameCharArray() { + return CPPVisitor.getQualifiedNameCharArray(this); + } + + @Override + public boolean isGloballyQualified() throws DOMException { + return ((ICPPBinding) aliasTemplate).isGloballyQualified(); + } +} diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPNodeFactory.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPNodeFactory.java index 575873a4e67..fedcacd8a32 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPNodeFactory.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPNodeFactory.java @@ -51,6 +51,7 @@ import org.eclipse.cdt.core.dom.ast.IASTToken; import org.eclipse.cdt.core.dom.ast.IASTTokenList; import org.eclipse.cdt.core.dom.ast.IASTTypeId; import org.eclipse.cdt.core.dom.ast.IASTTypeIdInitializerExpression; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTArrayDeclarator; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTArraySubscriptExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTBinaryExpression; @@ -747,4 +748,9 @@ public class CPPNodeFactory extends NodeFactory implements ICPPNodeFactory { public ICPPASTWhileStatement newWhileStatement(IASTExpression condition, IASTStatement body) { return new CPPASTWhileStatement(condition, body); } + + @Override + public ICPPASTAliasDeclaration newAliasDeclaration(IASTName aliasName, ICPPASTTypeId mappingTypeId) { + return new CPPASTAliasDeclaration(aliasName, mappingTypeId); + } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java index 6faf853b47f..afa03268483 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/GNUCPPSourceParser.java @@ -94,6 +94,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTIfStatement; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTInitializerList; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLambdaExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLambdaExpression.CaptureDefault; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLinkageSpecification; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLiteralExpression; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNamedTypeSpecifier; @@ -1885,7 +1886,6 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { default: throw backtrack; } - ICPPASTUsingDirective astUD = nodeFactory.newUsingDirective(name); if (attributes != null) { for (IASTAttribute attribute : attributes) { @@ -1896,10 +1896,33 @@ public class GNUCPPSourceParser extends AbstractGNUSourceCodeParser { return astUD; } + if(LT(1) == IToken.tIDENTIFIER && LT(2) == IToken.tASSIGN){ + return aliasDeclaration(offset); + + } ICPPASTUsingDeclaration result = usingDeclaration(offset); return result; } + private IASTDeclaration aliasDeclaration(final int offset) throws EndOfFileException, + BacktrackException { + IToken identifierToken = consume(); + IASTName aliasName = buildName(-1, identifierToken); + + consume(); + + ICPPASTTypeId aliasedType = typeId(DeclarationOptions.TYPEID); + + if(LT(1) != IToken.tSEMI){ + throw backtrack; + } + int endOffset = consume().getEndOffset(); + + ICPPASTAliasDeclaration aliasDeclaration = nodeFactory.newAliasDeclaration(aliasName, aliasedType); + setRange(aliasDeclaration, offset, endOffset); + return aliasDeclaration; + } + private ICPPASTUsingDeclaration usingDeclaration(final int offset) throws EndOfFileException, BacktrackException { boolean typeName = false; if (LT(1) == IToken.t_typename) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java index 98bcf4830b8..3f4d58c7b84 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPSemantics.java @@ -12,6 +12,7 @@ * Andrew Ferguson (Symbian) * Sergey Prigogin (Google) * Mike Kucera (IBM) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.cpp.semantics; @@ -92,6 +93,7 @@ import org.eclipse.cdt.core.dom.ast.ISemanticProblem; import org.eclipse.cdt.core.dom.ast.IType; import org.eclipse.cdt.core.dom.ast.ITypedef; import org.eclipse.cdt.core.dom.ast.IVariable; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCatchHandler; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier; @@ -1668,6 +1670,9 @@ public class CPPSemantics { } else if (declaration instanceof ICPPASTNamespaceAlias) { IASTName alias = ((ICPPASTNamespaceAlias) declaration).getAlias(); ASTInternal.addName(scope, alias); + } else if (declaration instanceof ICPPASTAliasDeclaration) { + IASTName alias = ((ICPPASTAliasDeclaration) declaration).getAlias(); + ASTInternal.addName(scope, alias); } else if (declaration instanceof IASTFunctionDefinition) { IASTFunctionDefinition functionDef = (IASTFunctionDefinition) declaration; final IASTDeclSpecifier declSpec = functionDef.getDeclSpecifier(); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java index 276c7903673..564d946da48 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java @@ -10,6 +10,7 @@ * Bryan Wilkinson (QNX) * Markus Schorn (Wind River Systems) * Sergey Prigogin (Google) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.cpp.semantics; @@ -66,6 +67,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplatedTypeTemplateParameter; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassSpecialization; import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassTemplate; @@ -103,6 +105,7 @@ import org.eclipse.cdt.internal.core.dom.parser.ProblemBinding; import org.eclipse.cdt.internal.core.dom.parser.ProblemType; import org.eclipse.cdt.internal.core.dom.parser.Value; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTName; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPAliasTemplateInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPArrayType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassSpecialization; @@ -393,7 +396,7 @@ public class CPPTemplates { return instance; } - private static ICPPTemplateArgument[] addDefaultArguments(ICPPClassTemplate template, + private static ICPPTemplateArgument[] addDefaultArguments(ICPPTemplateDefinition template, ICPPTemplateArgument[] arguments, IASTNode point) throws DOMException { if (template instanceof ICPPClassTemplatePartialSpecialization) return arguments; @@ -642,17 +645,30 @@ public class CPPTemplates { } } try { - // Class template instance. IBinding result= null; IASTName templateName = id.getTemplateName(); IBinding template = templateName.resolvePreBinding(); - + + // Template alias. + if (template instanceof ICPPAliasTemplate) { + ICPPAliasTemplate aliasTemplate = (ICPPAliasTemplate) template; + IType aliasedType = aliasTemplate.getType(); + ICPPTemplateArgument[] args = createTemplateArgumentArray(id); + args = addDefaultArguments(aliasTemplate, args, id); + ICPPTemplateParameterMap parameterMap = createParameterMap(aliasTemplate, args); + IBinding owner = template.getOwner(); + ICPPClassSpecialization within = getSpecializationContext(owner); + IType instantiatedType = instantiateType(aliasedType, parameterMap, -1, within, id); + return new CPPAliasTemplateInstance(id.toCharArray(), instantiatedType, aliasTemplate); + } + + // Class template. if (template instanceof ICPPConstructor) { template= template.getOwner(); } if (template instanceof ICPPUnknownMemberClass) { - IType owner= ((ICPPUnknownMemberClass)template).getOwnerType(); + IType owner= ((ICPPUnknownMemberClass) template).getOwnerType(); ICPPTemplateArgument[] args= createTemplateArgumentArray(id); args= SemanticUtil.getSimplifiedArguments(args); return new CPPUnknownClassInstance(owner, id.getSimpleID(), args); @@ -716,8 +732,9 @@ public class CPPTemplates { if (parentOfName instanceof ICPPASTElaboratedTypeSpecifier || parentOfName instanceof ICPPASTCompositeTypeSpecifier || parentOfName instanceof ICPPASTNamedTypeSpecifier || - parentOfName instanceof ICPPASTBaseSpecifier) + parentOfName instanceof ICPPASTBaseSpecifier) { return true; + } if (parentOfName instanceof IASTDeclarator) { IASTDeclarator rel= ASTQueries.findTypeRelevantDeclarator((IASTDeclarator) parentOfName); @@ -726,7 +743,6 @@ public class CPPTemplates { return false; } - public static ICPPTemplateInstance createInstance(IBinding owner, ICPPTemplateDefinition template, CPPTemplateParameterMap tpMap, ICPPTemplateArgument[] args, IASTNode point) { if (owner instanceof ICPPSpecialization) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java index a2ab1c782ca..6c3d7d56605 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java @@ -10,6 +10,7 @@ * Markus Schorn (Wind River Systems) * Andrew Ferguson (Symbian) * Sergey Prigogin (Google) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.cpp.semantics; @@ -93,6 +94,7 @@ import org.eclipse.cdt.core.dom.ast.ISemanticProblem; import org.eclipse.cdt.core.dom.ast.IType; import org.eclipse.cdt.core.dom.ast.ITypedef; import org.eclipse.cdt.core.dom.ast.IVariable; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCatchHandler; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier; @@ -197,6 +199,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPPointerToMemberType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPPointerType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPReferenceType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPScope; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPAliasTemplate; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplateParameterMap; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplateTypeArgument; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTypedef; @@ -658,6 +661,36 @@ public class CPPVisitor extends ASTQueries { return binding; } + else if (declaration instanceof ICPPASTAliasDeclaration){ + ICPPASTAliasDeclaration alias = (ICPPASTAliasDeclaration) declaration; + ICPPScope scope = (ICPPScope) getContainingScope(declaration); + IBinding binding = scope.getBinding(alias.getAlias(), false); + if(!(binding instanceof ICPPInternalBinding)) { + + IType type = createType(alias.getMappingTypeId()); + if (type instanceof IProblemBinding) { + IProblemBinding problem = (IProblemBinding) type; + type = new CPPClassType.CPPClassTypeProblem(problem.getASTNode(), problem.getID(), alias.getMappingTypeId().getAbstractDeclarator().getName().toCharArray()); + } + if (type != null) { + if(alias.getParent() instanceof ICPPASTTemplateDeclaration){ + CPPAliasTemplate templateAlias = new CPPAliasTemplate(alias.getAlias()); + templateAlias.setType(type); + binding = templateAlias; + } + else{ + CPPTypedef typedef = new CPPTypedef(alias.getAlias()); + typedef.setType(type); + binding = typedef; + } + } else { + binding = new ProblemBinding(alias.getAlias(), IProblemBinding.SEMANTIC_NAME_NOT_FOUND); + } + } + + return binding; + + } return null; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/DeclarationWriter.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/DeclarationWriter.java index dc15a60bdc3..8776a2a3df9 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/DeclarationWriter.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/DeclarationWriter.java @@ -10,6 +10,7 @@ * Institute for Software - initial API and implementation * Markus Schorn (Wind River Systems) * Sergey Prigogin (Google) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.rewrite.astwriter; @@ -18,9 +19,11 @@ import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTDeclaration; import org.eclipse.cdt.core.dom.ast.IASTDeclarator; import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition; +import org.eclipse.cdt.core.dom.ast.IASTName; import org.eclipse.cdt.core.dom.ast.IASTProblemDeclaration; import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTAliasDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCatchHandler; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTConstructorChainInitializer; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTExplicitTemplateInstantiation; @@ -32,6 +35,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNamespaceDefinition; 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.ICPPASTTemplateSpecialization; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTypeId; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUsingDeclaration; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUsingDirective; import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTVisibilityLabel; @@ -93,6 +97,8 @@ public class DeclarationWriter extends NodeWriter { writeUsingDirective((ICPPASTUsingDirective) declaration); } else if (declaration instanceof ICPPASTVisibilityLabel) { writeVisibilityLabel((ICPPASTVisibilityLabel) declaration); + } else if (declaration instanceof ICPPASTAliasDeclaration) { + writeAliasDeclaration((ICPPASTAliasDeclaration) declaration); } writeTrailingComments(declaration, addNewLine); @@ -104,6 +110,20 @@ public class DeclarationWriter extends NodeWriter { } } + private void writeAliasDeclaration(ICPPASTAliasDeclaration aliasDeclaration) { + scribe.printStringSpace(Keywords.USING); + IASTName alias = aliasDeclaration.getAlias(); + if (alias != null) { + alias.accept(visitor); + } + scribe.print(EQUALS); + ICPPASTTypeId aliasedType = aliasDeclaration.getMappingTypeId(); + if (aliasedType != null) { + aliasedType.accept(visitor); + } + scribe.printSemicolon(); + } + private void writeVisibilityLabel(ICPPASTVisibilityLabel visiblityLabel) { scribe.decrementIndentationLevel(); switch (visiblityLabel.getVisibility()) { diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IIndexCPPBindingConstants.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IIndexCPPBindingConstants.java index ac8795b0018..7aab87f9d8d 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IIndexCPPBindingConstants.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/IIndexCPPBindingConstants.java @@ -8,6 +8,7 @@ * Contributors: * Andrew Ferguson (Symbian) - Initial implementation * Markus Schorn (Wind River Systems) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.index; @@ -60,4 +61,5 @@ public interface IIndexCPPBindingConstants { int CPP_UNKNOWN_FIELD = IIndexBindingConstants.LAST_CONSTANT + 48; int CPP_USING_DECLARATION_SPECIALIZATION= IIndexBindingConstants.LAST_CONSTANT + 49; int CPP_UNKNOWN_METHOD = IIndexBindingConstants.LAST_CONSTANT + 50; + int CPP_TEMPLATE_ALIAS = IIndexBindingConstants.LAST_CONSTANT + 51; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPAliasTemplate.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPAliasTemplate.java new file mode 100644 index 00000000000..7cf0c3c4971 --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPAliasTemplate.java @@ -0,0 +1,118 @@ +/******************************************************************************* + * Copyright (c) 2012 Institute for Software, HSR Hochschule fuer Technik + * Rapperswil, University of applied sciences. + * 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: + * Thomas Corbat (IFS) - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.internal.core.pdom.dom.cpp; + +import org.eclipse.cdt.core.CCorePlugin; +import org.eclipse.cdt.core.dom.ast.DOMException; +import org.eclipse.cdt.core.dom.ast.IType; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter; +import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants; +import org.eclipse.cdt.internal.core.pdom.db.Database; +import org.eclipse.cdt.internal.core.pdom.dom.PDOMNode; +import org.eclipse.core.runtime.CoreException; + +/** + * PDOM binding for alias template. + */ +class PDOMCPPAliasTemplate extends PDOMCPPBinding implements ICPPAliasTemplate { + private static final int ALIASED_TYPE_SIZE = Database.TYPE_SIZE; + private static final int TEMPLATE_PARAMS_SIZE = PDOMCPPTemplateTemplateParameter.RECORD_SIZE; + @SuppressWarnings("hiding") + protected static final int RECORD_SIZE = PDOMCPPBinding.RECORD_SIZE + ALIASED_TYPE_SIZE + TEMPLATE_PARAMS_SIZE; + + private static final int ALIASED_TYPE_OFFSET = PDOMCPPBinding.RECORD_SIZE + 0; + private static final int TEMPLATE_PARAMS_OFFSET = ALIASED_TYPE_OFFSET + ALIASED_TYPE_SIZE; + + private volatile IPDOMCPPTemplateParameter[] parameters; + + public PDOMCPPAliasTemplate(PDOMCPPLinkage linkage, PDOMNode parent, + ICPPAliasTemplate templateAlias) throws CoreException, DOMException { + super(linkage, parent, templateAlias.getNameCharArray()); + setTemplateParameters(linkage, templateAlias.getTemplateParameters()); + setType(linkage, templateAlias.getType()); + } + + public PDOMCPPAliasTemplate(PDOMCPPLinkage linkage, long record) { + super(linkage, record); + } + + private void setTemplateParameters(PDOMCPPLinkage linkage, + final ICPPTemplateParameter[] origParams) throws CoreException, DOMException { + parameters = PDOMTemplateParameterArray.createPDOMTemplateParameters(linkage, this, origParams); + final Database db = getDB(); + long rec= PDOMTemplateParameterArray.putArray(db, parameters); + db.putRecPtr(record + TEMPLATE_PARAMS_OFFSET, rec); + linkage.new ConfigureTemplateParameters(origParams, parameters); + } + + private void setType(PDOMCPPLinkage linkage, IType aliasedType) throws CoreException { + linkage.storeType(record + ALIASED_TYPE_OFFSET, aliasedType); + } + + @Override + public int getNodeType() { + return IIndexCPPBindingConstants.CPP_TEMPLATE_ALIAS; + } + + @Override + public boolean isSameType(IType type) { + if(type == null){ + return false; + } + IType aliasedType = getType(); + return type.isSameType(aliasedType); + } + + @Override + public ICPPTemplateParameter[] getTemplateParameters() { + if (parameters == null) { + try { + Database db = getDB(); + long rec= db.getRecPtr(record + TEMPLATE_PARAMS_OFFSET); + if (rec == 0) { + parameters= IPDOMCPPTemplateParameter.EMPTY_ARRAY; + } else { + parameters= PDOMTemplateParameterArray.getArray(this, rec); + } + } catch (CoreException e) { + CCorePlugin.log(e); + parameters = IPDOMCPPTemplateParameter.EMPTY_ARRAY; + } + } + return parameters; + } + + @Override + public IType getType() { + try { + return getLinkage().loadType(record + ALIASED_TYPE_OFFSET); + } catch (CoreException e) { + CCorePlugin.log(e); + return null; + } + } + + @Override + protected int getRecordSize() { + return RECORD_SIZE; + } + + @Override + public Object clone() { + try { + return super.clone(); + } catch (CloneNotSupportedException e) { + } + return null; + } +} \ No newline at end of file diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java index 0160143f331..920b06a2789 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java @@ -10,6 +10,7 @@ * Markus Schorn (Wind River Systems) * Andrew Ferguson (Symbian) * Sergey Prigogin (Google) + * Thomas Corbat (IFS) *******************************************************************************/ package org.eclipse.cdt.internal.core.pdom.dom.cpp; @@ -60,6 +61,8 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace; import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceAlias; import org.eclipse.cdt.core.dom.ast.cpp.ICPPParameter; import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplate; +import org.eclipse.cdt.core.dom.ast.cpp.ICPPAliasTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateArgument; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance; import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateNonTypeParameter; @@ -86,6 +89,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPPointerToMemberType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPPointerType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPQualifierType; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPReferenceType; +import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPAliasTemplateInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPUnknownClassInstance; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPUnknownMember; import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper; @@ -409,6 +413,8 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants { } } else if (binding instanceof ITypedef) { pdomBinding = new PDOMCPPTypedef(this, parent, (ITypedef) binding); + } else if (binding instanceof ICPPAliasTemplate) { + pdomBinding = new PDOMCPPAliasTemplate(this, parent, (ICPPAliasTemplate) binding); } if (pdomBinding != null) { @@ -601,11 +607,18 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants { return CPPENUMERATOR; } else if (binding instanceof ITypedef) { return CPPTYPEDEF; + } else if (binding instanceof ICPPAliasTemplate) { + return CPP_TEMPLATE_ALIAS; } return 0; } + @Override + protected boolean cannotAdapt(final IBinding inputBinding) throws CoreException { + return super.cannotAdapt(inputBinding) || inputBinding instanceof ICPPAliasTemplateInstance; + } + @Override public final PDOMBinding adaptBinding(final IBinding inputBinding, boolean includeLocal) throws CoreException { return adaptBinding(null, inputBinding, includeLocal ? FILE_LOCAL_REC_DUMMY : null); @@ -825,6 +838,8 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants { return new PDOMCPPTypedefSpecialization(this, record); case CPP_USING_DECLARATION_SPECIALIZATION: return new PDOMCPPUsingDeclarationSpecialization(this, record); + case CPP_TEMPLATE_ALIAS: + return new PDOMCPPAliasTemplate(this, record); } assert false : "nodeid= " + nodeType; //$NON-NLS-1$ return null; @@ -1044,6 +1059,8 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants { return CPPUnknownClassInstance.unmarshal(getPDOM(), firstByte, buffer); case ITypeMarshalBuffer.DEFERRED_CLASS_INSTANCE: return CPPDeferredClassInstance.unmarshal(getPDOM(), firstByte, buffer); + case ITypeMarshalBuffer.ALIAS_TEMPLATE: + return CPPAliasTemplateInstance.unmarshal(firstByte, buffer); } throw new CoreException(CCorePlugin.createStatus("Cannot unmarshal a type, first byte=" + firstByte)); //$NON-NLS-1$