| /******************************************************************************* |
| * Copyright (c) 2000, 2016 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Stephan Herrmann - Contribution for |
| * Bug 425183 - [1.8][inference] make CaptureBinding18 safe |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.tests.dom; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import junit.framework.Test; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jdt.core.dom.*; |
| import org.eclipse.jdt.core.BindingKey; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; |
| import org.eclipse.jdt.internal.core.ResolvedBinaryMethod; |
| |
| @SuppressWarnings({"rawtypes"}) |
| public class ASTConverter18Test extends ConverterTestSetup { |
| |
| ICompilationUnit workingCopy; |
| |
| public void setUpSuite() throws Exception { |
| super.setUpSuite(); |
| this.ast = AST.newAST(AST.JLS8); |
| } |
| |
| public ASTConverter18Test(String name) { |
| super(name); |
| } |
| |
| static { |
| // TESTS_NUMBERS = new int[] { 19 }; |
| // TESTS_RANGE = new int[] { 1, -1 }; |
| // TESTS_NAMES = new String[] {"test0001"}; |
| } |
| public static Test suite() { |
| return buildModelTestSuite(ASTConverter18Test.class); |
| } |
| |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| if (this.workingCopy != null) { |
| this.workingCopy.discardWorkingCopy(); |
| this.workingCopy = null; |
| } |
| } |
| |
| /* |
| * Type Annotations on Variable Arguments |
| */ |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391898 |
| public void test0001() throws JavaModelException { |
| String contents = |
| " @java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| " @interface Marker {\n" + |
| " }\n" + |
| "public class X {\n" + |
| " public void foo(int @Marker... args) {\n" + |
| " }\n" + |
| " public void bar(@Marker int @Marker... args) {\n" + |
| " }\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST( |
| contents, |
| this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 1, 0); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) node; |
| List parameters = methodDeclaration.parameters(); |
| assertEquals("wrong size", 1, parameters.size()); |
| SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0); |
| List annotations = parameter.varargsAnnotations(); |
| assertEquals("Wrong number of annotations", 1, annotations.size()); |
| ASTNode annotation = (ASTNode) annotations.get(0); |
| checkSourceRange(annotation, "@Marker", contents); |
| node = getASTNode(compilationUnit,1,1); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| parameters = methodDeclaration.parameters(); |
| assertEquals("Wrong number of parameters", 1, parameters.size()); |
| parameter = (SingleVariableDeclaration) parameters.get(0); |
| annotations = parameter.varargsAnnotations(); |
| assertEquals("Wrong number of annotations", 1, annotations.size()); |
| annotation = (ASTNode) annotations.get(0); |
| checkSourceRange(annotation, "@Marker", contents); |
| } |
| /* |
| * Type Annotations on Variable Argument of ArrayType |
| */ |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=413569 |
| public void test413569() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " @Target(ElementType.TYPE_USE) static @interface A {}\n" + |
| " @Target(ElementType.TYPE_USE) static @interface B {}\n" + |
| " @Target(ElementType.TYPE_USE) static @interface C { Class<?> value() default Object.class; }\n" + |
| " @Target(ElementType.TYPE_USE) static @interface D { Class<?> d(); }\n" + |
| " void foo(@A int @B()[] @C(int[].class) [] @D(d=String[].class)... arg) {}\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST( |
| contents, |
| this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0, 4); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) node; |
| List parameters = methodDeclaration.parameters(); |
| assertEquals("wrong size", 1, parameters.size()); |
| SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0); |
| |
| ArrayType type = (ArrayType) parameter.getType(); |
| List dimensions = type.dimensions(); |
| assertEquals(2, dimensions.size()); |
| |
| Dimension dimension = (Dimension) dimensions.get(0); |
| List annotations = dimension.annotations(); |
| assertEquals("Wrong number of annotations", 1, annotations.size()); |
| Annotation annotation = (Annotation) annotations.get(0); |
| checkSourceRange(annotation, "@B()", contents); |
| |
| dimension = (Dimension) dimensions.get(1); |
| annotations = dimension.annotations(); |
| assertEquals("Wrong number of annotations", 1, annotations.size()); |
| annotation = (Annotation) annotations.get(0); |
| checkSourceRange(annotation, "@C(int[].class)", contents); |
| |
| annotations = parameter.varargsAnnotations(); |
| assertEquals("Wrong number of annotations", 1, annotations.size()); |
| annotation = (Annotation) annotations.get(0); |
| checkSourceRange(annotation, "@D(d=String[].class)", contents); |
| |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests annotations on |
| * QTR in multiple scenarios of occurrence. |
| * |
| * @throws JavaModelException |
| */ |
| public void test0002() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0002/X.java", |
| true/* resolve */); |
| String contents = "package test0002;\n" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X {\n" |
| + " public static void main(String[] args) {\n" |
| + " Outer outer = new Outer();\n" |
| + " Object myObject = new Object();\n" |
| + " String myString;\n" |
| + " myString = (java.lang.@Marker String) myObject;\n" |
| + " Outer.Inner first = outer.new Inner();\n" |
| + " Outer. @Marker2 Inner second = outer.new Inner() ;\n" |
| + " Outer.Inner. @Marker1 Deeper deeper = second.new Deeper();\n" |
| + " Outer.@Marker1 Inner.@Marker2 Deeper deeper2 = second.new Deeper();\n" |
| + " }\n" + "}\n" + "class Outer {\n" |
| + " public class Inner {\n" + " public class Deeper {\n" |
| + " }\n" + " }\n" + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, |
| this.workingCopy); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0); |
| List statements = methodDeclaration.getBody().statements(); |
| int sCount = 3; |
| |
| // case 1 - annotation just before the last field |
| ExpressionStatement expressionStatement = (ExpressionStatement) statements.get(sCount++); |
| Assignment assignment = (Assignment) expressionStatement.getExpression(); |
| assertNotNull(assignment); |
| CastExpression castExpression = (CastExpression) assignment.getRightHandSide(); |
| assertNotNull(castExpression); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) castExpression.getType(); |
| assertNotNull(nameQualifiedType); |
| assertEquals("java.lang.@Marker String", nameQualifiedType.toString()); |
| List annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| assertEquals("@Marker", annotations.get(0).toString()); |
| |
| // case 2 - QualifiedType without annotations. |
| VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++); |
| Type type = variableDeclarationStatement.getType(); |
| assertTrue(type.isSimpleType()); |
| SimpleType simpleType = (SimpleType) type; |
| assertEquals("Outer.Inner", simpleType.toString()); |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 0); |
| |
| // case 3 - Qaulified Type with outer without annotations and inner with |
| // annotations. |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++); |
| type = variableDeclarationStatement.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| assertNotNull(nameQualifiedType); |
| assertEquals("Outer.@Marker2 Inner", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| assertEquals("@Marker2", annotations.get(0).toString()); |
| |
| // case 4 - Multiple levels with annotations at the last only. |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++); |
| type = variableDeclarationStatement.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| assertNotNull(nameQualifiedType); |
| assertEquals("Outer.Inner.@Marker1 Deeper", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| assertEquals("@Marker1", annotations.get(0).toString()); |
| |
| // case 5 - Multiple annotations |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++); |
| type = variableDeclarationStatement.getType(); |
| assertTrue(type.isQualifiedType()); |
| QualifiedType qualifiedType = (QualifiedType) type; |
| assertNotNull(qualifiedType); |
| assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper", qualifiedType.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| assertEquals("@Marker2", annotations.get(0).toString()); |
| SimpleName simpleName = qualifiedType.getName(); |
| assertEquals("Deeper", simpleName.toString()); |
| Type qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) qualifierType; |
| assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| assertEquals("@Marker1", annotations.get(0).toString()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests the |
| * representation of type annotations on a possible JAVA 7 and 8 place. |
| * |
| * @throws JavaModelException |
| */ |
| public void test0003() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0003/X.java", |
| true/* resolve */); |
| String contents = "package test0003;\n" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X {\n" |
| + " public static void main(String[] args) {\n" |
| + " @Marker Outer.Inner first[] = new Outer.Inner[1];\n" |
| + " }\n" + "}\n" + "class Outer {\n" |
| + " public class Inner {\n" + " }\n" + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0); |
| List statements = methodDeclaration.getBody().statements(); |
| int sCount = 0; |
| |
| // Current design expects annotation only at the JAVA 7 place if it is |
| // expected at JAVA 8. |
| VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount); |
| List modifiers = variableDeclarationStatement.modifiers(); |
| assertTrue(modifiers.size() == 1); |
| Annotation annotation = (Annotation) modifiers.get(0); |
| assertEquals("@Marker", annotation.toString()); |
| Type type = variableDeclarationStatement.getType(); |
| assertTrue(type.isSimpleType()); |
| SimpleType simpleType = (SimpleType) type; |
| assertEquals("Outer.Inner", simpleType.toString()); |
| List annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 0); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests QTR with |
| * annotations |
| * |
| * @throws JavaModelException |
| */ |
| public void test0004() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0004/X.java", |
| true/* resolve */); |
| String contents = "package test0004;" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X implements One</*start*/@Marker1 Outer<Integer>. @Marker2 Inner<Double>[]/*end*/> {\n" |
| + "}\n" + "interface One<T> {}\n" + "class Outer<T> {\n" |
| + " public class Inner<S> {}\n" + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| ArrayType type = (ArrayType) buildAST(contents, this.workingCopy); |
| assertNotNull("No annotation", type); |
| ITypeBinding binding = type.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>[]", binding.getQualifiedName()); |
| Type elementType = type.getElementType(); |
| binding = elementType.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", |
| "test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>", binding.getQualifiedName()); |
| assertTrue("Not parameterized", elementType.isParameterizedType()); |
| ParameterizedType parameterizedType = (ParameterizedType) elementType; |
| Type type2 = parameterizedType.getType(); |
| assertTrue("Not qualified", type2.isQualifiedType()); |
| QualifiedType qualifiedType = (QualifiedType) type2; |
| binding = qualifiedType.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name","test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>", binding.getQualifiedName()); |
| Type qualifier = qualifiedType.getQualifier(); |
| assertTrue("Not parameterized", qualifier.isParameterizedType()); |
| binding = qualifier.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test0004.Outer<java.lang.Integer>", binding.getQualifiedName()); |
| parameterizedType = (ParameterizedType) qualifier; |
| type2 = parameterizedType.getType(); |
| assertTrue("Not simple type", type2.isSimpleType()); |
| binding = type2.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name","test0004.Outer<java.lang.Integer>", binding.getQualifiedName()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests QTR with |
| * annotations |
| * |
| * @throws JavaModelException |
| */ |
| public void test0005() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0005/X.java", |
| true/* resolve */); |
| String contents = "package test0005;" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X implements One< Outer.Inner > {\n" |
| + "}\n" |
| + "class Y implements One< Outer. @Marker1 Inner > {\n" |
| + "}\n" |
| + "class Z implements One< @Marker1 Outer.Inner > {\n" |
| + "}\n" |
| + "class W implements One< @Marker1 Outer. @Marker2 Inner > {\n" |
| + "}\n" + "interface One<T> {}\n" + "class Outer {\n" |
| + " public class Inner {}\n" + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, |
| this.workingCopy); |
| int tCount = 0; |
| |
| // case 1 - no annotations Outer.Inner |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| ParameterizedType parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| List typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| Type type = (Type) typeArguments.get(0); |
| assertTrue(type.isSimpleType()); |
| assertEquals("Outer.Inner", type.toString()); |
| |
| // case 2 - QTR with one annotation Outer.@Marker1 Inner |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration |
| .superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| type = (Type) typeArguments.get(0); |
| assertTrue(type.isNameQualifiedType()); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) type; |
| assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString()); |
| List annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| Annotation annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 3 - QTR with one annotation at the beginning @Marker1 |
| // Outer.Inner |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| type = (Type) typeArguments.get(0); |
| assertTrue(type.isQualifiedType()); |
| assertEquals("@Marker1 Outer.Inner", type.toString()); |
| QualifiedType qualifiedType = (QualifiedType) type; |
| assertEquals("Inner", qualifiedType.getName().toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| Type qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isSimpleType()); |
| SimpleType simpleType = (SimpleType) qualifierType; |
| assertEquals("@Marker1 Outer", simpleType.toString()); |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 4 - QTR with annotations at both the types @Marker1 |
| // Outer.@Marker2 Inner |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| type = (Type) typeArguments.get(0); |
| assertTrue(type.isQualifiedType()); |
| assertEquals("@Marker1 Outer.@Marker2 Inner", type.toString()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Inner", qualifiedType.getName().toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker2", annotation.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isSimpleType()); |
| simpleType = (SimpleType) qualifierType; |
| assertEquals("@Marker1 Outer", simpleType.toString()); |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests PQTR with |
| * annotations part |
| * |
| * @throws JavaModelException |
| */ |
| public void test0006() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0006/X.java", |
| true); |
| String contents = "package test0006;" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X implements One<Outer. Inner.Deeper<Double>> {\n" |
| + "}\n" |
| + "class X1 implements One<Outer. @Marker1 Inner.Deeper<Double>> {\n" |
| + "}\n" |
| + "class X2 implements One<Outer. @Marker1 Inner.@Marker2 Deeper<Double>> {\n" |
| + "}\n" |
| + "class X3 implements One<@Marker1 Outer. @Marker2 Inner. Deeper<Double>> {\n" |
| + "}\n" |
| + "class Y implements One<Outer1. Inner<Integer>. Deeper<Double>> {\n" |
| + "}\n" |
| + "class Y1 implements One<Outer1. Inner<Integer>. @Marker1 Deeper<Double>> {\n" |
| + "}\n" |
| + "class Y2 implements One<Outer1. @Marker1 Inner<Integer>. Deeper<Double>> {\n" |
| + "}\n" |
| + "class Y3 implements One<@Marker1 Outer1. Inner<Integer>. Deeper<Double>> {\n" |
| + "}\n" |
| + "class Y4 implements One<@Marker1 Outer1. @Marker2 Inner<Integer>. Deeper<Double>> {\n" |
| + "}\n" |
| + "class Z implements One<Outer2<Integer>.Inner.Deeper<Double>> {\n" |
| + "}\n" |
| + "class Z1 implements One<@Marker1 Outer2<Integer>.Inner.Deeper<Double>> {\n" |
| + "}\n" |
| + "class Z2 implements One<Outer2<Integer>. @Marker1 Inner.@Marker2 Deeper<Double>> {\n" |
| + "}\n" |
| + "class W implements One<Outer3<Double>. @Marker1 @Marker2 Inner<Integer, Character>. Deeper<Double>> {\n" |
| + "}\n" + "interface One<T> {}\n" + "class Outer {\n" |
| + " public class Inner {\n" |
| + " public class Deeper<S> {\n" + " }\n" + " }\n" |
| + "}\n" + "class Outer1 {\n" + " public class Inner<T> {\n" |
| + " public class Deeper<S> {\n" + " }\n" + " }\n" |
| + "}\n" + "class Outer2 <T> {\n" + " public class Inner {\n" |
| + " public class Deeper<S> {}\n" + " }\n" + "}\n" |
| + "class Outer3 <T> {\n" + " public class Inner<K, V> {\n" |
| + " public class Deeper<S> {}\n" + " }\n" + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, |
| this.workingCopy); |
| int tCount = 0; |
| |
| // case 1: vanilla case without annotations and with single typeArgument |
| // Outer.Inner.Deeper<Double> |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| ParameterizedType parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| List typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer.Inner.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| Type type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isSimpleType()); |
| SimpleType simpleType = (SimpleType) type; |
| assertEquals("Outer.Inner.Deeper", simpleType.toString()); |
| Name name = simpleType.getName(); |
| assertTrue(name.isQualifiedName()); |
| QualifiedName qualifiedName = (QualifiedName) name; |
| assertEquals("Outer.Inner.Deeper", qualifiedName.toString()); |
| |
| // case 2 - One annotation after the first class |
| // Outer. @Marker1 Inner.Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer.@Marker1 Inner.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| QualifiedType qualifiedType = (QualifiedType) type; |
| assertEquals("Outer.@Marker1 Inner.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| List annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) qualifiedType.getQualifier(); |
| assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| Annotation annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 3 - Inner types annotated with outer not annotated with last |
| // type arg |
| // Outer. @Marker1 Inner.@Marker2 Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker2", annotation.toString()); |
| Type qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) qualifierType; |
| assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 4 - one annotation on the outermost, one in middle and one |
| // typearg in innermost |
| // @Marker1 Outer. @Marker2 Inner. Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration |
| .superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("@Marker1 Outer.@Marker2 Inner.Deeper<Double>", parametrizedType.toString()); |
| ITypeBinding typeBinding = parametrizedType.resolveBinding(); |
| assertNotNull("Binding non-null", typeBinding); |
| assertEquals("wrong qualified name", "test0006.Outer.Inner.Deeper<java.lang.Double>", typeBinding.getQualifiedName()); |
| assertTrue("Not a Parameterized Type", typeBinding.isParameterizedType()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer.@Marker2 Inner.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isQualifiedType()); |
| qualifiedType = (QualifiedType) qualifierType; |
| assertEquals("@Marker1 Outer.@Marker2 Inner", qualifierType.toString()); |
| typeBinding = qualifiedType.resolveBinding(); |
| assertNotNull("Binding non-null", typeBinding); |
| typeBinding = qualifiedType.resolveBinding(); |
| assertEquals("wrong qualified name", "test0006.Outer.Inner", typeBinding.getQualifiedName()); |
| assertTrue(qualifierType.isAnnotatable()); |
| AnnotatableType annotatableType = (AnnotatableType) qualifierType; |
| annotations = annotatableType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker2", annotation.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Inner", name.toString()); |
| type = qualifiedType.getQualifier(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| assertEquals("@Marker1 Outer", simpleType.toString()); |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 5 - without annotations, but with typeargs at second and third |
| // types |
| // Outer1. Inner<Integer>. Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer1.Inner<Integer>.Deeper<Double>",parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer1.Inner<Integer>.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| assertEquals("Outer1.Inner<Integer>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| name = simpleType.getName(); |
| assertTrue(name.isQualifiedName()); |
| qualifiedName = (QualifiedName) name; |
| assertEquals("Outer1.Inner", qualifiedName.toString()); |
| |
| // case 6 - Annot in between two PQRT with outermost neither annotated |
| // nor having typeargs |
| // Outer1. Inner<Integer>. @Marker1 Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer1.Inner<Integer>.@Marker1 Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer1.Inner<Integer>.@Marker1 Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| assertEquals("Outer1.Inner<Integer>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| name = simpleType.getName(); |
| assertTrue(name.isQualifiedName()); |
| qualifiedName = (QualifiedName) name; |
| assertEquals("Outer1.Inner", qualifiedName.toString()); |
| |
| // case 7 - Outermost still empty (no annotations, no type args), |
| // followed by annotation, and then typeargs |
| // Outer1. @Marker1 Inner<Integer>. Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer1.@Marker1 Inner<Integer>.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer1.@Marker1 Inner<Integer>.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| assertEquals("Outer1.@Marker1 Inner<Integer>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| assertEquals("Outer1.@Marker1 Inner", nameQualifiedType.toString()); |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 8 - Similar to above, but with the major difference of |
| // annotation shifted to outermost. |
| // @Marker1 Outer1. Inner<Integer>. Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("@Marker1 Outer1.Inner<Integer>.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer1.Inner<Integer>.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| assertEquals("@Marker1 Outer1.Inner<Integer>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer1.Inner", qualifiedType.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| name = qualifiedType.getName(); |
| assertTrue(name.isSimpleName()); |
| assertEquals("Inner", name.toString()); |
| type = qualifiedType.getQualifier(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| name = simpleType.getName(); |
| assertTrue(name.isSimpleName()); |
| assertEquals("Outer1", name.toString()); |
| |
| // case 9: scenario of the above case plus another annotation at |
| // mid-level. |
| // @Marker1 Outer1.@Marker2 Inner<Integer>. Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>.Deeper<Double>",parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer1.@Marker2 Inner", qualifiedType.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker2", annotation.toString()); |
| name = qualifiedType.getName(); |
| assertTrue(name.isSimpleName()); |
| assertEquals("Inner", name.toString()); |
| type = qualifiedType.getQualifier(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| name = simpleType.getName(); |
| assertTrue(name.isSimpleName()); |
| assertEquals("Outer1", name.toString()); |
| |
| // case 10 - PQRT with two type args but without annotations |
| // Outer2<Integer>.Inner.Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer2<Integer>.Inner.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer2<Integer>.Inner.Deeper", qualifiedType.toString()); |
| ITypeBinding binding = qualifiedType.resolveBinding(); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isQualifiedType()); |
| qualifiedType = (QualifiedType) qualifierType; |
| binding = qualifiedType.resolveBinding(); |
| assertEquals("Outer2<Integer>.Inner", qualifiedType.toString()); |
| assertEquals("wrong qualified binding", "test0006.Outer2<java.lang.Integer>.Inner", binding.getQualifiedName()); |
| name = qualifiedType.getName(); |
| assertEquals("Inner", name.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertEquals("Outer2", type.toString()); |
| |
| // case 11 - annotation at outermost in addition to scenario in case 10. |
| // @Marker1 Outer2<Integer>.Inner.Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("@Marker1 Outer2<Integer>.Inner.Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("@Marker1 Outer2<Integer>.Inner.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isQualifiedType()); |
| qualifiedType = (QualifiedType) qualifierType; |
| assertEquals("@Marker1 Outer2<Integer>.Inner", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Inner", name.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertEquals("@Marker1 Outer2", type.toString()); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| annotations = simpleType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| |
| // case 12 - No annotations at outermost, but outermost has |
| // typeAnnotations. |
| // Outer2<Integer>. @Marker1 Inner.@Marker2 Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer2<Integer>.@Marker1 Inner.@Marker2 Deeper<Double>", parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer2<Integer>.@Marker1 Inner.@Marker2 Deeper",qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker2", annotation.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isQualifiedType()); |
| qualifiedType = (QualifiedType) qualifierType; |
| assertEquals("Outer2<Integer>.@Marker1 Inner", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Inner", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| assertEquals("@Marker1", annotation.toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Integer", type.toString()); |
| type = parametrizedType.getType(); |
| assertEquals("Outer2", type.toString()); |
| assertTrue(type.isSimpleType()); |
| |
| // case 13 - a list of annotations and multiple typeArgument element |
| // lists. |
| // Outer3<Double>. @Marker1 @Marker2 Inner<Integer, Character>. |
| // Deeper<Double> |
| typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++); |
| parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0); |
| typeArguments = parametrizedType.typeArguments(); |
| assertEquals(1, typeArguments.size()); |
| parametrizedType = (ParameterizedType) typeArguments.get(0); |
| assertEquals("Outer3<Double>.@Marker1 @Marker2 Inner<Integer,Character>.Deeper<Double>",parametrizedType.toString()); |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertEquals("Double", type.toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Outer3<Double>.@Marker1 @Marker2 Inner<Integer,Character>.Deeper", qualifiedType.toString()); |
| name = qualifiedType.getName(); |
| assertEquals("Deeper", name.toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 0); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 2); |
| assertEquals("Integer", typeArguments.get(0).toString()); |
| assertEquals("Character", typeArguments.get(1).toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isQualifiedType()); |
| qualifiedType = (QualifiedType) type; |
| assertEquals("Inner", qualifiedType.getName().toString()); |
| annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 2); |
| assertEquals("@Marker1", annotations.get(0).toString()); |
| assertEquals("@Marker2", annotations.get(1).toString()); |
| qualifierType = qualifiedType.getQualifier(); |
| assertTrue(qualifierType.isParameterizedType()); |
| parametrizedType = (ParameterizedType) qualifierType; |
| typeArguments = parametrizedType.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| assertEquals("Double", typeArguments.get(0).toString()); |
| type = parametrizedType.getType(); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| assertEquals("Outer3", simpleType.toString()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391893 |
| public void test0007() throws JavaModelException { |
| String contents = |
| "public class X {\n" + |
| " public void foo(@Marker @Marker2 X this, @Marker2 @Marker int i){}\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| Type receiver = method.getReceiverType(); |
| assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, receiver.getNodeType()); |
| assertEquals("Incorrect receiver signature", "@Marker @Marker2 X", ((SimpleType) receiver).toString()); |
| assertEquals("Incorrect annotations on receiver", 2, ((SimpleType) receiver).annotations().size()); |
| assertNull("Incorrect receiver qualfier", method.getReceiverQualifier()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391893 |
| public void test0008() throws JavaModelException { |
| String contents = |
| "public class X {\n" + |
| " class Y {\n" + |
| " public Y(@Marker @Marker2 X X.this, @Marker2 @Marker int i){}\n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| TypeDeclaration innerType = (TypeDeclaration) node; |
| assertEquals("Incorrect no of methods", 1, innerType.getMethods().length); |
| MethodDeclaration method = innerType.getMethods()[0]; |
| Type receiver = method.getReceiverType(); |
| assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, receiver.getNodeType()); |
| assertEquals("Incorrect receiver signature", "@Marker @Marker2 X", ((SimpleType) receiver).toString()); |
| assertEquals("Incorrect annotations on receiver", 2, ((SimpleType) receiver).annotations().size()); |
| assertNotNull("Incorrect receiver qualfier", method.getReceiverQualifier()); |
| assertEquals("Incorrect receiver qualfier", "X", method.getReceiverQualifier().getFullyQualifiedName()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391895 |
| public void test0009() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "public class X {\n" + |
| " class Y {\n" + |
| " @Annot int @Annot1 [] a @Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 [], b @Annot2 @Annot3 [] @Annot4 [], c [][][];\n" + |
| " public void foo1(@Annot int @Annot1 [] p @Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 @Annot3 []) {}\n" + |
| " public void foo2(@Annot int p [][]) {}\n" + |
| " @Annot String @Annot1 [] foo3() @Annot1 @Annot2 [][] { return null; }\n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + |
| "@interface Annot {}\n" + |
| "@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + |
| "@interface Annot1 {}\n" + |
| "@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + |
| "@interface Annot2 {}\n" + |
| "@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + |
| "@interface Annot3 {}\n" + |
| "@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + |
| "@interface Annot4 {}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| TypeDeclaration type = (TypeDeclaration) node; |
| FieldDeclaration field = type.getFields()[0]; |
| List fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 3, fragments.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "@Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 []"); |
| fragment = (VariableDeclarationFragment) fragments.get(1); |
| assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "@Annot2 @Annot3 [] @Annot4 []"); |
| fragment = (VariableDeclarationFragment) fragments.get(2); |
| assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "[] [] []"); |
| MethodDeclaration[] methods = type.getMethods(); |
| assertEquals("Incorrect no of methods", 3, methods.length); |
| MethodDeclaration method = methods[0]; |
| List parameters = method.parameters(); |
| assertEquals("Incorrect no of parameters", 1, parameters.size()); |
| assertExtraDimensionsEqual("Incorrect extra dimensions", ((SingleVariableDeclaration) parameters.get(0)).extraDimensions(), "@Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 @Annot3 []"); |
| |
| method = methods[1]; |
| parameters = method.parameters(); |
| assertEquals("Incorrect no of parameters", 1, parameters.size()); |
| assertExtraDimensionsEqual("Incorrect extra dimensions", ((SingleVariableDeclaration) parameters.get(0)).extraDimensions(), "[] []"); |
| |
| method = methods[2]; |
| assertExtraDimensionsEqual("Incorrect extra dimensions", method.extraDimensions(), "@Annot1 @Annot2 [] []"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=399600 |
| public void test0010() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "public class X {\n" + |
| " @Marker int foo(@Marker(\"Blah\") int z) @Marker [] @Marker [] {\n" + |
| " return null;\n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {\n" + |
| " String value() default \"Blah\";\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertExtraDimensionsEqual("Incorrect extra dimensions", method.extraDimensions(), "@Marker [] @Marker []"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894 |
| public void test0011() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [2] @Marker2 @Marker3 [bar()] @Marker3 @Marker []; \n" + |
| " int @Marker [][][] j = new @Marker int @Marker3 @Marker [2] @Marker @Marker2 [X.bar2(2)] @Marker2 @Marker3 [];\n" + |
| " }\n" + |
| " public int bar() {\n" + |
| " return 2;\n" + |
| " }\n" + |
| " public static int bar2(int k) {\n" + |
| " return k;\n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker3 {}"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| List list = method.getBody().statements(); |
| assertEquals("Incorrect no of statements", 2, list.size()); |
| VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0); |
| VariableDeclarationStatement statement2 = (VariableDeclarationStatement) list.get(1); |
| list = statement1.fragments(); |
| assertEquals("Incorrect no of fragments", 1, list.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0); |
| ArrayCreation creation = (ArrayCreation) fragment.getInitializer(); |
| Type type = creation.getType(); |
| assertEquals("Incorrect type", true, type.isArrayType()); |
| checkSourceRange(type, "@Marker2 int @Marker @Marker2 [2] @Marker2 @Marker3 [bar()] @Marker3 @Marker []", contents.toCharArray()); |
| Dimension dimension = (Dimension) ((ArrayType) type).dimensions().get(2); |
| assertEquals("Incorrect annotations", "@Marker3 @Marker ", convertAnnotationsList(dimension.annotations())); |
| dimension = (Dimension) ((ArrayType) type).dimensions().get(1); |
| assertEquals("Incorrect annotations", "@Marker2 @Marker3 ", convertAnnotationsList(dimension.annotations())); |
| dimension = (Dimension) ((ArrayType) type).dimensions().get(0); |
| assertEquals("Incorrect annotations", "@Marker @Marker2 ", convertAnnotationsList(dimension.annotations())); |
| List dimensions = creation.dimensions(); |
| assertEquals("Incorrect expressions", 2, dimensions.size()); |
| assertEquals("Incorrect expressions", "2", dimensions.get(0).toString()); |
| assertEquals("Incorrect expressions", "bar()", dimensions.get(1).toString()); |
| |
| list = statement2.fragments(); |
| assertEquals("Incorrect no of fragments", 1, list.size()); |
| fragment = (VariableDeclarationFragment) list.get(0); |
| creation = (ArrayCreation) fragment.getInitializer(); |
| checkSourceRange(creation.getType(), "@Marker int @Marker3 @Marker [2] @Marker @Marker2 [X.bar2(2)] @Marker2 @Marker3 []", contents.toCharArray()); |
| |
| type = creation.getType(); |
| assertEquals("Incorrect type", true, type.isArrayType()); |
| dimension = (Dimension) ((ArrayType) type).dimensions().get(2); |
| assertEquals("Incorrect annotations", "@Marker2 @Marker3 ", convertAnnotationsList(dimension.annotations())); |
| dimension = (Dimension) ((ArrayType) type).dimensions().get(1); |
| assertEquals("Incorrect annotations", "@Marker @Marker2 ", convertAnnotationsList(dimension.annotations())); |
| dimension = (Dimension) ((ArrayType) type).dimensions().get(0); |
| assertEquals("Incorrect annotations", "@Marker3 @Marker ", convertAnnotationsList(dimension.annotations())); |
| dimensions = creation.dimensions(); |
| assertEquals("Incorrect expressions", 2, dimensions.size()); |
| assertEquals("Incorrect expressions", "2", dimensions.get(0).toString()); |
| assertEquals("Incorrect expressions", "X.bar2(2)", dimensions.get(1).toString()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894 |
| public void test0012() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker [] {{{1, 2, 3}}}; \n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker3 {}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| List list = method.getBody().statements(); |
| assertEquals("Incorrect no of statements", 1, list.size()); |
| VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0); |
| list = statement1.fragments(); |
| assertEquals("Incorrect no of fragments", 1, list.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0); |
| ArrayCreation creation = (ArrayCreation) fragment.getInitializer(); |
| Type type = creation.getType(); |
| assertEquals("Incorrect type", true, type.isArrayType()); |
| checkSourceRange(type, "@Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker []", contents.toCharArray()); |
| ArrayInitializer initializer = creation.getInitializer(); |
| checkSourceRange(initializer, "{{{1, 2, 3}}}", contents.toCharArray()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894 |
| // Force to use JLS4 and confirm malformed flags are set. |
| public void test0021() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker [] {{{1, 2, 3}}}; \n" + |
| " }\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker3 {}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| CompilationUnit unit = (CompilationUnit) buildAST(getJLS4(), contents, this.workingCopy, true, true, true); |
| |
| ASTNode node = getASTNode(unit, 0, 0); |
| assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| List list = method.getBody().statements(); |
| assertEquals("Incorrect no of statements", 1, list.size()); |
| VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0); |
| list = statement1.fragments(); |
| assertEquals("Incorrect no of fragments", 1, list.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0); |
| ArrayCreation creation = (ArrayCreation) fragment.getInitializer(); |
| Type type = creation.getType(); |
| assertEquals("Incorrect type", true, type.isArrayType()); |
| assertEquals("Type should be malformed", ASTNode.MALFORMED, (type.getFlags() & ASTNode.MALFORMED)); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768 |
| * |
| * @throws JavaModelException |
| */ |
| public void test0013() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0010/X.java", |
| true/* resolve */); |
| String contents = "package test0010;" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X implements One<@Marker1 Integer, @Marker2 Boolean> {\n" |
| + "}\n" |
| + "class Y implements One<@Marker1 @Marker2 Integer, @Marker2 @Marker1 Double> {\n" |
| + "}\n" |
| + "interface One<T, U> {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| // simple types for generic type arguments to parameterized classes |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| Type type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(0); |
| assertTrue(type.isSimpleType()); |
| SimpleType simpleType = (SimpleType) type; |
| List annotations = simpleType.annotations(); |
| assertEquals("wrong number of annotations", 1, annotations.size()); |
| assertEquals("@Marker1", annotations.get(0).toString()); |
| assertNotNull("No annotation", type); |
| typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(0); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| annotations = simpleType.annotations(); |
| assertEquals("wrong number of annotations", 2, annotations.size()); |
| assertEquals("@Marker2", annotations.get(1).toString()); |
| assertNotNull("No annotation", type); |
| type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(1); |
| assertTrue(type.isSimpleType()); |
| simpleType = (SimpleType) type; |
| annotations = simpleType.annotations(); |
| assertEquals("wrong number of annotations", 2, annotations.size()); |
| assertEquals("@Marker1", annotations.get(1).toString()); |
| assertNotNull("No annotation", type); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768 |
| * |
| * @throws JavaModelException |
| */ |
| public void test0014() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0011/X.java", |
| true/* resolve */); |
| String contents = "package test0011;" |
| + "import java.lang.annotation.Target;\n" |
| + "public class X {\n" |
| + " public void foo() {\n" |
| + " Y y = new <@Marker2 @Marker1 String> Y(new String(\"Hello\"));\n" |
| + " len = y.<@Marker1 @Marker2 String> bar(new String(\"World\"));\n" |
| + " }\n" |
| + " public int len;\n" |
| + "}\n" |
| + "class Y {\n" |
| + " public <T> Y(T t) {\n" |
| + " len = t instanceof String ? ((String)t).length() : 0;\n" |
| + " }\n" |
| + " public <T> int bar(T t) {\n" |
| + " return t instanceof String ? ((String)t).length() : len;\n" |
| + " }\n" |
| + " private int len;\n" |
| + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| // simple type for generic type arguments in a generic method or constructor invocation |
| MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0); |
| List statements = methodDeclaration.getBody().statements(); |
| Statement statement = (Statement)statements.get(0); |
| VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statement; |
| VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0); |
| Expression expression = variableDeclarationFragment.getInitializer(); |
| ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression; |
| Type type = (Type) classInstanceCreation.typeArguments().get(0); |
| assertEquals("@Marker2 @Marker1 String", type.toString()); |
| assertTrue(type.isSimpleType()); |
| SimpleType simpleType = (SimpleType) type; |
| List annotations = simpleType.annotations(); |
| assertEquals("wrong number of annotations", 2, annotations.size()); |
| assertEquals("@Marker2", annotations.get(0).toString()); |
| statement = (Statement) statements.get(1); |
| Assignment assignment = (Assignment) ((ExpressionStatement)statement).getExpression(); |
| expression = assignment.getRightHandSide(); |
| MethodInvocation methodInvocation = (MethodInvocation) expression; |
| simpleType = (SimpleType)methodInvocation.typeArguments().get(0); |
| annotations = simpleType.annotations(); |
| assertEquals("wrong number of annotations", 2, annotations.size()); |
| assertEquals("@Marker1", annotations.get(0).toString()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768 |
| * |
| * @throws JavaModelException |
| */ |
| public void test0015() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test0012/X.java", |
| true/* resolve */); |
| String contents = "package test0012;" |
| + "import java.lang.annotation.Target;\n" |
| + "import java.io.File;\n" |
| + "public class X <@Marker1 @Marker3 F extends @Marker1 @Marker2 File> {\n" |
| + " public int foo(F f) {\n" |
| + " Y <@Marker2 @Marker3 ? super @Marker1 @Marker2 File> y = new @Marker2 @Marker1 Y<File>();\n" |
| + " Outer o = new @Marker1 @Marker2 Outer();\n" |
| + " Outer.Inner inner = o.new @Marker1 @Marker2 Inner();\n" |
| + " ZZ zz = new <String> @Marker1 @Marker2 ZZ();\n" |
| + " return f.getName().length() + y.hashCode() + inner.hashCode();\n" |
| + " }\n" |
| + "}\n" |
| + "class Y<@Marker3 T> {\n" |
| + " public int bar(T t) {\n" |
| + " return t instanceof @Marker1 @Marker2 File ? t.toString().length() : 0;\n" |
| + " }\n" |
| + "}\n" |
| + "class Outer {\n" |
| + " public class Inner {\n" |
| + " public class Deeper {\n" |
| + " }\n" |
| + " }\n" |
| + "}\n" |
| + "class ZZ {\n" |
| + "public @Marker1 @Marker2 <T> ZZ() {\n" |
| + " T t = null;\n" |
| + " len = t instanceof String ? t.hashCode() : 0;\n" |
| + "}\n" |
| + "public @Marker1 int getint(@Marker2 @Marker1 ZZ this) {return len;}\n" |
| + "public int len;\n" |
| + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker1 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker2 {}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker3 {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| TypeParameter typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0); |
| |
| // TypeParameter with TYPE_USE and TYPE_PARAMETER annotation combination. |
| assertEquals("@Marker1 @Marker3 F extends @Marker1 @Marker2 File", typeParameter.toString()); |
| assertTrue(typeParameter.modifiers().size() == 2); |
| Annotation annotation = (Annotation)typeParameter.modifiers().get(1); |
| assertEquals("@Marker3", annotation.toString()); |
| IAnnotationBinding abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker3()", abinding.toString()); |
| |
| // simpletype for type parameter bounds |
| SimpleType simpleType = (SimpleType) typeParameter.typeBounds().get(0); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0); |
| List statements = methodDeclaration.getBody().statements(); |
| Statement statement = (Statement)statements.get(0); |
| VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement)statement; |
| Type type = variableDeclarationStatement.getType(); |
| assertTrue(type.isParameterizedType()); |
| type = (Type)((ParameterizedType)type).typeArguments().get(0); |
| assertTrue(type.isWildcardType()); |
| |
| // for constructor invocation results 1/4 |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertEquals("new @Marker2 @Marker1 Y<File>()", expression.toString()); |
| simpleType = (SimpleType) ((ParameterizedType)((ClassInstanceCreation)expression).getType()).getType(); |
| assertEquals("@Marker2 @Marker1 Y", simpleType.toString()); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker1", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker1()", abinding.toString()); |
| |
| // for constructor invocation results 2/4 |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(1); |
| fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertEquals("new @Marker1 @Marker2 Outer()", expression.toString()); |
| simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType(); |
| assertEquals("@Marker1 @Marker2 Outer", simpleType.toString()); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| // for constructor invocation results 3/4 |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(2); |
| fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertEquals("o.new @Marker1 @Marker2 Inner()", expression.toString()); |
| simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType(); |
| assertEquals("@Marker1 @Marker2 Inner", simpleType.toString()); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| // for constructor invocation results 4/4 |
| variableDeclarationStatement = (VariableDeclarationStatement) statements.get(3); |
| fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertEquals("new <String>@Marker1 @Marker2 ZZ()", expression.toString()); |
| simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType(); |
| assertEquals("@Marker1 @Marker2 ZZ", simpleType.toString()); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| // annotations on wildcardtypes with TYPE_USE and TYPE_PARAMETER combination. |
| WildcardType wildCardType = (WildcardType) type; |
| assertEquals("@Marker2 @Marker3 ? super @Marker1 @Marker2 File", wildCardType.toString()); |
| assertTrue(wildCardType.annotations().size() == 2); |
| annotation = (Annotation) wildCardType.annotations().get(1); |
| assertEquals("@Marker3", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker3()", abinding.toString()); |
| |
| // simpleType for wildcard bounds |
| simpleType = (SimpleType) wildCardType.getBound(); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| // class declaration with TYPE_PARAMETER annotation |
| typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0); |
| assertEquals("@Marker3 T", typeParameter.toString()); |
| assertTrue(typeParameter.modifiers().size() == 1); |
| annotation = (Annotation)typeParameter.modifiers().get(0); |
| assertEquals("@Marker3", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker3()", abinding.toString()); |
| |
| // for type tests |
| methodDeclaration = (MethodDeclaration) getASTNode(cu, 1, 0); |
| statements = methodDeclaration.getBody().statements(); |
| statement = (Statement)statements.get(0); |
| ConditionalExpression conditionalExpression = (ConditionalExpression)((ReturnStatement)statement).getExpression(); |
| simpleType = (SimpleType) ((InstanceofExpression)conditionalExpression.getExpression()).getRightOperand(); |
| assertEquals("@Marker1 @Marker2 File", simpleType.toString()); |
| assertTrue(simpleType.annotations().size() == 2); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker2", annotation.toString()); |
| |
| // type annotation in front of a constructor declaration |
| methodDeclaration = (MethodDeclaration) getASTNode(cu, 3, 0); |
| annotation = (Annotation) methodDeclaration.modifiers().get(2); |
| assertEquals("@Marker2", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker2()", abinding.toString()); |
| |
| // type annotation on "this" |
| methodDeclaration = (MethodDeclaration) getASTNode(cu, 3, 1); |
| simpleType = (SimpleType) methodDeclaration.getReceiverType(); |
| assertEquals("@Marker2 @Marker1 ZZ", simpleType.toString()); |
| annotation = (Annotation) simpleType.annotations().get(1); |
| assertEquals("@Marker1", annotation.toString()); |
| abinding = annotation.resolveAnnotationBinding(); |
| assertEquals("@Marker1()", abinding.toString()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void test399793a() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java", |
| true/* resolve */); |
| String contents = "package test399793;" |
| + "interface I {\n" |
| + " int foo(int x);\n" |
| + "}\n" |
| + "public class X {\n" |
| + " I i = vlambda -> {return 200;};\n" |
| +"}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("vlambda -> {\n return 200;\n}\n", lambdaExpression.toString()); |
| assertTrue(lambdaExpression.parameters().size() == 1); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertEquals("public int foo(int) ", binding.toString()); |
| assertEquals("real modifiers", ClassFileConstants.AccPublic, binding.getModifiers()); |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| assertTrue(variableDeclaration instanceof VariableDeclarationFragment); |
| fragment = (VariableDeclarationFragment)variableDeclaration; |
| assertEquals("vlambda", fragment.toString()); |
| IVariableBinding variableBinding = fragment.resolveBinding(); |
| ITypeBinding typeBinding = variableBinding.getType(); |
| assertNotNull("Null Binding for lambda argument", typeBinding); |
| assertEquals("binding of int expected for lambda","int",typeBinding.getName()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void test399793b() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java", |
| true/* resolve */); |
| String contents = "package test399793;" |
| + "interface I {\n" |
| + " int foo(int x);\n" |
| + "}\n" |
| + "public class X {\n" |
| + " I i = vlambda -> 200;\n" |
| +"}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("vlambda -> 200", lambdaExpression.toString()); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertEquals("public int foo(int) ", binding.toString()); |
| assertEquals("real modifiers", ClassFileConstants.AccPublic, binding.getModifiers()); |
| assertTrue(lambdaExpression.parameters().size() == 1); |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| assertTrue(variableDeclaration instanceof VariableDeclarationFragment); |
| fragment = (VariableDeclarationFragment)variableDeclaration; |
| assertEquals("vlambda", fragment.toString()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void test399793c() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java", |
| true/* resolve */); |
| String contents = "package test399793;" |
| + "interface I {\n" |
| + " Object foo(int [] ia);\n" |
| + "}\n" |
| + "public class X {\n" |
| + " I i = (int [] ia) ->{\n" |
| + " return ia.clone();" |
| + "};\n" |
| +"}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("(int[] ia) -> {\n return ia.clone();\n}\n", lambdaExpression.toString()); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertEquals("public java.lang.Object foo(int[]) ", binding.toString()); |
| assertEquals("real modifiers", ClassFileConstants.AccPublic, binding.getModifiers()); |
| assertTrue(lambdaExpression.parameters().size() == 1); |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| assertTrue(variableDeclaration instanceof SingleVariableDeclaration); |
| SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration)variableDeclaration; |
| assertEquals("int[] ia", singleVariableDeclaration.toString()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void test399793d() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java", |
| true/* resolve */); |
| String contents = "package test399793;" + |
| "interface I {\n" + |
| " void doit();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " I i = () -> {\n" + |
| " System.out.println(this);\n" + |
| " I j = () -> {\n" + |
| " System.out.println(this);\n" + |
| " I k = () -> {\n" + |
| " System.out.println(this);\n" + |
| " };\n" + |
| " };\n" + |
| " };\n" + |
| " }\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| IVariableBinding variableBinding = fragment.resolveBinding(); |
| assertEquals("test399793.I i", variableBinding.toString()); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("() -> {\n System.out.println(this);\n I j=() -> {\n System.out.println(this);\n I k=() -> {\n System.out.println(this);\n }\n;\n }\n;\n}\n", lambdaExpression.toString()); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertEquals("public void doit() ", binding.toString()); |
| assertEquals("real modifiers", ClassFileConstants.AccPublic, binding.getModifiers()); |
| assertTrue(lambdaExpression.parameters().size() == 0); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399794 |
| * ReferenceExpression Family Tests |
| * |
| * @throws JavaModelException |
| */ |
| public void test399794() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java", |
| true/* resolve */); |
| String contents = "package test399794;" + |
| "import java.lang.annotation.*;\n " + |
| "interface I {\n" + |
| " Object copy(int [] ia);\n" + |
| "}\n" + |
| "interface J {\n" + |
| " void foo(int x);\n" + |
| "}\n" + |
| "class XX {\n" + |
| " public void foo(int x) {}\n" + |
| "}\n" + |
| "\n" + |
| "class Y {\n" + |
| " static class Z {\n" + |
| " public static void foo(int x) {\n" + |
| " System.out.print(x);\n" + |
| " }\n" + |
| " }\n" + |
| " public void foo(int x) {\n" + |
| " System.out.print(x);\n" + |
| " }\n" + |
| " public <T> void foo(T t){t.hashCode();}\n" + |
| "}\n" + |
| "\n" + |
| "public class X extends XX {\n" + |
| " @SuppressWarnings(\"unused\")\n" + |
| " public void bar(String [] args) {\n" + |
| " Y y = new Y();\n" + |
| " I i = @Marker int []::<String>clone;\n" + |
| " J j = Y.@Marker Z :: foo;\n" + |
| " J j1 = Y.@Marker Z :: <String> foo;\n" + |
| " J jdash = @Marker W<@Marker Integer> :: <String> new ;\n" + |
| " J jj = y :: foo;\n" + |
| " J jx = super :: foo;\n" + |
| " class Z {\n" + |
| " void foo() {\n" + |
| " J jz = X.super :: foo;\n" + |
| " }\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main (String [] args) {}\n" + |
| "}\n" + |
| "class W<T> extends Y {\n" + |
| " public W(T x) {}\n" + |
| "}\n" + |
| "\n" + |
| "@Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {}"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 4); |
| MethodDeclaration method = typeDeclaration.getMethods()[0]; |
| List statements = method.getBody().statements(); |
| assertTrue(statements.size() == 8); |
| int fCount = 1; |
| |
| // type method reference with primitive type with type arguments |
| VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(fCount++); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof TypeMethodReference); |
| TypeMethodReference typeMethodReference = (TypeMethodReference) expression; |
| checkSourceRange(typeMethodReference, "@Marker int []::<String>clone", contents); |
| ITypeBinding typeBinding = typeMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| IMethodBinding methodBinding = typeMethodReference.resolveMethodBinding(); |
| assertNull(methodBinding); |
| Type type = typeMethodReference.getType(); |
| checkSourceRange(type, "@Marker int []", contents); |
| assertTrue(type.isArrayType()); |
| List typeArguments = typeMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| checkSourceRange(type, "String", contents); |
| assertTrue(type.isSimpleType()); |
| SimpleName name = typeMethodReference.getName(); |
| checkSourceRange(name, "clone", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // type method reference with qualified type without type arguments |
| statement = (VariableDeclarationStatement) statements.get(fCount++); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof TypeMethodReference); |
| typeMethodReference = (TypeMethodReference) expression; |
| checkSourceRange(typeMethodReference, "Y.@Marker Z :: foo", contents); |
| typeBinding = typeMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = typeMethodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| type = typeMethodReference.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| checkSourceRange(type, "Y.@Marker Z", contents); |
| typeArguments = typeMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 0); |
| name = typeMethodReference.getName(); |
| checkSourceRange(name, "foo", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // type method reference with qualified type with type arguments |
| statement = (VariableDeclarationStatement) statements.get(fCount++); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof TypeMethodReference); |
| typeMethodReference = (TypeMethodReference) expression; |
| checkSourceRange(typeMethodReference, "Y.@Marker Z :: <String> foo", contents); |
| typeBinding = typeMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = typeMethodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| type = typeMethodReference.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| checkSourceRange(type, "Y.@Marker Z", contents); |
| typeArguments = typeMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertTrue(type.isSimpleType()); |
| checkSourceRange(type, "String", contents); |
| name = typeMethodReference.getName(); |
| checkSourceRange(name, "foo", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // creation method reference |
| statement = (VariableDeclarationStatement) statements.get(fCount++); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof CreationReference); |
| CreationReference creationReference = (CreationReference) expression; |
| checkSourceRange(creationReference, "@Marker W<@Marker Integer> :: <String> new", contents); |
| typeBinding = creationReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = creationReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| type = creationReference.getType(); |
| checkSourceRange(type, "@Marker W<@Marker Integer>", contents); |
| assertTrue(type instanceof ParameterizedType); |
| assertASTNodeEquals("@Marker W<@Marker Integer>", type); |
| typeArguments = creationReference.typeArguments(); |
| assertTrue(typeArguments.size() == 1); |
| type = (Type) typeArguments.get(0); |
| assertTrue(type.isSimpleType()); |
| checkSourceRange(type, "String", contents); |
| |
| // expression method reference |
| statement = (VariableDeclarationStatement) statements.get(fCount++); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof ExpressionMethodReference); |
| ExpressionMethodReference expressionMethodReference = (ExpressionMethodReference) expression; |
| checkSourceRange(expressionMethodReference, "y :: foo", contents); |
| typeBinding = expressionMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = expressionMethodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| Expression lhs = expressionMethodReference.getExpression(); |
| checkSourceRange(lhs, "y", contents); |
| typeArguments = expressionMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 0); |
| name = expressionMethodReference.getName(); |
| checkSourceRange(name, "foo", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // super method reference without qualifier |
| statement = (VariableDeclarationStatement) statements.get(fCount++); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof SuperMethodReference); |
| SuperMethodReference superMethodReference = (SuperMethodReference) expression; |
| checkSourceRange(superMethodReference, "super :: foo", contents); |
| typeBinding = superMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = superMethodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| assertNull(superMethodReference.getQualifier()); |
| typeArguments = superMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 0); |
| name = superMethodReference.getName(); |
| checkSourceRange(name, "foo", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // super method reference with qualifier |
| TypeDeclarationStatement typeDeclarationStatement = (TypeDeclarationStatement) statements.get(fCount); |
| typeDeclaration = (TypeDeclaration) typeDeclarationStatement.getDeclaration(); |
| method = typeDeclaration.getMethods()[0]; |
| statements = method.getBody().statements(); |
| assertTrue(statements.size() == 1); |
| statement = (VariableDeclarationStatement) statements.get(0); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| expression = fragment.getInitializer(); |
| assertTrue(expression instanceof SuperMethodReference); |
| superMethodReference = (SuperMethodReference) expression; |
| checkSourceRange(superMethodReference, "X.super :: foo", contents); |
| typeBinding = superMethodReference.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| methodBinding = superMethodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| name = (SimpleName) superMethodReference.getQualifier(); |
| checkSourceRange(name, "X", contents); |
| typeArguments = superMethodReference.typeArguments(); |
| assertTrue(typeArguments.size() == 0); |
| name = superMethodReference.getName(); |
| checkSourceRange(name, "foo", contents); |
| typeBinding = name.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void test399793e() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java", |
| true/* resolve */); |
| String contents = "package test399793;" + |
| "interface I {\n" + |
| " J foo();\n" + |
| "}\n" + |
| "interface J {\n" + |
| " int foo();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " I I = () -> () -> 10;\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 2); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("() -> () -> 10", lambdaExpression.toString()); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertEquals("public test399793.J foo() ", binding.toString()); |
| assertEquals("real modifiers", ClassFileConstants.AccPublic, binding.getModifiers()); |
| assertTrue(lambdaExpression.parameters().size() == 0); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=402665 |
| * |
| * @throws JavaModelException |
| */ |
| public void test402665a() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test402665/X.java", |
| true/* resolve */); |
| String contents = "package test402665;" + |
| "public class X {\n" + |
| " public static interface StringToInt {\n" + |
| " int stoi(String s);\n" + |
| " }\n" + |
| " public static interface ReduceInt {\n" + |
| " int reduce(int a, int b);\n" + |
| " }\n" + |
| " void foo(StringToInt s) { }\n" + |
| " void bar(ReduceInt r) { }\n" + |
| " void bar() {\n" + |
| " foo(s -> s.length());\n" + |
| " foo((s) -> s.length());\n" + |
| " foo((String s) -> s.length()); //SingleVariableDeclaration is OK\n" + |
| " bar((x, y) -> x+y);\n" + |
| " bar((int x, int y) -> x+y); //SingleVariableDeclarations are OK\n" + |
| " }\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| MethodDeclaration methoddecl = (MethodDeclaration)typedeclaration.bodyDeclarations().get(4); |
| List statements = methoddecl.getBody().statements(); |
| int sCount = 0; |
| |
| ExpressionStatement statement = (ExpressionStatement)statements.get(sCount++); |
| MethodInvocation methodInvocation = (MethodInvocation)statement.getExpression(); |
| LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0); |
| checkSourceRange(fragment, "s", contents); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0); |
| checkSourceRange(fragment, "s", contents); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| SingleVariableDeclaration singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(0); |
| checkSourceRange(singleVarDecl, "String s", contents); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0); |
| checkSourceRange(fragment, "x", contents); |
| fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(1); |
| checkSourceRange(fragment, "y", contents); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(0); |
| checkSourceRange(singleVarDecl, "int x", contents); |
| singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(1); |
| checkSourceRange(singleVarDecl, "int y", contents); |
| } |
| public void testBug403132() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " class Y {\n" + |
| " class Z {\n" + |
| " public Z(@A X.@B Y Y.this,String str){\n}" + |
| " public void foo(@A X.@B Y.@C Z this,String str){\n}\n" + |
| " }\n" + |
| " }\n" + |
| "}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface A {}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface B {}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface C {}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| TypeDeclaration type = (TypeDeclaration)node; |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| type = (TypeDeclaration) node; |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| Type receiver = method.getReceiverType(); |
| assertEquals("Not a qualified type", ASTNode.QUALIFIED_TYPE, receiver.getNodeType()); |
| assertEquals("Incorrect receiver", "@A X.@B Y", ((QualifiedType) receiver).toString()); |
| assertEquals("Incorrect method signature", "public Z(@A X.@B Y Y.this,String str){\n}\n", method.toString()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(1); |
| receiver = method.getReceiverType(); |
| assertEquals("Incorrect receiver", "@A X.@B Y.@C Z", ((QualifiedType) receiver).toString()); |
| assertEquals("Incorrect method signature", "public void foo(@A X.@B Y.@C Z this,String str){\n}\n", method.toString()); |
| } |
| public void testParameterizedReceiverType() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "public class X<T extends Exception> {\n" + |
| " class Y<K, V> {\n" + |
| " class Z {\n" + |
| " public Z(@A X<T>.@B Y<K, V> Y.this, boolean a){ }\n" + |
| " public void foo(@B Y<K, V>.@C Z this, boolean a){ }\n" + |
| " public Z(X<T>.@B Y<K, V> Y.this){ }\n" + |
| " public void foo(Y<K, V>.@C Z this){ }\n" + |
| " }\n" + |
| " }\n" + |
| "}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface A {}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface B {}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface C {}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| TypeDeclaration type = (TypeDeclaration)node; |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| type = (TypeDeclaration) node; |
| |
| MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(0); |
| Type receiver = method.getReceiverType(); |
| assertEquals("Not a ParameterizedType", ASTNode.PARAMETERIZED_TYPE, receiver.getNodeType()); |
| checkSourceRange(receiver, "@A X<T>.@B Y<K, V>", contents); |
| assertEquals("Incorrect method signature", "public Z(@A X<T>.@B Y<K,V> Y.this,boolean a){\n}\n", method.toString()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(1); |
| receiver = method.getReceiverType(); |
| assertEquals("Not a QualifiedType", ASTNode.QUALIFIED_TYPE, receiver.getNodeType()); |
| checkSourceRange(receiver, "@B Y<K, V>.@C Z", contents); |
| assertEquals("Incorrect method signature", "public void foo(@B Y<K,V>.@C Z this,boolean a){\n}\n", method.toString()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(2); |
| receiver = method.getReceiverType(); |
| assertEquals("Not a ParameterizedType", ASTNode.PARAMETERIZED_TYPE, receiver.getNodeType()); |
| checkSourceRange(receiver, "X<T>.@B Y<K, V>", contents); |
| assertEquals("Incorrect method signature", "public Z(X<T>.@B Y<K,V> Y.this){\n}\n", method.toString()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(3); |
| receiver = method.getReceiverType(); |
| assertEquals("Not a QualifiedType", ASTNode.QUALIFIED_TYPE, receiver.getNodeType()); |
| checkSourceRange(receiver, "Y<K, V>.@C Z", contents); |
| assertEquals("Incorrect method signature", "public void foo(Y<K,V>.@C Z this){\n}\n", method.toString()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=403410 |
| public void testBug403410() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " class Y {\n" + |
| " class Z {\n" + |
| " public Z(final Y Y.this){\n}" + |
| " public void foo(static @A Z this){\n}\n" + |
| " }\n" + |
| " }\n" + |
| "}\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@interface A {}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| node = getASTNode(unit, 0, 0); |
| TypeDeclaration type = (TypeDeclaration)node; |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| type = (TypeDeclaration) node; |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Type should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(1); |
| assertEquals("Type should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED)); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=402674 |
| * |
| * @throws JavaModelException |
| */ |
| public void test402674() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test402674/X.java", |
| true/* resolve */); |
| String contents = "package test402674;" + |
| "public class X {\n" + |
| " public static interface StringToInt {\n" + |
| " int stoi(String s);\n" + |
| " }\n" + |
| " public static interface ReduceInt {\n" + |
| " int reduce(int a, int b);\n" + |
| " }\n" + |
| " void foo(StringToInt s) { }\n" + |
| " void bar(ReduceInt r) { }\n" + |
| " void bar() {\n" + |
| " foo(s -> s.length());\n" + |
| " foo((s) -> s.length());\n" + |
| " foo((String s) -> s.length()); //SingleVariableDeclaration is OK\n" + |
| " bar((x, y) -> x+y);\n" + |
| " bar((int x, int y) -> x+y); //SingleVariableDeclarations are OK\n" + |
| " }\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| MethodDeclaration methoddecl = (MethodDeclaration)typedeclaration.bodyDeclarations().get(4); |
| List statements = methoddecl.getBody().statements(); |
| int sCount = 0; |
| |
| ExpressionStatement statement = (ExpressionStatement)statements.get(sCount++); |
| MethodInvocation methodInvocation = (MethodInvocation)statement.getExpression(); |
| LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| ITypeBinding binding = lambdaExpression.resolveTypeBinding(); |
| assertNotNull(binding); |
| assertEquals("StringToInt", binding.getName()); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| binding = lambdaExpression.resolveTypeBinding(); |
| assertNotNull(binding); |
| assertEquals("StringToInt", binding.getName()); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| binding = lambdaExpression.resolveTypeBinding(); |
| assertNotNull(binding); |
| assertEquals("StringToInt", binding.getName()); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| binding = lambdaExpression.resolveTypeBinding(); |
| assertNotNull(binding); |
| assertEquals("ReduceInt", binding.getName()); |
| |
| statement = (ExpressionStatement)statements.get(sCount++); |
| methodInvocation = (MethodInvocation)statement.getExpression(); |
| lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| binding = lambdaExpression.resolveTypeBinding(); |
| assertNotNull(binding); |
| assertEquals("ReduceInt", binding.getName()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=399791 |
| public void testBug399791() throws JavaModelException { |
| String contents = |
| "public interface X {\n" + |
| " static void foo(){}\n" + |
| " public default void foo(int i){}\n" + |
| " native void foo(float f){}\n" + |
| " abstract void foo(long l){}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| List modifiers = method.modifiers(); |
| assertEquals("Incorrect no of modfiers", 1, modifiers.size()); |
| Modifier modifier = (Modifier) modifiers.get(0); |
| assertSame("Incorrect modifier keyword", Modifier.ModifierKeyword.STATIC_KEYWORD, modifier.getKeyword()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(1); |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| modifiers = method.modifiers(); |
| assertEquals("Incorrect no of modfiers", 2, modifiers.size()); |
| modifier = (Modifier) modifiers.get(1); |
| assertSame("Incorrect modifier keyword", Modifier.ModifierKeyword.DEFAULT_KEYWORD, modifier.getKeyword()); |
| assertTrue("Incorrect modifier", modifier.isDefault()); |
| assertEquals("Incorrect AST", "public default void foo(int i){\n}\n", method.toString()); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(2); |
| assertEquals("Method should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(3); |
| assertEquals("Method should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED)); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=404489 |
| public void testBug404489a() throws JavaModelException { |
| String contents = |
| "package test404489.bug;\n" + |
| "public class X { \n" + |
| " class Y { \n" + |
| " class Z {\n" + |
| " public Z(@A X.@B Y Y.this){}\n" + |
| " }\n" + |
| " }\n" + |
| " Object o=(@A X.@B Y.@Marker Z)null;\n" + |
| " }\n" + |
| "@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface Marker {} \n" + |
| "@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface A {} \n" + |
| "@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface B {} \n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test404489/bug/X.java", true/* resolve */); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a Type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| node = (ASTNode) ((TypeDeclaration)node).bodyDeclarations().get(0); |
| assertEquals("Not a Type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| node = (ASTNode) ((TypeDeclaration)node).bodyDeclarations().get(0); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| Type annotatableType = method.getReceiverType(); |
| assertTrue(annotatableType.isQualifiedType()); |
| QualifiedType qualifiedType = (QualifiedType) annotatableType; |
| assertEquals("wrong qualified type", "@A X.@B Y", qualifiedType.toString()); |
| ITypeBinding binding = qualifiedType.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test404489.bug.X.Y", binding.getQualifiedName()); |
| SimpleType simpleType = (SimpleType) qualifiedType.getQualifier(); |
| assertEquals("incorrect type", "@A X", simpleType.toString()); |
| binding = simpleType.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test404489.bug.X", binding.getQualifiedName()); |
| List annotations = qualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| MarkerAnnotation marker = (MarkerAnnotation) annotations.get(0); |
| assertEquals("wrong annotation name", "@B", marker.toString()); |
| binding = marker.resolveTypeBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test404489.bug.B", binding.getQualifiedName()); |
| IAnnotationBinding annotationBinding = marker.resolveAnnotationBinding(); |
| assertNotNull(annotationBinding); |
| assertEquals("wrong annotation binding", "B", annotationBinding.getName()); |
| Name name = marker.getTypeName(); |
| assertTrue(name.isSimpleName()); |
| SimpleName simpleName = (SimpleName) name; |
| assertEquals("wrong type name", "B", simpleName.toString()); |
| assertEquals("wrong simple name", "B",simpleName.getIdentifier()); |
| binding = simpleName.resolveTypeBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test404489.bug.B", binding.getQualifiedName()); |
| assertTrue(qualifiedType.getQualifier().isSimpleType()); |
| simpleType = (SimpleType) qualifiedType.getQualifier(); |
| assertEquals("incorrect type", "@A X", simpleType.toString()); |
| binding = simpleType.resolveBinding(); |
| assertNotNull("No binding", binding); |
| assertEquals("Wrong qualified name", "test404489.bug.X", binding.getQualifiedName()); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=404489 |
| public void testBug404489b() throws JavaModelException { |
| ICompilationUnit sourceUnit = getCompilationUnit("Converter18" , "src", "test404489.bug", "X.java"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ |
| ASTNode result = runConversion(this.ast.apiLevel(), sourceUnit, true); |
| char[] source = sourceUnit.getSource().toCharArray(); |
| assertTrue("Not a compilation unit", result.getNodeType() == ASTNode.COMPILATION_UNIT); |
| CompilationUnit compilationUnit = (CompilationUnit) result; |
| assertProblemsSize(compilationUnit, 0); |
| ASTNode node = getASTNode(compilationUnit, 0, 0, 0); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) compilationUnit.types().get(0); |
| |
| node = (ASTNode) typeDeclaration.bodyDeclarations().get(2); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration methodDecl = (MethodDeclaration) node; |
| Type type = methodDecl.getReturnType2(); |
| assertTrue(type.isNameQualifiedType()); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) type; |
| checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull IOException", source); |
| ITypeBinding typeBinding = nameQualifiedType.resolveBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.IOException", typeBinding.getQualifiedName()); |
| |
| // qualifier of the name qualified type |
| Name name = nameQualifiedType.getQualifier(); |
| assertTrue(name.isQualifiedName()); |
| QualifiedName qualifiedName = (QualifiedName) name; |
| checkSourceRange(qualifiedName, "test404489.bug", source); |
| typeBinding = qualifiedName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| IBinding binding = qualifiedName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| name = qualifiedName.getQualifier(); |
| assertTrue("wrong name type", name.isSimpleName()); |
| SimpleName simpleName = (SimpleName) name; |
| checkSourceRange(simpleName, "test404489", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489", binding.toString()); |
| simpleName = qualifiedName.getName(); |
| checkSourceRange(simpleName, "bug", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| |
| // annotations of name qualified type |
| List annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| Annotation annotation = (Annotation) annotations.get(0); |
| typeBinding = annotation.resolveTypeBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName()); |
| IAnnotationBinding annotationBinding = annotation.resolveAnnotationBinding(); |
| assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString()); |
| name = annotation.getTypeName(); |
| assertTrue(name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| typeBinding = simpleName.resolveTypeBinding(); |
| checkSourceRange(simpleName, "NonNull", source); |
| assertNotNull(typeBinding); |
| |
| // name of the name qualified type |
| simpleName = nameQualifiedType.getName(); |
| checkSourceRange(simpleName, "IOException", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // parameter |
| SingleVariableDeclaration param = (SingleVariableDeclaration) methodDecl.parameters().get(0); |
| type = param.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull FileNotFoundException", source); |
| typeBinding = nameQualifiedType.resolveBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.FileNotFoundException", typeBinding.getQualifiedName()); |
| |
| // qualifier of the name qualified type |
| name = nameQualifiedType.getQualifier(); |
| assertTrue(name.isQualifiedName()); |
| qualifiedName = (QualifiedName) name; |
| checkSourceRange(qualifiedName, "test404489.bug", source); |
| typeBinding = qualifiedName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = qualifiedName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| name = qualifiedName.getQualifier(); |
| assertTrue("wrong name type", name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| checkSourceRange(simpleName, "test404489", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489", binding.toString()); |
| simpleName = qualifiedName.getName(); |
| checkSourceRange(simpleName, "bug", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| |
| // annotations of name qualified type |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| typeBinding = annotation.resolveTypeBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName()); |
| annotationBinding = annotation.resolveAnnotationBinding(); |
| assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString()); |
| name = annotation.getTypeName(); |
| assertTrue(name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| typeBinding = simpleName.resolveTypeBinding(); |
| checkSourceRange(simpleName, "NonNull", source); |
| assertNotNull(typeBinding); |
| |
| // name of the name qualified type |
| simpleName = nameQualifiedType.getName(); |
| checkSourceRange(simpleName, "FileNotFoundException", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| // throws |
| type = (Type) methodDecl.thrownExceptionTypes().get(0); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull EOFException", source); |
| typeBinding = nameQualifiedType.resolveBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.EOFException", typeBinding.getQualifiedName()); |
| |
| // qualifier of the name qualified type |
| name = nameQualifiedType.getQualifier(); |
| assertTrue(name.isQualifiedName()); |
| qualifiedName = (QualifiedName) name; |
| checkSourceRange(qualifiedName, "test404489.bug", source); |
| typeBinding = qualifiedName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = qualifiedName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| name = qualifiedName.getQualifier(); |
| assertTrue("wrong name type", name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| checkSourceRange(simpleName, "test404489", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489", binding.toString()); |
| simpleName = qualifiedName.getName(); |
| checkSourceRange(simpleName, "bug", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| |
| // annotations of name qualified type |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| typeBinding = annotation.resolveTypeBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName()); |
| annotationBinding = annotation.resolveAnnotationBinding(); |
| assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString()); |
| name = annotation.getTypeName(); |
| assertTrue(name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| typeBinding = simpleName.resolveTypeBinding(); |
| checkSourceRange(simpleName, "NonNull", source); |
| assertNotNull(typeBinding); |
| |
| // name of the name qualified type |
| simpleName = nameQualifiedType.getName(); |
| checkSourceRange(simpleName, "EOFException", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| node = (ASTNode) typeDeclaration.bodyDeclarations().get(3); |
| assertEquals("Not a field declaration", ASTNode.FIELD_DECLARATION, node.getNodeType()); |
| FieldDeclaration field = (FieldDeclaration) node; |
| type = field.getType(); |
| assertTrue(type.isQualifiedType()); |
| QualifiedType qualifiedType = (QualifiedType) type; |
| nameQualifiedType = (NameQualifiedType)qualifiedType.getQualifier(); |
| checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull X", source); |
| typeBinding = nameQualifiedType.resolveBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.X", typeBinding.getQualifiedName()); |
| name = nameQualifiedType.getName(); |
| assertSame("bindings different for name qualified type and assocated name", typeBinding, name.resolveTypeBinding()); |
| |
| // qualifier of the name qualified type |
| name = nameQualifiedType.getQualifier(); |
| assertTrue(name.isQualifiedName()); |
| qualifiedName = (QualifiedName) name; |
| checkSourceRange(qualifiedName, "test404489.bug", source); |
| typeBinding = qualifiedName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = qualifiedName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| name = qualifiedName.getQualifier(); |
| assertTrue("wrong name type", name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| checkSourceRange(simpleName, "test404489", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489", binding.toString()); |
| simpleName = qualifiedName.getName(); |
| checkSourceRange(simpleName, "bug", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNull(typeBinding); |
| binding = simpleName.resolveBinding(); |
| assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE); |
| assertEquals("wrong package binding", "package test404489.bug", binding.toString()); |
| |
| // annotations of name qualified type |
| annotations = nameQualifiedType.annotations(); |
| assertTrue(annotations.size() == 1); |
| annotation = (Annotation) annotations.get(0); |
| typeBinding = annotation.resolveTypeBinding(); |
| assertNotNull("null binding", typeBinding); |
| assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName()); |
| annotationBinding = annotation.resolveAnnotationBinding(); |
| assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString()); |
| name = annotation.getTypeName(); |
| assertTrue(name.isSimpleName()); |
| simpleName = (SimpleName) name; |
| typeBinding = simpleName.resolveTypeBinding(); |
| checkSourceRange(simpleName, "NonNull", source); |
| assertNotNull(typeBinding); |
| |
| // name of the name qualified type |
| simpleName = nameQualifiedType.getName(); |
| checkSourceRange(simpleName, "X", source); |
| typeBinding = simpleName.resolveTypeBinding(); |
| assertNotNull(typeBinding); |
| |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=399792 |
| public void testBug399792() throws JavaModelException { |
| String content = |
| "import java.lang.annotation.ElementType;\n" + |
| "import java.io.Serializable;\n" + |
| "public class X {\n" + |
| " Object o = (@Marker1 @Marker2 Serializable & I & @Marker3 @Marker1 J) () -> {};" + |
| " public Serializable main(Object o) {\n" + |
| " Serializable oo = (Serializable & @Marker3 @Marker1 @Marker2 I & J) o;\n" + |
| " return oo;\n" + |
| " }\n" + |
| "}\n" + |
| "interface I {\n" + |
| " public void foo();\n" + |
| "}\n" + |
| "interface J {\n" + |
| " public void foo();\n" + |
| " public void bar();\n" + |
| "}\n" + |
| "interface K {\n" + |
| " public void foo();\n" + |
| " public void bar();\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {}\n" + |
| "@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + |
| "@interface Marker3 {}"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false); |
| ASTNode node = buildAST(content, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a field Declaration", ASTNode.FIELD_DECLARATION, node.getNodeType()); |
| FieldDeclaration field = (FieldDeclaration) node; |
| assertEquals("Field should not be malformed", 0, (field.getFlags() & ASTNode.MALFORMED)); |
| |
| List fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| CastExpression cast = (CastExpression) fragment.getInitializer(); |
| Type castType = cast.getType(); |
| assertEquals("Not an intersection cast type", ASTNode.INTERSECTION_TYPE, castType.getNodeType()); |
| assertTrue("Not an intersection cast type", castType.isIntersectionType()); |
| assertEquals("Type should not be malformed", 0, (castType.getFlags() & ASTNode.MALFORMED)); |
| |
| List intersectionTypes = ((IntersectionType) castType).types(); |
| assertEquals("Incorrect no of types", 3, intersectionTypes.size()); |
| castType = (Type) intersectionTypes.get(0); |
| assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType()); |
| SimpleName name = (SimpleName) ((SimpleType) castType).getName(); |
| assertEquals("Incorrect name", "Serializable", name.getIdentifier()); |
| |
| List annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 2, annotations.size()); |
| assertEquals("Incorrect receiver", "@Marker1 @Marker2 Serializable", castType.toString()); |
| |
| castType = (Type) intersectionTypes.get(1); |
| assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType()); |
| name = (SimpleName) ((SimpleType) castType).getName(); |
| assertEquals("Incorrect name", "I", name.getIdentifier()); |
| |
| annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 0, annotations.size()); |
| assertEquals("Incorrect receiver", "I", castType.toString()); |
| |
| castType = (Type) intersectionTypes.get(2); |
| assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType()); |
| name = (SimpleName) ((SimpleType) castType).getName(); |
| assertEquals("Incorrect name", "J", name.getIdentifier()); |
| |
| annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 2, annotations.size()); |
| assertEquals("Incorrect receiver", "@Marker3 @Marker1 J", castType.toString()); |
| |
| node = (ASTNode) type.bodyDeclarations().get(1); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| List statements = method.getBody().statements(); |
| VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| cast = (CastExpression) fragment.getInitializer(); |
| castType = cast.getType(); |
| |
| intersectionTypes = ((IntersectionType) castType).types(); |
| assertEquals("Incorrect no of types", 3, intersectionTypes.size()); |
| castType = (Type) intersectionTypes.get(0); |
| |
| annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 0, annotations.size()); |
| assertEquals("Incorrect receiver", "Serializable", castType.toString()); |
| |
| castType = (Type) intersectionTypes.get(1); |
| annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 3, annotations.size()); |
| assertEquals("Incorrect receiver", "@Marker3 @Marker1 @Marker2 I", castType.toString()); |
| |
| castType = (Type) intersectionTypes.get(2); |
| |
| annotations = ((SimpleType) castType).annotations(); |
| assertEquals("Incorrect no of annotations", 0, annotations.size()); |
| assertEquals("Incorrect receiver", "J", castType.toString()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=406505 |
| * tests the source range issue that resulted in bad ast node. |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug406505() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test406505/X.java", |
| true/* resolve */); |
| String contents = "package test406505;" |
| + "import java.lang.annotation.Target;\n" |
| + "import java.io.File;\n" |
| + "public class X {\n" |
| + " class Folder<@Marker F extends File> { }\n" |
| + "}\n" |
| + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n" |
| + "@interface Marker {}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| typedeclaration = (TypeDeclaration)typedeclaration.bodyDeclarations().get(0); |
| TypeParameter typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0); |
| checkSourceRange(typeParameter, "@Marker F extends File", contents); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=412726 |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526 |
| public void testBug412726() throws JavaModelException { |
| String contents = |
| "public interface X {\n" + |
| " abstract void foo();\n" + |
| "}\n" + |
| "interface Y1 {\n" + |
| "}\n" + |
| "interface Y2 {\n" + |
| " default void foo() {}\n" + |
| "}\n" + |
| "interface Z1 {\n" + |
| " default void foo(){}\n" + |
| " abstract void bar();\n" + |
| "}\n" + |
| "interface Z2 {\n" + |
| " default void foo(){}\n" + |
| " abstract void bar1();\n" + |
| " abstract void bar2();\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy, true); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| /* case 0: vanilla case - interface with one abstract method */ |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| ITypeBinding typeBinding = type.resolveBinding(); |
| assertEquals("Incorrect method", typeBinding.getDeclaredMethods()[0], typeBinding.getFunctionalInterfaceMethod()); |
| /* case 1: interface without any method */ |
| type = (TypeDeclaration) unit.types().get(1); |
| typeBinding = type.resolveBinding(); |
| assertNull(typeBinding.getFunctionalInterfaceMethod()); |
| /* case 2: interface with just one default method and without any abstract method */ |
| type = (TypeDeclaration) unit.types().get(2); |
| typeBinding = type.resolveBinding(); |
| assertNull(typeBinding.getFunctionalInterfaceMethod()); |
| /* case 3: interface with just one default method and one abstract method */ |
| type = (TypeDeclaration) unit.types().get(3); |
| typeBinding = type.resolveBinding(); |
| IMethodBinding functionalInterfaceMethod = typeBinding.getFunctionalInterfaceMethod(); |
| assertNotNull(functionalInterfaceMethod); |
| assertEquals("Incorrect method", "public abstract void bar() ", functionalInterfaceMethod.toString()); |
| assertEquals(typeBinding, functionalInterfaceMethod.getDeclaringClass()); |
| /* case 4: interface with just one default method and two abstract methods */ |
| type = (TypeDeclaration) unit.types().get(4); |
| typeBinding = type.resolveBinding(); |
| assertNull(typeBinding.getFunctionalInterfaceMethod()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017a() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java", |
| true/* resolve */); |
| String contents = "package test417017;" |
| + "interface I {\n" |
| + " int foo(int x);\n" |
| + "}\n" |
| + "public class X {\n" |
| + " void fun(int a) {\n" |
| +" I i1 = x1-> x1;\n" |
| +" I i2 = xxx-> {\n" |
| +" i1.foo(a);\n" |
| +" return xxx;\n" |
| +" };\n" |
| +" }\n" |
| +"}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0]; |
| VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(1)).fragments().get(0); |
| LambdaExpression lambda= (LambdaExpression) vdf.getInitializer(); |
| List parameters = lambda.parameters(); |
| assertTrue("Incorrect Number of parameters", parameters.size() == 1); |
| ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes(); |
| assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1); |
| assertEquals("Incorrect parameter type", "int", parameterTypes[0].toString()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017b() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java", |
| true/* resolve */); |
| String contents = "package test417017;" + |
| "interface I1 {\n" + |
| " int foo(int a);\n" + |
| "}\n" + |
| "\n" + |
| "interface I2 {\n" + |
| " public default int foo() {\n" + |
| " I1 i1 = (a) -> {\n" + |
| " return a;\n" + |
| " };\n" + |
| " //return 0;\n" + // Error on purpose |
| " }\n" + |
| "}\n" ; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy, false); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0]; |
| VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(0)).fragments().get(0); |
| LambdaExpression lambda= (LambdaExpression) vdf.getInitializer(); |
| List parameters = lambda.parameters(); |
| assertTrue("Incorrect Number of parameters", parameters.size() == 1); |
| ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes(); |
| assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1); |
| assertEquals("Incorrect parameter type", "int", parameterTypes[0].toString()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017c() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java", |
| true/* resolve */); |
| String contents = "package test417017;" + |
| "interface I1 {\n" + |
| " int foo(int a);\n" + |
| "}\n" + |
| "\n" + |
| "interface I2 {\n" + |
| " public default int foo() {\n" + |
| " I1 i1 = (float a) -> {\n" + |
| " return a;\n" + |
| " };\n" + |
| " //return 0;\n" + // Error on purpose |
| " }\n" + |
| "}\n" ; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy, false); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0]; |
| VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(0)).fragments().get(0); |
| LambdaExpression lambda= (LambdaExpression) vdf.getInitializer(); |
| List parameters = lambda.parameters(); |
| assertTrue("Incorrect Number of parameters", parameters.size() == 1); |
| ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes(); |
| assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1); |
| assertEquals("Incorrect parameter type", "float", parameterTypes[0].toString()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017d() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java", |
| true/* resolve */); |
| String contents = "package test399794;" + |
| "interface I {\n" + |
| " void foo(X x);\n" + |
| "}\n" + |
| "public class X {\n" + |
| " void foo(X x) {\n" + |
| " }\n" + |
| " I i = this::foo;\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration field = typeDeclaration.getFields()[0]; |
| |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| ExpressionMethodReference methodReference = (ExpressionMethodReference) expression; |
| IMethodBinding methodBinding = methodReference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| ITypeBinding [] parameterTypes = methodBinding.getParameterTypes(); |
| assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1); |
| assertEquals("Incorrect parameter type", "X", parameterTypes[0].getName()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017e() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java", |
| true/* resolve */); |
| String contents = "package test399794;" + |
| "interface I {\n" + |
| " int [] foo(int x);\n" + |
| "}\n" + |
| "public class X {\n" + |
| " I i = int []::new;\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration field = typeDeclaration.getFields()[0]; |
| |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| CreationReference creationReference = (CreationReference) expression; |
| IMethodBinding methodBinding = creationReference.resolveMethodBinding(); |
| assertNull(methodBinding); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017 |
| * |
| * @throws JavaModelException |
| */ |
| public void test417017f() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java", |
| true/* resolve */); |
| String contents = "package test399794;" + |
| "interface I {\n" + |
| " void foo(X x);\n" + |
| "}\n" + |
| "public class X {\n" + |
| " private void foo(X x) {\n" + |
| " }\n" + |
| " class Y {\n" + |
| " I i = X.this::foo;\n" + |
| " }\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| typeDeclaration = typeDeclaration.getTypes()[0]; |
| FieldDeclaration field = typeDeclaration.getFields()[0]; |
| |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| ExpressionMethodReference reference = (ExpressionMethodReference) expression; |
| IMethodBinding methodBinding = reference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| assertEquals("Wrong name", "foo", methodBinding.getName()); |
| ITypeBinding [] parameterTypes = methodBinding.getParameterTypes(); |
| assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1); |
| assertEquals("Incorrect parameter type", "X", parameterTypes[0].getName()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=413942 |
| // also refer https://bugs.eclipse.org/bugs/show_bug.cgi?id=413569 |
| public void testBug413942() throws JavaModelException { |
| String contents = |
| "public class X extends @NonNull(int[].class) Object {\n" + |
| " Object field = new ArrayList< @NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]>() ;\n" + |
| " @Annot int @Annot1 [] a1 @Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ] @Annot3 @Annot2 [] @Annot4 [];\n" + |
| " int[] xxx[];\n" + |
| " int [][] ii = new int[2][3];" + |
| " ArrayList<int[]> [][] yyy; // source ranges already broken in AST.JLS4\n" + |
| " ArrayList<int[][]> [][][][] zzz;\n" + |
| " ArrayList<Float> [][][] zzz2;\n" + |
| " Object a = new ArrayList< @TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []>() ;\n" + |
| " Object b = new @NonNull(value1 = Math.PI) ArrayList< >() ; \n" + |
| " Object c = new ArrayList<@NonNull(value1= Math.PI ) Object[]>() ;\n" + |
| "\n" + |
| " int foo(@TakeType(int[].class)int i ) @TakeType(int[].class) [] {\n" + |
| " int[] arr = new int[2];\n" + |
| " for (String tab @TakeType(int[].class) [] = null;; ++i) { break; }\n" + |
| " for (@Deprecated String tab@TakeType(int[].class) [][] = null;; ++i) {}\n" + |
| " }\n" + |
| " int bar(int [] /*@TakeType(int[].class)*/ [] a ) {\n" + |
| " return 0;\n" + |
| " }\n" + |
| "public int var1(int @TakeType(int[].class)... args) { return 0;}\n" + |
| "public int var2(int @Annot ... args) { return 0;}\n" + |
| "}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface NonNull {\n" + |
| " Class value() default int.class;\n" + |
| " double value1() default 0;\n" + |
| "}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface NonEmpty {\n" + |
| " int value() default 0;\n" + |
| "}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface TakeType {\n" + |
| " Class value() default int[].class;\n" + |
| "}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface Annot {}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface Annot1 {}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface Annot2 {}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface Annot3 {}\n" + |
| "\n" + |
| "@Target(ElementType.TYPE_USE)\n" + |
| "@Retention(RetentionPolicy.RUNTIME)\n" + |
| "@Documented\n" + |
| "@interface Annot4 {}\n" + |
| "\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| SimpleType simpleType = (SimpleType) type.getSuperclassType(); |
| checkSourceRange(simpleType, "@NonNull(int[].class) Object", contents); |
| SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) simpleType.annotations().get(0); |
| checkSourceRange(singleMemberAnnotation, "@NonNull(int[].class)", contents); |
| TypeLiteral typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue(); |
| checkSourceRange(typeLiteral, "int[].class", contents); |
| ArrayType arrayType = (ArrayType) typeLiteral.getType(); |
| checkSourceRange(arrayType, "int[]", contents); |
| |
| int count = 0; |
| FieldDeclaration field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "Object field = new ArrayList< @NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]>() ;", contents); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| ClassInstanceCreation instance = (ClassInstanceCreation) fragment.getInitializer(); |
| ParameterizedType parameterizedType = (ParameterizedType) instance.getType(); |
| arrayType = (ArrayType) parameterizedType.typeArguments().get(0); |
| checkSourceRange(arrayType, "@NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]", contents); |
| PrimitiveType primitiveType = (PrimitiveType) arrayType.getElementType(); |
| checkSourceRange(primitiveType, "@NonEmpty(0) int", contents); |
| Dimension dimension = (Dimension) arrayType.dimensions().get(0); |
| checkSourceRange(dimension, "@NonNull(value1 = 1) []", contents); |
| dimension = (Dimension) arrayType.dimensions().get(1); |
| checkSourceRange(dimension, "@NonEmpty(1) [ ]", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "@Annot int @Annot1 [] a1 @Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ] @Annot3 @Annot2 [] @Annot4 [];", contents); |
| arrayType = (ArrayType) field.getType(); |
| checkSourceRange(arrayType, "int @Annot1 []", contents); |
| fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| dimension = (Dimension) fragment.extraDimensions().get(0); |
| checkSourceRange(dimension, "@Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ]", contents); |
| dimension = (Dimension) fragment.extraDimensions().get(1); |
| checkSourceRange(dimension, "@Annot3 @Annot2 []", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "int[] xxx[];", contents); |
| assertTrue(field.getType().isArrayType()); |
| arrayType = (ArrayType) field.getType(); |
| checkSourceRange(arrayType, "int[]", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "int [][] ii = new int[2][3];", contents); |
| arrayType = (ArrayType) field.getType(); |
| checkSourceRange(arrayType, "int [][]", contents); |
| fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| ArrayCreation arrayCreation = (ArrayCreation) fragment.getInitializer(); |
| arrayType = arrayCreation.getType(); |
| assertTrue(arrayType.getElementType().isPrimitiveType()); |
| assertTrue(arrayType.getDimensions() == 2); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "ArrayList<int[]> [][] yyy;", contents); |
| arrayType = (ArrayType) field.getType(); |
| checkSourceRange(arrayType, "ArrayList<int[]> [][]", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "ArrayList<int[][]> [][][][] zzz;", contents); |
| arrayType = (ArrayType) field.getType(); |
| assertTrue(arrayType.getElementType().isParameterizedType()); |
| assertTrue(arrayType.getDimensions() == 4); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "ArrayList<Float> [][][] zzz2;", contents); |
| arrayType = (ArrayType) field.getType(); |
| assertTrue(arrayType.getElementType().isParameterizedType()); |
| assertTrue(arrayType.getDimensions() == 3); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "Object a = new ArrayList< @TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []>() ;", contents); |
| fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer(); |
| parameterizedType = (ParameterizedType) classInstanceCreation.getType(); |
| arrayType = (ArrayType) parameterizedType.typeArguments().get(0); |
| checkSourceRange(arrayType, "@TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []", contents); |
| checkSourceRange(arrayType.getElementType(), "@TakeType(int[][].class) int", contents); |
| assertTrue(arrayType.getElementType().isPrimitiveType()); |
| dimension = (Dimension) arrayType.dimensions().get(0); |
| checkSourceRange(dimension, "@TakeType(float.class) []", contents); |
| dimension = (Dimension) arrayType.dimensions().get(1); |
| Annotation annotation = (Annotation) dimension.annotations().get(0); |
| assertTrue(annotation.isSingleMemberAnnotation()); |
| singleMemberAnnotation = (SingleMemberAnnotation) annotation; |
| typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue(); |
| checkSourceRange(typeLiteral, "double.class", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "Object b = new @NonNull(value1 = Math.PI) ArrayList< >() ;", contents); |
| fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer(); |
| parameterizedType = (ParameterizedType) classInstanceCreation.getType(); |
| checkSourceRange(parameterizedType.getType(), "@NonNull(value1 = Math.PI) ArrayList", contents); |
| |
| field = (FieldDeclaration) type.bodyDeclarations().get(count++); |
| checkSourceRange(field, "Object c = new ArrayList<@NonNull(value1= Math.PI ) Object[]>() ;", contents); |
| fragment = (VariableDeclarationFragment) field.fragments().get(0); |
| classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer(); |
| parameterizedType = (ParameterizedType) classInstanceCreation.getType(); |
| arrayType = (ArrayType) parameterizedType.typeArguments().get(0); |
| assertTrue(arrayType.getDimensions() == 1); |
| |
| MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(count++); |
| dimension = (Dimension) method.extraDimensions().get(0); |
| checkSourceRange(dimension, "@TakeType(int[].class) []", contents); |
| singleMemberAnnotation = (SingleMemberAnnotation) dimension.annotations().get(0); |
| typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue(); |
| arrayType = (ArrayType) typeLiteral.getType(); |
| assertTrue(arrayType.getElementType().isPrimitiveType()); |
| assertTrue(arrayType.getDimensions() == 1); |
| SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0); |
| singleMemberAnnotation = (SingleMemberAnnotation) singleVariableDeclaration.modifiers().get(0); |
| checkSourceRange(singleMemberAnnotation, "@TakeType(int[].class)", contents); |
| typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue(); |
| arrayType = (ArrayType) typeLiteral.getType(); |
| assertTrue(arrayType.getElementType().isPrimitiveType()); |
| assertTrue(arrayType.getDimensions() == 1); |
| ForStatement forStatement = (ForStatement) method.getBody().statements().get(1); |
| VariableDeclarationExpression variableDeclarationExpression = (VariableDeclarationExpression) forStatement.initializers().get(0); |
| fragment = (VariableDeclarationFragment) variableDeclarationExpression.fragments().get(0); |
| dimension = (Dimension) fragment.extraDimensions().get(0); |
| checkSourceRange(dimension, "@TakeType(int[].class) []", contents); |
| forStatement = (ForStatement) method.getBody().statements().get(1); |
| variableDeclarationExpression = (VariableDeclarationExpression) forStatement.initializers().get(0); |
| fragment = (VariableDeclarationFragment) variableDeclarationExpression.fragments().get(0); |
| dimension = (Dimension) fragment.extraDimensions().get(0); |
| checkSourceRange(dimension, "@TakeType(int[].class) []", contents); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(count++); |
| singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0); |
| // test case active only after bug 417660 is fixed (uncomment) |
| checkSourceRange(singleVariableDeclaration, "int [] /*@TakeType(int[].class)*/ [] a", contents); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(count++); |
| singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0); |
| checkSourceRange(singleVariableDeclaration, "int @TakeType(int[].class)... args", contents); |
| singleMemberAnnotation = (SingleMemberAnnotation) singleVariableDeclaration.varargsAnnotations().get(0); |
| typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue(); |
| arrayType = (ArrayType) typeLiteral.getType(); |
| assertTrue(arrayType.getElementType().isPrimitiveType()); |
| assertTrue(arrayType.getDimensions() == 1); |
| |
| method = (MethodDeclaration) type.bodyDeclarations().get(count++); |
| singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0); |
| checkSourceRange(singleVariableDeclaration, "int @Annot ... args", contents); |
| assertTrue(singleVariableDeclaration.varargsAnnotations().size() == 1); |
| |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=409586 |
| public void testBug409586() throws JavaModelException { |
| String contents = |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker {\n" + |
| " String value() default \"\";\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {\n" + |
| " String value() default \"22\";\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public @Marker(\"1\") String foo(int @Marker @Marker2 [] args) {\n" + |
| " return null;\n" + |
| " }\n" + |
| " public @Marker(\"3\") String bar() {\n" + |
| " return null;\n" + |
| " }\n" + |
| " public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str = null;\n" + |
| " public @Marker String str2 = null;\n" + |
| " public @Marker String str3 = null;\n" + |
| " public String str4 = null;\n" + |
| "}"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 2, 0); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) node; |
| IMethodBinding mBinding = methodDeclaration.resolveBinding(); |
| assertNotNull("Should not be null", mBinding); |
| ITypeBinding tBinding1 = mBinding.getReturnType(); |
| assertNotNull("Should not be null", tBinding1); |
| |
| /* public @Marker("1") String foo(int @Marker @Marker2 [] args) */ |
| List params = methodDeclaration.parameters(); |
| assertEquals("Incorrect params", 1, params.size()); |
| SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0); |
| ArrayType type = (ArrayType) param.getType(); |
| ITypeBinding tBinding = type.resolveBinding(); |
| assertNotNull("Should not be null", tBinding); |
| IAnnotationBinding[] annots = tBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 2, annots.length); |
| assertEquals("Incorrect annotation", "@Marker()", annots[0].toString()); |
| assertEquals("Incorrect annotation", "@Marker2()", annots[1].toString()); |
| |
| /* public @Marker("3") String bar()*/ |
| node = getASTNode(compilationUnit, 2, 1); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| methodDeclaration = (MethodDeclaration) node; |
| mBinding = methodDeclaration.resolveBinding(); |
| assertNotNull("Should not be null", mBinding); |
| ITypeBinding tBinding2 = mBinding.getReturnType(); |
| assertNotNull("Should not be null", tBinding1); |
| assertNotSame("Type bindings should not be same", tBinding1, tBinding2); |
| annots = tBinding1.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 1, annots.length); |
| IAnnotationBinding annot = annots[0]; |
| assertEquals("Incorrect annotation", "@Marker(value = 1)", annot.toString()); |
| annots = tBinding2.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 1, annots.length); |
| annot = annots[0]; |
| assertEquals("Incorrect annotation", "@Marker(value = 3)", annot.toString()); |
| |
| /* public String @Marker("i0") @Marker2 [] [] @Marker("i1") [] str = null; */ |
| node = getASTNode(compilationUnit, 2, 2); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| FieldDeclaration field = (FieldDeclaration) node; |
| List fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| IVariableBinding variable = fragment.resolveBinding(); |
| assertNotNull("Should not be null", variable); |
| ITypeBinding tBinding3 = variable.getType(); |
| assertNotNull("Should not be null", tBinding3); |
| annots = tBinding3.getTypeAnnotations(); |
| |
| assertEquals("Incorrect type annotations", 2, annots.length); |
| assertEquals("Incorrect annotation", "@Marker(value = i0)", annots[0].toString()); |
| assertEquals("Incorrect annotation", "@Marker2()", annots[1].toString()); |
| tBinding3 = tBinding3.getComponentType(); |
| annots = tBinding3.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 0, annots.length); |
| tBinding3 = tBinding3.getComponentType(); |
| annots = tBinding3.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 1, annots.length); |
| assertEquals("Incorrect annotation", "@Marker(value = i1)", annots[0].toString()); |
| |
| /* public @Marker String str2 = null; */ |
| node = getASTNode(compilationUnit, 2, 3); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| field = (FieldDeclaration) node; |
| fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| fragment = (VariableDeclarationFragment) fragments.get(0); |
| variable = fragment.resolveBinding(); |
| assertNotNull("Should not be null", variable); |
| tBinding1 = variable.getType(); |
| |
| /* public @Marker String str3 = null; */ |
| node = getASTNode(compilationUnit, 2, 4); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| field = (FieldDeclaration) node; |
| fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| fragment = (VariableDeclarationFragment) fragments.get(0); |
| variable = fragment.resolveBinding(); |
| assertNotNull("Should not be null", variable); |
| tBinding2 = variable.getType(); |
| assertSame("Type bindings should be same", tBinding1, tBinding2); |
| assertTrue("Unannotated bindings should be same", tBinding1.isEqualTo(tBinding2)); |
| |
| /* public String str4 = null; */ |
| node = getASTNode(compilationUnit, 2, 5); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| field = (FieldDeclaration) node; |
| fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| fragment = (VariableDeclarationFragment) fragments.get(0); |
| variable = fragment.resolveBinding(); |
| assertNotNull("Should not be null", variable); |
| tBinding2 = variable.getType(); |
| assertNotSame("Type bindings should not be same", tBinding1, tBinding2); |
| assertTrue("Unannotated bindings should be same", tBinding1.isEqualTo(tBinding2)); |
| } |
| |
| public void testExtendedDimensions() throws JavaModelException { |
| String contents = |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker {\n" + |
| " String value() default \"\";\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker2 {\n" + |
| " String value() default \"22\";\n" + |
| "}\n" + |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker3 {\n" + |
| " String value() default \"22\";\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public @Marker(\"1\") String @Marker(\"2\") [] foo(int @Marker @Marker2 [] args @Marker3 []) @Marker3(\"3\") [] {\n" + |
| " return null;\n" + |
| " }\n" + |
| " public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str @Marker(\"Extended\") [] = null;\n" + |
| "}\n"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 3, 0); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| MethodDeclaration methodDeclaration = (MethodDeclaration) node; |
| Type returnType = methodDeclaration.getReturnType2(); |
| ITypeBinding tBinding1 = returnType.resolveBinding(); |
| assertEquals("Unexpected type", tBinding1.toString(), "@Marker((String)\"1\") String @Marker((String)\"2\") []"); |
| assertEquals("Unexpected type", methodDeclaration.resolveBinding().getReturnType().toString(), "@Marker((String)\"1\") String @Marker3((String)\"3\") [] @Marker((String)\"2\") []"); |
| |
| List params = methodDeclaration.parameters(); |
| assertEquals("Incorrect params", 1, params.size()); |
| SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0); |
| ArrayType type = (ArrayType) param.getType(); |
| ITypeBinding tBinding = type.resolveBinding(); |
| assertEquals("Unexpected type", tBinding.toString(), "int @Marker @Marker2 []"); |
| assertEquals("Unexpected type", param.resolveBinding().getType().toString(), "int @Marker3 [] @Marker @Marker2 []"); |
| |
| // public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str @Marker(\"Extended\") [] = null; |
| node = getASTNode(compilationUnit, 3, 1); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| FieldDeclaration field = (FieldDeclaration) node; |
| List fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| assertEquals("Unexpected type", fragment.resolveBinding().getType().toString(), "String @Marker((String)\"Extended\") [] @Marker((String)\"i0\") @Marker2 [] [] @Marker((String)\"i1\") []"); |
| assertEquals("Unexpected type", "String @Marker(\"i0\") @Marker2 [][] @Marker(\"i1\") []", field.getType().toString()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=417669 |
| public void testBug417669() throws JavaModelException { |
| String contents = |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Marker {}\n" + |
| "public class X {\n" + |
| " public static void main(String [] args) {\n" + |
| " W<String> w = (@Marker W<String>) null;\n" + |
| " }\n" + |
| "}\n" + |
| "class W<T> {}"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 1, 0); |
| assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| List statements = method.getBody().statements(); |
| VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| CastExpression cast = (CastExpression) fragment.getInitializer(); |
| ParameterizedType castType = (ParameterizedType) cast.getType(); |
| Type type = castType.getType(); |
| checkSourceRange(castType, "@Marker W<String>", contents); |
| checkSourceRange(type, "@Marker W", contents); |
| } |
| |
| // Bug 414113 - [1.8] Method Binding for default method has abstract modifier instead of default |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=414113 |
| public void testBug414113() throws JavaModelException { |
| String contents = |
| "public interface X {\n" + |
| " int i = foo();\n" + |
| " default int foo_default() { return 1;}\n" + |
| " static int foo_static() { return 1;}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(1); |
| IMethodBinding binding = method.resolveBinding(); |
| assertTrue("binding is default", (binding.getModifiers() & Modifier.DEFAULT) != 0); |
| method = (MethodDeclaration) type.bodyDeclarations().get(2); |
| binding = method.resolveBinding(); |
| assertTrue("binding is static", (binding.getModifiers() & Modifier.STATIC) != 0); |
| } |
| |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420660 |
| */ |
| public void testBug420660() throws JavaModelException { |
| String contents = |
| "package java.lang;\n" + |
| "public class X {\n" + |
| " public void foo(int p, int q) {\n" + |
| " final int finalVar = 1; // not effectively final! \n" + |
| " int effectivelyFinalVar = 2;\n" + |
| " int nonFinalVar = 3;\n" + |
| " nonFinalVar = 4; \n" + |
| " q = 0;\n" + |
| " try (FIS fis = new FIS()) {\n" + |
| " if (q == 0) { throw new IOError(); } else { throw new IllegalStateException(); }\n" + |
| " } catch (IOError | IllegalStateException implicitlyFinalExc) {\n" + |
| " // implicitlyFinalExc is not effectively final! \n" + |
| " } catch (Exception effectivelyFinalExc) { \n" + |
| " }\n" + |
| " }\n" + |
| "}\n" + |
| "class IOError extends Exception {private static final long serialVersionUID = 1L;}\n" + |
| "class IllegalStateException extends Exception {private static final long serialVersionUID = 1L;}\n" + |
| "class FIS implements AutoCloseable {\n public void close() throws Exception {} \n }\n" + |
| "interface AutoCloseable { \n void close() throws Exception; \n}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/java/lang/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 1, methods.length); |
| MethodDeclaration method = methods[0]; |
| List params = method.parameters(); |
| assertEquals("Incorrect no of parameters", 2, params.size()); |
| SingleVariableDeclaration variable = (SingleVariableDeclaration) params.get(0); |
| IVariableBinding binding = variable.resolveBinding(); |
| assertTrue("Should be effectively final", binding.isEffectivelyFinal()); |
| variable = (SingleVariableDeclaration) params.get(1); |
| binding = variable.resolveBinding(); |
| assertFalse("Should not be effectively final", binding.isEffectivelyFinal()); |
| |
| List statements = method.getBody().statements(); |
| VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); |
| List fragments = statement.fragments(); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| binding = fragment.resolveBinding(); |
| assertFalse("Should not be effectively final", binding.isEffectivelyFinal()); |
| statement = (VariableDeclarationStatement) statements.get(1); |
| fragments = statement.fragments(); |
| fragment = (VariableDeclarationFragment) fragments.get(0); |
| binding = fragment.resolveBinding(); |
| assertTrue("Should be effectively final", binding.isEffectivelyFinal()); |
| |
| statement = (VariableDeclarationStatement) statements.get(2); |
| fragments = statement.fragments(); |
| fragment = (VariableDeclarationFragment) fragments.get(0); |
| binding = fragment.resolveBinding(); |
| assertFalse("Should not be effectively final", binding.isEffectivelyFinal()); |
| |
| TryStatement tryStmt = (TryStatement) statements.get(5); |
| List resources = tryStmt.resources(); |
| VariableDeclarationExpression resourceExp = (VariableDeclarationExpression) resources.get(0); |
| fragment = (VariableDeclarationFragment) resourceExp.fragments().get(0); |
| binding = fragment.resolveBinding(); |
| assertFalse("Should not be effectively final", binding.isEffectivelyFinal()); |
| |
| List catches = tryStmt.catchClauses(); |
| CatchClause catchCl = (CatchClause) catches.get(1); |
| variable = catchCl.getException(); |
| binding = variable.resolveBinding(); |
| assertTrue("Should be effectively final", binding.isEffectivelyFinal()); |
| catchCl = (CatchClause) catches.get(0); |
| variable = catchCl.getException(); |
| binding = variable.resolveBinding(); |
| assertFalse("Should not be effectively final", binding.isEffectivelyFinal()); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420660 |
| */ |
| public void testBug420660a() throws JavaModelException { |
| String contents = |
| "interface I {\nvoid foo();\n}\n" + |
| "interface J {}\n" + |
| "public class X {\n" + |
| " void foo(int [] p) {\n" + |
| " for (int is : p) {\n" + |
| " I j = new I () {\n" + |
| " public void foo() {\n" + |
| " System.out.println(is);\n" + |
| " }\n" + |
| " };\n" + |
| " }\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 2); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 1, methods.length); |
| MethodDeclaration method = methods[0]; |
| List statements = method.getBody().statements(); |
| EnhancedForStatement stmt = (EnhancedForStatement) statements.get(0); |
| SingleVariableDeclaration variable = stmt.getParameter(); |
| IVariableBinding binding = variable.resolveBinding(); |
| assertTrue("Should be effectively final", binding.isEffectivelyFinal()); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=423872 |
| */ |
| public void testBug423872() throws JavaModelException { |
| String contents = |
| "public interface X {\n" + |
| " void foo(Y.Z<?>... events);\n" + |
| "}\n" + |
| "interface Y<T> {\n" + |
| " public static interface Z<T> {}\n" + |
| "}\n"; |
| try { |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 1, methods.length); |
| MethodDeclaration method = methods[0]; |
| List parameters = method.parameters(); |
| assertTrue(parameters.size() == 1); |
| SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration) parameters.get(0); |
| checkSourceRange(singleVariableDeclaration, "Y.Z<?>... events", contents); |
| assertTrue(singleVariableDeclaration.isVarargs()); |
| Type type = singleVariableDeclaration.getType(); |
| assertTrue(type.isParameterizedType()); |
| } catch (IllegalArgumentException e) { |
| assertTrue(false); |
| } |
| } |
| |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138 |
| */ |
| public void testBug424138_001() throws JavaModelException { |
| String contents = |
| "package jsr308.myex;\n" + |
| "\n" + |
| "public class X extends @jsr308.myex.X.Anno Object {\n" + |
| " void foo(@jsr308.myex.X.Anno X this) {}\n" + |
| " Y<@jsr308.myex.X.Anno Object> l;\n" + |
| " int o @jsr308.myex.X.Anno[];\n" + |
| "\n" + |
| " @jsr308.myex.X.Anno X f;\n" + |
| " int @jsr308.myex.X.Anno[] ok;\n" + |
| " @jsr308.myex.X.Anno X g;\n" + |
| " void bar(@jsr308.myex.X.Anno X ok) {\n" + |
| " @jsr308.myex.X.Anno X l;\n" + |
| " }\n" + |
| " @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" + |
| " public @interface Anno {}\n" + |
| "}\n" + |
| "class Y<T> {}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) node; |
| SimpleType simpleType = (SimpleType) typeDeclaration.getSuperclassType(); |
| checkSourceRange(simpleType, "@jsr308.myex.X.Anno Object", contents); |
| Annotation annotation = (Annotation) simpleType.annotations().get(0); |
| checkSourceRange(annotation, "@jsr308.myex.X.Anno", contents); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 2, methods.length); |
| MethodDeclaration method = methods[0]; |
| simpleType = (SimpleType) method.getReceiverType(); |
| checkSourceRange(simpleType, "@jsr308.myex.X.Anno X", contents); |
| FieldDeclaration [] fields = typeDeclaration.getFields(); |
| FieldDeclaration f = fields[0]; |
| checkSourceRange(f, "Y<@jsr308.myex.X.Anno Object> l;", contents); |
| Type type = f.getType(); |
| assertTrue(type.isParameterizedType()); |
| ParameterizedType parameterizedType = (ParameterizedType) type; |
| checkSourceRange((ASTNode) parameterizedType.typeArguments().get(0), "@jsr308.myex.X.Anno Object", contents); |
| f = fields[1]; |
| checkSourceRange(f, "int o @jsr308.myex.X.Anno[];", contents); |
| assertTrue(f.getType().isPrimitiveType()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) f.fragments().get(0); |
| checkSourceRange((ASTNode) fragment.extraDimensions().get(0), "@jsr308.myex.X.Anno[]", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138 |
| */ |
| public void testBug424138_002() throws JavaModelException { |
| String contents = |
| "package jsr308.myex;\n" + |
| "\n" + |
| "public class X{\n" + |
| " int o2[];\n" + |
| " int o1 @jsr308.myex.X.Anno[];\n" + |
| " int @jsr308.myex.X.Anno[][] o3 @jsr308.myex.X.Anno[][];\n" + |
| " @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" + |
| " public @interface Anno {}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) node; |
| FieldDeclaration [] fields = typeDeclaration.getFields(); |
| FieldDeclaration f = fields[0]; |
| checkSourceRange(f, "int o2[];", contents); |
| f = fields[1]; |
| checkSourceRange(f, "int o1 @jsr308.myex.X.Anno[];", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138 |
| */ |
| public void testBug424138_003() throws JavaModelException { |
| String contents = |
| "package jsr308.myex;\n" + |
| "\n" + |
| "public class X{\n" + |
| " public void foo() {\n" + |
| " for (int i @jsr308.myex.X.Anno[]: new int[10][12]) {\n" + |
| " System.out.println(\"hello\");\n" + |
| " }\n" + |
| " }\n" + |
| " @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" + |
| " public @interface Anno {}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) node; |
| MethodDeclaration [] methods = typeDeclaration.getMethods(); |
| EnhancedForStatement statement = (EnhancedForStatement) methods[0].getBody().statements().get(0); |
| SingleVariableDeclaration variable = statement.getParameter(); |
| checkSourceRange(variable, "int i @jsr308.myex.X.Anno[]", contents); |
| Dimension dim = (Dimension) variable.extraDimensions().get(0); |
| checkSourceRange(dim, "@jsr308.myex.X.Anno[]", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=423584, [1.8][dom ast] NPE in LambdaExpression#getMethodBinding() for lambda with unresolved type |
| */ |
| public void test423584() throws JavaModelException { |
| String contents = |
| "interface I { }\n" + |
| "public class X {\n" + |
| " static void goo(I i) {\n" + |
| " System.out.println(\"goo(I)\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " goo(s -> 0);\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 2, "The method goo(I) in the type X is not applicable for the arguments ((<no type> s) -> {})\n" + |
| "The target type of this expression must be a functional interface"); |
| node = getASTNode(compilationUnit, 1); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 2, methods.length); |
| MethodDeclaration method = methods[1]; |
| List statements = method.getBody().statements(); |
| LambdaExpression lambda = (LambdaExpression) ((MethodInvocation) ((ExpressionStatement) statements.get(0)).getExpression()).arguments().get(0); |
| IMethodBinding resolveMethodBinding = lambda.resolveMethodBinding(); |
| assertTrue("Should be null", resolveMethodBinding == null); // no NPE, just a null method binding. |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979 |
| */ |
| public void testBug418979_001() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " void foo(Y.@A Z<?> events) {}\n" + |
| " void foo(Y.@A ZZ events) {}\n" + |
| " }\n" + |
| "class Y {\n" + |
| " class Z<T> {}\n" + |
| " class ZZ{}\n" + |
| "}\n" + |
| "@Target (ElementType.TYPE_USE)\n" + |
| "@interface A{}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| assertEquals("Incorrect no of methods", 2, methods.length); |
| MethodDeclaration method = methods[0]; |
| List params = method.parameters(); |
| assertEquals("Incorrect no of parameters", 1, params.size()); |
| SingleVariableDeclaration variable = (SingleVariableDeclaration) params.get(0); |
| Type type = variable.getType(); |
| assertTrue(type.isParameterizedType()); |
| ParameterizedType parameterizedType = (ParameterizedType) type; |
| checkSourceRange(parameterizedType, "Y.@A Z<?>", contents); |
| type = parameterizedType.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) type; |
| checkSourceRange(nameQualifiedType, "Y.@A Z", contents); |
| |
| method = methods[1]; |
| params = method.parameters(); |
| assertEquals("Incorrect no of parameters", 1, params.size()); |
| variable = (SingleVariableDeclaration) params.get(0); |
| type = variable.getType(); |
| assertTrue(type.isNameQualifiedType()); |
| nameQualifiedType = (NameQualifiedType) type; |
| checkSourceRange(nameQualifiedType, "Y.@A ZZ", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979 |
| */ |
| public void testBug418979_002() throws JavaModelException { |
| String contents = |
| "package test;\n" + |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " test.@A Outer<C>.@A Inner<C> i;\n" + |
| " }\n" + |
| "class Outer<T> {\n" + |
| " class Inner<S> {}\n" + |
| "}\n" + |
| "class C {}\n" + |
| "@Target (ElementType.TYPE_USE)\n" + |
| "@interface A{}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| FieldDeclaration field = ((TypeDeclaration) node).getFields()[0]; |
| checkSourceRange(field, "test.@A Outer<C>.@A Inner<C> i;", contents); |
| ParameterizedType parameterizedType = (ParameterizedType) field.getType(); |
| checkSourceRange(parameterizedType, "test.@A Outer<C>.@A Inner<C>", contents); |
| QualifiedType qualifiedType = (QualifiedType) parameterizedType.getType(); |
| checkSourceRange(qualifiedType, "test.@A Outer<C>.@A Inner", contents); |
| parameterizedType = (ParameterizedType) qualifiedType.getQualifier(); |
| checkSourceRange(parameterizedType, "test.@A Outer<C>", contents); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) parameterizedType.getType(); |
| checkSourceRange(nameQualifiedType, "test.@A Outer", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979 |
| */ |
| public void testBug418979_003() throws JavaModelException { |
| String contents = |
| "package test;\n" + |
| "import java.lang.annotation.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " new java.util.@A HashMap<>();\n" + |
| " }\n" + |
| " }\n" + |
| "@Target (ElementType.TYPE_USE)\n" + |
| "@interface A{}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = ((TypeDeclaration) node).getMethods()[0]; |
| ExpressionStatement statement = (ExpressionStatement) method.getBody().statements().get(0); |
| ClassInstanceCreation instance = (ClassInstanceCreation) statement.getExpression(); |
| ParameterizedType parameterizedType = (ParameterizedType) instance.getType(); |
| checkSourceRange(parameterizedType, "java.util.@A HashMap<>", contents); |
| NameQualifiedType nameQualifiedType = (NameQualifiedType) parameterizedType.getType(); |
| checkSourceRange(nameQualifiedType, "java.util.@A HashMap", contents); |
| checkSourceRange(nameQualifiedType.getQualifier(), "java.util", contents); |
| checkSourceRange(nameQualifiedType.getName(), "HashMap", contents); |
| checkSourceRange((ASTNode) nameQualifiedType.annotations().get(0), "@A", contents); |
| } |
| /* |
| * [1.8][dom ast] variable binding for LambdaExpression parameter has non-unique key (https://bugs.eclipse.org/bugs/show_bug.cgi?id=416559) |
| */ |
| public void test416559() throws JavaModelException { |
| String contents = |
| "interface I {\n" + |
| " int f (int x);\n" + |
| "}\n" + |
| "\n" + |
| "class X {\n" + |
| " I i1 = (x) -> 1;\n" + |
| " I i2 = (x) -> 1;\n" + |
| "}\n" ; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 1); |
| FieldDeclaration[] field = ((TypeDeclaration) node).getFields(); |
| |
| List fragments = field[0].fragments(); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0); |
| Expression expression = fragment.getInitializer(); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| IVariableBinding variableBinding = variableDeclaration.resolveBinding(); |
| IMethodBinding methodBinding = lambdaExpression.resolveMethodBinding(); |
| String methodKey = ((IBinding) methodBinding).getKey(); |
| String variableKey = ((IBinding) variableBinding).getKey(); |
| assertTrue(variableKey.regionMatches(0, methodKey, 0, methodKey.length())); |
| |
| fragments = field[1].fragments(); |
| fragment = (VariableDeclarationFragment)fragments.get(0); |
| expression = fragment.getInitializer(); |
| lambdaExpression = (LambdaExpression)expression; |
| variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| variableBinding = variableDeclaration.resolveBinding(); |
| |
| assertNotSame(variableKey.intern(), ((IBinding) variableBinding).getKey().intern()); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420458 |
| */ |
| public void testBug420458() throws JavaModelException { |
| String contents = |
| "/**\n" + |
| " * Hello\n" + |
| " * @see #foo(Object[][][])\n" + |
| " **/\n" + |
| "public class X {}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| Javadoc javaDoc = ((TypeDeclaration) node).getJavadoc(); |
| TagElement tagElement = (TagElement) javaDoc.tags().get(1); |
| MethodRef methodRef = (MethodRef) tagElement.fragments().get(0); |
| MethodRefParameter parameter = (MethodRefParameter) methodRef.parameters().get(0); |
| ArrayType arrayType = (ArrayType) parameter.getType(); |
| checkSourceRange(arrayType, "Object[][][]", contents); |
| checkSourceRange(arrayType.getElementType(), "Object", contents); |
| assertTrue(arrayType.getDimensions() == 3); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420458 |
| */ |
| public void testBug425741() throws JavaModelException { |
| String contents = |
| "@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + |
| "@interface Annot { String value(); }\n" + |
| "@Annot(\"decl\") public class X {\n" + |
| " @Annot(\"field\") X x = null;\n" + |
| " public void foo(@Annot(\"param\") X i) {\n" + |
| " }\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 1); |
| assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType()); |
| FieldDeclaration field = ((TypeDeclaration) node).getFields()[0]; |
| List fragments = field.fragments(); |
| ITypeBinding typeBinding = field.getType().resolveBinding(); |
| IAnnotationBinding[] annots = typeBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 1, annots.length); |
| assertEquals("Incorrect annotation", "@Annot(value = field)", annots[0].toString()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| typeBinding = typeBinding.getTypeDeclaration(); |
| annots = typeBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 0, annots.length); |
| typeBinding = fragment.resolveBinding().getType().getTypeDeclaration(); |
| annots = typeBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 0, annots.length); |
| MethodDeclaration method = ((TypeDeclaration) node).getMethods()[0]; |
| SingleVariableDeclaration param = (SingleVariableDeclaration) method.parameters().get(0); |
| typeBinding = param.getType().resolveBinding(); |
| annots = typeBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 1, annots.length); |
| assertEquals("Incorrect annotation", "@Annot(value = param)", annots[0].toString()); |
| typeBinding = typeBinding.getTypeDeclaration(); |
| annots = typeBinding.getTypeAnnotations(); |
| assertEquals("Incorrect type annotations", 0, annots.length); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation |
| */ |
| public void testBug416560_001() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "@Target (ElementType.FIELD)\n" + |
| "public class X{\n" + |
| " public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" + |
| "}\n" + |
| "public class X\n" + |
| " public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" + |
| "interface FI {\n" + |
| " int foo(int s1, int s2);\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| this.workingCopy.getBuffer().setContents(contents); |
| CompilationUnit compilationUnit = this.workingCopy.reconcile(AST.JLS8, ICompilationUnit.FORCE_PROBLEM_DETECTION, null, null); |
| ASTNode node = getASTNode(compilationUnit, 0); |
| FieldDeclaration[] field = ((TypeDeclaration) node).getFields(); |
| List fragments = field[0].fragments(); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0); |
| Expression expression = fragment.getInitializer(); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| checkSourceRange(variableDeclaration, "int n1", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation |
| */ |
| public void testBug416560_002() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.ElementType;\n" + |
| "@Target (ElementType.FIELD)\n" + |
| "public class X{\n" + |
| " public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" + |
| "}\n" + |
| "public class X\n" + |
| " public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" + |
| "interface FI {\n" + |
| " int foo(int s1, int s2);\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| FieldDeclaration[] field = ((TypeDeclaration) node).getFields(); |
| List fragments = field[0].fragments(); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0); |
| Expression expression = fragment.getInitializer(); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| checkSourceRange(variableDeclaration, "int n1", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation |
| */ |
| public void testBug416560_003() throws JavaModelException { |
| String contents = |
| "public class X{\n" + |
| " void f() {\n" + |
| " //a\n" + |
| " //few\n" + |
| " //comments\n" + |
| " //here\n" + |
| " bar((int x) -> 91);\n" + |
| " }\n" + |
| " int bar(FI f){ return 1;}" + |
| "}\n" + |
| "interface FI {\n" + |
| " int foo(int s1);\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, true); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods(); |
| MethodDeclaration method = methods[0]; |
| Block block = method.getBody(); |
| List statements = block.statements(); |
| Statement statement = (Statement) statements.get(0); |
| MethodInvocation methodInvocation = (MethodInvocation) ((ExpressionStatement) statement).getExpression(); |
| LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0); |
| VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0); |
| checkSourceRange(variableDeclaration, "int x", contents); |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=425743, [1.8][api] CompilationUnit#findDeclaringNode(IBinding binding) returns null for type inferred lambda parameter |
| */ |
| public void testBug425743() throws JavaModelException { |
| String contents = |
| "public class X{\n" + |
| " FI fi = (x2) -> x2;\n" + |
| "}\n" + |
| "interface FI {\n" + |
| " int foo(int n);\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/); |
| ASTNode node = buildAST(contents, this.workingCopy, true); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| node = getASTNode(compilationUnit, 0); |
| FieldDeclaration fi = ((TypeDeclaration) node).getFields()[0]; |
| VariableDeclarationFragment vdf = (VariableDeclarationFragment) fi.fragments().get(0); |
| LambdaExpression lambda = (LambdaExpression) vdf.getInitializer(); |
| VariableDeclaration param = (VariableDeclaration) lambda.parameters().get(0); |
| IBinding binding = param.getName().resolveBinding(); |
| ASTNode astNode = compilationUnit.findDeclaringNode(binding); |
| assertNotNull(astNode); |
| assertEquals("Not a variable declaration fragment", ASTNode.VARIABLE_DECLARATION_FRAGMENT, astNode.getNodeType()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=427357 |
| public void testBug427357() throws JavaModelException { |
| String contents = |
| "public class X {\n" + |
| " public static void foo(X this, int i){}\n" + |
| " public void foo(Inner this){}\n" + |
| " I I = new I() {\n" + |
| " public void bar(I this, int i) {}\n" + |
| " };\n" + |
| " static class Inner {\n" + |
| " public Inner(Test2 Test2.this){}\n" + |
| " public Inner(Inner Inner.this, int i){}\n" + |
| " }\n" + |
| "}\n"+ |
| "interface I {}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy, false); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration typeDecl = (TypeDeclaration) unit.types().get(0); |
| MethodDeclaration method = (MethodDeclaration) typeDecl.bodyDeclarations().get(0); |
| Type receiver = method.getReceiverType(); |
| assertNotNull("Receiver should not be null", receiver); |
| assertEquals("Incorrect receiver type", "X", receiver.toString()); |
| |
| method = (MethodDeclaration) typeDecl.bodyDeclarations().get(1); |
| receiver = method.getReceiverType(); |
| assertNotNull("Receiver should not be null", receiver); |
| |
| FieldDeclaration field = (FieldDeclaration) typeDecl.bodyDeclarations().get(2); |
| ClassInstanceCreation anonymousInst = (ClassInstanceCreation ) ((VariableDeclarationFragment) field.fragments().get(0)).getInitializer(); |
| AnonymousClassDeclaration anonymousDecl = anonymousInst.getAnonymousClassDeclaration(); |
| method = (MethodDeclaration) anonymousDecl.bodyDeclarations().get(0); |
| receiver = method.getReceiverType(); |
| assertNotNull("Receiver should not be null", receiver); |
| assertEquals("Incorrect receiver type", "I", receiver.toString()); |
| typeDecl = (TypeDeclaration) typeDecl.bodyDeclarations().get(3); |
| method = (MethodDeclaration) typeDecl.bodyDeclarations().get(0); |
| receiver = method.getReceiverType(); |
| assertNotNull("Receiver should not be null", receiver); |
| assertEquals("Incorrect receiver type", "Test2", receiver.toString()); |
| method = (MethodDeclaration) typeDecl.bodyDeclarations().get(1); |
| receiver = method.getReceiverType(); |
| assertNotNull("Receiver should not be null", receiver); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=426459 |
| public void testBug426459() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "@Target(ElementType.TYPE_USE) @interface A {}\n" + |
| "@Target(ElementType.TYPE_USE) @interface B {}\n" + |
| "@Target(ElementType.TYPE_USE) @interface C {}\n" + |
| "public class X {\n" + |
| " @A int @B [] @C [] @A [] is;\n" + |
| " @C String @A [] @B [] @C [] ss;\n" + |
| " @C String @A [] [] [] [] sss;\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| node = getASTNode(compilationUnit, 3, 0); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| FieldDeclaration field = (FieldDeclaration) node; |
| Type type = field.getType(); |
| ITypeBinding original = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@A int @B [] @C [] @A []", original.toString()); |
| ITypeBinding binding = original.createArrayType(1); |
| assertEquals("Incorrect type binding", "@A int [] @B [] @C [] @A []", binding.toString()); |
| int dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 4, dims); |
| IAnnotationBinding[] annotations = binding.getTypeAnnotations(); |
| assertEquals("Incorrect no of type annotations", 0, annotations.length); |
| binding = binding.getComponentType(); |
| annotations = binding.getTypeAnnotations(); |
| assertEquals("Incorrect no of type annotations", 1, annotations.length); |
| assertEquals("Incorrect annotation", "@B()", annotations[0].toString()); |
| binding = binding.getComponentType(); |
| annotations = binding.getTypeAnnotations(); |
| assertEquals("Incorrect no of type annotations", 1, annotations.length); |
| assertEquals("Incorrect annotation", "@C()", annotations[0].toString()); |
| binding = binding.getComponentType(); |
| annotations = binding.getTypeAnnotations(); |
| assertEquals("Incorrect no of type annotations", 1, annotations.length); |
| assertEquals("Incorrect annotation", "@A()", annotations[0].toString()); |
| binding = binding.getElementType(); |
| annotations = binding.getTypeAnnotations(); |
| assertEquals("Incorrect no of type annotations", 1, annotations.length); |
| assertEquals("Incorrect annotation", "@A()", annotations[0].toString()); |
| |
| node = getASTNode(compilationUnit, 3, 1); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| field = (FieldDeclaration) node; |
| type = field.getType(); |
| original = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@C String @A [] @B [] @C []", original.toString()); |
| binding = original.createArrayType(1); |
| assertEquals("Incorrect type binding", "@C String [] @A [] @B [] @C []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 4, dims); |
| |
| binding = original.createArrayType(-1); |
| assertEquals("Incorrect type binding", "@C String @B [] @C []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 2, dims); |
| |
| binding = original.createArrayType(-2); |
| assertEquals("Incorrect type binding", "@C String @C []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 1, dims); |
| |
| node = getASTNode(compilationUnit, 3, 2); |
| assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION); |
| field = (FieldDeclaration) node; |
| type = field.getType(); |
| original = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@C String @A [] [] [] []", original.toString()); |
| binding = original.createArrayType(-1); |
| assertEquals("Incorrect type binding", "@C String [] [] []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 3, dims); |
| binding = binding.createArrayType(-2); |
| assertEquals("Incorrect type binding", "@C String []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 1, dims); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=426459 |
| public void testBug426459a() throws JavaModelException { |
| String contents = |
| "import java.lang.annotation.*;\n" + |
| "@Target(ElementType.TYPE_USE) @interface A {}\n" + |
| "@Target(ElementType.TYPE_USE) @interface B {}\n" + |
| "@Target(ElementType.TYPE_USE) @interface C {}\n" + |
| "public class X {\n" + |
| " public void foo() {}\n" + |
| " public @A X.@B Y foo(@C int i){ return null;}\n" + |
| " public @A @B X foo(int i, int j){ return null;}\n" + |
| " public @A X.Y [] @B [] foo(float f){ return null;}\n" + |
| " class Y {}\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| |
| node = getASTNode(compilationUnit, 3, 0); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| Type type = ((MethodDeclaration) node).getReturnType2(); |
| ITypeBinding binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| try { |
| binding = binding.createArrayType(1); |
| binding = null; |
| } catch(IllegalArgumentException iae) { |
| } |
| assertNotNull("IllegalArgumentException should have been thrown", binding); |
| |
| node = getASTNode(compilationUnit, 3, 1); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| type = ((MethodDeclaration) node).getReturnType2(); |
| binding = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@A X.@B Y", binding.toString()); |
| binding = binding.createArrayType(2); |
| assertEquals("Incorrect type binding", "@A X.@B Y [] []", binding.toString()); |
| int dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 2, dims); |
| SingleVariableDeclaration param = (SingleVariableDeclaration) ((MethodDeclaration) node).parameters().get(0); |
| type = param.getType(); |
| binding = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@C int", binding.toString()); |
| binding = binding.createArrayType(2); |
| assertEquals("Incorrect type binding", "@C int [] []", binding.toString()); |
| |
| node = getASTNode(compilationUnit, 3, 2); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| type = ((MethodDeclaration) node).getReturnType2(); |
| binding = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@A @B X", binding.toString()); |
| binding = binding.createArrayType(2); |
| assertEquals("Incorrect type binding", "@A @B X [] []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 2, dims); |
| |
| node = getASTNode(compilationUnit, 3, 3); |
| assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| type = ((MethodDeclaration) node).getReturnType2(); |
| ITypeBinding original = type.resolveBinding(); |
| assertEquals("Incorrect type binding", "@A X.Y [] @B []", original.toString()); |
| binding = original.createArrayType(1); |
| assertEquals("Incorrect type binding", "@A X.Y [] [] @B []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 3, dims); |
| |
| binding = original.createArrayType(-1); |
| assertEquals("Incorrect type binding", "@A X.Y @B []", binding.toString()); |
| dims = binding.getDimensions(); |
| assertEquals("Incorrect no of dimensions", 1, dims); |
| |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526, [1.8] API to get the single abstract method in a functional interface |
| public void test428526() throws JavaModelException { |
| String contents = |
| "interface Foo<T, N extends Number> {\n" + |
| " void m(T arg);\n" + |
| " void m(N arg);\n" + |
| "}\n" + |
| "interface Baz extends Foo<Integer, Integer> {}\n"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| |
| TypeDeclaration type = (TypeDeclaration) getASTNode(compilationUnit, 0); |
| assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType()); |
| ITypeBinding binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| IMethodBinding functionalInterfaceMethod = binding.getFunctionalInterfaceMethod(); |
| assertNull("Should not be a functional interface", functionalInterfaceMethod); |
| |
| type = (TypeDeclaration) getASTNode(compilationUnit, 1); |
| assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType()); |
| binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| functionalInterfaceMethod = binding.getFunctionalInterfaceMethod(); |
| assertNotNull("Should be a functional interface", functionalInterfaceMethod); |
| ITypeBinding declaringClass = functionalInterfaceMethod.getDeclaringClass(); |
| assertEquals("Foo<Integer,Integer>", declaringClass.getName()); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526, [1.8] API to get the single abstract method in a functional interface |
| public void test428526a() throws JavaModelException { |
| String contents = |
| "interface I { X foo(); }\n" + |
| "interface J { Y foo(); }\n" + |
| "interface K extends I, J {}\n" + |
| "class X {}\n" + |
| "class Y extends X {}\n"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| |
| TypeDeclaration type = (TypeDeclaration) getASTNode(compilationUnit, 0); |
| assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType()); |
| ITypeBinding binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| IMethodBinding functionalInterfaceMethod = binding.getFunctionalInterfaceMethod(); |
| assertNotNull("Should not be a functional interface", functionalInterfaceMethod); |
| |
| type = (TypeDeclaration) getASTNode(compilationUnit, 1); |
| assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType()); |
| binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| functionalInterfaceMethod = binding.getFunctionalInterfaceMethod(); |
| assertNotNull("Should be a functional interface", functionalInterfaceMethod); |
| |
| type = (TypeDeclaration) getASTNode(compilationUnit, 2); |
| assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType()); |
| binding = type.resolveBinding(); |
| assertNotNull("Binding should not be null", binding); |
| functionalInterfaceMethod = binding.getFunctionalInterfaceMethod(); |
| assertNotNull("Should be a functional interface", functionalInterfaceMethod); |
| ITypeBinding returnType = functionalInterfaceMethod.getReturnType(); |
| assertEquals("Y", returnType.getName()); |
| } |
| |
| // round-trip for binding keys of CaptureBinding18: |
| public void testBug425183a() throws JavaModelException { |
| String contents = |
| "interface Comparator<T> {\n" + |
| " public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() { return null; }\n" + |
| "}\n" + |
| "public class Bug425183a {\n" + |
| " @SuppressWarnings(\"unchecked\")\n" + |
| " <T> void test() {\n" + |
| " Comparator<? super T> comparator = (Comparator<? super T>) Comparator.naturalOrder();\n" + |
| " System.out.println(\"OK\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " new Bug425183a().test();\n" + |
| " }\n" + |
| "}\n"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug425183a.java", true); |
| ASTNode node = buildAST(contents, this.workingCopy); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit compilationUnit = (CompilationUnit) node; |
| assertProblemsSize(compilationUnit, 0); |
| |
| String selection = "naturalOrder"; |
| int start = contents.lastIndexOf(selection); |
| int length = selection.length(); |
| |
| IJavaElement[] elements = this.workingCopy.codeSelect(start, length); |
| assertElementsEqual( |
| "Unexpected elements", |
| "naturalOrder() {key=LBug425183a~Comparator<>;.naturalOrder<T::Ljava/lang/Comparable<-TT;>;>()LComparator<TT;>;%<^{291#0};>} [in Comparator [in [Working copy] Bug425183a.java [in <default> [in src [in Converter18]]]]]", |
| elements, |
| true |
| ); |
| IMethod method = (IMethod)elements[0]; |
| String[] keys = new String[] { method.getKey() }; |
| BindingRequestor requestor = new BindingRequestor(); |
| resolveASTs(new ICompilationUnit[] { this.workingCopy } , keys, requestor, getJavaProject("Converter18"), null); |
| assertBindingsEqual( |
| keys[0], |
| requestor.getBindings(keys)); |
| |
| // assert that KeyToSignature doesn't throw AIOOBE, the result containing '!*' is a workaround for now, see https://bugs.eclipse.org/429264 |
| assertEquals("wrong signature", "<T::Ljava.lang.Comparable<-TT;>;>()LComparator<!*>;", new BindingKey(method.getKey()).toSignature()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=432051 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug432051() throws JavaModelException { |
| String contents = |
| "public class X {\n" + |
| " * Delete line '/**' above.\n" + |
| " *\n" + |
| " * @param a (for example 'QVector')\n" + |
| " * @param declaringMember the context for resolving (made in)\n" + |
| " * @return if\n" + |
| " */\n" + |
| " void foo() {\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test432051/X.java", contents, true/*computeProblems*/); |
| IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| class BindingRequestor extends ASTRequestor { |
| ITypeBinding _result = null; |
| public void acceptBinding(String bindingKey, IBinding binding) { |
| if (this._result == null && binding != null && binding.getKind() == IBinding.TYPE) |
| this._result = (ITypeBinding) binding; |
| } |
| } |
| final BindingRequestor requestor = new BindingRequestor(); |
| final ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setResolveBindings(false); |
| parser.setProject(javaProject); |
| try { |
| parser.createASTs(new ICompilationUnit[] {this.workingCopy}, new String[0], requestor, null); |
| } catch (IllegalArgumentException e) { |
| assertTrue("Test Failed", false); |
| } |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=426977 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug426977() throws JavaModelException { |
| String contents = |
| "package com.test.todo;\r\n"+ |
| "import java.lang.annotation.ElementType;\r\n"+ |
| "import java.lang.annotation.Target;\r\n"+ |
| "public class Test {\r\n"+ |
| " static void m() {}\r\n"+ |
| " new Runnable() {\r\n"+ |
| " public void run(R) {}\r\n"+ |
| " };\r\n"+ |
| "}\r\n"+ |
| "@Target(ElementType.TYPE_USE)\r\n"+ |
| "@interface TU { }"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/com/test/todo/Test.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| //Bug 406805 - [1.8] Parameter names for enum constructor not available |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=406805 |
| public void test406805() throws CoreException, IOException { |
| String contents1 = |
| "package test406805;\n" + |
| "public class X {\n" + |
| "}"; |
| createFolder("/Converter18/src/test406805"); |
| createFile("/Converter18/src/test406805/X.java", contents1); |
| this.workingCopy = getWorkingCopy( |
| "/Converter18/src/test406805/X.java", |
| contents1, |
| true |
| ); |
| |
| String jarName = "getParameters.jar"; |
| String srcName = "getParameters_src.zip"; |
| final IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| try { |
| String[] contents = new String[] { |
| "TestEnum.java", |
| "package test406805;\n" + |
| "public enum TestEnum {\n" + |
| " FirstValue(\"Zonk\") {\n" + |
| " @Override\n" + |
| " public String toString() {\n" + |
| " return super.toString();\n" + |
| " }\n" + |
| " },\n" + |
| " SecondValue(\"Bla\");\n" + |
| " String string;\n" + |
| " TestEnum(String string) {\n" + |
| " this.string = string;\n" + |
| " }\n" + |
| "}" |
| }; |
| addLibrary(javaProject, jarName, srcName, contents, JavaCore.VERSION_1_8); |
| |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setIgnoreMethodBodies(true); |
| parser.setProject(javaProject); |
| IType type = javaProject.findType("test406805.TestEnum"); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { type }, null); |
| ITypeBinding typeBinding = (ITypeBinding) bindings[0]; |
| IMethodBinding[] methods = typeBinding.getDeclaredMethods(); |
| |
| for (int i = 0, length = methods.length; i < length; i++) { |
| IMethodBinding method = methods[i]; |
| if (method.isConstructor()) { |
| ResolvedBinaryMethod bm = (ResolvedBinaryMethod) method.getJavaElement(); |
| assertTrue(bm.getParameterNames().length == 1); |
| assertEquals(bm.getParameterNames()[0], "string"); |
| assertEquals(bm.getParameterTypes()[0], "Ljava.lang.String;"); |
| } |
| } |
| } finally { |
| removeLibrary(javaProject, jarName, srcName); |
| } |
| } |
| |
| //Bug 406805 - [1.8] Parameter names for enum constructor not available |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=406805 |
| //Nested Enum Constructor |
| public void test406805a() throws CoreException, IOException { |
| String contents1 = |
| "package test406805;\n" + |
| "public class X {\n" + |
| "}"; |
| createFolder("/Converter18/src/test406805a"); |
| createFile("/Converter18/src/test406805a/X.java", contents1); |
| this.workingCopy = getWorkingCopy( |
| "/Converter18/src/test406805a/X.java", |
| contents1, |
| true |
| ); |
| |
| String jarName = "getParameters.jar"; |
| String srcName = "getParameters_src.zip"; |
| final IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| try { |
| String[] contents = new String[] { |
| "NestedTestEnum.java", |
| "package test406805a;\n" + |
| "public class NestedTestEnum {\n" + |
| " public enum TestEnum {\n" + |
| " FirstValue(\"Zonk\") {\n" + |
| " @Override\n" + |
| " public String toString() {\n" + |
| " return super.toString();\n" + |
| " }\n" + |
| " },\n" + |
| " SecondValue(\"Bla\");\n" + |
| " String string;\n" + |
| " TestEnum(String string) {\n" + |
| " this.string = string;\n" + |
| " }\n" + |
| "}\n" + |
| "}" |
| }; |
| addLibrary(javaProject, jarName, srcName, contents, JavaCore.VERSION_1_8, null); |
| |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setIgnoreMethodBodies(true); |
| parser.setProject(javaProject); |
| IType type = javaProject.findType("test406805a.NestedTestEnum"); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { type }, null); |
| ITypeBinding typeBinding = (ITypeBinding) bindings[0]; |
| |
| typeBinding = typeBinding.getDeclaredTypes()[0]; |
| IMethodBinding[] methods = typeBinding.getDeclaredMethods(); |
| |
| for (int i = 0, length = methods.length; i < length; i++) { |
| IMethodBinding method = methods[i]; |
| if (method.isConstructor()) { |
| ResolvedBinaryMethod bm = (ResolvedBinaryMethod) method.getJavaElement(); |
| assertTrue(bm.getParameterNames().length == 1); |
| } |
| } |
| } finally { |
| removeLibrary(javaProject, jarName, srcName); |
| } |
| } |
| |
| //Bug 406805 - [1.8] Parameter names for enum constructor not available |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=406805 |
| //Parameterized enum constructor. |
| public void test406805b() throws CoreException, IOException { |
| String contents1 = |
| "package test406805b;\n" + |
| "public class X {\n" + |
| "}"; |
| createFolder("/Converter18/src/test406805b"); |
| createFile("/Converter18/src/test406805b/X.java", contents1); |
| this.workingCopy = getWorkingCopy( |
| "/Converter18/src/test406805b/X.java", |
| contents1, |
| true |
| ); |
| |
| String jarName = "getParameters.jar"; |
| String srcName = "getParameters_src.zip"; |
| final IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| try { |
| String[] contents = new String[] { |
| "TestEnum.java", |
| "package test406805b;\n" + |
| "interface A<T> {}\n" + |
| "\n" + |
| "class Y {\n" + |
| " static A<String> A1;\n" + |
| "}\n" + |
| "public enum TestEnum implements A<String> {\n" + |
| " FirstValue(Y.A1);\n" + |
| " A<String> xyzabcdef;\n" + |
| " TestEnum(A<String> abcdefghi) {\n" + |
| " this.xyzabcdef = abcdefghi;\n" + |
| " }\n" + |
| " int SecondValue() { return 0;}\n" + |
| "}\n" |
| }; |
| addLibrary(javaProject, jarName, srcName, contents, JavaCore.VERSION_1_8); |
| |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setIgnoreMethodBodies(true); |
| parser.setProject(javaProject); |
| IType type = javaProject.findType("test406805b.TestEnum"); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { type }, null); |
| ITypeBinding typeBinding = (ITypeBinding) bindings[0]; |
| IMethodBinding[] methods = typeBinding.getDeclaredMethods(); |
| |
| for (int i = 0, length = methods.length; i < length; i++) { |
| IMethodBinding method = methods[i]; |
| if (method.isConstructor()) { |
| ResolvedBinaryMethod bm = (ResolvedBinaryMethod) method.getJavaElement(); |
| assertTrue(bm.getParameterNames().length == 1); |
| } |
| } |
| } finally { |
| removeLibrary(javaProject, jarName, srcName); |
| } |
| } |
| //Bug 406805 - [1.8] Parameter names for enum constructor not available |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=406805 |
| //Testing types and names of parameters. |
| public void test406805d() throws CoreException, IOException { |
| String contents1 = |
| "package test406805;\n" + |
| "public class X {\n" + |
| "}"; |
| createFolder("/Converter18/src/test406805d"); |
| createFile("/Converter18/src/test406805d/X.java", contents1); |
| this.workingCopy = getWorkingCopy( |
| "/Converter18/src/test406805d/X.java", |
| contents1, |
| true |
| ); |
| |
| String jarName = "getParameters.jar"; |
| String srcName = "getParameters_src.zip"; |
| final IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| try { |
| String[] contents = new String[] { |
| "NestedTestEnum.java", |
| "package test406805d;\n" + |
| "public class NestedTestEnum {\n" + |
| " public enum TestEnum {\n" + |
| " FirstValue(\"Zonk\", 1) {\n" + |
| " @Override\n" + |
| " public String toString() {\n" + |
| " return super.toString();\n" + |
| " }\n" + |
| " },\n" + |
| " SecondValue(\"Bla\", 2);\n" + |
| " String string;\n" + |
| " int xyz;\n" + |
| " TestEnum(String string, int xyz) {\n" + |
| " this.string = string;\n" + |
| " this.xyz = xyz;\n" + |
| " }\n" + |
| "}\n" + |
| "}" |
| }; |
| addLibrary(javaProject, jarName, srcName, contents, JavaCore.VERSION_1_8, null); |
| |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setIgnoreMethodBodies(true); |
| parser.setProject(javaProject); |
| IType type = javaProject.findType("test406805d.NestedTestEnum"); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { type }, null); |
| ITypeBinding typeBinding = (ITypeBinding) bindings[0]; |
| |
| typeBinding = typeBinding.getDeclaredTypes()[0]; |
| IMethodBinding[] methods = typeBinding.getDeclaredMethods(); |
| |
| for (int i = 0, length = methods.length; i < length; i++) { |
| IMethodBinding method = methods[i]; |
| if (method.isConstructor()) { |
| ResolvedBinaryMethod bm = (ResolvedBinaryMethod) method.getJavaElement(); |
| String[] parameterNames = bm.getParameterNames(); |
| assertTrue(parameterNames.length == 2); |
| assertEquals(parameterNames[0], "string"); |
| assertEquals(parameterNames[1], "xyz"); |
| String[] parameterTypes = bm.getParameterTypes(); |
| assertEquals(parameterTypes[0], "Ljava.lang.String;"); |
| assertEquals(parameterTypes[1], "I"); |
| } |
| } |
| } finally { |
| removeLibrary(javaProject, jarName, srcName); |
| } |
| } |
| |
| //Bug 436347 - Regression: NegativeArraySizeException at org.eclipse.jdt.internal.core.ClassFileInfo.generateMethodInfos |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=436347 |
| //Enum constructor with no parameters. |
| public void test436347() throws CoreException, IOException { |
| String contents1 = |
| "package test436347;\n" + |
| "public class X {\n" + |
| "}"; |
| createFolder("/Converter18/src/test436347"); |
| createFile("/Converter18/src/test436347/X.java", contents1); |
| this.workingCopy = getWorkingCopy( |
| "/Converter18/src/test436347/X.java", |
| contents1, |
| true |
| ); |
| |
| String jarName = "getParameters.jar"; |
| String srcName = "getParameters_src.zip"; |
| final IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| try { |
| String[] contents = new String[] { |
| "TestEnum.java", |
| "package test436347;\n" + |
| "public enum TestEnum {\n" + |
| " FirstValue() {\n" + |
| " @Override\n" + |
| " public String toString() {\n" + |
| " return super.toString();\n" + |
| " }\n" + |
| " },\n" + |
| " SecondValue();\n" + |
| " TestEnum() {\n" + |
| " return;\n" + |
| " }\n" + |
| "}" |
| }; |
| addLibrary(javaProject, jarName, srcName, contents, JavaCore.VERSION_1_8); |
| |
| ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setIgnoreMethodBodies(true); |
| parser.setProject(javaProject); |
| IType type = javaProject.findType("test436347.TestEnum"); |
| IBinding[] bindings = parser.createBindings(new IJavaElement[] { type }, null); |
| ITypeBinding typeBinding = (ITypeBinding) bindings[0]; |
| IMethodBinding[] methods = typeBinding.getDeclaredMethods(); |
| |
| for (int i = 0, length = methods.length; i < length; i++) { |
| IMethodBinding method = methods[i]; |
| if (method.isConstructor()) { |
| ResolvedBinaryMethod bm = (ResolvedBinaryMethod) method.getJavaElement(); |
| assertTrue(bm.getParameterNames().length == 0); |
| assertTrue(bm.getParameterTypes().length == 0); |
| } |
| } |
| } finally { |
| removeLibrary(javaProject, jarName, srcName); |
| } |
| } |
| |
| |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=433879, org.eclipse.jdt.internal.compiler.lookup.ArrayBinding cannot be cast to org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding |
| //@throws ClassCastException without the fix |
| //Array type access in catch block. Test case picked up from the bug. |
| public void testBug433879() throws JavaModelException { |
| String contents = |
| "package Bug433879;\r\n"+ |
| "public class X {\n" + |
| "Class<? extends Exception>[] exceptions;\n" + |
| " void foo() {\n" + |
| " try {\n" + |
| " // some stuff here\n" + |
| " } catch (exceptions[0] e) {\n" + |
| " // some more stuff here\n" + |
| " }\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug433879/X.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=433879, org.eclipse.jdt.internal.compiler.lookup.ArrayBinding cannot be cast to org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding |
| //@throws ClassCastException without the fix |
| //Simplified version of the test case picked up from the bug report. |
| public void testBug433879a() throws JavaModelException { |
| String contents = |
| "package Bug433879a;\n"+ |
| "public class X {\n" + |
| " void foo() {\n" + |
| " try {\n" + |
| " // some stuff here\n" + |
| " } catch (A[0] e) {\n" + |
| " // some more stuff here\n" + |
| " }\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug433879a/X.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=433879, org.eclipse.jdt.internal.compiler.lookup.ArrayBinding cannot be cast to org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding |
| //Catch parameters Union Type |
| public void testBug433879b() throws JavaModelException { |
| String contents = |
| "package Bug433879c;\n"+ |
| "public class X {\n" + |
| " void foo() {\n" + |
| " try {\n" + |
| " // some stuff here\n" + |
| " } catch (A[0] | B[0] e) {\n" + |
| " // some more stuff here\n" + |
| " }\n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug433879c/X.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=433879, org.eclipse.jdt.internal.compiler.lookup.ArrayBinding cannot be cast to org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding |
| //@throws ClassCastException without the fix |
| //Catch parameters union type. Multiple Catch handlers. |
| public void testBug433879c() throws JavaModelException { |
| String contents = |
| "package Bug433879d;\n"+ |
| "class E1 extends Exception {private static final long serialVersionUID = 1L;}\n" + |
| "class E2 extends Exception { private static final long serialVersionUID = 1L;}\n" + |
| "\n" + |
| "\n" + |
| "public class X {\n" + |
| " Class<? extends Exception>[] exceptions;\n" + |
| " void foo() {\n" + |
| " try {\n" + |
| " bar();\n" + |
| " } catch (exceptions[0] e) {\n" + |
| " } catch (E1 | E2 eU) {}\n" + |
| " }\n" + |
| " private void bar() throws E1, E2 {}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug433879d/X.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=433879, org.eclipse.jdt.internal.compiler.lookup.ArrayBinding cannot be cast to org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding |
| //@throws ClassCastException without the fix |
| //Multiple Catch handlers. |
| public void testBug433879d() throws JavaModelException { |
| String contents = |
| "package Bug433879e;\n"+ |
| "class E1 extends Exception {private static final long serialVersionUID = 1L;}\n" + |
| "class E2 extends Exception { private static final long serialVersionUID = 1L;}\n" + |
| "public class X {\n" + |
| " Class<? extends Exception>[] exceptions;\n" + |
| " Class<? extends Exception>[] exceptions2;\n" + |
| " void foo() {\n" + |
| " try {\n" + |
| " bar();\n" + |
| " } catch (E2 e2) {\n" + |
| " } catch (exceptions[0] e) {\n" + |
| " } catch (E1 e1) {\n" + |
| " } catch (exceptions2[0] e) {\n" + |
| " }\n" + |
| " }\n" + |
| " private void bar() throws E1, E2 {}\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/Bug433879e/X.java", true/*computeProblems*/); |
| try { |
| buildAST(AST.JLS8, contents, this.workingCopy, false, true, true); |
| } catch (ClassCastException e) { |
| fail(e.getMessage()); |
| } |
| } |
| public void testBug432175() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/testBug432175/X.java", |
| true/* resolve */); |
| String contents = "package testBug432175;\n" + |
| "interface Collection <T> {}\n" + |
| "class Collections {\n" + |
| " public static final <T> T emptyList() { return null; }\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public static <T extends Number & Comparable<?>> void method2(Collection<T> coll) {}\n" + |
| "\n" + |
| " public static void main(String[] args) {\n" + |
| " method2(Collections.emptyList());\n" + |
| " }\n" + |
| "}\n" ; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 2); |
| MethodDeclaration [] methods = typeDeclaration.getMethods(); |
| |
| { |
| MethodDeclaration method = methods[1]; |
| ExpressionStatement expressionStatement = (ExpressionStatement) method.getBody().statements().get(0); |
| MethodInvocation methodInvocation = (MethodInvocation) expressionStatement.getExpression(); |
| methodInvocation = (MethodInvocation) methodInvocation.arguments().get(0); |
| ITypeBinding typeBinding = methodInvocation.resolveTypeBinding(); |
| typeBinding = typeBinding.getTypeArguments()[0]; |
| String res = typeBinding.getTypeDeclaration().getName(); |
| this.ast.newSimpleType(this.ast.newName(res)); |
| } |
| } |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=435348, [1.8][compiler] NPE in JDT Core during AST creation |
| // NPE without fix |
| public void testBug435348() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/testBug435348/X.java", |
| true/* resolve */); |
| String contents = "package testBug435348;\n" + |
| "class Y {}\n" + |
| "class Z{}\n" + |
| "class X {\n" + |
| " void bar2(@ Z z) {}\n" + |
| " // ^ Illegal @ \n" + |
| " static {\n" + |
| " bar(new Y() {});\n" + |
| " }\n" + |
| "}\n"; |
| buildAST(contents, this.workingCopy, false); |
| } |
| |
| public void testBug432614() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/testBug432614/X.java", true); |
| String contents = "package testBug432614;\n" + |
| "import java.lang.annotation.ElementType;\n" + |
| "import java.lang.annotation.Target;\n" + |
| "public class X {\n" + |
| " FI fi1= (@T2 int i) -> {};\n" + |
| "}\n" + |
| "interface FI {\n" + |
| " void foo(@T1 int iii);\n" + |
| "}\n" + |
| "@Target(ElementType.TYPE_USE) @interface T1 {}\n" + |
| "@Target(ElementType.TYPE_USE) @interface T2 {}"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| assertEquals("(@T2 int i) -> {\n}\n", lambdaExpression.toString()); |
| assertTrue(lambdaExpression.parameters().size() == 1); |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| ITypeBinding[] params = binding.getParameterTypes(); |
| assertEquals("Incorrect no of parameters", 1, params.length); |
| ITypeBinding thatParam = params[0]; |
| assertEquals("Incorrect param", "@T2 int", thatParam.toString()); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=447062 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug447062() throws JavaModelException { |
| String contents = |
| "public class X {\n" + |
| " Runnable foo = () -> {\n" + |
| " \n" + |
| " }\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test447062/X.java", contents, true/*computeProblems*/); |
| IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| class BindingRequestor extends ASTRequestor { |
| ITypeBinding _result = null; |
| public void acceptBinding(String bindingKey, IBinding binding) { |
| if (this._result == null && binding != null && binding.getKind() == IBinding.TYPE) |
| this._result = (ITypeBinding) binding; |
| } |
| } |
| final BindingRequestor requestor = new BindingRequestor(); |
| final ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setResolveBindings(false); |
| parser.setProject(javaProject); |
| parser.setIgnoreMethodBodies(true); |
| try { |
| parser.createASTs(new ICompilationUnit[] {this.workingCopy}, new String[0], requestor, null); |
| } catch (IllegalArgumentException e) { |
| assertTrue("Test Failed", false); |
| } |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug425601_001() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/testBug425601_001/Outer.java", |
| true/* resolve */); |
| String contents = "package testBug425601_001;\n" + |
| "@Deprecated\n"+ |
| "public class Outer<O> {\n"+ |
| " @Deprecated\n"+ |
| " public class Middle<X> {\n"+ |
| " @Deprecated\n"+ |
| " public class Inner<E> {\n"+ |
| " }\n"+ |
| " }\n"+ |
| " \n"+ |
| " Outer<String> o;\n"+ |
| " Middle<String> m; // Middle should be deprecated - Middle Case one\n"+ |
| " Outer<String>.Middle<String> m2; // Middle should be deprecated - Middle Case Two \n"+ |
| " @SuppressWarnings(\"rawtypes\")"+ |
| " Outer.Middle m3; \n"+ |
| " Middle<String>.Inner<Object> i; // Inner should be deprecated - Inner Case One\n"+ |
| "}\n"+ |
| "class Ref {\n"+ |
| " Outer<String> o;\n"+ |
| " Outer<String>.Middle<String> m;\n"+ |
| " Outer<String>.Middle<String>.Inner<Object> i;\n"+ |
| "}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| FieldDeclaration[] fields = typedeclaration.getFields(); |
| ITypeBinding binding = fields[0].getType().resolveBinding(); |
| assertTrue(binding.isDeprecated()); |
| binding = fields[3].getType().resolveBinding(); |
| assertTrue(binding.isDeprecated()); |
| binding = fields[1].getType().resolveBinding(); // Middle Case One |
| assertTrue(binding.isDeprecated()); |
| binding = fields[2].getType().resolveBinding(); // Middle Case Two |
| assertTrue(binding.isDeprecated()); |
| binding = fields[4].getType().resolveBinding(); // Inner Case One |
| assertTrue(binding.isDeprecated()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug425601_002() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/testBug425601_002/Outer.java", |
| true/* resolve */); |
| String contents = "package testBug425601_002;\n" + |
| //"@Deprecated\n"+ |
| "public class Outer<O> {\n"+ |
| " @Deprecated\n"+ |
| " public class Middle<X> {\n"+ |
| " @Deprecated\n"+ |
| " public class Inner<E> {\n"+ |
| " }\n"+ |
| " }\n"+ |
| " \n"+ |
| " Outer<String> o;\n"+ |
| " Middle<String> m; // Middle should be deprecated - Middle Case one\n"+ |
| " Outer<String>.Middle<String> m2; // Middle should be deprecated - Middle Case Two \n"+ |
| " @SuppressWarnings(\"rawtypes\")"+ |
| " Outer.Middle m3; \n"+ |
| " Middle<String>.Inner<Object> i; // Inner should be deprecated - Inner Case One\n"+ |
| "}\n"+ |
| "class Ref {\n"+ |
| " Outer<String> o;\n"+ |
| " Outer<String>.Middle<String> m;\n"+ |
| " Outer<String>.Middle<String>.Inner<Object> i;\n"+ |
| "}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| FieldDeclaration[] fields = typedeclaration.getFields(); |
| ITypeBinding binding = fields[0].getType().resolveBinding(); |
| assertTrue(!binding.isDeprecated()); |
| binding = fields[3].getType().resolveBinding(); |
| assertTrue(binding.isDeprecated()); |
| binding = fields[1].getType().resolveBinding(); // Middle Case One |
| assertTrue(binding.isDeprecated()); |
| binding = fields[2].getType().resolveBinding(); // Middle Case Two |
| assertTrue(binding.isDeprecated()); |
| binding = fields[4].getType().resolveBinding(); // Inner Case One |
| assertTrue(binding.isDeprecated()); |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=44000 |
| * |
| * @bug Bug 440000 [1.8][dom] MethodReference#resolveMethodBinding() API should return null for CreationReference of an ArrayType |
| * @throws JavaModelException |
| */ |
| public void testBug440000_001() throws JavaModelException { |
| String contents = |
| "interface I<T, R> {\n" + |
| " R apply(T t);\n" + |
| "}\n" + |
| "public class X {\n" + |
| " I<Integer, int[]> m1 = int[]::new;\n" + |
| "}\n"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", contents, true/*computeProblems*/); |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof CreationReference); |
| CreationReference creationReference = (CreationReference) expression; |
| assertEquals("int[]::new", creationReference.toString()); |
| IMethodBinding binding = creationReference.resolveMethodBinding(); |
| assertNull(binding); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=459344 |
| * |
| * @throws JavaModelException |
| */ |
| public void testBug459344_001() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test459344/X.java", |
| true/* resolve */); |
| String contents = "package test459344;" + |
| "interface I {\n" + |
| " int foo();\n" + |
| "}\n" + |
| "public class X {\n" + |
| " private void foo(Object arg) {\n" + |
| " I i = arg :: hashCode;\n" + |
| " }\n" + |
| "}\n"; |
| |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| MethodDeclaration methodDeclaration = typeDeclaration.getMethods()[0]; |
| VariableDeclarationStatement stmt = (VariableDeclarationStatement) methodDeclaration.getBody().statements().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) stmt.fragments().get(0); |
| ExpressionMethodReference reference = (ExpressionMethodReference) fragment.getInitializer(); |
| IMethodBinding methodBinding = reference.resolveMethodBinding(); |
| assertNotNull(methodBinding); |
| assertEquals("Wrong name", "hashCode", methodBinding.getName()); |
| assertNull("Non-Null",cu.findDeclaringNode(methodBinding)); |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=460186 |
| * @bug Bug 460186 IAE in ASTNode.setSourceRange with broken code case 2 |
| * @throws JavaModelException |
| */ |
| public void testBug460186() throws JavaModelException { |
| String contents = |
| "class Foo {\n" + |
| " void foo()\n {" + |
| " foo();[]\n" + |
| " }\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test460186/NPE.java", contents, false/*computeProblems*/); |
| IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| |
| final ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setResolveBindings(false); |
| parser.setProject(javaProject); |
| parser.setIgnoreMethodBodies(false); |
| ASTRequestor requestor = new ASTRequestor() {}; |
| parser.createASTs(new ICompilationUnit[] {this.workingCopy}, new String[0], requestor, null); |
| // Implicitly check that no exception is thrown by createASTs. |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=443232 |
| * @bug Bug 443232 IAE in ASTNode.setSourceRange with broken code |
| * @throws JavaModelException |
| */ |
| public void testBug443232() throws JavaModelException { |
| String contents = |
| "package test443232;\n" + |
| "public class E21 {\n" + |
| " {private int[] nums;\n" + |
| " void foo() {\n" + |
| " nums\n" + |
| " }\n" + |
| "}"; |
| this.workingCopy = getWorkingCopy("/Converter18/src/test443232/E21.java", contents, false/*computeProblems*/); |
| IJavaProject javaProject = this.workingCopy.getJavaProject(); |
| |
| final ASTParser parser = ASTParser.newParser(AST.JLS8); |
| parser.setResolveBindings(false); |
| parser.setProject(javaProject); |
| parser.setIgnoreMethodBodies(false); |
| ASTRequestor requestor = new ASTRequestor() {}; |
| try { |
| parser.createASTs(new ICompilationUnit[] {this.workingCopy}, new String[0], requestor, null); |
| } catch (IllegalArgumentException e) { |
| assertTrue("Test Failed", false); |
| } |
| } |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=429813 |
| * |
| * @throws JavaModelException |
| */ |
| public void test429813() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test429813/Snippet.java", |
| true/* resolve */); |
| String contents = "package test429813;" |
| + "public class Snippet {\n" |
| + " Function<Integer, int[]> m1L = n -> new int[n];\n" |
| + "}" |
| + "interface Function<T, R> {\n" |
| + " public R apply(T t);\n" |
| + "}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| IJavaElement element = binding.getJavaElement(); |
| assertEquals("Not a method", IJavaElement.METHOD, element.getElementType()); |
| assertFalse("Should not be a synthetic", binding.isSynthetic()); |
| } |
| |
| public void test429813a() throws JavaModelException { |
| this.workingCopy = getWorkingCopy("/Converter18/src/test429813/Snippet.java", |
| true/* resolve */); |
| String contents = "package test429813;" |
| + "interface FTest {\n" |
| + " Object foo (int[]... ints);\n" |
| + "};" |
| + "class TestX {" |
| + " FTest fi= ints -> null;\n" |
| + "}\n"; |
| CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy); |
| TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1); |
| FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0); |
| Expression expression = fragment.getInitializer(); |
| assertTrue(expression instanceof LambdaExpression); |
| LambdaExpression lambdaExpression = (LambdaExpression)expression; |
| IMethodBinding binding = lambdaExpression.resolveMethodBinding(); |
| assertTrue("Should be a varargs", binding.isVarargs()); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=399792 |
| public void testBug470794_001() throws JavaModelException { |
| String content = |
| "public class X {\n" + |
| " Object o = (I & J) () -> {};" + |
| " public K main(Object o) {\n" + |
| " K oo = (I & J & K) o;\n" + |
| " return oo;\n" + |
| " }\n" + |
| "}\n" + |
| "interface I {\n" + |
| " public void foo();\n" + |
| "}\n" + |
| "interface J {\n" + |
| " public void foo();\n" + |
| " public default void bar() {}\n" + |
| "}\n" + |
| "interface K {\n" + |
| " public void foo();\n" + |
| " public void bar();\n" + |
| "}\n"; |
| |
| this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); |
| ASTNode node = buildAST(content, this.workingCopy, true); |
| assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); |
| CompilationUnit unit = (CompilationUnit) node; |
| TypeDeclaration type = (TypeDeclaration) unit.types().get(0); |
| node = (ASTNode) type.bodyDeclarations().get(0); |
| assertEquals("Not a field Declaration", ASTNode.FIELD_DECLARATION, node.getNodeType()); |
| FieldDeclaration field = (FieldDeclaration) node; |
| assertEquals("Field should not be malformed", 0, (field.getFlags() & ASTNode.MALFORMED)); |
| |
| List fragments = field.fragments(); |
| assertEquals("Incorrect no of fragments", 1, fragments.size()); |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); |
| CastExpression cast = (CastExpression) fragment.getInitializer(); |
| Type castType = cast.getType(); |
| assertEquals("Not an intersection cast type", ASTNode.INTERSECTION_TYPE, castType.getNodeType()); |
| assertTrue("Not an intersection cast type", castType.isIntersectionType()); |
| assertEquals("Type should not be malformed", 0, (castType.getFlags() & ASTNode.MALFORMED)); |
| ITypeBinding binding = castType.resolveBinding(); |
| assertNotNull("binding is null", binding); |
| assertTrue("Not an intersection type binding", binding.isIntersectionType()); |
| { |
| ITypeBinding [] intersectionBindings = binding.getTypeBounds(); |
| String[] expectedTypes = new String[]{"I", "J"}; |
| assertTrue("Incorrect number of intersection bindings", intersectionBindings.length == expectedTypes.length); |
| for (int i = 0, l = intersectionBindings.length; i < l; ++i) { |
| assertTrue("Unexpected Intersection Type", expectedTypes[i].equals(intersectionBindings[i].getName())); |
| } |
| } |
| |
| node = (ASTNode) type.bodyDeclarations().get(1); |
| assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType()); |
| MethodDeclaration method = (MethodDeclaration) node; |
| assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED)); |
| |
| List statements = method.getBody().statements(); |
| VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); |
| fragment = (VariableDeclarationFragment) statement.fragments().get(0); |
| cast = (CastExpression) fragment.getInitializer(); |
| castType = cast.getType(); |
| binding = castType.resolveBinding(); |
| assertNotNull("binding is null", binding); |
| assertTrue("Not an intersection type binding", binding.isIntersectionType()); |
| { |
| ITypeBinding [] intersectionBindings = binding.getTypeBounds(); |
| String[] expectedTypes = new String[]{"I", "J", "K"}; |
| assertTrue("Incorrect number of intersection bindings", intersectionBindings.length == expectedTypes.length); |
| for (int i = 0, l = intersectionBindings.length; i < l; ++i) { |
| assertTrue("Unexpected Intersection Type", expectedTypes[i].equals(intersectionBindings[i].getName())); |
| } |
| } |
| } |
| |
| } |