/******************************************************************************* | |
* Copyright (c) 2013, 2014 IBM Corporation and others. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v1.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v10.html | |
* | |
* Contributors: | |
* IBM Corporation - initial API and implementation | |
*******************************************************************************/ | |
package org.eclipse.jdt.core.tests.dom; | |
import java.io.IOException; | |
import java.util.HashMap; | |
import java.util.List; | |
import junit.framework.Test; | |
import org.eclipse.core.runtime.CoreException; | |
import org.eclipse.jdt.core.ICompilationUnit; | |
import org.eclipse.jdt.core.IJavaProject; | |
import org.eclipse.jdt.core.JavaCore; | |
import org.eclipse.jdt.core.dom.AST; | |
import org.eclipse.jdt.core.dom.ASTNode; | |
import org.eclipse.jdt.core.dom.ArrayCreation; | |
import org.eclipse.jdt.core.dom.ArrayType; | |
import org.eclipse.jdt.core.dom.Assignment; | |
import org.eclipse.jdt.core.dom.Block; | |
import org.eclipse.jdt.core.dom.CastExpression; | |
import org.eclipse.jdt.core.dom.CatchClause; | |
import org.eclipse.jdt.core.dom.ClassInstanceCreation; | |
import org.eclipse.jdt.core.dom.CompilationUnit; | |
import org.eclipse.jdt.core.dom.CreationReference; | |
import org.eclipse.jdt.core.dom.EnhancedForStatement; | |
import org.eclipse.jdt.core.dom.Expression; | |
import org.eclipse.jdt.core.dom.ExpressionStatement; | |
import org.eclipse.jdt.core.dom.FieldDeclaration; | |
import org.eclipse.jdt.core.dom.IAnnotationBinding; | |
import org.eclipse.jdt.core.dom.IMethodBinding; | |
import org.eclipse.jdt.core.dom.ITypeBinding; | |
import org.eclipse.jdt.core.dom.IVariableBinding; | |
import org.eclipse.jdt.core.dom.IfStatement; | |
import org.eclipse.jdt.core.dom.InstanceofExpression; | |
import org.eclipse.jdt.core.dom.MarkerAnnotation; | |
import org.eclipse.jdt.core.dom.MethodDeclaration; | |
import org.eclipse.jdt.core.dom.MethodInvocation; | |
import org.eclipse.jdt.core.dom.ParameterizedType; | |
import org.eclipse.jdt.core.dom.ParenthesizedExpression; | |
import org.eclipse.jdt.core.dom.PrefixExpression; | |
import org.eclipse.jdt.core.dom.QualifiedType; | |
import org.eclipse.jdt.core.dom.ReturnStatement; | |
import org.eclipse.jdt.core.dom.SimpleName; | |
import org.eclipse.jdt.core.dom.SingleVariableDeclaration; | |
import org.eclipse.jdt.core.dom.ThisExpression; | |
import org.eclipse.jdt.core.dom.TryStatement; | |
import org.eclipse.jdt.core.dom.Type; | |
import org.eclipse.jdt.core.dom.TypeDeclaration; | |
import org.eclipse.jdt.core.dom.TypeMethodReference; | |
import org.eclipse.jdt.core.dom.TypeParameter; | |
import org.eclipse.jdt.core.dom.UnionType; | |
import org.eclipse.jdt.core.dom.VariableDeclarationExpression; | |
import org.eclipse.jdt.core.dom.VariableDeclarationFragment; | |
import org.eclipse.jdt.core.dom.VariableDeclarationStatement; | |
import org.eclipse.jdt.core.dom.WildcardType; | |
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; | |
public class TypeBindingTests308 extends ConverterTestSetup { | |
ICompilationUnit workingCopy; | |
public static Test suite() { | |
return buildModelTestSuite(TypeBindingTests308.class); | |
} | |
public void setUpSuite() throws Exception { | |
super.setUpSuite(); | |
this.ast = AST.newAST(AST.JLS8); | |
} | |
public TypeBindingTests308(String testName){ | |
super(testName); | |
} | |
static { | |
// TESTS_NUMBERS = new int[] { }; | |
// TESTS_RANGE = new int[] { }; | |
// TESTS_NAMES = new String[] {"test027"}; | |
} | |
private void verifyAnnotationOnType(Type type, String[] annots) { | |
verifyAnnotationsOnBinding(type.resolveBinding(), annots); | |
} | |
private void verifyAnnotationsOnBinding(ITypeBinding binding, String[] annots) { | |
IAnnotationBinding[] annotations = binding.getTypeAnnotations(); | |
assertNotNull("Should not be null", annotations); | |
int length = annots.length; | |
assertEquals("Incorrect type use annotations", length, annotations.length); | |
for (int i = 0; i < length; i++) { | |
assertEquals("Incorrect annotation", annots[i], (annotations[i] == null) ? null : annotations[i].toString()); | |
} | |
} | |
private void verifyAnnotationsOnBinding(IVariableBinding binding, String[] annots) { | |
IAnnotationBinding[] annotations = binding.getAnnotations(); | |
assertNotNull("Should not be null", annotations); | |
int length = annots.length; | |
assertEquals("Incorrect annotations", length, annotations.length); | |
for (int i = 0; i < length; i++) { | |
assertEquals("Incorrect annotation", annots[i], (annotations[i] == null) ? null : annotations[i].toString()); | |
} | |
} | |
public void test000() throws Exception { | |
String contents = | |
"public class X extends @Marker @SingleMember(0) @Normal(value = 0) Object {\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 SingleMember { int value() default 0;}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Normal { int value() default 0;}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
Type type = typeDecl.getSuperclassType(); | |
assertNotNull("Super class should not be null", type); | |
verifyAnnotationOnType(type, new String[]{"@Marker()", "@SingleMember(value = 0)", "@Normal(value = 0)"}); | |
} | |
public void test001() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" @Marker int x;\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect field", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
verifyAnnotationOnType(field.getType(), new String[]{"@Marker()"}); | |
} | |
public void test002() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" @Marker <@Marker2 T> int x() { return 10; };\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_PARAMETER)\n" + | |
"@interface Marker2{}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List params = method.typeParameters(); | |
TypeParameter param = (TypeParameter) params.get(0); | |
ITypeBinding binding = param.resolveBinding(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
verifyAnnotationOnType(method.getReturnType2(), new String[]{"@Marker()"}); | |
} | |
public void test003() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" int x(@Marker int p) { return 10; };\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List params = method.parameters(); | |
SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0); | |
ITypeBinding binding = param.resolveBinding().getType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
verifyAnnotationOnType(param.getType(), new String[]{"@Marker()"}); | |
} | |
public void test004() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" int x(@Marker int ... p) { return 10; };\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List params = method.parameters(); | |
SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0); | |
verifyAnnotationOnType(param.getType(), new String[]{"@Marker()"}); | |
} | |
public void test005() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" int x(@Marker int @Marker2 [] @Marker3 ... p) { return 10; };\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 {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker3 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List params = method.parameters(); | |
SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0); | |
ArrayType type = (ArrayType) param.getType(); | |
ITypeBinding binding = type.resolveBinding(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
verifyAnnotationsOnBinding(param.resolveBinding().getType(), new String[]{"@Marker2()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
} | |
public void test006() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" int x() {\n" + | |
" try {\n" + | |
" } catch (@Marker NullPointerException | @Marker2 ArrayIndexOutOfBoundsException e) {\n" + | |
" }\n" + | |
" return 10;\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
TryStatement trySt = (TryStatement) statements.get(0); | |
CatchClause catchCl = (CatchClause) trySt.catchClauses().get(0); | |
UnionType union = (UnionType) catchCl.getException().getType(); | |
types = union.types(); | |
assertEquals("Incorrect union types", 2, types.size()); | |
Type type = (Type) types.get(0); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
type = (Type) types.get(1); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
} | |
public void test007() throws Exception { | |
String contents = | |
"package java.lang;\n" + | |
"public class X {\n" + | |
" public void x() throws Exception {\n" + | |
" try (@Marker LocalStream p = null; final @Marker2 LocalStream q = null; @Marker3 final LocalStream r = null) {}\n" + | |
" }\n" + | |
"}\n" + | |
"class LocalStream implements AutoCloseable {\n" + | |
" public void close() throws Exception {}\n" + | |
"}\n" + | |
"interface AutoCloseable {}\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 {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker3 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 6, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
TryStatement trySt = (TryStatement) statements.get(0); | |
List resources = trySt.resources(); | |
assertEquals("Incorrect no of resources", 3, resources.size()); | |
VariableDeclarationExpression resource = (VariableDeclarationExpression) resources.get(0); | |
Type type = resource.getType(); | |
assertNotNull("Resource type should not be null", type); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
resource = (VariableDeclarationExpression) resources.get(1); | |
type = resource.getType(); | |
assertNotNull("Resource type should not be null", type); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
resource = (VariableDeclarationExpression) resources.get(2); | |
type = resource.getType(); | |
assertNotNull("Resource type should not be null", type); | |
verifyAnnotationOnType(type, new String[]{"@Marker3()"}); | |
} | |
public void test008() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" int x() {\n" + | |
" for (@Marker int i: new int[3]) {}\n" + | |
" for (final @Marker int i: new int[3]) {}\n" + | |
" for (@Marker final int i: new int[3]) {}\n" + | |
" return 10;\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
EnhancedForStatement forStmt = (EnhancedForStatement) statements.get(0); | |
SingleVariableDeclaration param = forStmt.getParameter(); | |
Type type = param.getType(); | |
assertNotNull("Resource type should not be null", type); | |
ITypeBinding binding = param.resolveBinding().getType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
binding = type.resolveBinding(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
} | |
public void test009() throws Exception { | |
String contents = | |
"interface I {\n" + | |
" Object copy(int [] ia);\n" + | |
"}\n" + | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" I i = @Marker int @Marker2 []::clone;\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
VariableDeclarationStatement stmt = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
TypeMethodReference lambda = (TypeMethodReference) fragment.getInitializer(); | |
ArrayType type = (ArrayType) lambda.getType(); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
ITypeBinding binding = type.resolveBinding(); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
} | |
public void test010() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" int i [] = new @Marker int @Marker2 [4];\n" + | |
" int j [] = new @Marker2 int @Marker [] { 10 };\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
VariableDeclarationStatement stmt = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
ArrayCreation arrayCr = (ArrayCreation) fragment.getInitializer(); | |
ArrayType type = arrayCr.getType(); | |
ITypeBinding binding = type.resolveBinding(); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
stmt = (VariableDeclarationStatement) statements.get(1); | |
fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
arrayCr = (ArrayCreation) fragment.getInitializer(); | |
type = arrayCr.getType(); | |
binding = type.resolveBinding(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
} | |
public void test011() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" int i = (@Marker int) 0;\n" + | |
" int j [] = (@Marker int @Marker2 []) null;\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
VariableDeclarationStatement stmt = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
CastExpression castExp = (CastExpression) fragment.getInitializer(); | |
Type type = castExp.getType(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
stmt = (VariableDeclarationStatement) statements.get(1); | |
fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
castExp = (CastExpression) fragment.getInitializer(); | |
ArrayType arrayType = (ArrayType) castExp.getType(); | |
ITypeBinding binding = arrayType.resolveBinding(); | |
verifyAnnotationOnType(arrayType, new String[]{"@Marker2()"}); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
} | |
public void test012() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" public static void main(String args) {\n" + | |
" if (args instanceof @Marker String) {\n" + | |
" }\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect method", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List statements = method.getBody().statements(); | |
IfStatement ifStmt = (IfStatement) statements.get(0); | |
InstanceofExpression instanceOf = (InstanceofExpression) ifStmt.getExpression(); | |
Type type = instanceOf.getRightOperand(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
} | |
public void test013() throws Exception { | |
String contents = | |
"public class X extends Y<@Marker(10) Integer, String> {}\n" + | |
"class Y<T, V> {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {int value();}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
ParameterizedType superClass = (ParameterizedType) typeDecl.getSuperclassType(); | |
List arguments = superClass.typeArguments(); | |
assertEquals("Incorrect no of type arguments", 2, arguments.size()); | |
Type type = (Type) arguments.get(0); | |
verifyAnnotationOnType(type, new String[]{"@Marker(value = 10)"}); | |
} | |
public void test014() throws Exception { | |
String contents = | |
"public class X<T extends Object & Comparable<? super @Marker String>> {}\n" + | |
"class Y<T> {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
List typeParams = typeDecl.typeParameters(); | |
TypeParameter typeParam = (TypeParameter) typeParams.get(0); | |
List bounds = typeParam.typeBounds(); | |
assertEquals("Incorrect no of type bounds", 2, bounds.size()); | |
ParameterizedType type = (ParameterizedType) bounds.get(1); | |
typeParams = type.typeArguments(); | |
assertEquals("Incorrect type params", 1, typeParams.size()); | |
WildcardType wildcard = (WildcardType)typeParams.get(0); | |
Type bound = wildcard.getBound(); | |
assertNotNull("Bound should not be null", bound); | |
verifyAnnotationOnType(bound, new String[]{"@Marker()"}); | |
} | |
public void test015() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" void foo(Map<@Marker ? super @Marker2 Object, @Marker3 ? extends @Marker4 String> m){}\n" + | |
" void goo(Map<@Marker4 ? extends @Marker3 Object, @Marker2 ? super @Marker String> m){}\n" + | |
"}\n" + | |
"class Map<K, V>{}\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 {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker3 {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker4 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 6, types.size()); | |
MethodDeclaration[] methods = ((TypeDeclaration) types.get(0)).getMethods(); | |
assertEquals("Incorrect no of metods", 2, methods.length); | |
MethodDeclaration method = methods[0]; | |
SingleVariableDeclaration arg = (SingleVariableDeclaration) method.parameters().get(0); | |
List typeArgs = ((ParameterizedType) arg.getType()).typeArguments(); | |
WildcardType wildcard = (WildcardType) typeArgs.get(0); | |
verifyAnnotationOnType(wildcard, new String[]{"@Marker()"}); | |
Type type = wildcard.getBound(); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
wildcard = (WildcardType) typeArgs.get(1); | |
verifyAnnotationOnType(wildcard, new String[]{"@Marker3()"}); | |
type = wildcard.getBound(); | |
verifyAnnotationOnType(type, new String[]{"@Marker4()"}); | |
method = methods[1]; | |
arg = (SingleVariableDeclaration) method.parameters().get(0); | |
typeArgs = ((ParameterizedType) arg.getType()).typeArguments(); | |
wildcard = (WildcardType) typeArgs.get(0); | |
verifyAnnotationOnType(wildcard, new String[]{"@Marker4()"}); | |
type = wildcard.getBound(); | |
verifyAnnotationOnType(type, new String[]{"@Marker3()"}); | |
wildcard = (WildcardType) typeArgs.get(1); | |
verifyAnnotationOnType(wildcard, new String[]{"@Marker2()"}); | |
type = wildcard.getBound(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
} | |
public void test016() throws Exception { | |
String contents = | |
"public class X<E> {\n" + | |
" class Y {\n" + | |
" E e;\n" + | |
" E getOtherElement(Object other) {\n" + | |
" if (!(other instanceof @Marker X<?>.Y)) {};\n" + | |
" return null;\n" + | |
" }\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
typeDecl = typeDecl.getTypes()[0]; | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
IfStatement ifStmt = (IfStatement) method.getBody().statements().get(0); | |
PrefixExpression prefix = (PrefixExpression ) ifStmt.getExpression(); | |
ParenthesizedExpression operand = (ParenthesizedExpression) prefix.getOperand(); | |
InstanceofExpression expression = (InstanceofExpression) operand.getExpression(); | |
QualifiedType type = (QualifiedType) expression.getRightOperand(); | |
verifyAnnotationOnType(type, new String[]{}); | |
verifyAnnotationOnType(type.getQualifier(), new String[]{"@Marker()"}); | |
} | |
public void test017() throws Exception { | |
String contents = | |
"public class X<P, C> {\n" + | |
" public X() {\n" + | |
" if (!(this instanceof @Marker X)) {}\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
IfStatement ifStmt = (IfStatement) method.getBody().statements().get(0); | |
PrefixExpression prefix = (PrefixExpression ) ifStmt.getExpression(); | |
ParenthesizedExpression operand = (ParenthesizedExpression) prefix.getOperand(); | |
InstanceofExpression expression = (InstanceofExpression) operand.getExpression(); | |
verifyAnnotationOnType(expression.getRightOperand(), new String[]{"@Marker()"}); | |
} | |
public void test018() throws Exception { | |
String contents = | |
"interface I {\n" + | |
" void foo(Y<String>.Z z, int x);\n" + | |
"}\n" + | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" I i = Y<String>.@Marker Z::foo;\n" + | |
" i.foo(new Y<String>().new Z(), 10); \n" + | |
" }\n" + | |
"}\n" + | |
"class Y<T> {\n" + | |
" class Z {\n" + | |
" void foo(int x) {\n" + | |
" }\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
VariableDeclarationStatement statement = (VariableDeclarationStatement) method.getBody().statements().get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
TypeMethodReference initializer = (TypeMethodReference) fragment.getInitializer(); | |
Type type = initializer.getType(); | |
assertTrue(type.isQualifiedType()); | |
QualifiedType qualifiedType = (QualifiedType) type; | |
checkSourceRange(qualifiedType.getName(), "Z", contents); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
assertEquals("Should be a qualified type", ASTNode.QUALIFIED_TYPE, type.getNodeType()); | |
verifyAnnotationOnType(((QualifiedType) type).getQualifier() , new String[]{}); | |
} | |
public void test019() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" X [] x = new @Marker X @Marker2 [5];\n" + | |
" X [] x2 = new @Marker2 X @Marker [] { null };\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
List statements = method.getBody().statements(); | |
assertEquals("Incorrect no of statements", 2, statements.size()); | |
VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
ArrayCreation initializer = (ArrayCreation) fragment.getInitializer(); | |
ArrayType arrayType = initializer.getType(); | |
ITypeBinding binding = arrayType.resolveBinding(); | |
verifyAnnotationOnType(arrayType, new String[]{"@Marker2()"}); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
statement = (VariableDeclarationStatement) statements.get(1); | |
fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
initializer = (ArrayCreation) fragment.getInitializer(); | |
arrayType = initializer.getType(); | |
binding = arrayType.resolveBinding(); | |
verifyAnnotationOnType(arrayType, new String[]{"@Marker()"}); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker()"}); | |
binding = binding.getComponentType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@Marker2()"}); | |
} | |
public void test020() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" Map.Entry<String, String> [] e = (Map.@Marker Entry<String, String> []) null;\n" + | |
" }\n" + | |
"}\n" + | |
"class Map<K, V> {\n" + | |
" interface Entry<K, V> {}\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
List statements = method.getBody().statements(); | |
assertEquals("Incorrect no of statements", 1, statements.size()); | |
VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
CastExpression castExp = (CastExpression) fragment.getInitializer(); | |
ArrayType arrayType = (ArrayType) castExp.getType(); | |
verifyAnnotationOnType(arrayType, new String[]{}); | |
ParameterizedType type = (ParameterizedType) arrayType.getElementType(); | |
verifyAnnotationOnType(type.getType(), new String[]{"@Marker()"}); | |
} | |
public void test021() throws Exception { | |
String contents = | |
"import java.io.Serializable;\n" + | |
"import java.util.List;\n" + | |
"public class X<T extends Comparable<T> & Serializable> {\n" + | |
" void foo(List<? extends @Marker @Marker2 Comparable<T>> p) {} \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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
SingleVariableDeclaration param = (SingleVariableDeclaration) method.parameters().get(0); | |
Type type = param.getType(); | |
assertEquals("Should be a parameterized type", ASTNode.PARAMETERIZED_TYPE, type.getNodeType()); | |
List typeArgs = ((ParameterizedType) type).typeArguments(); | |
assertEquals("Incorrect type args", 1, typeArgs.size()); | |
WildcardType wildcard = (WildcardType) typeArgs.get(0); | |
ParameterizedType bound = (ParameterizedType) wildcard.getBound(); | |
verifyAnnotationOnType(bound, new String[]{"@Marker()", "@Marker2()"}); | |
} | |
public void test022() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" X x = new @Marker X();\n" + | |
" X y = new <String> @Marker X();\n" + | |
" <T> X(){}\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 2, fields.length); | |
FieldDeclaration field = fields[0]; | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
ClassInstanceCreation creation = (ClassInstanceCreation) fragment.getInitializer(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker()"}); | |
field = fields[1]; | |
fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
creation = (ClassInstanceCreation) fragment.getInitializer(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker()"}); | |
} | |
public void test023() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" class Y {\n" + | |
" <T> Y(){}\n" + | |
" }\n" + | |
" Y y1 = new @Marker X().new @Marker2 Y();\n" + | |
" Y y2 = new @Marker2 X().new <String> @Marker Y();\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 2, fields.length); | |
FieldDeclaration field = fields[0]; | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
ClassInstanceCreation creation = (ClassInstanceCreation) fragment.getInitializer(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker2()"}); | |
creation = (ClassInstanceCreation) creation.getExpression(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker()"}); | |
field = fields[1]; | |
fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
creation = (ClassInstanceCreation) fragment.getInitializer(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker()"}); | |
creation = (ClassInstanceCreation) creation.getExpression(); | |
verifyAnnotationOnType(creation.getType(), new String[]{"@Marker2()"}); | |
} | |
public void test024() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" void foo() throws @Marker NullPointerException, @Marker2 ArrayIndexOutOfBoundsException {}\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
List thrownTypes = method.thrownExceptionTypes(); | |
assertEquals("Incorrect no of thrown exceptions", 2, thrownTypes.size()); | |
Type type = (Type) thrownTypes.get(0); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
type = (Type) thrownTypes.get(1); | |
verifyAnnotationOnType(type, new String[]{"@Marker2()"}); | |
} | |
public void test025() throws Exception { | |
String contents = | |
"interface I {}\n" + | |
"interface J {}\n" + | |
"interface K extends @Marker I, @Marker2 J {}\n" + | |
"interface L {}\n" + | |
"public class X implements @Marker2 K, @Marker L {\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 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 7, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(2); | |
List interfaces = typeDecl.superInterfaceTypes(); | |
assertEquals("Incorrect no of super interfaces", 2, interfaces.size()); | |
verifyAnnotationOnType((Type) interfaces.get(0), new String[]{"@Marker()"}); | |
verifyAnnotationOnType((Type) interfaces.get(1), new String[]{"@Marker2()"}); | |
typeDecl = (TypeDeclaration) types.get(4); | |
interfaces = typeDecl.superInterfaceTypes(); | |
assertEquals("Incorrect no of super interfaces", 2, interfaces.size()); | |
verifyAnnotationOnType((Type) interfaces.get(0), new String[]{"@Marker2()"}); | |
verifyAnnotationOnType((Type) interfaces.get(1), new String[]{"@Marker()"}); | |
} | |
public void test026() throws Exception { | |
String contents = | |
"interface I {\n" + | |
" void foo(int x);\n" + | |
"}\n" + | |
"public class X {\n" + | |
" public static void main(String [] args) {\n" + | |
" I i = A.Y.@Marker Z ::foo;\n" + | |
" i.foo(10); \n" + | |
" }\n" + | |
"}\n" + | |
"class A {\n" + | |
" static class Y {\n" + | |
" static class Z {\n" + | |
" public static void foo(int x) {\n" + | |
" System.out.println(x);\n" + | |
" }\n" + | |
" }\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
List statements = method.getBody().statements(); | |
VariableDeclarationStatement stmt = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) stmt.fragments().get(0); | |
TypeMethodReference lambda = (TypeMethodReference) fragment.getInitializer(); | |
Type type = lambda.getType(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
} | |
public void test027() throws Exception { | |
String contents = | |
"interface I {\n" + | |
" Y foo(int x);\n" + | |
"}\n" + | |
"public class X {\n" + | |
" class Z extends Y {\n" + | |
" public Z(int x) {\n" + | |
" super(x);\n" + | |
" }\n" + | |
" }\n" + | |
" public static void main(String [] args) {\n" + | |
" I i = @Marker W<@Marker2 Integer>::<@Marker3 String> new;\n" + | |
" }\n" + | |
"}\n" + | |
"class W<T> extends Y {\n" + | |
" public <C> W(T x) {\n" + | |
" super(0);\n" + | |
" }\n" + | |
"}\n" + | |
"class Y {\n" + | |
" public Y(int x) {\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 {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker3 {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 7, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
List statements = method.getBody().statements(); | |
VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
CreationReference lambda = (CreationReference) fragment.getInitializer(); | |
Type type = lambda.getType(); | |
verifyAnnotationOnType(type, new String[]{"@Marker()"}); | |
ParameterizedType paramType = (ParameterizedType) type; | |
verifyAnnotationOnType((Type) paramType.typeArguments().get(0), new String[]{"@Marker2()"}); | |
List typeArgs = lambda.typeArguments(); | |
verifyAnnotationOnType((Type) typeArgs.get(0), new String[]{"@Marker3()"}); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=418096 | |
public void test028() throws Exception { | |
String contents = | |
"public class X {\n" + | |
" @TypeUseAnnotation(\"a\") String @TypeUseAnnotation(\"a1\") [] @TypeUseAnnotation(\"a2\") [] _field2 @TypeUseAnnotation(\"a3\") [], _field3 @TypeUseAnnotation(\"a4\") [][] = null;\n" + | |
"}" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface TypeUseAnnotation {\n" + | |
" String value() default \"\";\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
List fragments = field.fragments(); | |
assertEquals("Incorrect no of fragments", 2, fragments.size()); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0); | |
ITypeBinding binding = fragment.resolveBinding().getType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@TypeUseAnnotation(value = a3)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a1)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a2)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a)"}); | |
fragment = (VariableDeclarationFragment) fragments.get(1); | |
binding = fragment.resolveBinding().getType(); | |
verifyAnnotationsOnBinding(binding, new String[]{"@TypeUseAnnotation(value = a4)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a1)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a2)"}); | |
verifyAnnotationsOnBinding(binding = binding.getComponentType(), new String[]{"@TypeUseAnnotation(value = a)"}); | |
} | |
public void testAnnotatedBinaryType() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer {\n" + | |
" class Middle {\n" + | |
" class Inner {\n" + | |
" }\n" + | |
" }\n" + | |
" public @Marker(\"Outer\") Outer.@Marker (\"Middle\") Middle.@Marker(\"Inner\") Inner omi;\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {\n" + | |
" String value() default \"GOK\";\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer o) {\n" + | |
" o.omi = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@Marker((String)\"Outer\") Outer.@Marker((String)\"Middle\") Middle.@Marker((String)\"Inner\") Inner", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedBinaryType2() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer {\n" + | |
" class Middle {\n" + | |
" class Inner {\n" + | |
" }\n" + | |
" }\n" + | |
" public @Marker(\"Outer\") Outer.@Marker (\"Middle\") Middle.@Marker(\"Inner\") Inner @Marker(\"Prefix []\") [] omi @Marker(\"Extended []\") [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface Marker {\n" + | |
" String value() default \"GOK\";\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer o) {\n" + | |
" o.omi = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@Marker((String)\"Outer\") Outer.@Marker((String)\"Middle\") Middle.@Marker((String)\"Inner\") Inner @Marker((String)\"Extended []\") [] @Marker((String)\"Prefix []\") []", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedBinaryType3() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer<K> {\n" + | |
" class Inner<P> {\n" + | |
" }\n" + | |
" public @T(1) Outer<@T(2) String>.@T(3) Inner<@T(4) Integer> @T(5) [] omi @T(6) [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value();\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer<String> o) {\n" + | |
" o.omi = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T((int)1) Outer<@T((int)2) String>.@T((int)3) Inner<@T((int)4) Integer> @T((int)6) [] @T((int)5) []", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedBinaryType4() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer<K> {\n" + | |
" class Inner<P> {\n" + | |
" }\n" + | |
" @T(1) K @T(2) [] f @T(3) [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value();\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer<String> o) {\n" + | |
" o.f = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T((int)1) String @T((int)3) [] @T((int)2) []", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedBinaryType5() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer<K> {\n" + | |
" class Inner<P> {\n" + | |
" }\n" + | |
" @T(1) Outer<@T(2) ? extends @T(3) String>.@T(4) Inner<@T(5) ? super @T(6) Integer> @T(7) [] f @T(8) [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value();\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer<String> o) {\n" + | |
" o.f = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T((int)1) Outer<@T((int)2) ? extends @T((int)3) String>.@T((int)4) Inner<@T((int)5) ? super @T((int)6) Integer> @T((int)8) [] @T((int)7) []", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedBinaryType6() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer<K> {\n" + | |
" class Inner<P> {\n" + | |
" }\n" + | |
" @T(1) Outer.@T(2) Inner @T(3) [] f @T(4) [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value();\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer<String> o) {\n" + | |
" o.f = 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T((int)1) Outer#RAW.@T((int)2) Inner#RAW @T((int)4) [] @T((int)3) []", type.toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testIntersectionCastType() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T1 {\n" + | |
"}\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T2 {\n" + | |
"}\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T3 {\n" + | |
"}\n" + | |
"public class X {\n" + | |
" Object o = (@T1 Object & @T2 Runnable & java.io.@T3 Serializable) null;\n" + | |
" Object p = (@T1 Object & @T2 Runnable & java.io.@T3 Serializable) 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 4, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(3); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 2, fields.length); | |
FieldDeclaration field = fields[0]; | |
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(); | |
ITypeBinding binding1 = castType.resolveBinding(); | |
assertEquals("Wrong annotations", "@T1 Object & @T2 Runnable & @T3 Serializable", binding1.toString()); | |
field = fields[1]; | |
fragments = field.fragments(); | |
assertEquals("Incorrect no of fragments", 1, fragments.size()); | |
fragment = (VariableDeclarationFragment) fragments.get(0); | |
cast = (CastExpression) fragment.getInitializer(); | |
castType = cast.getType(); | |
ITypeBinding binding2 = castType.resolveBinding(); | |
assertEquals("Wrong annotations", "@T1 Object & @T2 Runnable & @T3 Serializable", binding2.toString()); | |
assertSame("Should be equal", binding1, binding2); | |
} | |
public void testMemberType() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer {\n" + | |
" class Inner {\n" + | |
" }\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(@T Outer o) {\n" + | |
" }\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List parameters = method.parameters(); | |
SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0); | |
ITypeBinding binding = parameter.resolveBinding().getType(); | |
assertEquals("@T Outer", binding.toString()); | |
ITypeBinding [] memberTypes = binding.getDeclaredTypes(); | |
assertEquals("Incorrect no of types", 1, memberTypes.length); | |
assertEquals("Incorrect no of types", "@T Outer.Inner", memberTypes[0].toString()); | |
assertEquals("Incorrect no of types", "@T Outer", memberTypes[0].getDeclaringClass().toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testMemberType2() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer {\n" + | |
" @T Outer f;\n"+ | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Outer o) {\n" + | |
" o.f = null;\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T Outer", type.toString()); | |
IVariableBinding[] declaredFields = type.getDeclaredFields(); | |
assertEquals("Wrong type", 1, declaredFields.length); | |
assertEquals("Wrong type", "@T Outer", declaredFields[0].getType().toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testBinarySuperInterfaces() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Y.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T1 {\n" + | |
"}\n" + | |
"public abstract class Y implements Comparable<@T1 Y>{ \n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" void foo(Y y) {\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
List parameters = method.parameters(); | |
SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0); | |
ITypeBinding binding = parameter.resolveBinding().getType(); | |
ITypeBinding binding2 = binding.getInterfaces()[0].getTypeArguments()[0]; | |
assertEquals("Wrong type", "@T1 Y", binding2.toString()); | |
assertEquals("Wrong type", "Comparable<@T1 Y>", binding2.getInterfaces()[0].toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testMemberTypeSource() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
"}\n" + | |
"public class X {\n" + | |
" class Y {}\n" + | |
" @T X.Y xy;\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
ITypeBinding binding = field.getType().resolveBinding(); | |
assertEquals("Wrong Type", "@T X", (binding = binding.getDeclaringClass()).toString()); | |
assertEquals("Wrong Type", "@T X.Y", (binding = binding.getDeclaredTypes()[0]).toString()); | |
} | |
public void testAnnotatedTypeIdentity() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"import java.util.List;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
"}\n" + | |
"public class X {\n" + | |
" @T List<@T String> ls = (@T List<@T String>) 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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
ITypeBinding binding = field.getType().resolveBinding(); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
CastExpression cast = (CastExpression) fragment.getInitializer(); | |
ITypeBinding binding2 = cast.resolveTypeBinding(); | |
assertEquals("Wrong Type", "@T List<@T String>", binding.toString()); | |
assertSame("not Equal", binding, binding2); | |
} | |
public void testAnnotatedTypeIdentity2() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"public class Outer {\n" + | |
" Outer @T [] f @T [];\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value() default 10;\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"public class X {\n" + | |
" Outer @T [] f @T [];\n" + | |
" void foo(Outer o) {\n" + | |
" o.f = this.f;\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
Expression right = assignment.getRightHandSide(); | |
ITypeBinding type2 = right.resolveTypeBinding(); | |
assertEquals("Wrong type", "Outer @T [] @T []", type.toString()); | |
assertSame ("Should be same", type, type2); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testAnnotatedTypeIdentity3() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Outer.java", | |
"import java.util.List;\n" + | |
"public class Outer {\n" + | |
" @T List<@T String> ls;\n" + | |
"}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value() default 10;\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"import java.util.List;\n" + | |
"public class X {\n" + | |
" @T List<@T String> ls;\n" + | |
" void foo(Outer o) {\n" + | |
" o.ls = this.ls;\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Block body = method.getBody(); | |
ExpressionStatement stmt = (ExpressionStatement) body.statements().get(0); | |
Assignment assignment = (Assignment) stmt.getExpression(); | |
Expression left = assignment.getLeftHandSide(); | |
ITypeBinding type = left.resolveTypeBinding(); | |
Expression right = assignment.getRightHandSide(); | |
ITypeBinding type2 = right.resolveTypeBinding(); | |
assertEquals("Wrong type", "@T List<@T String>", type.toString()); | |
assertSame ("Should be same", type, type2); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
public void testHybridAnnotations() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@interface A {\n" + | |
"}\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface AUse {\n" + | |
"}\n" + | |
"@Target({ElementType.TYPE_USE, ElementType.PARAMETER})\n" + | |
"@interface AUseParameter {\n" + | |
"}\n" + | |
"@Target({ElementType.TYPE_USE, ElementType.LOCAL_VARIABLE})\n" + | |
"@interface AUseLocal {\n" + | |
"}\n" + | |
"@Target({ElementType.PARAMETER})\n" + | |
"@interface AParameter {\n" + | |
"}\n" + | |
"public class X { \n" + | |
" void foo(@A @AUse @AUseParameter @AUseLocal @AParameter X x) {\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 6, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(5); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
SingleVariableDeclaration parameter = (SingleVariableDeclaration) method.parameters().get(0); | |
IVariableBinding parameterBinding = parameter.resolveBinding(); | |
verifyAnnotationsOnBinding(parameterBinding, new String [] { "@A()", "@AUseParameter()", "@AParameter()" }); | |
ITypeBinding type = parameterBinding.getType(); | |
verifyAnnotationsOnBinding(type, new String [] { "@AUse()", "@AUseParameter()", "@AUseLocal()" }); | |
} | |
public void testGenericMethod() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.Annotation;\n" + | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
"}\n" + | |
"public class X { \n" + | |
" <N extends Annotation> @T String f(N a) {\n" + | |
" return null;\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
Type returnType = method.getReturnType2(); | |
ITypeBinding type = returnType.resolveBinding(); | |
verifyAnnotationsOnBinding(type, new String [] { "@T()" }); | |
} | |
public void testHybridAnnotations2() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.Target;\n" + | |
"import java.lang.annotation.ElementType;\n" + | |
"@Target({ ElementType.TYPE_USE, ElementType.METHOD })\n" + | |
"@interface SillyAnnotation { }\n" + | |
"public class X {\n" + | |
" @SillyAnnotation\n" + | |
" X(@SillyAnnotation int x) {\n" + | |
" }\n" + | |
" @SillyAnnotation\n" + | |
" void foo(@SillyAnnotation int x) {\n" + | |
" }\n" + | |
" @SillyAnnotation\n" + | |
" String goo(@SillyAnnotation int x) {\n" + | |
" return null;\n" + | |
" }\n" + | |
" @SillyAnnotation\n" + | |
" X field;\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 3, methods.length); | |
MethodDeclaration method = methods[0]; | |
List modifiers = method.modifiers(); | |
int size = modifiers.size(); | |
assertTrue("Should be just 1", size == 1); | |
MarkerAnnotation annotation = (MarkerAnnotation) modifiers.get(0); | |
assertEquals("Incorrect annotation", "@SillyAnnotation", annotation.toString()); | |
SingleVariableDeclaration parameter = (SingleVariableDeclaration) method.parameters().get(0); | |
IAnnotationBinding [] annotations = parameter.resolveBinding().getAnnotations(); | |
assertTrue("should be 0", annotations == null || annotations.length == 0); | |
IAnnotationBinding [] typeAnnotations = parameter.getType().resolveBinding().getTypeAnnotations(); | |
assertEquals("Incorrect annotation", "@SillyAnnotation()", typeAnnotations[0].toString()); | |
method = methods[1]; | |
modifiers = method.modifiers(); | |
size = modifiers.size(); | |
assertTrue("Should be just 1", size == 1); | |
annotation = (MarkerAnnotation) modifiers.get(0); | |
assertEquals("Incorrect annotation", "@SillyAnnotation", annotation.toString()); | |
typeAnnotations = method.getReturnType2().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be just 0", typeAnnotations.length == 0); | |
parameter = (SingleVariableDeclaration) method.parameters().get(0); | |
annotations = parameter.resolveBinding().getAnnotations(); | |
assertTrue("should be 0", annotations == null || annotations.length == 0); | |
typeAnnotations = parameter.getType().resolveBinding().getTypeAnnotations(); | |
assertEquals("Incorrect annotation", "@SillyAnnotation()", typeAnnotations[0].toString()); | |
method = methods[2]; | |
modifiers = method.modifiers(); | |
size = modifiers.size(); | |
assertTrue("Should be just 1", size == 1); | |
annotation = (MarkerAnnotation) modifiers.get(0); | |
assertEquals("Incorrect annotation", "@SillyAnnotation", annotation.toString()); | |
typeAnnotations = method.getReturnType2().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be just 1", typeAnnotations.length == 1); | |
assertEquals("Incorrect annotation", "@SillyAnnotation()", typeAnnotations[0].toString()); | |
parameter = (SingleVariableDeclaration) method.parameters().get(0); | |
annotations = parameter.resolveBinding().getAnnotations(); | |
assertTrue("should be 0", annotations == null || annotations.length == 0); | |
typeAnnotations = parameter.getType().resolveBinding().getTypeAnnotations(); | |
assertEquals("Incorrect annotation", "@SillyAnnotation()", typeAnnotations[0].toString()); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of fields", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
modifiers = field.modifiers(); | |
size = modifiers.size(); | |
assertTrue("Should be just 1", size == 1); | |
annotation = (MarkerAnnotation) modifiers.get(0); | |
assertEquals("Incorrect annotation", "@SillyAnnotation", annotation.toString()); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0); | |
annotations = fragment.resolveBinding().getAnnotations(); | |
assertTrue("Incorrect annotation", annotations == null || annotations.length == 0); | |
typeAnnotations = field.getType().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be just 1", typeAnnotations.length == 1); | |
assertEquals("Incorrect annotation", "@SillyAnnotation()", typeAnnotations[0].toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=419918, [1.8][compiler] Annotations are not restored from class files in a few situations. | |
public void testBinaryWithoutGenericSignature() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Superclass.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value() default 0;\n" + | |
"}\n" + | |
"@T(1)\n" + | |
"public abstract class Superclass extends @T(2) Object implements @T(3) Runnable {\n" + | |
" Object @T(4) [] field;\n" + | |
" @T(5)\n" + | |
" public String run(@T(6) Superclass this, Object @T(7) [] that) throws @T(8) NullPointerException {\n" + | |
" return null;\n" + | |
" }\n" + | |
" @T(9)\n" + | |
" Superclass () {}\n" + | |
" @T(10)\n" + | |
" class Inner {}\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"@T(21)\n" + | |
"public abstract class X extends @T(22) Superclass implements @T(23) Runnable {\n" + | |
" Object @T(24) [] field;\n" + | |
" @T(25)\n" + | |
" public String run(@T(26) X this, Object @T(27) [] that) throws @T(28) NullPointerException {\n" + | |
" return null;\n" + | |
" }\n" + | |
" @T(29)\n" + | |
" X() {\n" + | |
" }" + | |
" @T(30)\n" + | |
" class Inner {\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
ITypeBinding typeBinding = typeDecl.resolveBinding(); | |
IAnnotationBinding[] annotations = typeBinding.getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 21)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 22)", annotations[0].toString()); | |
annotations = typeBinding.getInterfaces()[0].getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 23)", annotations[0].toString()); | |
annotations = typeDecl.getFields()[0].getType().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 24)", annotations[0].toString()); | |
annotations = typeDecl.getMethods()[0].getReturnType2().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 25)", annotations[0].toString()); | |
annotations = typeDecl.getMethods()[0].getReceiverType().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 26)", annotations[0].toString()); | |
annotations = ((SingleVariableDeclaration) (typeDecl.getMethods()[0].parameters().get(0))).getType().resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 27)", annotations[0].toString()); | |
annotations = ((Type) typeDecl.getMethods()[0].thrownExceptionTypes().get(0)).resolveBinding().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 28)", annotations[0].toString()); | |
annotations = typeDecl.getMethods()[1].resolveBinding().getAnnotations(); | |
assertTrue("Should be 0", annotations.length == 0); | |
annotations = typeDecl.getTypes()[0].resolveBinding().getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 30)", annotations[0].toString()); | |
// Check the same set of things for the binary type. | |
annotations = typeBinding.getSuperclass().getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 1)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getSuperclass().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 2)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getInterfaces()[0].getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 3)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getDeclaredFields()[0].getType().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 4)", annotations[0].toString()); | |
// Skip past the constructor at [0] | |
annotations = typeBinding.getSuperclass().getDeclaredMethods()[1].getReturnType().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 5)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getDeclaredMethods()[1].getDeclaredReceiverType().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 6)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getDeclaredMethods()[1].getParameterTypes()[0].getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 7)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getDeclaredMethods()[1].getExceptionTypes()[0].getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 8)", annotations[0].toString()); | |
annotations = typeBinding.getSuperclass().getDeclaredMethods()[0].getAnnotations(); | |
assertTrue("Should be 0", annotations.length == 0); | |
annotations = typeBinding.getSuperclass().getDeclaredTypes()[0].getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 10)", annotations[0].toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
// Variants where superclass in binary is an annotated inner/nested class | |
public void testBinaryWithoutGenericSignature_b() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"Superclass.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value() default 0;\n" + | |
"}\n" + | |
"@T(1)\n" + | |
"public abstract class Superclass extends @T(2) Object implements @T(3) Runnable {\n" + | |
" @T(9)\n" + | |
" Superclass () {}\n" + | |
" @T(10)\n" + | |
" class Inner {}\n" + | |
" @T(11)\n" + | |
" class SubInner extends @T(12) Inner {}\n" + | |
" @T(13)\n" + | |
" static class Nested {}\n" + | |
" @T(14)\n" + | |
" static class SubNested extends @T(15) Nested {}\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"@T(21)\n" + | |
"public abstract class X extends @T(22) Superclass implements @T(23) Runnable {\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
ITypeBinding typeBinding = typeDecl.resolveBinding(); | |
IAnnotationBinding[] annotations = typeBinding.getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 21)", annotations[0].toString()); | |
ITypeBinding superclass = typeBinding.getSuperclass(); | |
ITypeBinding[] inners = superclass.getDeclaredTypes(); | |
assertTrue("Should be 2", inners.length == 4); | |
ITypeBinding subInner = inners[2]; | |
assertEquals("Type name mismatch", "SubInner", subInner.getName()); | |
annotations = subInner.getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 11)", annotations[0].toString()); | |
annotations = subInner.getSuperclass().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 12)", annotations[0].toString()); | |
ITypeBinding subNested = inners[3]; | |
annotations = subNested.getAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 14)", annotations[0].toString()); | |
annotations = subNested.getSuperclass().getTypeAnnotations(); | |
assertTrue("Should be 1", annotations.length == 1); | |
assertEquals("Annotation mismatch", "@T(value = 15)", annotations[0].toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=419918, [1.8][compiler] Annotations are not restored from class files in a few situations. | |
public void testBinaryAnnotationType() throws CoreException, IOException { | |
String jarName = "TypeBindingTests308.jar"; | |
String srcName = "TypeBindingTests308_src.zip"; | |
final IJavaProject javaProject = getJavaProject("Converter18"); | |
try { | |
String[] pathAndContents = new String[] { | |
"T.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Deprecated\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface T {\n" + | |
" int value() default 0;\n" + | |
"}\n" | |
}; | |
HashMap libraryOptions = new HashMap(javaProject.getOptions(true)); | |
libraryOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); | |
addLibrary(javaProject, jarName, srcName, pathAndContents, JavaCore.VERSION_1_8, libraryOptions); | |
String contents = | |
"@T\n" + | |
"public class X {\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 compilationUnit = (CompilationUnit) node; | |
assertProblemsSize(compilationUnit, 1, "The type T is deprecated"); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 1, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
ITypeBinding typeBinding = typeDecl.resolveBinding(); | |
IAnnotationBinding[] annotations = typeBinding.getAnnotations()[0].getAnnotationType().getAnnotations(); | |
assertTrue("Should be 2", annotations.length == 2); | |
assertEquals("Annotation mismatch", "@Target(value = {public static final java.lang.annotation.ElementType TYPE_USE})", annotations[0].toString()); | |
assertEquals("Annotation mismatch", "@Deprecated()", annotations[1].toString()); | |
} finally { | |
removeLibrary(javaProject, jarName, srcName); | |
} | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=420320, [1.8] Bad AST recovery with type annotation and a syntax error in secondary type | |
public void testAnnotationRecovery() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"import java.util.List;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface NonNull {\n" + | |
"}\n" + | |
"public class X {\n" + | |
" List<@NonNull String> list2;\n" + | |
"}\n" + | |
"class Y {\n" + | |
" void bar()\n" + | |
" void foo() { }\n" + | |
"}\n"; | |
String expected = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"import java.util.List;\n" + | |
"@Target(ElementType.TYPE_USE) @interface NonNull {}\n" + | |
"public class X {\n" + | |
" List<@NonNull String> list2;\n" + | |
"}\n" + | |
"class Y {\n" + | |
" void bar(){\n" + | |
" }\n" + | |
" void foo(){\n" + | |
" }\n" + | |
"}\n"; | |
this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); | |
ASTNode node = buildAST(contents, this.workingCopy, false, true); | |
assertEquals("AST mismatch", expected, node.toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=427337 | |
public void testBug427337() throws CoreException, IOException { | |
String contents = | |
"public class X implements I {\n" + | |
"}\n"; | |
createFile("/Converter18/src/NonNull.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface NonNull {}"); | |
createFile("/Converter18/src/I.java", | |
"import java.util.List;\n" + | |
"interface I { \n" + | |
" String bar2(@NonNull String s, @NonNull List<@NonNull String> l2);\n" + | |
"}"); | |
this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); | |
ASTNode node = buildAST(contents, this.workingCopy, false, true); | |
assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); | |
TypeDeclaration type = (TypeDeclaration) ((CompilationUnit) node).types().get(0); | |
ITypeBinding binding = type.resolveBinding(); | |
ITypeBinding superInterface = binding.getInterfaces()[0]; | |
IMethodBinding method = superInterface.getDeclaredMethods()[0]; | |
binding = method.getParameterTypes()[0]; | |
assertEquals("Incorrect type binding", "@NonNull String", binding.toString()); | |
binding = method.getParameterTypes()[1]; | |
assertEquals("Incorrect type binding", "@NonNull List<@NonNull String>", binding.toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=426515 | |
public void testBug426515() throws CoreException { | |
try { | |
String contents = | |
"public class X {\n" + | |
" void foo() {\n" + | |
" Outer.getInner();\n" + | |
" }\n" + | |
"}\n"; | |
createFile("/Converter18/src/A.java", | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface A { int value() default 0; \n }"); | |
createFile("/Converter18/src/Outer.java", | |
"class Outer<T> { \n" + | |
" public class Inner<I> {}\n" + | |
" public static @A(1) Outer<java.lang.@A(2) String>.@A(3) Inner<java.lang.@A(4) Object> getInner() { \n" + | |
" return null;\n" + | |
" }\n" + | |
"}"); | |
this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true); | |
ASTNode node = buildAST(contents, this.workingCopy, false, true); | |
assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType()); | |
TypeDeclaration type = (TypeDeclaration) ((CompilationUnit) node).types().get(0); | |
MethodDeclaration method = type.getMethods()[0]; | |
ExpressionStatement statement = (ExpressionStatement) method.getBody().statements().get(0); | |
MethodInvocation methodCal = (MethodInvocation) statement.getExpression(); | |
ITypeBinding binding = methodCal.resolveTypeBinding(); | |
assertEquals("Incorrect type binding", "@A((int)1) Outer<@A((int)2) String>.@A((int)3) Inner<@A((int)4) Object>", binding.toString()); | |
} finally { | |
deleteFile("/Converter18/src/A.java"); | |
deleteFile("/Converter18/src/Outer.java"); | |
} | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=425599, [1.8][compiler] ISE when trying to compile qualified and annotated class instance creation | |
public void test425599() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.ElementType;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"public class X {\n" + | |
" Object ax = new @A(1) Outer().new @A(2) Middle<@A(3) String>();\n" + | |
"}\n" + | |
"@Target(ElementType.TYPE_USE) @interface A { int value(); }\n" + | |
"class Outer {\n" + | |
" class Middle<E> {}\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 3, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
FieldDeclaration[] fields = typeDecl.getFields(); | |
assertEquals("Incorrect no of methods", 1, fields.length); | |
FieldDeclaration field = fields[0]; | |
assertEquals("Object ax=new @A(1) Outer().new @A(2) Middle<@A(3) String>();\n", field.toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=425216, Bug 425216 - [1.8][dom ast] Binding for 'this' should have type annotations when receiver is annotated | |
public void test425216() throws CoreException, IOException { | |
String contents = | |
"import static java.lang.annotation.ElementType.TYPE_USE;\n" + | |
"import java.lang.annotation.Target;\n" + | |
"@Target(TYPE_USE)\n" + | |
"@interface NonNull {}\n" + | |
"public class X {\n" + | |
" X foo(@NonNull X this) {\n" + | |
" return this;\n" + | |
" }\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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration[] methods = typeDecl.getMethods(); | |
assertEquals("Incorrect no of methods", 1, methods.length); | |
MethodDeclaration method = methods[0]; | |
ReturnStatement statement = (ReturnStatement) method.getBody().statements().get(0); | |
ThisExpression expression = (ThisExpression) statement.getExpression(); | |
ITypeBinding type = expression.resolveTypeBinding(); | |
assertEquals("@NonNull X", type.toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=425216, Bug 425216 - [1.8][dom ast] Binding for 'this' should have type annotations when receiver is annotated | |
public void test425216a() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.*;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface A {\n" + | |
" int value() default 0;\n" + | |
"}\n" + | |
"public class Outer {\n" + | |
" class Middle {\n" + | |
" class Inner {\n" + | |
" public @A(1) Inner(@A(2) Outer.@A(3) Middle Middle.this) {\n" + | |
" Outer r1 = Outer.this;\n" + | |
" Outer.Middle middle = Outer.Middle.this;\n" + | |
" Inner i = this;\n" + | |
" }\n" + | |
" }\n" + | |
" }\n" + | |
"}\n"; | |
this.workingCopy = getWorkingCopy("/Converter18/src/Outer.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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration method= typeDecl.getTypes()[0].getTypes()[0].getMethods()[0]; | |
ITypeBinding receiverType = method.getReceiverType().resolveBinding(); | |
assertEquals("@A((int)2) Outer.@A((int)3) Middle", receiverType.toString()); | |
ITypeBinding declaringClass = receiverType.getDeclaringClass(); | |
assertEquals("@A((int)2) Outer", declaringClass.toString()); | |
final List statements = method.getBody().statements(); | |
VariableDeclarationStatement statement = ((VariableDeclarationStatement) statements.get(0)); | |
VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
ITypeBinding type = fragment.getInitializer().resolveTypeBinding(); | |
assertEquals("@A((int)2) Outer", type.toString()); | |
statement = ((VariableDeclarationStatement) statements.get(1)); | |
fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
type = fragment.getInitializer().resolveTypeBinding(); | |
assertEquals("@A((int)2) Outer.@A((int)3) Middle", type.toString()); | |
assertEquals("@A((int)2) Outer", type.getDeclaringClass().toString()); | |
statement = ((VariableDeclarationStatement) statements.get(2)); | |
fragment = (VariableDeclarationFragment) statement.fragments().get(0); | |
type = fragment.getInitializer().resolveTypeBinding(); | |
assertTrue(type.getTypeAnnotations().length == 0); | |
assertTrue(type.getName().equals("Inner")); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=425216, Bug 425216 - [1.8][dom ast] Binding for 'this' should have type annotations when receiver is annotated | |
public void test425216b() throws CoreException, IOException { | |
String contents = | |
"import java.lang.annotation.*;\n" + | |
"@Target(ElementType.TYPE_USE)\n" + | |
"@interface A {\n" + | |
" int value() default 0;\n" + | |
"}\n" + | |
"public class Outer {\n" + | |
" class Middle {\n" + | |
" class Inner {\n" + | |
" public @A(1) Inner(@A(2) Outer.@A(3) Middle Middle.this) {\n" + | |
" }\n" + | |
" }\n" + | |
" }\n" + | |
"}\n"; | |
this.workingCopy = getWorkingCopy("/Converter18/src/Outer.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); | |
List types = compilationUnit.types(); | |
assertEquals("Incorrect no of types", 2, types.size()); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(1); | |
MethodDeclaration method= typeDecl.getTypes()[0].getTypes()[0].getMethods()[0]; | |
SimpleName receiverQualifier = method.getReceiverQualifier(); | |
ITypeBinding type = receiverQualifier.resolveTypeBinding(); | |
assertEquals("@A((int)2) Outer.@A((int)3) Middle", type.toString()); | |
} | |
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=427320 | |
public void testBug427320() throws Exception { | |
try { | |
String contents = | |
"public class X {\n" + | |
" @A @B @C X() {}\n" + | |
" @A @B @C String foo() {\nreturn null;\n}\n" + | |
"}\n" + | |
"@java.lang.annotation.Target ({java.lang.annotation.ElementType.CONSTRUCTOR, " | |
+ "java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.TYPE_USE})\n" + | |
"@interface A {}\n" + | |
"@java.lang.annotation.Target ({java.lang.annotation.ElementType.CONSTRUCTOR, " | |
+ "java.lang.annotation.ElementType.METHOD})\n" + | |
"@interface B {}\n" + | |
"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" + | |
"@interface C {}\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); | |
List types = compilationUnit.types(); | |
TypeDeclaration typeDecl = (TypeDeclaration) types.get(0); | |
MethodDeclaration method = typeDecl.getMethods()[0]; | |
assertTrue("Should be a constructor", method.isConstructor()); | |
IMethodBinding methodBinding = method.resolveBinding(); | |
IAnnotationBinding[] annots = methodBinding.getAnnotations(); | |
assertEquals("Incorrect no of annotations", 2, annots.length); | |
assertEquals("Incorrect annotations attached","@A()", annots[0].toString()); | |
assertEquals("Incorrect annotations attached","@B()", annots[1].toString()); | |
ITypeBinding binding = methodBinding.getReturnType(); | |
annots = binding.getTypeAnnotations(); | |
assertEquals("Incorrect no of annotations", 0, annots.length); | |
method = typeDecl.getMethods()[1]; | |
methodBinding = method.resolveBinding(); | |
annots = methodBinding.getAnnotations(); | |
assertEquals("Incorrect no of annotations", 2, annots.length); | |
assertEquals("Incorrect annotations attached","@A()", annots[0].toString()); | |
assertEquals("Incorrect annotations attached","@B()", annots[1].toString()); | |
binding = methodBinding.getReturnType(); | |
annots = binding.getTypeAnnotations(); | |
assertEquals("Incorrect no of annotations", 2, annots.length); | |
assertEquals("Incorrect annotations attached","@A @C String", binding.toString()); | |
} finally { | |
deleteFile("/Converter18/src/X.java"); | |
} | |
} | |
} |