From 46120337654a09db60dbf563fdeee34bd3985a0d Mon Sep 17 00:00:00 2001 From: Philipe Mulet Date: Sun, 3 Apr 2005 08:28:20 +0000 Subject: 36397 --- org.eclipse.jdt.core/buildnotes_jdt-core.html | 20 +++ .../internal/compiler/ast/ArrayInitializer.java | 2 + .../jdt/internal/compiler/ast/Assignment.java | 18 +-- .../internal/compiler/ast/FieldDeclaration.java | 26 ++-- .../internal/compiler/ast/LocalDeclaration.java | 30 ++--- .../ast/QualifiedAllocationExpression.java | 2 + .../jdt/internal/compiler/ast/ReturnStatement.java | 21 ++-- .../compiler/lookup/BinaryTypeBinding.java | 13 +- .../jdt/internal/compiler/lookup/ClassScope.java | 4 +- .../compiler/lookup/CompilationUnitScope.java | 140 ++++++++++++--------- .../internal/compiler/lookup/ReferenceBinding.java | 2 +- .../jdt/internal/compiler/lookup/Scope.java | 72 ++++++----- .../compiler/lookup/SourceTypeBinding.java | 13 +- .../jdt/core/dom/DefaultBindingResolver.java | 2 +- .../jdt/internal/eval/CodeSnippetScope.java | 4 +- 15 files changed, 216 insertions(+), 153 deletions(-) diff --git a/org.eclipse.jdt.core/buildnotes_jdt-core.html b/org.eclipse.jdt.core/buildnotes_jdt-core.html index 394395f93d..1cd25e729b 100644 --- a/org.eclipse.jdt.core/buildnotes_jdt-core.html +++ b/org.eclipse.jdt.core/buildnotes_jdt-core.html @@ -35,6 +35,26 @@ + +

+Eclipse Platform Build Notes 
+Java Development Tooling Core

+Eclipse SDK 3.0.3 Build - 3rd April 2005 - 3.0.3 RELEASE (R3_0_3) +
Project org.eclipse.jdt.core v_454_R30x +(cvs). +

+What's new in this drop

+ + +

Problem Reports Fixed

+36397 +Compiling source which indirectly references unavailable classes + +

Eclipse Platform Build Notes 
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java index b7170475ad..a4d0898798 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java @@ -150,6 +150,8 @@ public class ArrayInitializer extends Expression { return null; // Compile-time conversion required? + if (expectedElementsTb != expressionTb) // must call before computeConversion() and typeMismatchError() + scope.compilationUnitScope().recordTypeConversion(expectedElementsTb, expressionTb); if (expression.isConstantValueOfTypeAssignableToType(expressionTb, expectedElementsTb)) { expression.implicitWidening(expectedElementsTb, expressionTb); } else if (BaseTypeBinding.isWidening(expectedElementsTb.id, expressionTb.id)) { diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java index 5b86adec80..c39cb0801c 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java @@ -122,7 +122,7 @@ public class Assignment extends Expression { scope.problemReporter().expressionShouldBeAVariable(this.lhs); return null; } - this.resolvedType = lhs.resolveType(scope); // expressionType contains the assignment type (lhs Type) + TypeBinding lhsType = this.resolvedType = lhs.resolveType(scope); // expressionType contains the assignment type (lhs Type) TypeBinding rhsType = expression.resolveType(scope); if (this.resolvedType == null || rhsType == null) { return null; @@ -130,18 +130,20 @@ public class Assignment extends Expression { checkAssignmentEffect(scope); // Compile-time conversion of base-types : implicit narrowing integer into byte/short/character - // may require to widen the rhs expression at runtime - if ((expression.isConstantValueOfTypeAssignableToType(rhsType, this.resolvedType) - || (this.resolvedType.isBaseType() && BaseTypeBinding.isWidening(this.resolvedType.id, rhsType.id))) - || rhsType.isCompatibleWith(this.resolvedType)) { - expression.implicitWidening(this.resolvedType, rhsType); + // may require to widen the rhs expression at runtime + if (lhsType != rhsType) // must call before computeConversion() and typeMismatchError() + scope.compilationUnitScope().recordTypeConversion(lhsType, rhsType); + if ((expression.isConstantValueOfTypeAssignableToType(rhsType, lhsType) + || (lhsType.isBaseType() && BaseTypeBinding.isWidening(lhsType.id, rhsType.id))) + || rhsType.isCompatibleWith(lhsType)) { + expression.implicitWidening(lhsType, rhsType); return this.resolvedType; } scope.problemReporter().typeMismatchErrorActualTypeExpectedType( expression, rhsType, - this.resolvedType); - return this.resolvedType; + lhsType); + return lhsType; } /* (non-Javadoc) * @see org.eclipse.jdt.internal.compiler.ast.Expression#resolveTypeExpecting(org.eclipse.jdt.internal.compiler.lookup.BlockScope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding) 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 7f001c35a2..95c54a6a14 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 @@ -190,27 +190,29 @@ public class FieldDeclaration extends AbstractVariableDeclaration { // break dead-lock cycles by forcing constant to NotAConstant this.binding.constant = Constant.NotAConstant; - TypeBinding typeBinding = this.binding.type; - TypeBinding initializationTypeBinding; + TypeBinding fieldType = this.binding.type; + TypeBinding initializationType; if (this.initialization instanceof ArrayInitializer) { - if ((initializationTypeBinding = this.initialization.resolveTypeExpecting(initializationScope, typeBinding)) != null) { - ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationTypeBinding; - this.initialization.implicitWidening(typeBinding, initializationTypeBinding); + if ((initializationType = this.initialization.resolveTypeExpecting(initializationScope, fieldType)) != null) { + ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType; + this.initialization.implicitWidening(fieldType, initializationType); } - } else if ((initializationTypeBinding = this.initialization.resolveType(initializationScope)) != null) { + } else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) { - if (this.initialization.isConstantValueOfTypeAssignableToType(initializationTypeBinding, typeBinding) - || (typeBinding.isBaseType() && BaseTypeBinding.isWidening(typeBinding.id, initializationTypeBinding.id))) { + if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError() + initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType); + if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType) + || (fieldType.isBaseType() && BaseTypeBinding.isWidening(fieldType.id, initializationType.id))) { - this.initialization.implicitWidening(typeBinding, initializationTypeBinding); + this.initialization.implicitWidening(fieldType, initializationType); - } else if (initializationTypeBinding.isCompatibleWith(typeBinding)) { - this.initialization.implicitWidening(typeBinding, initializationTypeBinding); + } else if (initializationType.isCompatibleWith(fieldType)) { + this.initialization.implicitWidening(fieldType, initializationType); } else { - initializationScope.problemReporter().typeMismatchError(initializationTypeBinding, typeBinding, this); + initializationScope.problemReporter().typeMismatchError(initializationType, fieldType, this); } if (this.binding.isFinal()){ // cast from constant actual type to variable type this.binding.constant = 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 353fc00acb..1c1f3e2255 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 @@ -134,16 +134,16 @@ public class LocalDeclaration extends AbstractVariableDeclaration { public void resolve(BlockScope scope) { // create a binding and add it to the scope - TypeBinding typeBinding = type.resolveType(scope); + TypeBinding variableType = type.resolveType(scope); checkModifiers(); - if (typeBinding != null) { - if (typeBinding == VoidBinding) { + if (variableType != null) { + if (variableType == VoidBinding) { scope.problemReporter().variableTypeCannotBeVoid(this); return; } - if (typeBinding.isArrayType() && ((ArrayBinding) typeBinding).leafComponentType == VoidBinding) { + if (variableType.isArrayType() && ((ArrayBinding) variableType).leafComponentType == VoidBinding) { scope.problemReporter().variableTypeCannotBeVoidArray(this); return; } @@ -164,14 +164,14 @@ public class LocalDeclaration extends AbstractVariableDeclaration { if ((modifiers & AccFinal)!= 0 && this.initialization == null) { modifiers |= AccBlankFinal; } - binding = new LocalVariableBinding(this, typeBinding, modifiers, false); + binding = new LocalVariableBinding(this, variableType, modifiers, false); scope.addLocalVariable(binding); binding.constant = NotAConstant; // allow to recursivelly target the binding.... // the correct constant is harmed if correctly computed at the end of this method } - if (typeBinding == null) { + if (variableType == null) { if (initialization != null) initialization.resolveType(scope); // want to report all possible errors return; @@ -180,20 +180,22 @@ public class LocalDeclaration extends AbstractVariableDeclaration { // store the constant for final locals if (initialization != null) { if (initialization instanceof ArrayInitializer) { - TypeBinding initializationType = initialization.resolveTypeExpecting(scope, typeBinding); + TypeBinding initializationType = initialization.resolveTypeExpecting(scope, variableType); if (initializationType != null) { ((ArrayInitializer) initialization).binding = (ArrayBinding) initializationType; - initialization.implicitWidening(typeBinding, initializationType); + initialization.implicitWidening(variableType, initializationType); } } else { TypeBinding initializationType = initialization.resolveType(scope); if (initializationType != null) { - if (initialization.isConstantValueOfTypeAssignableToType(initializationType, typeBinding) - || (typeBinding.isBaseType() && BaseTypeBinding.isWidening(typeBinding.id, initializationType.id)) - || initializationType.isCompatibleWith(typeBinding)) - initialization.implicitWidening(typeBinding, initializationType); + if (variableType != initializationType) // must call before computeConversion() and typeMismatchError() + scope.compilationUnitScope().recordTypeConversion(variableType, initializationType); + if (initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType) + || (variableType.isBaseType() && BaseTypeBinding.isWidening(variableType.id, initializationType.id)) + || initializationType.isCompatibleWith(variableType)) + initialization.implicitWidening(variableType, initializationType); else - scope.problemReporter().typeMismatchError(initializationType, typeBinding, this); + scope.problemReporter().typeMismatchError(initializationType, variableType, this); } } @@ -203,7 +205,7 @@ public class LocalDeclaration extends AbstractVariableDeclaration { if (binding != null) { binding.constant = binding.isFinal() - ? initialization.constant.castTo((typeBinding.id << 4) + initialization.constant.typeID()) + ? initialization.constant.castTo((variableType.id << 4) + initialization.constant.typeID()) : NotAConstant; } } diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java index af7dd02d3a..4f80f5641f 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java @@ -276,6 +276,8 @@ public class QualifiedAllocationExpression extends AllocationExpression { // The enclosing instance must be compatible with the innermost enclosing type ReferenceBinding expectedType = this.binding.declaringClass.enclosingType(); + if (expectedType != enclosingInstanceType) // must call before computeConversion() and typeMismatchError() + scope.compilationUnitScope().recordTypeConversion(expectedType, enclosingInstanceType); if (enclosingInstanceType.isCompatibleWith(expectedType)) { return receiverType; } diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java index ca74dae364..1dc21ebd40 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java @@ -210,23 +210,24 @@ public class ReturnStatement extends Statement { } if ((expressionType = expression.resolveType(scope)) == null) return; - - if (methodType != null && expression.isConstantValueOfTypeAssignableToType(expressionType, methodType)) { + if (expressionType == VoidBinding) { + scope.problemReporter().attemptToReturnVoidValue(this); + return; + } + if (methodType == null) + return; + if (methodType != expressionType) // must call before computeConversion() and typeMismatchError() + scope.compilationUnitScope().recordTypeConversion(methodType, expressionType); + if (expression.isConstantValueOfTypeAssignableToType(expressionType, methodType)) { // dealing with constant expression.implicitWidening(methodType, expressionType); return; } - if (expressionType == VoidBinding) { - scope.problemReporter().attemptToReturnVoidValue(this); - return; - } - if (methodType != null && expressionType.isCompatibleWith(methodType)) { + if (expressionType.isCompatibleWith(methodType)) { expression.implicitWidening(methodType, expressionType); return; } - if (methodType != null){ - scope.problemReporter().typeMismatchErrorActualTypeExpectedType(expression, expressionType, methodType); - } + scope.problemReporter().typeMismatchErrorActualTypeExpectedType(expression, expressionType, methodType); } public void traverse(ASTVisitor visitor, BlockScope scope) { if (visitor.visit(this, scope)) { 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 6ada2f8d4c..3cffe58d72 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 @@ -317,7 +317,7 @@ public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) { // NOTE: the return type, arg & exception types of each method of a binary 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) { +public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) { int argCount = argumentTypes.length; int selectorLength = selector.length; boolean foundNothing = true; @@ -338,10 +338,15 @@ public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes if (foundNothing) { if (isInterface()) { - if (superInterfaces.length == 1) - return superInterfaces[0].getExactMethod(selector, argumentTypes); + if (superInterfaces.length == 1) { + if (refScope != null) + refScope.recordTypeReference(superInterfaces[0]); + return superInterfaces[0].getExactMethod(selector, argumentTypes, refScope); + } } else if (superclass != null) { - return superclass.getExactMethod(selector, argumentTypes); + if (refScope != null) + refScope.recordTypeReference(superclass); + return superclass.getExactMethod(selector, argumentTypes, refScope); } } return null; diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java index 12057f396e..166e3f76de 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java @@ -760,7 +760,7 @@ public class ClassScope extends Scope { sourceType.tagBits |= HierarchyHasProblems; return true; } - + compilationUnitScope().recordSuperTypeReference(superType); // to record supertypes if (superType.isBinaryBinding()) { // force its superclass & superinterfaces to be found... 2 possibilities exist - the source type is included in the hierarchy of: // - a binary type... this case MUST be caught & reported here @@ -853,7 +853,7 @@ public class ClassScope extends Scope { if (typeOrPackage instanceof PackageBinding) // error, the compoundName is a packageName return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, n), NotFound); superType = (ReferenceBinding) typeOrPackage; - compilationUnitScope().recordTypeReference(superType); // to record supertypes +// compilationUnitScope().recordTypeReference(superType); // to record supertypes if (checkVisibility && n == size) { // if we're finished and know the final supertype then check visibility diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java index d4a8d4f480..d2c6c247e5 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java @@ -36,7 +36,8 @@ public class CompilationUnitScope extends Scope { private CompoundNameVector qualifiedReferences; private SimpleNameVector simpleNameReferences; private ObjectVector referencedTypes; - + private ObjectVector referencedSuperTypes; + HashtableOfType constantPoolNameUsage; public CompilationUnitScope(CompilationUnitDeclaration unit, LookupEnvironment environment) { @@ -50,11 +51,13 @@ public CompilationUnitScope(CompilationUnitDeclaration unit, LookupEnvironment e this.qualifiedReferences = new CompoundNameVector(); this.simpleNameReferences = new SimpleNameVector(); this.referencedTypes = new ObjectVector(); + this.referencedSuperTypes = new ObjectVector(); } else { this.qualifiedReferences = null; // used to test if dependencies should be recorded this.simpleNameReferences = null; this.referencedTypes = null; - } + this.referencedSuperTypes = null; + } } void buildFieldsAndMethods() { for (int i = 0, length = topLevelTypes.length; i < length; i++) @@ -511,36 +514,34 @@ void recordSimpleReference(char[] simpleName) { if (!simpleNameReferences.contains(simpleName)) simpleNameReferences.add(simpleName); } -void recordTypeReference(TypeBinding type) { - if (referencedTypes == null) return; // not recording dependencies - - if (type.isArrayType()) - type = ((ArrayBinding) type).leafComponentType; +void recordSuperTypeReference(TypeBinding type) { + if (referencedSuperTypes == null) return; // not recording dependencies - if (type.isBaseType()) return; - if (referencedTypes.containsIdentical(type)) return; - if (((ReferenceBinding) type).isLocalType()) return; + ReferenceBinding actualType = typeToRecord(type); + if (actualType != null && !referencedSuperTypes.containsIdentical(actualType)) + referencedSuperTypes.add(actualType); +} +public void recordTypeConversion(TypeBinding superType, TypeBinding subType) { + recordSuperTypeReference(subType); // must record the hierarchy of the subType that is converted to the superType +} +void recordTypeReference(TypeBinding type) { + if (referencedTypes == null) return; // not recording dependencies - referencedTypes.add(type); + ReferenceBinding actualType = typeToRecord(type); + if (actualType != null && !referencedTypes.containsIdentical(actualType)) + referencedTypes.add(actualType); } void recordTypeReferences(TypeBinding[] types) { - if (qualifiedReferences == null) return; // not recording dependencies - if (types == null || types.length == 0) return; - - for (int i = 0, max = types.length; i < max; i++) { - // No need to record supertypes of method arguments & thrown exceptions, just the compoundName - // If a field/method is retrieved from such a type then a separate call does the job - TypeBinding type = types[i]; - if (type.isArrayType()) - type = ((ArrayBinding) type).leafComponentType; - if (!type.isBaseType()) { - ReferenceBinding actualType = (ReferenceBinding) type; - if (!actualType.isLocalType()) - recordQualifiedReference(actualType.isMemberType() - ? CharOperation.splitOn('.', actualType.readableName()) - : actualType.compoundName); - } - } + if (referencedTypes == null) return; // not recording dependencies + if (types == null || types.length == 0) return; + + for (int i = 0, max = types.length; i < max; i++) { + // No need to record supertypes of method arguments & thrown exceptions, just the compoundName + // If a field/method is retrieved from such a type then a separate call does the job + ReferenceBinding actualType = typeToRecord(types[i]); + if (actualType != null && !referencedTypes.containsIdentical(actualType)) + referencedTypes.add(actualType); + } } Binding resolveSingleTypeImport(ImportBinding importBinding) { if (importBinding.resolvedImport == null) { @@ -560,43 +561,60 @@ Binding resolveSingleTypeImport(ImportBinding importBinding) { return importBinding.resolvedImport; } public void storeDependencyInfo() { - // add the type hierarchy of each referenced type - // cannot do early since the hierarchy may not be fully resolved - for (int i = 0; i < referencedTypes.size; i++) { // grows as more types are added - ReferenceBinding type = (ReferenceBinding) referencedTypes.elementAt(i); - if (!type.isLocalType()) { - recordQualifiedReference(type.isMemberType() - ? CharOperation.splitOn('.', type.readableName()) - : type.compoundName); - ReferenceBinding enclosing = type.enclosingType(); - if (enclosing != null && !referencedTypes.containsIdentical(enclosing)) - referencedTypes.add(enclosing); // to record its supertypes - } - ReferenceBinding superclass = type.superclass(); - if (superclass != null && !referencedTypes.containsIdentical(superclass)) - referencedTypes.add(superclass); // to record its supertypes - ReferenceBinding[] interfaces = type.superInterfaces(); - if (interfaces != null && interfaces.length > 0) - for (int j = 0, length = interfaces.length; j < length; j++) - if (!referencedTypes.containsIdentical(interfaces[j])) - referencedTypes.add(interfaces[j]); // to record its supertypes - } - - int size = qualifiedReferences.size; - char[][][] qualifiedRefs = new char[size][][]; - for (int i = 0; i < size; i++) - qualifiedRefs[i] = qualifiedReferences.elementAt(i); - referenceContext.compilationResult.qualifiedReferences = qualifiedRefs; - - size = simpleNameReferences.size; - char[][] simpleRefs = new char[size][]; - for (int i = 0; i < size; i++) - simpleRefs[i] = simpleNameReferences.elementAt(i); - referenceContext.compilationResult.simpleNameReferences = simpleRefs; + // add the type hierarchy of each referenced supertype + // cannot do early since the hierarchy may not be fully resolved + for (int i = 0; i < referencedSuperTypes.size; i++) { // grows as more types are added + ReferenceBinding type = (ReferenceBinding) referencedSuperTypes.elementAt(i); + if (!referencedTypes.containsIdentical(type)) + referencedTypes.add(type); + + if (!type.isLocalType()) { + ReferenceBinding enclosing = type.enclosingType(); + if (enclosing != null) + recordSuperTypeReference(enclosing); + } + ReferenceBinding superclass = type.superclass(); + if (superclass != null) + recordSuperTypeReference(superclass); + ReferenceBinding[] interfaces = type.superInterfaces(); + if (interfaces != null) + for (int j = 0, length = interfaces.length; j < length; j++) + recordSuperTypeReference(interfaces[j]); + } + + for (int i = 0, l = referencedTypes.size; i < l; i++) { + ReferenceBinding type = (ReferenceBinding) referencedTypes.elementAt(i); + if (!type.isLocalType()) + recordQualifiedReference(type.isMemberType() + ? CharOperation.splitOn('.', type.readableName()) + : type.compoundName); + } + + int size = qualifiedReferences.size; + char[][][] qualifiedRefs = new char[size][][]; + for (int i = 0; i < size; i++) + qualifiedRefs[i] = qualifiedReferences.elementAt(i); + referenceContext.compilationResult.qualifiedReferences = qualifiedRefs; + + size = simpleNameReferences.size; + char[][] simpleRefs = new char[size][]; + for (int i = 0; i < size; i++) + simpleRefs[i] = simpleNameReferences.elementAt(i); + referenceContext.compilationResult.simpleNameReferences = simpleRefs; } public String toString() { return "--- CompilationUnit Scope : " + new String(referenceContext.getFileName()); //$NON-NLS-1$ } +private ReferenceBinding typeToRecord(TypeBinding type) { + if (type.isArrayType()) + type = ((ArrayBinding) type).leafComponentType; + + if (type instanceof ReferenceBinding) { + ReferenceBinding refType = (ReferenceBinding) type; + if (!refType.isLocalType()) return refType; + } + return null; +} public void verifyMethods(MethodVerifier verifier) { for (int i = 0, length = topLevelTypes.length; i < length; i++) topLevelTypes[i].verifyMethods(verifier); 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 6cda282e33..6cbeacc197 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 @@ -316,7 +316,7 @@ public final int getAccessFlags() { public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) { return null; } -public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes) { +public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) { return null; } public FieldBinding getField(char[] fieldName, boolean needResolve) { 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 bfbb0b55c8..89a7f10cfa 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 @@ -137,27 +137,27 @@ public abstract class Scope return ((CompilationUnitScope) unitScope).environment; } - protected void faultInReceiverType(TypeBinding type) { - if (type.isArrayType()) - type = ((ArrayBinding) type).leafComponentType; - - // check on Begin bit, so as to be resilient with potential illformed binaries containing cycles (67769) - if (type instanceof BinaryTypeBinding && (type.tagBits & BeginHierarchyCheck) == 0) { - type.tagBits |= BeginHierarchyCheck; - // fault in the hierarchy of the type now so we can detect missing types instead of in storeDependencyInfo - BinaryTypeBinding binaryType = (BinaryTypeBinding) type; - ReferenceBinding enclosingType = binaryType.enclosingType(); - if (enclosingType != null) - faultInReceiverType(enclosingType); - ReferenceBinding superclass = binaryType.superclass(); - if (superclass != null) - faultInReceiverType(superclass); - ReferenceBinding[] interfaces = binaryType.superInterfaces(); - for (int i = 0, l = interfaces.length; i < l; i++) - faultInReceiverType(interfaces[i]); - type.tagBits |= EndHierarchyCheck; - } - } +// protected void faultInReceiverType(TypeBinding type) { +// if (type.isArrayType()) +// type = ((ArrayBinding) type).leafComponentType; +// +// // check on Begin bit, so as to be resilient with potential illformed binaries containing cycles (67769) +// if (type instanceof BinaryTypeBinding && (type.tagBits & BeginHierarchyCheck) == 0) { +// type.tagBits |= BeginHierarchyCheck; +// // fault in the hierarchy of the type now so we can detect missing types instead of in storeDependencyInfo +// BinaryTypeBinding binaryType = (BinaryTypeBinding) type; +// ReferenceBinding enclosingType = binaryType.enclosingType(); +// if (enclosingType != null) +// faultInReceiverType(enclosingType); +// ReferenceBinding superclass = binaryType.superclass(); +// if (superclass != null) +// faultInReceiverType(superclass); +// ReferenceBinding[] interfaces = binaryType.superInterfaces(); +// for (int i = 0, l = interfaces.length; i < l; i++) +// faultInReceiverType(interfaces[i]); +// type.tagBits |= EndHierarchyCheck; +// } +// } // abstract method lookup lookup (since maybe missing default abstract methods) public MethodBinding findDefaultAbstractMethod( @@ -239,12 +239,11 @@ public abstract class Scope TypeBinding[] argumentTypes, InvocationSite invocationSite) { - faultInReceiverType(receiverType); - compilationUnitScope().recordTypeReference(receiverType); - compilationUnitScope().recordTypeReferences(argumentTypes); - MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes); + CompilationUnitScope unitScope = compilationUnitScope(); + unitScope.recordTypeReferences(argumentTypes); + MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes, unitScope); if (exactMethod != null) { - compilationUnitScope().recordTypeReferences(exactMethod.thrownExceptions); + unitScope.recordTypeReferences(exactMethod.thrownExceptions); if (receiverType.isInterface() || exactMethod.canBeSeenBy(receiverType, invocationSite, this)) return exactMethod; } @@ -274,8 +273,8 @@ public abstract class Scope return null; } - faultInReceiverType(receiverType); - compilationUnitScope().recordTypeReference(receiverType); + CompilationUnitScope unitScope = compilationUnitScope(); + unitScope.recordTypeReference(receiverType); ReferenceBinding currentType = (ReferenceBinding) receiverType; if (!currentType.canBeSeenBy(this)) @@ -311,6 +310,7 @@ public abstract class Scope if ((currentType = currentType.superclass()) == null) break; + unitScope.recordTypeReference(currentType); if ((field = currentType.getField(fieldName, needResolve)) != null) { keepLooking = false; if (field.canBeSeenBy(receiverType, invocationSite, this)) { @@ -334,6 +334,7 @@ public abstract class Scope if ((anInterface.tagBits & InterfaceVisited) == 0) { // if interface as not already been visited anInterface.tagBits |= InterfaceVisited; + unitScope.recordTypeReference(anInterface); if ((field = anInterface.getField(fieldName, true /*resolve*/)) != null) { if (visibleField == null) { visibleField = field; @@ -497,7 +498,6 @@ public abstract class Scope MethodBinding matchingMethod = null; ObjectVector found = new ObjectVector(); //TODO should rewrite to remove #matchingMethod since found is allocated anyway - faultInReceiverType(receiverType); compilationUnitScope().recordTypeReference(receiverType); compilationUnitScope().recordTypeReferences(argumentTypes); @@ -516,7 +516,9 @@ public abstract class Scope boolean isCompliant14 = compilationUnitScope().environment.options.complianceLevel >= ClassFileConstants.JDK1_4; // superclass lookup ReferenceBinding classHierarchyStart = currentType; + CompilationUnitScope unitScope = compilationUnitScope(); while (currentType != null) { + unitScope.recordTypeReference(currentType); MethodBinding[] currentMethods = currentType.getMethods(selector); int currentLength = currentMethods.length; @@ -677,7 +679,7 @@ public abstract class Scope } ReferenceBinding object = getJavaLangObject(); - MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes); + MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes, null); if (methodBinding != null) { // handle the method clone() specially... cannot be protected or throw exceptions if (argumentTypes == NoParameters && CharOperation.equals(selector, CLONE)) @@ -737,7 +739,8 @@ public abstract class Scope if ((currentType.tagBits & InterfaceVisited) == 0) { // if interface as not already been visited currentType.tagBits |= InterfaceVisited; - + + compilationUnitScope().recordTypeReference(currentType); MethodBinding[] currentMethods = currentType.getMethods(selector); int currentLength = currentMethods.length; if (currentLength == 1 && matchingMethod == null && found.size == 0) { @@ -1041,7 +1044,6 @@ public abstract class Scope public MethodBinding getConstructor(ReferenceBinding receiverType, TypeBinding[] argumentTypes, InvocationSite invocationSite) { try { - faultInReceiverType(receiverType); compilationUnitScope().recordTypeReference(receiverType); compilationUnitScope().recordTypeReferences(argumentTypes); MethodBinding methodBinding = receiverType.getExactConstructor(argumentTypes); @@ -1418,10 +1420,12 @@ public abstract class Scope public MethodBinding getMethod(TypeBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite) { try { + if (receiverType.isBaseType()) + return new ProblemMethodBinding(selector, argumentTypes, NotFound); + + compilationUnitScope().recordTypeReference(receiverType); if (receiverType.isArrayType()) return findMethodForArray((ArrayBinding) receiverType, selector, argumentTypes, invocationSite); - if (receiverType.isBaseType()) - return new ProblemMethodBinding(selector, argumentTypes, NotFound); ReferenceBinding currentType = (ReferenceBinding) receiverType; if (!currentType.canBeSeenBy(this)) 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 e791f1e03e..c89be68748 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 @@ -439,7 +439,7 @@ public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) { // 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) { +public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) { int argCount = argumentTypes.length; int selectorLength = selector.length; boolean foundNothing = true; @@ -475,10 +475,15 @@ public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes if (foundNothing) { if (isInterface()) { - if (superInterfaces.length == 1) - return superInterfaces[0].getExactMethod(selector, argumentTypes); + if (superInterfaces.length == 1) { + if (refScope != null) + refScope.recordTypeReference(superInterfaces[0]); + return superInterfaces[0].getExactMethod(selector, argumentTypes, refScope); + } } else if (superclass != null) { - return superclass.getExactMethod(selector, argumentTypes); + if (refScope != null) + refScope.recordTypeReference(superclass); + return superclass.getExactMethod(selector, argumentTypes, refScope); } } return null; diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java index d1fe48e296..5a112a53b5 100644 --- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java +++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java @@ -941,7 +941,7 @@ class DefaultBindingResolver extends BindingResolver { case ProblemReasons.NonStaticReferenceInConstructorInvocation : ReferenceBinding declaringClass = methodBinding.declaringClass; if (declaringClass != null) { - org.eclipse.jdt.internal.compiler.lookup.MethodBinding exactBinding = declaringClass.getExactMethod(methodBinding.selector, methodBinding.parameters); + org.eclipse.jdt.internal.compiler.lookup.MethodBinding exactBinding = declaringClass.getExactMethod(methodBinding.selector, methodBinding.parameters, null); if (exactBinding != null) { IMethodBinding binding = (IMethodBinding) this.compilerBindingsToASTBindings.get(exactBinding); if (binding != null) { diff --git a/org.eclipse.jdt.core/eval/org/eclipse/jdt/internal/eval/CodeSnippetScope.java b/org.eclipse.jdt.core/eval/org/eclipse/jdt/internal/eval/CodeSnippetScope.java index 10c42cb805..b361131b69 100644 --- a/org.eclipse.jdt.core/eval/org/eclipse/jdt/internal/eval/CodeSnippetScope.java +++ b/org.eclipse.jdt.core/eval/org/eclipse/jdt/internal/eval/CodeSnippetScope.java @@ -243,7 +243,7 @@ public final boolean canBeSeenByForCodeSnippet(ReferenceBinding referenceBinding } // Internal use only public MethodBinding findExactMethod(ReferenceBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite) { - MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes); + MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes, null); if (exactMethod != null){ if (receiverType.isInterface() || canBeSeenByForCodeSnippet(exactMethod, receiverType, invocationSite, this)) return exactMethod; @@ -484,7 +484,7 @@ public MethodBinding findMethod( // Internal use only public MethodBinding findMethodForArray(ArrayBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite) { ReferenceBinding object = getJavaLangObject(); - MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes); + MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes, null); if (methodBinding != null) { // handle the method clone() specially... cannot be protected or throw exceptions if (argumentTypes == NoParameters && CharOperation.equals(selector, CLONE)) -- cgit v1.2.3