| /******************************************************************************* |
| * Copyright (c) 2007, 2015 Symbian Software Systems and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Andrew Ferguson (Symbian) - Initial implementation |
| * Markus Schorn (Wind River Systems) |
| * Sergey Prigogin (Google) |
| * Nathan Ridge |
| *******************************************************************************/ |
| package org.eclipse.cdt.internal.index.tests; |
| |
| import java.io.IOException; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| import org.eclipse.cdt.core.dom.ast.ASTTypeUtil; |
| import org.eclipse.cdt.core.dom.ast.DOMException; |
| import org.eclipse.cdt.core.dom.ast.EScopeKind; |
| import org.eclipse.cdt.core.dom.ast.IASTProblem; |
| import org.eclipse.cdt.core.dom.ast.IBinding; |
| import org.eclipse.cdt.core.dom.ast.ICompositeType; |
| import org.eclipse.cdt.core.dom.ast.IEnumeration; |
| import org.eclipse.cdt.core.dom.ast.IEnumerator; |
| import org.eclipse.cdt.core.dom.ast.IFunction; |
| import org.eclipse.cdt.core.dom.ast.IPointerType; |
| import org.eclipse.cdt.core.dom.ast.IProblemType; |
| import org.eclipse.cdt.core.dom.ast.IType; |
| import org.eclipse.cdt.core.dom.ast.IValue; |
| import org.eclipse.cdt.core.dom.ast.IVariable; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPBinding; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassScope; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPConstructor; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPField; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionType; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespace; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPNamespaceScope; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPPointerToMemberType; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable; |
| import org.eclipse.cdt.core.dom.ast.cpp.SemanticQueries; |
| import org.eclipse.cdt.core.index.IIndex; |
| import org.eclipse.cdt.core.index.IIndexBinding; |
| import org.eclipse.cdt.core.parser.IProblem; |
| import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper; |
| import org.eclipse.core.runtime.CoreException; |
| |
| import junit.framework.TestSuite; |
| |
| /** |
| * For testing PDOM binding CPP language resolution |
| */ |
| /* |
| * aftodo - once we have non-problem bindings working, each test should |
| * additionally check that the binding obtained has characteristics as |
| * expected (type,name,etc..) |
| */ |
| public abstract class IndexCPPBindingResolutionTest extends IndexBindingResolutionTestBase { |
| |
| public static class SingleProjectTest extends IndexCPPBindingResolutionTest { |
| public SingleProjectTest() { |
| setStrategy(new SinglePDOMTestStrategy(true)); |
| } |
| |
| public static TestSuite suite() { |
| return suite(SingleProjectTest.class); |
| } |
| } |
| |
| public static class ProjectWithDepProjTest extends IndexCPPBindingResolutionTest { |
| public ProjectWithDepProjTest() { |
| setStrategy(new ReferencedProject(true)); |
| } |
| |
| public static TestSuite suite() { |
| return suite(ProjectWithDepProjTest.class); |
| } |
| } |
| |
| public static void addTests(TestSuite suite) { |
| suite.addTest(SingleProjectTest.suite()); |
| suite.addTest(ProjectWithDepProjTest.suite()); |
| } |
| |
| public IndexCPPBindingResolutionTest() { |
| setStrategy(new SinglePDOMTestStrategy(true)); |
| } |
| |
| public static TestSuite suite() { |
| return suite(SingleProjectTest.class); |
| } |
| |
| /* Assertion helpers */ |
| /* ##################################################################### */ |
| |
| static protected void assertField(IBinding binding, String qn, Class expType, String expTypeQN) { |
| assertTrue(binding instanceof ICPPField); |
| ICPPField field = (ICPPField) binding; |
| assertQNEquals(qn, field); |
| assertTrue(expType.isInstance(field.getType())); |
| if (expTypeQN != null) { |
| assert (field.getType() instanceof ICPPBinding); |
| ICPPBinding tyBinding = (ICPPBinding) field.getType(); |
| assertQNEquals(expTypeQN, tyBinding); |
| } |
| } |
| |
| static protected void assertClassTypeBinding(IBinding binding, String qn, int key, int bases, int fields, |
| int declaredFields, int methods, int declaredMethods, int allDeclaredMethods, int friends, int constructors, |
| int nestedClasses) { |
| assertTrue(binding instanceof ICPPClassType); |
| assertClassType((ICPPClassType) binding, qn, key, bases, fields, declaredFields, methods, declaredMethods, |
| allDeclaredMethods, friends, constructors, nestedClasses); |
| } |
| |
| static protected void assertClassType(IType type, String qn, int key, int bases, int fields, int declaredFields, |
| int methods, int declaredMethods, int allDeclaredMethods, int friends, int constructors, |
| int nestedClasses) { |
| assertTrue(type instanceof ICPPClassType); |
| ICPPClassType classType = (ICPPClassType) type; |
| assertQNEquals(qn, classType); |
| assertEquals(key, classType.getKey()); |
| assertEquals(bases, classType.getBases().length); |
| assertEquals(fields, classType.getFields().length); |
| assertEquals(declaredFields, classType.getDeclaredFields().length); |
| assertEquals(methods, classType.getMethods().length); |
| assertEquals(declaredMethods, classType.getDeclaredMethods().length); |
| assertEquals(allDeclaredMethods, classType.getAllDeclaredMethods().length); |
| assertEquals(friends, classType.getFriends().length); |
| assertEquals(constructors, classType.getConstructors().length); |
| assertEquals(nestedClasses, classType.getNestedClasses().length); |
| } |
| |
| public void assertEnumeration(IBinding binding, String name, String[] enumerators) throws DOMException { |
| assertTrue(binding instanceof IEnumeration); |
| assertEquals(name, binding.getName()); |
| IEnumerator[] aEnumerators = ((IEnumeration) binding).getEnumerators(); |
| Set expectedEnumerators = new HashSet(); |
| expectedEnumerators.addAll(Arrays.asList(enumerators)); |
| Set actualEnumerators = new HashSet(); |
| for (IEnumerator enumerator : aEnumerators) { |
| actualEnumerators.add(enumerator.getName()); |
| } |
| assertEquals(expectedEnumerators, actualEnumerators); |
| } |
| |
| /** |
| * @param type |
| * @param cqn |
| * @param qn may be null |
| */ |
| static protected void assertPTM(IType type, String cqn, String qn) { |
| assertTrue(type instanceof ICPPPointerToMemberType); |
| ICPPPointerToMemberType ptmt = (ICPPPointerToMemberType) type; |
| ICPPClassType classType = (ICPPClassType) ptmt.getMemberOfClass(); |
| assertQNEquals(cqn, classType); |
| if (qn != null) { |
| assert (ptmt.getType() instanceof ICPPBinding); |
| ICPPBinding tyBinding = (ICPPBinding) ptmt.getType(); |
| assertQNEquals(qn, tyBinding); |
| } |
| } |
| |
| private void asserValueEquals(IValue initialValue, long i) { |
| assertNotNull(initialValue); |
| final Number numericalValue = initialValue.numberValue(); |
| assertNotNull(numericalValue); |
| assertEquals(i, numericalValue.longValue()); |
| } |
| |
| private void assertUserDefinedLiteralType(String retName) { |
| ICPPVariable v = getBindingFromFirstIdentifier("test ="); |
| assertEquals(retName, ASTTypeUtil.getType(v.getType())); |
| } |
| |
| // namespace ns { class A; enum E {E1}; typedef int T; } |
| // |
| // class B { |
| // public: |
| // void m(ns::A* a); |
| // void n(ns::E* a); |
| // void o(ns::T* a); |
| // void p(ns::E a); |
| // }; |
| |
| // namespace ns { |
| // class A {}; |
| // typedef int T; |
| // } |
| // |
| // using ns::A; |
| // using ns::E; |
| // using ns::T; |
| // using ns::E1; |
| // |
| // void B::m(A* a) {} |
| // void B::n(E* a) {} |
| // void B::o(T* a) {} |
| // void B::p(E a) {} |
| // |
| // void usage() { |
| // B b; |
| // b.p(E1); |
| // } |
| public void testUsingTypeDeclaration_201177() { |
| IBinding b0 = getBindingFromASTName("B::m", 4); |
| IBinding b1 = getBindingFromASTName("B::n", 4); |
| IBinding b2 = getBindingFromASTName("B::o", 4); |
| IBinding b3 = getBindingFromASTName("p(E1)", 1); |
| assertInstance(b0, ICPPMethod.class); |
| assertInstance(b1, ICPPMethod.class); |
| assertInstance(b2, ICPPMethod.class); |
| } |
| |
| // namespace n { class A{}; class B{}; class C{}; } |
| |
| // namespace m { |
| // using namespace n; |
| // class D{}; |
| // } |
| // m::C c; |
| // m::D d; |
| public void testUsingNamingDirective_177917_1a() { |
| IBinding b0 = getBindingFromASTName("C c", 1); |
| IBinding b1 = getBindingFromASTName("D d", 1); |
| } |
| |
| // namespace n { class A{}; } |
| // namespace m { |
| // using namespace n; |
| // class B {}; |
| // } |
| |
| // namespace n { class C{}; } |
| // m::C c; |
| public void testUsingNamingDirective_177917_1b() { |
| IBinding b0 = getBindingFromFirstIdentifier("C c"); |
| } |
| |
| // int ff(int x) { return x; } |
| // namespace n { class A {}; } |
| // namespace m { class B {}; enum C{CE1,CE2}; } |
| // namespace o { int (*f)(int)= ff; } |
| |
| // using n::A; |
| // A a; |
| // using namespace m; |
| // B b; |
| // C c= CE1; |
| // using o::f; |
| // int g(int x) {return 4;} |
| // int g(char x) {return 2;} |
| // int nn= g(f(2)); |
| public void testUsingTypeDeclaration_177917_1() { |
| IBinding b1 = getBindingFromASTName("A a", 1); |
| IBinding b2 = getBindingFromASTName("B b", 1); |
| IBinding b3 = getBindingFromASTName("C c", 1); |
| IBinding b4 = getBindingFromASTName("CE1", 3); |
| IBinding b5 = getBindingFromASTName("f(2", 1); |
| } |
| |
| // namespace a { class A {}; } |
| // namespace b { |
| // using a::A; |
| // class B {}; |
| // } |
| |
| // b::A aa; |
| // b::B bb; |
| public void testUsingTypeDeclaration_177917_2() { |
| IBinding b0 = getBindingFromASTName("A aa", 1); |
| IBinding b1 = getBindingFromASTName("B bb", 1); |
| } |
| |
| // namespace header { |
| // class clh { |
| // }; |
| // void fh(); |
| // void fh(int a); |
| // |
| // class cl { |
| // }; |
| // void f(); |
| // void f(int a); |
| // } |
| // using header::clh; |
| // using header::fh; |
| |
| // namespace source { |
| // class cls { |
| // }; |
| // void fs(); |
| // void fs(int a); |
| // |
| // } |
| // using header::cl; |
| // using header::f; |
| // |
| // |
| // using source::cls; |
| // using source::fs; |
| // |
| // void test() { |
| // fh(); |
| // fh(1); |
| // |
| // clh c; |
| // |
| // f(); |
| // f(1); |
| // cl c1; |
| // |
| // fs(); |
| // fs(1); |
| // cls c2; |
| // } |
| public void testUsingOverloadedFunctionDeclaration() { |
| IBinding b; |
| b = getBindingFromASTName("fh()", 2); |
| b = getBindingFromASTName("fh(1)", 2); |
| b = getBindingFromASTName("clh c", 3); |
| b = getBindingFromASTName("f()", 1); |
| b = getBindingFromASTName("f(1)", 1); |
| b = getBindingFromASTName("cl c1", 2); |
| b = getBindingFromASTName("fs()", 2); |
| b = getBindingFromASTName("fs(1)", 2); |
| b = getBindingFromASTName("cls c2", 3); |
| } |
| |
| // int (*f)(int); |
| // int g(int n){return n;} |
| // int g(int n, int m){ return n+m; } |
| |
| // void foo() { |
| // f= g; |
| // } |
| public void testPointerToFunction() { |
| IBinding b0 = getBindingFromASTName("f= g;", 1); |
| IBinding b1 = getBindingFromASTName("g;", 1); |
| |
| assertInstance(b0, ICPPVariable.class); |
| ICPPVariable v0 = (ICPPVariable) b0; |
| assertInstance(v0.getType(), IPointerType.class); |
| IPointerType p0 = (IPointerType) v0.getType(); |
| assertInstance(p0.getType(), ICPPFunctionType.class); |
| ICPPFunctionType f0 = (ICPPFunctionType) p0.getType(); |
| assertInstance(f0.getReturnType(), ICPPBasicType.class); |
| assertEquals(1, f0.getParameterTypes().length); |
| assertInstance(f0.getParameterTypes()[0], ICPPBasicType.class); |
| |
| assertInstance(b1, ICPPFunction.class); |
| ICPPFunctionType f1 = ((ICPPFunction) b1).getType(); |
| assertInstance(f1.getReturnType(), ICPPBasicType.class); |
| assertEquals(1, f1.getParameterTypes().length); |
| assertInstance(f1.getParameterTypes()[0], ICPPBasicType.class); |
| } |
| |
| // class Base {public: int field; void foo() {}}; |
| // class C : public Base { |
| // public: |
| // struct CS { long* l; C *method(CS **); }; |
| // CS cs; |
| // CS **cspp; |
| // long * CS::* ouch; |
| // long * CS::* autsch; |
| // C* (CS::*method)(CS **); |
| // }; |
| |
| // C *cp = new C(); /*b0, b1*/ |
| // void references() { |
| // long l = 5, *lp; |
| // lp = &l; |
| // cp->cs.*cp->ouch = lp = cp->cs.*cp->autsch; /*b2, b3, b4*/ |
| // &(cp->cs)->*cp->autsch = lp = &(cp->cs)->*cp->ouch; |
| // (cp->cs).method(cp->cspp);/*1*/ (&(cp->cs))->method(cp->cspp);/*2*/ |
| // ((cp->cs).*(cp->method))(cp->cspp);/*3*/ |
| // ((&(cp->cs))->*(cp->method))(cp->cspp);/*4*/ |
| // } |
| public void testPointerToMemberFields() throws IOException, DOMException { |
| IBinding b0 = getBindingFromASTName("C *cp", 1); |
| assertClassType((ICPPClassType) b0, "C", ICPPClassType.k_class, 1, 6, 5, 9, 0, 1, 0, 2, 1); |
| |
| IBinding b1 = getBindingFromASTName("cp = new C()", 2); |
| assertVariable(b1, "cp", IPointerType.class, null); |
| IPointerType b1type = (IPointerType) ((ICPPVariable) b1).getType(); |
| assertClassType(b1type.getType(), "C", ICPPClassType.k_class, 1, 6, 5, 9, 0, 1, 0, 2, 1); |
| |
| IBinding b2 = getBindingFromASTName("cs.*cp->o", 2); |
| ICPPField field0 = (ICPPField) b2; |
| assertTrue(field0.getType() instanceof ICPPClassType); |
| |
| IBinding b3 = getBindingFromASTName("ouch = lp", 4); |
| assertField(b3, "C::ouch", ICPPPointerToMemberType.class, null); |
| assertPTM(((ICPPField) b3).getType(), "C::CS", null); |
| |
| IBinding b4 = getBindingFromASTName("autsch;", 6); |
| assertField(b4, "C::autsch", ICPPPointerToMemberType.class, null); |
| assertPTM(((ICPPField) b4).getType(), "C::CS", null); |
| |
| IBinding b5 = getBindingFromASTName("cs)->*cp->a", 2); |
| assertField(b5, "C::cs", ICPPClassType.class, "C::CS"); |
| assertClassType(((ICPPField) b5).getType(), "C::CS", ICompositeType.k_struct, 0, 1, 1, 5, 1, 1, 0, 2, 0); |
| |
| IBinding b6 = getBindingFromASTName("autsch = lp", 6); |
| assertField(b4, "C::autsch", ICPPPointerToMemberType.class, null); |
| assertPTM(((ICPPField) b4).getType(), "C::CS", null); |
| |
| IBinding b7 = getBindingFromASTName("ouch;", 4); |
| assertField(b3, "C::ouch", ICPPPointerToMemberType.class, null); |
| assertPTM(((ICPPField) b3).getType(), "C::CS", null); |
| } |
| |
| // class C {}; struct S {}; union U {}; enum E {ER1,ER2,ER3}; |
| // int var1; C var2; S *var3; void func(E); void func(C); |
| // namespace ns {} |
| // typedef int Int; typedef int *IntPtr; |
| // void func(int*); void func(int); |
| |
| // void references() { |
| // C c; /*c*/ S s; /*s*/ U u; /*u*/ E e; /*e*/ |
| // var1 = 1; /*var1*/ var2 = c; /*var2*/ var3 = &s; /*var3*/ |
| // func(e); /*func1*/ func(var1); /*func2*/ func(c); /*func3*/ |
| // Int a; /*a*/ |
| // IntPtr b = &a; /*b*/ |
| // func(*b); /*func4*/ func(a); /*func5*/ |
| // } |
| // class C2 : public C {}; /*base*/ |
| // struct S2 : public S {}; /*base*/ |
| public void testSimpleGlobalBindings() throws IOException, DOMException { |
| { |
| IBinding b0 = getBindingFromASTName("C c; ", 1); |
| assertClassTypeBinding(b0, "C", ICPPClassType.k_class, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| |
| IBinding b1 = getBindingFromASTName("c; ", 1); |
| assertVariable(b1, "c", ICPPClassType.class, "C"); |
| ICPPClassType b1type = (ICPPClassType) ((ICPPVariable) b1).getType(); |
| assertClassTypeBinding(b1type, "C", ICPPClassType.k_class, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| assertEquals(EScopeKind.eGlobal, b1type.getScope().getKind()); |
| assertTrue(b1type.getCompositeScope() instanceof ICPPClassScope); |
| assertClassTypeBinding(((ICPPClassScope) b1type.getCompositeScope()).getClassType(), "C", |
| ICPPClassType.k_class, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| } |
| { |
| IBinding b2 = getBindingFromASTName("S s;", 1); |
| assertClassTypeBinding(b2, "S", ICompositeType.k_struct, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| |
| IBinding b3 = getBindingFromASTName("s;", 1); |
| assertVariable(b3, "s", ICPPClassType.class, "S"); |
| ICPPClassType b3type = (ICPPClassType) ((ICPPVariable) b3).getType(); |
| assertClassTypeBinding(b3type, "S", ICompositeType.k_struct, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| } |
| { |
| IBinding b4 = getBindingFromASTName("U u;", 1); |
| assertClassTypeBinding(b4, "U", ICompositeType.k_union, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| |
| IBinding b5 = getBindingFromASTName("u; ", 1); |
| assertVariable(b5, "u", ICPPClassType.class, "U"); |
| ICPPClassType b5type = (ICPPClassType) ((ICPPVariable) b5).getType(); |
| assertClassTypeBinding(b5type, "U", ICompositeType.k_union, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| } |
| { |
| IBinding b6 = getBindingFromASTName("E e; ", 1); |
| assertEnumeration(b6, "E", new String[] { "ER1", "ER2", "ER3" }); |
| |
| IBinding b7 = getBindingFromASTName("e; ", 1); |
| assertVariable(b7, "e", IEnumeration.class, "E"); |
| IEnumeration b5type = (IEnumeration) ((ICPPVariable) b7).getType(); |
| assertEnumeration(b5type, "E", new String[] { "ER1", "ER2", "ER3" }); |
| assertEquals(EScopeKind.eGlobal, b5type.getScope().getKind()); |
| } |
| { |
| IBinding b8 = getBindingFromASTName("var1 = 1;", 4); |
| assertVariable(b8, "var1", ICPPBasicType.class, null); |
| } |
| { |
| IBinding b9 = getBindingFromASTName("var2 = c;", 4); |
| assertVariable(b9, "var2", ICPPClassType.class, "C"); |
| ICPPClassType b9type = (ICPPClassType) ((ICPPVariable) b9).getType(); |
| assertClassTypeBinding(b9type, "C", ICPPClassType.k_class, 0, 0, 0, 4, 0, 0, 0, 2, 0); |
| } |
| { |
| IBinding b10 = getBindingFromASTName("var3 = &s;", 4); |
| assertVariable(b10, "var3", IPointerType.class, null); |
| IPointerType b10type = (IPointerType) ((ICPPVariable) b10).getType(); |
| assertClassTypeBinding((ICPPClassType) b10type.getType(), "S", ICompositeType.k_struct, 0, 0, 0, 4, 0, 0, 0, |
| 2, 0); |
| } |
| { |
| IBinding b11 = getBindingFromASTName("func(e);", 4); |
| } |
| IBinding b12 = getBindingFromASTName("func(var1);", 4); |
| IBinding b13 = getBindingFromASTName("func(c);", 4); |
| IBinding b14 = getBindingFromASTName("Int a; ", 3); |
| IBinding b15 = getBindingFromASTName("a; ", 1); |
| IBinding b16 = getBindingFromASTName("IntPtr b = &a; ", 6); |
| IBinding b17 = getBindingFromASTName("b = &a; /*b*/", 1); |
| IBinding b18 = getBindingFromASTName("func(*b);", 4); |
| IBinding b19 = getBindingFromASTName("b); /*func4*/", 1); |
| IBinding b20 = getBindingFromASTName("func(a);", 4); |
| IBinding b21 = getBindingFromASTName("a); /*func5*/", 1); |
| IBinding b22 = getBindingFromASTName("C2 : public", 2); |
| IBinding b23 = getBindingFromASTName("C {}; /*base*/", 1); |
| IBinding b24 = getBindingFromASTName("S2 : public", 2); |
| IBinding b25 = getBindingFromASTName("S {}; /*base*/", 1); |
| } |
| |
| //// header content |
| //class TopC {}; struct TopS {}; union TopU {}; enum TopE {TopER1,TopER2}; |
| //short topBasic; void *topPtr; TopC *topCPtr; TopU topFunc(){return *new TopU();} |
| |
| //// referencing content |
| //namespace n1 { |
| // class TopC {}; struct TopS {}; union TopU {}; enum TopE {TopER1,TopER2}; |
| // short topBasic; void *topPtr;/*A*/ TopC *topCPtr;/*A*/ TopU topFunc(){return *new TopU();} |
| // class C { |
| // class TopC {}; struct TopS {}; union TopU {}; enum TopE {TopER1,TopER2}; |
| // short topBasic; void *topPtr;/*B*/ TopC *topCPtr;/*B*/ TopU topFunc(){return *new TopU();} |
| // void references() { |
| // ::TopC c; ::TopS s; ::TopU u; ::TopE e = ::TopER1; |
| // ::topBasic++; ::topPtr = &::topBasic; ::topCPtr = &c; ::topFunc(); |
| // } |
| // }; |
| //} |
| public void testSingletonQualifiedName() { |
| IBinding b0 = getBindingFromASTName("TopC c", 4); |
| IBinding b1 = getBindingFromASTName("TopS s", 4); |
| IBinding b2 = getBindingFromASTName("TopU u", 4); |
| IBinding b3 = getBindingFromASTName("TopE e", 4); |
| IBinding b4 = getBindingFromASTName("TopER1;", 6); |
| IBinding b5 = getBindingFromASTName("topBasic++", 8); |
| IBinding b6 = getBindingFromASTName("topPtr = &", 6); |
| IBinding b7 = getBindingFromASTName("topBasic; ::", 8); |
| IBinding b8 = getBindingFromASTName("topCPtr = &", 7); |
| IBinding b9 = getBindingFromASTName("topFunc();", 7); |
| |
| IBinding _b5 = getBindingFromASTName("topBasic; v", 8); |
| IBinding _b6 = getBindingFromASTName("topPtr;/*A*/", 6); |
| IBinding _b7 = getBindingFromASTName("topPtr;/*B*/", 6); |
| IBinding _b8 = getBindingFromASTName("topCPtr;/*A*/", 7); |
| IBinding _b9 = getBindingFromASTName("topCPtr;/*B*/", 7); |
| IBinding _b10 = getBindingFromASTName("topFunc(){", 7); |
| } |
| |
| // // header content |
| // namespace n1 { namespace n2 { struct S {}; } } |
| // class c1 { public: class c2 { public: struct S {}; }; }; |
| // struct s1 { struct s2 { struct S {}; }; }; |
| // union u1 { struct u2 { struct S {}; }; }; |
| // namespace n3 { class c3 { public: struct s3 { union u3 { struct S {}; }; }; }; } |
| |
| // // reference content |
| // void reference() { |
| // ::n1::n2::S _s0; n1::n2::S _s1; |
| // ::c1::c2::S _s2; c1::c2::S _s3; |
| // ::s1::s2::S _s4; s1::s2::S _s5; |
| // ::u1::u2::S _s6; u1::u2::S _s7; |
| // ::n3::c3::s3::u3::S _s8; |
| // n3::c3::s3::u3::S _s9; |
| // } |
| // namespace n3 { c3::s3::u3::S _s10; } |
| // namespace n1 { n2::S _s11; } |
| // namespace n1 { namespace n2 { S _s12; }} |
| public void testQualifiedNamesForStruct() throws DOMException { |
| IBinding b0 = getBindingFromASTName("S _s0;", 1); |
| assertTrue(b0.getScope() instanceof ICPPNamespaceScope); |
| assertTrue(b0.getScope().getParent() instanceof ICPPNamespaceScope); |
| assertEquals(EScopeKind.eGlobal, b0.getScope().getParent().getParent().getKind()); |
| assertQNEquals("n1::n2::S", b0); |
| |
| IBinding b1 = getBindingFromASTName("S _s1;", 1); |
| assertTrue(b1.getScope() instanceof ICPPNamespaceScope); |
| assertTrue(b1.getScope().getParent() instanceof ICPPNamespaceScope); |
| assertEquals(EScopeKind.eGlobal, b1.getScope().getParent().getParent().getKind()); |
| assertQNEquals("n1::n2::S", b1); |
| |
| IBinding b2 = getBindingFromASTName("S _s2;", 1); |
| assertTrue(b2.getScope() instanceof ICPPClassScope); |
| assertTrue(b2.getScope().getParent() instanceof ICPPClassScope); |
| assertEquals(EScopeKind.eGlobal, b2.getScope().getParent().getParent().getKind()); |
| assertQNEquals("c1::c2::S", b2); |
| |
| IBinding b3 = getBindingFromASTName("S _s3;", 1); |
| assertQNEquals("c1::c2::S", b3); |
| IBinding b4 = getBindingFromASTName("S _s4;", 1); |
| assertQNEquals("s1::s2::S", b4); |
| IBinding b5 = getBindingFromASTName("S _s5;", 1); |
| assertQNEquals("s1::s2::S", b5); |
| IBinding b6 = getBindingFromASTName("S _s6;", 1); |
| assertQNEquals("u1::u2::S", b6); |
| IBinding b7 = getBindingFromASTName("S _s7;", 1); |
| assertQNEquals("u1::u2::S", b7); |
| IBinding b8 = getBindingFromASTName("S _s8;", 1); |
| assertQNEquals("n3::c3::s3::u3::S", b8); |
| IBinding b9 = getBindingFromASTName("S _s9;", 1); |
| assertQNEquals("n3::c3::s3::u3::S", b9); |
| |
| IBinding b10 = getBindingFromASTName("S _s10;", 1); |
| assertTrue(b10.getScope() instanceof ICPPClassScope); |
| assertTrue(b10.getScope().getParent() instanceof ICPPClassScope); |
| assertTrue(b10.getScope().getParent().getParent() instanceof ICPPClassScope); |
| assertTrue(b10.getScope().getParent().getParent().getParent() instanceof ICPPNamespaceScope); |
| assertEquals(EScopeKind.eGlobal, b10.getScope().getParent().getParent().getParent().getParent().getKind()); |
| assertQNEquals("n3::c3::s3::u3::S", b10); |
| |
| IBinding b11 = getBindingFromASTName("S _s11;", 1); |
| assertQNEquals("n1::n2::S", b11); |
| IBinding b12 = getBindingFromASTName("S _s12;", 1); |
| assertQNEquals("n1::n2::S", b12); |
| } |
| |
| // // header content |
| // namespace n1 { namespace n2 { union U {}; } } |
| // class c1 { public: class c2 { public: union U {}; }; }; |
| // struct s1 { struct s2 { union U {}; }; }; |
| // union u1 { struct u2 { union U {}; }; }; |
| // namespace n3 { class c3 { public: struct s3 { union u3 { union U {}; }; }; }; } |
| |
| // // reference content |
| // void reference() { |
| // ::n1::n2::U _u0; n1::n2::U _u1; |
| // ::c1::c2::U _u2; c1::c2::U _u3; |
| // ::s1::s2::U _u4; s1::s2::U _u5; |
| // ::u1::u2::U _u6; u1::u2::U _u7; |
| // ::n3::c3::s3::u3::U _u8; |
| // n3::c3::s3::u3::U _u9; |
| // } |
| // namespace n3 { c3::s3::u3::U _u10; } |
| // namespace n1 { n2::U _u11; } |
| // namespace n1 { namespace n2 { U _u12; }} |
| public void testQualifiedNamesForUnion() throws DOMException { |
| IBinding b0 = getBindingFromASTName("U _u0;", 1); |
| assertQNEquals("n1::n2::U", b0); |
| IBinding b1 = getBindingFromASTName("U _u1;", 1); |
| assertQNEquals("n1::n2::U", b1); |
| IBinding b2 = getBindingFromASTName("U _u2;", 1); |
| assertQNEquals("c1::c2::U", b2); |
| IBinding b3 = getBindingFromASTName("U _u3;", 1); |
| assertQNEquals("c1::c2::U", b3); |
| IBinding b4 = getBindingFromASTName("U _u4;", 1); |
| assertQNEquals("s1::s2::U", b4); |
| IBinding b5 = getBindingFromASTName("U _u5;", 1); |
| assertQNEquals("s1::s2::U", b5); |
| IBinding b6 = getBindingFromASTName("U _u6;", 1); |
| assertQNEquals("u1::u2::U", b6); |
| IBinding b7 = getBindingFromASTName("U _u7;", 1); |
| assertQNEquals("u1::u2::U", b7); |
| IBinding b8 = getBindingFromASTName("U _u8;", 1); |
| assertQNEquals("n3::c3::s3::u3::U", b8); |
| IBinding b9 = getBindingFromASTName("U _u9;", 1); |
| assertQNEquals("n3::c3::s3::u3::U", b9); |
| IBinding b10 = getBindingFromASTName("U _u10;", 1); |
| assertQNEquals("n3::c3::s3::u3::U", b10); |
| IBinding b11 = getBindingFromASTName("U _u11;", 1); |
| assertQNEquals("n1::n2::U", b11); |
| IBinding b12 = getBindingFromASTName("U _u12;", 1); |
| assertQNEquals("n1::n2::U", b12); |
| } |
| |
| // struct A { |
| // A& operator<<(int); |
| // void p() &; |
| // void p() &&; |
| // }; |
| // A& operator<<(A&&, char); |
| |
| // void test() { |
| // A a; |
| // A() << 1;//1 // calls A::operator<<(int) |
| // A() << 'c';//2 // calls operator<<(A&&, char) |
| // a << 1;//3 // calls A::operator<<(int) |
| // a << 'c';//4 // calls A::operator<<(int) |
| // A().p();//5 // calls A::p()&& |
| // a.p();//6 // calls A::p()& |
| // } |
| public void testRankingOfReferenceBindings() throws Exception { |
| ICPPMethod m = getBindingFromImplicitASTName("<< 1;//1", 2); |
| assertNotNull(m); |
| assertEquals(1, m.getType().getParameterTypes().length); |
| ICPPFunction f = getBindingFromImplicitASTName("<< 'c';//2", 2); |
| assertNotNull(f); |
| assertEquals(2, f.getType().getParameterTypes().length); |
| m = getBindingFromImplicitASTName("<< 1;//3", 2); |
| assertNotNull(m); |
| assertEquals(1, m.getType().getParameterTypes().length); |
| m = getBindingFromImplicitASTName("<< 'c';//4", 2); |
| assertNotNull(m); |
| assertEquals(1, m.getType().getParameterTypes().length); |
| m = getBindingFromFirstIdentifier("p();//5"); |
| assertNotNull(m); |
| assertTrue(m.getType().isRValueReference()); |
| m = getBindingFromFirstIdentifier("p();//6"); |
| assertNotNull(m); |
| assertFalse(m.getType().isRValueReference()); |
| } |
| |
| // // header content |
| // namespace n1 { namespace n2 { class C {}; } } |
| // class c1 { public: class c2 { public: class C {}; }; }; |
| // struct s1 { struct s2 { class C {}; }; }; |
| // union u1 { union u2 { class C {}; }; }; |
| // namespace n3 { class c3 { public: struct s3 { union u3 { class C {}; }; }; }; } |
| |
| // // reference content |
| // void reference() { |
| // ::n1::n2::C _c0; n1::n2::C _c1; |
| // ::c1::c2::C _c2; c1::c2::C _c3; |
| // ::s1::s2::C _c4; s1::s2::C _c5; |
| // ::u1::u2::C _c6; u1::u2::C _c7; |
| // ::n3::c3::s3::u3::C _c8; |
| // n3::c3::s3::u3::C _c9; |
| // } |
| // namespace n3 { c3::s3::u3::C _c10; } |
| // namespace n1 { n2::C _c11; } |
| // namespace n1 { namespace n2 { C _c12; }} |
| public void testQualifiedNamesForClass() throws DOMException { |
| IBinding b0 = getBindingFromASTName("C _c0;", 1); |
| assertQNEquals("n1::n2::C", b0); |
| IBinding b1 = getBindingFromASTName("C _c1;", 1); |
| assertQNEquals("n1::n2::C", b1); |
| IBinding b2 = getBindingFromASTName("C _c2;", 1); |
| assertQNEquals("c1::c2::C", b2); |
| IBinding b3 = getBindingFromASTName("C _c3;", 1); |
| assertQNEquals("c1::c2::C", b3); |
| IBinding b4 = getBindingFromASTName("C _c4;", 1); |
| assertQNEquals("s1::s2::C", b4); |
| IBinding b5 = getBindingFromASTName("C _c5;", 1); |
| assertQNEquals("s1::s2::C", b5); |
| IBinding b6 = getBindingFromASTName("C _c6;", 1); |
| assertQNEquals("u1::u2::C", b6); |
| IBinding b7 = getBindingFromASTName("C _c7;", 1); |
| assertQNEquals("u1::u2::C", b7); |
| IBinding b8 = getBindingFromASTName("C _c8;", 1); |
| assertQNEquals("n3::c3::s3::u3::C", b8); |
| IBinding b9 = getBindingFromASTName("C _c9;", 1); |
| assertQNEquals("n3::c3::s3::u3::C", b9); |
| IBinding b10 = getBindingFromASTName("C _c10;", 1); |
| assertQNEquals("n3::c3::s3::u3::C", b10); |
| IBinding b11 = getBindingFromASTName("C _c11;", 1); |
| assertQNEquals("n1::n2::C", b11); |
| IBinding b12 = getBindingFromASTName("C _c12;", 1); |
| assertQNEquals("n1::n2::C", b12); |
| } |
| |
| // // header content |
| // namespace n1 { namespace n2 { typedef int Int; } } |
| // class c1 { public: class c2 { public: typedef int Int; }; }; |
| // struct s1 { struct s2 { typedef int Int; }; }; |
| // union u1 { struct u2 { typedef int Int; }; }; |
| // namespace n3 { class c3 { public: struct s3 { union u3 { typedef int Int; }; }; }; } |
| |
| // // reference content |
| // void reference() { |
| // ::n1::n2::Int i0; n1::n2::Int i1; |
| // ::c1::c2::Int i2; c1::c2::Int i3; |
| // ::s1::s2::Int i4; s1::s2::Int i5; |
| // ::u1::u2::Int i6; u1::u2::Int i7; |
| // ::n3::c3::s3::u3::Int i8; |
| // n3::c3::s3::u3::Int i9; |
| // } |
| // namespace n3 { c3::s3::u3::Int i10; } |
| // namespace n1 { n2::Int i11; } |
| // namespace n1 { namespace n2 { Int i12; }} |
| public void testQualifiedNamesForTypedef() throws DOMException { |
| IBinding b0 = getBindingFromASTName("Int i0;", 3); |
| assertQNEquals("n1::n2::Int", b0); |
| IBinding b1 = getBindingFromASTName("Int i1;", 3); |
| assertQNEquals("n1::n2::Int", b1); |
| |
| IBinding b2 = getBindingFromASTName("Int i2;", 3); |
| assertQNEquals("c1::c2::Int", b2); |
| IBinding b3 = getBindingFromASTName("Int i3;", 3); |
| assertQNEquals("c1::c2::Int", b3); |
| |
| IBinding b4 = getBindingFromASTName("Int i4;", 3); |
| assertQNEquals("s1::s2::Int", b4); |
| IBinding b5 = getBindingFromASTName("Int i5;", 3); |
| assertQNEquals("s1::s2::Int", b5); |
| |
| IBinding b6 = getBindingFromASTName("Int i6;", 3); |
| assertQNEquals("u1::u2::Int", b6); |
| IBinding b7 = getBindingFromASTName("Int i7;", 3); |
| assertQNEquals("u1::u2::Int", b7); |
| |
| IBinding b8 = getBindingFromASTName("Int i8;", 3); |
| assertQNEquals("n3::c3::s3::u3::Int", b8); |
| IBinding b9 = getBindingFromASTName("Int i9;", 3); |
| assertQNEquals("n3::c3::s3::u3::Int", b9); |
| IBinding b10 = getBindingFromASTName("Int i10;", 3); |
| assertQNEquals("n3::c3::s3::u3::Int", b10); |
| IBinding b11 = getBindingFromASTName("Int i11;", 3); |
| assertQNEquals("n1::n2::Int", b11); |
| IBinding b12 = getBindingFromASTName("Int i12;", 3); |
| assertQNEquals("n1::n2::Int", b12); |
| } |
| |
| // struct A { |
| // static struct { |
| // } waldo; |
| // }; |
| // decltype(A::waldo) A::waldo; |
| |
| // A a; |
| public void testDecltype_434150() { |
| checkBindings(); |
| } |
| |
| // // header content |
| // enum E { ER1, ER2 }; |
| |
| // // referencing content |
| // class C { |
| // E e1; |
| // static E e2; |
| // void m1() { e1 = ER1; } |
| // static void m2() { e2 = ER2; } |
| // }; |
| public void testEnumeratorInClassScope() { |
| IBinding b0 = getBindingFromASTName("E e1", 1); |
| IBinding b1 = getBindingFromASTName("ER1; }", 3); |
| IBinding b2 = getBindingFromASTName("ER2; }", 3); |
| } |
| |
| // // header content |
| // enum E { ER1, ER2 }; |
| |
| // // referencing content |
| // struct S { |
| // E e1; |
| // static E e2; |
| // void m1() { e1 = ER1; } |
| // static void m2() { e2 = ER2; } |
| // }; |
| public void testEnumeratorInStructScope() { |
| IBinding b0 = getBindingFromASTName("E e1", 1); |
| IBinding b1 = getBindingFromASTName("ER1; }", 3); |
| IBinding b2 = getBindingFromASTName("ER2; }", 3); |
| } |
| |
| // // header content |
| // enum E { ER1, ER2 }; |
| |
| // // referencing content |
| // union U { |
| // E e1; |
| // static E e2; |
| // void m1() { e1 = ER1; } |
| // static void m2() { e2 = ER2; } |
| // }; |
| public void testEnumeratorInUnionScope() { |
| IBinding b0 = getBindingFromASTName("E e1", 1); |
| IBinding b1 = getBindingFromASTName("ER1; }", 3); |
| IBinding b2 = getBindingFromASTName("ER2; }", 3); |
| } |
| |
| // // header content |
| // enum E { ER1, ER2 }; |
| |
| // // referencing content |
| // namespace n1 { |
| // E e1; |
| // static E e2; |
| // void f1() { e1 = ER1; } |
| // static void f2() { e2 = ER2; } |
| // }; |
| public void testEnumeratorInNamespaceScope() { |
| IBinding b0 = getBindingFromASTName("E e1", 1); |
| IBinding b1 = getBindingFromASTName("ER1; }", 3); |
| IBinding b2 = getBindingFromASTName("ER2; }", 3); |
| } |
| |
| // static union { |
| // int a; |
| // int b; |
| // }; |
| // namespace N { |
| // static union { |
| // int c; |
| // int d; |
| // }; |
| // } |
| |
| // int waldo1 = a; |
| // int waldo2 = N::d; |
| public void testAnonymousUnion_377409() { |
| checkBindings(); |
| } |
| |
| // void foo(int a=2, int b=3); |
| |
| // void ref() { foo(); } |
| public void testFunctionDefaultArguments() { |
| IBinding b0 = getBindingFromASTName("foo();", 3); |
| } |
| |
| // typedef int TYPE; |
| // namespace ns { |
| // const TYPE* foo(int a); |
| // }; |
| |
| // const TYPE* ns::foo(int a) { return 0; } |
| public void testTypeQualifier() { |
| IBinding b0 = getBindingFromASTName("foo(", 3); |
| } |
| |
| // class Base { public: void foo(int i) {} }; |
| // class Derived : public Base { public: void foo(long l) {} }; |
| |
| // void references() { |
| // Derived d; /*d*/ |
| // d.foo(55L); // calls long version |
| // d.foo(4); // also calls long version (int version is hidden) |
| // // aftodo - does this test make sense? |
| // } |
| public void testMethodHidingInInheritance() { |
| IBinding b0 = getBindingFromASTName("d; /*d*/", 1); |
| IBinding b1 = getBindingFromASTName("foo(55L);", 3); |
| IBinding b2 = getBindingFromASTName("foo(4);", 3); |
| } |
| |
| // namespace x { namespace y { int i; } } |
| |
| // class C { public: |
| // class x { public: |
| // class y { public: |
| // static int j; |
| // }; |
| // }; |
| // void method() { |
| // ::x::y::i++; |
| // x::y::j++; |
| // } |
| // }; |
| public void testGQualifiedReference() { |
| IBinding b0 = getBindingFromASTName("x::y::i++", 1); |
| assertTrue(ICPPNamespace.class.isInstance(b0)); |
| IBinding b1 = getBindingFromASTName("y::i++", 1); |
| assertTrue(ICPPNamespace.class.isInstance(b1)); |
| IBinding b2 = getBindingFromASTName("i++", 1); |
| assertTrue(ICPPVariable.class.isInstance(b2)); |
| IBinding b3 = getBindingFromASTName("x::y::j++", 1); |
| assertTrue(ICPPClassType.class.isInstance(b3)); |
| IBinding b4 = getBindingFromASTName("y::j++", 1); |
| assertTrue(ICPPClassType.class.isInstance(b4)); |
| IBinding b5 = getBindingFromASTName("j++", 1); |
| assertTrue(ICPPVariable.class.isInstance(b5)); |
| } |
| |
| ////header content |
| //struct S {int i;}; |
| //struct SS { S s, *sp; }; |
| // |
| //S* retsptr() {return 0;} |
| //S rets() { return *new S(); } |
| //S s, *sp; |
| //SS ss, *ssp; |
| //S *a[3]; |
| |
| ////reference content |
| //void references() { |
| // a[0]->i/*0*/++; (*a[0]).i/*1*/++; // IASTArraySubscriptExpression |
| // /* not applicable ?? */ // IASTBinaryExpression |
| // ((S*)sp)->i/*3*/++; ((S)s).i/*4*/++; //aftodo-valid? // IASTCastExpression |
| // (true ? sp : sp)->i/*5*/++; (true ? s : s).i/*6*/++; // IASTConditionalExpression |
| // (sp,sp)->i/*7*/++; (s,s).i/*8*/++; // IASTExpressionList |
| // ss.sp->i/*9*/++; ss.s.i/*10*/++; // IASTFieldReference |
| // ssp->sp->i/*11*/++; ssp->s.i/*12*/++; // IASTFieldReference |
| // retsptr()->i/*13*/++; rets().i/*14*/++; // IASTFunctionCallExpression |
| // sp->i/*15*/++; s.i/*16*/++; // IASTIdExpression |
| // /* not applicable */ // IASTLiteralExpression |
| // /* not applicable */ // IASTTypeIdExpression |
| // (*sp).i/*17*/++; // IASTUnaryExpression |
| // /* not applicable */ // ICPPASTDeleteExpression |
| // (new S())->i/*18*/++; // ICPPASTNewExpression |
| //} |
| public void testFieldReference() { |
| IBinding b0 = getBindingFromASTName("i/*0*/", 1); |
| IBinding b1 = getBindingFromASTName("i/*1*/", 1); |
| // IBinding b2 = getBindingFromASTName(ast, "i/*2*/", 1); |
| IBinding b3 = getBindingFromASTName("i/*3*/", 1); |
| IBinding b4 = getBindingFromASTName("i/*4*/", 1); |
| IBinding b5 = getBindingFromASTName("i/*5*/", 1); |
| IBinding b6 = getBindingFromASTName("i/*6*/", 1); |
| IBinding b7 = getBindingFromASTName("i/*7*/", 1); |
| IBinding b8 = getBindingFromASTName("i/*8*/", 1); |
| IBinding b9 = getBindingFromASTName("i/*9*/", 1); |
| IBinding b10 = getBindingFromASTName("i/*10*/", 1); |
| IBinding b11 = getBindingFromASTName("i/*11*/", 1); |
| IBinding b12 = getBindingFromASTName("i/*12*/", 1); |
| IBinding b13 = getBindingFromASTName("i/*13*/", 1); |
| IBinding b14 = getBindingFromASTName("i/*14*/", 1); |
| IBinding b15 = getBindingFromASTName("i/*15*/", 1); |
| IBinding b16 = getBindingFromASTName("i/*16*/", 1); |
| IBinding b17 = getBindingFromASTName("i/*17*/", 1); |
| IBinding b18 = getBindingFromASTName("i/*18*/", 1); |
| } |
| |
| // class C {public: C* cp;}; |
| // C foo(C c); |
| // C* foo(C* c); |
| // int foo(int i); |
| // int foo(int i, C c); |
| |
| // void references() { |
| // C c, *cp; |
| // foo/*a*/(cp[1]); // IASTArraySubscriptExpression |
| // foo/*b*/(cp+1); // IASTBinaryExpression |
| // foo/*c*/((C*) cp);/*1*/ // IASTCastExpression |
| // foo/*d*/(true ? c : c);/*2*/ // IASTConditionalExpression |
| // foo/*e*/(5, c);/*3*/ // IASTExpressionList |
| // foo/*f*/(c.cp);/*4*/ foo(cp->cp);/*5*/ // IASTFieldReference |
| // foo/*g*/(foo(c));/*6*/ foo(foo(1));/*7*/// IASTFunctionCallExpression |
| // foo/*h*/(c);/*8*/ // IASTIdExpression |
| // foo/*i*/(23489); // IASTLiteralExpression |
| // foo/*j*/(sizeof(C));/*9*/ // IASTTypeIdExpression |
| // foo/*k*/(*cp);/*10*/ // IASTUnaryExpression |
| // foo/*m*/(new C());/*12*/ // ICPPASTNewExpression |
| // // ?? foo/*n*/(); // ICPPASTSimpleTypeConstructorExpression |
| // // ?? foo/*o*/(); // ICPPASTTypenameExprssion |
| // // foo/*p*/(MADE_UP_SYMBOL); // ICPPASTTypenameExprssion |
| // } |
| public void testExpressionKindForFunctionCalls() { |
| // depends on bug 164470 because resolution takes place during parse. |
| IBinding b0 = getBindingFromASTName("foo/*a*/", 3); |
| IBinding b0a = getBindingFromASTName("cp[1]", 2); |
| // assertCompositeTypeParam(0, ICPPClassType.k_class, b0, "C"); |
| |
| IBinding b1 = getBindingFromASTName("foo/*b*/", 3); |
| IBinding b1a = getBindingFromASTName("cp+1", 2); |
| |
| IBinding b2 = getBindingFromASTName("foo/*c*/", 3); |
| IBinding b2a = getBindingFromASTName("cp);/*1*/", 2); |
| |
| IBinding b3 = getBindingFromASTName("foo/*d*/", 3); |
| IBinding b3a = getBindingFromASTName("c : c", 1); |
| IBinding b3b = getBindingFromASTName("c);/*2*/", 1); |
| |
| IBinding b4 = getBindingFromASTName("foo/*e*/", 3); |
| IBinding b4a = getBindingFromASTName("c);/*3*/", 1); |
| |
| IBinding b5 = getBindingFromASTName("cp);/*4*/", 2); |
| IBinding b5a = getBindingFromASTName("foo/*f*/", 3); |
| IBinding b5b = getBindingFromASTName("cp->cp);/*5*/", 2); |
| IBinding b5c = getBindingFromASTName("cp);/*5*/", 2); |
| |
| IBinding b6 = getBindingFromASTName("foo/*g*/", 3); |
| IBinding b6a = getBindingFromASTName("foo(c));/*6*/", 3); |
| IBinding b6b = getBindingFromASTName("c));/*6*/", 1); |
| IBinding b6c = getBindingFromASTName("foo(foo(1));/*7*/", 3); |
| IBinding b6d = getBindingFromASTName("foo(1));/*7*/", 3); |
| |
| IBinding b7 = getBindingFromASTName("foo/*h*/", 3); |
| IBinding b7a = getBindingFromASTName("c);/*8*/", 1); |
| |
| IBinding b8 = getBindingFromASTName("foo/*i*/", 3); |
| |
| IBinding b9 = getBindingFromASTName("foo/*j*/", 3); |
| IBinding b9a = getBindingFromASTName("C));/*9*/", 1); |
| |
| IBinding b10 = getBindingFromASTName("foo/*k*/", 3); |
| IBinding b10a = getBindingFromASTName("cp);/*10*/", 2); |
| |
| IBinding b12 = getBindingFromASTName("foo/*m*/", 3); |
| IBinding b12a = getBindingFromASTName("C());/*12*/", 1); |
| // IBinding b13 = getBindingFromASTName(ast, "foo/*n*/", 3); |
| } |
| |
| // class C { public: |
| // typedef int i1; typedef long *lp1; |
| // class C1 {}; struct S1 {}; union U1 {}; enum E1 {A1}; |
| // }; |
| // struct S { public: |
| // typedef int i2; typedef long *lp2; |
| // class C2 {}; struct S2 {}; union U2 {}; enum E2 {A2}; |
| // }; |
| // union U { public: |
| // typedef int i3; typedef long *lp3; |
| // class C3 {}; struct S3 {}; union U3 {}; enum E3 {A3}; |
| // }; |
| // enum E {A}; |
| // namespace n { |
| // typedef int i4; typedef long *lp4; |
| // class C4 {}; struct S4 {}; union U4 {}; enum E4 {A4}; |
| // } |
| // void f(int); |
| // void f(long); |
| // void f(C); void f(C::i1); void f(C::lp1); void f(C::S1); void f(C::U1); void f(C::E1); |
| // void f(S); void f(S::i2); void f(S::lp2); void f(S::S2); void f(S::U2); void f(S::E2); |
| // void f(U); void f(U::i3); void f(U::lp3); void f(U::S3); void f(U::U3); void f(U::E3); |
| // void f(n::i4); void f(n::lp4); void f(n::S4); void f(n::U4); void f(n::E4); |
| // void f(E); |
| |
| // void references() { |
| // void (*fintptr)(int), (*flongptr)(long); |
| // void (*fC)(C), (*fCi1)(C::i1), (*fClp1)(C::lp1), (*fCS1)(C::S1), (*fCU1)(C::U1), (*fCE1)(C::E1); |
| // void (*fS)(S), (*fSi2)(S::i2), (*fSlp2)(S::lp2), (*fSS2)(S::S2), (*fSU2)(S::U2), (*fSE2)(S::E2); |
| // void (*fU)(U), (*fUi3)(U::i3), (*fUlp3)(U::lp3), (*fUS3)(U::S3), (*fUU3)(U::U3), (*fUE3)(U::E3); |
| // void (*fni4)(n::i4), (*fnlp4)(n::lp4), (*fnS4)(n::S4), (*fnU4)(n::U4), (*fnE4)(n::E4); |
| // void (*fE)(E); |
| // fintptr = &f;/*0*/ flongptr = &f;/*1*/ |
| // fC = &f;/*2*/ fCi1 = &f;/*3*/ fClp1 = &f;/*4*/ fCS1 = &f;/*5*/ fCU1 = &f;/*6*/ fCE1 = &f;/*7*/ |
| // fS = &f;/*8*/ fSi2 = &f;/*9*/ fSlp2 = &f;/*10*/ fSS2 = &f;/*11*/ fSU2 = &f;/*12*/ fSE2 = &f;/*13*/ |
| // fU = &f;/*14*/ fUi3 = &f;/*15*/ fUlp3 = &f;/*16*/ fUS3 = &f;/*17*/ fUU3 = &f;/*18*/ fUE3 = &f;/*19*/ |
| // fni4 = &f;/*20*/ fnlp4 = &f;/*21*/ fnS4 = &f;/*22*/ fnU4 = &f;/*23*/ fnE4 = &f;/*24*/ |
| // fE = &f;/*25*/ |
| // } |
| public void testAddressOfOverloadedFunction() throws DOMException { |
| IBinding b0 = getBindingFromASTName("f;/*0*/", 1); |
| IBinding b1 = getBindingFromASTName("f;/*1*/", 1); |
| IBinding b2 = getBindingFromASTName("f;/*2*/", 1); |
| IBinding b3 = getBindingFromASTName("f;/*3*/", 1); |
| IBinding b4 = getBindingFromASTName("f;/*4*/", 1); |
| IBinding b5 = getBindingFromASTName("f;/*5*/", 1); |
| IBinding b6 = getBindingFromASTName("f;/*6*/", 1); |
| IBinding b7 = getBindingFromASTName("f;/*7*/", 1); |
| IBinding b8 = getBindingFromASTName("f;/*8*/", 1); |
| IBinding b9 = getBindingFromASTName("f;/*9*/", 1); |
| IBinding b10 = getBindingFromASTName("f;/*10*/", 1); |
| IBinding b11 = getBindingFromASTName("f;/*11*/", 1); |
| IBinding b12 = getBindingFromASTName("f;/*12*/", 1); |
| IBinding b13 = getBindingFromASTName("f;/*13*/", 1); |
| IBinding b14 = getBindingFromASTName("f;/*14*/", 1); |
| IBinding b15 = getBindingFromASTName("f;/*15*/", 1); |
| IBinding b16 = getBindingFromASTName("f;/*16*/", 1); |
| IBinding b17 = getBindingFromASTName("f;/*17*/", 1); |
| IBinding b18 = getBindingFromASTName("f;/*18*/", 1); |
| IBinding b19 = getBindingFromASTName("f;/*19*/", 1); |
| IBinding b20 = getBindingFromASTName("f;/*20*/", 1); |
| IBinding b21 = getBindingFromASTName("f;/*21*/", 1); |
| IBinding b22 = getBindingFromASTName("f;/*22*/", 1); |
| IBinding b23 = getBindingFromASTName("f;/*23*/", 1); |
| IBinding b24 = getBindingFromASTName("f;/*24*/", 1); |
| } |
| |
| // struct C { |
| // int m1(int a); |
| // int m2(int a) const; |
| // }; |
| // |
| // C* func(int (C::*m)(int) const); |
| // C* func(int (C::*m)(int)); |
| |
| // void ref() { |
| // func(&C::m1); |
| // func(&C::m2); |
| // } |
| public void testAddressOfConstMethod_233889() { |
| IBinding fn1 = getBindingFromASTName("func(&C::m1", 4, ICPPFunction.class); |
| IBinding fn2 = getBindingFromASTName("func(&C::m2", 4, ICPPFunction.class); |
| assertNotSame(fn1, fn2); |
| } |
| |
| // void f_int(int); |
| // void f_const_int(const int); |
| // void f_int_ptr(int*); |
| |
| // void ref() { |
| // int i = 0; |
| // const int const_int = 0; |
| // |
| // f_int(i); // ok |
| // f_int(const_int); // ok (passed as value) |
| // f_const_int(i); // ok |
| // f_const_int(const_int); // ok |
| // } |
| // |
| // void f_const_int(const int const_int) { |
| // f_int_ptr(&const_int); // error |
| // } |
| public void testConstIntParameter() { |
| getBindingFromASTName("f_int(i)", 5); |
| getBindingFromASTName("f_int(const_int)", 5); |
| getBindingFromASTName("f_const_int(i)", 11); |
| getBindingFromASTName("f_const_int(const_int)", 11); |
| getProblemFromASTName("f_int_ptr(&const_int)", 9); |
| } |
| |
| // void f_int_ptr(int*); |
| // void f_const_int_ptr(const int*); |
| // void f_int_const_ptr(int const*); |
| // void f_int_ptr_const(int *const); |
| // void f_const_int_ptr_const(const int*const); |
| // void f_int_const_ptr_const(int const*const); |
| |
| // void ref() { |
| // int* int_ptr = 0; |
| // const int* const_int_ptr = 0; |
| // int const* int_const_ptr = 0; |
| // int *const int_ptr_const = 0; |
| // const int*const const_int_ptr_const = 0; |
| // int const*const int_const_ptr_const = 0; |
| // |
| // f_int_ptr(int_ptr); // ok |
| // f_int_ptr(const_int_ptr); // error |
| // f_int_ptr(int_const_ptr); // error |
| // f_int_ptr(int_ptr_const); // ok |
| // f_int_ptr(const_int_ptr_const); // error |
| // f_int_ptr(int_const_ptr_const); // error |
| // |
| // f_const_int_ptr(int_ptr); // ok |
| // f_const_int_ptr(const_int_ptr); // ok |
| // f_const_int_ptr(int_const_ptr); // ok |
| // f_const_int_ptr(int_ptr_const); // ok |
| // f_const_int_ptr(const_int_ptr_const); // ok |
| // f_const_int_ptr(int_const_ptr_const); // ok |
| // |
| // f_int_const_ptr(int_ptr); // ok |
| // f_int_const_ptr(const_int_ptr); // ok |
| // f_int_const_ptr(int_const_ptr); // ok |
| // f_int_const_ptr(int_ptr_const); // ok |
| // f_int_const_ptr(const_int_ptr_const); // ok |
| // f_int_const_ptr(int_const_ptr_const); // ok |
| // |
| // f_int_ptr_const(int_ptr); // ok |
| // f_int_ptr_const(const_int_ptr); // error |
| // f_int_ptr_const(int_const_ptr); // error |
| // f_int_ptr_const(int_ptr_const); // ok |
| // f_int_ptr_const(const_int_ptr_const); // error |
| // f_int_ptr_const(int_const_ptr_const); // error |
| // |
| // f_const_int_ptr_const(int_ptr); // ok |
| // f_const_int_ptr_const(const_int_ptr); // ok |
| // f_const_int_ptr_const(int_const_ptr); // ok |
| // f_const_int_ptr_const(int_ptr_const); // ok |
| // f_const_int_ptr_const(const_int_ptr_const); // ok |
| // f_const_int_ptr_const(int_const_ptr_const); // ok |
| // |
| // f_int_const_ptr_const(int_ptr); // ok |
| // f_int_const_ptr_const(const_int_ptr); // ok |
| // f_int_const_ptr_const(int_const_ptr); // ok |
| // f_int_const_ptr_const(int_ptr_const); // ok |
| // f_int_const_ptr_const(const_int_ptr_const); // ok |
| // f_int_const_ptr_const(int_const_ptr_const); // ok |
| // } |
| public void testConstIntPtrParameter() { |
| getBindingFromASTName("f_int_ptr(int_ptr)", 9); |
| getProblemFromASTName("f_int_ptr(const_int_ptr)", 9); |
| getProblemFromASTName("f_int_ptr(int_const_ptr)", 9); |
| getBindingFromASTName("f_int_ptr(int_ptr_const)", 9); |
| getProblemFromASTName("f_int_ptr(const_int_ptr_const)", 9); |
| getProblemFromASTName("f_int_ptr(int_const_ptr_const)", 9); |
| |
| getBindingFromASTName("f_const_int_ptr(int_ptr)", 15); |
| getBindingFromASTName("f_const_int_ptr(const_int_ptr)", 15); |
| getBindingFromASTName("f_const_int_ptr(int_const_ptr)", 15); |
| getBindingFromASTName("f_const_int_ptr(int_ptr_const)", 15); |
| getBindingFromASTName("f_const_int_ptr(const_int_ptr_const)", 15); |
| getBindingFromASTName("f_const_int_ptr(int_const_ptr_const)", 15); |
| |
| getBindingFromASTName("f_int_const_ptr(int_ptr)", 15); |
| getBindingFromASTName("f_int_const_ptr(const_int_ptr)", 15); |
| getBindingFromASTName("f_int_const_ptr(int_const_ptr)", 15); |
| getBindingFromASTName("f_int_const_ptr(int_ptr_const)", 15); |
| getBindingFromASTName("f_int_const_ptr(const_int_ptr_const)", 15); |
| getBindingFromASTName("f_int_const_ptr(int_const_ptr_const)", 15); |
| |
| getBindingFromASTName("f_int_ptr_const(int_ptr)", 15); |
| getProblemFromASTName("f_int_ptr_const(const_int_ptr)", 15); |
| getProblemFromASTName("f_int_ptr_const(int_const_ptr)", 15); |
| getBindingFromASTName("f_int_ptr_const(int_ptr_const)", 15); |
| getProblemFromASTName("f_int_ptr_const(const_int_ptr_const)", 15); |
| getProblemFromASTName("f_int_ptr_const(int_const_ptr_const)", 15); |
| |
| getBindingFromASTName("f_const_int_ptr_const(int_ptr)", 21); |
| getBindingFromASTName("f_const_int_ptr_const(const_int_ptr)", 21); |
| getBindingFromASTName("f_const_int_ptr_const(int_const_ptr)", 21); |
| getBindingFromASTName("f_const_int_ptr_const(int_ptr_const)", 21); |
| getBindingFromASTName("f_const_int_ptr_const(const_int_ptr_const)", 21); |
| getBindingFromASTName("f_const_int_ptr_const(int_const_ptr_const)", 21); |
| |
| getBindingFromASTName("f_int_const_ptr_const(int_ptr)", 21); |
| getBindingFromASTName("f_int_const_ptr_const(const_int_ptr)", 21); |
| getBindingFromASTName("f_int_const_ptr_const(int_const_ptr)", 21); |
| getBindingFromASTName("f_int_const_ptr_const(int_ptr_const)", 21); |
| getBindingFromASTName("f_int_const_ptr_const(const_int_ptr_const)", 21); |
| getBindingFromASTName("f_int_const_ptr_const(int_const_ptr_const)", 21); |
| } |
| |
| // // the header |
| |
| // void f(int*){} // b1 |
| // void f(const int*){} // b2 |
| // void f(int const*){} // b2, redef |
| // void f(int *const){} // b1, redef |
| // void f(const int*const){} // b2, redef |
| // void f(int const*const){} // b2, redef |
| public void testConstIntPtrParameterInDefinitionAST() throws CoreException { |
| IBinding binding1 = getBindingFromASTName("f(int*){}", 1); |
| IBinding binding2 = getBindingFromASTName("f(const int*){}", 1); |
| getProblemFromASTName("f(int const*){}", 1); |
| getProblemFromASTName("f(int *const){}", 1); |
| getProblemFromASTName("f(const int*const){}", 1); |
| getProblemFromASTName("f(int const*const){}", 1); |
| } |
| |
| // // the header |
| |
| // void f(int&){} // b1 |
| // void f(const int&){} // b2 |
| // void f(int const&){} // b2, redef |
| public void testConstIntRefParameterInDefinitionAST() throws CoreException { |
| IBinding binding1 = getBindingFromASTName("f(int&){}", 1); |
| IBinding binding2 = getBindingFromASTName("f(const int&){}", 1); |
| getProblemFromASTName("f(int const&){}", 1); |
| } |
| |
| // // the header |
| |
| // void f(int*); // b1 |
| // void f(const int*); // b2 |
| // void f(int const*); // b2 |
| // void f(int *const); // b1 |
| // void f(const int*const); // b2 |
| // void f(int const*const); // b2 |
| // |
| // void f(int*){} // b1 |
| // void f(const int*){} // b2 |
| // |
| // void ref() { |
| // int* int_ptr = 0; |
| // const int* const_int_ptr = 0; |
| // int const* int_const_ptr = 0; |
| // int *const int_ptr_const = 0; |
| // const int*const const_int_ptr_const = 0; |
| // int const*const int_const_ptr_const = 0; |
| // |
| // f(int_ptr); // b1 |
| // f(const_int_ptr); // b2 |
| // f(int_const_ptr); // b2 |
| // f(int_ptr_const); // b1 |
| // f(const_int_ptr_const); // b2 |
| // f(int_const_ptr_const); // b2 |
| // } |
| public void testConstIntPtrParameterInDefinitionAST2() throws CoreException { |
| IBinding binding1 = getBindingFromASTName("f(int*){}", 1); |
| IBinding binding2 = getBindingFromASTName("f(const int*){}", 1); |
| |
| assertEquals(binding1, getBindingFromASTName("f(int_ptr)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(const_int_ptr)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(int_const_ptr)", 1)); |
| assertEquals(binding1, getBindingFromASTName("f(int_ptr_const)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(const_int_ptr_const)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(int_const_ptr_const)", 1)); |
| } |
| |
| // void f(int*); // b1 |
| // void f(const int*); // b2 |
| // void f(int const*); // b2 |
| // void f(int *const); // b1 |
| // void f(const int*const); // b2 |
| // void f(int const*const); // b2 |
| |
| // void f(int*){} // b1 |
| // void f(const int*){} // b2 |
| // |
| // void ref() { |
| // int* int_ptr = 0; |
| // const int* const_int_ptr = 0; |
| // int const* int_const_ptr = 0; |
| // int *const int_ptr_const = 0; |
| // const int*const const_int_ptr_const = 0; |
| // int const*const int_const_ptr_const = 0; |
| // |
| // f(int_ptr); // b1 |
| // f(const_int_ptr); // b2 |
| // f(int_const_ptr); // b2 |
| // f(int_ptr_const); // b1 |
| // f(const_int_ptr_const); // b2 |
| // f(int_const_ptr_const); // b2 |
| // } |
| public void testConstIntPtrParameterInDefinition() throws CoreException { |
| IBinding binding1 = getBindingFromASTName("f(int*){}", 1); |
| IBinding binding2 = getBindingFromASTName("f(const int*){}", 1); |
| |
| assertEquals(binding1, getBindingFromASTName("f(int_ptr)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(const_int_ptr)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(int_const_ptr)", 1)); |
| assertEquals(binding1, getBindingFromASTName("f(int_ptr_const)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(const_int_ptr_const)", 1)); |
| assertEquals(binding2, getBindingFromASTName("f(int_const_ptr_const)", 1)); |
| |
| assertEquals(2, getIndex().findNames(binding1, IIndex.FIND_DECLARATIONS).length); |
| assertEquals(4, getIndex().findNames(binding2, IIndex.FIND_DECLARATIONS).length); |
| assertEquals(1, getIndex().findNames(binding1, IIndex.FIND_DEFINITIONS).length); |
| assertEquals(1, getIndex().findNames(binding2, IIndex.FIND_DEFINITIONS).length); |
| } |
| |
| // // header file |
| // struct myStruct { |
| // int a; |
| // }; |
| // union myUnion { |
| // int b; |
| // }; |
| |
| // // referencing content |
| // struct myStruct; |
| // union myUnion; |
| // void test() { |
| // struct myStruct* u; |
| // union myUnion* v; |
| // u->a= 1; // since we include the definition, we may use the type. |
| // v->b= 1; // since we include the definition, we may use the type. |
| // } |
| public void testTypeDefinitionWithFwdDeclaration() { |
| getBindingFromASTName("a= 1", 1); |
| getBindingFromASTName("b= 1", 1); |
| } |
| |
| // namespace x { |
| // int a(int); |
| // } |
| // using namespace x; |
| // using x::a; |
| |
| // void test() { |
| // a(1); |
| // } |
| public void testLegalConflictWithUsingDeclaration() { |
| getBindingFromASTName("a(1)", 1); |
| } |
| |
| // class A {}; |
| // class B {}; |
| // class C { |
| // public: |
| // operator B() {B b; return b;} |
| // }; |
| // class D : public C {}; |
| // void foo(B b) {} |
| |
| // class E : public C {}; |
| // void refs() { |
| // C c; |
| // foo(c); |
| // D d; |
| // foo(d); |
| // E e; |
| // foo(e); |
| // } |
| public void testUserDefinedConversionOperator_224364() { |
| IBinding ca = getBindingFromASTName("C c;", 1); |
| assertInstance(ca, ICPPClassType.class); |
| |
| IBinding foo1 = getBindingFromASTName("foo(c)", 3); |
| |
| IBinding da = getBindingFromASTName("D d", 1); |
| assertInstance(da, ICPPClassType.class); |
| |
| IBinding foo2 = getBindingFromASTName("foo(d)", 3); |
| IBinding foo3 = getBindingFromASTName("foo(e)", 3); |
| } |
| |
| // int a= 1+2-3*4+10/2; // -4 |
| // int b= a+4; |
| // int* c= &b; |
| // enum X {e0, e4=4, e5, e2=2, e3}; |
| |
| // void ref() { |
| // a; b; c; e0; e2; e3; e4; e5; |
| // } |
| public void testValues() { |
| IVariable v = (IVariable) getBindingFromASTName("a;", 1); |
| asserValueEquals(v.getInitialValue(), -4); |
| v = (IVariable) getBindingFromASTName("b;", 1); |
| asserValueEquals(v.getInitialValue(), 0); |
| v = (IVariable) getBindingFromASTName("c;", 1); |
| assertNull(v.getInitialValue().numberValue()); |
| |
| IEnumerator e = (IEnumerator) getBindingFromASTName("e0", 2); |
| asserValueEquals(e.getValue(), 0); |
| e = (IEnumerator) getBindingFromASTName("e2", 2); |
| asserValueEquals(e.getValue(), 2); |
| e = (IEnumerator) getBindingFromASTName("e3", 2); |
| asserValueEquals(e.getValue(), 3); |
| e = (IEnumerator) getBindingFromASTName("e4", 2); |
| asserValueEquals(e.getValue(), 4); |
| e = (IEnumerator) getBindingFromASTName("e5", 2); |
| asserValueEquals(e.getValue(), 5); |
| } |
| |
| // namespace ns1 { namespace ns2 { |
| // class A {}; |
| // }} |
| // using namespace ns1::ns2; |
| |
| // A a; |
| public void testUsingDirectiveWithQualifiedName_269727() { |
| getBindingFromASTName("A a", 1, ICPPClassType.class); |
| } |
| |
| // void f(int (&v)[1]); |
| // void f(int (&v)[2]); |
| |
| // void test() { |
| // int a[1], b[2]; |
| // f(a); f(b); |
| // } |
| public void testArrayTypeWithSize_269926() { |
| IFunction f1 = getBindingFromASTName("f(a)", 1, IFunction.class); |
| IFunction f2 = getBindingFromASTName("f(b)", 1, IFunction.class); |
| assertFalse(f1.equals(f2)); |
| } |
| |
| // struct Params { |
| // constexpr Params(int, int) {} |
| // }; |
| // struct Desc { |
| // Desc(const Params*, int = 0); |
| // }; |
| // struct Descs { |
| // Desc a; |
| // Desc b[2]; |
| // }; |
| // struct S { |
| // static Descs waldo; |
| // }; |
| // constexpr Params params[1] = { |
| // { 0, 0 }, |
| // }; |
| // struct Descs S::waldo = { |
| // {nullptr}, |
| // { |
| // {params, 0}, |
| // {params, 0}, |
| // }, |
| // }; |
| |
| // // empty file |
| public void testArrayWithOneElement_508254() throws Exception { |
| checkBindings(); |
| } |
| |
| // class A { |
| // class B; |
| // void method(); |
| // }; |
| |
| // class A::B { |
| // B(int x); |
| // static void m(int p); |
| // }; |
| // |
| // void A::method() { |
| // new B(0); |
| // B::m(0); |
| // } |
| public void testNestedClass_284665() { |
| ICPPClassType b0 = getBindingFromASTName("B {", 1, ICPPClassType.class); |
| assertFalse(b0 instanceof IIndexBinding); |
| ICPPConstructor b1 = getBindingFromASTName("B(int x)", 1, ICPPConstructor.class); |
| assertFalse(b1 instanceof IIndexBinding); |
| ICPPClassType b2 = getBindingFromASTName("B(0)", 1, ICPPClassType.class); |
| ICPPMethod b3 = getBindingFromASTName("m(0)", 1, ICPPMethod.class); |
| assertFalse(b3 instanceof IIndexBinding); |
| } |
| |
| // class A { |
| // friend inline void m(A p) {} |
| // }; |
| |
| // void test(A a) { |
| // m(a); |
| // } |
| public void testInlineFriendFunction_284690() { |
| getBindingFromASTName("m(a)", 1, IFunction.class); |
| } |
| |
| // namespace ns { |
| // struct S {}; |
| // } |
| // namespace m { |
| // void h(ns::S); |
| // } |
| // namespace ns { |
| // inline namespace a { |
| // using namespace m; |
| // struct A {}; |
| // void fa(S s); |
| // } |
| // inline namespace b { |
| // struct B {}; |
| // void fb(S s); |
| // void gb(a::A); |
| // } |
| // void f(S s); |
| // void g(a::A); |
| // void g(b::B); |
| // } |
| |
| // ns::S s; |
| // ns::A a0; |
| // ns::B b0; |
| // ns::a::A a; |
| // ns::b::B b; |
| // |
| // void ok() { |
| // fa(s); fb(s); f(s); |
| // g(a); |
| // gb(a); |
| // } |
| public void testInlineNamespace_305980a() { |
| IFunction f = getBindingFromASTName("fa(s)", 2); |
| f = getBindingFromASTName("fb(s)", 2); |
| f = getBindingFromASTName("f(s)", 1); |
| f = getBindingFromASTName("g(a)", 1); |
| f = getBindingFromASTName("gb(a)", 2); |
| } |
| |
| // namespace ns { |
| // struct S {}; |
| // } |
| // namespace m { |
| // void h(ns::S); |
| // } |
| // namespace ns { |
| // inline namespace a { |
| // using namespace m; |
| // struct A {}; |
| // void fa(S s); |
| // } |
| // inline namespace b { |
| // struct B {}; |
| // void fb(S s); |
| // void gb(a::A); |
| // } |
| // void f(S s); |
| // void g(a::A); |
| // void g(b::B); |
| // } |
| |
| // namespace ns {} |
| // namespace m {} |
| // ns::S s; |
| // ns::A a0; |
| // ns::B b0; |
| // ns::a::A a; |
| // ns::b::B b; |
| // |
| // void ok() { |
| // fa(s); fb(s); f(s); |
| // g(a); |
| // gb(a); |
| // } |
| public void testInlineNamespace_305980am() { |
| IFunction f = getBindingFromASTName("fa(s)", 2); |
| f = getBindingFromASTName("fb(s)", 2); |
| f = getBindingFromASTName("f(s)", 1); |
| f = getBindingFromASTName("g(a)", 1); |
| f = getBindingFromASTName("gb(a)", 2); |
| } |
| |
| // namespace ns { |
| // inline namespace m { |
| // int a; |
| // } |
| // } |
| |
| // void test() { |
| // ns::m::a; //1 |
| // ns::a; //2 |
| // } |
| public void testInlineNamespace_305980b() { |
| IVariable v1 = getBindingFromASTName("a; //1", 1); |
| IVariable v2 = getBindingFromASTName("a; //2", 1); |
| assertEquals(v1, v2); |
| } |
| |
| // namespace ns { |
| // inline namespace m { |
| // int a; |
| // } |
| // } |
| |
| // namespace ns { |
| // void test() { |
| // m::a; //1 |
| // a; //2 |
| // } |
| // } |
| // void test() { |
| // ns::m::a; //3 |
| // ns::a; //4 |
| // } |
| public void testInlineNamespace_305980bm() { |
| IVariable v1 = getBindingFromASTName("a; //1", 1); |
| IVariable v2 = getBindingFromASTName("a; //2", 1); |
| IVariable v3 = getBindingFromASTName("a; //3", 1); |
| IVariable v4 = getBindingFromASTName("a; //4", 1); |
| assertEquals(v1, v2); |
| assertEquals(v2, v3); |
| assertEquals(v3, v4); |
| } |
| |
| // namespace out { |
| // void f(int); |
| // } |
| // namespace out2 { |
| // void g(int); |
| // } |
| // using namespace out; |
| // inline namespace in { |
| // inline namespace in2 { |
| // void f(char); |
| // using namespace out2; |
| // } |
| // } |
| |
| // void test() { |
| // ::f(1); |
| // ::g(1); |
| // } |
| public void testInlineNamespace_305980c() { |
| IFunction ref = getBindingFromASTName("f(1)", 1); |
| assertEquals("void (char)", ASTTypeUtil.getType(ref.getType())); |
| getBindingFromASTName("g(1)", 1); |
| } |
| |
| // namespace out { |
| // void f(int); |
| // } |
| // namespace out2 { |
| // void g(int); |
| // } |
| // using namespace out; |
| // inline namespace in { |
| // inline namespace in2 { |
| // void f(char); |
| // using namespace out2; |
| // } |
| // } |
| |
| // namespace out {} |
| // namespace out2 {} |
| // namespace in {} |
| // void test() { |
| // ::f(1); |
| // ::g(1); |
| // } |
| public void testInlineNamespace_305980cm() { |
| IFunction ref = getBindingFromASTName("f(1)", 1); |
| assertEquals("void (char)", ASTTypeUtil.getType(ref.getType())); |
| getBindingFromASTName("g(1)", 1); |
| } |
| |
| // namespace std { |
| // inline namespace __cxx11 { } |
| // } |
| |
| // namespace std { |
| // namespace __cxx11 { |
| // class string {}; |
| // } |
| // void regex_match(string); // Type 'string' could not be resolved |
| // } |
| public void testInlineNamespaceReopenedWithoutInlineKeyword_483824() { |
| checkBindings(); |
| } |
| |
| // namespace ns { |
| // void fun(); |
| // } |
| |
| // namespace alias = ns; |
| // void alias::fun() { |
| // } |
| public void testNamespaceAliasAsQualifier_356493a() { |
| IFunction ref = getBindingFromASTName("fun", 0); |
| assertEquals("ns", ref.getOwner().getName()); |
| } |
| |
| // namespace ns { |
| // void fun(); |
| // } |
| // namespace alias = ns; |
| |
| // void alias::fun() { |
| // } |
| public void testNamespaceAliasAsQualifier_356493b() { |
| IFunction ref = getBindingFromASTName("fun", 0); |
| assertEquals("ns", ref.getOwner().getName()); |
| } |
| |
| // class A {}; |
| // void f(A a) {} |
| // struct B {}; |
| // void g(B b) {} |
| |
| // struct A; |
| // class B; |
| // |
| // void test(A a, B b) { |
| // f(a); |
| // g(b); |
| // } |
| public void testStructClassMismatch_358282() { |
| getBindingFromASTName("f(a)", 1, ICPPFunction.class); |
| getBindingFromASTName("g(b)", 1, ICPPFunction.class); |
| } |
| |
| // namespace { |
| // class A {}; |
| // } |
| |
| // A a; |
| public void testAnonymousNamespace() { |
| getBindingFromFirstIdentifier("A", ICPPClassType.class); |
| } |
| |
| // namespace ns { |
| // namespace { |
| // const char str[] = ""; |
| // } |
| // } |
| |
| // namespace { |
| // const char str[] = ""; |
| // } |
| // |
| // namespace ns { |
| // |
| // void f(const char* s); |
| // |
| // void test() { |
| // f(str); |
| // } |
| // |
| // } |
| public void testAnonymousNamespaces_392577() { |
| getBindingFromFirstIdentifier("f(str)", ICPPFunction.class); |
| } |
| |
| // namespace ns { |
| // typedef int INT; |
| // } |
| |
| // namespace { |
| // namespace ns { |
| // using ::ns::INT; |
| // } |
| // } |
| public void testAnonymousNamespaces_418130() { |
| checkBindings(); |
| } |
| |
| // struct A { |
| // A(int); |
| // }; |
| |
| // struct B : public A { |
| // using A::A; |
| // }; |
| // |
| // void foo(B); |
| // |
| // int test() { |
| // foo(1); |
| // } |
| public void testInheritedConstructor() { |
| checkBindings(); |
| } |
| |
| // template <class T> |
| // struct A { |
| // A(T); |
| // }; |
| |
| // struct B : public A<int> { |
| // using A::A; |
| // }; |
| // |
| // void foo(B); |
| // |
| // int test() { |
| // foo(1); |
| // } |
| public void testInheritedConstructorFromTemplateInstance() { |
| checkBindings(); |
| } |
| |
| // struct A { |
| // A(int); |
| // }; |
| // |
| // template <class T> |
| // struct B : public T { |
| // using T::T; |
| // }; |
| |
| // void foo(B<A>); |
| // |
| // int test() { |
| // foo(1); |
| // } |
| public void testInheritedConstructorFromUnknownClass() { |
| checkBindings(); |
| } |
| |
| // template <typename T> |
| // struct A {}; |
| // |
| // struct B { |
| // template <typename T> |
| // B(const A<T>&, int i = 3); |
| // }; |
| // |
| // struct C : public B { |
| // using B::B; |
| // }; |
| |
| // void foo(C); |
| // |
| // void test(A<int> a) { |
| // foo(a); |
| // } |
| public void testInheritedTemplateConstructor() { |
| checkBindings(); |
| } |
| |
| // constexpr int foo(int a = 42) { |
| // return a; |
| // } |
| |
| // constexpr int waldo = foo(); |
| public void testNameLookupInDefaultArgument_432701() { |
| IVariable waldo = getBindingFromASTName("waldo", 5); |
| assertEquals(42, waldo.getInitialValue().numberValue().longValue()); |
| } |
| |
| // struct function { |
| // template <typename T> |
| // function(T); |
| // }; |
| // |
| // struct test { |
| // // These lambdas have the class 'test' as their owner. |
| // test(function f = [](int c) { return c; }); |
| // function member = [](int c) { return c; }; |
| // }; |
| |
| // int z; |
| public void testLambdaOwnedByClass_409882() { |
| checkBindings(); |
| } |
| |
| // struct A { |
| // auto a = [](int p) { int waldo = p; return waldo; }; |
| // }; |
| |
| // // No code in this file. |
| public void testLambdaOwnedByClass_449099() { |
| checkBindings(); |
| } |
| |
| // extern char TableValue[10]; |
| |
| // char TableValue[sizeof TableValue]; |
| public void testNameLookupFromArrayModifier_435075() { |
| checkBindings(); |
| } |
| |
| // struct S { |
| // int* a; |
| // int* b; |
| // }; |
| // |
| // constexpr S waldo = { nullptr, waldo.a }; |
| |
| // // empty file |
| public void testVariableInitializerThatReferencesVariable_508254a() throws Exception { |
| checkBindings(); |
| } |
| |
| // struct S { |
| // int* a; |
| // int* b; |
| // }; |
| // |
| // constexpr S waldo = { nullptr, waldo.a }; |
| // |
| // struct T { |
| // int *pBlock; |
| // }; |
| // |
| // static const constexpr T greebo[] = { |
| // { waldo.a }, |
| // }; |
| |
| // // empty file |
| public void testVariableInitializerThatReferencesVariable_508254b() throws Exception { |
| checkBindings(); |
| } |
| |
| // class NonVirt { |
| // void m(); |
| // }; |
| // class C1 : NonVirt { |
| // virtual void m(); |
| // }; |
| // class C2 : C1 { |
| // void m(); |
| // }; |
| // class C3 : C2 { |
| // void m(int); |
| // }; |
| // class C4 : C3 { |
| // void m(); |
| // }; |
| // class C5 : C1 { |
| // void m(); |
| // }; |
| |
| // void test(NonVirt* n, C1* c1, C2* c2, C3* c3, C4* c4, C5* c5) { |
| // n->m();//0 |
| // c1->m();//1 |
| // c2->m();//2 |
| // c3->m(0);//3 |
| // c4->m();//4 |
| // c5->m();//5 |
| // } |
| public void testOverridden_248846() throws Exception { |
| ICPPMethod m0 = getBindingFromFirstIdentifier("m();//0"); |
| ICPPMethod m1 = getBindingFromFirstIdentifier("m();//1"); |
| ICPPMethod m2 = getBindingFromFirstIdentifier("m();//2"); |
| ICPPMethod m3 = getBindingFromFirstIdentifier("m(0);"); |
| ICPPMethod m4 = getBindingFromFirstIdentifier("m();//4"); |
| ICPPMethod m5 = getBindingFromFirstIdentifier("m();//5"); |
| |
| assertFalse(ClassTypeHelper.isVirtual(m0)); |
| assertFalse(ClassTypeHelper.isVirtual(m3)); |
| assertTrue(ClassTypeHelper.isVirtual(m1)); |
| assertTrue(ClassTypeHelper.isVirtual(m2)); |
| assertTrue(ClassTypeHelper.isVirtual(m4)); |
| assertTrue(ClassTypeHelper.isVirtual(m5)); |
| |
| assertFalse(ClassTypeHelper.isOverrider(m0, m0)); |
| assertFalse(ClassTypeHelper.isOverrider(m1, m0)); |
| assertFalse(ClassTypeHelper.isOverrider(m2, m0)); |
| assertFalse(ClassTypeHelper.isOverrider(m3, m0)); |
| assertFalse(ClassTypeHelper.isOverrider(m4, m0)); |
| assertFalse(ClassTypeHelper.isOverrider(m5, m0)); |
| |
| assertFalse(ClassTypeHelper.isOverrider(m0, m1)); |
| assertFalse(ClassTypeHelper.isOverrider(m1, m1)); |
| assertFalse(ClassTypeHelper.isOverrider(m3, m1)); |
| assertTrue(ClassTypeHelper.isOverrider(m2, m1)); |
| assertTrue(ClassTypeHelper.isOverrider(m4, m1)); |
| assertTrue(ClassTypeHelper.isOverrider(m5, m1)); |
| |
| assertFalse(ClassTypeHelper.isOverrider(m0, m2)); |
| assertFalse(ClassTypeHelper.isOverrider(m1, m2)); |
| assertFalse(ClassTypeHelper.isOverrider(m2, m2)); |
| assertFalse(ClassTypeHelper.isOverrider(m3, m2)); |
| assertFalse(ClassTypeHelper.isOverrider(m5, m2)); |
| assertTrue(ClassTypeHelper.isOverrider(m4, m2)); |
| |
| ICPPMethod[] ors = ClassTypeHelper.findOverridden(m0); |
| assertEquals(0, ors.length); |
| ors = ClassTypeHelper.findOverridden(m1); |
| assertEquals(0, ors.length); |
| ors = ClassTypeHelper.findOverridden(m2); |
| assertEquals(1, ors.length); |
| assertEquals(ors[0], m1); |
| ors = ClassTypeHelper.findOverridden(m3); |
| assertEquals(0, ors.length); |
| ors = ClassTypeHelper.findOverridden(m4); |
| assertEquals(2, ors.length); |
| assertEquals(ors[0], m2); |
| assertEquals(ors[1], m1); |
| ors = ClassTypeHelper.findOverridden(m5); |
| assertEquals(1, ors.length); |
| assertEquals(ors[0], m1); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(unsigned long long i) { return Ret(); } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralOperatorTypes1() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(long double i) { return Ret(); } |
| |
| // auto test = 12.3_X; |
| public void testUserDefinedLiteralOperatorTypes2() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s) { return Ret(); } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralOperatorTypes1a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s) { return Ret(); } |
| |
| // auto test = 12.3_X; |
| public void testUserDefinedLiteralOperatorTypes2a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(unsigned long long d) { return Ret(); } |
| // bool operator "" _X(const char* s) { return false; } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralOperatorTypes1b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(long double d) { return Ret(); } |
| // bool operator "" _X(const char* s) { return false; } |
| |
| // auto test = 12.3_X; |
| public void testUserDefinedLiteralOperatorTypes2b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X; |
| public void testUserDefinedLiteralOperatorTypes3() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const wchar_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = L"123"_X; |
| public void testUserDefinedLiteralOperatorTypes3a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char16_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = u"123"_X; |
| public void testUserDefinedLiteralOperatorTypes3b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = U"123"_X; |
| public void testUserDefinedLiteralOperatorTypes3c() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // template<char... Chars> Ret operator "" _X() { return Ret(); } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralOperatorTypes4a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // template<char... Chars> Ret operator "" _X() { return Ret(); } |
| |
| // auto test = 123.123_X; |
| public void testUserDefinedLiteralOperatorTypes4b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123" "123"_X; |
| public void testUserDefinedLiteralConcatenation1a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X "123"; |
| public void testUserDefinedLiteralConcatenation1b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = u8"123" "123"_X; |
| public void testUserDefinedLiteralConcatenation2a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = u8"123"_X "123"; |
| public void testUserDefinedLiteralConcatenation2b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123" u8"123"_X; |
| public void testUserDefinedLiteralConcatenation2c() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X u8"123"; |
| public void testUserDefinedLiteralConcatenation2d() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const wchar_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = L"123" "123"_X; |
| public void testUserDefinedLiteralConcatenation3a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const wchar_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = L"123"_X "123"; |
| public void testUserDefinedLiteralConcatenation3b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const wchar_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123" L"123"_X; |
| public void testUserDefinedLiteralConcatenation3c() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const wchar_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X L"123"; |
| public void testUserDefinedLiteralConcatenation3d() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char16_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = u"123" "123"_X; |
| public void testUserDefinedLiteralConcatenation4a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char16_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = u"123"_X "123"; |
| public void testUserDefinedLiteralConcatenation4b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char16_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123" u"123"_X; |
| public void testUserDefinedLiteralConcatenation4c() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char16_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X u"123"; |
| public void testUserDefinedLiteralConcatenation4d() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = U"123" "123"_X; |
| public void testUserDefinedLiteralConcatenation5a() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = U"123"_X "123"; |
| public void testUserDefinedLiteralConcatenation5b() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123" U"123"_X; |
| public void testUserDefinedLiteralConcatenation5c() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X U"123"; |
| public void testUserDefinedLiteralConcatenation5d() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char32_t* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X U"123"_X; |
| public void testUserDefinedLiteralConcatenation6() throws Exception { |
| assertUserDefinedLiteralType("Ret"); |
| } |
| |
| // class Ret {}; |
| // Ret operator "" _X(const char* s, unsigned sz) { return Ret(); } |
| // Ret operator "" _Y(const char* s, unsigned sz) { return Ret(); } |
| |
| // auto test = "123"_X "123"_Y; |
| public void testUserDefinedLiteralBadConcat1() throws Exception { |
| IASTProblem[] problems = strategy.getAst(0).getPreprocessorProblems(); |
| assertEquals(1, problems.length); |
| assertEquals(IProblem.PREPROCESSOR_MULTIPLE_USER_DEFINED_SUFFIXES_IN_CONCATENATION, problems[0].getID()); |
| } |
| |
| // class RetA {}; |
| // class RetB {}; |
| // template<char... Chars> RetA operator "" _X() { return RetA(); } |
| // RetB operator "" _X(unsigned long long i) { return RetB(); } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralResolution1() throws Exception { |
| assertUserDefinedLiteralType("RetB"); |
| } |
| |
| // class RetA {}; |
| // class RetB {}; |
| // template<char... Chars> RetA operator "" _X() { return RetA(); } |
| // RetB operator "" _X(long double i) { return RetB(); } |
| |
| // auto test = 123.123_X; |
| public void testUserDefinedLiteralResolution2() throws Exception { |
| assertUserDefinedLiteralType("RetB"); |
| } |
| |
| // class RetA {}; |
| // class RetB {}; |
| // template<char... Chars> RetA operator "" _X() { return RetA(); } |
| // RetB operator "" _X(const char * c) { return RetB(); } |
| |
| // auto test = 123_X; |
| public void testUserDefinedLiteralResolution3() throws Exception { |
| ICPPVariable v = getBindingFromFirstIdentifier("test"); |
| assertTrue(v.getType() instanceof IProblemType); |
| } |
| |
| // struct A { |
| // virtual bool foo() = 0; |
| // }; |
| // |
| // struct B : A { |
| // bool foo(); |
| // }; |
| |
| // class B; |
| // int main() { |
| // B waldo; |
| // } |
| public void testFinalOverriderAnalysis_489477() throws Exception { |
| ICPPVariable waldo = getBindingFromFirstIdentifier("waldo"); |
| IType type = waldo.getType(); |
| assertInstance(type, ICPPClassType.class); |
| ICPPMethod[] pureVirtuals = SemanticQueries.getPureVirtualMethods((ICPPClassType) type, null); |
| assertEquals(0, pureVirtuals.length); |
| } |
| |
| // class A { |
| // friend class B; |
| // }; |
| |
| // B* b; |
| public void testFriendClassDeclaration_508338() throws Exception { |
| getProblemFromFirstIdentifier("B*"); |
| } |
| |
| // class waldo { |
| // static waldo instance; |
| // |
| // constexpr waldo() {} |
| // }; |
| // |
| // waldo waldo::instance; |
| |
| // // empty file |
| public void testStaticFieldOfEnclosingType_508254() throws Exception { |
| checkBindings(); |
| } |
| |
| // namespace { |
| // struct {} waldo; |
| // } |
| |
| // // empty file |
| public void testAnonymousStructInAnonymousNamespace_508254() throws Exception { |
| checkBindings(); |
| } |
| |
| // struct base { |
| // int* ptr; |
| // }; |
| // |
| // struct shared_ptr : public base { |
| // constexpr shared_ptr() {} |
| // constexpr shared_ptr(int) : shared_ptr() {} |
| // }; |
| // |
| // struct Foo { |
| // shared_ptr m_variable = 0; |
| // }; |
| |
| // int main() { |
| // Foo a; // Error: Type 'Foo' could not be resolved |
| // } |
| public void testDelegatingConstructorCallInConstexprConstructor_509871() throws Exception { |
| checkBindings(); |
| } |
| |
| // // empty file |
| |
| // template <typename T> |
| // struct base { |
| // constexpr base() : p(0) {} |
| // int p; |
| // }; |
| // |
| // template <typename T> |
| // struct derived : public base<T> { |
| // constexpr derived() : base<T>() {} |
| // constexpr derived(int) : derived() {} |
| // }; |
| // |
| // class C {}; |
| // derived<C> waldo = 0; |
| public void testDelegatingConstructorCallInConstexprConstructor_514595() throws Exception { |
| checkBindings(); |
| } |
| |
| // enum class NoneType { None }; |
| // const NoneType None = None; |
| |
| // // empty file |
| public void testSelfReferencingVariable_510484() throws Exception { |
| checkBindings(); |
| } |
| |
| // class Foo { |
| // struct Bar; |
| // void func(); |
| // }; |
| |
| // struct Foo::Bar { |
| // Bar(int, int); |
| // }; |
| // void Foo::func() { |
| // Bar waldo(0, 0); |
| // } |
| public void testNestedClassDefinedOutOfLine_502999() throws Exception { |
| checkBindings(); |
| } |
| |
| // class MyClass |
| // { |
| // public: |
| // MyClass( int i ) |
| // { |
| // } |
| // static const MyClass CONSTANT_NAME1; |
| // static const MyClass CONSTANT_NAME2; |
| // static const MyClass CONSTANT_NAME3; |
| // static const MyClass CONSTANT_NAME4; |
| // static const MyClass CONSTANT_NAME5; |
| // static const MyClass CONSTANT_NAME6; |
| // static const MyClass CONSTANT_NAME7; |
| // static const MyClass CONSTANT_NAME8; |
| // static const MyClass CONSTANT_NAME9; |
| // static const MyClass CONSTANT_NAME10; |
| // static const MyClass CONSTANT_NAME11; |
| // static const MyClass CONSTANT_NAME12; |
| // static const MyClass CONSTANT_NAME13; |
| // static const MyClass CONSTANT_NAME14; |
| // static const MyClass CONSTANT_NAME15; |
| // static const MyClass CONSTANT_NAME16; |
| // static const MyClass CONSTANT_NAME17; |
| // static const MyClass CONSTANT_NAME18; |
| // static const MyClass CONSTANT_NAME19; |
| // static const MyClass CONSTANT_NAME20; |
| // static const MyClass CONSTANT_NAME21; |
| // static const MyClass CONSTANT_NAME22; |
| // static const MyClass CONSTANT_NAME23; |
| // static const MyClass CONSTANT_NAME24; |
| // static const MyClass CONSTANT_NAME25; |
| // static const MyClass CONSTANT_NAME26; |
| // }; |
| // |
| // const MyClass MyClass::CONSTANT_NAME1( 1 ); |
| // const MyClass MyClass::CONSTANT_NAME2( 2 ); |
| // const MyClass MyClass::CONSTANT_NAME3( 3 ); |
| // const MyClass MyClass::CONSTANT_NAME4( 4 ); |
| // const MyClass MyClass::CONSTANT_NAME5( 5 ); |
| // const MyClass MyClass::CONSTANT_NAME6( 6 ); |
| // const MyClass MyClass::CONSTANT_NAME7( 7 ); |
| // const MyClass MyClass::CONSTANT_NAME8( 8 ); |
| // const MyClass MyClass::CONSTANT_NAME9( 9 ); |
| // const MyClass MyClass::CONSTANT_NAME10( 10 ); |
| // const MyClass MyClass::CONSTANT_NAME11( 11 ); |
| // const MyClass MyClass::CONSTANT_NAME12( 12 ); |
| // const MyClass MyClass::CONSTANT_NAME13( 13 ); |
| // const MyClass MyClass::CONSTANT_NAME14( 14 ); |
| // const MyClass MyClass::CONSTANT_NAME15( 15 ); |
| // const MyClass MyClass::CONSTANT_NAME16( 16 ); |
| // const MyClass MyClass::CONSTANT_NAME17( 17 ); |
| // const MyClass MyClass::CONSTANT_NAME18( 18 ); |
| // const MyClass MyClass::CONSTANT_NAME19( 19 ); |
| // const MyClass MyClass::CONSTANT_NAME20( 20 ); |
| // const MyClass MyClass::CONSTANT_NAME21( 21 ); |
| // const MyClass MyClass::CONSTANT_NAME22( 22 ); |
| // const MyClass MyClass::CONSTANT_NAME23( 23 ); |
| // const MyClass MyClass::CONSTANT_NAME24( 24 ); |
| // const MyClass MyClass::CONSTANT_NAME25( 25 ); |
| // const MyClass MyClass::CONSTANT_NAME26( 26 ); |
| |
| // // empty file |
| public void testOOM_529646() throws Exception { |
| checkBindings(); |
| } |
| |
| // int foo() noexcept; |
| |
| // constexpr bool is_noexcept = noexcept(foo()); |
| public void testNoexceptOperator_545021() throws Exception { |
| IVariable isNoexcept = getBindingFromASTName("is_noexcept", 11); |
| assertEquals(1, isNoexcept.getInitialValue().numberValue().longValue()); |
| } |
| } |