/*******************************************************************************
* Copyright (c) 2011, 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
* Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contributions for
* Bug 415541 - [1.8][compiler] Type annotations in the body of static initializer get dropped
* Bug 415543 - [1.8][compiler] Incorrect bound index in RuntimeInvisibleTypeAnnotations attribute
* Bug 415397 - [1.8][compiler] Type Annotations on wildcard type argument dropped
* Bug 415399 - [1.8][compiler] Type annotations on constructor results dropped by the code generator
* Bug 415470 - [1.8][compiler] Type annotations on class declaration go vanishing
* Bug 414384 - [1.8] type annotation on abbreviated inner class is not marked as inner type
* Jesper S Moller - Contributions for
* Bug 416885 - [1.8][compiler]IncompatibleClassChange error (edit)
*******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;
import java.io.File;
import java.util.Map;
import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import junit.framework.Test;
@SuppressWarnings({ "unchecked", "rawtypes" })
public class JSR308SpecSnippetTests extends AbstractRegressionTest {
static {
// TESTS_NUMBERS = new int [] { 19 };
// TESTS_NAMES = new String [] { "test033" };
}
public static Class testClass() {
return JSR308SpecSnippetTests.class;
}
public static Test suite() {
return buildMinimalComplianceTestSuite(testClass(), F_1_8);
}
public JSR308SpecSnippetTests(String testName){
super(testName);
}
// Enables the tests to run individually
protected Map getCompilerOptions() {
Map defaultOptions = super.getCompilerOptions();
defaultOptions.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_8);
defaultOptions.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_8);
defaultOptions.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_8);
return defaultOptions;
}
public void test001() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.util.Map;\n" +
"import java.util.List;\n" +
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class Document {}\n" +
"public class X {\n" +
" Map<@NonNull String, @NonEmpty List<@Readonly Document>> files;\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @NonNull(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #11 @NonEmpty(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #12 @Readonly(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1), TYPE_ARGUMENT(0)]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// note, javac 8b100 emits offset incorrectly.
public void test002() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class Document {}\n" +
"public class X {\n" +
" static void foo(X o) {\n" +
" o.<@NonNull String>m(\"...\");\n" +
" }\n" +
" <T> void m(String s) {}\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x49 METHOD_INVOCATION_TYPE_ARGUMENT\n" +
" offset = 3\n" +
" type argument index = 0\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test003() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.Collection;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Existing {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class File {}\n" +
"class X<F extends @Existing File> { \n" +
" Collection<? super @Existing File> c;\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Existing(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), WILDCARD]\n" +
" )\n" +
" \n" +
" // Method descriptor #12 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [14]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 11]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X<F>\n" +
"\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Existing(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 0\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test004() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.List;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Existing {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class File {}\n" +
"abstract class X<T> implements @Readonly List<@Readonly T> { }\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #23 @Readonly(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" )\n" +
" #23 @Readonly(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test005() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.List;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Critical {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class TemperatureException extends RuntimeException{}\n" +
"class X {\n" +
" void monitorTemperature() throws @Critical TemperatureException {}\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @Critical(\n" +
" target type = 0x17 THROWS\n" +
" throws index = 0\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test006() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Interned {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Tainted {}\n" +
"class MyObject {\n" +
" class NestedClass {}\n" +
"}\n" +
"class List<T> {}\n" +
"class X {\n" +
" static void monitorTemperature(MyObject myVar) {\n" +
" new <String> @Interned MyObject();\n" +
" new @NonEmpty @Readonly List<String>();\n" +
" myVar.new @Tainted NestedClass();\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #33 @Interned(\n" +
" target type = 0x44 NEW\n" +
" offset = 0\n" +
" )\n" +
" #34 @NonEmpty(\n" +
" target type = 0x44 NEW\n" +
" offset = 6\n" +
" )\n" +
" #35 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 6\n" +
" )\n" +
" #36 @Tainted(\n" +
" target type = 0x44 NEW\n" +
" offset = 12\n" +
" location = [INNER_TYPE]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test007() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.Map;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Tainted {}\n" +
"class MyObject {\n" +
" class NestedClass {}\n" +
"}\n" +
"class List<T> {}\n" +
"class X {\n" +
" Map.@NonNull Entry e;\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @NonNull(\n" +
" target type = 0x13 FIELD\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test008() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface A {}\n" +
"@Target(TYPE_USE)\n" +
"@interface B {}\n" +
"class MyObject {\n" +
" class NestedClass {}\n" +
"}\n" +
"class List<T> {}\n" +
"class Type1 {}\n" +
"interface Type2 {}\n" +
"class X {\n" +
" static void monitorTemperature(Object myObject) {\n" +
" String myString = (@NonNull String) myObject;\n" +
" Type1 x = (@A Type1 & @B Type2) null;\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #29 @NonNull(\n" +
" target type = 0x47 CAST\n" +
" offset = 1\n" +
" type argument index = 0\n" +
" )\n" +
" #30 @B(\n" +
" target type = 0x47 CAST\n" +
" offset = 6\n" +
" type argument index = 1\n" +
" )\n" +
" #31 @A(\n" +
" target type = 0x47 CAST\n" +
" offset = 9\n" +
" type argument index = 0\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test009() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface A {}\n" +
"@Target(TYPE_USE)\n" +
"@interface B {}\n" +
"class MyObject {\n" +
" class NestedClass {}\n" +
"}\n" +
"class List<T> {}\n" +
"class Type1 {}\n" +
"interface Type2 {}\n" +
"class X {\n" +
" static void monitorTemperature(Object myObject) {\n" +
" boolean isNonNull = myObject instanceof @NonNull String;\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #23 @NonNull(\n" +
" target type = 0x43 INSTANCEOF\n" +
" offset = 1\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test010() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.Arrays;\n" +
"import java.util.Date;\n" +
"import java.util.List;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"@Target(TYPE_USE)\n" +
"@interface English {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Vernal {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonNegative {}\n" +
"class MyObject {\n" +
" class NestedClass {}\n" +
"}\n" +
"class Type1 {}\n" +
"interface I {\n" +
" int f(Date d);\n" +
"}\n" +
"interface J {\n" +
" int f(List l);\n" +
"}\n" +
"interface K {\n" +
" void s(int [] ia);\n" +
"}\n" +
"class X {\n" +
" static void monitorTemperature(Object myObject) {\n" +
" I i = @Vernal Date::getDay;\n" +
" J j = List<@English String>::size;\n" +
" K k = Arrays::<@NonNegative Integer>sort;\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #36 @Vernal(\n" +
" target type = 0x46 METHOD_REFERENCE\n" +
" offset = 0\n" +
" )\n" +
" #37 @English(\n" +
" target type = 0x46 METHOD_REFERENCE\n" +
" offset = 6\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #38 @NonNegative(\n" +
" target type = 0x4b METHOD_REFERENCE_TYPE_ARGUMENT\n" +
" offset = 12\n" +
" type argument index = 0\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test011() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.*;\n" +
"import java.io.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Immutable { int value() default 0; }\n" +
"class X {\n" +
" List<@Immutable ? extends Comparable<X>> a;\n" +
" List<? extends @Immutable Comparable<X>> b;\n" +
" List<@Immutable(1) ? extends @Immutable(2) Comparable<X>> c;\n" +
" Map<@Immutable(1) ? extends Comparable<X>,@Immutable(2) ? extends @Immutable(3) Serializable> d;\n" +
"}\n",
},
"");
// javac b100
// Field a:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): FIELD, location=[TYPE_ARGUMENT(0)]
// Field b:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): FIELD, location=[TYPE_ARGUMENT(0), WILDCARD]
// Field c:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(#12=I#13): FIELD, location=[TYPE_ARGUMENT(0)]
// 1: #9(#12=I#14): FIELD, location=[TYPE_ARGUMENT(0), WILDCARD]
// Field d:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(#12=I#13): FIELD, location=[TYPE_ARGUMENT(0)]
// 1: #9(#12=I#14): FIELD, location=[TYPE_ARGUMENT(1)]
// 2: #9(#12=I#18): FIELD, location=[TYPE_ARGUMENT(1), WILDCARD]
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"a\"\n" +
" constant #6 utf8: \"Ljava/util/List;\"\n" +
" constant #7 utf8: \"Signature\"\n" +
" constant #8 utf8: \"Ljava/util/List<+Ljava/lang/Comparable<LX;>;>;\"\n" +
" constant #9 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #10 utf8: \"LImmutable;\"\n" +
" constant #11 utf8: \"b\"\n" +
" constant #12 utf8: \"c\"\n" +
" constant #13 utf8: \"value\"\n" +
" constant #14 integer: 1\n" +
" constant #15 integer: 2\n" +
" constant #16 utf8: \"d\"\n" +
" constant #17 utf8: \"Ljava/util/Map;\"\n" +
" constant #18 utf8: \"Ljava/util/Map<+Ljava/lang/Comparable<LX;>;+Ljava/io/Serializable;>;\"\n" +
" constant #19 integer: 3\n" +
" constant #20 utf8: \"<init>\"\n" +
" constant #21 utf8: \"()V\"\n" +
" constant #22 utf8: \"Code\"\n" +
" constant #23 method_ref: #3.#24 java/lang/Object.<init> ()V\n" +
" constant #24 name_and_type: #20.#21 <init> ()V\n" +
" constant #25 utf8: \"LineNumberTable\"\n" +
" constant #26 utf8: \"LocalVariableTable\"\n" +
" constant #27 utf8: \"this\"\n" +
" constant #28 utf8: \"LX;\"\n" +
" constant #29 utf8: \"SourceFile\"\n" +
" constant #30 utf8: \"X.java\"\n" +
" \n" +
" // Field descriptor #6 Ljava/util/List;\n" +
" // Signature: Ljava/util/List<+Ljava/lang/Comparable<LX;>;>;\n" +
" java.util.List a;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Immutable(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" \n" +
" // Field descriptor #6 Ljava/util/List;\n" +
" // Signature: Ljava/util/List<+Ljava/lang/Comparable<LX;>;>;\n" +
" java.util.List b;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Immutable(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), WILDCARD]\n" +
" )\n" +
" \n" +
" // Field descriptor #6 Ljava/util/List;\n" +
" // Signature: Ljava/util/List<+Ljava/lang/Comparable<LX;>;>;\n" +
" java.util.List c;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Immutable(\n" +
" #13 value=(int) 1 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #10 @Immutable(\n" +
" #13 value=(int) 2 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), WILDCARD]\n" +
" )\n" +
" \n" +
" // Field descriptor #17 Ljava/util/Map;\n" +
" // Signature: Ljava/util/Map<+Ljava/lang/Comparable<LX;>;+Ljava/io/Serializable;>;\n" +
" java.util.Map d;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @Immutable(\n" +
" #13 value=(int) 1 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #10 @Immutable(\n" +
" #13 value=(int) 2 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #10 @Immutable(\n" +
" #13 value=(int) 3 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1), WILDCARD]\n" +
" )\n" +
" \n" +
" // Method descriptor #21 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [23]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test012() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class Document {}\n" +
"class X {\n" +
" @Readonly Document [][] docs1 = new @Readonly Document [2][12]; // array of arrays of read-only documents\n" +
" Document @Readonly [][] docs2 = new Document @Readonly [2][12]; // read-only array of arrays of documents\n" +
" Document[] @Readonly [] docs3 = new Document[2] @Readonly [12]; // array of read-only arrays of documents\n" +
"}\n",
},
"");
String expectedOutput =
" Document[][] docs1;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @Readonly(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY, ARRAY]\n" +
" )\n" +
" \n" +
" // Field descriptor #6 [[LDocument;\n" +
" Document[][] docs2;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @Readonly(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" \n" +
" // Field descriptor #6 [[LDocument;\n" +
" Document[][] docs3;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @Readonly(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY]\n" +
" )\n" +
" \n" +
" // Method descriptor #12 ()V\n" +
" // Stack: 3, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [14]\n" +
" 4 aload_0 [this]\n" +
" 5 iconst_2\n" +
" 6 bipush 12\n" +
" 8 multianewarray Document[][] [16]\n" +
" 12 putfield X.docs1 : Document[][] [17]\n" +
" 15 aload_0 [this]\n" +
" 16 iconst_2\n" +
" 17 bipush 12\n" +
" 19 multianewarray Document[][] [16]\n" +
" 23 putfield X.docs2 : Document[][] [19]\n" +
" 26 aload_0 [this]\n" +
" 27 iconst_2\n" +
" 28 bipush 12\n" +
" 30 multianewarray Document[][] [16]\n" +
" 34 putfield X.docs3 : Document[][] [21]\n" +
" 37 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 6]\n" +
" [pc: 4, line: 7]\n" +
" [pc: 15, line: 8]\n" +
" [pc: 26, line: 9]\n" +
" [pc: 37, line: 6]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 38] local: this index: 0 type: X\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 8\n" +
" location = [ARRAY, ARRAY]\n" +
" )\n" +
" #8 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 19\n" +
" )\n" +
" #8 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 30\n" +
" location = [ARRAY]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test013() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Immutable {}\n" +
"class Document {}\n" +
"class X {\n" +
" @Immutable X() {\n" +
" }\n" +
"}\n",
},
"");
// javac b100 gives:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): METHOD_RETURN
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #15 utf8: \"LImmutable;\"\n" +
" constant #16 utf8: \"SourceFile\"\n" +
" constant #17 utf8: \"X.java\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" [pc: 4, line: 8]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #15 @Immutable(\n" +
" target type = 0x14 METHOD_RETURN\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test014() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Immutable {}\n" +
"class Document {}\n" +
"interface I {\n" +
" void foo();\n" +
"}\n" +
"class X {\n" +
" void foo (X this, X this) {\n" +
" }\n" +
" static void foo (X this) {\n" +
" }\n" +
" I i = (X this) -> {};\n" +
"}\n" +
"class Y<T> {\n" +
" void foo(X this) {}\n" +
" void foo(Y this, int x) {}\n" +
" class Z {\n" +
" void foo(Y<T>.Z this) {}\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 10)\n" +
" void foo (X this, X this) {\n" +
" ^^^^\n" +
"Only the first formal parameter may be declared explicitly as \'this\'\n" +
"----------\n" +
"2. ERROR in X.java (at line 12)\n" +
" static void foo (X this) {\n" +
" ^^^^\n" +
"Explicit \'this\' parameter is allowed only in instance methods of non-anonymous classes and inner class constructors\n" +
"----------\n" +
"3. ERROR in X.java (at line 14)\n" +
" I i = (X this) -> {};\n" +
" ^^^^^^^^^^^\n" +
"Lambda expression\'s signature does not match the signature of the functional interface method foo()\n" +
"----------\n" +
"4. ERROR in X.java (at line 14)\n" +
" I i = (X this) -> {};\n" +
" ^^^^\n" +
"Lambda expressions cannot declare a this parameter\n" +
"----------\n" +
"5. ERROR in X.java (at line 17)\n" +
" void foo(X this) {}\n" +
" ^\n" +
"The declared type of the explicit \'this\' parameter is expected to be Y<T>\n" +
"----------\n" +
"6. WARNING in X.java (at line 18)\n" +
" void foo(Y this, int x) {}\n" +
" ^\n" +
"Y is a raw type. References to generic type Y<T> should be parameterized\n" +
"----------\n" +
"7. ERROR in X.java (at line 18)\n" +
" void foo(Y this, int x) {}\n" +
" ^\n" +
"The declared type of the explicit \'this\' parameter is expected to be Y<T>\n" +
"----------\n");
}
public void test015() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Immutable {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class Document {}\n" +
"interface I {\n" +
" void foo();\n" +
"}\n" +
"class X {\n" +
" class Y {\n" +
" void foo(@Immutable X.@Readonly Y this) {\n" +
" }\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @Immutable(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" )\n" +
" #22 @Readonly(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" location = [INNER_TYPE]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$Y.class", "Y", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test016() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface A {}\n" +
"@Target(TYPE_USE)\n" +
"@interface B {}\n" +
"@Target(TYPE_USE)\n" +
"@interface C {}\n" +
"public class X {}\n" +
"class Outer {\n" +
" class Middle {\n" +
" class Inner {\n" +
" void innerMethod(@A Outer.@B Middle.@C Inner this) { }\n" +
" }\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @A(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" )\n" +
" #22 @B(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" #23 @C(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" location = [INNER_TYPE, INNER_TYPE]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "Outer$Middle$Inner.class", "Inner", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test017() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Result {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Receiver {}\n" +
"class Document {}\n" +
"interface I {\n" +
" void foo();\n" +
"}\n" +
"class X {\n" +
" class Y {\n" +
" Y(@Receiver X X.this, boolean b) { }\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #22 @Receiver(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$Y.class", "Y", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test018() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@interface Receiver {}\n" +
"class Document {}\n" +
"interface I {\n" +
" void foo();\n" +
"}\n" +
"class X {\n" +
" void foo(@Receiver X this) {}\n" +
" class Y {\n" +
" Y(@Receiver X X.this, boolean b) { }\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 9)\n" +
" void foo(@Receiver X this) {}\n" +
" ^^^^^^^^^\n" +
"Annotation types that do not specify explicit target element types cannot be applied here\n" +
"----------\n" +
"2. ERROR in X.java (at line 11)\n" +
" Y(@Receiver X X.this, boolean b) { }\n" +
" ^^^^^^^^^\n" +
"Annotation types that do not specify explicit target element types cannot be applied here\n" +
"----------\n");
}
public void test019() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class X<@Readonly T> {\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @Readonly(\n" +
" target type = 0x0 CLASS_TYPE_PARAMETER\n" +
" type parameter index = 0\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test020() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.util.@NotAllowed Date; // illegal!\n" +
"import @IllegalSyntax java.util.Date; // illegal syntax\n" +
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Even {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NotAllowed {}\n" +
"@Target(TYPE_USE)\n" +
"@interface IllegalSyntax {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Legal {}\n" +
"class X {\n" +
" static int staticField;\n" +
" static class StaticNestedClass {}\n" +
" void foo() {\n" +
" Object o = @Even int.class; // illegal!\n" +
" o = int @NonEmpty [].class; // illegal!\n" +
" int x = @IllegalSyntax X.staticField;\n" +
" StaticNestedClass snc = (@IllegalSyntax X.StaticNestedClass) null;\n" +
" X.@Legal StaticNestedClass lsnc = (X.@Legal StaticNestedClass) null;\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 1)\n" +
" import java.util.@NotAllowed Date; // illegal!\n" +
" ^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"2. ERROR in X.java (at line 2)\n" +
" import @IllegalSyntax java.util.Date; // illegal syntax\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"3. WARNING in X.java (at line 2)\n" +
" import @IllegalSyntax java.util.Date; // illegal syntax\n" +
" ^^^^^^^^^^^^^^\n" +
"The import java.util.Date is never used\n" +
"----------\n" +
"4. ERROR in X.java (at line 19)\n" +
" Object o = @Even int.class; // illegal!\n" +
" ^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"5. WARNING in X.java (at line 20)\n" +
" o = int @NonEmpty [].class; // illegal!\n" +
" ^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"6. ERROR in X.java (at line 21)\n" +
" int x = @IllegalSyntax X.staticField;\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"7. ERROR in X.java (at line 22)\n" +
" StaticNestedClass snc = (@IllegalSyntax X.StaticNestedClass) null;\n" +
" ^^^^^^^^^^^^^^\n" +
"Type annotations are not allowed on type names used to access static members\n" +
"----------\n");
}
public void test021() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.util.@NotAllowed Date; // illegal!\n" +
"import @IllegalSyntax java.util.Date; // illegal syntax\n" +
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Even {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NonEmpty {}\n" +
"@Target(TYPE_USE)\n" +
"@interface NotAllowed {}\n" +
"@Target(TYPE_USE)\n" +
"@interface IllegalSyntax {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Legal {}\n" +
"interface I {\n" +
" int f(Y y);\n" +
"}\n" +
"class Y {\n" +
" int f;\n" +
" int x(Y y) {}\n" +
"}\n" +
"class X extends Y {\n" +
" static int staticField;\n" +
" static class StaticNestedClass {}\n" +
" void foo() {\n" +
" Object o = @Even int.class; // illegal!\n" +
" o = int @NonEmpty [].class; // illegal!\n" +
" int x = @IllegalSyntax X.staticField;\n" +
" StaticNestedClass snc = (@IllegalSyntax X.StaticNestedClass) null;\n" +
" X.@Legal StaticNestedClass lsnc = (X.@Legal StaticNestedClass) null;\n" +
" int x2 = @IllegalSyntax X.super.f;\n" +
" I i = @IllegalSyntax X.super::x;\n" +
" }\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 1)\n" +
" import java.util.@NotAllowed Date; // illegal!\n" +
" ^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"2. ERROR in X.java (at line 2)\n" +
" import @IllegalSyntax java.util.Date; // illegal syntax\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"3. WARNING in X.java (at line 2)\n" +
" import @IllegalSyntax java.util.Date; // illegal syntax\n" +
" ^^^^^^^^^^^^^^\n" +
"The import java.util.Date is never used\n" +
"----------\n" +
"4. ERROR in X.java (at line 26)\n" +
" Object o = @Even int.class; // illegal!\n" +
" ^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"5. WARNING in X.java (at line 27)\n" +
" o = int @NonEmpty [].class; // illegal!\n" +
" ^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"6. ERROR in X.java (at line 28)\n" +
" int x = @IllegalSyntax X.staticField;\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"7. ERROR in X.java (at line 29)\n" +
" StaticNestedClass snc = (@IllegalSyntax X.StaticNestedClass) null;\n" +
" ^^^^^^^^^^^^^^\n" +
"Type annotations are not allowed on type names used to access static members\n" +
"----------\n" +
"8. ERROR in X.java (at line 31)\n" +
" int x2 = @IllegalSyntax X.super.f;\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n" +
"9. ERROR in X.java (at line 32)\n" +
" I i = @IllegalSyntax X.super::x;\n" +
" ^^^^^^^^^^^^^^\n" +
"Syntax error, type annotations are illegal here\n" +
"----------\n");
}
public void test022() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"class X {\n" +
" @Readonly int foo() @Readonly [] {\n" +
" return null;\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #17 @Readonly(\n" +
" target type = 0x14 METHOD_RETURN\n" +
" location = [ARRAY]\n" +
" )\n" +
" #17 @Readonly(\n" +
" target type = 0x14 METHOD_RETURN\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test023() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"interface X {\n" +
" default @Readonly int foo() @Readonly [] {\n" +
" return null;\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #13 @Readonly(\n" +
" target type = 0x14 METHOD_RETURN\n" +
" location = [ARRAY]\n" +
" )\n" +
" #13 @Readonly(\n" +
" target type = 0x14 METHOD_RETURN\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test024() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Critical {}\n" +
"class X {\n" +
" void foo() {\n" +
" try {\n" +
" System.out.println();\n" +
" } catch (@Readonly NullPointerException | @Critical ArrayIndexOutOfBoundsException e) {\n" +
" }\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #34 @Readonly(\n" +
" target type = 0x42 EXCEPTION_PARAMETER\n" +
" exception table index = 0\n" +
" )\n" +
" #35 @Critical(\n" +
" target type = 0x42 EXCEPTION_PARAMETER\n" +
" exception table index = 1\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test025() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Critical {}\n" +
"class X {\n" +
" void foo(@Readonly int [] [] @Critical ... x) {\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @Readonly(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [ARRAY, ARRAY, ARRAY]\n" +
" )\n" +
" #20 @Critical(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [ARRAY, ARRAY]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test026() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface Readonly {}\n" +
"@Target(TYPE_USE)\n" +
"@interface Critical {}\n" +
"class X {\n" +
" void foo(@Readonly int [] [] @Critical ... x) {\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @Readonly(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [ARRAY, ARRAY, ARRAY]\n" +
" )\n" +
" #20 @Critical(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [ARRAY, ARRAY]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test027() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"class X {\n" +
" @NonNull String var1, arr2[];\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @NonNull(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" \n" +
" // Field descriptor #10 [Ljava/lang/String;\n" +
" java.lang.String[] arr2;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @NonNull(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test028() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.List;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target(TYPE_USE)\n" +
"@interface NonNull {}\n" +
"class X<@NonNull T> {\n" +
" <@NonNull K> void foo() {}\n" +
" List<@NonNull ?> l;\n" +
"}\n",
},
"");
// javac b100
// On the type declaration:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): CLASS_TYPE_PARAMETER, param_index=0
// On the method:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): METHOD_TYPE_PARAMETER, param_index=0
// On the field:
// RuntimeInvisibleTypeAnnotations:
// 0: #9(): FIELD, location=[TYPE_ARGUMENT(0)]
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"// Signature: <T:Ljava/lang/Object;>Ljava/lang/Object;\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"l\"\n" +
" constant #6 utf8: \"Ljava/util/List;\"\n" +
" constant #7 utf8: \"Signature\"\n" +
" constant #8 utf8: \"Ljava/util/List<*>;\"\n" +
" constant #9 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #10 utf8: \"LNonNull;\"\n" +
" constant #11 utf8: \"<init>\"\n" +
" constant #12 utf8: \"()V\"\n" +
" constant #13 utf8: \"Code\"\n" +
" constant #14 method_ref: #3.#15 java/lang/Object.<init> ()V\n" +
" constant #15 name_and_type: #11.#12 <init> ()V\n" +
" constant #16 utf8: \"LineNumberTable\"\n" +
" constant #17 utf8: \"LocalVariableTable\"\n" +
" constant #18 utf8: \"this\"\n" +
" constant #19 utf8: \"LX;\"\n" +
" constant #20 utf8: \"LocalVariableTypeTable\"\n" +
" constant #21 utf8: \"LX<TT;>;\"\n" +
" constant #22 utf8: \"foo\"\n" +
" constant #23 utf8: \"<K:Ljava/lang/Object;>()V\"\n" +
" constant #24 utf8: \"SourceFile\"\n" +
" constant #25 utf8: \"X.java\"\n" +
" constant #26 utf8: \"<T:Ljava/lang/Object;>Ljava/lang/Object;\"\n" +
" \n" +
" // Field descriptor #6 Ljava/util/List;\n" +
" // Signature: Ljava/util/List<*>;\n" +
" java.util.List l;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @NonNull(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" \n" +
" // Method descriptor #12 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [14]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 6]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X<T>\n" +
" \n" +
" // Method descriptor #12 ()V\n" +
" // Signature: <K:Ljava/lang/Object;>()V\n" +
" // Stack: 0, Locals: 1\n" +
" void foo();\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @NonNull(\n" +
" target type = 0x1 METHOD_TYPE_PARAMETER\n" +
" type parameter index = 0\n" +
" )\n" +
"\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @NonNull(\n" +
" target type = 0x0 CLASS_TYPE_PARAMETER\n" +
" type parameter index = 0\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test029() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface TAnno { }\n" +
"@Target({METHOD}) @interface MAnno { }\n" +
"@Target({METHOD, TYPE_USE}) @interface MTAnno { }\n" +
"@Target({FIELD}) @interface FAnno { }\n" +
"@Target({FIELD, TYPE_USE}) @interface FTAnno { }\n" +
"class X {\n" +
"@FAnno Object field4; // legal, one field annotation\n" +
"@TAnno Object field5; // legal, one type annotation\n" +
"@FTAnno Object field6; // legal, one field annotation and one type annotation\n" +
"@FAnno java.lang.Object field7; // legal, one field annotation\n" +
"@TAnno java.lang.Object field8; // illegal\n" +
"@FTAnno java.lang.Object field9; // legal, one field annotation\n" +
"java.lang. @FAnno Object field10; // illegal\n" +
"java.lang. @TAnno Object field11; // legal, one type annotation\n" +
"java.lang. @FTAnno Object field12; // legal, one type annotation\n" +
"@MAnno void myMethod1() { } // legal, one method annotation\n" +
"@TAnno void myMethod2() { } // illegal\n" +
"@MTAnno void myMethod3() { } // legal, one method annotation\n" +
"@MAnno Object myMethod4() { } // legal, one method annotation\n" +
"@TAnno Object myMethod5() { } // legal, one type annotation\n" +
"@MTAnno Object myMethod6() { } // legal, one method annotation and one type annotation\n" +
"@MAnno java.lang.Object myMethod7() { } // legal, one method annotation\n" +
"@TAnno java.lang.Object myMethod8() { } // illegal\n" +
"@MTAnno java.lang.Object myMethod9() { } // legal, one method annotation\n" +
"java.lang. @MAnno Object myMethod10() { } // illegal\n" +
"java.lang. @TAnno Object myMethod11() { } // legal, one type annotation\n" +
"java.lang. @MTAnno Object myMethod12() { } // legal, one type annotation\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 13)\n" +
" @TAnno java.lang.Object field8; // illegal\n" +
" ^^^^^^\n" +
"Illegally placed annotation: type annotations must directly precede the simple name of the type they are meant to affect (or the [] for arrays)\n" +
"----------\n" +
"2. ERROR in X.java (at line 15)\n" +
" java.lang. @FAnno Object field10; // illegal\n" +
" ^^^^^^\n" +
"The annotation @FAnno is disallowed for this location\n" +
"----------\n" +
"3. ERROR in X.java (at line 19)\n" +
" @TAnno void myMethod2() { } // illegal\n" +
" ^^^^^^\n" +
"Type annotation is illegal for a method that returns void\n" +
"----------\n" +
"4. ERROR in X.java (at line 25)\n" +
" @TAnno java.lang.Object myMethod8() { } // illegal\n" +
" ^^^^^^\n" +
"Illegally placed annotation: type annotations must directly precede the simple name of the type they are meant to affect (or the [] for arrays)\n" +
"----------\n" +
"5. ERROR in X.java (at line 27)\n" +
" java.lang. @MAnno Object myMethod10() { } // illegal\n" +
" ^^^^^^\n" +
"The annotation @MAnno is disallowed for this location\n" +
"----------\n");
}
public void test030() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface TypeAnnotation { }\n" +
"@Target({TYPE}) @interface Annotation { }\n" +
"@Annotation @TypeAnnotation class X {\n" +
"}\n",
},
"");
// javac b100 produces:
// RuntimeInvisibleAnnotations:
// 0: #11() LAnnotation;
// 1: #12() LTypeAnnotation;
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"SourceFile\"\n" +
" constant #15 utf8: \"X.java\"\n" +
" constant #16 utf8: \"RuntimeInvisibleAnnotations\"\n" +
" constant #17 utf8: \"LAnnotation;\"\n" +
" constant #18 utf8: \"LTypeAnnotation;\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 5]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
"\n" +
" RuntimeInvisibleAnnotations: \n" +
" #17 @Annotation(\n" +
" )\n" +
" #18 @TypeAnnotation(\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test030a() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@Target({TYPE_USE}) @interface TypeAnnotation { }\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@Target({TYPE}) @interface Annotation { }\n" +
"@Annotation @TypeAnnotation class X {\n" +
"}\n",
},
"");
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"SourceFile\"\n" +
" constant #15 utf8: \"X.java\"\n" +
" constant #16 utf8: \"RuntimeVisibleAnnotations\"\n" +
" constant #17 utf8: \"LAnnotation;\"\n" +
" constant #18 utf8: \"LTypeAnnotation;\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
"\n" +
" RuntimeVisibleAnnotations: \n" +
" #17 @Annotation(\n" +
" )\n" +
" #18 @TypeAnnotation(\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test030b() throws Exception {
this.runNegativeTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
// Only TYPE_USE annotations get this special treatment
"@Target({TYPE_PARAMETER}) @interface TypeAnnotation { }\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@Target({TYPE}) @interface Annotation { }\n" +
"@Annotation @TypeAnnotation class X {\n" +
"}\n",
},
"----------\n" +
"1. ERROR in X.java (at line 7)\n" +
" @Annotation @TypeAnnotation class X {\n" +
" ^^^^^^^^^^^^^^^\n" +
"The annotation @TypeAnnotation is disallowed for this location\n" +
"----------\n");
}
public void test030c() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@Target({TYPE_USE,TYPE_PARAMETER}) @interface TypeAnnotation { }\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@Target({TYPE}) @interface Annotation { }\n" +
"@Annotation @TypeAnnotation class X {\n" +
"}\n",
},
"");
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"SourceFile\"\n" +
" constant #15 utf8: \"X.java\"\n" +
" constant #16 utf8: \"RuntimeVisibleAnnotations\"\n" +
" constant #17 utf8: \"LAnnotation;\"\n" +
" constant #18 utf8: \"LTypeAnnotation;\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
"\n" +
" RuntimeVisibleAnnotations: \n" +
" #17 @Annotation(\n" +
" )\n" +
" #18 @TypeAnnotation(\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// Test that annotations in initializer code are not attached to the field.
public void test031() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"class X {\n" +
" X x = new @NonNull X();\n" +
"}\n",
},
"");
String expectedOutput =
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [10]\n" +
" 4 aload_0 [this]\n" +
" 5 new X [1]\n" +
" 8 dup\n" +
" 9 invokespecial X() [12]\n" +
" 12 putfield X.x : X [13]\n" +
" 15 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 4]\n" +
" [pc: 4, line: 5]\n" +
" [pc: 15, line: 4]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 16] local: this index: 0 type: X\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @NonNull(\n" +
" target type = 0x44 NEW\n" +
" offset = 5\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// Test co-existence of parameter annotations and type annotations.
public void test032() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"@Target({PARAMETER}) @interface ParameterAnnot { }\n" +
"class X {\n" +
" void foo(@NonNull X this, @ParameterAnnot @NonNull X x) {\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" void foo(X x);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: x index: 1 type: X\n" +
" RuntimeInvisibleParameterAnnotations: \n" +
" Number of annotations for parameter 0: 1\n" +
" #17 @ParameterAnnot(\n" +
" )\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #20 @NonNull(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" )\n" +
" #20 @NonNull(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// Test type annotations in initializer code.
public void test033() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"class X {\n" +
" static {\n" +
" Object o = (@NonNull Object) new @NonNull Object();\n" +
" }\n" +
" {\n" +
" new @NonNull Object();\n" +
" }\n" +
" X() {\n" +
" }\n" +
" X (int x) {\n" +
" }\n" +
"}\n",
},
"");
// javac b100
// For the annotations in the static {...} the clinit has:
// RuntimeInvisibleTypeAnnotations:
// 0: #11(): CAST, offset=0, type_index=0
// 1: #11(): NEW, offset=0
// javac is skipping production of the cast so offset is 0. JDT is currently always producing the
// checkcast for an annotated cast so the offset is 7.
// For the annotations in the initializer {...} the constructors both have:
// RuntimeInvisibleTypeAnnotations:
// 0: #11(): NEW, offset=4
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<clinit>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #10.#6 <init> ()V\n" +
" constant #10 utf8: \"<init>\"\n" +
" constant #11 utf8: \"LineNumberTable\"\n" +
" constant #12 utf8: \"LocalVariableTable\"\n" +
" constant #13 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #14 utf8: \"LNonNull;\"\n" +
" constant #15 utf8: \"this\"\n" +
" constant #16 utf8: \"LX;\"\n" +
" constant #17 utf8: \"(I)V\"\n" +
" constant #18 utf8: \"x\"\n" +
" constant #19 utf8: \"I\"\n" +
" constant #20 utf8: \"SourceFile\"\n" +
" constant #21 utf8: \"X.java\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 2, Locals: 1\n" +
" static {};\n" +
" 0 new java.lang.Object [3]\n" +
" 3 dup\n" +
" 4 invokespecial java.lang.Object() [8]\n" +
" 7 checkcast java.lang.Object [3]\n" +
" 10 astore_0\n" +
" 11 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 6]\n" +
" [pc: 11, line: 7]\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #14 @NonNull(\n" +
" target type = 0x44 NEW\n" +
" offset = 0\n" +
" )\n" +
" #14 @NonNull(\n" +
" target type = 0x47 CAST\n" +
" offset = 7\n" +
" type argument index = 0\n" +
" )\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 new java.lang.Object [3]\n" +
" 7 invokespecial java.lang.Object() [8]\n" +
" 10 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 11]\n" +
" [pc: 4, line: 9]\n" +
" [pc: 10, line: 12]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 11] local: this index: 0 type: X\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #14 @NonNull(\n" +
" target type = 0x44 NEW\n" +
" offset = 4\n" +
" )\n" +
" \n" +
" // Method descriptor #17 (I)V\n" +
" // Stack: 1, Locals: 2\n" +
" X(int x);\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 new java.lang.Object [3]\n" +
" 7 invokespecial java.lang.Object() [8]\n" +
" 10 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 13]\n" +
" [pc: 4, line: 9]\n" +
" [pc: 10, line: 14]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 11] local: this index: 0 type: X\n" +
" [pc: 0, pc: 11] local: x index: 1 type: int\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #14 @NonNull(\n" +
" target type = 0x44 NEW\n" +
" offset = 4\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test034() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"class X <T extends @NonNull Comparable> {\n" +
"}\n",
},
"");
// javac b100
// RuntimeInvisibleTypeAnnotations:
// 0: #13(): CLASS_TYPE_PARAMETER_BOUND, param_index=0, bound_index=1
// bound_index is 1 because the bound is an interface, not a class
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"// Signature: <T::Ljava/lang/Comparable;>Ljava/lang/Object;\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"LocalVariableTypeTable\"\n" +
" constant #15 utf8: \"LX<TT;>;\"\n" +
" constant #16 utf8: \"SourceFile\"\n" +
" constant #17 utf8: \"X.java\"\n" +
" constant #18 utf8: \"Signature\"\n" +
" constant #19 utf8: \"<T::Ljava/lang/Comparable;>Ljava/lang/Object;\"\n" +
" constant #20 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #21 utf8: \"LNonNull;\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 4]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X<T>\n" +
"\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @NonNull(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// Bug 415543 - Incorrect bound index in RuntimeInvisibleTypeAnnotations attribute
public void test034b() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.io.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"\n" +
"class X <T extends Comparable & @NonNull Serializable> {\n" +
" <T extends @NonNull Comparable> void one(T t) {}\n" +
" <T extends Comparable & @NonNull Serializable> void two(T t) {}\n" +
" <T extends @NonNull Comparable & @NonNull Serializable> void three(T t) {}\n" +
" <T extends Object & @NonNull Serializable> void four(T t) {}\n" +
" <T extends Object & @NonNull Serializable & @NonNull Runnable> void five(T t) {}\n" +
"}\n",
},
"");
String expectedOutput =
"// Compiled from X.java (version 1.8 : 52.0, super bit)\n" +
"// Signature: <T::Ljava/lang/Comparable;:Ljava/io/Serializable;>Ljava/lang/Object;\n" +
"class X {\n" +
" Constant pool:\n" +
" constant #1 class: #2 X\n" +
" constant #2 utf8: \"X\"\n" +
" constant #3 class: #4 java/lang/Object\n" +
" constant #4 utf8: \"java/lang/Object\"\n" +
" constant #5 utf8: \"<init>\"\n" +
" constant #6 utf8: \"()V\"\n" +
" constant #7 utf8: \"Code\"\n" +
" constant #8 method_ref: #3.#9 java/lang/Object.<init> ()V\n" +
" constant #9 name_and_type: #5.#6 <init> ()V\n" +
" constant #10 utf8: \"LineNumberTable\"\n" +
" constant #11 utf8: \"LocalVariableTable\"\n" +
" constant #12 utf8: \"this\"\n" +
" constant #13 utf8: \"LX;\"\n" +
" constant #14 utf8: \"LocalVariableTypeTable\"\n" +
" constant #15 utf8: \"LX<TT;>;\"\n" +
" constant #16 utf8: \"one\"\n" +
" constant #17 utf8: \"(Ljava/lang/Comparable;)V\"\n" +
" constant #18 utf8: \"Signature\"\n" +
" constant #19 utf8: \"<T::Ljava/lang/Comparable;>(TT;)V\"\n" +
" constant #20 utf8: \"t\"\n" +
" constant #21 utf8: \"Ljava/lang/Comparable;\"\n" +
" constant #22 utf8: \"TT;\"\n" +
" constant #23 utf8: \"RuntimeInvisibleTypeAnnotations\"\n" +
" constant #24 utf8: \"LNonNull;\"\n" +
" constant #25 utf8: \"two\"\n" +
" constant #26 utf8: \"<T::Ljava/lang/Comparable;:Ljava/io/Serializable;>(TT;)V\"\n" +
" constant #27 utf8: \"three\"\n" +
" constant #28 utf8: \"four\"\n" +
" constant #29 utf8: \"(Ljava/lang/Object;)V\"\n" +
" constant #30 utf8: \"<T:Ljava/lang/Object;:Ljava/io/Serializable;>(TT;)V\"\n" +
" constant #31 utf8: \"Ljava/lang/Object;\"\n" +
" constant #32 utf8: \"five\"\n" +
" constant #33 utf8: \"<T:Ljava/lang/Object;:Ljava/io/Serializable;:Ljava/lang/Runnable;>(TT;)V\"\n" +
" constant #34 utf8: \"SourceFile\"\n" +
" constant #35 utf8: \"X.java\"\n" +
" constant #36 utf8: \"<T::Ljava/lang/Comparable;:Ljava/io/Serializable;>Ljava/lang/Object;\"\n" +
" \n" +
" // Method descriptor #6 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [8]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 6]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X<T>\n" +
" \n" +
" // Method descriptor #17 (Ljava/lang/Comparable;)V\n" +
" // Signature: <T::Ljava/lang/Comparable;>(TT;)V\n" +
" // Stack: 0, Locals: 2\n" +
" void one(java.lang.Comparable t);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: t index: 1 type: java.lang.Comparable\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" [pc: 0, pc: 1] local: t index: 1 type: T\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
" \n" +
" // Method descriptor #17 (Ljava/lang/Comparable;)V\n" +
" // Signature: <T::Ljava/lang/Comparable;:Ljava/io/Serializable;>(TT;)V\n" +
" // Stack: 0, Locals: 2\n" +
" void two(java.lang.Comparable t);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 8]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: t index: 1 type: java.lang.Comparable\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" [pc: 0, pc: 1] local: t index: 1 type: T\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 2\n" +
" )\n" +
" \n" +
" // Method descriptor #17 (Ljava/lang/Comparable;)V\n" +
" // Signature: <T::Ljava/lang/Comparable;:Ljava/io/Serializable;>(TT;)V\n" +
" // Stack: 0, Locals: 2\n" +
" void three(java.lang.Comparable t);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 9]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: t index: 1 type: java.lang.Comparable\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" [pc: 0, pc: 1] local: t index: 1 type: T\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 2\n" +
" )\n" +
" \n" +
" // Method descriptor #29 (Ljava/lang/Object;)V\n" +
" // Signature: <T:Ljava/lang/Object;:Ljava/io/Serializable;>(TT;)V\n" +
" // Stack: 0, Locals: 2\n" +
" void four(java.lang.Object t);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 10]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: t index: 1 type: java.lang.Object\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" [pc: 0, pc: 1] local: t index: 1 type: T\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
" \n" +
" // Method descriptor #29 (Ljava/lang/Object;)V\n" +
" // Signature: <T:Ljava/lang/Object;:Ljava/io/Serializable;:Ljava/lang/Runnable;>(TT;)V\n" +
" // Stack: 0, Locals: 2\n" +
" void five(java.lang.Object t);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 11]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: t index: 1 type: java.lang.Object\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X<T>\n" +
" [pc: 0, pc: 1] local: t index: 1 type: T\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
" #24 @NonNull(\n" +
" target type = 0x12 METHOD_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 2\n" +
" )\n" +
"\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #24 @NonNull(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 2\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test035() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"\n" +
"class X {\n" +
" void foo() {\n" +
" @NonNull X [] x = new X[10];\n" +
" System.out.println(x);\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" void foo();\n" +
" 0 bipush 10\n" +
" 2 anewarray X [1]\n" +
" 5 astore_1 [x]\n" +
" 6 getstatic java.lang.System.out : java.io.PrintStream [15]\n" +
" 9 aload_1 [x]\n" +
" 10 invokevirtual java.io.PrintStream.println(java.lang.Object) : void [21]\n" +
" 13 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" [pc: 6, line: 8]\n" +
" [pc: 13, line: 9]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 14] local: this index: 0 type: X\n" +
" [pc: 6, pc: 14] local: x index: 1 type: X[]\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #30 @NonNull(\n" +
" target type = 0x40 LOCAL_VARIABLE\n" +
" local variable entries:\n" +
" [pc: 6, pc: 14] index: 1\n" +
" location = [ARRAY]\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// test that parameter index does not include explicit this parameter.
public void test036() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*; \n" +
"@Target({TYPE_USE}) @interface NonNull { }\n" +
"class X {\n" +
" void foo(@NonNull X this, @NonNull X x) {\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" void foo(X x);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 6]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: x index: 1 type: X\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #18 @NonNull(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" )\n" +
" #18 @NonNull(\n" +
" target type = 0x15 METHOD_RECEIVER\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test037() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@interface Readonly {\n" +
" String value() default \"default\";\n" +
"}\n" +
"public class X {\n" +
" X [] x = new @Readonly X @Readonly [10];\n" +
"}\n",
},
"");
String expectedOutput =
" public X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [10]\n" +
" 4 aload_0 [this]\n" +
" 5 bipush 10\n" +
" 7 anewarray X [1]\n" +
" 10 putfield X.x : X[] [12]\n" +
" 13 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" [pc: 4, line: 8]\n" +
" [pc: 13, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 14] local: this index: 0 type: X\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #19 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 7\n" +
" location = [ARRAY]\n" +
" )\n" +
" #19 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 7\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// test anonymous class, the class itself should have class_extends target ?
public void test038() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@interface Readonly {\n" +
" String value() default \"default\";\n" +
"}\n" +
"public class X {\n" +
" X x = new @Readonly X() {\n" +
" };\n" +
"}\n",
},
"");
String expectedOutput =
" public X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [10]\n" +
" 4 aload_0 [this]\n" +
" 5 new X$1 [12]\n" +
" 8 dup\n" +
" 9 aload_0 [this]\n" +
" 10 invokespecial X$1(X) [14]\n" +
" 13 putfield X.x : X [17]\n" +
" 16 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 7]\n" +
" [pc: 4, line: 8]\n" +
" [pc: 16, line: 7]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 17] local: this index: 0 type: X\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #23 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 5\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test039() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.List;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@interface Readonly {\n" +
" String value() default \"default\";\n" +
"}\n" +
"public class X { \n" +
" void foo(List<@Readonly ?> l) {\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" void foo(java.util.List l);\n" +
" 0 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 10]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 1] local: this index: 0 type: X\n" +
" [pc: 0, pc: 1] local: l index: 1 type: java.util.List\n" +
" Local variable type table:\n" +
" [pc: 0, pc: 1] local: l index: 1 type: java.util.List<?>\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #23 @Readonly(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test040() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@interface Readonly {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class X {\n" +
" class Y {}\n" +
" void foo() {\n" +
" @Readonly X x = new X();\n" +
" x.new @Readonly Y();\n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeVisibleTypeAnnotations: \n" +
" #27 @Readonly(\n" +
" target type = 0x44 NEW\n" +
" offset = 8\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" #27 @Readonly(\n" +
" target type = 0x40 LOCAL_VARIABLE\n" +
" local variable entries:\n" +
" [pc: 8, pc: 21] index: 1\n" +
" )\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test041() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface A {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface B {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface C {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class X<T extends @A Object & @B Comparable, U extends @C Cloneable> {\n" +
"}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @A(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 0\n" +
" )\n" +
" #22 @B(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 0 type parameter bound index = 1\n" +
" )\n" +
" #23 @C(\n" +
" target type = 0x11 CLASS_TYPE_PARAMETER_BOUND\n" +
" type parameter index = 1 type parameter bound index = 1\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// type path tests.
public void test042() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.Map;\n" +
"import java.util.List;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface A {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface B {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface C {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface D {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface E {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class X {\n" +
" @A Map <@B ? extends @C String, @D List<@E Object>> f;\n" +
"}\n",
},
"");
String expectedOutput =
" java.util.Map f;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @A(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #11 @B(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #12 @C(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), WILDCARD]\n" +
" )\n" +
" #13 @D(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #14 @E(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1), TYPE_ARGUMENT(0)]\n" +
" )\n" +
" \n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// Bug 414384 - [1.8] type annotation on abbreviated inner class is not marked as inner type
public void test043() throws Exception {
this.runConformTest(
new String[] {
"pkg/Clazz.java",
"package pkg;\n" +
"import java.lang.annotation.*;\n" +
"import static java.lang.annotation.ElementType.*;\n" +
"\n" +
"@Target({TYPE_USE}) @interface P { }\n" +
"@Target({TYPE_USE}) @interface O { }\n" +
"@Target({TYPE_USE}) @interface I { }\n" +
"\n" +
"public abstract class Clazz {\n" +
" public class Inner {}\n" +
" public abstract void n1(@I Inner i1);\n" +
" public abstract void n2(@O Clazz.@I Inner i2);\n" +
" public abstract void n3(pkg.@O Clazz.@I Inner i3);\n" +
"}\n",
},
"");
// javac b100 produces for the methods:
// public abstract void n1(pkg.Clazz$Inner);
// RuntimeInvisibleTypeAnnotations:
// 0: #14(): METHOD_FORMAL_PARAMETER, param_index=0, location=[INNER_TYPE]
//
// public abstract void n2(pkg.Clazz$Inner);
// RuntimeInvisibleTypeAnnotations:
// 0: #14(): METHOD_FORMAL_PARAMETER, param_index=0, location=[INNER_TYPE]
// 1: #16(): METHOD_FORMAL_PARAMETER, param_index=0
//
// public abstract void n3(pkg.Clazz$Inner);
// RuntimeInvisibleTypeAnnotations:
// 0: #14(): METHOD_FORMAL_PARAMETER, param_index=0, location=[INNER_TYPE]
// 1: #16(): METHOD_FORMAL_PARAMETER, param_index=0
String expectedOutput =
" // Method descriptor #15 (Lpkg/Clazz$Inner;)V\n" +
" public abstract void n1(pkg.Clazz.Inner arg0);\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #17 @pkg.I(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" \n" +
" // Method descriptor #15 (Lpkg/Clazz$Inner;)V\n" +
" public abstract void n2(pkg.Clazz.Inner arg0);\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @pkg.O(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" )\n" +
" #17 @pkg.I(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" \n" +
" // Method descriptor #15 (Lpkg/Clazz$Inner;)V\n" +
" public abstract void n3(pkg.Clazz.Inner arg0);\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #19 @pkg.O(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" )\n" +
" #17 @pkg.I(\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
"\n" +
" Inner classes:\n" +
" [inner class info: #24 pkg/Clazz$Inner, outer class info: #1 pkg/Clazz\n" +
" inner name: #26 Inner, accessflags: 1 public]\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "pkg" + File.separator + "Clazz.class", "pkg.Clazz", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// More type path tests
public void test044() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface I {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface F {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface G {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface H {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class X {\n" +
" @I String @F [] @G [] @H [] f;\n" +
"}\n",
},
"");
String expectedOutput =
" // Field descriptor #6 [[[Ljava/lang/String;\n" +
" java.lang.String[][][] f;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @I(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY, ARRAY, ARRAY]\n" +
" )\n" +
" #9 @F(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #10 @G(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY]\n" +
" )\n" +
" #11 @H(\n" +
" target type = 0x13 FIELD\n" +
" location = [ARRAY, ARRAY]\n" +
" )\n" +
" \n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// More type path tests
public void test045() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface M {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface L {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface K {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface J {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class O1 {\n" +
" class O2 {\n" +
" class O3 {\n" +
" class Nested {}\n" +
" }\n" +
" }\n" +
"}\n" +
"class X {\n" +
" @M O1.@L O2.@K O3.@J Nested f = null;\n" +
"}\n",
},
"");
String expectedOutput =
" // Field descriptor #6 LO1$O2$O3$Nested;\n" +
" O1$O2$O3$Nested f;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #8 @M(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #9 @L(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" #10 @K(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE]\n" +
" )\n" +
" #11 @J(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE, INNER_TYPE]\n" +
" )\n" +
" \n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// More type path tests
public void test046() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.Map;\n" +
"import java.util.List;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface A {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface B {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface C {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface D {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface E {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface F {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface G {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface H {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class Document {}\n" +
"class X {\n" +
" @A Map<@B Comparable<@F Object @C [] @D [] @E[]>, @G List<@H Document>> f;\n" +
"}\n",
},
"");
String expectedOutput =
" java.util.Map f;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @A(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #11 @B(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #12 @F(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), TYPE_ARGUMENT(0), ARRAY, ARRAY, ARRAY]\n" +
" )\n" +
" #13 @C(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #14 @D(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), TYPE_ARGUMENT(0), ARRAY]\n" +
" )\n" +
" #15 @E(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(0), TYPE_ARGUMENT(0), ARRAY, ARRAY]\n" +
" )\n" +
" #16 @G(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #17 @H(\n" +
" target type = 0x13 FIELD\n" +
" location = [TYPE_ARGUMENT(1), TYPE_ARGUMENT(0)]\n" +
" )\n" +
" \n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
// More type path tests
public void test047() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface A {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface B {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface C {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface D {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface E {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface F {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface G {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface H {\n" +
" String value() default \"default\";\n" +
"}\n" +
"class O1 {\n" +
" class O2<S, T> {\n" +
" class O3 {\n" +
" class Nested<K, V> {\n" +
" }\n" +
" }\n" +
" }\n" +
"}\n" +
" class S {}\n" +
" class T {}\n" +
" class U {}\n" +
" class V {}\n" +
"class X {\n" +
" @H O1.@E O2<@F S, @G T>.@D O3.@A Nested<@B U, @C V> f;\n" +
"}\n",
},
"");
String expectedOutput =
" // Field descriptor #6 LO1$O2$O3$Nested;\n" +
" // Signature: LO1$O2<LS;LT;>.O3.Nested<LU;LV;>;\n" +
" O1$O2$O3$Nested f;\n" +
" RuntimeInvisibleTypeAnnotations: \n" +
" #10 @H(\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #11 @E(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" #12 @D(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE]\n" +
" )\n" +
" #13 @A(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE, INNER_TYPE]\n" +
" )\n" +
" #14 @F(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #15 @G(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #16 @B(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE, INNER_TYPE, TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #17 @C(\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE, INNER_TYPE, INNER_TYPE, TYPE_ARGUMENT(1)]\n" +
" )\n" +
" \n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test048() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"import java.util.List;\n" +
"import java.util.Map;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface Readonly {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface NonNull {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface NonEmpty {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface D {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface E {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface F {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface G {\n" +
" String value() default \"default\";\n" +
"}\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@interface H {\n" +
" String value() default \"default\";\n" +
"}\n" +
"\n" +
"abstract class X implements @Readonly Map<@NonNull String, @NonEmpty List<@NonNull @Readonly String>> {}\n",
},
"");
String expectedOutput =
" RuntimeInvisibleTypeAnnotations: \n" +
" #21 @Readonly(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" )\n" +
" #22 @NonNull(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" location = [TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #23 @NonEmpty(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" location = [TYPE_ARGUMENT(1)]\n" +
" )\n" +
" #22 @NonNull(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" location = [TYPE_ARGUMENT(1), TYPE_ARGUMENT(0)]\n" +
" )\n" +
" #21 @Readonly(\n" +
" target type = 0x10 CLASS_EXTENDS\n" +
" type index = 0\n" +
" location = [TYPE_ARGUMENT(1), TYPE_ARGUMENT(0)]\n" +
" )\n" +
"}";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
public void test049() throws Exception {
this.runConformTest(
new String[] {
"X.java",
"import java.lang.annotation.*;\n" +
"@Target(ElementType.TYPE_USE)\n" +
"@Retention(RetentionPolicy.RUNTIME)\n" +
"@interface B { int value() default -1; }\n" +
"public class X {\n" +
" class Y {\n" +
" }\n" +
" @B(1) X. @B(2) Y xy;\n" +
" void foo(@B(3) X. @B(4) Y xy) {\n" +
" @B(5) X. @B(6) Y local = null; \n" +
" }\n" +
"}\n",
},
"");
String expectedOutput =
" // Field descriptor #6 LX$Y;\n" +
" X$Y xy;\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #8 @B(\n" +
" #9 value=(int) 1 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" )\n" +
" #8 @B(\n" +
" #9 value=(int) 2 (constant type)\n" +
" target type = 0x13 FIELD\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" \n" +
" // Method descriptor #13 ()V\n" +
" // Stack: 1, Locals: 1\n" +
" public X();\n" +
" 0 aload_0 [this]\n" +
" 1 invokespecial java.lang.Object() [15]\n" +
" 4 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 5]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 5] local: this index: 0 type: X\n" +
" \n" +
" // Method descriptor #22 (LX$Y;)V\n" +
" // Stack: 1, Locals: 3\n" +
" void foo(X.Y xy);\n" +
" 0 aconst_null\n" +
" 1 astore_2 [local]\n" +
" 2 return\n" +
" Line numbers:\n" +
" [pc: 0, line: 10]\n" +
" [pc: 2, line: 11]\n" +
" Local variable table:\n" +
" [pc: 0, pc: 3] local: this index: 0 type: X\n" +
" [pc: 0, pc: 3] local: xy index: 1 type: X.Y\n" +
" [pc: 2, pc: 3] local: local index: 2 type: X.Y\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #8 @B(\n" +
" #9 value=(int) 5 (constant type)\n" +
" target type = 0x40 LOCAL_VARIABLE\n" +
" local variable entries:\n" +
" [pc: 2, pc: 3] index: 2\n" +
" )\n" +
" #8 @B(\n" +
" #9 value=(int) 6 (constant type)\n" +
" target type = 0x40 LOCAL_VARIABLE\n" +
" local variable entries:\n" +
" [pc: 2, pc: 3] index: 2\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
" RuntimeVisibleTypeAnnotations: \n" +
" #8 @B(\n" +
" #9 value=(int) 3 (constant type)\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" )\n" +
" #8 @B(\n" +
" #9 value=(int) 4 (constant type)\n" +
" target type = 0x16 METHOD_FORMAL_PARAMETER\n" +
" method parameter index = 0\n" +
" location = [INNER_TYPE]\n" +
" )\n" +
"\n";
checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "Z", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
}