--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v0.5
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v05.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ ******************************************************************************/
+package net.sourceforge.phpdt.internal.compiler.lookup;
+
+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 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;
+
+ public final static VariableBinding[] EmulationPathToImplicitThis = {};
+
+ 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) {
+
+ super(kind, parent);
+ }
+
+ public BlockScope(BlockScope parent) {
+
+ this(parent, true);
+ }
+
+ public BlockScope(BlockScope parent, boolean addToParentScope) {
+
+ this(BLOCK_SCOPE, parent);
+ locals = new LocalVariableBinding[5];
+ if (addToParentScope) parent.addSubscope(this);
+ this.startIndex = parent.localIndex;
+ }
+
+ public BlockScope(BlockScope parent, int variableCount) {
+
+ this(BLOCK_SCOPE, parent);
+ locals = new LocalVariableBinding[variableCount];
+ parent.addSubscope(this);
+ this.startIndex = parent.localIndex;
+ }
+
+ /* Create the class scope & binding for the anonymous type.
+ */
+ public final void addAnonymousType(
+ TypeDeclaration anonymousType,
+ ReferenceBinding superBinding) {
+
+ ClassScope anonymousClassScope = new ClassScope(this, anonymousType);
+ anonymousClassScope.buildAnonymousTypeBinding(
+ enclosingSourceType(),
+ superBinding);
+ }
+
+ /* Create the class scope & binding for the local type.
+ */
+ public final void addLocalType(TypeDeclaration localType) {
+
+ // check that the localType does not conflict with an enclosing type
+ ReferenceBinding type = enclosingSourceType();
+ do {
+ if (CharOperation.equals(type.sourceName, localType.name)) {
+ problemReporter().hidingEnclosingType(localType);
+ return;
+ }
+ type = type.enclosingType();
+ } while (type != null);
+
+ // check that the localType does not conflict with another sibling local type
+ Scope scope = this;
+ do {
+ if (((BlockScope) scope).findLocalType(localType.name) != null) {
+ problemReporter().duplicateNestedType(localType);
+ return;
+ }
+ } while ((scope = scope.parent) instanceof BlockScope);
+
+ ClassScope localTypeScope = new ClassScope(this, localType);
+ localTypeScope.buildLocalTypeBinding(enclosingSourceType());
+ addSubscope(localTypeScope);
+ }
+
+ /* 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) {
+
+ checkAndSetModifiersForVariable(binding);
+
+ // insert local in scope
+ if (localIndex == locals.length)
+ System.arraycopy(
+ locals,
+ 0,
+ (locals = new LocalVariableBinding[localIndex * 2]),
+ 0,
+ localIndex);
+ locals[localIndex++] = 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);
+ 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
+ */
+ public final boolean allowBlankFinalFieldAssignment(FieldBinding binding) {
+
+ if (enclosingSourceType() != binding.declaringClass)
+ return false;
+
+ MethodScope methodScope = methodScope();
+ if (methodScope.isStatic != binding.isStatic())
+ return false;
+ return methodScope.isInsideInitializer() // inside initializer
+ || ((AbstractMethodDeclaration) methodScope.referenceContext)
+ .isInitializationMethod();
+ // inside constructor or clinit
+ }
+ String basicToString(int tab) {
+ String newLine = "\n"; //$NON-NLS-1$
+ for (int i = tab; --i >= 0;)
+ newLine += "\t"; //$NON-NLS-1$
+
+ String s = newLine + "--- Block Scope ---"; //$NON-NLS-1$
+ newLine += "\t"; //$NON-NLS-1$
+ s += newLine + "locals:"; //$NON-NLS-1$
+ for (int i = 0; i < localIndex; i++)
+ s += newLine + "\t" + locals[i].toString(); //$NON-NLS-1$
+ s += newLine + "startIndex = " + startIndex; //$NON-NLS-1$
+ return s;
+ }
+
+ private void checkAndSetModifiersForVariable(LocalVariableBinding varBinding) {
+
+ int modifiers = varBinding.modifiers;
+ 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);
+ }
+ varBinding.modifiers = modifiers;
+ }
+
+ /* 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.
+ */
+ 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.
+ */
+ public final LocalVariableBinding duplicateName(char[] name) {
+ for (int i = 0; i < localIndex; i++)
+ if (CharOperation.equals(name, locals[i].name))
+ return locals[i];
+
+ if (this instanceof MethodScope)
+ return null;
+ else
+ return ((BlockScope) parent).duplicateName(name);
+ }
+
+ /*
+ * 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();
+
+ //do nothing for member types, pre emulation was performed already
+ if (!currentType.isLocalType()) {
+ return;
+ }
+ // must also add a synthetic field if we're not inside a constructor
+ if (!currentMethodScope.isInsideInitializerOrConstructor()) {
+ currentType.addSyntheticArgumentAndField(outerLocalVariable);
+ } else {
+ currentType.addSyntheticArgument(outerLocalVariable);
+ }
+ }
+ }
+
+ /*
+ * 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)
+ */
+ 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;
+ if (CharOperation.equals(sourceType.sourceName(), name))
+ return sourceType;
+ }
+ }
+ return null;
+ }
+
+ public LocalVariableBinding findVariable(char[] variable) {
+
+ int variableLength = variable.length;
+ for (int i = 0, length = locals.length; i < length; i++) {
+ LocalVariableBinding local = locals[i];
+ if (local == null)
+ return null;
+ if (local.name.length == variableLength
+ && 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.
+ */
+ public Binding getBinding(char[][] compoundName, int mask, InvocationSite invocationSite) {
+
+ Binding binding = getBinding(compoundName[0], mask | TYPE | PACKAGE, invocationSite);
+ invocationSite.setFieldIndex(1);
+ if (binding instanceof VariableBinding) return binding;
+ compilationUnitScope().recordSimpleReference(compoundName[0]);
+ if (!binding.isValidBinding()) return binding;
+
+ int length = compoundName.length;
+ int currentIndex = 1;
+ foundType : if (binding instanceof PackageBinding) {
+ PackageBinding packageBinding = (PackageBinding) binding;
+ while (currentIndex < length) {
+ 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);
+ else
+ 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());
+ if (!((ReferenceBinding) binding).canBeSeenBy(this))
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ 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);
+ }
+
+ // know binding is now a ReferenceBinding
+ while (currentIndex < length) {
+ ReferenceBinding typeBinding = (ReferenceBinding) binding;
+ char[] nextName = compoundName[currentIndex++];
+ invocationSite.setFieldIndex(currentIndex);
+ invocationSite.setActualReceiverType(typeBinding);
+ if ((binding = findField(typeBinding, nextName, invocationSite)) != null) {
+ if (!binding.isValidBinding())
+ return new ProblemFieldBinding(
+ ((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.isValidBinding())
+ 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 binding;
+ }
+ if ((mask & TYPE) != 0 && (binding instanceof ReferenceBinding)) {
+ // was looking for a type and found a type
+ 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);
+ }
+
+ // Added for code assist... NOT Public API
+ public final Binding getBinding(
+ char[][] compoundName,
+ InvocationSite invocationSite) {
+ int currentIndex = 0;
+ int length = compoundName.length;
+ Binding binding =
+ getBinding(
+ compoundName[currentIndex++],
+ VARIABLE | TYPE | PACKAGE,
+ invocationSite);
+ if (!binding.isValidBinding())
+ return binding;
+
+ foundType : if (binding instanceof PackageBinding) {
+ while (currentIndex < length) {
+ PackageBinding packageBinding = (PackageBinding) binding;
+ 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);
+ else
+ 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());
+ if (!((ReferenceBinding) binding).canBeSeenBy(this))
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ binding,
+ NotVisible);
+ break foundType;
+ }
+ }
+ return binding;
+ }
+
+ 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());
+ if (!((FieldBinding) binding).isStatic())
+ return new ProblemFieldBinding(
+ ((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);
+ if (!binding.isValidBinding())
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ binding.problemId());
+ }
+ return binding;
+ }
+
+ VariableBinding variableBinding = (VariableBinding) 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);
+ if (variableBinding == null)
+ 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
+ */
+ 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;
+ }
+
+ boolean insideStaticContext = false;
+ boolean insideConstructorCall = false;
+ if (this.kind == METHOD_SCOPE) {
+ MethodScope methodScope = (MethodScope) this;
+ insideStaticContext |= methodScope.isStatic;
+ insideConstructorCall |= methodScope.isConstructorCall;
+ }
+
+ FieldBinding foundField = null;
+ // 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
+ 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,
+ 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,
+ 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);
+ }
+ }
+
+ 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;
+ }
+ scope = scope.parent;
+ }
+
+ if (foundInsideProblem != null){
+ return foundInsideProblem;
+ }
+ if (foundField != null) {
+ if (foundField.isValidBinding()){
+ if (foundDepth > 0){
+ invocationSite.setDepth(foundDepth);
+ invocationSite.setActualReceiverType(foundActualReceiverType);
+ }
+ return foundField;
+ }
+ problemField = foundField;
+ }
+ }
+
+ // We did not find a local or instance variable.
+ if ((mask & TYPE) != 0) {
+ if ((binding = getBaseType(name)) != null)
+ return binding;
+ 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 if ((mask & PACKAGE) != 0) {
+ compilationUnitScope().recordSimpleReference(name);
+ if ((binding = environment().getTopLevelPackage(name)) != null)
+ return binding;
+ }
+ if (problemField != null)
+ return problemField;
+ 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.
+ */
+ public MethodBinding getConstructor(
+ ReferenceBinding receiverType,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ compilationUnitScope().recordTypeReference(receiverType);
+ compilationUnitScope().recordTypeReferences(argumentTypes);
+ MethodBinding methodBinding = receiverType.getExactConstructor(argumentTypes);
+ if (methodBinding != null)
+ if (methodBinding.canBeSeenBy(invocationSite, this))
+ return methodBinding;
+
+ MethodBinding[] methods =
+ receiverType.getMethods(ConstructorDeclaration.ConstantPoolName);
+ if (methods == NoMethods)
+ return new ProblemMethodBinding(
+ ConstructorDeclaration.ConstantPoolName,
+ argumentTypes,
+ NotFound);
+
+ MethodBinding[] compatible = new MethodBinding[methods.length];
+ int compatibleIndex = 0;
+ for (int i = 0, length = methods.length; i < length; i++)
+ if (areParametersAssignable(methods[i].parameters, argumentTypes))
+ compatible[compatibleIndex++] = methods[i];
+ if (compatibleIndex == 0)
+ return new ProblemMethodBinding(
+ ConstructorDeclaration.ConstantPoolName,
+ argumentTypes,
+ NotFound);
+ // need a more descriptive error... cannot convert from X to Y
+
+ MethodBinding[] visible = new MethodBinding[compatibleIndex];
+ int visibleIndex = 0;
+ for (int i = 0; i < compatibleIndex; i++) {
+ MethodBinding method = compatible[i];
+ if (method.canBeSeenBy(invocationSite, this))
+ visible[visibleIndex++] = method;
+ }
+ if (visibleIndex == 1)
+ return visible[0];
+ if (visibleIndex == 0)
+ return new ProblemMethodBinding(
+ ConstructorDeclaration.ConstantPoolName,
+ argumentTypes,
+ 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
+ */
+ public VariableBinding[] getEmulationPath(LocalVariableBinding outerLocalVariable) {
+
+ MethodScope currentMethodScope = this.methodScope();
+ SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
+
+ // identity check
+ 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())) {
+ SyntheticArgumentBinding syntheticArg;
+ 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) {
+ return new VariableBinding[] { syntheticField };
+ }
+ }
+ return null;
+ }
+
+ /*
+ * 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
+ */
+ public Object[] getExactEmulationPath(ReferenceBinding targetEnclosingType) {
+
+ MethodScope currentMethodScope = this.methodScope();
+ SourceTypeBinding sourceType = currentMethodScope.enclosingSourceType();
+
+ // identity check
+ if (!currentMethodScope.isStatic
+ && !currentMethodScope.isConstructorCall
+ && (sourceType == targetEnclosingType)) {
+ 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, true)) != 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 };
+ }
+ // 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);
+ }
+ 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);
+ }
+ // 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;
+ }
+ }
+ }
+ 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.
+ */
+ 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);
+ 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
+ *
+ * If no visible method is discovered, an error binding is answered.
+ */
+ 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)
+ 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
+ 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,
+ invocationSite)
+ : 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,
+ 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);
+ }
+ }
+
+ 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(
+ 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;
+ }
+ scope = scope.parent;
+ }
+
+ if (foundFuzzyProblem != null)
+ return foundFuzzyProblem;
+ if (foundInsideProblem != null)
+ return foundInsideProblem;
+ if (foundMethod != null)
+ return foundMethod;
+ 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.
+ */
+ public MethodBinding getMethod(
+ TypeBinding receiverType,
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ 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))
+ return new ProblemMethodBinding(selector, argumentTypes, NotVisible);
+ // *** Need a new problem id - TypeNotVisible?
+
+ // retrieve an exact visible match (if possible)
+ 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);
+ 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 (!methodBinding.canBeSeenBy(currentType, invocationSite, this))
+ return new ProblemMethodBinding(
+ selector,
+ argumentTypes,
+ methodBinding.declaringClass,
+ NotVisible);
+ }
+ return methodBinding;
+ }
+
+ public int maxShiftedOffset() {
+ int max = -1;
+ 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;
+ }
+ }
+ return max;
+ }
+
+ /* 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.
+ */
+ public ProblemReporter problemReporter() {
+
+ return outerMostMethodScope().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.
+ */
+ 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);
+ }
+ }
+ }
+ 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);
+ }
+ }
+ }
+ }
+
+ /* Answer the reference type of this scope.
+ *
+ * i.e. the nearest enclosing type of this scope.
+ */
+ public TypeDeclaration referenceType() {
+
+ return methodScope().referenceType();
+ }
+
+ // start position in this scope - for ordering scopes vs. variables
+ int startIndex() {
+ return startIndex;
+ }
+
+ public String toString() {
+ return toString(0);
+ }
+
+ public String toString(int tab) {
+
+ String s = basicToString(tab);
+ for (int i = 0; i < scopeIndex; i++)
+ if (subscopes[i] instanceof BlockScope)
+ 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