/*******************************************************************************
- * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Common Public License v0.5
+ * are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v05.html
+ * http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
- ******************************************************************************/
+ *******************************************************************************/
package net.sourceforge.phpdt.internal.compiler.lookup;
+import net.sourceforge.phpdt.core.compiler.CharOperation;
import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
-import net.sourceforge.phpdt.internal.compiler.ast.Argument;
-import net.sourceforge.phpdt.internal.compiler.ast.AstNode;
import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
-import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
-import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
-import net.sourceforge.phpdt.internal.compiler.impl.Constant;
import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
-import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
public class BlockScope extends Scope {
// Local variable management
public LocalVariableBinding[] locals;
+
public int localIndex; // position for next variable
- public int startIndex; // start position in this scope - for ordering scopes vs. variables
+
+ public int startIndex; // start position in this scope - for ordering
+ // scopes vs. variables
+
public int offset; // for variable allocation throughout scopes
+
public int maxOffset; // for variable allocation throughout scopes
- // finally scopes must be shifted behind respective try scope
- public BlockScope[] shiftScopes;
+ // finally scopes must be shifted behind respective try&catch scope(s) so as
+ // to avoid
+ // collisions of secret variables (return address, save value).
+ public BlockScope[] shiftScopes;
public final static VariableBinding[] EmulationPathToImplicitThis = {};
+ public final static VariableBinding[] NoEnclosingInstanceInConstructorCall = {};
+
+ public final static VariableBinding[] NoEnclosingInstanceInStaticContext = {};
+
public Scope[] subscopes = new Scope[1]; // need access from code assist
+
public int scopeIndex = 0; // need access from code assist
protected BlockScope(int kind, Scope parent) {
this(BLOCK_SCOPE, parent);
locals = new LocalVariableBinding[5];
- if (addToParentScope) parent.addSubscope(this);
+ if (addToParentScope)
+ parent.addSubscope(this);
this.startIndex = parent.localIndex;
}
this.startIndex = parent.localIndex;
}
- /* Create the class scope & binding for the anonymous type.
+ /*
+ * Create the class scope & binding for the anonymous type.
*/
- public final void addAnonymousType(
- TypeDeclaration anonymousType,
- ReferenceBinding superBinding) {
+ public final void addAnonymousType(TypeDeclaration anonymousType,
+ ReferenceBinding superBinding) {
ClassScope anonymousClassScope = new ClassScope(this, anonymousType);
- anonymousClassScope.buildAnonymousTypeBinding(
- enclosingSourceType(),
- superBinding);
+ anonymousClassScope.buildAnonymousTypeBinding(enclosingSourceType(),
+ superBinding);
}
- /* Create the class scope & binding for the local type.
+ /*
+ * Create the class scope & binding for the local type.
*/
public final void addLocalType(TypeDeclaration localType) {
type = type.enclosingType();
} while (type != null);
- // check that the localType does not conflict with another sibling local type
+ // check that the localType does not conflict with another sibling local
+ // type
Scope scope = this;
do {
if (((BlockScope) scope).findLocalType(localType.name) != null) {
} while ((scope = scope.parent) instanceof BlockScope);
ClassScope localTypeScope = new ClassScope(this, localType);
- localTypeScope.buildLocalTypeBinding(enclosingSourceType());
addSubscope(localTypeScope);
+ localTypeScope.buildLocalTypeBinding(enclosingSourceType());
}
- /* Insert a local variable into a given scope, updating its position
- * and checking there are not too many locals or arguments allocated.
+ /*
+ * Insert a local variable into a given scope, updating its position and
+ * checking there are not too many locals or arguments allocated.
*/
public final void addLocalVariable(LocalVariableBinding binding) {
// insert local in scope
if (localIndex == locals.length)
- System.arraycopy(
- locals,
- 0,
- (locals = new LocalVariableBinding[localIndex * 2]),
- 0,
- localIndex);
+ System.arraycopy(locals, 0,
+ (locals = new LocalVariableBinding[localIndex * 2]), 0,
+ localIndex);
locals[localIndex++] = binding;
- // update local variable binding
+ // update local variable binding
binding.declaringScope = this;
binding.id = this.outerMostMethodScope().analysisIndex++;
// share the outermost method scope analysisIndex
public void addSubscope(Scope childScope) {
if (scopeIndex == subscopes.length)
- System.arraycopy(
- subscopes,
- 0,
- (subscopes = new Scope[scopeIndex * 2]),
- 0,
- scopeIndex);
+ System.arraycopy(subscopes, 0,
+ (subscopes = new Scope[scopeIndex * 2]), 0, scopeIndex);
subscopes[scopeIndex++] = childScope;
}
- /* Answer true if the receiver is suitable for assigning final blank fields.
- *
- * i.e. is inside an initializer, a constructor or a clinit
+ /*
+ * Answer true if the receiver is suitable for assigning final blank fields.
+ *
+ * in other words, it is inside an initializer, a constructor or a clinit
*/
public final boolean allowBlankFinalFieldAssignment(FieldBinding binding) {
if (methodScope.isStatic != binding.isStatic())
return false;
return methodScope.isInsideInitializer() // inside initializer
- || ((AbstractMethodDeclaration) methodScope.referenceContext)
- .isInitializationMethod();
- // inside constructor or clinit
+ || ((AbstractMethodDeclaration) methodScope.referenceContext)
+ .isInitializationMethod(); // inside constructor or
+ // clinit
}
+
String basicToString(int tab) {
String newLine = "\n"; //$NON-NLS-1$
for (int i = tab; --i >= 0;)
private void checkAndSetModifiersForVariable(LocalVariableBinding varBinding) {
int modifiers = varBinding.modifiers;
- if ((modifiers & AccAlternateModifierProblem) != 0 && varBinding.declaration != null){
- problemReporter().duplicateModifierForVariable(varBinding.declaration, this instanceof MethodScope);
+ if ((modifiers & AccAlternateModifierProblem) != 0
+ && varBinding.declaration != null) {
+ problemReporter().duplicateModifierForVariable(
+ varBinding.declaration, this instanceof MethodScope);
}
int realModifiers = modifiers & AccJustFlag;
-
+
int unexpectedModifiers = ~AccFinal;
- if ((realModifiers & unexpectedModifiers) != 0 && varBinding.declaration != null){
- problemReporter().illegalModifierForVariable(varBinding.declaration, this instanceof MethodScope);
+ if ((realModifiers & unexpectedModifiers) != 0
+ && varBinding.declaration != null) {
+ problemReporter().illegalModifierForVariable(
+ varBinding.declaration, this instanceof MethodScope);
}
varBinding.modifiers = modifiers;
}
- /* Compute variable positions in scopes given an initial position offset
+ /*
+ * Compute variable positions in scopes given an initial position offset
* ignoring unused local variables.
*
- * Special treatment to have Try secret return address variables located at non
- * colliding positions. Return addresses are not allocated initially, but gathered
- * and allocated behind all other variables.
+ * No argument is expected here (ilocal is the first non-argument local of
+ * the outermost scope) Arguments are managed by the MethodScope method
*/
- public void computeLocalVariablePositions(
- int initOffset,
- CodeStream codeStream) {
-
- this.offset = initOffset;
- this.maxOffset = initOffset;
-
- // local variable init
- int ilocal = 0, maxLocals = 0, localsLength = locals.length;
- while ((maxLocals < localsLength) && (locals[maxLocals] != null))
- maxLocals++;
- boolean hasMoreVariables = maxLocals > 0;
-
- // scope init
- int iscope = 0, maxScopes = 0, subscopesLength = subscopes.length;
- while ((maxScopes < subscopesLength) && (subscopes[maxScopes] != null))
- maxScopes++;
- boolean hasMoreScopes = maxScopes > 0;
-
- // iterate scopes and variables in parallel
- while (hasMoreVariables || hasMoreScopes) {
- if (hasMoreScopes
- && (!hasMoreVariables || (subscopes[iscope].startIndex() <= ilocal))) {
- // consider subscope first
- if (subscopes[iscope] instanceof BlockScope) {
- BlockScope subscope = (BlockScope) subscopes[iscope];
- int subOffset = subscope.shiftScopes == null ? this.offset : subscope.maxShiftedOffset();
- subscope.computeLocalVariablePositions(subOffset, codeStream);
- if (subscope.maxOffset > this.maxOffset)
- this.maxOffset = subscope.maxOffset;
- }
- hasMoreScopes = ++iscope < maxScopes;
- } else {
- // consider variable first
- LocalVariableBinding local = locals[ilocal];
-
- // check if variable is actually used, and may force it to be preserved
- boolean generatesLocal =
- (local.used && (local.constant == Constant.NotAConstant)) || local.isArgument;
- if (!local.used
- && (local.declaration != null) // unused (and non secret) local
- && ((local.declaration.bits & AstNode.IsLocalDeclarationReachableMASK) != 0)) { // declaration is reachable
- if (local.isArgument) // method argument
- this.problemReporter().unusedArgument(local.declaration);
- else if (!(local.declaration instanceof Argument)) // do not report unused catch arguments
- this.problemReporter().unusedLocalVariable(local.declaration);
- }
- if (!generatesLocal) {
- if (local.declaration != null
- && environment().options.preserveAllLocalVariables) {
- generatesLocal = true; // force it to be preserved in the generated code
- local.used = true;
- }
- }
- if (generatesLocal) {
-
- if (local.declaration != null) {
- codeStream.record(local);
- // record user local variables for attribute generation
- }
- // allocate variable position
- local.resolvedPosition = this.offset;
-
- // check for too many arguments/local variables
- if (local.isArgument) {
- if (this.offset > 0xFF) { // no more than 255 words of arguments
- this.problemReporter().noMoreAvailableSpaceForArgument(local, local.declaration);
- }
- } else {
- if (this.offset > 0xFFFF) { // no more than 65535 words of locals
- this.problemReporter().noMoreAvailableSpaceForLocal(
- local, local.declaration == null ? (AstNode)this.methodScope().referenceContext : local.declaration);
- }
- }
-
- // increment offset
- if ((local.type == LongBinding) || (local.type == DoubleBinding)) {
- this.offset += 2;
- } else {
- this.offset++;
- }
- } else {
- local.resolvedPosition = -1; // not generated
- }
- hasMoreVariables = ++ilocal < maxLocals;
- }
- }
- if (this.offset > this.maxOffset)
- this.maxOffset = this.offset;
- }
-
- /* Answer true if the variable name already exists within the receiver's scope.
+ // void computeLocalVariablePositions(int ilocal, int initOffset, CodeStream
+ // codeStream) {
+ //
+ // this.offset = initOffset;
+ // this.maxOffset = initOffset;
+ //
+ // // local variable init
+ // int maxLocals = this.localIndex;
+ // boolean hasMoreVariables = ilocal < maxLocals;
+ //
+ // // scope init
+ // int iscope = 0, maxScopes = this.scopeIndex;
+ // boolean hasMoreScopes = maxScopes > 0;
+ //
+ // // iterate scopes and variables in parallel
+ // while (hasMoreVariables || hasMoreScopes) {
+ // if (hasMoreScopes
+ // && (!hasMoreVariables || (subscopes[iscope].startIndex() <= ilocal))) {
+ // // consider subscope first
+ // if (subscopes[iscope] instanceof BlockScope) {
+ // BlockScope subscope = (BlockScope) subscopes[iscope];
+ // int subOffset = subscope.shiftScopes == null ? this.offset :
+ // subscope.maxShiftedOffset();
+ // subscope.computeLocalVariablePositions(0, subOffset, codeStream);
+ // if (subscope.maxOffset > this.maxOffset)
+ // this.maxOffset = subscope.maxOffset;
+ // }
+ // hasMoreScopes = ++iscope < maxScopes;
+ // } else {
+ //
+ // // consider variable first
+ // LocalVariableBinding local = locals[ilocal]; // if no local at all, will
+ // be locals[ilocal]==null
+ //
+ // // check if variable is actually used, and may force it to be preserved
+ // boolean generateCurrentLocalVar = (local.useFlag ==
+ // LocalVariableBinding.USED && (local.constant == Constant.NotAConstant));
+ //
+ // // do not report fake used variable
+ // if (local.useFlag == LocalVariableBinding.UNUSED
+ // && (local.declaration != null) // unused (and non secret) local
+ // && ((local.declaration.bits & ASTNode.IsLocalDeclarationReachableMASK) !=
+ // 0)) { // declaration is reachable
+ //
+ // if (!(local.declaration instanceof Argument)) // do not report unused
+ // catch arguments
+ // this.problemReporter().unusedLocalVariable(local.declaration);
+ // }
+ //
+ // // could be optimized out, but does need to preserve unread variables ?
+ // // if (!generateCurrentLocalVar) {
+ // // if (local.declaration != null &&
+ // environment().options.preserveAllLocalVariables) {
+ // // generateCurrentLocalVar = true; // force it to be preserved in the
+ // generated code
+ // // local.useFlag = LocalVariableBinding.USED;
+ // // }
+ // // }
+ //
+ // // allocate variable
+ // if (generateCurrentLocalVar) {
+ //
+ // if (local.declaration != null) {
+ // codeStream.record(local); // record user-defined local variables for
+ // attribute generation
+ // }
+ // // assign variable position
+ // local.resolvedPosition = this.offset;
+ //
+ // if ((local.type == LongBinding) || (local.type == DoubleBinding)) {
+ // this.offset += 2;
+ // } else {
+ // this.offset++;
+ // }
+ // if (this.offset > 0xFFFF) { // no more than 65535 words of locals
+ // this.problemReporter().noMoreAvailableSpaceForLocal(
+ // local,
+ // local.declaration == null ? (ASTNode)this.methodScope().referenceContext
+ // : local.declaration);
+ // }
+ // } else {
+ // local.resolvedPosition = -1; // not generated
+ // }
+ // hasMoreVariables = ++ilocal < maxLocals;
+ // }
+ // }
+ // if (this.offset > this.maxOffset)
+ // this.maxOffset = this.offset;
+ // }
+ /*
+ * Answer true if the variable name already exists within the receiver's
+ * scope.
*/
public final LocalVariableBinding duplicateName(char[] name) {
for (int i = 0; i < localIndex; i++)
}
/*
- * Record the suitable binding denoting a synthetic field or constructor argument,
- * mapping to the actual outer local variable in the scope context.
- * Note that this may not need any effect, in case the outer local variable does not
- * need to be emulated and can directly be used as is (using its back pointer to its
- * declaring scope).
+ * Record the suitable binding denoting a synthetic field or constructor
+ * argument, mapping to the actual outer local variable in the scope
+ * context. Note that this may not need any effect, in case the outer local
+ * variable does not need to be emulated and can directly be used as is
+ * (using its back pointer to its declaring scope).
*/
public void emulateOuterAccess(LocalVariableBinding outerLocalVariable) {
MethodScope currentMethodScope;
- if ((currentMethodScope = this.methodScope())
- != outerLocalVariable.declaringScope.methodScope()) {
- NestedTypeBinding currentType = (NestedTypeBinding) this.enclosingSourceType();
+ if ((currentMethodScope = this.methodScope()) != outerLocalVariable.declaringScope
+ .methodScope()) {
+ NestedTypeBinding currentType = (NestedTypeBinding) this
+ .enclosingSourceType();
- //do nothing for member types, pre emulation was performed already
+ // do nothing for member types, pre emulation was performed already
if (!currentType.isLocalType()) {
return;
}
}
/*
- * Record the suitable binding denoting a synthetic field or constructor argument,
- * mapping to a given actual enclosing instance type in the scope context.
- * Skip it if the enclosingType is actually the current scope's enclosing type.
- */
-
- public void emulateOuterAccess(
- ReferenceBinding targetEnclosingType,
- boolean useDirectReference) {
-
- ReferenceBinding currentType = enclosingSourceType();
- if (currentType.isNestedType()
- && currentType != targetEnclosingType){
- /*&& !targetEnclosingType.isSuperclassOf(currentType)*/
-
- if (useDirectReference) {
- // the target enclosing type is not in scope, we directly refer it
- // must also add a synthetic field if we're not inside a constructor
- NestedTypeBinding currentNestedType = (NestedTypeBinding) currentType;
- if (methodScope().isInsideInitializerOrConstructor())
- currentNestedType.addSyntheticArgument(targetEnclosingType);
- else
- currentNestedType.addSyntheticArgumentAndField(targetEnclosingType);
-
- } else { // indirect reference sequence
- int depth = 0;
-
- // saturate all the way up until reaching compatible enclosing type
- while (currentType.isLocalType()){
- NestedTypeBinding currentNestedType = (NestedTypeBinding) currentType;
- currentType = currentNestedType.enclosingType;
-
- if (depth == 0){
- if (methodScope().isInsideInitializerOrConstructor()) {
- // must also add a synthetic field if we're not inside a constructor
- currentNestedType.addSyntheticArgument(currentType);
- } else {
- currentNestedType.addSyntheticArgumentAndField(currentType);
- }
- } else if (currentNestedType == targetEnclosingType
- || targetEnclosingType.isSuperclassOf(currentNestedType)) {
- break;
- } else {
- currentNestedType.addSyntheticArgumentAndField(currentType);
- }
- depth++;
- }
- }
- }
- }
-
- /* Note that it must never produce a direct access to the targetEnclosingType,
- * but instead a field sequence (this$2.this$1.this$0) so as to handle such a test case:
- *
- * class XX {
- * void foo() {
- * class A {
- * class B {
- * class C {
- * boolean foo() {
- * return (Object) A.this == (Object) B.this;
- * }
- * }
- * }
- * }
- * new A().new B().new C();
- * }
- * }
- * where we only want to deal with ONE enclosing instance for C (could not figure out an A for C)
+ * Note that it must never produce a direct access to the
+ * targetEnclosingType, but instead a field sequence (this$2.this$1.this$0)
+ * so as to handle such a test case:
+ *
+ * class XX { void foo() { class A { class B { class C { boolean foo() {
+ * return (Object) A.this == (Object) B.this; } } } } new A().new B().new
+ * C(); } } where we only want to deal with ONE enclosing instance for C
+ * (could not figure out an A for C)
*/
public final ReferenceBinding findLocalType(char[] name) {
for (int i = 0, length = scopeIndex; i < length; i++) {
if (subscopes[i] instanceof ClassScope) {
- SourceTypeBinding sourceType =
- ((ClassScope) subscopes[i]).referenceContext.binding;
+ SourceTypeBinding sourceType = ((ClassScope) subscopes[i]).referenceContext.binding;
if (CharOperation.equals(sourceType.sourceName(), name))
return sourceType;
}
if (local == null)
return null;
if (local.name.length == variableLength
- && CharOperation.prefixEquals(local.name, variable))
+ && CharOperation.prefixEquals(local.name, variable))
return local;
}
return null;
}
- /* API
- * flag is a mask of the following values VARIABLE (= FIELD or LOCAL), TYPE.
- * Only bindings corresponding to the mask will be answered.
- *
- * if the VARIABLE mask is set then
- * If the first name provided is a field (or local) then the field (or local) is answered
- * Otherwise, package names and type names are consumed until a field is found.
- * In this case, the field is answered.
- *
- * if the TYPE mask is set,
- * package names and type names are consumed until the end of the input.
- * Only if all of the input is consumed is the type answered
- *
- * All other conditions are errors, and a problem binding is returned.
- *
- * NOTE: If a problem binding is returned, senders should extract the compound name
- * from the binding & not assume the problem applies to the entire compoundName.
- *
- * The VARIABLE mask has precedence over the TYPE mask.
- *
- * InvocationSite implements
- * isSuperAccess(); this is used to determine if the discovered field is visible.
- * setFieldIndex(int); this is used to record the number of names that were consumed.
- *
- * For example, getBinding({"foo","y","q", VARIABLE, site) will answer
- * the binding for the field or local named "foo" (or an error binding if none exists).
- * In addition, setFieldIndex(1) will be sent to the invocation site.
- * If a type named "foo" exists, it will not be detected (and an error binding will be answered)
- *
- * IMPORTANT NOTE: This method is written under the assumption that compoundName is longer than length 1.
+
+ /*
+ * API flag is a mask of the following values VARIABLE (= FIELD or LOCAL),
+ * TYPE. Only bindings corresponding to the mask will be answered.
+ *
+ * if the VARIABLE mask is set then If the first name provided is a field
+ * (or local) then the field (or local) is answered Otherwise, package names
+ * and type names are consumed until a field is found. In this case, the
+ * field is answered.
+ *
+ * if the TYPE mask is set, package names and type names are consumed until
+ * the end of the input. Only if all of the input is consumed is the type
+ * answered
+ *
+ * All other conditions are errors, and a problem binding is returned.
+ *
+ * NOTE: If a problem binding is returned, senders should extract the
+ * compound name from the binding & not assume the problem applies to the
+ * entire compoundName.
+ *
+ * The VARIABLE mask has precedence over the TYPE mask.
+ *
+ * InvocationSite implements isSuperAccess(); this is used to determine if
+ * the discovered field is visible. setFieldIndex(int); this is used to
+ * record the number of names that were consumed.
+ *
+ * For example, getBinding({"foo","y","q", VARIABLE, site) will answer the
+ * binding for the field or local named "foo" (or an error binding if none
+ * exists). In addition, setFieldIndex(1) will be sent to the invocation
+ * site. If a type named "foo" exists, it will not be detected (and an error
+ * binding will be answered)
+ *
+ * IMPORTANT NOTE: This method is written under the assumption that
+ * compoundName is longer than length 1.
*/
- public Binding getBinding(char[][] compoundName, int mask, InvocationSite invocationSite) {
+ public Binding getBinding(char[][] compoundName, int mask,
+ InvocationSite invocationSite) {
- Binding binding = getBinding(compoundName[0], mask | TYPE | PACKAGE, invocationSite);
+ Binding binding = getBinding(compoundName[0], mask | TYPE | PACKAGE,
+ invocationSite);
invocationSite.setFieldIndex(1);
- if (binding instanceof VariableBinding) return binding;
+ if (binding instanceof VariableBinding)
+ return binding;
compilationUnitScope().recordSimpleReference(compoundName[0]);
- if (!binding.isValidBinding()) return binding;
+ if (!binding.isValidBinding())
+ return binding;
int length = compoundName.length;
int currentIndex = 1;
- foundType : if (binding instanceof PackageBinding) {
+ foundType: if (binding instanceof PackageBinding) {
PackageBinding packageBinding = (PackageBinding) binding;
while (currentIndex < length) {
- compilationUnitScope().recordReference(packageBinding.compoundName, compoundName[currentIndex]);
- binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
+ compilationUnitScope()
+ .recordReference(packageBinding.compoundName,
+ compoundName[currentIndex]);
+ binding = packageBinding
+ .getTypeOrPackage(compoundName[currentIndex++]);
invocationSite.setFieldIndex(currentIndex);
if (binding == null) {
if (currentIndex == length)
- // must be a type if its the last name, otherwise we have no idea if its a package or type
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ // must be a type if its the last name, otherwise we
+ // have no idea if its a package or type
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ NotFound);
else
- return new ProblemBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ return new ProblemBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), NotFound);
}
if (binding instanceof ReferenceBinding) {
if (!binding.isValidBinding())
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ binding.problemId());
if (!((ReferenceBinding) binding).canBeSeenBy(this))
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding,
- NotVisible);
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ (ReferenceBinding) binding, NotVisible);
break foundType;
}
packageBinding = (PackageBinding) binding;
}
// It is illegal to request a PACKAGE from this method.
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ return new ProblemReferenceBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), NotFound);
}
// know binding is now a ReferenceBinding
char[] nextName = compoundName[currentIndex++];
invocationSite.setFieldIndex(currentIndex);
invocationSite.setActualReceiverType(typeBinding);
- if ((binding = findField(typeBinding, nextName, invocationSite)) != null) {
+ if ((mask & FIELD) != 0
+ && (binding = findField(typeBinding, nextName,
+ invocationSite)) != null) {
if (!binding.isValidBinding())
return new ProblemFieldBinding(
- ((FieldBinding) binding).declaringClass,
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ ((FieldBinding) binding).declaringClass,
+ CharOperation.subarray(compoundName, 0,
+ currentIndex), binding.problemId());
break; // binding is now a field
}
- if ((binding = findMemberType(nextName, typeBinding)) == null)
- return new ProblemBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- typeBinding,
- NotFound);
+ if ((binding = findMemberType(nextName, typeBinding)) == null) {
+ if ((mask & FIELD) != 0) {
+ return new ProblemBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), typeBinding,
+ NotFound);
+ } else {
+ return new ProblemReferenceBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), typeBinding,
+ NotFound);
+ }
+ }
if (!binding.isValidBinding())
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ return new ProblemReferenceBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), binding.problemId());
}
if ((mask & FIELD) != 0 && (binding instanceof FieldBinding)) {
// was looking for a field and found a field
FieldBinding field = (FieldBinding) binding;
if (!field.isStatic())
- return new ProblemFieldBinding(
- field.declaringClass,
- CharOperation.subarray(compoundName, 0, currentIndex),
- NonStaticReferenceInStaticContext);
+ return new ProblemFieldBinding(field.declaringClass,
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ NonStaticReferenceInStaticContext);
return binding;
}
if ((mask & TYPE) != 0 && (binding instanceof ReferenceBinding)) {
return binding;
}
- // handle the case when a field or type was asked for but we resolved the compoundName to a type or field
- return new ProblemBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ // handle the case when a field or type was asked for but we resolved
+ // the compoundName to a type or field
+ return new ProblemBinding(CharOperation.subarray(compoundName, 0,
+ currentIndex), NotFound);
}
// Added for code assist... NOT Public API
- public final Binding getBinding(
- char[][] compoundName,
- InvocationSite invocationSite) {
+ public final Binding getBinding(char[][] compoundName,
+ InvocationSite invocationSite) {
int currentIndex = 0;
int length = compoundName.length;
- Binding binding =
- getBinding(
- compoundName[currentIndex++],
- VARIABLE | TYPE | PACKAGE,
- invocationSite);
+ Binding binding = getBinding(compoundName[currentIndex++], VARIABLE
+ | TYPE | PACKAGE, invocationSite);
if (!binding.isValidBinding())
return binding;
- foundType : if (binding instanceof PackageBinding) {
+ foundType: if (binding instanceof PackageBinding) {
while (currentIndex < length) {
PackageBinding packageBinding = (PackageBinding) binding;
- binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
+ binding = packageBinding
+ .getTypeOrPackage(compoundName[currentIndex++]);
if (binding == null) {
if (currentIndex == length)
- // must be a type if its the last name, otherwise we have no idea if its a package or type
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ // must be a type if its the last name, otherwise we
+ // have no idea if its a package or type
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ NotFound);
else
- return new ProblemBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ return new ProblemBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), NotFound);
}
if (binding instanceof ReferenceBinding) {
if (!binding.isValidBinding())
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ binding.problemId());
if (!((ReferenceBinding) binding).canBeSeenBy(this))
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding,
- NotVisible);
+ return new ProblemReferenceBinding(CharOperation
+ .subarray(compoundName, 0, currentIndex),
+ (ReferenceBinding) binding, NotVisible);
break foundType;
}
}
return binding;
}
- foundField : if (binding instanceof ReferenceBinding) {
+ foundField: if (binding instanceof ReferenceBinding) {
while (currentIndex < length) {
ReferenceBinding typeBinding = (ReferenceBinding) binding;
char[] nextName = compoundName[currentIndex++];
if ((binding = findField(typeBinding, nextName, invocationSite)) != null) {
if (!binding.isValidBinding())
return new ProblemFieldBinding(
- ((FieldBinding) binding).declaringClass,
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ ((FieldBinding) binding).declaringClass,
+ CharOperation.subarray(compoundName, 0,
+ currentIndex), binding.problemId());
if (!((FieldBinding) binding).isStatic())
return new ProblemFieldBinding(
- ((FieldBinding) binding).declaringClass,
- CharOperation.subarray(compoundName, 0, currentIndex),
- NonStaticReferenceInStaticContext);
+ ((FieldBinding) binding).declaringClass,
+ CharOperation.subarray(compoundName, 0,
+ currentIndex),
+ NonStaticReferenceInStaticContext);
break foundField; // binding is now a field
}
if ((binding = findMemberType(nextName, typeBinding)) == null)
- return new ProblemBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- typeBinding,
- NotFound);
+ return new ProblemBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), typeBinding,
+ NotFound);
if (!binding.isValidBinding())
- return new ProblemReferenceBinding(
- CharOperation.subarray(compoundName, 0, currentIndex),
- binding.problemId());
+ return new ProblemReferenceBinding(CharOperation.subarray(
+ compoundName, 0, currentIndex), binding.problemId());
}
return binding;
}
while (currentIndex < length) {
TypeBinding typeBinding = variableBinding.type;
if (typeBinding == null)
- return new ProblemFieldBinding(
- null,
- CharOperation.subarray(compoundName, 0, currentIndex + 1),
- NotFound);
- variableBinding =
- findField(typeBinding, compoundName[currentIndex++], invocationSite);
+ return new ProblemFieldBinding(null, CharOperation.subarray(
+ compoundName, 0, currentIndex + 1), NotFound);
+ variableBinding = findField(typeBinding,
+ compoundName[currentIndex++], invocationSite);
if (variableBinding == null)
- return new ProblemFieldBinding(
- null,
- CharOperation.subarray(compoundName, 0, currentIndex),
- NotFound);
+ return new ProblemFieldBinding(null, CharOperation.subarray(
+ compoundName, 0, currentIndex), NotFound);
if (!variableBinding.isValidBinding())
return variableBinding;
}
return variableBinding;
}
- /* API
- *
- * Answer the binding that corresponds to the argument name.
- * flag is a mask of the following values VARIABLE (= FIELD or LOCAL), TYPE, PACKAGE.
- * Only bindings corresponding to the mask can be answered.
- *
- * For example, getBinding("foo", VARIABLE, site) will answer
- * the binding for the field or local named "foo" (or an error binding if none exists).
- * If a type named "foo" exists, it will not be detected (and an error binding will be answered)
- *
- * The VARIABLE mask has precedence over the TYPE mask.
- *
- * If the VARIABLE mask is not set, neither fields nor locals will be looked for.
- *
- * InvocationSite implements:
- * isSuperAccess(); this is used to determine if the discovered field is visible.
- *
- * Limitations: cannot request FIELD independently of LOCAL, or vice versa
+ /*
+ * API
+ *
+ * Answer the binding that corresponds to the argument name. flag is a mask
+ * of the following values VARIABLE (= FIELD or LOCAL), TYPE, PACKAGE. Only
+ * bindings corresponding to the mask can be answered.
+ *
+ * For example, getBinding("foo", VARIABLE, site) will answer the binding
+ * for the field or local named "foo" (or an error binding if none exists).
+ * If a type named "foo" exists, it will not be detected (and an error
+ * binding will be answered)
+ *
+ * The VARIABLE mask has precedence over the TYPE mask.
+ *
+ * If the VARIABLE mask is not set, neither fields nor locals will be looked
+ * for.
+ *
+ * InvocationSite implements: isSuperAccess(); this is used to determine if
+ * the discovered field is visible.
+ *
+ * Limitations: cannot request FIELD independently of LOCAL, or vice versa
*/
- public Binding getBinding(char[] name, int mask, InvocationSite invocationSite) {
-
+ public Binding getBinding(char[] name, int mask,
+ InvocationSite invocationSite) {
+
Binding binding = null;
FieldBinding problemField = null;
if ((mask & VARIABLE) != 0) {
if (this.kind == BLOCK_SCOPE || this.kind == METHOD_SCOPE) {
LocalVariableBinding variableBinding = findVariable(name);
// looks in this scope only
- if (variableBinding != null) return variableBinding;
+ if (variableBinding != null)
+ return variableBinding;
}
boolean insideStaticContext = false;
}
FieldBinding foundField = null;
- // can be a problem field which is answered if a valid field is not found
+ // can be a problem field which is answered if a valid field is not
+ // found
ProblemFieldBinding foundInsideProblem = null;
// inside Constructor call or inside static context
Scope scope = parent;
int depth = 0;
int foundDepth = 0;
ReferenceBinding foundActualReceiverType = null;
- done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
+ done: while (true) { // done when a COMPILATION_UNIT_SCOPE is
+ // found
switch (scope.kind) {
- case METHOD_SCOPE :
- MethodScope methodScope = (MethodScope) scope;
- insideStaticContext |= methodScope.isStatic;
- insideConstructorCall |= methodScope.isConstructorCall;
- // Fall through... could duplicate the code below to save a cast - questionable optimization
- case BLOCK_SCOPE :
- LocalVariableBinding variableBinding = ((BlockScope) scope).findVariable(name);
- // looks in this scope only
- if (variableBinding != null) {
- if (foundField != null && foundField.isValidBinding())
- return new ProblemFieldBinding(
- foundField.declaringClass,
- name,
+ case METHOD_SCOPE:
+ MethodScope methodScope = (MethodScope) scope;
+ insideStaticContext |= methodScope.isStatic;
+ insideConstructorCall |= methodScope.isConstructorCall;
+ // Fall through... could duplicate the code below to save a
+ // cast - questionable optimization
+ case BLOCK_SCOPE:
+ LocalVariableBinding variableBinding = ((BlockScope) scope)
+ .findVariable(name);
+ // looks in this scope only
+ if (variableBinding != null) {
+ if (foundField != null && foundField.isValidBinding())
+ return new ProblemFieldBinding(
+ foundField.declaringClass, name,
InheritedNameHidesEnclosingName);
- if (depth > 0)
- invocationSite.setDepth(depth);
- return variableBinding;
- }
- break;
- case CLASS_SCOPE :
- ClassScope classScope = (ClassScope) scope;
- SourceTypeBinding enclosingType = classScope.referenceContext.binding;
- FieldBinding fieldBinding =
- classScope.findField(enclosingType, name, invocationSite);
- // Use next line instead if willing to enable protected access accross inner types
- // FieldBinding fieldBinding = findField(enclosingType, name, invocationSite);
- if (fieldBinding != null) { // skip it if we did not find anything
- if (fieldBinding.problemId() == Ambiguous) {
- if (foundField == null || foundField.problemId() == NotVisible)
- // supercedes any potential InheritedNameHidesEnclosingName problem
- return fieldBinding;
- else
- // make the user qualify the field, likely wants the first inherited field (javac generates an ambiguous error instead)
- return new ProblemFieldBinding(
- fieldBinding.declaringClass,
- name,
+ if (depth > 0)
+ invocationSite.setDepth(depth);
+ return variableBinding;
+ }
+ break;
+ case CLASS_SCOPE:
+ ClassScope classScope = (ClassScope) scope;
+ SourceTypeBinding enclosingType = classScope.referenceContext.binding;
+ FieldBinding fieldBinding = classScope.findField(
+ enclosingType, name, invocationSite);
+ // Use next line instead if willing to enable protected
+ // access accross inner types
+ // FieldBinding fieldBinding = findField(enclosingType,
+ // name, invocationSite);
+ if (fieldBinding != null) { // skip it if we did not find
+ // anything
+ if (fieldBinding.problemId() == Ambiguous) {
+ if (foundField == null
+ || foundField.problemId() == NotVisible)
+ // supercedes any potential
+ // InheritedNameHidesEnclosingName problem
+ return fieldBinding;
+ else
+ // make the user qualify the field, likely wants
+ // the first inherited field (javac generates an
+ // ambiguous error instead)
+ return new ProblemFieldBinding(
+ fieldBinding.declaringClass, name,
InheritedNameHidesEnclosingName);
- }
+ }
- ProblemFieldBinding insideProblem = null;
- if (fieldBinding.isValidBinding()) {
- if (!fieldBinding.isStatic()) {
- if (insideConstructorCall) {
- insideProblem =
- new ProblemFieldBinding(
- fieldBinding.declaringClass,
- name,
- NonStaticReferenceInConstructorInvocation);
- } else if (insideStaticContext) {
- insideProblem =
- new ProblemFieldBinding(
- fieldBinding.declaringClass,
- name,
- NonStaticReferenceInStaticContext);
- }
- }
- if (enclosingType == fieldBinding.declaringClass
- || environment().options.complianceLevel >= CompilerOptions.JDK1_4){
- // found a valid field in the 'immediate' scope (ie. not inherited)
- // OR in 1.4 mode (inherited shadows enclosing)
- if (foundField == null) {
- if (depth > 0){
- invocationSite.setDepth(depth);
- invocationSite.setActualReceiverType(enclosingType);
- }
- // return the fieldBinding if it is not declared in a superclass of the scope's binding (i.e. "inherited")
- return insideProblem == null ? fieldBinding : insideProblem;
- }
- if (foundField.isValidBinding())
- // if a valid field was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
- if (foundField.declaringClass != fieldBinding.declaringClass)
- // ie. have we found the same field - do not trust field identity yet
- return new ProblemFieldBinding(
- fieldBinding.declaringClass,
- name,
- InheritedNameHidesEnclosingName);
+ ProblemFieldBinding insideProblem = null;
+ if (fieldBinding.isValidBinding()) {
+ if (!fieldBinding.isStatic()) {
+ if (insideConstructorCall) {
+ insideProblem = new ProblemFieldBinding(
+ fieldBinding.declaringClass, name,
+ NonStaticReferenceInConstructorInvocation);
+ } else if (insideStaticContext) {
+ insideProblem = new ProblemFieldBinding(
+ fieldBinding.declaringClass, name,
+ NonStaticReferenceInStaticContext);
}
}
+ // if (enclosingType == fieldBinding.declaringClass
+ // || environment().options.complianceLevel >=
+ // CompilerOptions.JDK1_4){
+ // // found a valid field in the 'immediate' scope
+ // (ie. not inherited)
+ // // OR in 1.4 mode (inherited shadows enclosing)
+ // if (foundField == null) {
+ // if (depth > 0){
+ // invocationSite.setDepth(depth);
+ // invocationSite.setActualReceiverType(enclosingType);
+ // }
+ // // return the fieldBinding if it is not declared
+ // in a superclass of the scope's binding (that is,
+ // inherited)
+ // return insideProblem == null ? fieldBinding :
+ // insideProblem;
+ // }
+ // if (foundField.isValidBinding())
+ // // if a valid field was found, complain when
+ // another is found in an 'immediate' enclosing type
+ // (that is, not inherited)
+ // if (foundField.declaringClass !=
+ // fieldBinding.declaringClass)
+ // // ie. have we found the same field - do not
+ // trust field identity yet
+ // return new ProblemFieldBinding(
+ // fieldBinding.declaringClass,
+ // name,
+ // InheritedNameHidesEnclosingName);
+ // }
+ }
- if (foundField == null
- || (foundField.problemId() == NotVisible
- && fieldBinding.problemId() != NotVisible)) {
- // only remember the fieldBinding if its the first one found or the previous one was not visible & fieldBinding is...
- foundDepth = depth;
- foundActualReceiverType = enclosingType;
- foundInsideProblem = insideProblem;
- foundField = fieldBinding;
- }
+ if (foundField == null
+ || (foundField.problemId() == NotVisible && fieldBinding
+ .problemId() != NotVisible)) {
+ // only remember the fieldBinding if its the first
+ // one found or the previous one was not visible &
+ // fieldBinding is...
+ foundDepth = depth;
+ foundActualReceiverType = enclosingType;
+ foundInsideProblem = insideProblem;
+ foundField = fieldBinding;
}
- depth++;
- insideStaticContext |= enclosingType.isStatic();
- // 1EX5I8Z - accessing outer fields within a constructor call is permitted
- // in order to do so, we change the flag as we exit from the type, not the method
- // itself, because the class scope is used to retrieve the fields.
- MethodScope enclosingMethodScope = scope.methodScope();
- insideConstructorCall =
- enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
- break;
- case COMPILATION_UNIT_SCOPE :
- break done;
+ }
+ depth++;
+ insideStaticContext |= enclosingType.isStatic();
+ // 1EX5I8Z - accessing outer fields within a constructor
+ // call is permitted
+ // in order to do so, we change the flag as we exit from the
+ // type, not the method
+ // itself, because the class scope is used to retrieve the
+ // fields.
+ MethodScope enclosingMethodScope = scope.methodScope();
+ insideConstructorCall = enclosingMethodScope == null ? false
+ : enclosingMethodScope.isConstructorCall;
+ break;
+ case COMPILATION_UNIT_SCOPE:
+ break done;
}
scope = scope.parent;
}
- if (foundInsideProblem != null){
+ if (foundInsideProblem != null) {
return foundInsideProblem;
}
if (foundField != null) {
- if (foundField.isValidBinding()){
- if (foundDepth > 0){
+ if (foundField.isValidBinding()) {
+ if (foundDepth > 0) {
invocationSite.setDepth(foundDepth);
- invocationSite.setActualReceiverType(foundActualReceiverType);
+ invocationSite
+ .setActualReceiverType(foundActualReceiverType);
}
return foundField;
}
if ((mask & TYPE) != 0) {
if ((binding = getBaseType(name)) != null)
return binding;
- binding = getTypeOrPackage(name, (mask & PACKAGE) == 0 ? TYPE : TYPE | PACKAGE);
+ binding = getTypeOrPackage(name, (mask & PACKAGE) == 0 ? TYPE
+ : TYPE | PACKAGE);
if (binding.isValidBinding() || mask == TYPE)
return binding;
// answer the problem type binding if we are only looking for a type
else
return new ProblemBinding(name, enclosingSourceType(), NotFound);
}
-
- /*
- * This retrieves the argument that maps to an enclosing instance of the suitable type,
- * if not found then answers nil -- do not create one
- *
- * #implicitThis : the implicit this will be ok
- * #((arg) this$n) : available as a constructor arg
- * #((arg) this$n access$m... access$p) : available as as a constructor arg + a sequence of synthetic accessors to synthetic fields
- * #((fieldDescr) this$n access#m... access$p) : available as a first synthetic field + a sequence of synthetic accessors to synthetic fields
- * nil : not found
- *
- */
- public Object[] getCompatibleEmulationPath(ReferenceBinding targetEnclosingType) {
-
- MethodScope currentMethodScope = this.methodScope();
- SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
- // identity check
- if (!currentMethodScope.isStatic
- && !currentMethodScope.isConstructorCall
- && (sourceType == targetEnclosingType
- || targetEnclosingType.isSuperclassOf(sourceType))) {
- return EmulationPathToImplicitThis; // implicit this is good enough
- }
- if (!sourceType.isNestedType()
- || sourceType.isStatic()) { // no emulation from within non-inner types
- return null;
- }
- boolean insideConstructor =
- currentMethodScope.isInsideInitializerOrConstructor();
- // use synthetic constructor arguments if possible
- if (insideConstructor) {
- SyntheticArgumentBinding syntheticArg;
- if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(targetEnclosingType, this, false)) != null) {
- return new Object[] { syntheticArg };
- }
- }
-
- // use a direct synthetic field then
- if (!currentMethodScope.isStatic) {
- FieldBinding syntheticField;
- if ((syntheticField = sourceType.getSyntheticField(targetEnclosingType, this, false)) != null) {
- return new Object[] { syntheticField };
- }
- // could be reached through a sequence of enclosing instance link (nested members)
- Object[] path = new Object[2]; // probably at least 2 of them
- ReferenceBinding currentType = sourceType.enclosingType();
- if (insideConstructor) {
- path[0] = ((NestedTypeBinding) sourceType).getSyntheticArgument((SourceTypeBinding) currentType, this, false);
- } else {
- path[0] =
- sourceType.getSyntheticField((SourceTypeBinding) currentType, this, false);
- }
- if (path[0] != null) { // keep accumulating
- int count = 1;
- ReferenceBinding currentEnclosingType;
- while ((currentEnclosingType = currentType.enclosingType()) != null) {
- //done?
- if (currentType == targetEnclosingType
- || targetEnclosingType.isSuperclassOf(currentType))
- break;
- syntheticField = ((NestedTypeBinding) currentType).getSyntheticField((SourceTypeBinding) currentEnclosingType, this, false);
- if (syntheticField == null)
- break;
- // append inside the path
- if (count == path.length) {
- System.arraycopy(path, 0, (path = new Object[count + 1]), 0, count);
- }
- // private access emulation is necessary since synthetic field is private
- path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true);
- currentType = currentEnclosingType;
- }
- if (currentType == targetEnclosingType
- || targetEnclosingType.isSuperclassOf(currentType)) {
- return path;
- }
- }
- }
- return null;
- }
-
- /* API
- *
- * Answer the constructor binding that corresponds to receiverType, argumentTypes.
- *
- * InvocationSite implements
- * isSuperAccess(); this is used to determine if the discovered constructor is visible.
- *
- * If no visible constructor is discovered, an error binding is answered.
+ /*
+ * API
+ *
+ * Answer the constructor binding that corresponds to receiverType,
+ * argumentTypes.
+ *
+ * InvocationSite implements isSuperAccess(); this is used to determine if
+ * the discovered constructor is visible.
+ *
+ * If no visible constructor is discovered, an error binding is answered.
*/
- public MethodBinding getConstructor(
- ReferenceBinding receiverType,
- TypeBinding[] argumentTypes,
- InvocationSite invocationSite) {
+ public MethodBinding getConstructor(ReferenceBinding receiverType,
+ TypeBinding[] argumentTypes, InvocationSite invocationSite) {
compilationUnitScope().recordTypeReference(receiverType);
compilationUnitScope().recordTypeReferences(argumentTypes);
- MethodBinding methodBinding = receiverType.getExactConstructor(argumentTypes);
- if (methodBinding != null)
+ MethodBinding methodBinding = receiverType
+ .getExactConstructor(argumentTypes);
+ if (methodBinding != null) {
if (methodBinding.canBeSeenBy(invocationSite, this))
return methodBinding;
-
- MethodBinding[] methods =
- receiverType.getMethods(ConstructorDeclaration.ConstantPoolName);
- if (methods == NoMethods)
+ }
+ MethodBinding[] methods = receiverType
+ .getMethods(ConstructorDeclaration.ConstantPoolName);
+ if (methods == NoMethods) {
return new ProblemMethodBinding(
- ConstructorDeclaration.ConstantPoolName,
- argumentTypes,
- NotFound);
-
+ ConstructorDeclaration.ConstantPoolName, argumentTypes,
+ NotFound);
+ }
MethodBinding[] compatible = new MethodBinding[methods.length];
int compatibleIndex = 0;
for (int i = 0, length = methods.length; i < length; i++)
compatible[compatibleIndex++] = methods[i];
if (compatibleIndex == 0)
return new ProblemMethodBinding(
- ConstructorDeclaration.ConstantPoolName,
- argumentTypes,
- NotFound);
+ ConstructorDeclaration.ConstantPoolName, argumentTypes,
+ NotFound);
// need a more descriptive error... cannot convert from X to Y
MethodBinding[] visible = new MethodBinding[compatibleIndex];
if (visibleIndex == 1)
return visible[0];
if (visibleIndex == 0)
- return new ProblemMethodBinding(
- ConstructorDeclaration.ConstantPoolName,
- argumentTypes,
- NotVisible);
+ return new ProblemMethodBinding(compatible[0],
+ ConstructorDeclaration.ConstantPoolName,
+ compatible[0].parameters, NotVisible);
return mostSpecificClassMethodBinding(visible, visibleIndex);
}
/*
- * This retrieves the argument that maps to an enclosing instance of the suitable type,
- * if not found then answers nil -- do not create one
- *
- * #implicitThis : the implicit this will be ok
- * #((arg) this$n) : available as a constructor arg
- * #((arg) this$n ... this$p) : available as as a constructor arg + a sequence of fields
- * #((fieldDescr) this$n ... this$p) : available as a sequence of fields
- * nil : not found
- *
- * Note that this algorithm should answer the shortest possible sequence when
- * shortcuts are available:
- * this$0 . this$0 . this$0
- * instead of
- * this$2 . this$1 . this$0 . this$1 . this$0
- * thus the code generation will be more compact and runtime faster
+ * This retrieves the argument that maps to an enclosing instance of the
+ * suitable type, if not found then answers nil -- do not create one
+ *
+ * #implicitThis : the implicit this will be ok #((arg) this$n) : available
+ * as a constructor arg #((arg) this$n ... this$p) : available as as a
+ * constructor arg + a sequence of fields #((fieldDescr) this$n ... this$p) :
+ * available as a sequence of fields nil : not found
+ *
+ * Note that this algorithm should answer the shortest possible sequence
+ * when shortcuts are available: this$0 . this$0 . this$0 instead of this$2 .
+ * this$1 . this$0 . this$1 . this$0 thus the code generation will be more
+ * compact and runtime faster
*/
- public VariableBinding[] getEmulationPath(LocalVariableBinding outerLocalVariable) {
+ public VariableBinding[] getEmulationPath(
+ LocalVariableBinding outerLocalVariable) {
MethodScope currentMethodScope = this.methodScope();
SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
// identity check
- if (currentMethodScope == outerLocalVariable.declaringScope.methodScope()) {
+ if (currentMethodScope == outerLocalVariable.declaringScope
+ .methodScope()) {
return new VariableBinding[] { outerLocalVariable };
// implicit this is good enough
}
// use synthetic constructor arguments if possible
if (currentMethodScope.isInsideInitializerOrConstructor()
- && (sourceType.isNestedType())) {
+ && (sourceType.isNestedType())) {
SyntheticArgumentBinding syntheticArg;
- if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(outerLocalVariable)) != null) {
+ if ((syntheticArg = ((NestedTypeBinding) sourceType)
+ .getSyntheticArgument(outerLocalVariable)) != null) {
return new VariableBinding[] { syntheticArg };
}
}
// use a synthetic field then
if (!currentMethodScope.isStatic) {
FieldBinding syntheticField;
- if ((syntheticField = sourceType.getSyntheticField(outerLocalVariable)) != null) {
+ if ((syntheticField = sourceType
+ .getSyntheticField(outerLocalVariable)) != null) {
return new VariableBinding[] { syntheticField };
}
}
}
/*
- * This retrieves the argument that maps to an enclosing instance of the suitable type,
- * if not found then answers nil -- do not create one
- *
- * #implicitThis : the implicit this will be ok
- * #((arg) this$n) : available as a constructor arg
- * #((arg) this$n access$m... access$p) : available as as a constructor arg + a sequence of synthetic accessors to synthetic fields
- * #((fieldDescr) this$n access#m... access$p) : available as a first synthetic field + a sequence of synthetic accessors to synthetic fields
- * nil : not found
- *
- * EXACT MATCH VERSION - no type compatibility is performed
+ * This retrieves the argument that maps to an enclosing instance of the
+ * suitable type, if not found then answers nil -- do not create one
+ *
+ * #implicitThis : the implicit this will be ok #((arg) this$n) : available
+ * as a constructor arg #((arg) this$n access$m... access$p) : available as
+ * as a constructor arg + a sequence of synthetic accessors to synthetic
+ * fields #((fieldDescr) this$n access#m... access$p) : available as a first
+ * synthetic field + a sequence of synthetic accessors to synthetic fields
+ * nil : not found jls 15.9.2
*/
- public Object[] getExactEmulationPath(ReferenceBinding targetEnclosingType) {
-
+ public Object[] getEmulationPath(ReferenceBinding targetEnclosingType,
+ boolean onlyExactMatch, boolean ignoreEnclosingArgInConstructorCall) {
+ // TODO: (philippe) investigate why exactly test76 fails if
+ // ignoreEnclosingArgInConstructorCall is always false
MethodScope currentMethodScope = this.methodScope();
SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
// identity check
- if (!currentMethodScope.isStatic
- && !currentMethodScope.isConstructorCall
- && (sourceType == targetEnclosingType)) {
+ if (!currentMethodScope.isStatic
+ && (!currentMethodScope.isConstructorCall || ignoreEnclosingArgInConstructorCall)
+ && (sourceType == targetEnclosingType || (!onlyExactMatch && targetEnclosingType
+ .isSuperclassOf(sourceType)))) {
+ if (currentMethodScope.isConstructorCall) {
+ return NoEnclosingInstanceInConstructorCall;
+ }
+ if (currentMethodScope.isStatic) {
+ return NoEnclosingInstanceInStaticContext;
+ }
return EmulationPathToImplicitThis; // implicit this is good enough
}
- if (!sourceType.isNestedType()
- || sourceType.isStatic()) { // no emulation from within non-inner types
+ if (!sourceType.isNestedType() || sourceType.isStatic()) { // no
+ // emulation
+ // from
+ // within
+ // non-inner
+ // types
+ if (currentMethodScope.isConstructorCall) {
+ return NoEnclosingInstanceInConstructorCall;
+ }
+ if (currentMethodScope.isStatic) {
+ return NoEnclosingInstanceInStaticContext;
+ }
return null;
}
-
- boolean insideConstructor =
- currentMethodScope.isInsideInitializerOrConstructor();
+ boolean insideConstructor = currentMethodScope
+ .isInsideInitializerOrConstructor();
// use synthetic constructor arguments if possible
if (insideConstructor) {
SyntheticArgumentBinding syntheticArg;
- if ((syntheticArg = ((NestedTypeBinding) sourceType).getSyntheticArgument(targetEnclosingType, this, true)) != null) {
+ if ((syntheticArg = ((NestedTypeBinding) sourceType)
+ .getSyntheticArgument(targetEnclosingType, onlyExactMatch)) != null) {
return new Object[] { syntheticArg };
}
}
+
// use a direct synthetic field then
- if (!currentMethodScope.isStatic) {
- FieldBinding syntheticField;
- if ((syntheticField = sourceType.getSyntheticField(targetEnclosingType, this, true)) != null) {
- return new Object[] { syntheticField };
+ if (currentMethodScope.isStatic) {
+ return NoEnclosingInstanceInStaticContext;
+ }
+ FieldBinding syntheticField = sourceType.getSyntheticField(
+ targetEnclosingType, onlyExactMatch);
+ if (syntheticField != null) {
+ if (currentMethodScope.isConstructorCall) {
+ return NoEnclosingInstanceInConstructorCall;
}
- // could be reached through a sequence of enclosing instance link (nested members)
- Object[] path = new Object[2]; // probably at least 2 of them
- ReferenceBinding currentType = sourceType.enclosingType();
- if (insideConstructor) {
- path[0] =
- ((NestedTypeBinding) sourceType).getSyntheticArgument((SourceTypeBinding) currentType, this, true);
- } else {
- path[0] =
- sourceType.getSyntheticField((SourceTypeBinding) currentType, this, true);
+ return new Object[] { syntheticField };
+ }
+ // could be reached through a sequence of enclosing instance link
+ // (nested members)
+ Object[] path = new Object[2]; // probably at least 2 of them
+ ReferenceBinding currentType = sourceType.enclosingType();
+ if (insideConstructor) {
+ path[0] = ((NestedTypeBinding) sourceType).getSyntheticArgument(
+ (SourceTypeBinding) currentType, onlyExactMatch);
+ } else {
+ if (currentMethodScope.isConstructorCall) {
+ return NoEnclosingInstanceInConstructorCall;
}
- if (path[0] != null) { // keep accumulating
- int count = 1;
- ReferenceBinding currentEnclosingType;
- while ((currentEnclosingType = currentType.enclosingType()) != null) {
- //done?
- if (currentType == targetEnclosingType)
- break;
- syntheticField =
- ((NestedTypeBinding) currentType).getSyntheticField(
- (SourceTypeBinding) currentEnclosingType,
- this,
- true);
- if (syntheticField == null)
- break;
- // append inside the path
- if (count == path.length) {
- System.arraycopy(path, 0, (path = new Object[count + 1]), 0, count);
+ path[0] = sourceType.getSyntheticField(
+ (SourceTypeBinding) currentType, onlyExactMatch);
+ }
+ if (path[0] != null) { // keep accumulating
+
+ int count = 1;
+ ReferenceBinding currentEnclosingType;
+ while ((currentEnclosingType = currentType.enclosingType()) != null) {
+
+ // done?
+ if (currentType == targetEnclosingType
+ || (!onlyExactMatch && targetEnclosingType
+ .isSuperclassOf(currentType)))
+ break;
+
+ if (currentMethodScope != null) {
+ currentMethodScope = currentMethodScope
+ .enclosingMethodScope();
+ if (currentMethodScope != null
+ && currentMethodScope.isConstructorCall) {
+ return NoEnclosingInstanceInConstructorCall;
+ }
+ if (currentMethodScope != null
+ && currentMethodScope.isStatic) {
+ return NoEnclosingInstanceInStaticContext;
}
- // private access emulation is necessary since synthetic field is private
- path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true);
- currentType = currentEnclosingType;
}
- if (currentType == targetEnclosingType) {
- return path;
+
+ syntheticField = ((NestedTypeBinding) currentType)
+ .getSyntheticField(
+ (SourceTypeBinding) currentEnclosingType,
+ onlyExactMatch);
+ if (syntheticField == null)
+ break;
+
+ // append inside the path
+ if (count == path.length) {
+ System.arraycopy(path, 0, (path = new Object[count + 1]),
+ 0, count);
}
+ // private access emulation is necessary since synthetic field
+ // is private
+ path[count++] = ((SourceTypeBinding) syntheticField.declaringClass)
+ .addSyntheticMethod(syntheticField, true);
+ currentType = currentEnclosingType;
+ }
+ if (currentType == targetEnclosingType
+ || (!onlyExactMatch && targetEnclosingType
+ .isSuperclassOf(currentType))) {
+ return path;
}
}
return null;
}
- /* API
- *
- * Answer the field binding that corresponds to fieldName.
- * Start the lookup at the receiverType.
- * InvocationSite implements
- * isSuperAccess(); this is used to determine if the discovered field is visible.
- * Only fields defined by the receiverType or its supertypes are answered;
- * a field of an enclosing type will not be found using this API.
- *
- * If no visible field is discovered, an error binding is answered.
+ /*
+ * API
+ *
+ * Answer the field binding that corresponds to fieldName. Start the lookup
+ * at the receiverType. InvocationSite implements isSuperAccess(); this is
+ * used to determine if the discovered field is visible. Only fields defined
+ * by the receiverType or its supertypes are answered; a field of an
+ * enclosing type will not be found using this API.
+ *
+ * If no visible field is discovered, an error binding is answered.
*/
- public FieldBinding getField(
- TypeBinding receiverType,
- char[] fieldName,
- InvocationSite invocationSite) {
+ public FieldBinding getField(TypeBinding receiverType, char[] fieldName,
+ InvocationSite invocationSite) {
FieldBinding field = findField(receiverType, fieldName, invocationSite);
if (field == null)
return new ProblemFieldBinding(
- receiverType instanceof ReferenceBinding
- ? (ReferenceBinding) receiverType
- : null,
- fieldName,
- NotFound);
+ receiverType instanceof ReferenceBinding ? (ReferenceBinding) receiverType
+ : null, fieldName, NotFound);
else
return field;
}
- /* API
- *
- * Answer the method binding that corresponds to selector, argumentTypes.
- * Start the lookup at the enclosing type of the receiver.
- * InvocationSite implements
- * isSuperAccess(); this is used to determine if the discovered method is visible.
- * setDepth(int); this is used to record the depth of the discovered method
- * relative to the enclosing type of the receiver. (If the method is defined
- * in the enclosing type of the receiver, the depth is 0; in the next enclosing
- * type, the depth is 1; and so on
+ /*
+ * API
+ *
+ * Answer the method binding that corresponds to selector, argumentTypes.
+ * Start the lookup at the enclosing type of the receiver. InvocationSite
+ * implements isSuperAccess(); this is used to determine if the discovered
+ * method is visible. setDepth(int); this is used to record the depth of the
+ * discovered method relative to the enclosing type of the receiver. (If the
+ * method is defined in the enclosing type of the receiver, the depth is 0;
+ * in the next enclosing type, the depth is 1; and so on
*
- * If no visible method is discovered, an error binding is answered.
+ * If no visible method is discovered, an error binding is answered.
*/
- public MethodBinding getImplicitMethod(
- char[] selector,
- TypeBinding[] argumentTypes,
- InvocationSite invocationSite) {
+ public MethodBinding getImplicitMethod(char[] selector,
+ TypeBinding[] argumentTypes, InvocationSite invocationSite) {
boolean insideStaticContext = false;
boolean insideConstructorCall = false;
MethodBinding foundMethod = null;
ProblemMethodBinding foundFuzzyProblem = null;
- // the weird method lookup case (matches method name in scope, then arg types, then visibility)
+ // the weird method lookup case (matches method name in scope, then arg
+ // types, then visibility)
ProblemMethodBinding foundInsideProblem = null;
// inside Constructor call or inside static context
Scope scope = this;
int depth = 0;
- done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
+ done: while (true) { // done when a COMPILATION_UNIT_SCOPE is found
switch (scope.kind) {
- case METHOD_SCOPE :
- MethodScope methodScope = (MethodScope) scope;
- insideStaticContext |= methodScope.isStatic;
- insideConstructorCall |= methodScope.isConstructorCall;
- break;
- case CLASS_SCOPE :
- ClassScope classScope = (ClassScope) scope;
- SourceTypeBinding receiverType = classScope.referenceContext.binding;
- boolean isExactMatch = true;
- // retrieve an exact visible match (if possible)
- MethodBinding methodBinding =
- (foundMethod == null)
- ? classScope.findExactMethod(
- receiverType,
- selector,
- argumentTypes,
+ case METHOD_SCOPE:
+ MethodScope methodScope = (MethodScope) scope;
+ insideStaticContext |= methodScope.isStatic;
+ insideConstructorCall |= methodScope.isConstructorCall;
+ break;
+ case CLASS_SCOPE:
+ ClassScope classScope = (ClassScope) scope;
+ SourceTypeBinding receiverType = classScope.referenceContext.binding;
+ boolean isExactMatch = true;
+ // retrieve an exact visible match (if possible)
+ MethodBinding methodBinding = (foundMethod == null) ? classScope
+ .findExactMethod(receiverType, selector, argumentTypes,
invocationSite)
- : classScope.findExactMethod(
- receiverType,
- foundMethod.selector,
- foundMethod.parameters,
+ : classScope.findExactMethod(receiverType,
+ foundMethod.selector, foundMethod.parameters,
invocationSite);
- // ? findExactMethod(receiverType, selector, argumentTypes, invocationSite)
- // : findExactMethod(receiverType, foundMethod.selector, foundMethod.parameters, invocationSite);
- if (methodBinding == null) {
- // answers closest approximation, may not check argumentTypes or visibility
- isExactMatch = false;
- methodBinding =
- classScope.findMethod(receiverType, selector, argumentTypes, invocationSite);
- // methodBinding = findMethod(receiverType, selector, argumentTypes, invocationSite);
- }
- if (methodBinding != null) { // skip it if we did not find anything
- if (methodBinding.problemId() == Ambiguous) {
- if (foundMethod == null || foundMethod.problemId() == NotVisible)
- // supercedes any potential InheritedNameHidesEnclosingName problem
- return methodBinding;
- else
- // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
- return new ProblemMethodBinding(
- selector,
+ // ? findExactMethod(receiverType, selector, argumentTypes,
+ // invocationSite)
+ // : findExactMethod(receiverType, foundMethod.selector,
+ // foundMethod.parameters, invocationSite);
+ if (methodBinding == null) {
+ // answers closest approximation, may not check
+ // argumentTypes or visibility
+ isExactMatch = false;
+ methodBinding = classScope.findMethod(receiverType,
+ selector, argumentTypes, invocationSite);
+ // methodBinding = findMethod(receiverType, selector,
+ // argumentTypes, invocationSite);
+ }
+ if (methodBinding != null) { // skip it if we did not find
+ // anything
+ if (methodBinding.problemId() == Ambiguous) {
+ if (foundMethod == null
+ || foundMethod.problemId() == NotVisible)
+ // supercedes any potential
+ // InheritedNameHidesEnclosingName problem
+ return methodBinding;
+ else
+ // make the user qualify the method, likely wants
+ // the first inherited method (javac generates an
+ // ambiguous error instead)
+ return new ProblemMethodBinding(selector,
argumentTypes,
InheritedNameHidesEnclosingName);
- }
+ }
- ProblemMethodBinding fuzzyProblem = null;
- ProblemMethodBinding insideProblem = null;
- if (methodBinding.isValidBinding()) {
- if (!isExactMatch) {
- if (!areParametersAssignable(methodBinding.parameters, argumentTypes)) {
- if (foundMethod == null || foundMethod.problemId() == NotVisible){
- // inherited mismatch is reported directly, not looking at enclosing matches
- return new ProblemMethodBinding(methodBinding, selector, argumentTypes, NotFound);
- }
- // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
- fuzzyProblem = new ProblemMethodBinding(selector, argumentTypes, InheritedNameHidesEnclosingName);
-
- } else if (!methodBinding.canBeSeenBy(receiverType, invocationSite, classScope)) {
- // using <classScope> instead of <this> for visibility check does grant all access to innerclass
- fuzzyProblem =
- new ProblemMethodBinding(
- selector,
- argumentTypes,
- methodBinding.declaringClass,
- NotVisible);
- }
- }
- if (fuzzyProblem == null && !methodBinding.isStatic()) {
- if (insideConstructorCall) {
- insideProblem =
- new ProblemMethodBinding(
- methodBinding.selector,
- methodBinding.parameters,
- NonStaticReferenceInConstructorInvocation);
- } else if (insideStaticContext) {
- insideProblem =
- new ProblemMethodBinding(
- methodBinding.selector,
- methodBinding.parameters,
- NonStaticReferenceInStaticContext);
+ ProblemMethodBinding fuzzyProblem = null;
+ ProblemMethodBinding insideProblem = null;
+ if (methodBinding.isValidBinding()) {
+ if (!isExactMatch) {
+ if (!areParametersAssignable(
+ methodBinding.parameters, argumentTypes)) {
+ if (foundMethod == null
+ || foundMethod.problemId() == NotVisible) {
+ // inherited mismatch is reported directly,
+ // not looking at enclosing matches
+ return new ProblemMethodBinding(
+ methodBinding, selector,
+ argumentTypes, NotFound);
}
+ // make the user qualify the method, likely
+ // wants the first inherited method (javac
+ // generates an ambiguous error instead)
+ fuzzyProblem = new ProblemMethodBinding(
+ selector, methodBinding.parameters,
+ InheritedNameHidesEnclosingName);
+
+ } else if (!methodBinding.canBeSeenBy(receiverType,
+ invocationSite, classScope)) {
+ // using <classScope> instead of <this> for
+ // visibility check does grant all access to
+ // innerclass
+ fuzzyProblem = new ProblemMethodBinding(
+ methodBinding, selector,
+ methodBinding.parameters, NotVisible);
}
-
- if (receiverType == methodBinding.declaringClass
- || (receiverType.getMethods(selector)) != NoMethods
- || ((fuzzyProblem == null || fuzzyProblem.problemId() != NotVisible) && environment().options.complianceLevel >= CompilerOptions.JDK1_4)){
- // found a valid method in the 'immediate' scope (ie. not inherited)
- // OR the receiverType implemented a method with the correct name
- // OR in 1.4 mode (inherited visible shadows enclosing)
- if (foundMethod == null) {
- if (depth > 0){
- invocationSite.setDepth(depth);
- invocationSite.setActualReceiverType(receiverType);
- }
- // return the methodBinding if it is not declared in a superclass of the scope's binding (i.e. "inherited")
- if (fuzzyProblem != null)
- return fuzzyProblem;
- if (insideProblem != null)
- return insideProblem;
- return methodBinding;
- }
- // if a method was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
- // NOTE: Unlike fields, a non visible method hides a visible method
- if (foundMethod.declaringClass != methodBinding.declaringClass)
- // ie. have we found the same method - do not trust field identity yet
- return new ProblemMethodBinding(
+ }
+ if (fuzzyProblem == null && !methodBinding.isStatic()) {
+ if (insideConstructorCall) {
+ insideProblem = new ProblemMethodBinding(
methodBinding.selector,
methodBinding.parameters,
- InheritedNameHidesEnclosingName);
+ NonStaticReferenceInConstructorInvocation);
+ } else if (insideStaticContext) {
+ insideProblem = new ProblemMethodBinding(
+ methodBinding.selector,
+ methodBinding.parameters,
+ NonStaticReferenceInStaticContext);
}
}
- if (foundMethod == null
- || (foundMethod.problemId() == NotVisible
- && methodBinding.problemId() != NotVisible)) {
- // only remember the methodBinding if its the first one found or the previous one was not visible & methodBinding is...
- // remember that private methods are visible if defined directly by an enclosing class
- if (depth > 0){
- invocationSite.setDepth(depth);
- invocationSite.setActualReceiverType(receiverType);
- }
- foundFuzzyProblem = fuzzyProblem;
- foundInsideProblem = insideProblem;
- if (fuzzyProblem == null)
- foundMethod = methodBinding; // only keep it if no error was found
+ // if (receiverType == methodBinding.declaringClass
+ // || (receiverType.getMethods(selector)) != NoMethods
+ // || ((fuzzyProblem == null || fuzzyProblem.problemId()
+ // != NotVisible) &&
+ // environment().options.complianceLevel >=
+ // CompilerOptions.JDK1_4)){
+ // // found a valid method in the 'immediate' scope (ie.
+ // not inherited)
+ // // OR the receiverType implemented a method with the
+ // correct name
+ // // OR in 1.4 mode (inherited visible shadows
+ // enclosing)
+ // if (foundMethod == null) {
+ // if (depth > 0){
+ // invocationSite.setDepth(depth);
+ // invocationSite.setActualReceiverType(receiverType);
+ // }
+ // // return the methodBinding if it is not declared in
+ // a superclass of the scope's binding (that is,
+ // inherited)
+ // if (fuzzyProblem != null)
+ // return fuzzyProblem;
+ // if (insideProblem != null)
+ // return insideProblem;
+ // return methodBinding;
+ // }
+ // // if a method was found, complain when another is
+ // found in an 'immediate' enclosing type (that is, not
+ // inherited)
+ // // NOTE: Unlike fields, a non visible method hides a
+ // visible method
+ // if (foundMethod.declaringClass !=
+ // methodBinding.declaringClass)
+ // // ie. have we found the same method - do not trust
+ // field identity yet
+ // return new ProblemMethodBinding(
+ // methodBinding.selector,
+ // methodBinding.parameters,
+ // InheritedNameHidesEnclosingName);
+ // }
+ }
+
+ if (foundMethod == null
+ || (foundMethod.problemId() == NotVisible && methodBinding
+ .problemId() != NotVisible)) {
+ // only remember the methodBinding if its the first one
+ // found or the previous one was not visible &
+ // methodBinding is...
+ // remember that private methods are visible if defined
+ // directly by an enclosing class
+ if (depth > 0) {
+ invocationSite.setDepth(depth);
+ invocationSite.setActualReceiverType(receiverType);
}
+ foundFuzzyProblem = fuzzyProblem;
+ foundInsideProblem = insideProblem;
+ if (fuzzyProblem == null)
+ foundMethod = methodBinding; // only keep it if
+ // no error was
+ // found
}
- depth++;
- insideStaticContext |= receiverType.isStatic();
- // 1EX5I8Z - accessing outer fields within a constructor call is permitted
- // in order to do so, we change the flag as we exit from the type, not the method
- // itself, because the class scope is used to retrieve the fields.
- MethodScope enclosingMethodScope = scope.methodScope();
- insideConstructorCall =
- enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
- break;
- case COMPILATION_UNIT_SCOPE :
- break done;
+ }
+ depth++;
+ insideStaticContext |= receiverType.isStatic();
+ // 1EX5I8Z - accessing outer fields within a constructor call is
+ // permitted
+ // in order to do so, we change the flag as we exit from the
+ // type, not the method
+ // itself, because the class scope is used to retrieve the
+ // fields.
+ MethodScope enclosingMethodScope = scope.methodScope();
+ insideConstructorCall = enclosingMethodScope == null ? false
+ : enclosingMethodScope.isConstructorCall;
+ break;
+ case COMPILATION_UNIT_SCOPE:
+ break done;
}
scope = scope.parent;
}
return new ProblemMethodBinding(selector, argumentTypes, NotFound);
}
- /* API
- *
- * Answer the method binding that corresponds to selector, argumentTypes.
- * Start the lookup at the receiverType.
- * InvocationSite implements
- * isSuperAccess(); this is used to determine if the discovered method is visible.
- *
- * Only methods defined by the receiverType or its supertypes are answered;
- * use getImplicitMethod() to discover methods of enclosing types.
- *
- * If no visible method is discovered, an error binding is answered.
+ /*
+ * API
+ *
+ * Answer the method binding that corresponds to selector, argumentTypes.
+ * Start the lookup at the receiverType. InvocationSite implements
+ * isSuperAccess(); this is used to determine if the discovered method is
+ * visible.
+ *
+ * Only methods defined by the receiverType or its supertypes are answered;
+ * use getImplicitMethod() to discover methods of enclosing types.
+ *
+ * If no visible method is discovered, an error binding is answered.
*/
- public MethodBinding getMethod(
- TypeBinding receiverType,
- char[] selector,
- TypeBinding[] argumentTypes,
- InvocationSite invocationSite) {
+ public MethodBinding getMethod(TypeBinding receiverType, char[] selector,
+ TypeBinding[] argumentTypes, InvocationSite invocationSite) {
if (receiverType.isArrayType())
- return findMethodForArray(
- (ArrayBinding) receiverType,
- selector,
- argumentTypes,
- invocationSite);
+ return findMethodForArray((ArrayBinding) receiverType, selector,
+ argumentTypes, invocationSite);
if (receiverType.isBaseType())
return new ProblemMethodBinding(selector, argumentTypes, NotFound);
ReferenceBinding currentType = (ReferenceBinding) receiverType;
if (!currentType.canBeSeenBy(this))
- return new ProblemMethodBinding(selector, argumentTypes, NotVisible);
- // *** Need a new problem id - TypeNotVisible?
+ return new ProblemMethodBinding(selector, argumentTypes,
+ ReceiverTypeNotVisible);
// retrieve an exact visible match (if possible)
- MethodBinding methodBinding =
- findExactMethod(currentType, selector, argumentTypes, invocationSite);
+ MethodBinding methodBinding = findExactMethod(currentType, selector,
+ argumentTypes, invocationSite);
if (methodBinding != null)
return methodBinding;
- // answers closest approximation, may not check argumentTypes or visibility
- methodBinding =
- findMethod(currentType, selector, argumentTypes, invocationSite);
+ // answers closest approximation, may not check argumentTypes or
+ // visibility
+ methodBinding = findMethod(currentType, selector, argumentTypes,
+ invocationSite);
if (methodBinding == null)
return new ProblemMethodBinding(selector, argumentTypes, NotFound);
if (methodBinding.isValidBinding()) {
- if (!areParametersAssignable(methodBinding.parameters, argumentTypes))
- return new ProblemMethodBinding(
- methodBinding,
- selector,
- argumentTypes,
- NotFound);
+ if (!areParametersAssignable(methodBinding.parameters,
+ argumentTypes))
+ return new ProblemMethodBinding(methodBinding, selector,
+ argumentTypes, NotFound);
if (!methodBinding.canBeSeenBy(currentType, invocationSite, this))
- return new ProblemMethodBinding(
- selector,
- argumentTypes,
- methodBinding.declaringClass,
- NotVisible);
+ return new ProblemMethodBinding(methodBinding, selector,
+ methodBinding.parameters, NotVisible);
}
return methodBinding;
}
public int maxShiftedOffset() {
int max = -1;
- if (this.shiftScopes != null){
- for (int i = 0, length = this.shiftScopes.length; i < length; i++){
+ if (this.shiftScopes != null) {
+ for (int i = 0, length = this.shiftScopes.length; i < length; i++) {
int subMaxOffset = this.shiftScopes[i].maxOffset;
- if (subMaxOffset > max) max = subMaxOffset;
+ if (subMaxOffset > max)
+ max = subMaxOffset;
}
}
return max;
}
-
- /* Answer the problem reporter to use for raising new problems.
- *
+
+ /*
+ * Answer the problem reporter to use for raising new problems.
+ *
* Note that as a side-effect, this updates the current reference context
- * (unit, type or method) in case the problem handler decides it is necessary
- * to abort.
+ * (unit, type or method) in case the problem handler decides it is
+ * necessary to abort.
*/
public ProblemReporter problemReporter() {
}
/*
- * Code responsible to request some more emulation work inside the invocation type, so as to supply
- * correct synthetic arguments to any allocation of the target type.
+ * Code responsible to request some more emulation work inside the
+ * invocation type, so as to supply correct synthetic arguments to any
+ * allocation of the target type.
*/
- public void propagateInnerEmulation(
- ReferenceBinding targetType,
- boolean isEnclosingInstanceSupplied,
- boolean useDirectReference) {
-
- // perform some emulation work in case there is some and we are inside a local type only
- // propage emulation of the enclosing instances
- ReferenceBinding[] syntheticArgumentTypes;
- if ((syntheticArgumentTypes = targetType.syntheticEnclosingInstanceTypes())
- != null) {
- for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
- ReferenceBinding syntheticArgType = syntheticArgumentTypes[i];
- // need to filter out the one that could match a supplied enclosing instance
- if (!(isEnclosingInstanceSupplied
- && (syntheticArgType == targetType.enclosingType()))) {
- this.emulateOuterAccess(syntheticArgType, useDirectReference);
- }
- }
- }
+ public void propagateInnerEmulation(ReferenceBinding targetType,
+ boolean isEnclosingInstanceSupplied) {
+
+ // no need to propagate enclosing instances, they got eagerly allocated
+ // already.
+
SyntheticArgumentBinding[] syntheticArguments;
if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {
for (int i = 0, max = syntheticArguments.length; i < max; i++) {
SyntheticArgumentBinding syntheticArg = syntheticArguments[i];
- // need to filter out the one that could match a supplied enclosing instance
- if (!(isEnclosingInstanceSupplied
- && (syntheticArg.type == targetType.enclosingType()))) {
- this.emulateOuterAccess(syntheticArg.actualOuterLocalVariable);
+ // need to filter out the one that could match a supplied
+ // enclosing instance
+ if (!(isEnclosingInstanceSupplied && (syntheticArg.type == targetType
+ .enclosingType()))) {
+ this
+ .emulateOuterAccess(syntheticArg.actualOuterLocalVariable);
}
}
}
}
- /* Answer the reference type of this scope.
- *
- * i.e. the nearest enclosing type of this scope.
+ /*
+ * Answer the reference type of this scope.
+ *
+ * It is the nearest enclosing type of this scope.
*/
public TypeDeclaration referenceType() {
s += ((BlockScope) subscopes[i]).toString(tab + 1) + "\n"; //$NON-NLS-1$
return s;
}
-}
\ No newline at end of file
+}
git://git.phpeclipse.com / phpeclipse.git / blobdiff