/******************************************************************************* | |
* Copyright (c) 2000, 2015 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 = | |
"package test460186;\n" + | |
"public class NPE {\n" + | |
" void foo(String[] args) throws Exception {\n" + | |
" if (args == null) error(); \n" + | |
" error();[]\n" + | |
" }\n" + | |
" void error() throws Exception {\n" + | |
" throw new Exception();\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() {}; | |
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=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=463942 | |
public void testBug463942_001() 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 String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str = 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); | |
/* public String @Marker("i0") @Marker2 [] [] @Marker("i1") [] str = null; */ | |
node = getASTNode(compilationUnit, 2, 0); | |
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 typeBinding = variable.getType(); | |
assertNotNull("Should not be null", typeBinding); | |
IAnnotationBinding[][] dimAnnotations = typeBinding.getTypeAnnotationsOnDimensions(); | |
assertEquals("Incorrect type annotations", 3, dimAnnotations.length); | |
IAnnotationBinding[] annotations = dimAnnotations[0]; | |
assertTrue("Incorrect number of annotations", annotations.length == 2); | |
assertEquals("Incorrect type annotations", "@Marker(value = i0)", annotations[0].toString()); | |
assertEquals("Incorrect type annotations", "@Marker2()", annotations[1].toString()); | |
annotations = dimAnnotations[1]; | |
assertTrue("Incorrect number of annotations", annotations.length == 0); | |
annotations = dimAnnotations[2]; | |
assertTrue("Incorrect number of annotations", annotations.length == 1); | |
assertEquals("Incorrect type annotations", "@Marker(value = i1)", annotations[0].toString()); | |
} | |
// 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 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())); | |
} | |
} | |
} | |
} |