Update jdt.core from origin BETA_JAVA8 with
3b7e9a0f1d7c1bcba3808ca366020fd264fda3dd
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest8.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest8.java
index f50670f..fa8e4f1 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest8.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest8.java
@@ -153,7 +153,7 @@
"----------\n");
}
-// Lambda with declared args has illegal @NonNull an primitive argument
+// Lambda with declared args has illegal @NonNull an primitive argument, we now emit an additional not-invalid message.
public void testLambda_04() {
Map customOptions = getCompilerOptions();
runNegativeTestWithLibs(
@@ -177,6 +177,11 @@
" ISAM printer1 = (@NonNull int i) \n" +
" ^^^^^^^^\n" +
"The nullness annotation @NonNull is not applicable for the primitive type int\n" +
+ "----------\n" +
+ "2. ERROR in X.java (at line 4)\n" +
+ " ISAM printer1 = (@NonNull int i) \n" +
+ " ^^^^^^^^^^^^\n" +
+ "Illegal redefinition of parameter i, inherited method from ISAM does not constrain this parameter\n" +
"----------\n");
}
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
index 9d9aecb..5ba0ab8 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GrammarCoverageTests308.java
@@ -975,7 +975,8 @@
// TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
// AdditionalBound ::= '&' ReferenceType
// TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
- public void test023() throws Exception {
+ // TODO(Srikanth): fix and re-enable test.
+ public void _test023() throws Exception {
this.runNegativeTest(
new String[] {
"I.java",
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeTypeAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeTypeAnnotationTest.java
index 568fc37..3d9e27c 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeTypeAnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NegativeTypeAnnotationTest.java
@@ -23,6 +23,7 @@
static {
// TESTS_NUMBERS = new int [] { 35 };
+// TESTS_NAMES = new String [] { "test0390882b" };
}
public static Class testClass() {
return NegativeTypeAnnotationTest.class;
@@ -2719,7 +2720,12 @@
" TYPE_USE\n" +
"}\n"},
"----------\n" +
- "1. ERROR in X.java (at line 4)\n" +
+ "1. ERROR in X.java (at line 2)\n" +
+ " X<@Marker ?> l;\n" +
+ " ^^^^^^^\n" +
+ "The annotation @Marker is disallowed for this location\n" +
+ "----------\n" +
+ "2. ERROR in X.java (at line 4)\n" +
" X<@Marker3 ?> l3;\n" +
" ^^^^^^^^\n" +
"Annotation types that do not specify explicit target element types cannot be applied here\n" +
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
index a169fe1..3f214c2 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullTypeAnnotationTest.java
@@ -629,7 +629,7 @@
"2. WARNING in A.java (at line 5)\n" +
" realArrays[0] = unknownArrays[0]; // problems: inner array is unspecified, outer can be null\n" +
" ^^^^^^^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type 'String []' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
+ "Null type safety (type annotations): The expression of type 'String[]' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
"----------\n" +
"3. ERROR in A.java (at line 5)\n" +
" realArrays[0] = unknownArrays[0]; // problems: inner array is unspecified, outer can be null\n" +
@@ -923,8 +923,8 @@
"----------\n" +
"1. ERROR in Y.java (at line 6)\n" +
" x.setAllStrings(-1, ss);\n" +
- " ^^^^^^^^^^^^^\n" +
- "The method setAllStrings(int, List<@NonNull String>) in the type X is not applicable for the arguments (int, List<@Nullable String>)\n" +
+ " ^^\n" +
+ "Null type mismatch (type annotations): required \'List<@NonNull String>\' but this expression has type \'List<@Nullable String>\'\n" +
"----------\n"
);
}
@@ -1030,6 +1030,7 @@
}
// storing and decoding null-type-annotations to/from classfile: CLASS_TYPE_PARAMETER & METHOD_TYPE_PARAMETER
+ // TODO(Stephan) : 3rd error message looks weird. We need to clone and set the bits for allocation expression or otherwise handle.
public void testBinary05() {
Map customOptions = getCompilerOptions();
customOptions.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.ERROR);
@@ -1068,7 +1069,12 @@
"2. ERROR in Y1.java (at line 6)\n" +
" x.<@NonNull Object>foo(new Object());\n" +
" ^^^^^^^^^^^^^^^\n" +
- "Null constraint mismatch: The type '@NonNull Object' is not a valid substitute for the type parameter 'S' which is constrained as '@Nullable'\n" +
+ "Null constraint mismatch: The type \'@NonNull Object\' is not a valid substitute for the type parameter \'S\' which is constrained as \'@Nullable\'\n" +
+ "----------\n" +
+ "3. WARNING in Y1.java (at line 6)\n" +
+ " x.<@NonNull Object>foo(new Object());\n" +
+ " ^^^^^^^^^^^^\n" +
+ "Null type safety (type annotations): The expression of type \'Object\' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
"----------\n"
);
}
@@ -1453,7 +1459,7 @@
"Null type mismatch (type annotations): required \'List<@Nullable ? extends p.X1>\' but this expression has type \'ArrayList<@NonNull X1>\', corresponding supertype is \'List<@NonNull X1>\'\n" +
"----------\n");
}
-
+ // TODO(Stephan): Fix lub computation to create an intersection type when annotations differ. See comment in Scope#lowerUpperBound.
public void testConditional1() {
runNegativeTestWithLibs(
new String[] {
@@ -1473,12 +1479,7 @@
+ "}\n"
},
"----------\n" +
- "1. WARNING in X.java (at line 6)\n" +
- " return f == 0 ? good : dubious;\n" +
- " ^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'List<String>\' needs unchecked conversion to conform to \'List<@NonNull String>\'\n" +
- "----------\n" +
- "2. WARNING in X.java (at line 8)\n" +
+ "1. WARNING in X.java (at line 8)\n" +
" return f == 2 ? dubious : good;\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^\n" +
"Null type safety (type annotations): The expression of type \'List<String>\' needs unchecked conversion to conform to \'List<@NonNull String>\'\n" +
@@ -1667,6 +1668,7 @@
}
// types without null annotations are converted (unsafe) to types with detail annotations (array content)
+ // FIXME(Stephan) : Old messages are wrong, the new diagnostics are correct, but the leaf component types differ - null annotated readable names don't reflect that - this needs to be fixed.
public void testCompatibility3a() {
runNegativeTestWithLibs(
new String[] {
@@ -1695,32 +1697,32 @@
"1. WARNING in X.java (at line 4)\n" +
" return dubious;\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n" +
"2. WARNING in X.java (at line 7)\n" +
" return dubious;\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @Nullable[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n" +
"3. WARNING in X.java (at line 10)\n" +
" @Nullable String[] l1 = dubious;\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @Nullable[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n" +
"4. WARNING in X.java (at line 11)\n" +
" @NonNull String[] l2 = dubious;\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n" +
"5. WARNING in X.java (at line 14)\n" +
" acceptNulls(dubious);\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n" +
"6. WARNING in X.java (at line 15)\n" +
" acceptNoNulls(dubious);\n" +
" ^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String @NonNull[]\'\n" +
+ "Null type safety (type annotations): The expression of type \'String[]\' needs unchecked conversion to conform to \'String []\'\n" +
"----------\n");
}
@@ -1781,6 +1783,8 @@
}
// types with null annotations on details (array content) are incompatible to opposite types
+ // TODO(Stephan) : Per the right interpretation of the spec, @Nullable and @NonNull are annotating the component type and not the arrays. The new diagnostics are correct, but
+ // should mention the annotation on the leaf type.
public void testCompatibility4a() {
runNegativeTestWithLibs(
new String[] {
@@ -1806,32 +1810,32 @@
"1. ERROR in X.java (at line 4)\n" +
" return noNulls;\n" +
" ^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @Nullable[]\' but this expression has type \'String @NonNull[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n" +
"2. ERROR in X.java (at line 7)\n" +
" return withNulls;\n" +
" ^^^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @NonNull[]\' but this expression has type \'String @Nullable[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n" +
"3. ERROR in X.java (at line 10)\n" +
" @NonNull String[] l1 = withNulls;\n" +
" ^^^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @NonNull[]\' but this expression has type \'String @Nullable[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n" +
"4. ERROR in X.java (at line 11)\n" +
" @Nullable String[] l2 = noNulls;\n" +
" ^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @Nullable[]\' but this expression has type \'String @NonNull[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n" +
"5. ERROR in X.java (at line 14)\n" +
" assigns(withNulls, noNulls);\n" +
" ^^^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @NonNull[]\' but this expression has type \'String @Nullable[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n" +
"6. ERROR in X.java (at line 14)\n" +
" assigns(withNulls, noNulls);\n" +
" ^^^^^^^\n" +
- "Null type mismatch (type annotations): required \'String @Nullable[]\' but this expression has type \'String @NonNull[]\'\n" +
+ "Null type mismatch (type annotations): required \'String []\' but this expression has type \'String []\'\n" +
"----------\n");
}
@@ -2290,7 +2294,7 @@
"The method foo(List<X>) of type Z should be tagged with @Override since it actually overrides a superclass method\n" +
"----------\n");
}
-
+ // TODO(Stephan) : the message needs clean up.
public void testBug416175() {
runNegativeTestWithLibs(
new String[] {
@@ -2313,12 +2317,12 @@
"1. WARNING in X.java (at line 8)\n" +
" List<@NonNull ? extends @NonNull String> ls = new ArrayList<String>();\n" +
" ^^^^^^^^^^^^^^^^^^^^^^^\n" +
- "Null type safety (type annotations): The expression of type \'ArrayList<String>\' needs unchecked conversion to conform to \'List<@NonNull ? extends String>\'\n" +
+ "Null type safety (type annotations): The expression of type \'ArrayList<String>\' needs unchecked conversion to conform to \'List<@NonNull ? extends java.lang.String>\'\n" +
"----------\n" +
"2. ERROR in X.java (at line 9)\n" +
" ls.add(null);\n" +
" ^^^^\n" +
- "Null type mismatch: required \'@NonNull ? extends String\' but the provided value is null\n" +
+ "Null type mismatch: required \'@NonNull capture#\' but the provided value is null\n" +
"----------\n");
}
@@ -2372,7 +2376,7 @@
"2. ERROR in X.java (at line 15)\n" +
" return null;\n" +
" ^^^^\n" +
- "Null type mismatch: required \'T\' but the provided value is null\n" +
+ "Null type mismatch: required \'@NonNull T\' but the provided value is null\n" +
"----------\n");
}
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
index 06526c9..de28360 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter18Test.java
@@ -1390,7 +1390,7 @@
+ "@interface Marker1 {}\n"
+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
+ "@interface Marker2 {}\n"
- + "@Target (java.lang.annotation.ElementType.TYPE_PARAMETER)\n"
+ + "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
+ "@interface Marker3 {}\n";
CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
index 437afbb..c396822 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java
@@ -5127,11 +5127,11 @@
this.innerClassesBindings = new HashSet(INNER_CLASSES_SIZE);
}
ReferenceBinding innerClass = (ReferenceBinding) binding;
- this.innerClassesBindings.add(innerClass.erasure());
+ this.innerClassesBindings.add(innerClass.erasure().unannotated()); // should not emit yet another inner class for Outer.@Inner Inner.
ReferenceBinding enclosingType = innerClass.enclosingType();
while (enclosingType != null
&& enclosingType.isNestedType()) {
- this.innerClassesBindings.add(enclosingType.erasure());
+ this.innerClassesBindings.add(enclosingType.erasure().unannotated());
enclosingType = enclosingType.enclosingType();
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 4759465..0b6622a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -695,24 +695,31 @@
}
return polyExpressionsHaveErrors;
}
+
+ // Method retained with original signature to satisfy reference from APT.
+ public static void resolveAnnotations(BlockScope scope, Annotation[] sourceAnnotations, Binding recipient) {
+ resolveAnnotations(scope, sourceAnnotations, recipient, false);
+ }
+
/**
* Resolve annotations, and check duplicates, answers combined tagBits
- * for recognized standard annotations
+ * for recognized standard annotations. Return null if nothing new is
+ * resolved.
*/
- public static void resolveAnnotations(BlockScope scope, Annotation[] sourceAnnotations, Binding recipient) {
+ public static AnnotationBinding [] resolveAnnotations(BlockScope scope, Annotation[] sourceAnnotations, Binding recipient, boolean copySE8AnnotationsToType) {
AnnotationBinding[] annotations = null;
int length = sourceAnnotations == null ? 0 : sourceAnnotations.length;
if (recipient != null) {
switch (recipient.kind()) {
case Binding.PACKAGE :
PackageBinding packageBinding = (PackageBinding) recipient;
- if ((packageBinding.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((packageBinding.tagBits & TagBits.AnnotationResolved) != 0) return annotations;
packageBinding.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
break;
case Binding.TYPE :
case Binding.GENERIC_TYPE :
ReferenceBinding type = (ReferenceBinding) recipient;
- if ((type.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((type.tagBits & TagBits.AnnotationResolved) != 0) return annotations;
type.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
if (length > 0) {
annotations = new AnnotationBinding[length];
@@ -721,7 +728,7 @@
break;
case Binding.METHOD :
MethodBinding method = (MethodBinding) recipient;
- if ((method.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((method.tagBits & TagBits.AnnotationResolved) != 0) return annotations;
method.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
if (length > 0) {
annotations = new AnnotationBinding[length];
@@ -731,7 +738,8 @@
//{ObjectTeams: method mappings
case Binding.BINDING :
CallinCalloutBinding mapping = (CallinCalloutBinding) recipient;
- if ((mapping.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((mapping.tagBits & TagBits.AnnotationResolved) != 0)
+ return annotations;
mapping.tagBits |= TagBits.AnnotationResolved;
if (length > 0) {
annotations = new AnnotationBinding[length];
@@ -741,7 +749,7 @@
// SH}
case Binding.FIELD :
FieldBinding field = (FieldBinding) recipient;
- if ((field.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((field.tagBits & TagBits.AnnotationResolved) != 0) return annotations;
field.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
if (length > 0) {
annotations = new AnnotationBinding[length];
@@ -750,7 +758,7 @@
break;
case Binding.LOCAL :
LocalVariableBinding local = (LocalVariableBinding) recipient;
- if ((local.tagBits & TagBits.AnnotationResolved) != 0) return;
+ if ((local.tagBits & TagBits.AnnotationResolved) != 0) return annotations;
local.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
if (length > 0) {
annotations = new AnnotationBinding[length];
@@ -758,30 +766,16 @@
}
break;
case Binding.TYPE_PARAMETER :
- // jsr308
- ReferenceBinding typeVariableBinding = (ReferenceBinding) recipient;
- if ((typeVariableBinding.tagBits & TagBits.AnnotationResolved) != 0) return;
- typeVariableBinding.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
- if (length > 0) {
- annotations = new AnnotationBinding[length];
- typeVariableBinding.setAnnotations(annotations);
- }
- break;
case Binding.TYPE_USE :
- ReferenceBinding typeUseBinding = (ReferenceBinding) recipient;
- if ((typeUseBinding.tagBits & TagBits.AnnotationResolved) != 0) return;
- typeUseBinding.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved);
- if (length > 0) {
- annotations = new AnnotationBinding[length];
- typeUseBinding.setAnnotations(annotations);
- }
+ // deliberately don't set the annotation resolved tagbits, it is not material and also we are working with a dummy static object.
+ annotations = new AnnotationBinding[length];
break;
default :
- return;
+ return annotations;
}
}
if (sourceAnnotations == null)
- return;
+ return annotations;
for (int i = 0; i < length; i++) {
Annotation annotation = sourceAnnotations[i];
final Binding annotationRecipient = annotation.recipient;
@@ -835,7 +829,7 @@
}
break;
}
- return;
+ return annotations;
} else {
annotation.recipient = recipient;
annotation.resolveType(scope);
@@ -845,8 +839,12 @@
}
}
}
+
+ if (copySE8AnnotationsToType)
+ copySE8AnnotationsToType(scope, recipient, annotations);
+
// check duplicate annotations
- if (annotations != null) {
+ if (annotations != null && length > 1) {
AnnotationBinding[] distinctAnnotations = annotations; // only copy after 1st duplicate is detected
for (int i = 0; i < length; i++) {
AnnotationBinding annotation = distinctAnnotations[i];
@@ -870,6 +868,95 @@
}
}
}
+ return annotations;
+ }
+
+ /** Resolve JSR308 annotations on a type reference, array creation expression or a wildcard. Type parameters go directly to the subroutine,
+ By construction the bindings associated with QTR, PQTR etc get resolved first and then annotations for different levels get resolved
+ and applied at one go. Likewise for multidimensional arrays.
+
+ @Returns the annotated type binding.
+ */
+ public static TypeBinding resolveAnnotations(BlockScope scope, Annotation[][] sourceAnnotations, TypeBinding type) {
+ int levels = sourceAnnotations == null ? 0 : sourceAnnotations.length;
+ if (type == null || levels == 0)
+ return type;
+ AnnotationBinding [][] annotationBindings = new AnnotationBinding [levels][];
+
+ for (int i = 0; i < levels; i++) {
+ Annotation[] annotations = sourceAnnotations[i];
+ if (annotations != null && annotations.length > 0) {
+ annotationBindings[i] = resolveAnnotations(scope, annotations, TypeBinding.TYPE_USE_BINDING, false);
+ }
+ }
+ return scope.environment().createAnnotatedType(type, annotationBindings);
+ }
+
+ /** When SE8 annotations feature in SE7 locations, they get attributed to the declared entity. Copy these to the type of the declared entity (field, local, argument etc.)
+ We leave in the annotation in the declared entity's binding as of now, i.e we do a copy not a transfer.
+ */
+ public static void copySE8AnnotationsToType(BlockScope scope, Binding recipient, AnnotationBinding[] annotations) {
+ if (annotations != null && recipient.kind() != Binding.TYPE_USE) {
+ AnnotationBinding [] se8Annotations = null;
+ int se8count = 0;
+ for (int i = 0, length = annotations.length; i < length; i++) {
+ final ReferenceBinding annotationType = annotations[i].getAnnotationType();
+ long metaTagBits = annotationType.getAnnotationTagBits();
+ if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
+ if (se8Annotations == null) {
+ se8Annotations = new AnnotationBinding[] { annotations[i] };
+ se8count = 1;
+ } else {
+ System.arraycopy(se8Annotations, 0, se8Annotations = new AnnotationBinding[se8count + 1], 0, se8count);
+ se8Annotations[se8count++] = annotations[i];
+ }
+ }
+ }
+ if (se8Annotations != null) {
+ switch (recipient.kind()) {
+ case Binding.LOCAL:
+ LocalVariableBinding local = (LocalVariableBinding) recipient;
+ if (Annotation.isTypeUseCompatible(local.declaration.type, scope)) { // discard hybrid annotations on package qualified types.
+ local.declaration.bits |= HasTypeAnnotations;
+ final TypeBinding localType = local.type;
+ TypeBinding oldLeafType = localType.leafComponentType();
+ AnnotationBinding [][] goodies = new AnnotationBinding[local.declaration.type.getAnnotatableLevels()][];
+ goodies[0] = se8Annotations; // @T X.Y.Z local; ==> @T should annotate X
+ TypeBinding newLeafType = scope.environment().createAnnotatedType(oldLeafType, goodies);
+ local.type = localType.isArrayType() ? scope.environment().createArrayType(newLeafType, localType.dimensions(), localType.getTypeAnnotations()) : newLeafType;
+ }
+ break;
+ case Binding.FIELD:
+ FieldBinding field = (FieldBinding) recipient;
+ SourceTypeBinding sourceType = (SourceTypeBinding) field.declaringClass;
+ FieldDeclaration fieldDeclaration = sourceType.scope.referenceContext.declarationOf(field);
+ if (Annotation.isTypeUseCompatible(fieldDeclaration.type, scope)) { // discard hybrid annotations on package qualified types.
+ TypeBinding fieldType = field.type;
+ TypeBinding oldLeafType = fieldType.leafComponentType();
+ AnnotationBinding [][] goodies = new AnnotationBinding[fieldDeclaration.type.getAnnotatableLevels()][];
+ goodies[0] = se8Annotations; // @T X.Y.Z field; ==> @T should annotate X
+ TypeBinding newLeafType = scope.environment().createAnnotatedType(oldLeafType, goodies);
+ field.type = fieldType.isArrayType() ? scope.environment().createArrayType(newLeafType, fieldType.dimensions(), fieldType.getTypeAnnotations()) : newLeafType;
+ }
+ break;
+ case Binding.METHOD:
+ MethodBinding method = (MethodBinding) recipient;
+ if (!method.isConstructor()) {
+ sourceType = (SourceTypeBinding) method.declaringClass;
+ MethodDeclaration methodDecl = (MethodDeclaration) sourceType.scope.referenceContext.declarationOf(method);
+ if (Annotation.isTypeUseCompatible(methodDecl.returnType, scope)) {
+ final TypeBinding returnType = method.returnType;
+ TypeBinding oldLeafType = returnType.leafComponentType();
+ AnnotationBinding [][] goodies = new AnnotationBinding[methodDecl.returnType.getAnnotatableLevels()][];
+ goodies[0] = se8Annotations;
+ TypeBinding newLeafType = scope.environment().createAnnotatedType(oldLeafType, goodies);
+ method.returnType = returnType.isArrayType() ? scope.environment().createArrayType(newLeafType, returnType.dimensions(), returnType.getTypeAnnotations()) : newLeafType;
+ }
+ }
+ break;
+ }
+ }
+ }
}
/**
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java
index 79a4b6d..e64483f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java
@@ -873,7 +873,7 @@
this.receiver.qualifyingName = null;
}
- if (enclosingReceiver != resolvedReceiverType.unannotated()) {
+ if (TypeBinding.notEquals(enclosingReceiver, resolvedReceiverType)) {
this.scope.problemReporter().illegalTypeForExplicitThis(this.receiver, enclosingReceiver);
this.receiver = null;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
index fc437bb..c295955 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
@@ -426,7 +426,7 @@
needsInnerEntryInfo = new boolean[typeReference.tokens.length];
int counter = needsInnerEntryInfo.length - 1;
ReferenceBinding type = resolvedType;//resolvedType.enclosingType();
- while (type != null) {
+ while (type != null && counter > 0) {
needsInnerEntryInfo[counter--] = !type.isStatic();
type = type.enclosingType();
}
@@ -529,21 +529,6 @@
}
return result;
}
-
- // jsr 308
- public static class TypeUseBinding extends ReferenceBinding {
- private int kind;
- public TypeUseBinding(int kind) {
- this.tagBits = 0L;
- this.kind = kind;
- }
- public int kind() {
- return this.kind;
- }
- public boolean hasTypeBit(int bit) {
- return false;
- }
- }
final static MemberValuePair[] NoValuePairs = new MemberValuePair[0];
@@ -959,11 +944,6 @@
case Binding.PACKAGE :
((PackageBinding)this.recipient).tagBits |= tagBits;
break;
- case Binding.TYPE_PARAMETER:
- case Binding.TYPE_USE:
- ReferenceBinding typeAnnotationRecipient = (ReferenceBinding) this.recipient;
- typeAnnotationRecipient.tagBits |= tagBits;
- break;
case Binding.TYPE :
case Binding.GENERIC_TYPE :
SourceTypeBinding sourceType = (SourceTypeBinding) this.recipient;
@@ -1052,8 +1032,6 @@
if (((variable.type.tagBits & TagBits.AnnotationNullMASK) | nullTagBits ) == TagBits.AnnotationNullMASK) {
scope.problemReporter().contradictoryNullAnnotations(this);
variable.type = variable.type.unannotated();
- } else {
- variable.type = scope.environment().createAnnotatedType(variable.type, nullTagBits);
}
}
}
@@ -1187,7 +1165,7 @@
}
return this.resolvedType;
}
- private boolean isTypeUseCompatible(TypeReference reference, Scope scope) {
+ public static boolean isTypeUseCompatible(TypeReference reference, Scope scope) {
if (reference != null && !(reference instanceof SingleTypeReference)) {
Binding binding = scope.getPackage(reference.getTypeName());
// In case of ProblemReferenceBinding, don't report additional error
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Argument.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Argument.java
index 2b81969..f71cf7c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Argument.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Argument.java
@@ -93,7 +93,7 @@
}
}
}
- resolveAnnotations(scope, this.annotations, this.binding);
+ resolveAnnotations(scope, this.annotations, this.binding, true);
this.binding.declaration = this;
return this.binding.type; // might have been updated during resolveAnnotations (for typeAnnotations)
}
@@ -234,7 +234,7 @@
} else {
this.binding = new CatchParameterBinding(this, exceptionType, this.modifiers, false); // argument decl, but local var (where isArgument = false)
}
- resolveAnnotations(scope, this.annotations, this.binding);
+ resolveAnnotations(scope, this.annotations, this.binding, true);
// Type annotations may need attaching to the type references
// Example of code this block handles: } catch(@A Exception e) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayAllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayAllocationExpression.java
index 7e3c1f6..172f5a3 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayAllocationExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayAllocationExpression.java
@@ -193,10 +193,7 @@
}
}
if (this.annotationsOnDimensions != null) {
- for (int i = 0, max = this.annotationsOnDimensions.length; i < max; i++) {
- Annotation[] annotations = this.annotationsOnDimensions[i];
- resolveAnnotations(scope, annotations, new Annotation.TypeUseBinding(Binding.TYPE_USE));
- }
+ this.resolvedType = resolveAnnotations(scope, this.annotationsOnDimensions, this.resolvedType);
}
return this.resolvedType;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
index 8765ce2..62d413f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
@@ -416,7 +416,7 @@
if (castType instanceof WeakenedTypeBinding)
castType = ((WeakenedTypeBinding)castType).getStrongType();
// SH}
- if (match == castType) {
+ if (TypeBinding.equalsEquals(match, castType)) {
if (!isNarrowing && match == this.resolvedType.leafComponentType()) { // do not tag as unnecessary when recursing through upper bounds
tagAsUnnecessaryCast(scope, castType);
}
@@ -690,16 +690,11 @@
if (castType != null) {
if (expressionType != null) {
- // internally for type checking use the unannotated types:
- TypeBinding unannotatedCastType = castType.unannotated();
boolean nullAnnotationMismatch = NullAnnotationMatching.analyse(castType, expressionType, -1).isAnyMismatch();
- if (nullAnnotationMismatch)
- castType = unannotatedCastType; // problem exists, so use the unannotated type also externally
- expressionType = expressionType.unannotated();
- boolean isLegal = checkCastTypesCompatibility(scope, unannotatedCastType, expressionType, this.expression);
+ boolean isLegal = checkCastTypesCompatibility(scope, castType, expressionType, this.expression);
if (isLegal) {
- this.expression.computeConversion(scope, unannotatedCastType, expressionType);
+ this.expression.computeConversion(scope, castType, expressionType);
if ((this.bits & ASTNode.UnsafeCast) != 0) { // unsafe cast
//{ObjectTeams: getAllRoles requires an unchecked cast (T[]), don't report:
if (!scope.isGeneratedScope())
@@ -712,8 +707,8 @@
// report null annotation issue at medium priority
scope.problemReporter().unsafeNullnessCast(this, scope);
} else {
- if (unannotatedCastType.isRawType() && scope.compilerOptions().getSeverity(CompilerOptions.RawTypeReference) != ProblemSeverities.Ignore){
- scope.problemReporter().rawTypeReference(this.type, unannotatedCastType);
+ if (castType.isRawType() && scope.compilerOptions().getSeverity(CompilerOptions.RawTypeReference) != ProblemSeverities.Ignore){
+ scope.problemReporter().rawTypeReference(this.type, castType);
}
if ((this.bits & (ASTNode.UnnecessaryCast|ASTNode.DisableUnnecessaryCastCheck)) == ASTNode.UnnecessaryCast) { // unnecessary cast
if (!isIndirectlyUsed()) // used for generic type inference or boxing ?
@@ -721,8 +716,8 @@
}
}
} else { // illegal cast
- if ((unannotatedCastType.tagBits & TagBits.HasMissingType) == 0) { // no complaint if secondary error
- scope.problemReporter().typeCastError(this, unannotatedCastType, expressionType);
+ if ((castType.tagBits & TagBits.HasMissingType) == 0) { // no complaint if secondary error
+ scope.problemReporter().typeCastError(this, castType, expressionType);
}
this.bits |= ASTNode.DisableUnnecessaryCastCheck; // disable further secondary diagnosis
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
index 8666e92..05dc8f1 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java
@@ -471,11 +471,7 @@
TypeBinding valueIfTrueType = this.originalValueIfTrueType;
TypeBinding valueIfFalseType = this.originalValueIfFalseType;
- if (use18specifics && valueIfTrueType != null && valueIfFalseType != null && valueIfTrueType != valueIfFalseType) {
- valueIfTrueType = valueIfTrueType.unannotated();
- valueIfFalseType = valueIfFalseType.unannotated();
- }
- if (use15specifics && valueIfTrueType != valueIfFalseType) {
+ if (use15specifics && TypeBinding.notEquals(valueIfTrueType, valueIfFalseType)) {
if (valueIfTrueType.isBaseType()) {
if (valueIfFalseType.isBaseType()) {
// bool ? baseType : baseType
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java
index 3b91512..9907461 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java
@@ -836,7 +836,7 @@
return;
}
int compileTimeTypeID, runtimeTypeID;
- if ((compileTimeTypeID = compileTimeType.id) == TypeIds.NoId) { // e.g. ? extends String ==> String (103227)
+ if ((compileTimeTypeID = compileTimeType.id) >= TypeIds.T_LastWellKnownTypeId) { // e.g. ? extends String ==> String (103227); >= TypeIds.T_LastWellKnownTypeId implies TypeIds.NoId
compileTimeTypeID = compileTimeType.erasure().id == TypeIds.T_JavaLangString ? TypeIds.T_JavaLangString : TypeIds.T_JavaLangObject;
}
switch (runtimeTypeID = runtimeType.id) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java
index 8eb1e71..4d1682a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java
@@ -308,7 +308,7 @@
}
} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
- if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
+ if (TypeBinding.notEquals(fieldType, initializationType)) // must call before computeConversion() and typeMismatchError()
initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
|| initializationType.isCompatibleWith(fieldType, classScope)) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
index 37a49d1..8c26094 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -209,7 +209,7 @@
if ((parameterType.tagBits & TagBits.HasMissingType) != 0) {
this.binding.tagBits |= TagBits.HasMissingType;
}
- if (haveDescriptor && expectedParameterType != null && parameterType.isValidBinding() && parameterType.unannotated() != expectedParameterType.unannotated()) {
+ if (haveDescriptor && expectedParameterType != null && parameterType.isValidBinding() && TypeBinding.notEquals(parameterType, expectedParameterType)) {
this.scope.problemReporter().lambdaParameterTypeMismatched(argument, argument.type, expectedParameterType);
}
@@ -368,8 +368,20 @@
long ourTagBits = ourParameters[i].tagBits & TagBits.AnnotationNullMASK;
long descTagBits = descParameters[i].tagBits & TagBits.AnnotationNullMASK;
if (ourTagBits == 0L) {
- if (descTagBits != 0L && !ourParameters[i].isBaseType())
- ourParameters[i] = env.createAnnotatedType(ourParameters[i], descTagBits);
+ if (descTagBits != 0L && !ourParameters[i].isBaseType()) {
+ AnnotationBinding [] annotations = descParameters[i].getTypeAnnotations();
+ for (int j = 0, length = annotations.length; j < length; j++) {
+ AnnotationBinding annotation = annotations[j];
+ if (annotation != null) {
+ switch (annotation.getAnnotationType().id) {
+ case TypeIds.T_ConfiguredAnnotationNullable :
+ case TypeIds.T_ConfiguredAnnotationNonNull :
+ ourParameters[i] = env.createAnnotatedType(ourParameters[i], new AnnotationBinding [] { annotation });
+ break;
+ }
+ }
+ }
+ }
} else if (ourTagBits != descTagBits) {
if (ourTagBits == TagBits.AnnotationNonNull) { // requested @NonNull not provided
char[][] inheritedAnnotationName = null;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java
index d09b7a4..d80efc2 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java
@@ -369,17 +369,7 @@
// SH}
}
// only resolve annotation at the end, for constant to be positioned before (96991)
- resolveAnnotations(scope, this.annotations, this.binding);
- // Check if this declaration should now have the type annotations bit set
- if (this.annotations != null) {
- for (int i = 0, max = this.annotations.length; i < max; i++) {
- TypeBinding resolvedAnnotationType = this.annotations[i].resolvedType;
- if (resolvedAnnotationType != null && (resolvedAnnotationType.getAnnotationTagBits() & TagBits.AnnotationForTypeUse) != 0) {
- this.bits |= ASTNode.HasTypeAnnotations;
- break;
- }
- }
- }
+ resolveAnnotations(scope, this.annotations, this.binding, true);
if (!scope.validateNullAnnotation(this.binding.tagBits, this.type, this.annotations))
this.binding.tagBits &= ~TagBits.AnnotationNullMASK;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
index 53e8455..24a9493 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
@@ -105,7 +105,7 @@
if (providedDimsTagBits == null) {
severity = 1; // required is annotated, provided not, need unchecked conversion
} else {
- for (int i=0; i<dims; i++) {
+ for (int i=0; i<=dims; i++) {
long requiredBits = requiredDimsTagBits[i] & TagBits.AnnotationNullMASK;
long providedBits = providedDimsTagBits[i] & TagBits.AnnotationNullMASK;
if (i > 0)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
index e1decab..17cd958 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java
@@ -323,7 +323,7 @@
typeIsConsistent = false;
}
}
- ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, currentType.tagBits & TagBits.AnnotationNullMASK, qualifyingType);
+ ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, qualifyingType);
// check argument type compatibility for non <> cases - <> case needs no bounds check, we will scream foul if needed during inference.
if (!isDiamond) {
if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
index 7386a04..e33a10a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java
@@ -267,19 +267,26 @@
TypeBinding type = internalResolveLeafType(scope, enclosingType, checkBounds);
:giro */
// SH}
- resolveAnnotations(scope);
- checkNullConstraints(scope, this.typeArguments);
// handle three different outcomes:
if (type == null) {
this.resolvedType = createArrayType(scope, this.resolvedType);
+ resolveAnnotations(scope);
+ checkNullConstraints(scope, this.typeArguments);
return null; // no useful type, but still captured dimensions into this.resolvedType
} else {
type = createArrayType(scope, type);
- if (!this.resolvedType.isValidBinding())
+ if (!this.resolvedType.isValidBinding()) {
+ resolveAnnotations(scope);
+ checkNullConstraints(scope, this.typeArguments);
return type; // found some error, but could recover useful type (like closestMatch)
- else
- return this.resolvedType = type; // no complaint, keep fully resolved type (incl. dimensions)
+ } else {
+ this.resolvedType = type; // no complaint, keep fully resolved type (incl. dimensions)
+ resolveAnnotations(scope);
+ checkNullConstraints(scope, this.typeArguments);
+ return this.resolvedType; // pick up any annotated type.
+ }
+
}
}
//{ObjectTeams: consider two scopes (base imports, regular):
@@ -424,14 +431,14 @@
return this.resolvedType;
// feed more parameters into createParameterizedType:
- long annotTagBits = currentType.tagBits & TagBits.AnnotationNullMASK;
+ AnnotationBinding[] currentAnnotations = currentType.getAnnotations();
ITeamAnchor anchor = null;
int valParPos = -1;
if (DependentTypeBinding.isDependentType(currentType)) {
anchor = ((DependentTypeBinding)currentType)._teamAnchor;
valParPos = ((DependentTypeBinding)currentType)._valueParamPosition;
}
- ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, annotTagBits, anchor, valParPos, enclosingType);
+ ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, anchor, valParPos, enclosingType, currentAnnotations);
/* orig:
ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);
:giro */
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeParameter.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeParameter.java
index 4eb533a..582af65 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeParameter.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeParameter.java
@@ -26,6 +26,7 @@
import org.eclipse.jdt.internal.compiler.ast.TypeReference.AnnotationCollector;
import org.eclipse.jdt.internal.compiler.codegen.AnnotationTargetTypeConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
+import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
@@ -140,7 +141,8 @@
public void resolveAnnotations(Scope scope) {
BlockScope resolutionScope = Scope.typeAnnotationsResolutionScope(scope);
if (resolutionScope != null) {
- resolveAnnotations(resolutionScope, this.annotations, new Annotation.TypeUseBinding(Binding.TYPE_PARAMETER));
+ AnnotationBinding [] annotationBindings = resolveAnnotations(resolutionScope, this.annotations, this.binding, false);
+ this.binding.setTypeAnnotations(annotationBindings, scope.environment().globalOptions.isAnnotationBasedNullAnalysisEnabled);
if (this.binding != null && this.binding.isValidBinding())
this.binding.evaluateNullAnnotations(scope, this);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java
index 4720947..2eb350b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java
@@ -725,78 +725,14 @@
if (this.annotations != null || annotationsOnDimensions != null) {
BlockScope resolutionScope = Scope.typeAnnotationsResolutionScope(scope);
if (resolutionScope != null) {
- long tagBits = 0;
- long[] tagBitsPerDimension = null;
int dimensions = this.dimensions();
- boolean evalNullAnnotations = scope.compilerOptions().isAnnotationBasedNullAnalysisEnabled;
- boolean isArrayReference = dimensions > 0;
if (this.annotations != null) {
- int annotationsLevels = this.annotations.length;
- for (int i = 0; i < annotationsLevels; i++) {
- Annotation[] currentAnnotations = this.annotations[i];
- if (currentAnnotations != null) {
- resolveAnnotations(resolutionScope, currentAnnotations, new Annotation.TypeUseBinding(isWildcard() ? Binding.TYPE_PARAMETER : Binding.TYPE_USE));
- if (evalNullAnnotations) {
- int len = currentAnnotations.length;
- for (int j=0; j<len; j++) {
- Binding recipient = currentAnnotations[j].recipient;
- if (recipient instanceof Annotation.TypeUseBinding) {
- long nullTagBits = ((Annotation.TypeUseBinding)recipient).tagBits & TagBits.AnnotationNullMASK;
- if (nullTagBits != 0) {
- if (isArrayReference) {
- if (tagBitsPerDimension == null)
- tagBitsPerDimension = new long[dimensions+1]; // each dimension plus leaf component type at last position
- // @NonNull Foo [][][] means the leaf component type is @NonNull:
- tagBitsPerDimension[dimensions] = nullTagBits;
- } else {
- tagBits |= nullTagBits;
- }
- }
- }
- }
- }
- }
- }
+ TypeBinding leafComponentType = this.resolvedType.leafComponentType();
+ leafComponentType = resolveAnnotations(resolutionScope, this.annotations, leafComponentType);
+ this.resolvedType = dimensions > 0 ? scope.environment().createArrayType(leafComponentType, dimensions) : leafComponentType;
}
-
if (annotationsOnDimensions != null) {
- for (int i = 0, length = annotationsOnDimensions.length; i < length; i++) {
- Annotation [] dimensionAnnotations = annotationsOnDimensions[i];
- if (dimensionAnnotations != null) {
- resolveAnnotations(resolutionScope, dimensionAnnotations, new Annotation.TypeUseBinding(Binding.TYPE_USE));
- if (evalNullAnnotations && isArrayReference) {
- int len = dimensionAnnotations.length;
- for (int j=0; j<len; j++) {
- Binding recipient = dimensionAnnotations[j].recipient;
- if (recipient instanceof Annotation.TypeUseBinding) {
- long nullTagBits = ((Annotation.TypeUseBinding)recipient).tagBits & TagBits.AnnotationNullMASK;
- if (nullTagBits != 0) {
- if (tagBitsPerDimension == null)
- tagBitsPerDimension = new long[dimensions+1];
- tagBitsPerDimension[i] = nullTagBits;
- }
- }
- }
- }
- }
- }
- }
- if (this.resolvedType != null && this.resolvedType.isValidBinding()) {
- if (isArrayReference) {
- if (tagBitsPerDimension != null) {
- // TODO(stephan): wouldn't it be more efficient to store the array bindings inside the type binding rather than the environment?
- // cf. LocalTypeBinding.createArrayType()
- this.resolvedType = scope.environment().createArrayType(this.resolvedType.leafComponentType(), dimensions, tagBitsPerDimension);
- }
- } else {
- if (tagBits != 0) {
- if (!this.resolvedType.isBaseType()) {
- this.resolvedType = scope.environment().createAnnotatedType(this.resolvedType, tagBits);
- } else {
- // TODO(stephan) report null annotation on non-reference type
- }
- }
- }
+ this.resolvedType = resolveAnnotations(resolutionScope, annotationsOnDimensions, this.resolvedType);
}
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotatableTypeSystem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotatableTypeSystem.java
new file mode 100644
index 0000000..cead307
--- /dev/null
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotatableTypeSystem.java
@@ -0,0 +1,392 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ *
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.lookup;
+
+import org.eclipse.jdt.internal.compiler.util.Util;
+import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.DependentTypeBinding;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.ITeamAnchor;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.RoleTypeBinding;
+
+/* AnnotatableTypeSystem: Keep track of annotated types so as to provide unique bindings for identically annotated versions identical underlying "naked" types.
+ As of now, we ensure uniqueness only for marker annotated types, i.e two instances of @NonNull String would have the same binding, while @T(1) X and @T(2) X
+ will not. Binding uniqueness is only a memory optimization and is not essential for correctness of compilation. Various subsystems should expect to determine
+ binding identity/equality by calling TypeBinding.equalsEquals and not by using == operator.
+
+ ATS is a superset of UTS and is not a subclass of UTS for obvious reasons. ATS maintains a handle to the UnannotatedTypeSystem over whose types ATS adds
+ annotations to create annotated types. ATS is AnnotatableTypeSystem and not AnnotatedTypeSystem, various methods may actually return unannotated types if the
+ input arguments do not specify any annotations and component types of the composite type being constructed are themselves unannotated.
+
+ We do not keep track of unannotated types here, that is done by UTS whose handle we maintain.
+*/
+public class AnnotatableTypeSystem {
+
+ LookupEnvironment environment;
+ UnannotatedTypeSystem unannotatedTypeSystem;
+
+ private SimpleLookupTable annotatedTypes; // store of all annotated types created so far. Unlike earlier incarnation of LE, we maintain one look up table for all derived types.
+
+ public AnnotatableTypeSystem(LookupEnvironment environment) {
+ this.environment = environment;
+ this.unannotatedTypeSystem = new UnannotatedTypeSystem(environment);
+ this.annotatedTypes = new SimpleLookupTable(16);
+ }
+
+ public TypeBinding getUnannotatedType(TypeBinding type) {
+ return this.unannotatedTypeSystem.getUnannotatedType(type);
+ }
+
+ /* This method replaces the version that used to sit in LE. The parameter `annotations' is a flattened sequence of annotations,
+ where each dimension's annotations end with a sentinel null.
+ */
+ public ArrayBinding getArrayType(TypeBinding leafType, int dimensions, AnnotationBinding [] annotations) {
+
+ if (!haveTypeAnnotations(leafType, annotations))
+ return this.unannotatedTypeSystem.getArrayType(leafType, dimensions);
+
+ TypeBinding[] cachedInfo = (TypeBinding[]) this.annotatedTypes.get(leafType);
+ int index = 0;
+ if (cachedInfo != null) {
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null) break;
+ if (cachedType.isArrayType() && cachedType.dimensions() == dimensions && Util.effectivelyEqual(cachedType.getTypeAnnotations(), annotations))
+ return (ArrayBinding) cachedType;
+ }
+ } else {
+ this.annotatedTypes.put(leafType, cachedInfo = new TypeBinding[4]);
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.annotatedTypes.put(leafType, cachedInfo);
+ }
+ // Add the newcomer, ensuring its identity is the same as the naked version of it.
+ ArrayBinding unannotatedArrayType = this.unannotatedTypeSystem.getArrayType(leafType, dimensions);
+ TypeBinding arrayBinding = new ArrayBinding(leafType, dimensions, this.environment);
+ arrayBinding.id = unannotatedArrayType.id;
+ arrayBinding.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return (ArrayBinding) (cachedInfo[index] = arrayBinding);
+ }
+
+ public ParameterizedTypeBinding getParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType, AnnotationBinding [] annotations) {
+//{ObjectTeams: more arguments for role types:
+ return getParameterizedType(genericType, typeArguments, null, -1, enclosingType, annotations);
+ }
+ public ParameterizedTypeBinding getParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments,
+ ITeamAnchor teamAnchor, int valueParamPosition, ReferenceBinding enclosingType, AnnotationBinding [] annotations) {
+/* orig:
+ if (!haveTypeAnnotations(genericType, enclosingType, typeArguments, annotations))
+ return this.unannotatedTypeSystem.getParameterizedType(genericType, typeArguments, enclosingType);
+ :giro */
+ if (!haveTypeAnnotations(genericType, enclosingType, typeArguments, annotations))
+ return this.unannotatedTypeSystem.getParameterizedType(genericType, typeArguments, teamAnchor, valueParamPosition, enclosingType);
+// SH}
+
+ /* When restoring annotations from class files, we encounter a situation where the generic type comes in attributed with the annotations that should
+ really belong to the parameterized type that is being created just now. e.g @T List<String> => comes in as (@T List)<String>. The question really
+ is List being parameterized by String and then the resultant type is annotated or is "@T List" being parameterized with String ? We don't care one
+ way or other except that we would want a uniform treatment. As a stop gap, we "repair" the situation here, so it is consistent with treatment of
+ type references in source code. Probably need similar treatment for raw types and wildcards ?
+ */
+ AnnotationBinding [] misplacedAnnotations = genericType.getTypeAnnotations();
+ if (misplacedAnnotations != null && misplacedAnnotations != Binding.NO_ANNOTATIONS) {
+ if (annotations != null && annotations != Binding.NO_ANNOTATIONS)
+ throw new IllegalStateException(); // cannot cut both ways.
+ annotations = misplacedAnnotations;
+ genericType = (ReferenceBinding) this.unannotatedTypeSystem.getUnannotatedType(genericType);
+ }
+
+ int index = 0;
+ TypeBinding[] cachedInfo = (TypeBinding[]) this.annotatedTypes.get(genericType);
+ if (cachedInfo != null) {
+ for (int max = cachedInfo.length; index < max; index++){
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isParameterizedType())
+ continue;
+//{ObjectTeams: also match team anchor if given:
+ if (!this.unannotatedTypeSystem.isRoleTypeMatch(teamAnchor, valueParamPosition, cachedType))
+ continue;
+// SH}
+ if (cachedType.enclosingType() == enclosingType && Util.effectivelyEqual(annotations, cachedType.getTypeAnnotations()) && Util.effectivelyEqual(cachedType.typeArguments(), typeArguments))
+ return (ParameterizedTypeBinding) cachedType;
+ }
+ } else {
+ this.annotatedTypes.put(genericType, cachedInfo = new TypeBinding[4]);
+ }
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.annotatedTypes.put(genericType, cachedInfo);
+ }
+ // Add the new comer, retaining the same type binding id as the naked type.
+//{ObjectTeams: dependent type?
+/* orig:
+ ParameterizedTypeBinding unannotatedParameterizedType = this.unannotatedTypeSystem.getParameterizedType(genericType, typeArguments, enclosingType);
+ TypeBinding parameterizedType = new ParameterizedTypeBinding(genericType, typeArguments, enclosingType, this.environment);
+ :giro */
+ ParameterizedTypeBinding unannotatedParameterizedType = this.unannotatedTypeSystem.getParameterizedType(genericType, typeArguments,
+ teamAnchor, valueParamPosition, enclosingType);
+ ParameterizedTypeBinding parameterizedType;
+ if (teamAnchor == null) {
+ parameterizedType = new ParameterizedTypeBinding(genericType,typeArguments, enclosingType, this.environment);
+ } else {
+ if (genericType.isRole()) {
+ parameterizedType = new RoleTypeBinding(genericType, typeArguments, teamAnchor, enclosingType, this.environment);
+ } else {
+ parameterizedType = new DependentTypeBinding(genericType, typeArguments, teamAnchor, valueParamPosition, enclosingType, this.environment);
+ }
+ }
+// SH}
+ parameterizedType.id = unannotatedParameterizedType.id;
+ parameterizedType.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return (ParameterizedTypeBinding) (cachedInfo[index] = parameterizedType);
+ }
+
+ public RawTypeBinding getRawType(ReferenceBinding genericType, ReferenceBinding enclosingType, AnnotationBinding [] annotations) {
+
+ if (!haveTypeAnnotations(genericType, enclosingType, null, annotations))
+ return this.unannotatedTypeSystem.getRawType(genericType, enclosingType);
+
+ TypeBinding[] cachedInfo = (TypeBinding[]) this.annotatedTypes.get(genericType);
+ int index = 0;
+ if (cachedInfo != null) {
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (cachedType.isRawType() && cachedType.enclosingType() == enclosingType && Util.effectivelyEqual(cachedType.getTypeAnnotations(), annotations))
+ return (RawTypeBinding) cachedType;
+ }
+ } else {
+ this.annotatedTypes.put(genericType, cachedInfo = new TypeBinding[4]);
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.annotatedTypes.put(genericType, cachedInfo);
+ }
+ // Add the new comer, retaining the same type binding id as the naked type.
+ RawTypeBinding unannotatedRawType = this.unannotatedTypeSystem.getRawType(genericType, enclosingType);
+ TypeBinding rawType = new RawTypeBinding(genericType, enclosingType, this.environment);
+ rawType.id = unannotatedRawType.id;
+ rawType.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return (RawTypeBinding) (cachedInfo[index] = rawType);
+ }
+
+ public WildcardBinding getWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind, AnnotationBinding [] annotations) {
+
+ if (!haveTypeAnnotations(genericType, bound, otherBounds, annotations))
+ return this.unannotatedTypeSystem.getWildcard(genericType, rank, bound, otherBounds, boundKind);
+
+ if (genericType == null) // pseudo wildcard denoting composite bounds for lub computation
+ genericType = ReferenceBinding.LUB_GENERIC;
+
+ TypeBinding[] cachedInfo = (TypeBinding[]) this.annotatedTypes.get(genericType);
+ int index = 0;
+ if (cachedInfo != null) {
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isWildcard())
+ continue;
+ if (cachedType.rank() != rank || cachedType.boundKind() != boundKind || cachedType.bound() != bound)
+ continue;
+ if (Util.effectivelyEqual(cachedType.additionalBounds(), otherBounds) && Util.effectivelyEqual(cachedType.getTypeAnnotations(), annotations))
+ return (WildcardBinding) cachedType;
+ }
+ } else {
+ this.annotatedTypes.put(genericType, cachedInfo = new TypeBinding[4]);
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.annotatedTypes.put(genericType, cachedInfo);
+ }
+ // Add the new comer, retaining the same type binding id as the naked type.
+ TypeBinding unannotatedWildcard = this.unannotatedTypeSystem.getWildcard(genericType, rank, bound, otherBounds, boundKind);
+ TypeBinding wildcard = new WildcardBinding(genericType, rank, bound, otherBounds, boundKind, this.environment);
+ wildcard.id = unannotatedWildcard.id;
+ wildcard.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return (WildcardBinding) (cachedInfo[index] = wildcard);
+ }
+
+ // Private subroutine for getAnnotatedType(TypeBinding type, AnnotationBinding[][] annotations)
+ private TypeBinding getAnnotatedType(TypeBinding type, TypeBinding enclosingType, TypeBinding [] typeArguments, AnnotationBinding[] annotations) {
+ TypeBinding[] cachedInfo = (TypeBinding[]) this.annotatedTypes.get(type);
+ int i = 0;
+ if (cachedInfo != null) {
+ for (int length = cachedInfo.length; i < length; i++) {
+ TypeBinding cachedType = cachedInfo[i];
+ if (cachedType == null) break;
+ if (cachedType.enclosingType() == enclosingType) {
+ if (Util.effectivelyEqual(cachedType.getTypeAnnotations(), annotations) && Util.effectivelyEqual(cachedType.typeArguments(), typeArguments)) {
+ return cachedType;
+ }
+ }
+ }
+ } else {
+ this.annotatedTypes.put(type, cachedInfo = new TypeBinding[4]);
+ }
+ int length = cachedInfo.length;
+ if (i == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.annotatedTypes.put(type, cachedInfo);
+ }
+ /* Add the new comer, retaining the same type binding id as the naked type. To materialize the new comer we can't use new since this is a general
+ purpose method designed to deal type bindings of all types. "Clone" the incoming type, specializing for any enclosing type and type arguments
+ that may themselves be possibly be annotated. This is so the binding for @Outer Outer.Inner != Outer.@Inner Inner != @Outer Outer.@Inner Inner.
+ Likewise so the bindings for @Readonly List<@NonNull String> != @Readonly List<@Nullable String> != @Readonly List<@Interned String>
+ */
+ TypeBinding unannotatedType = this.unannotatedTypeSystem.getUnannotatedType(type);
+ TypeBinding annotatedType = type.clone(enclosingType, typeArguments);
+ annotatedType.id = unannotatedType.id;
+ annotatedType.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return cachedInfo[i] = annotatedType;
+ }
+
+ /* Take a type and apply annotations to various components of it. By construction when we see the type reference @Outer Outer.@Middle Middle.@Inner Inner,
+ we first construct the binding for Outer.Middle.Inner and then annotate various parts of it. Likewise for PQTR's binding.
+ */
+ public TypeBinding getAnnotatedType(TypeBinding type, AnnotationBinding[][] annotations) {
+
+ if (type == null || !type.isValidBinding() || annotations == null || annotations.length == 0)
+ return type;
+
+ TypeBinding annotatedType = null;
+ switch (type.kind()) {
+ case Binding.ARRAY_TYPE:
+ ArrayBinding arrayBinding = (ArrayBinding) type;
+ annotatedType = getArrayType(arrayBinding.leafComponentType, arrayBinding.dimensions, flattenedAnnotations(annotations));
+ break;
+ case Binding.BASE_TYPE:
+ case Binding.TYPE:
+ case Binding.GENERIC_TYPE:
+ case Binding.PARAMETERIZED_TYPE:
+ case Binding.RAW_TYPE:
+ case Binding.TYPE_PARAMETER:
+ case Binding.WILDCARD_TYPE:
+ /* Taking the binding of QTR as an example, there could be different annotatable components, but we come in a with a single binding, e.g:
+ @T Z; type => Z annotations => [[@T]]
+ @T Y.@T Z type => Z annotations => [[@T][@T]]
+ @T X.@T Y.@T Z type => Z annotations => [[][][@T][@T][@T]]
+ java.lang.@T X.@T Y.@T Z
+ in all these cases the incoming type binding is for Z, but annotations are for different levels. Align their layout for proper attribution.
+ */
+ int levels = type.depth() + 1;
+ TypeBinding [] types = new TypeBinding[levels];
+ types[--levels] = type;
+ TypeBinding enclosingType = type.enclosingType();
+ while (enclosingType != null) {
+ types[--levels] = enclosingType;
+ enclosingType = enclosingType.enclosingType();
+ }
+ // Locate the outermost type being annotated. Beware annotations.length could be > types.length (for package qualified names in QTR/PQTR)
+ levels = annotations.length;
+ int i, j = types.length - levels;
+ for (i = 0 ; i < levels; i++, j++) {
+ if (annotations[i] != null && annotations[i].length > 0)
+ break;
+ }
+ if (i == levels) // empty annotations array ?
+ return type;
+ // types[j] is the first component being annotated. Its annotations are annotations[i]
+ for (enclosingType = j == 0 ? null : types[j - 1]; i < levels; i++, j++) {
+ annotatedType = getAnnotatedType(types[j], enclosingType, types[j].typeArguments(), annotations[i]);
+ enclosingType = annotatedType;
+ }
+ break;
+ }
+ return annotatedType;
+ }
+
+ public AnnotationBinding getAnnotationType(ReferenceBinding annotationType) {
+ return this.unannotatedTypeSystem.getAnnotationType(annotationType); // deflect, annotation type uses cannot be type annotated.
+ }
+
+ private boolean haveTypeAnnotations(TypeBinding baseType, TypeBinding someType, TypeBinding[] someTypes, AnnotationBinding[] annotations) {
+ if (baseType != null && baseType.hasTypeAnnotations())
+ return true;
+ if (someType != null && someType.hasTypeAnnotations())
+ return true;
+ for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++)
+ if (annotations [i] != null)
+ return true;
+ for (int i = 0, length = someTypes == null ? 0 : someTypes.length; i < length; i++)
+ if (someTypes[i].hasTypeAnnotations())
+ return true;
+ return false;
+ }
+
+ private boolean haveTypeAnnotations(TypeBinding leafType, AnnotationBinding[] annotations) {
+ return haveTypeAnnotations(leafType, null, null, annotations);
+ }
+
+ /* Utility method to "flatten" annotations. For multidimensional arrays, we encode the annotations into a flat array
+ where a null separates the annotations of dimension n from dimension n - 1 as well as dimenion n + 1. There is a
+ final null always.
+ */
+ static AnnotationBinding [] flattenedAnnotations (AnnotationBinding [][] annotations) {
+
+ if (annotations == null || annotations.length == 0)
+ return Binding.NO_ANNOTATIONS;
+
+ int levels = annotations.length;
+ int length = levels;
+ for (int i = 0; i < levels; i++) {
+ length += annotations[i] == null ? 0 : annotations[i].length;
+ }
+ if (length == 0)
+ return Binding.NO_ANNOTATIONS;
+
+ AnnotationBinding[] series = new AnnotationBinding [length];
+ int index = 0;
+ for (int i = 0; i < levels; i++) {
+ final int annotationsLength = annotations[i] == null ? 0 : annotations[i].length;
+ if (annotationsLength > 0) {
+ System.arraycopy(annotations[i], 0, series, index, annotationsLength);
+ index += annotationsLength;
+ }
+ series[index++] = null;
+ }
+ if (index != length)
+ throw new IllegalStateException();
+ return series;
+ }
+
+ public final void reset() { // develop amnesia
+ this.annotatedTypes = new SimpleLookupTable(16);
+ this.unannotatedTypeSystem.reset();
+ }
+
+ public void updateCaches(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType) {
+ if (this.annotatedTypes.get(unresolvedType) != null) { // update the key
+ Object[] keys = this.annotatedTypes.keyTable;
+ for (int i = 0, l = keys.length; i < l; i++) {
+ if (keys[i] == unresolvedType) {
+ keys[i] = resolvedType; // hashCode is based on compoundName so this works.
+ break;
+ }
+ }
+ }
+ this.unannotatedTypeSystem.updateCaches(unresolvedType.prototype, unresolvedType.prototype.resolvedType);
+ }
+}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
index ff4179e..6091c97 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java
@@ -50,9 +50,6 @@
public long[] nullTagBitsPerDimension;
public ArrayBinding(TypeBinding type, int dimensions, LookupEnvironment environment) {
- this(type, dimensions, environment, null);
-}
-public ArrayBinding(TypeBinding type, int dimensions, LookupEnvironment environment, long[] nullTagBitsPerDimension) {
this.tagBits |= TagBits.IsArrayType;
this.leafComponentType = type;
this.dimensions = dimensions;
@@ -61,10 +58,10 @@
((UnresolvedReferenceBinding) type).addWrapper(this, environment);
else
this.tagBits |= type.tagBits & (TagBits.HasTypeVariable | TagBits.HasDirectWildcard | TagBits.HasMissingType | TagBits.ContainsNestedTypeReferences);
-
- if (nullTagBitsPerDimension != null) {
- this.tagBits |= nullTagBitsPerDimension[0]; // outer-most dimension
- this.nullTagBitsPerDimension = nullTagBitsPerDimension;
+ long mask = type.tagBits & TagBits.AnnotationNullMASK;
+ if (mask != 0) {
+ this.nullTagBitsPerDimension = new long[this.dimensions + 1];
+ this.nullTagBitsPerDimension[this.dimensions] = mask;
this.tagBits |= TagBits.HasNullTypeAnnotation;
}
}
@@ -144,11 +141,33 @@
return this.constantPoolName = CharOperation.concat(brackets, this.leafComponentType.signature());
}
public String debugName() {
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
StringBuffer brackets = new StringBuffer(this.dimensions * 2);
for (int i = this.dimensions; --i >= 0;)
brackets.append("[]"); //$NON-NLS-1$
return this.leafComponentType.debugName() + brackets.toString();
}
+
+public String annotatedDebugName() {
+ StringBuffer brackets = new StringBuffer(this.dimensions * 2);
+ brackets.append(this.leafComponentType.annotatedDebugName());
+ brackets.append(' ');
+ AnnotationBinding [] annotations = getTypeAnnotations();
+ for (int i = 0, j = -1; i < this.dimensions; i++) {
+ if (annotations != null) {
+ if (i != 0)
+ brackets.append(' ');
+ while (++j < annotations.length && annotations[j] != null) {
+ brackets.append(annotations[j]);
+ brackets.append(' ');
+ }
+ }
+ brackets.append("[]"); //$NON-NLS-1$
+ }
+ return brackets.toString();
+}
+
public int dimensions() {
return this.dimensions;
}
@@ -159,18 +178,22 @@
*/
public TypeBinding elementsType() {
- long[] nullTagBitsSub = null;
- if (this.nullTagBitsPerDimension != null) {
- int len = this.nullTagBitsPerDimension.length-1;
- System.arraycopy(this.nullTagBitsPerDimension, 1, nullTagBitsSub = new long[len], 0, len);
- }
- if (this.dimensions == 1) {
- if (nullTagBitsSub != null && nullTagBitsSub[0] != 0L)
- return this.environment.createAnnotatedType(this.leafComponentType, nullTagBitsSub[0]);
+
+ if (this.dimensions == 1)
return this.leafComponentType;
+
+ AnnotationBinding [] oldies = getTypeAnnotations();
+ AnnotationBinding [] newbies = Binding.NO_ANNOTATIONS;
+
+ for (int i = 0, length = oldies == null ? 0 : oldies.length; i < length; i++) {
+ if (oldies[i] == null) {
+ System.arraycopy(oldies, i+1, newbies = new AnnotationBinding[length - i - 1], 0, length - i - 1);
+ break;
+ }
}
- return this.environment.createArrayType(this.leafComponentType, this.dimensions - 1, nullTagBitsSub);
+ return this.environment.createArrayType(this.leafComponentType, this.dimensions - 1, newbies);
}
+
/**
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#erasure()
*/
@@ -205,14 +228,7 @@
/* Answer true if the receiver type can be assigned to the argument type (right)
*/
public boolean isCompatibleWith(TypeBinding otherType, Scope captureScope) {
- // disregard any type annotations on this and otherType
- // recursive call needed when this is annotated, unless the annotation was introduced on a declaration
- otherType = otherType.unannotated();
- TypeBinding unannotated = unannotated();
- if (unannotated != this)
- return unannotated.isCompatibleWith(otherType, captureScope);
-
- if (this == otherType)
+ if (equalsEquals(this, otherType))
return true;
switch (otherType.kind()) {
@@ -325,6 +341,43 @@
}
return CharOperation.concat(this.leafComponentType.readableName(), brackets);
}
+
+public void setTypeAnnotations(AnnotationBinding[] annotations, boolean evalNullAnnotations) {
+
+ this.typeAnnotations = annotations;
+ this.tagBits |= TagBits.HasTypeAnnotations | TagBits.HasTypeAnnotations;
+
+ if (evalNullAnnotations) {
+ long nullTagBits = 0;
+ if (this.nullTagBitsPerDimension == null)
+ this.nullTagBitsPerDimension = new long[this.dimensions + 1];
+
+ int dimension = 0;
+ for (int i = 0, length = annotations.length; i < length; i++) {
+ AnnotationBinding annotation = annotations[i];
+ if (annotation != null) {
+ switch (annotation.type.id) {
+ case TypeIds.T_ConfiguredAnnotationNullable :
+ nullTagBits |= TagBits.AnnotationNullable;
+ this.tagBits |= TagBits.HasNullTypeAnnotation;
+ break;
+ case TypeIds.T_ConfiguredAnnotationNonNull :
+ nullTagBits |= TagBits.AnnotationNonNull;
+ this.tagBits |= TagBits.HasNullTypeAnnotation;
+ break;
+ }
+ } else {
+ // null signals end of annotations for the current dimension in the serialized form.
+ if (nullTagBits != 0) {
+ this.nullTagBitsPerDimension[dimension] = nullTagBits;
+ nullTagBits = 0;
+ }
+ dimension++;
+ }
+ }
+ this.tagBits |= this.nullTagBitsPerDimension[0]; // outer-most dimension
+ }
+}
public char[] shortReadableName(){
char[] brackets = new char[this.dimensions * 2];
for (int i = this.dimensions * 2 - 1; i >= 0; i -= 2) {
@@ -359,11 +412,10 @@
}
// SH}
public String toString() {
- return this.leafComponentType != null ? debugName() : "NULL TYPE ARRAY"; //$NON-NLS-1$
+ return this.leafComponentType != null ? this.hasTypeAnnotations() ? annotatedDebugName() : debugName() : "NULL TYPE ARRAY"; //$NON-NLS-1$
}
public TypeBinding unannotated() {
- if (this.nullTagBitsPerDimension == null)
- return this;
- return this.environment.createArrayType(this.leafComponentType, this.dimensions);
+ return this.hasTypeAnnotations() ? this.environment.getUnannotatedType(this) : this;
}
+
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BaseTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BaseTypeBinding.java
index 65826fe..1bc3bc9 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BaseTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BaseTypeBinding.java
@@ -134,6 +134,12 @@
this.simpleName = name;
this.constantPoolName = constantPoolName;
}
+
+ BaseTypeBinding(BaseTypeBinding prototype) {
+ super(prototype);
+ this.simpleName = prototype.simpleName;
+ this.constantPoolName = prototype.constantPoolName;
+ }
/**
* int -> I
@@ -149,6 +155,10 @@
return this.constantPoolName;
}
+ public TypeBinding clone(TypeBinding enclosingType, TypeBinding[] typeArguments) {
+ return new BaseTypeBinding(this);
+ }
+
public PackageBinding getPackage() {
return null;
@@ -157,7 +167,7 @@
/* Answer true if the receiver type can be assigned to the argument type (right)
*/
public final boolean isCompatibleWith(TypeBinding right, Scope captureScope) {
- if (this == right)
+ if (equalsEquals(this, right))
return true;
int right2left = this.id + (right.id<<4);
if (right2left >= 0
@@ -167,6 +177,28 @@
return this == TypeBinding.NULL && !right.isBaseType();
}
+ public TypeBinding unannotated() {
+ switch (this.id) {
+ case TypeIds.T_boolean:
+ return TypeBinding.BOOLEAN;
+ case TypeIds.T_byte:
+ return TypeBinding.BYTE;
+ case TypeIds.T_char:
+ return TypeBinding.CHAR;
+ case TypeIds.T_double:
+ return TypeBinding.DOUBLE;
+ case TypeIds.T_float:
+ return TypeBinding.FLOAT;
+ case TypeIds.T_int:
+ return TypeBinding.INT;
+ case TypeIds.T_long:
+ return TypeBinding.LONG;
+ case TypeIds.T_short:
+ return TypeBinding.SHORT;
+ default:
+ throw new IllegalStateException();
+ }
+ }
/**
* T_null is acting as an unchecked exception
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#isUncheckedException(boolean)
@@ -198,6 +230,6 @@
}
public String toString() {
- return new String(this.constantPoolName) + " (id=" + this.id + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+ return this.hasTypeAnnotations() ? annotatedDebugName() : new String(readableName());
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
index 533f78c..b7ad5af 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
@@ -132,6 +132,7 @@
protected MethodBinding[] methods;
protected ReferenceBinding[] memberTypes;
protected TypeVariableBinding[] typeVariables;
+ protected BinaryTypeBinding prototype;
// For the link with the principle structure
protected LookupEnvironment environment;
@@ -218,6 +219,18 @@
throw new IllegalStateException();
}
+public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ BinaryTypeBinding copy = new BinaryTypeBinding(this);
+
+ copy.enclosingType = (ReferenceBinding) outerType;
+ if (outerType instanceof UnresolvedReferenceBinding)
+ copy.tagBits |= TagBits.HasUnresolvedEnclosingType;
+ else
+ copy.tagBits &= ~TagBits.HasUnresolvedEnclosingType;
+
+ return copy;
+}
+
static AnnotationBinding createAnnotation(IBinaryAnnotation annotationInfo, LookupEnvironment env, char[][][] missingTypeNames) {
IBinaryElementValuePair[] binaryPairs = annotationInfo.getElementValuePairs();
int length = binaryPairs == null ? 0 : binaryPairs.length;
@@ -276,8 +289,22 @@
*/
protected BinaryTypeBinding() {
// only for subclasses
+ this.prototype = this;
}
+public BinaryTypeBinding(BinaryTypeBinding prototype) {
+ super(prototype);
+ this.superclass = prototype.superclass;
+ this.enclosingType = prototype.enclosingType;
+ this.superInterfaces = prototype.superInterfaces;
+ this.fields = prototype.fields;
+ this.methods = prototype.methods;
+ this.memberTypes = prototype.memberTypes;
+ this.typeVariables = prototype.typeVariables;
+ this.prototype = prototype.prototype;
+ this.environment = prototype.environment;
+ this.storedAnnotations = prototype.storedAnnotations;
+}
/**
* Standard constructor for creating binary type bindings from binary models (classfiles)
* @param packageBinding
@@ -285,6 +312,8 @@
* @param environment
*/
public BinaryTypeBinding(PackageBinding packageBinding, IBinaryType binaryType, LookupEnvironment environment) {
+
+ this.prototype = this;
this.compoundName = CharOperation.splitOn('/', binaryType.getName());
computeId();
@@ -334,9 +363,13 @@
}
/**
- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#availableMethods()
+ * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#availableFields()
*/
public FieldBinding[] availableFields() {
+
+ if (this != this.prototype)
+ return this.prototype.availableFields();
+
if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
return this.fields;
@@ -391,6 +424,10 @@
* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#availableMethods()
*/
public MethodBinding[] availableMethods() {
+
+ if (this != this.prototype)
+ return this.prototype.availableMethods();
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
return this.methods;
@@ -484,8 +521,7 @@
and/or super interfaces in order to be able to detect overriding in the presence
of generics.
*/
- TypeAnnotationWalker walker = (sourceLevel >= ClassFileConstants.JDK1_8 && globalOptions.isAnnotationBasedNullAnalysisEnabled) ?
- TypeAnnotationWalker.create(binaryType.getTypeAnnotations()) : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
+ TypeAnnotationWalker walker = sourceLevel >= ClassFileConstants.JDK1_8 ? TypeAnnotationWalker.create(binaryType.getTypeAnnotations()) : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
char[] typeSignature = binaryType.getGenericSignature(); // use generic signature even in 1.4
this.tagBits |= binaryType.getTagBits();
@@ -641,8 +677,7 @@
for (int i = 0; i < size; i++) {
IBinaryField binaryField = iFields[i];
char[] fieldSignature = use15specifics ? binaryField.getGenericSignature() : null;
- TypeAnnotationWalker walker = (use18specifics && this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) ?
- TypeAnnotationWalker.create(binaryField.getTypeAnnotations()).toField() : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
+ TypeAnnotationWalker walker = use18specifics ? TypeAnnotationWalker.create(binaryField.getTypeAnnotations()).toField() : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
TypeBinding type = fieldSignature == null
? this.environment.getTypeFromSignature(binaryField.getTypeName(), 0, -1, false, this, missingTypeNames, walker)
: this.environment.getTypeFromTypeSignature(new SignatureWrapper(fieldSignature), Binding.NO_TYPE_VARIABLES, this, missingTypeNames, walker);
@@ -747,8 +782,7 @@
variables properly in order to be able to apply substitutions and thus be able to detect
overriding in the presence of generics. Seeing the erased form is not good enough.
*/
- TypeAnnotationWalker walker = (sourceLevel >= ClassFileConstants.JDK1_8 && this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) ?
- TypeAnnotationWalker.create(method) : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
+ TypeAnnotationWalker walker = sourceLevel >= ClassFileConstants.JDK1_8 ? TypeAnnotationWalker.create(method) : TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
char[] methodSignature = method.getGenericSignature(); // always use generic signature, even in 1.4
if (methodSignature == null) { // no generics
char[] methodDescriptor = method.getMethodDescriptor(); // of the form (I[Ljava/jang/String;)V
@@ -1084,10 +1118,10 @@
int colon = CharOperation.indexOf(Util.C_COLON, typeSignature, i);
char[] variableName = CharOperation.subarray(typeSignature, i, colon);
TypeVariableBinding typeVariable = new TypeVariableBinding(variableName, this, rank, this.environment);
- IBinaryAnnotation[] annotations = walker.toTypeParameter(isClassTypeParameter, rank++).getAnnotationsAtCursor();
- long annotationTagBits = this.environment.typeAnnotationsToTagBits(annotations);
- if (annotationTagBits != 0)
- typeVariable.tagBits |= annotationTagBits | TagBits.HasNullTypeAnnotation;
+ AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.toTypeParameter(isClassTypeParameter, rank++).getAnnotationsAtCursor(),
+ this.environment, missingTypeNames);
+ if (annotations != null && annotations != Binding.NO_ANNOTATIONS)
+ typeVariable.setTypeAnnotations(annotations, this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
variables.add(typeVariable);
}
}
@@ -1111,6 +1145,7 @@
* NOTE: enclosingType of a binary type is resolved when needed
*/
public ReferenceBinding enclosingType() {
+
if ((this.tagBits & TagBits.HasUnresolvedEnclosingType) == 0)
return this.enclosingType;
@@ -1121,6 +1156,10 @@
}
// NOTE: the type of each field of a binary type is resolved when needed
public FieldBinding[] fields() {
+
+ if (this != this.prototype)
+ return this.prototype.fields();
+
if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
return this.fields;
@@ -1203,12 +1242,17 @@
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#genericTypeSignature()
*/
public char[] genericTypeSignature() {
+ if (this != this.prototype)
+ return this.prototype.computeGenericTypeSignature(this.typeVariables);
return computeGenericTypeSignature(this.typeVariables);
}
//NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
+ if (this != this.prototype)
+ return this.prototype.getExactConstructor(argumentTypes);
+
// lazily sort methods
if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
int length = this.methods.length;
@@ -1244,6 +1288,9 @@
public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) {
// sender from refScope calls recordTypeReference(this)
+ if (this != this.prototype)
+ return this.prototype.getExactMethod(selector, argumentTypes, refScope);
+
// lazily sort methods
if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
int length = this.methods.length;
@@ -1306,6 +1353,10 @@
}
//NOTE: the type of a field of a binary type is resolved when needed
public FieldBinding getField(char[] fieldName, boolean needResolve) {
+
+ if (this != this.prototype)
+ return this.prototype.getField(fieldName, needResolve);
+
// lazily sort fields
if ((this.tagBits & TagBits.AreFieldsSorted) == 0) {
int length = this.fields.length;
@@ -1320,6 +1371,10 @@
* Rewrite of default getMemberType to avoid resolving eagerly all member types when one is requested
*/
public ReferenceBinding getMemberType(char[] typeName) {
+
+ if (this != this.prototype)
+ return this.prototype.getMemberType(typeName);
+
for (int i = this.memberTypes.length; --i >= 0;) {
ReferenceBinding memberType = this.memberTypes[i];
if (memberType instanceof UnresolvedReferenceBinding) {
@@ -1369,6 +1424,10 @@
// SH}
// NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
public MethodBinding[] getMethods(char[] selector) {
+
+ if (this != this.prototype)
+ return this.prototype.getMethods(selector);
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0) {
long range;
if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
@@ -1405,6 +1464,10 @@
// Answer methods named selector, which take no more than the suggestedParameterLength.
// The suggested parameter length is optional and may not be guaranteed by every type.
public MethodBinding[] getMethods(char[] selector, int suggestedParameterLength) {
+
+ if (this != this.prototype)
+ return this.prototype.getMethods(selector, suggestedParameterLength);
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
return getMethods(selector);
// lazily sort methods
@@ -1444,15 +1507,24 @@
return Binding.NO_METHODS;
}
public boolean hasMemberTypes() {
+ if (this != this.prototype)
+ return this.prototype.hasMemberTypes();
return this.memberTypes.length > 0;
}
// NOTE: member types of binary types are resolved when needed
public TypeVariableBinding getTypeVariable(char[] variableName) {
+ if (this != this.prototype)
+ return this.prototype.getTypeVariable(variableName);
+
TypeVariableBinding variable = super.getTypeVariable(variableName);
variable.resolve();
return variable;
}
public boolean hasTypeBit(int bit) {
+
+ if (this != this.prototype)
+ return this.prototype.hasTypeBit(bit);
+
// ensure hierarchy is resolved, which will propagate bits down to us
boolean wasToleratingMissingTypeProcessingAnnotations = this.environment.mayTolerateMissingType;
this.environment.mayTolerateMissingType = true;
@@ -1511,7 +1583,8 @@
* or for generic types, true if compared to its raw type.
*/
public boolean isEquivalentTo(TypeBinding otherType) {
- if (this == otherType) return true;
+
+ if (TypeBinding.equalsEquals(this, otherType)) return true;
if (otherType == null) return false;
switch(otherType.kind()) {
case Binding.WILDCARD_TYPE :
@@ -1526,24 +1599,40 @@
not. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=186565 && https://bugs.eclipse.org/bugs/show_bug.cgi?id=328827
*/
case Binding.RAW_TYPE :
- return otherType.erasure() == this;
+ return TypeBinding.equalsEquals(otherType.erasure(), this);
}
return false;
}
public boolean isGenericType() {
+
+ if (this != this.prototype)
+ return this.prototype.isGenericType();
+
return this.typeVariables != Binding.NO_TYPE_VARIABLES;
}
public boolean isHierarchyConnected() {
+
+ if (this != this.prototype)
+ return this.prototype.isHierarchyConnected();
+
return (this.tagBits & (TagBits.HasUnresolvedSuperclass | TagBits.HasUnresolvedSuperinterfaces)) == 0;
}
public int kind() {
+
+ if (this != this.prototype)
+ return this.prototype.kind();
+
if (this.typeVariables != Binding.NO_TYPE_VARIABLES)
return Binding.GENERIC_TYPE;
return Binding.TYPE;
}
// NOTE: member types of binary types are resolved when needed
public ReferenceBinding[] memberTypes() {
- if ((this.tagBits & TagBits.HasUnresolvedMemberTypes) == 0)
+
+ if (this != this.prototype)
+ return this.prototype.memberTypes();
+
+ if ((this.tagBits & TagBits.HasUnresolvedMemberTypes) == 0)
return this.memberTypes;
for (int i = this.memberTypes.length; --i >= 0;)
@@ -1553,6 +1642,10 @@
}
// NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
public MethodBinding[] methods() {
+
+ if (this != this.prototype)
+ return this.prototype.methods();
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
return this.methods;
@@ -1569,6 +1662,10 @@
return this.methods;
}
private FieldBinding resolveTypeFor(FieldBinding field) {
+
+ if (this != this.prototype)
+ return this.prototype.resolveTypeFor(field);
+
if ((field.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
return field;
@@ -1599,6 +1696,10 @@
return field;
}
MethodBinding resolveTypesFor(MethodBinding method) {
+
+ if (this != this.prototype)
+ return this.prototype.resolveTypesFor(method);
+
if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
return method;
@@ -1646,9 +1747,17 @@
public
// SH}
AnnotationBinding[] retrieveAnnotations(Binding binding) {
+
+ if (this != this.prototype)
+ return this.prototype.retrieveAnnotations(binding);
+
return AnnotationBinding.addStandardAnnotations(super.retrieveAnnotations(binding), binding.getAnnotationTagBits(), this.environment);
}
SimpleLookupTable storedAnnotations(boolean forceInitialize) {
+
+ if (this != this.prototype)
+ return this.prototype.storedAnnotations(forceInitialize);
+
if (forceInitialize && this.storedAnnotations == null) {
//{ObjectTeams: do support annotations for roles for the sake of copying:
if (!this.isRole())
@@ -1660,18 +1769,7 @@
return this.storedAnnotations;
}
-void scanFieldForNullAnnotation(IBinaryField field, FieldBinding fieldBinding) {
- if (this.environment.globalOptions.sourceLevel >= ClassFileConstants.JDK1_8) {
- TypeBinding fieldType = fieldBinding.type;
- if (fieldType != null
- && !fieldType.isBaseType()
- && (fieldType.tagBits & TagBits.AnnotationNullMASK) == 0
- && (this.tagBits & TagBits.AnnotationNonNullByDefault) != 0) {
- fieldBinding.type = this.environment.createAnnotatedType(fieldType, TagBits.AnnotationNonNull);
- }
- return; // not using fieldBinding.tagBits when we have type annotations.
- }
-
+private void scanFieldForNullAnnotation(IBinaryField field, FieldBinding fieldBinding) {
// global option is checked by caller
char[][] nullableAnnotationName = this.environment.getNullableAnnotationName();
char[][] nonNullAnnotationName = this.environment.getNonNullAnnotationName();
@@ -1706,7 +1804,7 @@
}
}
-void scanMethodForNullAnnotation(IBinaryMethod method, MethodBinding methodBinding) {
+private void scanMethodForNullAnnotation(IBinaryMethod method, MethodBinding methodBinding) {
if (!this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled)
return;
boolean useTypeAnnotations = this.environment.globalOptions.sourceLevel >= ClassFileConstants.JDK1_8;
@@ -1777,7 +1875,7 @@
}
}
}
-void scanTypeForNullDefaultAnnotation(IBinaryType binaryType, PackageBinding packageBinding, BinaryTypeBinding binaryBinding) {
+private void scanTypeForNullDefaultAnnotation(IBinaryType binaryType, PackageBinding packageBinding, BinaryTypeBinding binaryBinding) {
char[][] nonNullByDefaultAnnotationName = this.environment.getNonNullByDefaultAnnotationName();
if (nonNullByDefaultAnnotationName == null)
return; // not well-configured to use null annotations
@@ -1858,6 +1956,10 @@
* NOTE: superclass of a binary type is resolved when needed
*/
public ReferenceBinding superclass() {
+
+ if (this != this.prototype)
+ return this.prototype.superclass();
+
if ((this.tagBits & TagBits.HasUnresolvedSuperclass) == 0)
return this.superclass;
@@ -1901,6 +2003,10 @@
// NOTE: superInterfaces of binary types are resolved when needed
public ReferenceBinding[] superInterfaces() {
+
+ if (this != this.prototype)
+ return this.prototype.superInterfaces();
+
if ((this.tagBits & TagBits.HasUnresolvedSuperinterfaces) == 0)
return this.superInterfaces;
@@ -1925,6 +2031,10 @@
return this.superInterfaces;
}
public TypeVariableBinding[] typeVariables() {
+
+ if (this != this.prototype)
+ return this.prototype.typeVariables();
+
if ((this.tagBits & TagBits.HasUnresolvedTypeVariables) == 0)
return this.typeVariables;
@@ -1934,6 +2044,10 @@
return this.typeVariables;
}
public String toString() {
+
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
+
StringBuffer buffer = new StringBuffer();
if (isDeprecated()) buffer.append("deprecated "); //$NON-NLS-1$
@@ -2029,11 +2143,24 @@
buffer.append("\n\n\n"); //$NON-NLS-1$
return buffer.toString();
}
+
+public TypeBinding unannotated() {
+ return this.prototype;
+}
+
MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types
+
+ if (this != this.prototype)
+ return this.prototype.unResolvedMethods();
+
return this.methods;
}
public FieldBinding[] unResolvedFields() {
+
+ if (this != this.prototype)
+ return this.prototype.unResolvedFields();
+
return this.fields;
}
//{ObjectTeams: for use by TypeModel:
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CaptureBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CaptureBinding.java
index 03df6f1..913ca61 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CaptureBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CaptureBinding.java
@@ -1,10 +1,14 @@
/*******************************************************************************
- * Copyright (c) 2000, 2009 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
*
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
* Contributors:
* IBM Corporation - initial API and implementation
* Technical University Berlin - extended API and implementation
@@ -30,7 +34,13 @@
public CaptureBinding(WildcardBinding wildcard, ReferenceBinding sourceType, int position, int captureID) {
super(TypeConstants.WILDCARD_CAPTURE_NAME_PREFIX, null, 0, wildcard.environment);
- this.wildcard = wildcard;
+ // Capture the unannotated wildcard and then capture the annotations.
+ if (wildcard.hasTypeAnnotations()) {
+ this.wildcard = (WildcardBinding) wildcard.unannotated();
+ setTypeAnnotations(wildcard.getTypeAnnotations(), wildcard.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ } else {
+ this.wildcard = wildcard;
+ }
this.modifiers = ClassFileConstants.AccPublic | ExtraCompilerModifiers.AccGenericSignature; // treat capture as public
this.fPackage = wildcard.fPackage;
this.sourceType = sourceType;
@@ -63,6 +73,11 @@
if (this.wildcard != null) {
StringBuffer buffer = new StringBuffer(10);
+ AnnotationBinding [] annotations = getTypeAnnotations();
+ for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) {
+ buffer.append(annotations[i]);
+ buffer.append(' ');
+ }
buffer
.append(TypeConstants.WILDCARD_CAPTURE_NAME_PREFIX)
.append(this.captureID)
@@ -207,7 +222,7 @@
* @see TypeBinding#isEquivalentTo(TypeBinding)
*/
public boolean isEquivalentTo(TypeBinding otherType) {
- if (this == otherType) return true;
+ if (equalsEquals(this, otherType)) return true;
if (otherType == null) return false;
// capture of ? extends X[]
if (this.firstBound != null && this.firstBound.isArrayType()) {
@@ -257,6 +272,11 @@
public String toString() {
if (this.wildcard != null) {
StringBuffer buffer = new StringBuffer(10);
+ AnnotationBinding [] annotations = getTypeAnnotations();
+ for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) {
+ buffer.append(annotations[i]);
+ buffer.append(' ');
+ }
buffer
.append(TypeConstants.WILDCARD_CAPTURE_NAME_PREFIX)
.append(this.captureID)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
index aa902a2..8a506c4 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
@@ -136,9 +136,11 @@
if (sourceLevel < ClassFileConstants.JDK1_8) {
currentMethod.tagBits |= tagBits;
} else {
- if (!currentMethod.returnType.isBaseType())
- currentMethod.returnType = scope.environment()
- .createAnnotatedType(currentMethod.returnType, tagBits);
+ if (!currentMethod.returnType.isBaseType()) {
+ // TODO(Stephan: Synthesize AnnotationBinding[] and call LE#createAnnotatedType(TB, AB[]);
+ // currentMethod.returnType = scope.environment()
+ // .createAnnotatedType(currentMethod.returnType, tagBits);
+ }
}
}
}
@@ -398,8 +400,10 @@
if (environment.globalOptions.sourceLevel < ClassFileConstants.JDK1_8) {
method.tagBits |= nullnessBits;
} else {
- if (!method.returnType.isBaseType())
- method.returnType = environment.createAnnotatedType(method.returnType, nullnessBits);
+ if (!method.returnType.isBaseType()) {
+ // TODO(Stephan: Synthesize AnnotationBinding[] and call LE#createAnnotatedType(TB, AB[]);
+ // method.returnType = environment.createAnnotatedType(method.returnType, nullnessBits);
+ }
}
}
@@ -454,8 +458,9 @@
}
}
void recordArgNonNullness18(MethodBinding method, int paramIdx, Argument currentArgument, Boolean nonNullNess, LookupEnvironment env) {
- method.parameters[paramIdx] = env.createAnnotatedType(method.parameters[paramIdx],
- nonNullNess.booleanValue() ? TagBits.AnnotationNonNull : TagBits.AnnotationNullable);
+ // TODO(Stephan: Synthesize AnnotationBinding[] and call LE#createAnnotatedType(TB, AB[]);
+ // method.parameters[paramIdx] = env.createAnnotatedType(method.parameters[paramIdx],
+ // nonNullNess.booleanValue() ? TagBits.AnnotationNonNull : TagBits.AnnotationNullable);
if (currentArgument != null) {
currentArgument.binding.type = method.parameters[paramIdx];
}
@@ -522,7 +527,7 @@
//{ObjectTeams: enable role type comparison
//added parameters 3 & 4:
static boolean areTypesEqual(TypeBinding one, TypeBinding two, MethodBinding methodTwo, LookupEnvironment environment) {
- if (one == two) return true;
+ if (TypeBinding.equalsEquals(one, two)) return true;
// different comparison for role types:
if (areEqualRoleTypes(one, two, methodTwo.declaringClass, environment))
return true;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalTypeBinding.java
index 278a36d..4f3d236 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LocalTypeBinding.java
@@ -41,7 +41,6 @@
final static char[] LocalTypePrefix = { '$', 'L', 'o', 'c', 'a', 'l', '$' };
private InnerEmulationDependency[] dependents;
- public ArrayBinding[] localArrayBindings; // used to cache array bindings of various dimensions for this local type
public CaseStatement enclosingCase; // from 1.4 on, local types should not be accessed across switch case blocks (52221)
public int sourceStart; // used by computeUniqueKey to uniquely identify this binding
public MethodBinding enclosingMethod;
@@ -78,6 +77,14 @@
// SH}
}
+public LocalTypeBinding(LocalTypeBinding prototype) {
+ super(prototype);
+ this.dependents = prototype.dependents;
+ this.enclosingCase = prototype.enclosingCase;
+ this.sourceStart = prototype.sourceStart;
+ this.enclosingMethod = prototype.enclosingMethod;
+}
+
/* Record a dependency onto a source target type which may be altered
* by the end of the innerclass emulation. Later on, we will revisit
* all its dependents so as to update them (see updateInnerEmulationDependents()).
@@ -102,6 +109,9 @@
* Returns the anonymous original super type (in some error cases, superclass may get substituted with Object)
*/
public ReferenceBinding anonymousOriginalSuperType() {
+ if (this != this.prototype)
+ return ((LocalTypeBinding) this.prototype).anonymousOriginalSuperType();
+
if (this.superInterfaces != Binding.NO_SUPERINTERFACES) {
return this.superInterfaces[0];
}
@@ -118,6 +128,10 @@
}
protected void checkRedundantNullnessDefaultRecurse(ASTNode location, Annotation[] annotations, long annotationTagBits) {
+ if (this != this.prototype) {
+ this.prototype.checkRedundantNullnessDefaultRecurse(location, annotations, annotationTagBits);
+ return;
+ }
long outerDefault = this.enclosingMethod != null ? this.enclosingMethod.tagBits & ((TagBits.AnnotationNonNullByDefault|TagBits.AnnotationNullUnspecifiedByDefault)) : 0;
if (outerDefault != 0) {
if (outerDefault == annotationTagBits) {
@@ -129,6 +143,9 @@
}
public char[] computeUniqueKey(boolean isLeaf) {
+ if (this != this.prototype)
+ return this.prototype.computeUniqueKey(isLeaf);
+
char[] outerKey = outermostEnclosingType().computeUniqueKey(isLeaf);
int semicolon = CharOperation.lastIndexOf(';', outerKey);
@@ -155,6 +172,10 @@
}
public char[] constantPoolName() /* java/lang/Object */ {
+ if (this.constantPoolName != null)
+ return this.constantPoolName;
+ if (this != this.prototype)
+ this.prototype.constantPoolName();
if (this.constantPoolName == null && this.scope != null) {
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=322154, we do have some
// cases where the left hand does not know what the right is doing.
@@ -163,28 +184,27 @@
return this.constantPoolName;
}
-ArrayBinding createArrayType(int dimensionCount, LookupEnvironment lookupEnvironment) {
- if (this.localArrayBindings == null) {
- this.localArrayBindings = new ArrayBinding[] {new ArrayBinding(this, dimensionCount, lookupEnvironment)};
- return this.localArrayBindings[0];
+public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ LocalTypeBinding copy = new LocalTypeBinding(this);
+ if (outerType == null) {
+ outerType = enclosingType();
}
- // find the cached array binding for this dimensionCount (if any)
- int length = this.localArrayBindings.length;
- for (int i = 0; i < length; i++)
- if (this.localArrayBindings[i].dimensions == dimensionCount)
- return this.localArrayBindings[i];
-
- // no matching array
- System.arraycopy(this.localArrayBindings, 0, this.localArrayBindings = new ArrayBinding[length + 1], 0, length);
- return this.localArrayBindings[length] = new ArrayBinding(this, dimensionCount, lookupEnvironment);
+ return copy;
}
+public int hashCode() {
+ return this.enclosingType.hashCode();
+}
/*
* Overriden for code assist. In this case, the constantPoolName() has not been computed yet.
* Slam the source name so that the signature is syntactically correct.
* (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=99686)
*/
public char[] genericTypeSignature() {
+
+ if (this != this.prototype)
+ return this.prototype.genericTypeSignature();
+
if (this.genericReferenceTypeSignature == null && this.constantPoolName == null) {
if (isAnonymousType())
setConstantPoolName(superclass().sourceName());
@@ -244,12 +264,20 @@
return shortReadableName;
}
-// Record that the type is a local member type
+//Record that the type is a local member type
public void setAsMemberType() {
+ if (this != this.prototype) {
+ ((LocalTypeBinding) this.prototype).setAsMemberType();
+ return;
+ }
this.tagBits |= TagBits.MemberTypeMask;
}
public void setConstantPoolName(char[] computedConstantPoolName) /* java/lang/Object */ {
+ if (this != this.prototype) {
+ ((LocalTypeBinding) this.prototype).setConstantPoolName(computedConstantPoolName);
+ return;
+ }
this.constantPoolName = computedConstantPoolName;
}
//{ObjectTeams:
@@ -269,6 +297,10 @@
* (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=102284)
*/
public char[] signature() {
+
+ if (this != this.prototype)
+ return this.prototype.signature();
+
if (this.signature == null && this.constantPoolName == null) {
if (isAnonymousType())
setConstantPoolName(superclass().sourceName());
@@ -286,6 +318,9 @@
}
public String toString() {
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName() + " (local)"; //$NON-NLS-1$
+
if (isAnonymousType())
return "Anonymous type : " + super.toString(); //$NON-NLS-1$
if (isMemberType())
@@ -297,6 +332,10 @@
* to be propagated to all dependent source types.
*/
public void updateInnerEmulationDependents() {
+ if (this != this.prototype) {
+ ((LocalTypeBinding) this.prototype).updateInnerEmulationDependents();
+ return;
+ }
if (this.dependents != null) {
for (int i = 0; i < this.dependents.length; i++) {
InnerEmulationDependency dependency = this.dependents[i];
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
index 7b26590..2165a37 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
@@ -31,7 +31,6 @@
package org.eclipse.jdt.internal.compiler.lookup;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@@ -55,9 +54,7 @@
import org.eclipse.objectteams.otdt.internal.core.compiler.control.Dependencies;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.ITranslationStates;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.StateHelper;
-import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.DependentTypeBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.ITeamAnchor;
-import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.RoleTypeBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.TeamModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.RoleSplitter;
import org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.TeamMethodGenerator;
@@ -117,6 +114,8 @@
private int lastCompletedUnitIndex = -1;
private int lastUnitIndex = -1;
+ private AnnotatableTypeSystem typeSystem;
+
public INameEnvironment nameEnvironment;
public CompilerOptions globalOptions;
@@ -129,11 +128,7 @@
private int stepCompleted;
public ITypeRequestor typeRequestor;
- private ArrayBinding[][] uniqueArrayBindings;
private IntersectionCastTypeBinding[][] uniqueIntersectionCastTypeBindings;
- private SimpleLookupTable uniqueParameterizedTypeBindings;
- private SimpleLookupTable uniqueRawTypeBindings;
- private SimpleLookupTable uniqueWildcardBindings;
private SimpleLookupTable uniqueParameterizedGenericMethodBindings;
// key is a string with the method selector value is an array of method bindings
@@ -184,18 +179,14 @@
this.defaultImports = null;
this.nameEnvironment = nameEnvironment;
this.knownPackages = new HashtableOfPackage();
- this.uniqueArrayBindings = new ArrayBinding[5][];
- this.uniqueArrayBindings[0] = new ArrayBinding[50]; // start off the most common 1 dimension array @ 50
this.uniqueIntersectionCastTypeBindings = new IntersectionCastTypeBinding[0][0];
- this.uniqueParameterizedTypeBindings = new SimpleLookupTable(3);
- this.uniqueRawTypeBindings = new SimpleLookupTable(3);
- this.uniqueWildcardBindings = new SimpleLookupTable(3);
this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
this.uniquePolymorphicMethodBindings = new SimpleLookupTable(3);
this.missingTypes = null;
this.accessRestrictions = new HashMap(3);
this.classFilePool = ClassFilePool.newInstance();
this.typesBeingConnected = new HashSet();
+ this.typeSystem = new AnnotatableTypeSystem(this);
}
/**
@@ -858,60 +849,27 @@
return type;
}
/*
- * Used to guarantee annotation identity.
+ * Used to guarantee annotation identity: we do that only for marker annotations. We don't have the machinery for the general case as of now.
*/
public AnnotationBinding createAnnotation(ReferenceBinding annotationType, ElementValuePair[] pairs) {
if (pairs.length != 0) {
AnnotationBinding.setMethodBindings(annotationType, pairs);
+ return new AnnotationBinding(annotationType, pairs);
}
- return new AnnotationBinding(annotationType, pairs);
+ return this.typeSystem.getAnnotationType(annotationType);
}
/*
* Used to guarantee array type identity.
*/
public ArrayBinding createArrayType(TypeBinding leafComponentType, int dimensionCount) {
- return createArrayType(leafComponentType, dimensionCount, null);
+ return this.typeSystem.getArrayType(leafComponentType, dimensionCount, Binding.NO_ANNOTATIONS);
}
-public ArrayBinding createArrayType(TypeBinding leafComponentType, int dimensionCount, long[] nullTagBitsPerDimension) {
- if (leafComponentType instanceof LocalTypeBinding) // cache local type arrays with the local type itself
- return ((LocalTypeBinding) leafComponentType).createArrayType(dimensionCount, this);
- // find the array binding cache for this dimension
- int dimIndex = dimensionCount - 1;
- int length = this.uniqueArrayBindings.length;
- ArrayBinding[] arrayBindings;
- if (dimIndex < length) {
- if ((arrayBindings = this.uniqueArrayBindings[dimIndex]) == null)
- this.uniqueArrayBindings[dimIndex] = arrayBindings = new ArrayBinding[10];
- } else {
- System.arraycopy(
- this.uniqueArrayBindings, 0,
- this.uniqueArrayBindings = new ArrayBinding[dimensionCount][], 0,
- length);
- this.uniqueArrayBindings[dimIndex] = arrayBindings = new ArrayBinding[10];
- }
-
- // find the cached array binding for this leaf component type (if any)
- int index = -1;
- length = arrayBindings.length;
- while (++index < length) {
- ArrayBinding currentBinding = arrayBindings[index];
- if (currentBinding == null) // no matching array, but space left
- return arrayBindings[index] = new ArrayBinding(leafComponentType, dimensionCount, this, nullTagBitsPerDimension);
- if (currentBinding.leafComponentType == leafComponentType
- && Arrays.equals(currentBinding.nullTagBitsPerDimension, nullTagBitsPerDimension))
- return currentBinding;
- }
-
- // no matching array, no space left
- System.arraycopy(
- arrayBindings, 0,
- (arrayBindings = new ArrayBinding[length * 2]), 0,
- length);
- this.uniqueArrayBindings[dimIndex] = arrayBindings;
- return arrayBindings[length] = new ArrayBinding(leafComponentType, dimensionCount, this, nullTagBitsPerDimension);
+public ArrayBinding createArrayType(TypeBinding leafComponentType, int dimensionCount, AnnotationBinding [] annotations) {
+ return this.typeSystem.getArrayType(leafComponentType, dimensionCount, annotations);
}
+
public TypeBinding createIntersectionCastType(ReferenceBinding[] intersectingTypes) {
// this is perhaps an overkill, but since what is worth doing is worth doing well ...
@@ -1223,255 +1181,48 @@
}
public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType) {
- return createParameterizedType(genericType, typeArguments, 0L, enclosingType);
-}
-/**
- * Create a ParameterizedTypeBinding or ArrayBinding which represents the same structure as the given genericType,
- * but with type annotations as given by 'annotationBits' (TagBits.AnnotationNonNull or TagBits.AnnotationNullable).
- */
-public TypeBinding createAnnotatedType(TypeBinding genericType, long annotationBits) {
- if (genericType instanceof UnresolvedReferenceBinding) {
- // clone so we don't interfere with future lookups:
- return new UnresolvedReferenceBinding((UnresolvedReferenceBinding)genericType, annotationBits);
- }
- if (genericType instanceof ReferenceBinding) {
- TypeBinding[] typeArguments = genericType.isParameterizedType() ? ((ParameterizedTypeBinding) genericType).arguments : null;
- ParameterizedTypeBinding parameterizedType = createParameterizedType((ReferenceBinding) genericType.original(), typeArguments,
- annotationBits, genericType.enclosingType());
- parameterizedType.id = genericType.id; // for well-known types shared the id (only here since those types are not generic, are they?)
- return parameterizedType;
- } else if (genericType instanceof ArrayBinding) {
- long[] tagBitsPerDims = ((ArrayBinding) genericType).nullTagBitsPerDimension;
- if (tagBitsPerDims == null)
- tagBitsPerDims = new long[genericType.dimensions()+1];
- if (tagBitsPerDims[0] != annotationBits) {
- tagBitsPerDims[0] = annotationBits;
- return createArrayType(genericType.leafComponentType(), genericType.dimensions(), tagBitsPerDims);
- }
- }
- return genericType;
+ return this.typeSystem.getParameterizedType(genericType, typeArguments, enclosingType, Binding.NO_ANNOTATIONS);
}
-/**
- * After an 'annotatedType' has been substituted yielding 'unannotatedSubstitute,
- * use this method to re-apply the null type annotations from 'annotatedType' to the substitute.
- * We assume that both types are structurally equivalent.
- */
-public TypeBinding copyAnnotations(TypeBinding annotatedType, TypeBinding unannotatedSubstitute) {
- if (!annotatedType.hasNullTypeAnnotations())
- return unannotatedSubstitute;
-
- // FIXME(stephan): what if both types have (some) null annotations??
- if (unannotatedSubstitute instanceof ReferenceBinding) {
- TypeBinding[] newArguments = null;
- if (annotatedType.isParameterizedType() && unannotatedSubstitute.isParameterizedType()) {
- ParameterizedTypeBinding unannotatedPTB = (ParameterizedTypeBinding) unannotatedSubstitute;
- ParameterizedTypeBinding annotatedPTB = (ParameterizedTypeBinding) annotatedType;
- if (unannotatedPTB.arguments != null
- && annotatedPTB.arguments != null
- && unannotatedPTB.arguments.length == annotatedPTB.arguments.length) {
- int length = annotatedPTB.arguments.length;
- newArguments = new TypeBinding[length];
- for (int i = 0; i < length; i++) {
- newArguments[i] = copyAnnotations(annotatedPTB.arguments[i], unannotatedPTB.arguments[i]);
- }
- }
- }
- ReferenceBinding annotatedEnclosing = annotatedType.enclosingType();
- ReferenceBinding newEnclosing = unannotatedSubstitute.enclosingType();
- if (annotatedEnclosing != null && annotatedEnclosing.hasNullTypeAnnotations())
- newEnclosing = (ReferenceBinding) copyAnnotations(annotatedEnclosing, newEnclosing);
- long nullTagBits = annotatedType.tagBits & TagBits.AnnotationNullMASK;
- return createParameterizedType((ReferenceBinding)unannotatedSubstitute.original(), newArguments, nullTagBits, newEnclosing);
-
- } else if (annotatedType instanceof ArrayBinding && unannotatedSubstitute instanceof ArrayBinding) {
- long[] tagBitsOnDimensions = ((ArrayBinding) annotatedType).nullTagBitsPerDimension;
- TypeBinding annotatedLeaf = annotatedType.leafComponentType();
- TypeBinding newLeafType = unannotatedSubstitute.leafComponentType();
- if (annotatedLeaf.hasNullTypeAnnotations())
- newLeafType = copyAnnotations(annotatedLeaf, newLeafType);
- return createArrayType(newLeafType, unannotatedSubstitute.dimensions(), tagBitsOnDimensions);
- }
- return unannotatedSubstitute; // shouldn't happen actually
-}
-
-/**
- * Note: annotationBits are exactly those tagBits from annotations on type parameters that are interpreted by the compiler, currently: null annotations.
- * typeArguments should never be Binding.NO_TYPES, but rather: null, if no type arguments are present (and only annotationBits are the reason for coming here).
- */
-public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, long annotationBits, ReferenceBinding enclosingType) {
-//{ObjectTeams: new overload: support team anchors, too:
- ITeamAnchor anchor = null;
- int valueParamPosition = -1;
- if (DependentTypeBinding.isDependentType(genericType)) {
- anchor = ((DependentTypeBinding)genericType)._teamAnchor;
- valueParamPosition = ((DependentTypeBinding)genericType)._valueParamPosition;
- }
- return createParameterizedType(genericType, typeArguments, annotationBits, anchor, valueParamPosition, enclosingType);
-}
-public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, long annotationBits, ITeamAnchor teamAnchor, int valueParamPosition, ReferenceBinding enclosingType) {
+//{ObjectTeams: for anchored role types:
+public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments,
+ ITeamAnchor teamAnchor, int valueParamPosition, ReferenceBinding enclosingType, AnnotationBinding[] annotations) {
if (teamAnchor != null) {
genericType = genericType.getRealType();
if (genericType.isParameterizedType())
genericType = (ReferenceBinding) genericType.erasure();
}
+ return this.typeSystem.getParameterizedType(genericType, typeArguments, teamAnchor, valueParamPosition, enclosingType, annotations);
+}
// SH}
- // cached info is array of already created parameterized types for this type
- ParameterizedTypeBinding[] cachedInfo = (ParameterizedTypeBinding[])this.uniqueParameterizedTypeBindings.get(genericType);
- int argLength = typeArguments == null ? 0: typeArguments.length;
- boolean needToGrow = false;
- int index = 0;
- if (cachedInfo != null){
- nextCachedType :
- // iterate existing parameterized for reusing one with same type arguments if any
- for (int max = cachedInfo.length; index < max; index++){
- ParameterizedTypeBinding cachedType = cachedInfo[index];
- if (cachedType == null) break nextCachedType;
- if (cachedType.actualType() != genericType) continue nextCachedType; // remain of unresolved type
- if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
- long cachedBits = cachedType.tagBits & TagBits.AnnotationNullMASK;
- if ((cachedBits | annotationBits) != 0 && cachedBits != annotationBits) continue nextCachedType;
- TypeBinding[] cachedArguments = cachedType.arguments;
- int cachedArgLength = cachedArguments == null ? 0 : cachedArguments.length;
- if (argLength != cachedArgLength) continue nextCachedType; // would be an error situation (from unresolved binaries)
- for (int j = 0; j < cachedArgLength; j++){
- if (typeArguments[j] != cachedArguments[j]) continue nextCachedType;
- }
-//{ObjectTeams: also match team anchor if given:
- if (teamAnchor != null) {
- if (!(cachedType instanceof DependentTypeBinding))
- continue nextCachedType;
- if (!((DependentTypeBinding)cachedType)._teamAnchor.hasSameBestNameAs(teamAnchor))
- continue nextCachedType;
- }
- if ( valueParamPosition > -1 // position specified, requires dependent type
- && !(cachedType instanceof DependentTypeBinding))
- continue nextCachedType;
- if ( (cachedType instanceof DependentTypeBinding) // dependent type specified, positions must match
- && ((DependentTypeBinding)cachedType)._valueParamPosition != valueParamPosition)
- continue nextCachedType;
- if (teamAnchor == null && RoleTypeBinding.isRoleType(cachedType)) // role type found though not requested?
- continue nextCachedType;
-// SH}
- // all arguments match, reuse current
- return cachedType;
- }
- needToGrow = true;
- } else {
- cachedInfo = new ParameterizedTypeBinding[5];
- this.uniqueParameterizedTypeBindings.put(genericType, cachedInfo);
+
+public TypeBinding createAnnotatedType(TypeBinding type, AnnotationBinding[][] annotations) {
+ return this.typeSystem.getAnnotatedType(type, annotations);
+}
+
+// Variant to handle incoming type possibly carrying annotations.
+public TypeBinding createAnnotatedType(TypeBinding type, AnnotationBinding[] newbies) {
+ final int newLength = newbies == null ? 0 : newbies.length;
+ if (type == null || newLength == 0)
+ return type;
+ AnnotationBinding [] oldies = type.getTypeAnnotations();
+ final int oldLength = oldies == null ? 0 : oldies.length;
+ if (oldLength > 0) {
+ System.arraycopy(newbies, 0, newbies = new AnnotationBinding[newLength + oldLength], 0, newLength);
+ System.arraycopy(oldies, 0, newbies, newLength, oldLength);
}
- // grow cache ?
- int length = cachedInfo.length;
- if (needToGrow && index == length){
- System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedTypeBinding[length*2], 0, length);
- this.uniqueParameterizedTypeBindings.put(genericType, cachedInfo);
- }
- // add new binding
-//{ObjectTeams: dependent type?
-/* orig:
- ParameterizedTypeBinding parameterizedType = new ParameterizedTypeBinding(genericType,typeArguments, enclosingType, this);
- :giro */
- ParameterizedTypeBinding parameterizedType;
- if (teamAnchor == null) {
- parameterizedType = new ParameterizedTypeBinding(genericType,typeArguments, enclosingType, this);
- } else {
- if (genericType.isRole()) {
- parameterizedType = new RoleTypeBinding(genericType, typeArguments, teamAnchor, enclosingType, this);
- } else {
- parameterizedType = new DependentTypeBinding(genericType, typeArguments, teamAnchor, valueParamPosition, enclosingType, this);
- }
- }
-// SH}
- if (annotationBits != 0L)
- parameterizedType.tagBits |= annotationBits | TagBits.HasNullTypeAnnotation;
- cachedInfo[index] = parameterizedType;
- return parameterizedType;
+
+ TypeBinding annotatedType = this.typeSystem.getAnnotatedType(type, new AnnotationBinding [][] { newbies });
+ annotatedType.tagBits |= type.tagBits & TagBits.AnnotationNullMASK; // carry over any synthesized null bits e.g new Object() unless the annotation binding themselves are synthesized.
+ return annotatedType;
}
public RawTypeBinding createRawType(ReferenceBinding genericType, ReferenceBinding enclosingType) {
- // cached info is array of already created raw types for this type
- RawTypeBinding[] cachedInfo = (RawTypeBinding[])this.uniqueRawTypeBindings.get(genericType);
- boolean needToGrow = false;
- int index = 0;
- if (cachedInfo != null){
- nextCachedType :
- // iterate existing parameterized for reusing one with same type arguments if any
- for (int max = cachedInfo.length; index < max; index++){
- RawTypeBinding cachedType = cachedInfo[index];
- if (cachedType == null) break nextCachedType;
- if (cachedType.actualType() != genericType) continue nextCachedType; // remain of unresolved type
- if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
- // all enclosing type match, reuse current
- return cachedType;
- }
- needToGrow = true;
- } else {
- cachedInfo = new RawTypeBinding[1];
- this.uniqueRawTypeBindings.put(genericType, cachedInfo);
- }
- // grow cache ?
- int length = cachedInfo.length;
- if (needToGrow && index == length){
- System.arraycopy(cachedInfo, 0, cachedInfo = new RawTypeBinding[length*2], 0, length);
- this.uniqueRawTypeBindings.put(genericType, cachedInfo);
- }
- // add new binding
- RawTypeBinding rawType = new RawTypeBinding(genericType, enclosingType, this);
- cachedInfo[index] = rawType;
- return rawType;
-
+ return this.typeSystem.getRawType(genericType, enclosingType, Binding.NO_ANNOTATIONS);
}
public WildcardBinding createWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind) {
- return createWildcard(genericType, rank, bound, otherBounds, boundKind, 0);
-}
-public WildcardBinding createWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind, long annotationTagBits) {
- // cached info is array of already created wildcard types for this type
- if (genericType == null) // pseudo wildcard denoting composite bounds for lub computation
- genericType = ReferenceBinding.LUB_GENERIC;
- WildcardBinding[] cachedInfo = (WildcardBinding[])this.uniqueWildcardBindings.get(genericType);
- boolean needToGrow = false;
- int index = 0;
- if (cachedInfo != null){
- nextCachedType :
- // iterate existing wildcards for reusing one with same information if any
- for (int max = cachedInfo.length; index < max; index++){
- WildcardBinding cachedType = cachedInfo[index];
- if (cachedType == null) break nextCachedType;
- if (cachedType.genericType != genericType) continue nextCachedType; // remain of unresolved type
- if (cachedType.rank != rank) continue nextCachedType;
- if ((cachedType.tagBits & TagBits.AnnotationNullMASK) != annotationTagBits) continue nextCachedType;
- if (cachedType.boundKind != boundKind) continue nextCachedType;
- if (cachedType.bound != bound) continue nextCachedType;
- if (cachedType.otherBounds != otherBounds) {
- int cachedLength = cachedType.otherBounds == null ? 0 : cachedType.otherBounds.length;
- int length = otherBounds == null ? 0 : otherBounds.length;
- if (cachedLength != length) continue nextCachedType;
- for (int j = 0; j < length; j++) {
- if (cachedType.otherBounds[j] != otherBounds[j]) continue nextCachedType;
- }
- }
- // all match, reuse current
- return cachedType;
- }
- needToGrow = true;
- } else {
- cachedInfo = new WildcardBinding[10];
- this.uniqueWildcardBindings.put(genericType, cachedInfo);
- }
- // grow cache ?
- int length = cachedInfo.length;
- if (needToGrow && index == length){
- System.arraycopy(cachedInfo, 0, cachedInfo = new WildcardBinding[length*2], 0, length);
- this.uniqueWildcardBindings.put(genericType, cachedInfo);
- }
- // add new binding
- WildcardBinding wildcard = new WildcardBinding(genericType, rank, bound, otherBounds, boundKind, this);
- if (annotationTagBits != 0)
- wildcard.tagBits |= annotationTagBits | TagBits.HasNullTypeAnnotation;
- cachedInfo[index] = wildcard;
- return wildcard;
+ return this.typeSystem.getWildcard(genericType, rank, bound, otherBounds, boundKind, Binding.NO_ANNOTATIONS);
}
/**
@@ -1503,10 +1254,20 @@
return packageBinding.getType0(compoundName[compoundName.length - 1]);
}
+public AnnotationBinding getNullableAnnotation() {
+ ReferenceBinding nullable = getResolvedType(this.globalOptions.nullableAnnotationName, null);
+ return new AnnotationBinding(nullable, Binding.NO_ELEMENT_VALUE_PAIRS);
+}
+
public char[][] getNullableAnnotationName() {
return this.globalOptions.nullableAnnotationName;
}
+public AnnotationBinding getNonNullAnnotation() {
+ ReferenceBinding nonNull = getResolvedType(this.globalOptions.nonNullAnnotationName, null);
+ return new AnnotationBinding(nonNull, Binding.NO_ELEMENT_VALUE_PAIRS);
+}
+
public char[][] getNonNullAnnotationName() {
return this.globalOptions.nonNullAnnotationName;
}
@@ -1761,11 +1522,19 @@
dimension++;
}
// null annotations on dimensions?
- long[] annotationTagBitsOnDimensions = null;
+ AnnotationBinding [][] annotationsOnDimensions = null;
if (dimension > 0 && walker != TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
- annotationTagBitsOnDimensions = getAnnotationTagBitsOnDimensions(dimension, walker);
+ for (int i = 0; i < dimension; i++) {
+ AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ if (annotations != Binding.NO_ANNOTATIONS) {
+ if (annotationsOnDimensions == null)
+ annotationsOnDimensions = new AnnotationBinding[dimension][];
+ annotationsOnDimensions[i] = annotations;
+ }
+ walker = walker.toNextArrayDimension();
+ }
}
-
+
if (end == -1)
end = signature.length - 1;
@@ -1805,59 +1574,24 @@
// will never reach here, since error will cause abort
}
} else {
- ReferenceBinding refType = getTypeFromConstantPoolName(signature, start + 1, end, isParameterized, missingTypeNames); // skip leading 'L' or 'T'
- int depth = refType.depth();
- while (depth > 0 && walker != TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
- walker = walker.toNextNestedType();
- depth--;
- }
- long tagBits = typeAnnotationsToTagBits(walker.getAnnotationsAtCursor());
- if (tagBits != 0 && annotationTagBitsOnDimensions == null) {
- binding = createAnnotatedType(refType, tagBits);
- } else {
- if (annotationTagBitsOnDimensions != null)
- annotationTagBitsOnDimensions[dimension] = tagBits; // insert leaf type into array
- binding = refType;
- }
+ binding = getTypeFromConstantPoolName(signature, start + 1, end, isParameterized, missingTypeNames); // skip leading 'L' or 'T'
}
-
- if (dimension == 0)
- return binding;
- if (annotationTagBitsOnDimensions != null)
- return createArrayType(binding, dimension, annotationTagBitsOnDimensions);
- return createArrayType(binding, dimension);
-}
-
-private long[] getAnnotationTagBitsOnDimensions(int dimension, TypeAnnotationWalker walker) {
- TypeAnnotationWalker dimensionsWalker = null;
- long[] annotationTagBitsOnDimensions = null;
- for (int i = 0; i < dimension; i++) {
- if (dimensionsWalker == null)
- dimensionsWalker = walker; // outermost dimension == main type
- else
- dimensionsWalker = dimensionsWalker.toNextArrayDimension();
- long tagBits = typeAnnotationsToTagBits(dimensionsWalker.getAnnotationsAtCursor());
- if (tagBits != 0L) {
- if (annotationTagBitsOnDimensions == null)
- annotationTagBitsOnDimensions = new long[dimension+1]; // leave room for leaf type
- annotationTagBitsOnDimensions[i] = tagBits;
- }
+
+ int depth = binding.depth();
+ while (depth > 0 && walker != TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) { // we are dropping annotations on enclosing types.
+ walker = walker.toNextNestedType();
+ depth--;
}
- return annotationTagBitsOnDimensions;
-}
-
-public long typeAnnotationsToTagBits(IBinaryAnnotation[] annotations) {
- long tagBits = 0;
- for (int i = 0; i < annotations.length; i++) {
- char[] typeName = annotations[i].getTypeName();
- if (qualifiedNameMatchesSignature(getNonNullAnnotationName(), typeName)) {
- tagBits |= TagBits.AnnotationNonNull;
- } else if (qualifiedNameMatchesSignature(getNullableAnnotationName(), typeName)) {
- tagBits |= TagBits.AnnotationNullable;
- }
- // TODO(stephan): detect conflict
- }
- return tagBits;
+ AnnotationBinding [][] annotations = new AnnotationBinding[depth + 1][];
+ annotations[depth] = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+
+ if (annotations[depth] != null && annotations[depth] != Binding.NO_ANNOTATIONS)
+ binding = createAnnotatedType(binding, annotations);
+
+ if (dimension != 0)
+ binding = this.typeSystem.getArrayType(binding, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
+
+ return binding;
}
boolean qualifiedNameMatchesSignature(char[][] name, char[] signature) {
@@ -1893,7 +1627,7 @@
int varEnd = wrapper.computeEnd();
for (int i = staticVariables.length; --i >= 0;)
if (CharOperation.equals(staticVariables[i].sourceName, wrapper.signature, varStart, varEnd))
- return typeFromTypeVariable(staticVariables[i], dimension, walker);
+ return typeFromTypeVariable(staticVariables[i], dimension, walker, missingTypeNames);
ReferenceBinding initialType = enclosingType;
do {
TypeVariableBinding[] enclosingTypeVariables;
@@ -1904,7 +1638,7 @@
}
for (int i = enclosingTypeVariables.length; --i >= 0;)
if (CharOperation.equals(enclosingTypeVariables[i].sourceName, wrapper.signature, varStart, varEnd))
- return typeFromTypeVariable(enclosingTypeVariables[i], dimension, walker);
+ return typeFromTypeVariable(enclosingTypeVariables[i], dimension, walker, missingTypeNames);
} while ((enclosingType = enclosingType.enclosingType()) != null);
this.problemReporter.undefinedTypeVariableSignature(CharOperation.subarray(wrapper.signature, varStart, varEnd), initialType);
return null; // cannot reach this, since previous problem will abort compilation
@@ -1948,19 +1682,29 @@
return dimension == 0 ? (TypeBinding) parameterizedType : createArrayType(parameterizedType, dimension);
}
-private TypeBinding typeFromTypeVariable(TypeVariableBinding typeVariableBinding, int dimension, TypeAnnotationWalker walker) {
- long tagBits = typeAnnotationsToTagBits(walker.getAnnotationsAtCursor());
- if (dimension == 0) {
- if (tagBits != 0L)
- return createAnnotatedType(typeVariableBinding, tagBits);
- return typeVariableBinding;
- } else {
- long[] annotationTagBitsOnDimensions = null;
- if (walker != TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
- annotationTagBitsOnDimensions = getAnnotationTagBitsOnDimensions(dimension, walker);
+private TypeBinding typeFromTypeVariable(TypeVariableBinding typeVariableBinding, int dimension, TypeAnnotationWalker walker, char [][][] missingTypeNames) {
+ AnnotationBinding [] annotations;
+ AnnotationBinding [][] annotationsOnDimensions = null;
+ if (walker != TypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
+ for (int i = 0; i < dimension; i++) {
+ annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ if (annotations != Binding.NO_ANNOTATIONS) {
+ if (annotationsOnDimensions == null)
+ annotationsOnDimensions = new AnnotationBinding[dimension][];
+ annotationsOnDimensions[i] = annotations;
+ }
+ walker = walker.toNextArrayDimension();
}
- return createArrayType(typeVariableBinding, dimension, annotationTagBitsOnDimensions);
}
+
+ annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ if (annotations != null && annotations != Binding.NO_ANNOTATIONS)
+ typeVariableBinding = (TypeVariableBinding) createAnnotatedType(typeVariableBinding, new AnnotationBinding [][] { annotations });
+
+ if (dimension == 0) {
+ return typeVariableBinding;
+ }
+ return this.typeSystem.getArrayType(typeVariableBinding, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
}
TypeBinding getTypeFromVariantTypeSignature(
@@ -1980,19 +1724,19 @@
// ? super aType
wrapper.start++;
TypeBinding bound = getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker.toWildcardBound());
- long tagBits = typeAnnotationsToTagBits(walker.getAnnotationsAtCursor());
- return createWildcard(genericType, rank, bound, null /*no extra bound*/, Wildcard.SUPER, tagBits);
+ AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ return this.typeSystem.getWildcard(genericType, rank, bound, null /*no extra bound*/, Wildcard.SUPER, annotations);
case '+' :
// ? extends aType
wrapper.start++;
bound = getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker.toWildcardBound());
- tagBits = typeAnnotationsToTagBits(walker.getAnnotationsAtCursor());
- return createWildcard(genericType, rank, bound, null /*no extra bound*/, Wildcard.EXTENDS, tagBits);
+ annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ return this.typeSystem.getWildcard(genericType, rank, bound, null /*no extra bound*/, Wildcard.EXTENDS, annotations);
case '*' :
// ?
wrapper.start++;
- tagBits = typeAnnotationsToTagBits(walker.getAnnotationsAtCursor());
- return createWildcard(genericType, rank, null, null /*no extra bound*/, Wildcard.UNBOUND, tagBits);
+ annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(), this, missingTypeNames);
+ return this.typeSystem.getWildcard(genericType, rank, null, null /*no extra bound*/, Wildcard.UNBOUND, annotations);
default :
return getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker);
}
@@ -2042,16 +1786,8 @@
this.accessRestrictions = new HashMap(3);
this.verifier = null;
- for (int i = this.uniqueArrayBindings.length; --i >= 0;) {
- ArrayBinding[] arrayBindings = this.uniqueArrayBindings[i];
- if (arrayBindings != null)
- for (int j = arrayBindings.length; --j >= 0;)
- arrayBindings[j] = null;
- }
+
// NOTE: remember to fix #updateCaches(...) when adding unique binding caches
- this.uniqueParameterizedTypeBindings = new SimpleLookupTable(3);
- this.uniqueRawTypeBindings = new SimpleLookupTable(3);
- this.uniqueWildcardBindings = new SimpleLookupTable(3);
this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
this.uniquePolymorphicMethodBindings = new SimpleLookupTable(3);
this.uniqueGetClassMethodBinding = null;
@@ -2065,7 +1801,7 @@
this.unitBeingCompleted = null; // in case AbortException occurred
this.classFilePool.reset();
-
+ this.typeSystem.reset();
// name environment has a longer life cycle, and must be reset in
// the code which created it.
//{ObjectTeams: more state to release:
@@ -2084,35 +1820,7 @@
}
void updateCaches(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType) {
- // walk all the unique collections & replace the unresolvedType with the resolvedType
- // must prevent 2 entries so == still works (1 containing the unresolvedType and the other containing the resolvedType)
- if (this.uniqueParameterizedTypeBindings.get(unresolvedType) != null) { // update the key
- Object[] keys = this.uniqueParameterizedTypeBindings.keyTable;
- for (int i = 0, l = keys.length; i < l; i++) {
- if (keys[i] == unresolvedType) {
- keys[i] = resolvedType; // hashCode is based on compoundName so this works - cannot be raw since type of parameterized type
- break;
- }
- }
- }
- if (this.uniqueRawTypeBindings.get(unresolvedType) != null) { // update the key
- Object[] keys = this.uniqueRawTypeBindings.keyTable;
- for (int i = 0, l = keys.length; i < l; i++) {
- if (keys[i] == unresolvedType) {
- keys[i] = resolvedType; // hashCode is based on compoundName so this works
- break;
- }
- }
- }
- if (this.uniqueWildcardBindings.get(unresolvedType) != null) { // update the key
- Object[] keys = this.uniqueWildcardBindings.keyTable;
- for (int i = 0, l = keys.length; i < l; i++) {
- if (keys[i] == unresolvedType) {
- keys[i] = resolvedType; // hashCode is based on compoundName so this works
- break;
- }
- }
- }
+ this.typeSystem.updateCaches(unresolvedType, resolvedType);
}
//{ObjectTeams: translate the step completed into a dependencies step (from ITranslationStates):
public int getDependenciesStateCompleted() {
@@ -2144,4 +1852,9 @@
this.resolutionListeners = new IQualifiedTypeResolutionListener[length + 1], 0, length);
this.resolutionListeners[length] = resolutionListener;
}
+
+
+public TypeBinding getUnannotatedType(TypeBinding typeBinding) {
+ return this.typeSystem.getUnannotatedType(typeBinding);
}
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MemberTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MemberTypeBinding.java
index de5858f..0ff9319 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MemberTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MemberTypeBinding.java
@@ -39,10 +39,16 @@
*
*/
public final class MemberTypeBinding extends NestedTypeBinding {
+
public MemberTypeBinding(char[][] compoundName, ClassScope scope, SourceTypeBinding enclosingType) {
super(compoundName, scope, enclosingType);
this.tagBits |= TagBits.MemberTypeMask;
}
+
+public MemberTypeBinding(MemberTypeBinding prototype) {
+ super(prototype);
+}
+
void checkSyntheticArgsAndFields() {
//{ObjectTeams: role ifcs require synth args too
/* orig:
@@ -56,6 +62,10 @@
}
if (isStatic()) return;
// SH}
+ if (this != this.prototype) {
+ ((MemberTypeBinding) this.prototype).checkSyntheticArgsAndFields();
+ return;
+ }
this.addSyntheticArgumentAndField(this.enclosingType);
}
/* Answer the receiver's constant pool name.
@@ -64,16 +74,32 @@
*/
public char[] constantPoolName() /* java/lang/Object */ {
+
if (this.constantPoolName != null)
return this.constantPoolName;
+
+ if (this != this.prototype) {
+ return this.prototype.constantPoolName();
+ }
return this.constantPoolName = CharOperation.concat(enclosingType().constantPoolName(), this.sourceName, '$');
}
+public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ MemberTypeBinding copy = new MemberTypeBinding(this);
+ if (outerType != null)
+ copy.enclosingType = (SourceTypeBinding) outerType;
+ return copy;
+}
+
/**
* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()
*/
public void initializeDeprecatedAnnotationTagBits() {
+ if (this != this.prototype) {
+ this.prototype.initializeDeprecatedAnnotationTagBits();
+ return;
+ }
if ((this.tagBits & TagBits.DeprecatedAnnotationResolved) == 0) {
super.initializeDeprecatedAnnotationTagBits();
if ((this.tagBits & TagBits.AnnotationDeprecated) == 0) {
@@ -279,6 +305,10 @@
}
//SH}
public String toString() {
- return "Member type : " + new String(sourceName()) + " " + super.toString(); //$NON-NLS-2$ //$NON-NLS-1$
+ if (this.hasTypeAnnotations()) {
+ return annotatedDebugName();
+ } else {
+ return "Member type : " + new String(sourceName()) + " " + super.toString(); //$NON-NLS-2$ //$NON-NLS-1$
+ }
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
index faf7c59..9f36902 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
@@ -292,7 +292,7 @@
return false;
for (int i = 0; i < length; i++)
- if (this.parameters[i] != args[i] && this.parameters[i].erasure() != args[i].erasure())
+ if (TypeBinding.notEquals(this.parameters[i], args[i]) && TypeBinding.notEquals(this.parameters[i].erasure(), args[i].erasure()))
return false;
// :giro
} finally {
@@ -344,7 +344,7 @@
return false;
for (int i = 0; i < length; i++)
- if (this.parameters[i].unannotated() != args[i].unannotated())
+ if (TypeBinding.notEquals(this.parameters[i], args[i]))
return false;
return true;
}
@@ -926,7 +926,8 @@
if (existing == 0L) {
added = true;
if (!parameter.isBaseType()) {
- this.parameters[i] = env.createAnnotatedType(parameter, TagBits.AnnotationNonNull);
+ // TODO(Stephan): Synthesize AnnotationBinding[] and call LE#createAnnotatedType(TB, AB[]);
+ // this.parameters[i] = env.createAnnotatedType(parameter, TagBits.AnnotationNonNull);
if (sourceMethod != null)
sourceMethod.arguments[i].binding.type = this.parameters[i];
}
@@ -940,7 +941,8 @@
&& !this.returnType.isBaseType()
&& (this.returnType.tagBits & (TagBits.AnnotationNonNull|TagBits.AnnotationNullable)) == 0)
{
- this.returnType = env.createAnnotatedType(this.returnType, TagBits.AnnotationNonNull);
+ // TODO(Stephan: Synthesize AnnotationBinding[] and call LE#createAnnotatedType(TB, AB[]);
+ // this.returnType = env.createAnnotatedType(this.returnType, TagBits.AnnotationNonNull);
} else if (sourceMethod != null && (this.returnType.tagBits & TagBits.AnnotationNonNull) != 0) {
sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, -1/*signifies method return*/);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
index e0fbbac..9906be5 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java
@@ -118,7 +118,7 @@
// so the parameters are equal and the return type is compatible b/w the currentMethod & the substituted inheritedMethod
MethodBinding originalInherited = inheritedMethod.original();
- if (originalInherited.returnType != currentMethod.returnType)
+ if (TypeBinding.notEquals(originalInherited.returnType, currentMethod.returnType))
if (!isAcceptableReturnTypeOverride(currentMethod, inheritedMethod))
problemReporter(currentMethod).unsafeReturnTypeOverride(currentMethod, originalInherited, this.type);
@@ -505,8 +505,7 @@
char[][] methodSelectors = this.inheritedMethods.keyTable;
nextSelector : for (int s = methodSelectors.length; --s >= 0;) {
if (methodSelectors[s] == null) continue nextSelector;
-
- MethodBinding[] current = (MethodBinding[]) this.currentMethods.get(methodSelectors[s]);
+ MethodBinding[] current = (MethodBinding[]) this.currentMethods.get(methodSelectors[s]);
MethodBinding[] inherited = (MethodBinding[]) this.inheritedMethods.valueTable[s];
// ensure that if we have a concrete method this shows up at position [0]:
inherited = Sorting.concreteFirst(inherited, inherited.length);
@@ -612,6 +611,7 @@
// (and perform some side effects : bridge methods & use flags)
for (int i = 0; i < inheritedLength; i++) {
MethodBinding matchMethod = foundMatch[i];
+
if (matchMethod == null && current != null && this.type.isPublic()) { // current == null case handled already.
MethodBinding inheritedMethod = inherited[i];
if (inheritedMethod.isPublic() && !inheritedMethod.declaringClass.isPublic()) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MissingTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MissingTypeBinding.java
index 3281d43..46b2805 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MissingTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MissingTypeBinding.java
@@ -43,6 +43,10 @@
this.methods = Binding.NO_METHODS;
}
+public MissingTypeBinding(MissingTypeBinding prototype) {
+ super(prototype);
+}
+
//{ObjectTeams: missing o.o.Team cannot be further initialized:
@Override
protected void setupOrgObjectteamsTeamModel() {
@@ -51,6 +55,14 @@
}
// SH}
+public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ MissingTypeBinding copy = new MissingTypeBinding(this);
+ copy.enclosingType = (ReferenceBinding) outerType; // for better or worse.
+ return copy;
+}
+public TypeBinding unannotated() {
+ return this.prototype;
+}
/**
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#collectMissingTypes(java.util.List)
*/
@@ -78,10 +90,13 @@
* @see LookupEnvironment#createMissingType(PackageBinding, char[][])
*/
void setMissingSuperclass(ReferenceBinding missingSuperclass) {
+ if (this != this.prototype) {
+ ((MissingTypeBinding) this.prototype).setMissingSuperclass(missingSuperclass);
+ }
this.superclass = missingSuperclass;
}
public String toString() {
- return "[MISSING:" + new String(CharOperation.concatWith(this.compoundName, '.')) + "]"; //$NON-NLS-1$ //$NON-NLS-2$
- }
+ return this.hasTypeAnnotations() ? annotatedDebugName() + " (missing)" : "[MISSING:" + new String(CharOperation.concatWith(this.compoundName, '.')) + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java
index abd5450..aa1f044 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java
@@ -18,7 +18,7 @@
import org.eclipse.objectteams.otdt.internal.core.compiler.control.Dependencies;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.ITranslationStates;
-public class NestedTypeBinding extends SourceTypeBinding {
+public abstract class NestedTypeBinding extends SourceTypeBinding {
public SourceTypeBinding enclosingType;
@@ -33,6 +33,15 @@
this.enclosingType = enclosingType;
}
+public NestedTypeBinding(NestedTypeBinding prototype) {
+ super(prototype);
+ this.enclosingType = prototype.enclosingType;
+ this.enclosingInstances = prototype.enclosingInstances;
+ this.enclosingTypes = prototype.enclosingTypes;
+ this.outerLocalVariables = prototype.outerLocalVariables;
+ this.outerLocalVariablesSlotSize = prototype.outerLocalVariablesSlotSize;
+}
+
/* Add a new synthetic argument for <actualOuterLocalVariable>.
* Answer the new argument or the existing argument if one already existed.
*/
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
index e5ff6f2..891ac10 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
@@ -561,7 +561,7 @@
}
// With T mapping to I<T>, answer of I<?>, when given T, having eliminated the circularity/self reference.
public TypeBinding substitute(TypeVariableBinding typeVariable) {
- if (typeVariable.rank >= this.variables.length || this.variables[typeVariable.rank] != typeVariable) { // not kosher, don't touch.
+ if (typeVariable.rank >= this.variables.length || TypeBinding.notEquals(this.variables[typeVariable.rank], typeVariable)) { // not kosher, don't touch.
return typeVariable;
}
if (this.substitutes != null) {
@@ -600,8 +600,9 @@
TypeVariableBinding[] variables = this.originalMethod.typeVariables;
int length = variables.length;
// check this variable can be substituted given parameterized type
- if (originalVariable.rank < length && variables[originalVariable.rank] == originalVariable) {
- return this.typeArguments[originalVariable.rank];
+ if (originalVariable.rank < length && TypeBinding.equalsEquals(variables[originalVariable.rank], originalVariable)) {
+ TypeBinding substitute = this.typeArguments[originalVariable.rank];
+ return originalVariable.hasTypeAnnotations() ? this.environment.createAnnotatedType(substitute, originalVariable.getTypeAnnotations()) : substitute;
}
return originalVariable;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
index 9633688..3c23500 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedMethodBinding.java
@@ -84,8 +84,9 @@
}
public TypeBinding substitute(TypeVariableBinding typeVariable) {
// check this variable can be substituted given copied variables
- if (typeVariable.rank < length && originalVariables[typeVariable.rank] == typeVariable) {
- return substitutedVariables[typeVariable.rank];
+ if (typeVariable.rank < length && TypeBinding.equalsEquals(originalVariables[typeVariable.rank], typeVariable)) {
+ TypeBinding substitute = substitutedVariables[typeVariable.rank];
+ return typeVariable.hasTypeAnnotations() ? environment().createAnnotatedType(substitute, typeVariable.getTypeAnnotations()) : substitute;
}
if (!isStatic)
return parameterizedDeclaringClass.substitute(typeVariable);
@@ -225,8 +226,9 @@
}
public TypeBinding substitute(TypeVariableBinding typeVariable) {
// check this variable can be substituted given copied variables
- if (typeVariable.rank < length && originalVariables[typeVariable.rank] == typeVariable) {
- return substitutedVariables[typeVariable.rank];
+ if (typeVariable.rank < length && TypeBinding.equalsEquals(originalVariables[typeVariable.rank], typeVariable)) {
+ TypeBinding substitute = substitutedVariables[typeVariable.rank];
+ return typeVariable.hasTypeAnnotations() ? environment().createAnnotatedType(substitute, typeVariable.getTypeAnnotations()) : substitute;
}
return typeVariable;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
index c4d9637..5cbe2ab 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
@@ -371,23 +371,30 @@
public char[] constantPoolName() {
return this.type.constantPoolName(); // erasure
}
+
+ public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ ParameterizedTypeBinding copy = new ParameterizedTypeBinding(this.type, typeArguments, (ReferenceBinding) outerType, this.environment);
+ if (this.hasTypeAnnotations())
+ copy.setTypeAnnotations(this.getTypeAnnotations(), this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return copy;
+ }
public ParameterizedMethodBinding createParameterizedMethod(MethodBinding originalMethod) {
return new ParameterizedMethodBinding(this, originalMethod);
}
-
/**
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#debugName()
*/
public String debugName() {
- StringBuffer nameBuffer = new StringBuffer(10);
- appendNullAnnotation(nameBuffer, this.environment.globalOptions);
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
+ StringBuffer nameBuffer = new StringBuffer(10);
if (this.type instanceof UnresolvedReferenceBinding) {
nameBuffer.append(this.type);
} else {
nameBuffer.append(this.type.sourceName());
}
- if (this.arguments != null && this.arguments.length > 0) { // empty arguments array happens when PTB has been created just to capture type annotations
+ if (this.arguments != null && this.arguments.length > 0) {
nameBuffer.append('<');
for (int i = 0, length = this.arguments.length; i < length; i++) {
if (i > 0) nameBuffer.append(',');
@@ -397,6 +404,19 @@
}
return nameBuffer.toString();
}
+
+ public String annotatedDebugName() {
+ StringBuffer nameBuffer = new StringBuffer(super.annotatedDebugName());
+ if (this.arguments != null && this.arguments.length > 0) {
+ nameBuffer.append('<');
+ for (int i = 0, length = this.arguments.length; i < length; i++) {
+ if (i > 0) nameBuffer.append(',');
+ nameBuffer.append(this.arguments[i].annotatedDebugName());
+ }
+ nameBuffer.append('>');
+ }
+ return nameBuffer.toString();
+ }
/**
* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#enclosingType()
@@ -819,14 +839,7 @@
// SH}
public boolean isEquivalentTo(TypeBinding otherType) {
- // disregard any type annotations on this and otherType
- // recursive call needed when this is annotated, unless the annotation was introduced on a declaration
- otherType = otherType.unannotated();
- TypeBinding unannotated = unannotated();
- if (unannotated != this)
- return unannotated.isEquivalentTo(otherType);
-
- if (this == otherType)
+ if (equalsEquals(this, otherType))
return true;
if (otherType == null)
return false;
@@ -861,8 +874,9 @@
for (int i = 0; i < length; i++) {
if (!this.arguments[i].isTypeArgumentContainedBy(otherArguments[i]))
return false;
- if ((this.arguments[i].tagBits & TagBits.AnnotationNullMASK) != (otherArguments[i].tagBits & TagBits.AnnotationNullMASK))
- return false;
+ // Stephan : is this intentional ??
+// if ((this.arguments[i].tagBits & TagBits.AnnotationNullMASK) != (otherArguments[i].tagBits & TagBits.AnnotationNullMASK))
+// return false;
}
return true;
@@ -902,19 +916,7 @@
}
public TypeBinding unannotated() {
- if (!hasNullTypeAnnotations())
- return this;
- if (isAnnotatedTypeWithoutArguments())
- return this.type;
- TypeBinding[] unannotatedArguments = null;
- if (this.arguments != null) {
- unannotatedArguments = new TypeBinding[this.arguments.length];
- for (int i = 0; i < unannotatedArguments.length; i++) {
- unannotatedArguments[i] = this.arguments[i].unannotated();
- }
- }
- return this.environment.createParameterizedType((ReferenceBinding) this.type.unannotated(), unannotatedArguments,
- this.enclosingType == null ? null : (ReferenceBinding) this.enclosingType.unannotated());
+ return this.hasTypeAnnotations() ? this.environment.getUnannotatedType(this) : this;
}
public int kind() {
@@ -1266,15 +1268,16 @@
TypeVariableBinding[] typeVariables = currentType.type.typeVariables();
int length = typeVariables.length;
// check this variable can be substituted given parameterized type
- if (originalVariable.rank < length && typeVariables[originalVariable.rank] == originalVariable) {
+ if (originalVariable.rank < length && TypeBinding.equalsEquals(typeVariables[originalVariable.rank], originalVariable)) {
// lazy init, since cannot do so during binding creation if during supertype connection
if (currentType.arguments == null)
currentType.initializeArguments(); // only for raw types
if (currentType.arguments != null) {
if (currentType.arguments.length == 0) { // diamond type
return originalVariable;
- }
- return currentType.arguments[originalVariable.rank];
+ }
+ TypeBinding substitute = currentType.arguments[originalVariable.rank];
+ return originalVariable.hasTypeAnnotations() ? this.environment.createAnnotatedType(substitute, originalVariable.getTypeAnnotations()) : substitute;
}
}
// recurse on enclosing type, as it may hold more substitutions to perform
@@ -1358,8 +1361,11 @@
* @see java.lang.Object#toString()
*/
public String toString() {
- StringBuffer buffer = new StringBuffer(30);
- if (this.type instanceof UnresolvedReferenceBinding) {
+ if (this.hasTypeAnnotations()) {
+ return annotatedDebugName();
+ }
+ StringBuffer buffer = new StringBuffer(30);
+ if (this.type instanceof UnresolvedReferenceBinding) {
buffer.append(debugName());
} else {
if (isDeprecated()) buffer.append("deprecated "); //$NON-NLS-1$
@@ -1441,6 +1447,10 @@
return Binding.NO_TYPE_VARIABLES;
}
+ public TypeBinding[] typeArguments() {
+ return this.arguments;
+ }
+
public FieldBinding[] unResolvedFields() {
return this.fields;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java
index 54b3b17..caf7fff 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java
@@ -76,6 +76,13 @@
sig.getChars(0, sigLength, uniqueKey, 0);
return uniqueKey;
}
+
+ public TypeBinding clone(TypeBinding outerType, TypeBinding[] typeArguments) {
+ RawTypeBinding copy = new RawTypeBinding(this.actualType(), (ReferenceBinding) outerType, this.environment);
+ if (this.hasTypeAnnotations())
+ copy.setTypeAnnotations(this.getTypeAnnotations(), this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ return copy;
+ }
/**
* @see org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding#createParameterizedMethod(org.eclipse.jdt.internal.compiler.lookup.MethodBinding)
@@ -99,11 +106,17 @@
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#debugName()
*/
public String debugName() {
- StringBuffer nameBuffer = new StringBuffer(10);
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
+ StringBuffer nameBuffer = new StringBuffer(10);
nameBuffer.append(actualType().sourceName()).append("#RAW"); //$NON-NLS-1$
return nameBuffer.toString();
}
-
+ public String annotatedDebugName() {
+ StringBuffer buffer = new StringBuffer(super.annotatedDebugName());
+ buffer.append("#RAW"); //$NON-NLS-1$
+ return buffer.toString();
+ }
/**
* Ltype<param1 ... paramN>;
* LY<TT;>;
@@ -138,14 +151,7 @@
}
public boolean isEquivalentTo(TypeBinding otherType) {
- // disregard any type annotations on this and otherType
- // recursive call needed when this is annotated, unless the annotation was introduced on a declaration
- otherType = otherType.unannotated();
- TypeBinding unannotated = unannotated();
- if (unannotated != this)
- return unannotated.isEquivalentTo(otherType);
-
- if (this == otherType || erasure() == otherType)
+ if (equalsEquals(this, otherType) || equalsEquals(erasure(), otherType))
return true;
if (otherType == null)
return false;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
index 8f982bc..6b4ee90 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java
@@ -118,6 +118,7 @@
protected MethodBinding singleAbstractMethod;
public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */
+ { this.id = TypeIds.T_undefined; }
public boolean hasTypeBit(int bit) { return false; }
};
@@ -140,6 +141,29 @@
};
static protected ProblemMethodBinding samProblemBinding = new ProblemMethodBinding(TypeConstants.ANONYMOUS_METHOD, null, ProblemReasons.NoSuchSingleAbstractMethod);
+
+ public ReferenceBinding(ReferenceBinding prototype) {
+ super(prototype);
+
+ this.compoundName = prototype.compoundName;
+ this.sourceName = prototype.sourceName;
+ this.modifiers = prototype.modifiers;
+ this.fPackage = prototype.fPackage;
+ this.fileName = prototype.fileName;
+ this.constantPoolName = prototype.constantPoolName;
+ this.signature = prototype.signature;
+ this.compatibleCache = prototype.compatibleCache;
+ this.typeBits = prototype.typeBits;
+ this.singleAbstractMethod = prototype.singleAbstractMethod;
+}
+
+public ReferenceBinding() {
+ super();
+//{ObjectTeams: most subclasses need model to be set:
+ this.model = new TypeModel(this);
+// SH}
+}
+
public static FieldBinding binarySearch(char[] name, FieldBinding[] sortedFields) {
if (sortedFields == null)
return null;
@@ -322,11 +346,7 @@
Arrays.sort(sortedMethods, left, right, METHOD_COMPARATOR);
}
-//{ObjectTeams: most subclasses need model to be set:
- protected ReferenceBinding() {
- this.model = new TypeModel(this);
- }
- // some subclasses share an existing model
+//{ObjectTeams: some subclasses share an existing model
protected ReferenceBinding(TypeModel model) {
this.model = model;
if (model != null && model.getBinding() == null)
@@ -455,7 +475,7 @@
if (currentType.isCapture()) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=285002
if (originalDeclaringClass == currentType.erasure().original()) return true;
} else {
- if (originalDeclaringClass == currentType.original()) return true;
+ if (equalsEquals(originalDeclaringClass, currentType.original())) return true;
}
PackageBinding currentPackage = currentType.fPackage;
// package could be null for wildcards/intersection types, ignore and recurse in superclass
@@ -1016,7 +1036,7 @@
}
// SH}
public String debugName() {
- return (this.compoundName != null) ? new String(readableName()) : "UNNAMED TYPE"; //$NON-NLS-1$
+ return (this.compoundName != null) ? this.hasTypeAnnotations() ? annotatedDebugName() : new String(readableName()) : "UNNAMED TYPE"; //$NON-NLS-1$
}
public int depth() {
@@ -1520,15 +1540,9 @@
}
public boolean isCompatibleWith(TypeBinding otherType, boolean useObjectShortcut, /*@Nullable*/ Scope captureScope) {
// SH}
- // disregard any type annotations on this and otherType
- // recursive call needed when this is annotated, unless the annotation was introduced on a declaration
- otherType = otherType.unannotated();
- TypeBinding unannotated = unannotated();
- if (unannotated != this)
- return unannotated.isCompatibleWith(otherType, captureScope);
-
- if (otherType == this)
+ if (equalsEquals(otherType, this))
return true;
+
//{ObjectTeams: respect new argument useObjectShortcut:
/* orig:
if (otherType.id == TypeIds.T_JavaLangObject)
@@ -1944,6 +1958,83 @@
storeAnnotations(this, annotations);
}
+/**
+ * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#nullAnnotatedReadableName(CompilerOptions,boolean)
+ */
+public char[] nullAnnotatedReadableName(CompilerOptions options, boolean shortNames) {
+ if (shortNames)
+ return nullAnnotatedShortReadableName(options);
+ return nullAnnotatedReadableName(options);
+}
+
+char[] nullAnnotatedReadableName(CompilerOptions options) {
+ StringBuffer nameBuffer = new StringBuffer(10);
+ if (isMemberType()) {
+ nameBuffer.append(enclosingType().nullAnnotatedReadableName(options, false));
+ nameBuffer.append('.');
+ appendNullAnnotation(nameBuffer, options);
+ nameBuffer.append(this.sourceName);
+ } else if (this.compoundName != null) {
+ int i;
+ int l=this.compoundName.length;
+ for (i=0; i<l-1; i++) {
+ nameBuffer.append(this.compoundName[i]);
+ nameBuffer.append('.');
+ }
+ appendNullAnnotation(nameBuffer, options);
+ nameBuffer.append(this.compoundName[i]);
+ } else {
+ // case of TypeVariableBinding with nullAnnotationTagBits:
+ appendNullAnnotation(nameBuffer, options);
+ if (this.sourceName != null)
+ nameBuffer.append(this.sourceName);
+ else // WildcardBinding, CaptureBinding have no sourceName
+ nameBuffer.append(this.readableName());
+ }
+ TypeBinding [] arguments = typeArguments();
+ if (arguments != null && arguments.length > 0) { // empty arguments array happens when PTB has been created just to capture type annotations
+ nameBuffer.append('<');
+ for (int i = 0, length = arguments.length; i < length; i++) {
+ if (i > 0) nameBuffer.append(',');
+ nameBuffer.append(arguments[i].nullAnnotatedReadableName(options, false));
+ }
+ nameBuffer.append('>');
+ }
+ int nameLength = nameBuffer.length();
+ char[] readableName = new char[nameLength];
+ nameBuffer.getChars(0, nameLength, readableName, 0);
+ return readableName;
+}
+
+char[] nullAnnotatedShortReadableName(CompilerOptions options) {
+ StringBuffer nameBuffer = new StringBuffer(10);
+ if (isMemberType()) {
+ nameBuffer.append(enclosingType().nullAnnotatedReadableName(options, true));
+ nameBuffer.append('.');
+ appendNullAnnotation(nameBuffer, options);
+ nameBuffer.append(this.sourceName);
+ } else {
+ appendNullAnnotation(nameBuffer, options);
+ if (this.sourceName != null)
+ nameBuffer.append(this.sourceName);
+ else // WildcardBinding, CaptureBinding have no sourceName
+ nameBuffer.append(this.shortReadableName());
+ }
+ TypeBinding [] arguments = typeArguments();
+ if (arguments != null && arguments.length > 0) { // empty arguments array happens when PTB has been created just to capture type annotations
+ nameBuffer.append('<');
+ for (int i = 0, length = arguments.length; i < length; i++) {
+ if (i > 0) nameBuffer.append(',');
+ nameBuffer.append(arguments[i].nullAnnotatedReadableName(options, true));
+ }
+ nameBuffer.append('>');
+ }
+ int nameLength = nameBuffer.length();
+ char[] shortReadableName = new char[nameLength];
+ nameBuffer.getChars(0, nameLength, shortReadableName, 0);
+ return shortReadableName;
+}
+
public char[] shortReadableName() /*Object*/ {
char[] shortReadableName;
if (isMemberType()) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
index d2e757d..ada4028 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
@@ -449,16 +449,6 @@
* of its type in the generic declaration corresponding to C."
*/
public static TypeBinding substitute(Substitution substitution, TypeBinding originalType) {
- TypeBinding unannotatedOriginal = originalType.unannotated();
- TypeBinding substitute = substitute0(substitution, unannotatedOriginal);
- if (unannotatedOriginal == originalType) // no annotation => use naked substitute
- return substitute;
- else if (substitute == unannotatedOriginal) // no substitution => re-use annotated type
- return originalType;
- else // substitution and annotation: merge both
- return substitution.environment().copyAnnotations(originalType, substitute);
- }
- private static TypeBinding substitute0(Substitution substitution, TypeBinding originalType) {
if (originalType == null) return null;
//{ObjectTeams: unwrap type variable from dependent type?
if (DependentTypeBinding.isDependentTypeVariable(originalType))
@@ -492,7 +482,7 @@
if (RoleTypeBinding.isRoleType(originalParameterizedType)) {
DependentTypeBinding originalRole = (DependentTypeBinding) originalParameterizedType;
return originalParameterizedType.environment.createParameterizedType(
- originalParameterizedType.genericType(), substitutedArguments, 0L, originalRole._teamAnchor, originalRole._valueParamPosition, substitutedEnclosing);
+ originalParameterizedType.genericType(), substitutedArguments, originalRole._teamAnchor, originalRole._valueParamPosition, substitutedEnclosing, Binding.NO_ANNOTATIONS);
}
// SH}
return originalParameterizedType.environment.createParameterizedType(
@@ -3944,6 +3934,7 @@
case 0 : return TypeBinding.VOID;
case 1 : return mecs[0];
case 2 :
+ // TODO(Stephan) : if null annotations differ, we need to create an intersection type and return.
if ((commonDim == 0 ? mecs[1].id : mecs[1].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[0];
if ((commonDim == 0 ? mecs[0].id : mecs[0].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[1];
}
@@ -3955,7 +3946,7 @@
otherBounds[rank++] = mec;
}
}
- TypeBinding intersectionType = environment().createWildcard(null, 0, firstBound, otherBounds, Wildcard.EXTENDS);
+ TypeBinding intersectionType = environment().createWildcard(null, 0, firstBound, otherBounds, Wildcard.EXTENDS); // pass common null annotations by synthesized annotation bindings.
return commonDim == 0 ? intersectionType : environment().createArrayType(intersectionType, commonDim);
}
@@ -4022,7 +4013,7 @@
firstErasure = firstType;
break;
}
- if (firstErasure != firstType) {
+ if (TypeBinding.notEquals(firstErasure, firstType)) {
allInvocations.put(firstErasure, firstType);
}
typesToVisit.add(firstType);
@@ -4082,7 +4073,7 @@
typesToVisit.add(superType);
max++;
TypeBinding superTypeErasure = (firstBound.isTypeVariable() || firstBound.isWildcard() /*&& !itsInterface.isCapture()*/) ? superType : superType.erasure();
- if (superTypeErasure != superType) {
+ if (TypeBinding.notEquals(superTypeErasure, superType)) {
allInvocations.put(superTypeErasure, superType);
}
}
@@ -4099,7 +4090,7 @@
typesToVisit.add(superType);
max++;
TypeBinding superTypeErasure = (itsInterface.isTypeVariable() || itsInterface.isWildcard() /*&& !itsInterface.isCapture()*/) ? superType : superType.erasure();
- if (superTypeErasure != superType) {
+ if (TypeBinding.notEquals(superTypeErasure, superType)) {
allInvocations.put(superTypeErasure, superType);
}
}
@@ -4112,7 +4103,7 @@
typesToVisit.add(superType);
max++;
TypeBinding superTypeErasure = (itsSuperclass.isTypeVariable() || itsSuperclass.isWildcard() /*&& !itsSuperclass.isCapture()*/) ? superType : superType.erasure();
- if (superTypeErasure != superType) {
+ if (TypeBinding.notEquals(superTypeErasure, superType)) {
allInvocations.put(superTypeErasure, superType);
}
}
@@ -4146,7 +4137,7 @@
if (invocationData == null) {
allInvocations.put(erasedSuperType, match); // no array for singleton
} else if (invocationData instanceof TypeBinding) {
- if (match != invocationData) {
+ if (TypeBinding.notEquals(match, (TypeBinding) invocationData)) {
// using an array to record invocations in order (188103)
TypeBinding[] someInvocations = { (TypeBinding) invocationData, match, };
allInvocations.put(erasedSuperType, someInvocations);
@@ -4189,7 +4180,7 @@
if (invocationData == null) {
allInvocations.put(erasedSuperType, match); // no array for singleton
} else if (invocationData instanceof TypeBinding) {
- if (match != invocationData) {
+ if (TypeBinding.notEquals(match, (TypeBinding) invocationData)) {
// using an array to record invocations in order (188103)
TypeBinding[] someInvocations = { (TypeBinding) invocationData, match, };
allInvocations.put(erasedSuperType, someInvocations);
@@ -4656,7 +4647,7 @@
for (int i = 0; i < lastIndex; i++) {
TypeBinding param = parameters[i];
TypeBinding arg = (tiebreakingVarargsMethods && (i == (argLength - 1))) ? ((ArrayBinding)arguments[i]).elementsType() : arguments[i];
- if (arg != param) {
+ if (TypeBinding.notEquals(arg,param)) {
int newLevel = parameterCompatibilityLevel(arg, param, env, tiebreakingVarargsMethods);
if (newLevel == NOT_COMPATIBLE)
return NOT_COMPATIBLE;
@@ -4887,7 +4878,7 @@
}
public TypeBinding substitute(TypeVariableBinding typeVariable) {
TypeBinding retVal = (TypeBinding) map.get(typeVariable);
- return retVal != null ? retVal : typeVariable;
+ return typeVariable.hasTypeAnnotations() ? environment().createAnnotatedType(retVal, typeVariable.getTypeAnnotations()) : retVal;
}
//{ObjectTeams:
public ITeamAnchor substituteAnchor(ITeamAnchor anchor, int rank) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
index e705969..bcac5a8 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
@@ -126,6 +126,7 @@
// SH}
public ClassScope scope;
+ protected SourceTypeBinding prototype;
// Synthetics are separated into 4 categories: methods, super methods, fields, class literals and bridge methods
// if a new category is added, also increment MAX_SYNTHETICS
@@ -150,7 +151,7 @@
MultipleCasts.compoundName = new char[][] { "multiple".toCharArray(), "casts".toCharArray(), "required".toCharArray() }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
- protected SourceTypeBinding() { super(null); } // default ctor for Singleton membertypes NoBaseclass, ProblemBaseclass
+ protected SourceTypeBinding() { super(); } // default ctor for Singleton membertypes NoBaseclass, ProblemBaseclass
//Markus Witte}
@@ -183,10 +184,36 @@
// expect the fields & methods to be initialized correctly later
this.fields = Binding.UNINITIALIZED_FIELDS;
this.methods = Binding.UNINITIALIZED_METHODS;
-
+ this.prototype = this;
computeId();
}
+public SourceTypeBinding(SourceTypeBinding prototype) {
+ super(prototype);
+ this.prototype = prototype.prototype;
+ this.compoundName = prototype.compoundName;
+ this.fPackage = prototype.fPackage;
+ this.fileName = prototype.fileName;
+ this.modifiers = prototype.modifiers;
+ this.sourceName = prototype.sourceName;
+
+ this.superclass = prototype.superclass;
+ this.superInterfaces = prototype.superInterfaces;
+ this.fields = prototype.fields;
+ this.methods = prototype.methods;
+ this.memberTypes = prototype.memberTypes;
+ this.typeVariables = prototype.typeVariables;
+
+ // this.scope = prototype.scope; // Will defeat CompilationUnitDeclaration.cleanUp(TypeDeclaration) && CompilationUnitDeclaration.cleanUp(), so not copied, not an issue for JSR 308.
+
+ this.synthetics = prototype.synthetics;
+ this.genericReferenceTypeSignature = prototype.genericReferenceTypeSignature;
+ this.storedAnnotations = prototype.storedAnnotations;
+ this.defaultNullness = prototype.defaultNullness;
+ this.nullnessDefaultInitialized= prototype.nullnessDefaultInitialized;
+ this.lambdaOrdinal = prototype.lambdaOrdinal;
+}
+
private void addDefaultAbstractMethods() {
if ((this.tagBits & TagBits.KnowsDefaultAbstractMethods) != 0) return;
@@ -902,9 +929,9 @@
//{ObjectTeams: retrieve callin method's real return type:
TypeBinding inheritedReturn= MethodModel.getReturnType(inheritedMethodToBridge);
TypeBinding targetReturn= MethodModel.getReturnType(targetMethod);
- if (inheritedReturn.erasure() == targetReturn.erasure()
+ if (TypeBinding.equalsEquals(inheritedReturn.erasure(), targetReturn.erasure())
/* orig:
- if (inheritedMethodToBridge.returnType.erasure() == targetMethod.returnType.erasure()
+ if (TypeBinding.equalsEquals(inheritedMethodToBridge.returnType.erasure(), targetMethod.returnType.erasure())
:giro */
// SH}
&& inheritedMethodToBridge.areParameterErasuresEqual(targetMethod)) {
@@ -991,9 +1018,13 @@
return accessMethod;
}
boolean areFieldsInitialized() {
+ if (this != this.prototype)
+ return this.prototype.areFieldsInitialized();
return this.fields != Binding.UNINITIALIZED_FIELDS;
}
boolean areMethodsInitialized() {
+ if (this != this.prototype)
+ return this.prototype.areMethodsInitialized();
return this.methods != Binding.UNINITIALIZED_METHODS;
}
public int kind() {
@@ -1001,7 +1032,13 @@
return Binding.TYPE;
}
+public TypeBinding clone(TypeBinding immaterial, TypeBinding[] irrelevant) {
+ return new SourceTypeBinding(this);
+}
+
public char[] computeUniqueKey(boolean isLeaf) {
+ if (this != this.prototype)
+ return this.prototype.computeUniqueKey();
//{ObjectTeams: don't use __OT__R names for keys (TODO(SH): nested roles?)
if (isRole()) {
if (isClass()) {
@@ -1078,6 +1115,10 @@
}
// NOTE: the type of each field of a source type is resolved when needed
public FieldBinding[] fields() {
+
+ if (this != this.prototype)
+ return this.prototype.fields();
+
if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
return this.fields;
@@ -1144,6 +1185,9 @@
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#genericTypeSignature()
*/
public char[] genericTypeSignature() {
+ if (this != this.prototype)
+ return this.prototype.genericTypeSignature();
+
if (this.genericReferenceTypeSignature == null)
this.genericReferenceTypeSignature = computeGenericTypeSignature(this.typeVariables);
return this.genericReferenceTypeSignature;
@@ -1153,6 +1197,9 @@
* <T:LY<TT;>;U:Ljava/lang/Object;V::Ljava/lang/Runnable;:Ljava/lang/Cloneable;:Ljava/util/Map;>Ljava/lang/Exception;Ljava/lang/Runnable;
*/
public char[] genericSignature() {
+ if (this != this.prototype)
+ return this.prototype.genericSignature();
+
StringBuffer sig = null;
if (this.typeVariables != Binding.NO_TYPE_VARIABLES) {
sig = new StringBuffer(10);
@@ -1185,6 +1232,9 @@
* @see org.eclipse.jdt.internal.compiler.lookup.Binding#getAnnotationTagBits()
*/
public long getAnnotationTagBits() {
+ if (this != this.prototype)
+ return this.prototype.getAnnotationTagBits();
+
if ((this.tagBits & TagBits.AnnotationResolved) == 0 && this.scope != null) {
TypeDeclaration typeDecl = this.scope.referenceContext;
boolean old = typeDecl.staticInitializerScope.insideTypeAnnotation;
@@ -1206,6 +1256,9 @@
return this.tagBits;
}
public MethodBinding[] getDefaultAbstractMethods() {
+ if (this != this.prototype)
+ return this.prototype.getDefaultAbstractMethods();
+
int count = 0;
for (int i = this.methods.length; --i >= 0;)
if (this.methods[i].isDefaultAbstract())
@@ -1221,6 +1274,9 @@
}
// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
+ if (this != this.prototype)
+ return this.prototype.getExactConstructor(argumentTypes);
+
int argCount = argumentTypes.length;
if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods
long range;
@@ -1273,6 +1329,9 @@
//NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
//searches up the hierarchy as long as no potential (but not exact) match was found.
public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) {
+ if (this != this.prototype)
+ return this.prototype.getExactMethod(selector, argumentTypes, refScope);
+
// sender from refScope calls recordTypeReference(this)
int argCount = argumentTypes.length;
boolean foundNothing = true;
@@ -1368,6 +1427,8 @@
//NOTE: the type of a field of a source type is resolved when needed
public FieldBinding getField(char[] fieldName, boolean needResolve) {
+ if (this != this.prototype)
+ return this.prototype.getField(fieldName, needResolve);
//{ObjectTeams: could be called before fields are present
// (from ClassScope.findSupertype if supertyperef is a QualifiedTypeReference),
// can't find any fields, but mustn't prematurely set NO_FIELDS.
@@ -1454,6 +1515,9 @@
// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
public MethodBinding[] getMethods(char[] selector) {
+ if (this != this.prototype)
+ return this.prototype.getMethods(selector);
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0) {
long range;
if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
@@ -1688,6 +1752,9 @@
}
public boolean hasTypeBit(int bit) {
+ if (this != this.prototype) {
+ return this.prototype.hasTypeBit(bit);
+ }
// source types initialize type bits during connectSuperclass/interfaces()
return (this.typeBits & bit) != 0;
}
@@ -1696,6 +1763,10 @@
* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()
*/
public void initializeDeprecatedAnnotationTagBits() {
+ if (this != this.prototype) {
+ this.prototype.initializeDeprecatedAnnotationTagBits();
+ return;
+ }
if ((this.tagBits & TagBits.DeprecatedAnnotationResolved) == 0) {
TypeDeclaration typeDecl = this.scope.referenceContext;
boolean old = typeDecl.staticInitializerScope.insideTypeAnnotation;
@@ -1718,6 +1789,10 @@
protected
// SH}
void initializeForStaticImports() {
+ if (this != this.prototype) {
+ this.prototype.initializeForStaticImports();
+ return;
+ }
if (this.scope == null) return; // already initialized
if (this.superInterfaces == null)
@@ -1743,7 +1818,9 @@
* or for generic types, true if compared to its raw type.
*/
public boolean isEquivalentTo(TypeBinding otherType) {
-
+ if (this != this.prototype)
+ return this.prototype.isEquivalentTo(otherType);
+
if (this == otherType) return true;
if (otherType == null) return false;
switch(otherType.kind()) {
@@ -1786,21 +1863,33 @@
return false;
}
public boolean isGenericType() {
+ if (this != this.prototype)
+ return this.prototype.isGenericType();
return this.typeVariables != Binding.NO_TYPE_VARIABLES;
}
public boolean isHierarchyConnected() {
+ if (this != this.prototype)
+ return this.prototype.isHierarchyConnected();
return (this.tagBits & TagBits.EndHierarchyCheck) != 0;
}
public ReferenceBinding[] memberTypes() {
+ if (this != this.prototype)
+ return this.prototype.memberTypes();
return this.memberTypes;
}
public boolean hasMemberTypes() {
+ if (this != this.prototype)
+ return this.prototype.hasMemberTypes();
return this.memberTypes.length > 0;
}
// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
public MethodBinding[] methods() {
+
+ if (this != this.prototype)
+ return this.prototype.methods();
+
if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
return this.methods;
@@ -2038,6 +2127,10 @@
return this.methods;
}
public FieldBinding resolveTypeFor(FieldBinding field) {
+
+ if (this != this.prototype)
+ return this.prototype.resolveTypeFor(field);
+
if ((field.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
return field;
@@ -2091,6 +2184,12 @@
field.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
}
+ if (sourceLevel >= ClassFileConstants.JDK1_8) {
+ AnnotationBinding [] annotations = field.getAnnotations();
+ if (annotations != null && annotations != Binding.NO_ANNOTATIONS) {
+ ASTNode.copySE8AnnotationsToType(initializationScope, field, annotations);
+ }
+ }
// apply null default:
LookupEnvironment environment = this.scope.environment();
if (environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
@@ -2107,12 +2206,6 @@
if (!this.scope.validateNullAnnotation(field.tagBits, fieldDecl.type, fieldDecl.annotations))
field.tagBits &= ~TagBits.AnnotationNullMASK;
}
- if (sourceLevel >= ClassFileConstants.JDK1_8 && !fieldType.isBaseType()) {
- long nullTagBits = field.tagBits & TagBits.AnnotationNullMASK;
- if (nullTagBits != 0 && nullTagBits != (fieldType.tagBits & TagBits.AnnotationNullMASK))
- field.type = environment.createAnnotatedType(fieldType, nullTagBits);
- // do not reset field.tagBits, since more fields may need to share this information ("@NonNull Object o1, o2;")
- }
}
} finally {
initializationScope.initializedField = previousField;
@@ -2160,6 +2253,10 @@
}
public MethodBinding resolveTypesFor(MethodBinding method, boolean fromSynthetic) {
// SH}
+
+ if (this != this.prototype)
+ return this.prototype.resolveTypesFor(method);
+
if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
return method;
//{ObjectTeams: in state final we lost the scope, cannot use code below any more.
@@ -2167,7 +2264,8 @@
return method;
//SH}
- if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
+ final long sourceLevel = this.scope.compilerOptions().sourceLevel;
+ if (sourceLevel >= ClassFileConstants.JDK1_5) {
if ((method.getAnnotationTagBits() & TagBits.AnnotationDeprecated) != 0)
method.modifiers |= ClassFileConstants.AccDeprecated;
}
@@ -2349,7 +2447,7 @@
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799
- if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) {
+ if (sourceLevel >= ClassFileConstants.JDK1_7) {
if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {
if (!method.isVarargs()) {
methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);
@@ -2417,6 +2515,12 @@
method.tagBits |= TagBits.HasMissingType;
}
method.returnType = methodType;
+ if (sourceLevel >= ClassFileConstants.JDK1_8) {
+ AnnotationBinding [] annotations = method.getAnnotations();
+ if (annotations != null && annotations != Binding.NO_ANNOTATIONS) {
+ ASTNode.copySE8AnnotationsToType(methodDecl.scope, method, annotations);
+ }
+ }
TypeBinding leafType = methodType.leafComponentType();
if (leafType instanceof ReferenceBinding && (((ReferenceBinding) leafType).modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)
method.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
@@ -2455,10 +2559,7 @@
} else {
if (nullTagBits != (method.returnType.tagBits & TagBits.AnnotationNullMASK)) {
if (!this.scope.validateNullAnnotation(nullTagBits, returnTypeRef, methodDecl.annotations)) {
- method.returnType = method.returnType.unannotated();
- } else {
- // annotation was mistakenly associated to the method, create the annotated type now:
- method.returnType = this.scope.environment().createAnnotatedType(method.returnType, nullTagBits);
+ method.returnType.tagBits &= ~TagBits.AnnotationNullMASK;
}
method.tagBits &= ~TagBits.AnnotationNullMASK;
}
@@ -2519,6 +2620,7 @@
}
}
private void evaluateNullAnnotations(long annotationTagBits) {
+
if (this.nullnessDefaultInitialized > 0 || !this.scope.compilerOptions().isAnnotationBasedNullAnalysisEnabled)
return;
boolean isPackageInfo = CharOperation.equals(this.sourceName, TypeConstants.PACKAGE_INFO_NAME);
@@ -2565,6 +2667,10 @@
}
protected void checkRedundantNullnessDefaultRecurse(ASTNode location, Annotation[] annotations, long annotationTagBits) {
+ if (this != this.prototype) {
+ this.prototype.checkRedundantNullnessDefaultRecurse(location, annotations, annotationTagBits);
+ return;
+ }
if (this.fPackage.defaultNullness != NO_NULL_DEFAULT) {
if ((this.fPackage.defaultNullness == NONNULL_BY_DEFAULT
&& ((annotationTagBits & TagBits.AnnotationNonNullByDefault) != 0))) {
@@ -2576,6 +2682,9 @@
// return: should caller continue searching?
protected boolean checkRedundantNullnessDefaultOne(ASTNode location, Annotation[] annotations, long annotationTagBits) {
+ if (this != this.prototype)
+ return this.prototype.checkRedundantNullnessDefaultOne(location, annotations, annotationTagBits);
+
int thisDefault = this.defaultNullness;
if (thisDefault == NONNULL_BY_DEFAULT) {
if ((annotationTagBits & TagBits.AnnotationNonNullByDefault) != 0) {
@@ -2587,6 +2696,10 @@
}
boolean hasNonNullDefault() {
+
+ if (this != this.prototype)
+ return this.prototype.hasNonNullDefault();
+
// find the applicable default inside->out:
SourceTypeBinding currentType = null;
@@ -2639,6 +2752,8 @@
}
public void setFields(FieldBinding[] fields) {
this.fields = fields;
+ if (this != this.prototype)
+ this.prototype.setFields(fields);
//{ObjectTeams: // integrate pendingField
if (this.pendingField != null) {
int l= fields.length;
@@ -2664,6 +2779,8 @@
} else
// SH}
this.methods = methods;
+ if (this != this.prototype)
+ this.prototype.setMethods(methods);
}
//{ObjectTeams: adding generated elements
FieldBinding pendingField= null;
@@ -2842,18 +2959,27 @@
//Markus Witte}
public final int sourceEnd() {
+ if (this != this.prototype)
+ return this.prototype.sourceEnd();
return this.scope.referenceContext.sourceEnd;
}
public final int sourceStart() {
+ if (this != this.prototype)
+ return this.prototype.sourceStart();
+
return this.scope.referenceContext.sourceStart;
}
SimpleLookupTable storedAnnotations(boolean forceInitialize) {
+ if (this != this.prototype)
+ return this.prototype.storedAnnotations(forceInitialize);
+
if (forceInitialize && this.storedAnnotations == null && this.scope != null) { // scope null when no annotation cached, and type got processed fully (159631)
this.scope.referenceCompilationUnit().compilationResult.hasAnnotations = true;
+ final CompilerOptions globalOptions = this.scope.environment().globalOptions;
//{ObjectTeams: do support annotations for roles for the sake of copying:
if (!this.isRole())
// SH}
- if (!this.scope.environment().globalOptions.storeAnnotations)
+ if (!globalOptions.storeAnnotations && !globalOptions.isAnnotationBasedNullAnalysisEnabled)
return null; // not supported during this compile
this.storedAnnotations = new SimpleLookupTable(3);
}
@@ -2866,6 +2992,8 @@
return this.superInterfaces;
}
public SyntheticMethodBinding[] syntheticMethods() {
+ if (this != this.prototype)
+ return this.prototype.syntheticMethods();
//{ObjectTeams: two different kinds of synthetics:
/* orig:
if (this.synthetics == null
@@ -2927,6 +3055,9 @@
* Answer the collection of synthetic fields to append into the classfile
*/
public FieldBinding[] syntheticFields() {
+ if (this != this.prototype)
+ return this.prototype.syntheticFields();
+
if (this.synthetics == null) return null;
int fieldSize = this.synthetics[SourceTypeBinding.FIELD_EMUL] == null ? 0 : this.synthetics[SourceTypeBinding.FIELD_EMUL].size();
int literalSize = this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL] == null ? 0 :this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].size();
@@ -2953,7 +3084,11 @@
return bindings;
}
public String toString() {
- StringBuffer buffer = new StringBuffer(30);
+ if (this.hasTypeAnnotations()) {
+ return annotatedDebugName();
+ }
+
+ StringBuffer buffer = new StringBuffer(30);
buffer.append("(id="); //$NON-NLS-1$
if (this.id == TypeIds.NoId)
buffer.append("NoId"); //$NON-NLS-1$
@@ -3057,6 +3192,10 @@
return this.typeVariables != null ? this.typeVariables : Binding.NO_TYPE_VARIABLES;
}
void verifyMethods(MethodVerifier verifier) {
+ if (this != this.prototype) {
+ this.prototype.verifyMethods(verifier);
+ return;
+ }
//{ObjectTeams: shortcut for predefined confined types (override final methods???)
if (TypeAnalyzer.isTopConfined(this))
return;
@@ -3076,11 +3215,21 @@
// SH}
}
+public TypeBinding unannotated() {
+ return this.prototype;
+}
+
public FieldBinding[] unResolvedFields() {
+ if (this != this.prototype)
+ return this.prototype.unResolvedFields();
return this.fields;
}
public void tagIndirectlyAccessibleMembers() {
+ if (this != this.prototype) {
+ this.prototype.tagIndirectlyAccessibleMembers();
+ return;
+ }
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328281
for (int i = 0; i < this.fields.length; i++) {
if (!this.fields[i].isPrivate())
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java
index d1765c1..beda545 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java
@@ -183,6 +183,8 @@
/** @since 3.9_BETA_JAVA8 marks a type that has a nullness annotation directly or on a detail (array dimension/type argument). */
long HasNullTypeAnnotation = ASTNode.Bit21;
+ long HasTypeAnnotations = ASTNode.Bit22;
+
long DefaultValueResolved = ASTNode.Bit60L;
// set when type contains non-private constructor(s)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
index db07658..d2587b6 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java
@@ -57,7 +57,15 @@
public int id = TypeIds.NoId;
public long tagBits = 0; // See values in the interface TagBits below
-
+ protected AnnotationBinding [] typeAnnotations = Binding.NO_ANNOTATIONS;
+
+ // jsr 308
+ public static final ReferenceBinding TYPE_USE_BINDING = new ReferenceBinding() { /* used for type annotation resolution. */
+ { this.id = TypeIds.T_undefined; }
+ public int kind() { return Binding.TYPE_USE; }
+ public boolean hasTypeBit(int bit) { return false; }
+ };
+
/** Base type definitions */
public final static BaseTypeBinding INT = new BaseTypeBinding(
TypeIds.T_int, TypeConstants.INT, new char[] { 'I' });
@@ -89,6 +97,17 @@
public final static BaseTypeBinding VOID = new BaseTypeBinding(
TypeIds.T_void, TypeConstants.VOID, new char[] { 'V' });
+
+public TypeBinding() {
+ super();
+}
+
+public TypeBinding(TypeBinding prototype) { // faithfully copy all instance state - clone operation should specialize/override suitably.
+ this.id = prototype.id;
+ this.tagBits = prototype.tagBits;
+ this.typeAnnotations = prototype.typeAnnotations;
+}
+
/**
* Match a well-known type id to its binding
*/
@@ -119,6 +138,42 @@
}
}
+protected ReferenceBinding actualType() {
+ return null; // overridden in ParameterizedTypeBinding & WildcardBinding
+}
+
+TypeBinding [] additionalBounds() {
+ return null; // overridden in WildcardBinding
+}
+
+public String annotatedDebugName() {
+ TypeBinding enclosingType = enclosingType();
+ StringBuffer buffer = new StringBuffer(16);
+ if (enclosingType != null) {
+ buffer.append(enclosingType.annotatedDebugName());
+ buffer.append('.');
+ }
+ AnnotationBinding [] annotations = getTypeAnnotations();
+ for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) {
+ buffer.append(annotations[i]);
+ buffer.append(' ');
+ }
+ buffer.append(sourceName());
+ return buffer.toString();
+}
+
+TypeBinding bound() {
+ return null; // overridden in WildcardBinding
+}
+
+int boundKind() {
+ return -1; // overridden in WildcardBinding
+}
+
+int rank() {
+ return -1; // overridden in WildcardBinding
+}
+
/* Answer true if the receiver can be instantiated
*/
public boolean canBeInstantiated() {
@@ -161,6 +216,15 @@
// no substitute by default
}
+/** Virtual copy constructor: a copy is made of the receiver's entire instance state and then suitably
+ parameterized by the arguments to the clone operation as seen fit by each type. Parameters may not
+ make sense for every type in the hierarchy, in which case they are silently ignored. A type may
+ choose to retain a copy of the prototype for reference.
+*/
+public TypeBinding clone(TypeBinding enclosingType, TypeBinding[] typeArguments) {
+ throw new IllegalStateException("TypeBinding#clone() should have been overridden"); //$NON-NLS-1$
+}
+
/**
* Answer the receiver's constant pool name.
* NOTE: This method should only be used during/after code gen.
@@ -169,7 +233,7 @@
public abstract char[] constantPoolName();
public String debugName() {
- return new String(readableName());
+ return this.hasTypeAnnotations() ? annotatedDebugName() : new String(readableName());
}
/*
@@ -179,6 +243,10 @@
return 0;
}
+public int depth() {
+ return 0;
+}
+
/* Answer the receiver's enclosing type... null if the receiver is a top level type.
*/
public ReferenceBinding enclosingType() {
@@ -263,7 +331,7 @@
* Find supertype which originates from a given type, or null if not found
*/
public TypeBinding findSuperTypeOriginatingFrom(TypeBinding otherType) {
- if (this == otherType) return this;
+ if (equalsEquals(this, otherType)) return this;
if (otherType == null) return null;
switch(kind()) {
case Binding.ARRAY_TYPE :
@@ -304,16 +372,16 @@
case Binding.INTERSECTION_TYPE:
// do not allow type variables/intersection types to match with erasures for free
otherType = otherType.original();
- if (this == otherType)
+ if (equalsEquals(this, otherType))
return this;
- if (original() == otherType)
+ if (equalsEquals(original(), otherType))
return this;
ReferenceBinding currentType = (ReferenceBinding)this;
if (!otherType.isInterface()) {
while ((currentType = currentType.superclass()) != null) {
- if (currentType == otherType)
+ if (equalsEquals(currentType, otherType))
return currentType;
- if (currentType.original() == otherType)
+ if (equalsEquals(currentType.original(), otherType))
return currentType;
}
return null;
@@ -333,7 +401,7 @@
nextInterface : for (int a = 0; a < itsLength; a++) {
ReferenceBinding next = itsInterfaces[a];
for (int b = 0; b < nextPosition; b++)
- if (next == interfacesToVisit[b]) continue nextInterface;
+ if (equalsEquals(next, interfacesToVisit[b])) continue nextInterface;
interfacesToVisit[nextPosition++] = next;
}
}
@@ -342,9 +410,9 @@
for (int i = 0; i < nextPosition; i++) {
currentType = interfacesToVisit[i];
- if (currentType == otherType)
+ if (equalsEquals(currentType, otherType))
return currentType;
- if (currentType.original() == otherType)
+ if (equalsEquals(currentType.original(), otherType))
return currentType;
ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
if (itsInterfaces != null && itsInterfaces != Binding.NO_SUPERINTERFACES) {
@@ -354,7 +422,7 @@
nextInterface : for (int a = 0; a < itsLength; a++) {
ReferenceBinding next = itsInterfaces[a];
for (int b = 0; b < nextPosition; b++)
- if (next == interfacesToVisit[b]) continue nextInterface;
+ if (equalsEquals(next, interfacesToVisit[b])) continue nextInterface;
interfacesToVisit[nextPosition++] = next;
}
}
@@ -525,7 +593,7 @@
* or for generic types, true if compared to its raw type.
*/
public boolean isEquivalentTo(TypeBinding otherType) {
- if (this == otherType)
+ if (equalsEquals(this, otherType))
return true;
if (otherType == null)
return false;
@@ -613,6 +681,10 @@
public boolean isAnnotatedTypeWithoutArguments() {
return false;
}
+
+public int hashCode() {
+ return this.id != TypeIds.NoId ? this.id : super.hashCode();
+}
/**
* Does this type or any of its details (array dimensions, type arguments)
* have a null type annotation?
@@ -700,7 +772,7 @@
https://bugs.eclipse.org/bugs/show_bug.cgi?id=329588
*/
- if (this == otherType)
+ if (equalsEquals(this, otherType))
return false;
if (otherType == null)
return true;
@@ -712,7 +784,7 @@
switch(otherType.kind()) {
case Binding.PARAMETERIZED_TYPE :
ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;
- if (paramType.genericType() != otherParamType.genericType())
+ if (notEquals(paramType.genericType(), otherParamType.genericType()))
return true;
if (!paramType.isStatic()) { // static member types do not compare their enclosing
ReferenceBinding enclosing = enclosingType();
@@ -738,7 +810,7 @@
return false;
case Binding.GENERIC_TYPE :
- if (paramType.genericType() != otherType)
+ if (notEquals(paramType.genericType(), otherType))
return true;
if (!paramType.isStatic()) { // static member types do not compare their enclosing
ReferenceBinding enclosing = enclosingType();
@@ -746,7 +818,7 @@
ReferenceBinding otherEnclosing = otherType.enclosingType();
if (otherEnclosing == null) return true;
if ((otherEnclosing.tagBits & TagBits.HasDirectWildcard) == 0) {
- if (enclosing != otherEnclosing) return true;
+ if (notEquals(enclosing, otherEnclosing)) return true;
} else {
if (!enclosing.isEquivalentTo(otherType.enclosingType())) return true;
}
@@ -764,15 +836,12 @@
return false;
case Binding.RAW_TYPE :
+ case Binding.TYPE: // https://bugs.eclipse.org/bugs/show_bug.cgi?id=329588
//{ObjectTeams: dependent types?
/* orig:
- return erasure() != otherType.erasure();
- case Binding.TYPE: // https://bugs.eclipse.org/bugs/show_bug.cgi?id=329588
- return erasure() != otherType;
+ return notEquals(erasure(), otherType.erasure());
:giro */
return distinctRealTypes(erasure(), otherType.erasure());
- case Binding.TYPE: // https://bugs.eclipse.org/bugs/show_bug.cgi?id=329588
- return distinctRealTypes(erasure(), otherType);
// SH}
}
return true;
@@ -798,7 +867,7 @@
switch(otherType.kind()) {
case Binding.PARAMETERIZED_TYPE :
case Binding.RAW_TYPE :
- return this != otherType.erasure();
+ return notEquals(this, otherType.erasure());
}
break;
@@ -811,7 +880,7 @@
boolean distinctRealTypes(TypeBinding one, TypeBinding two) {
if (one instanceof ReferenceBinding && two instanceof ReferenceBinding)
if (DependentTypeBinding.isDependentType(one) || DependentTypeBinding.isDependentType(two))
- return ((ReferenceBinding)one).getRealType() != ((ReferenceBinding)two).getRealType();
+ return notEquals(((ReferenceBinding)one).getRealType(), ((ReferenceBinding)two).getRealType());
return one != two;
}
// SH}
@@ -1299,11 +1368,16 @@
}
/**
- * Return this type minus its tagBit-encoded type annotations
+ * Return this type minus its type annotations
*/
public TypeBinding unannotated() {
return this;
}
+
+public boolean hasTypeAnnotations() {
+ return (this.tagBits & TagBits.HasTypeAnnotations) != 0;
+}
+
/**
* Answer the qualified name of the receiver's package separated by periods
* or an empty string if its the default package.
@@ -1327,6 +1401,35 @@
public abstract char[] qualifiedSourceName();
/**
+ * @return the JSR 308 annotations for this type.
+ */
+public AnnotationBinding[] getTypeAnnotations() {
+ return this.typeAnnotations;
+}
+
+public void setTypeAnnotations(AnnotationBinding[] annotations, boolean evalNullAnnotations) {
+ this.tagBits |= TagBits.HasTypeAnnotations;
+ if (annotations == null || annotations == Binding.NO_ANNOTATIONS)
+ return;
+ this.typeAnnotations = annotations;
+ if (evalNullAnnotations) {
+ for (int i = 0, length = annotations.length; i < length; i++) {
+ AnnotationBinding annotation = annotations[i];
+ if (annotation != null) {
+ switch (annotation.type.id) {
+ case TypeIds.T_ConfiguredAnnotationNullable :
+ this.tagBits |= TagBits.AnnotationNullable | TagBits.HasNullTypeAnnotation;
+ break;
+ case TypeIds.T_ConfiguredAnnotationNonNull :
+ this.tagBits |= TagBits.AnnotationNonNull | TagBits.HasNullTypeAnnotation;
+ break;
+ }
+ }
+ }
+ }
+}
+
+/**
* Answer the receiver classfile signature.
* Arrays & base types do not distinguish between signature() & constantPoolName().
* NOTE: This method should only be used during/after code gen.
@@ -1347,6 +1450,13 @@
// subclasses must override if they wrap another type binding
}
+//{ObjectTeams: visible across AbstractOTReferenceBinding (in a different package):
+protected
+// SH}
+TypeBinding [] typeArguments () {
+ return null;
+}
+
public TypeVariableBinding[] typeVariables() {
return Binding.NO_TYPE_VARIABLES;
}
@@ -1381,4 +1491,25 @@
public ReferenceBinding[] getIntersectingTypes() {
return null;
}
+
+public static boolean equalsEquals(TypeBinding that, TypeBinding other) {
+ if (that == other)
+ return true;
+ if (that == null || other == null)
+ return false;
+ if (that.id != TypeIds.NoId && that.id == other.id)
+ return true;
+ return false;
+}
+
+public static boolean notEquals(TypeBinding that, TypeBinding other) {
+ if (that == other)
+ return false;
+ if (that == null || other == null)
+ return true;
+ if (that.id != TypeIds.NoId && that.id == other.id)
+ return false;
+ return true;
+}
+
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBindingVisitor.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBindingVisitor.java
index 2f54acb..e01368e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBindingVisitor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBindingVisitor.java
@@ -15,7 +15,6 @@
package org.eclipse.jdt.internal.compiler.lookup;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
-import org.eclipse.jdt.internal.compiler.ast.Annotation.TypeUseBinding;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
@@ -51,10 +50,6 @@
return true; // continue traversal.
}
- public boolean visit(TypeUseBinding typeUseBinding) {
- return true; // continue traversal.
- }
-
public boolean visit(RawTypeBinding rawTypeBinding) {
return true; // continue traversal.
}
@@ -139,10 +134,6 @@
visit(visitor, intersectionCastTypeBinding.intersectingTypes);
break;
- case Binding.TYPE_USE:
- visitor.visit((TypeUseBinding) type);
- break;
-
default:
throw new InternalError("Unexpected binding type"); //$NON-NLS-1$
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java
index 186cb9c..2f4428f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java
@@ -123,15 +123,16 @@
final int T_ComGoogleCommonBasePreconditions = 73;
final int T_JavaUtilObjects = 74;
- // new in 3.9 to identify known @Inject annotations
- final int T_JavaxInjectInject = 80;
- final int T_ComGoogleInjectInject = 81;
-
-
// java 8
final int T_JavaLangFunctionalInterface = 69;
+ // new in 3.9 to identify known @Inject annotations
+ final int T_JavaxInjectInject = 80;
+ final int T_ComGoogleInjectInject = 81;
+ // If you add new type id, make sure to bump up T_LastWellKnownTypeId if there is a cross over.
+ final int T_LastWellKnownTypeId = 128;
+
final int NoId = Integer.MAX_VALUE;
public static final int IMPLICIT_CONVERSION_MASK = 0xFF;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
index b9c2b36..f91b085 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
@@ -71,6 +71,17 @@
this.environment = environment;
this.typeBits = TypeIds.BitUninitialized;
}
+
+ public TypeVariableBinding(TypeVariableBinding prototype) {
+ super(prototype);
+ this.declaringElement = prototype.declaringElement;
+ this.rank = prototype.rank;
+ this.firstBound = prototype.firstBound;
+ this.superclass = prototype.superclass;
+ this.superInterfaces = prototype.superInterfaces;
+ this.genericTypeSignature = prototype.genericTypeSignature;
+ this.environment = prototype.environment;
+ }
/**
* Returns true if the argument type satisfies all bounds of the type parameter
@@ -96,7 +107,7 @@
//{ObjectTeams: added optional argument actualReceiverType:
private int internalBoundCheck(Substitution substitution, TypeBinding argumentType, ReferenceBinding actualReceiverType, Scope scope) {
// SH}
- if (argumentType == TypeBinding.NULL || argumentType == this) {
+ if (argumentType == TypeBinding.NULL || TypeBinding.equalsEquals(argumentType, this)) {
return TypeConstants.OK;
}
boolean hasSubstitution = substitution != null;
@@ -112,7 +123,7 @@
switch(wildcard.boundKind) {
case Wildcard.EXTENDS :
TypeBinding wildcardBound = wildcard.bound;
- if (wildcardBound == this)
+ if (TypeBinding.equalsEquals(wildcardBound, this))
return TypeConstants.OK;
boolean isArrayBound = wildcardBound.isArrayType();
if (!wildcardBound.isInterface()) {
@@ -176,7 +187,7 @@
boolean unchecked = false;
if (this.superclass.id != TypeIds.T_JavaLangObject) {
TypeBinding substitutedSuperType = hasSubstitution ? Scope.substitute(substitution, this.superclass) : this.superclass;
- if (substitutedSuperType != argumentType) {
+ if (TypeBinding.notEquals(substitutedSuperType, argumentType)) {
if (!argumentType.isCompatibleWith(substitutedSuperType, scope)) {
return TypeConstants.MISMATCH;
}
@@ -231,7 +242,7 @@
// SH}
for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
TypeBinding substitutedSuperType = hasSubstitution ? Scope.substitute(substitution, this.superInterfaces[i]) : this.superInterfaces[i];
- if (substitutedSuperType != argumentType) {
+ if (TypeBinding.notEquals(substitutedSuperType, argumentType)) {
if (!argumentType.isCompatibleWith(substitutedSuperType, scope)) {
return TypeConstants.MISMATCH;
}
@@ -399,10 +410,37 @@
}
return this.superclass.constantPoolName(); // java/lang/Object
}
+
+ public TypeBinding clone(TypeBinding enclosingType, TypeBinding[] typeArguments) {
+ return new TypeVariableBinding(this);
+ }
+ public String annotatedDebugName() {
+ StringBuffer buffer = new StringBuffer(10);
+ buffer.append('<');
+ buffer.append(super.annotatedDebugName());
+ if (this.superclass != null && this.firstBound == this.superclass) {
+ buffer.append(" extends ").append(this.superclass.annotatedDebugName()); //$NON-NLS-1$
+ }
+ if (this.superInterfaces != null && this.superInterfaces != Binding.NO_SUPERINTERFACES) {
+ if (this.firstBound != this.superclass) {
+ buffer.append(" extends "); //$NON-NLS-1$
+ }
+ for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
+ if (i > 0 || this.firstBound == this.superclass) {
+ buffer.append(" & "); //$NON-NLS-1$
+ }
+ buffer.append(this.superInterfaces[i].annotatedDebugName());
+ }
+ }
+ buffer.append('>');
+ return buffer.toString();
+ }
/**
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#debugName()
*/
public String debugName() {
+ if (this.hasTypeAnnotations())
+ return super.annotatedDebugName();
return new String(this.sourceName);
}
public TypeBinding erasure() {
@@ -645,6 +683,8 @@
* @see java.lang.Object#toString()
*/
public String toString() {
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
StringBuffer buffer = new StringBuffer(10);
buffer.append('<').append(this.sourceName);//.append('[').append(this.rank).append(']');
//{ObjectTeams:
@@ -670,6 +710,9 @@
return buffer.toString();
}
+ public TypeBinding unannotated() {
+ return this.hasTypeAnnotations() ? this.environment.getUnannotatedType(this) : this;
+ }
/**
* Upper bound doesn't perform erasure
*/
@@ -681,17 +724,6 @@
}
public void evaluateNullAnnotations(Scope scope, TypeParameter parameter) {
- Annotation[] annotations = parameter.annotations;
- int len = annotations.length;
- for (int j=0; j<len; j++) {
- Binding recipient = annotations[j].recipient;
- if (recipient instanceof Annotation.TypeUseBinding) {
- // FIXME(stephan): detect contradictions
- long annotationsTagBits = ((Annotation.TypeUseBinding)recipient).tagBits & TagBits.AnnotationNullMASK;
- if (annotationsTagBits != 0)
- this.tagBits |= annotationsTagBits | TagBits.HasNullTypeAnnotation;
- }
- }
long nullTagBits = this.tagBits & TagBits.AnnotationNullMASK;
if (this.firstBound != null && this.firstBound.isValidBinding()) {
long superNullTagBits = this.firstBound.tagBits & TagBits.AnnotationNullMASK;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnannotatedTypeSystem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnannotatedTypeSystem.java
new file mode 100644
index 0000000..f25e5ef
--- /dev/null
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnannotatedTypeSystem.java
@@ -0,0 +1,278 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ *
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.lookup;
+
+import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
+import org.eclipse.jdt.internal.compiler.util.Util;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.DependentTypeBinding;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.ITeamAnchor;
+import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.RoleTypeBinding;
+
+/* UnannotatedTypeSystem: An abstraction responsible for keeping track of naked a.k.a unannotated types. This piece is also responsible for id stamping unique
+ types. Only those types that are "derived from" in some form or participate in the derivation in some form (by being type arguments say) get tracked and
+ id'd here. At Java 8 time, a new type can be derived from another type by (a) parameterizing it (b) creating arrays of it, (c) by creating raw forms of it,
+ (d) by creating a wild card that could parameterize it or finally by (e) annotating it. A type which is not thus derived from in one form or the other or
+ participate in the derivation thus - UTS is completely oblivious to.
+
+ TypeBinding.id computation: For primitive types and certain "well known" types, id assignment happens elsewhere. Here we start with an id value that is
+ suitably high and proceed monotonically upwards so we will not accidentally collide with the id space in use already. id assignments happens in such a
+ way that a naked type and its annotated variants - variously annotated - would all share the same id. Example: @T1 Map<@T2 String, @T3 Object> and
+ Map<@T4 String, @T5 Object> and @T6 Map<String, Object> and @T7 Map<String, @T8 Object> and Map<String, @T9 Object> would all share the same id since
+ the unadorned naked type in each case is the same: Map<String, Object>. None of this would share the id with Map<String, String>. Briefly put, if you
+ take a certain annotated type and strip it of all annotations to come up with the naked type, that naked type and the annotated type would have the
+ same id. Alternately, if you take a certain naked type and arrive at the set of all differently annotated types, they would all share the same id while
+ their bindings could be different - would be different unless they are identically annotated.
+
+ Thus subsystems that are annotation agnostic could quickly ascertain binding equality by comparing the id field.
+*/
+public class UnannotatedTypeSystem {
+
+ private int typeid = TypeIds.T_LastWellKnownTypeId;
+ private TypeBinding [][] types;
+ private SimpleLookupTable annotationTypes;
+ private LookupEnvironment environment;
+
+ public UnannotatedTypeSystem(LookupEnvironment environment) {
+ this.environment = environment;
+ this.annotationTypes = new SimpleLookupTable(16);
+ this.typeid = TypeIds.T_LastWellKnownTypeId;
+ this.types = new TypeBinding[TypeIds.T_LastWellKnownTypeId * 2][];
+ }
+
+ TypeBinding getUnannotatedType(TypeBinding type) {
+ if (type.id == TypeIds.NoId) {
+ if (type.hasTypeAnnotations() && !type.isTypeVariable())
+ throw new IllegalStateException();
+ int typesLength = this.types.length;
+ if (this.typeid == typesLength)
+ System.arraycopy(this.types, 0, this.types = new TypeBinding[typesLength * 2][], 0, typesLength);
+ this.types[type.id = this.typeid++] = new TypeBinding[4];
+ } else {
+ TypeBinding nakedType = this.types[type.id] == null ? null : this.types[type.id][0];
+ if (type.hasTypeAnnotations() && nakedType == null)
+ throw new IllegalStateException();
+ if (nakedType != null)
+ return nakedType;
+ this.types[type.id] = new TypeBinding[4]; // well known type, assigned id elsewhere.
+ }
+
+ return this.types[type.id][0] = type;
+ }
+
+ public ArrayBinding getArrayType(TypeBinding leafType, int dimensions) {
+ TypeBinding unannotatedLeafType = getUnannotatedType(leafType);
+ TypeBinding[] cachedInfo = this.types[unannotatedLeafType.id]; // by construction, cachedInfo != null now.
+ int index = 0;
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isArrayType())
+ continue;
+ if (cachedType.leafComponentType() == unannotatedLeafType && cachedType.dimensions() == dimensions)
+ return (ArrayBinding) cachedType;
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.types[unannotatedLeafType.id] = cachedInfo;
+ }
+ // Add the new array type id stamping it.
+ TypeBinding arrayType = cachedInfo[index] = new ArrayBinding(unannotatedLeafType, dimensions, this.environment);
+ int typesLength = this.types.length;
+ if (this.typeid == typesLength)
+ System.arraycopy(this.types, 0, this.types = new TypeBinding[typesLength * 2][], 0, typesLength);
+ this.types[this.typeid] = new TypeBinding[1];
+ return (ArrayBinding) (this.types[arrayType.id = this.typeid++][0] = arrayType);
+ }
+
+//{ObjectTeams: 2 parameters added:
+/* orig:
+ public ParameterizedTypeBinding getParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType) {
+ :giro */
+ public ParameterizedTypeBinding getParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments,
+ ITeamAnchor teamAnchor, int valueParamPosition, ReferenceBinding enclosingType) {
+// SH}
+ ReferenceBinding unannotatedGenericType = (ReferenceBinding) getUnannotatedType(genericType);
+ int typeArgumentsLength = typeArguments == null ? 0: typeArguments.length;
+ TypeBinding [] unannotatedTypeArguments = typeArguments == null ? null : new TypeBinding[typeArgumentsLength];
+ for (int i = 0; i < typeArgumentsLength; i++) {
+ unannotatedTypeArguments[i] = getUnannotatedType(typeArguments[i]);
+ }
+ ReferenceBinding unannotatedEnclosingType = enclosingType == null ? null : (ReferenceBinding) getUnannotatedType(enclosingType);
+
+ TypeBinding[] cachedInfo = this.types[unannotatedGenericType.id]; // by construction, cachedInfo != null now.
+ int index = 0;
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isParameterizedType())
+ continue;
+//{ObjectTeams: also match team anchor if given:
+ if (!isRoleTypeMatch(teamAnchor, valueParamPosition, cachedType))
+ continue;
+//SH}
+ if (cachedType.enclosingType() == unannotatedEnclosingType && Util.effectivelyEqual(cachedType.typeArguments(), unannotatedTypeArguments))
+ return (ParameterizedTypeBinding) cachedType;
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.types[unannotatedGenericType.id] = cachedInfo;
+ }
+//{ObjectTeams: dependent type?
+/* orig:
+ TypeBinding parameterizedType = cachedInfo[index] = new ParameterizedTypeBinding(unannotatedGenericType, unannotatedTypeArguments, unannotatedEnclosingType, this.environment);
+ :giro */
+ TypeBinding parameterizedType;
+ if (teamAnchor == null) {
+ parameterizedType = new ParameterizedTypeBinding(unannotatedGenericType, unannotatedTypeArguments, unannotatedEnclosingType, this.environment);
+ } else {
+ if (genericType.isRole()) {
+ parameterizedType = new RoleTypeBinding(genericType, typeArguments, teamAnchor, enclosingType, this.environment);
+ } else {
+ parameterizedType = new DependentTypeBinding(genericType, typeArguments, teamAnchor, valueParamPosition, enclosingType, this.environment);
+ }
+ }
+ cachedInfo[index] = parameterizedType;
+// SH}
+
+ int typesLength = this.types.length;
+ if (this.typeid == typesLength)
+ System.arraycopy(this.types, 0, this.types = new TypeBinding[typesLength * 2][], 0, typesLength);
+ this.types[this.typeid] = new TypeBinding[1];
+ return (ParameterizedTypeBinding) (this.types[parameterizedType.id = this.typeid++][0] = parameterizedType);
+ }
+
+//{ObjectTeams: compare role types:
+ boolean isRoleTypeMatch(ITeamAnchor teamAnchor, int valueParamPosition, TypeBinding cachedType) {
+ if (teamAnchor != null) {
+ if (!(cachedType instanceof DependentTypeBinding))
+ return false;
+ if (!((DependentTypeBinding)cachedType)._teamAnchor.hasSameBestNameAs(teamAnchor))
+ return false;
+ }
+ if ( valueParamPosition > -1 // position specified, requires dependent type
+ && !(cachedType instanceof DependentTypeBinding))
+ return false;
+ if ( (cachedType instanceof DependentTypeBinding) // dependent type specified, positions must match
+ && ((DependentTypeBinding)cachedType)._valueParamPosition != valueParamPosition)
+ return false;
+ if (teamAnchor == null && RoleTypeBinding.isRoleType(cachedType)) // role type found though not requested?
+ return false;
+ return true;
+ }
+//SH}
+
+ public RawTypeBinding getRawType(ReferenceBinding genericType, ReferenceBinding enclosingType) {
+ ReferenceBinding unannotatedGenericType = (ReferenceBinding) getUnannotatedType(genericType);
+ ReferenceBinding unannotatedEnclosingType = enclosingType == null ? null : (ReferenceBinding) getUnannotatedType(enclosingType);
+
+ TypeBinding[] cachedInfo = this.types[unannotatedGenericType.id]; // by construction, cachedInfo != null now.
+ int index = 0;
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isRawType())
+ continue;
+ if (cachedType.enclosingType() == unannotatedEnclosingType)
+ return (RawTypeBinding) cachedType;
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.types[unannotatedGenericType.id] = cachedInfo;
+ }
+
+ TypeBinding rawTytpe = cachedInfo[index] = new RawTypeBinding(unannotatedGenericType, unannotatedEnclosingType, this.environment);
+ int typesLength = this.types.length;
+ if (this.typeid == typesLength)
+ System.arraycopy(this.types, 0, this.types = new TypeBinding[typesLength * 2][], 0, typesLength);
+ this.types[this.typeid] = new TypeBinding[1];
+ return (RawTypeBinding) (this.types[rawTytpe.id = this.typeid++][0] = rawTytpe);
+ }
+
+
+ public WildcardBinding getWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind) {
+ if (genericType == null) // pseudo wildcard denoting composite bounds for lub computation
+ genericType = ReferenceBinding.LUB_GENERIC;
+
+ ReferenceBinding unannotatedGenericType = (ReferenceBinding) getUnannotatedType(genericType);
+ int otherBoundsLength = otherBounds == null ? 0: otherBounds.length;
+ TypeBinding [] unannotatedOtherBounds = otherBounds == null ? null : new TypeBinding[otherBoundsLength];
+ for (int i = 0; i < otherBoundsLength; i++) {
+ unannotatedOtherBounds[i] = getUnannotatedType(otherBounds[i]);
+ }
+ TypeBinding unannotatedBound = bound == null ? null : getUnannotatedType(bound);
+
+ TypeBinding[] cachedInfo = this.types[unannotatedGenericType.id]; // by construction, cachedInfo != null now.
+ int index = 0;
+ for (int max = cachedInfo.length; index < max; index++) {
+ TypeBinding cachedType = cachedInfo[index];
+ if (cachedType == null)
+ break;
+ if (!cachedType.isWildcard())
+ continue;
+ if (cachedType.rank() != rank || cachedType.boundKind() != boundKind || cachedType.bound() != unannotatedBound)
+ continue;
+ if (Util.effectivelyEqual(cachedType.additionalBounds(), unannotatedOtherBounds))
+ return (WildcardBinding) cachedType;
+ }
+
+ int length = cachedInfo.length;
+ if (index == length) {
+ System.arraycopy(cachedInfo, 0, cachedInfo = new TypeBinding[length * 2], 0, length);
+ this.types[unannotatedGenericType.id] = cachedInfo;
+ }
+ TypeBinding wildcard = cachedInfo[index] = new WildcardBinding(unannotatedGenericType, rank, unannotatedBound, unannotatedOtherBounds, boundKind, this.environment);
+
+ int typesLength = this.types.length;
+ if (this.typeid == typesLength)
+ System.arraycopy(this.types, 0, this.types = new TypeBinding[typesLength * 2][], 0, typesLength);
+ this.types[this.typeid] = new TypeBinding[1];
+ return (WildcardBinding) (this.types[wildcard.id = this.typeid++][0] = wildcard);
+ }
+
+
+ public AnnotationBinding getAnnotationType(ReferenceBinding annotationType) {
+ AnnotationBinding annotation = (AnnotationBinding) this.annotationTypes.get(annotationType);
+ if (annotation == null) {
+ annotation = new AnnotationBinding(annotationType, Binding.NO_ELEMENT_VALUE_PAIRS);
+ this.annotationTypes.put(annotationType, annotation);
+ }
+ return annotation;
+ }
+
+ public void reset() {
+ this.annotationTypes = new SimpleLookupTable(16);
+ this.typeid = TypeIds.T_LastWellKnownTypeId;
+ this.types = new TypeBinding[TypeIds.T_LastWellKnownTypeId * 2][];
+ }
+
+ public void updateCaches(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType) {
+ final int unresolvedTypeId = unresolvedType.id;
+ if (unresolvedTypeId == TypeIds.NoId)
+ return;
+ if (this.types[unresolvedTypeId] != null && this.types[unresolvedTypeId][0] == unresolvedType) {
+ resolvedType.id = unresolvedTypeId;
+ this.types[unresolvedTypeId][0] = resolvedType;
+ }
+ }
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java
index fa4ae18..ce66700 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java
@@ -26,7 +26,8 @@
ReferenceBinding resolvedType;
TypeBinding[] wrappers;
-ReferenceBinding original; // used by a clone to refer to the source of cloning
+UnresolvedReferenceBinding prototype;
+TypeBinding enclosingType;
//{ObjectTeams: make visible to subclass:
protected
@@ -36,13 +37,26 @@
this.sourceName = compoundName[compoundName.length - 1]; // reasonable guess
this.fPackage = packageBinding;
this.wrappers = null;
+ this.prototype = this;
+ computeId();
}
-// for cloning with tagBits:
-UnresolvedReferenceBinding(ReferenceBinding refType, long tagBits) {
- this(refType.compoundName, refType.fPackage);
- this.original = refType;
- this.tagBits |= tagBits;
+
+public UnresolvedReferenceBinding(UnresolvedReferenceBinding prototype) {
+ super(prototype);
+ this.resolvedType = prototype.resolvedType;
+ this.wrappers = null;
+ this.prototype = prototype.prototype;
}
+
+public TypeBinding clone(TypeBinding outerType, TypeBinding[] someTypeArguments) {
+ if (this.resolvedType != null)
+ throw new IllegalStateException();
+ UnresolvedReferenceBinding copy = new UnresolvedReferenceBinding(this);
+ copy.enclosingType = outerType;
+ this.addWrapper(copy, null);
+ return copy;
+}
+
void addWrapper(TypeBinding wrapper, LookupEnvironment environment) {
if (this.resolvedType != null) {
// the type reference B<B<T>.M> means a signature of <T:Ljava/lang/Object;>LB<LB<TT;>.M;>;
@@ -73,10 +87,14 @@
//{ObjectTeams: changed to public (was default-vis)
public ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {
// SH}
+ if (this != this.prototype) {
+ this.prototype.resolve(environment, convertGenericToRawType);
+ return this.resolvedType;
+ }
ReferenceBinding targetType = this.resolvedType;
if (targetType == null) {
targetType = this.fPackage.getType0(this.compoundName[this.compoundName.length - 1]);
- if (targetType == this || targetType == this.original) {
+ if (targetType == this) {
targetType = environment.askForType(this.compoundName);
}
if (targetType == null || targetType == this) { // could not resolve any better, error was already reported against it
@@ -89,12 +107,6 @@
}
// create a proxy for the missing BinaryType
targetType = environment.createMissingType(null, this.compoundName);
- } else if (!(targetType instanceof UnresolvedReferenceBinding)) {
- // for a clone pre-populated with tagBits wrap the resolved type in an annotated type
- // (represented by a ParameterizedTypeBinding):
- long nullTagBits = this.tagBits & TagBits.AnnotationNullMASK;
- if (nullTagBits != 0L)
- targetType = (ReferenceBinding) environment.createAnnotatedType(targetType, nullTagBits);
}
setResolvedType(targetType, environment);
}
@@ -115,7 +127,22 @@
this.wrappers[i].swapUnresolved(this, targetType, environment);
environment.updateCaches(this, targetType);
}
+
+public void swapUnresolved(UnresolvedReferenceBinding unresolvedType, ReferenceBinding unannotatedType, LookupEnvironment environment) {
+ if (this.resolvedType != null) return;
+ ReferenceBinding annotatedType = (ReferenceBinding) unannotatedType.clone(this.enclosingType != null ? this.enclosingType : unannotatedType.enclosingType(), null);
+
+ this.resolvedType = annotatedType;
+ annotatedType.setTypeAnnotations(getTypeAnnotations(), environment.globalOptions.isAnnotationBasedNullAnalysisEnabled);
+ annotatedType.id = unannotatedType.id = this.id;
+ if (this.wrappers != null)
+ for (int i = 0, l = this.wrappers.length; i < l; i++)
+ this.wrappers[i].swapUnresolved(this, annotatedType, environment);
+ environment.updateCaches(this, annotatedType);
+}
public String toString() {
+ if (this.hasTypeAnnotations())
+ return super.annotatedDebugName() + "(unresolved)"; //$NON-NLS-1$
return "Unresolved type " + ((this.compoundName != null) ? CharOperation.toString(this.compoundName) : "UNNAMED"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
index f8eca68..72c51df 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
@@ -70,6 +70,20 @@
this.typeBits = TypeIds.BitUninitialized;
}
+ public WildcardBinding(WildcardBinding prototype) {
+ super(prototype);
+ this.genericType = prototype.genericType;
+ this.rank = prototype.rank;
+ this.bound = prototype.bound;
+ this.otherBounds = prototype.otherBounds;
+ this.genericSignature = prototype.genericSignature;
+ this.boundKind = prototype.boundKind;
+ this.superclass = prototype.superclass;
+ this.superInterfaces = prototype.superInterfaces;
+ this.typeVariable = prototype.typeVariable;
+ this.environment = prototype.environment;
+ }
+
//{ObjectTeams: role wrapping?
public TypeBinding maybeWrapQualifiedRoleType(Scope scope, Expression anchorExpr, ASTNode typedNode) {
TypeBinding wrappedBound = RoleTypeCreator.maybeWrapQualifiedRoleType(scope, anchorExpr, this.bound, typedNode);
@@ -420,6 +434,32 @@
return erasure().constantPoolName();
}
+ public TypeBinding clone(TypeBinding immaterial, TypeBinding[] irrelevant) {
+ return new WildcardBinding(this);
+ }
+
+ public String annotatedDebugName() {
+ StringBuffer buffer = new StringBuffer(16);
+ AnnotationBinding [] annotations = getTypeAnnotations();
+ for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) {
+ buffer.append(annotations[i]);
+ buffer.append(' ');
+ }
+ switch (this.boundKind) {
+ case Wildcard.UNBOUND :
+ return buffer.append(TypeConstants.WILDCARD_NAME).toString();
+ case Wildcard.EXTENDS :
+ if (this.otherBounds == null)
+ return buffer.append(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.annotatedDebugName().toCharArray())).toString();
+ buffer.append(this.bound.annotatedDebugName());
+ for (int i = 0, length = this.otherBounds.length; i < length; i++) {
+ buffer.append('&').append(this.otherBounds[i].annotatedDebugName());
+ }
+ return buffer.toString();
+ default: // SUPER
+ return buffer.append(CharOperation.concat(TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.annotatedDebugName().toCharArray())).toString();
+ }
+ }
/**
* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#debugName()
*/
@@ -539,6 +579,10 @@
return true;
}
+ int rank() {
+ return this.rank;
+ }
+
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.lookup.Binding#readableName()
*/
@@ -748,6 +792,8 @@
* @see java.lang.Object#toString()
*/
public String toString() {
+ if (this.hasTypeAnnotations())
+ return annotatedDebugName();
switch (this.boundKind) {
case Wildcard.UNBOUND :
return new String(TypeConstants.WILDCARD_NAME);
@@ -776,15 +822,6 @@
}
public TypeBinding unannotated() {
- if (!hasNullTypeAnnotations())
- return this;
- TypeBinding boundType = this.bound.unannotated();
- TypeBinding[] otherBoundTypes = null;
- if (this.otherBounds != null) {
- otherBoundTypes = new TypeBinding[this.otherBounds.length];
- for (int i = 0; i < this.otherBounds.length; i++)
- otherBoundTypes[i] = this.otherBounds[i].unannotated();
- }
- return this.environment.createWildcard(this.genericType, this.rank, boundType, otherBoundTypes, this.boundKind);
+ return this.hasTypeAnnotations() ? this.environment.getUnannotatedType(this) : this;
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
index 0b1b841..6c87dd1 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
@@ -1612,4 +1612,20 @@
return scanTypeSignature(string, start);
}
}
+
+ public static boolean effectivelyEqual(Object [] one, Object [] two) {
+ if (one == two)
+ return true;
+ int oneLength = one == null ? 0 : one.length;
+ int twoLength = two == null ? 0 : two.length;
+ if (oneLength != twoLength)
+ return false;
+ if (oneLength == 0)
+ return true;
+ for (int i = 0; i < one.length; i++) {
+ if (one[i] != two[i])
+ return false;
+ }
+ return true;
+ }
}
\ No newline at end of file
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/LiftingTypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/LiftingTypeReference.java
index c0fd792..22be863 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/LiftingTypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/LiftingTypeReference.java
@@ -40,6 +40,7 @@
import org.eclipse.jdt.internal.compiler.ast.LongLiteral;
import org.eclipse.jdt.internal.compiler.ast.NullLiteral;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.MissingTypeBinding;
@@ -204,7 +205,7 @@
ITeamAnchor anchor = null;
if (roleRefType.baseclass() instanceof RoleTypeBinding)
anchor = ((RoleTypeBinding)roleRefType.baseclass())._teamAnchor;
- roleBase = parameterizedRole.environment.createParameterizedType((ReferenceBinding)roleBase.original(), typeArgs, 0L, anchor, -1, roleBase.enclosingType());
+ roleBase = parameterizedRole.environment.createParameterizedType((ReferenceBinding)roleBase.original(), typeArgs, anchor, -1, roleBase.enclosingType(), Binding.NO_ANNOTATIONS);
}
// THE compatibility check:
if ( !baseType.isCompatibleWith(roleBase)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
index 90c62dd..b78cdf0 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
@@ -810,10 +810,10 @@
RoleTypeBinding baseRole = (RoleTypeBinding)boundBase;
boundBase = environment.createParameterizedType(baseRole._declaredRoleType,
null, // erase type parameters
- 0L, // annotationTagBits
- baseRole._teamAnchor, // but retain anchor
- -1, // valueParamPosition
- baseRole.enclosingType());
+ baseRole._teamAnchor, // but retain anchor
+ -1, // valueParamPosition
+ baseRole.enclosingType(),
+ Binding.NO_ANNOTATIONS);
}
// only RTB but not parameterized: leave unchanged.
} else {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
index 8279312..d36a115 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
@@ -69,7 +69,14 @@
// allow to see this as a ReferenceBinding:
protected abstract ReferenceBinding _this();
-
+
+ public AbstractOTReferenceBinding(ReferenceBinding prototype) {
+ super(prototype);
+ }
+
+ protected AbstractOTReferenceBinding() {
+ super();
+ }
// === Start OT-additions: ===
/** If set to true, assume that this class implements o.o.IBoundBase (will be added by the OTRE) */
private boolean isBoundBase = false;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
index 1ac4de8..bd34a7f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
@@ -794,7 +794,7 @@
LookupEnvironment env)
{
DependentTypeBinding dependentTypeBinding =
- (DependentTypeBinding)env.createParameterizedType(typeBinding, arguments, 0L, this, paramPosition, typeBinding.enclosingType());
+ (DependentTypeBinding)env.createParameterizedType(typeBinding, arguments, this, paramPosition, typeBinding.enclosingType(), Binding.NO_ANNOTATIONS);
return (dimensions > 0)
? dependentTypeBinding.getArrayType(dimensions)
: dependentTypeBinding;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
index 73948d9..1d310b3 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
@@ -773,7 +773,7 @@
TypeBinding[] typeArguments = liftMethod[0].typeVariables();
if (typeArguments != Binding.NO_TYPE_VARIABLES)
try {
- roleVarType = Config.getLookupEnvironment().createParameterizedType(roleVarType, typeArguments, 0L, null, -1, roleModel.getBinding().enclosingType());
+ roleVarType = Config.getLookupEnvironment().createParameterizedType(roleVarType, typeArguments, null, -1, roleModel.getBinding().enclosingType(), Binding.NO_ANNOTATIONS);
} catch (NotConfiguredException e) {
e.logWarning("Cannot lookup parameterized type"); //$NON-NLS-1$
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/model/TeamModel.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/model/TeamModel.java
index 0f93f51..7354e00 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/model/TeamModel.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/model/TeamModel.java
@@ -33,6 +33,7 @@
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
@@ -613,7 +614,7 @@
if (roleType.isParameterizedType()) {
// consult original role type for type arguments:
ParameterizedTypeBinding ptb = (ParameterizedTypeBinding)roleType;
- TypeBinding parameterized = ptb.environment.createParameterizedType(roleRefType, ptb.arguments, 0L, anchor, -1, roleRefType.enclosingType());
+ TypeBinding parameterized = ptb.environment.createParameterizedType(roleRefType, ptb.arguments, anchor, -1, roleRefType.enclosingType(), Binding.NO_ANNOTATIONS);
if (dimensions > 0)
return ptb.environment.createArrayType(parameterized, dimensions);
return parameterized;