コード例 #1
0
  /*
   * When unit result is about to be accepted, removed back pointers
   * to compiler structures.
   */
  public void cleanUp() {
    if (this.compilationUnitBinding != null) this.compilationUnitBinding.cleanup();

    if (this.types != null) {
      for (int i = 0, max = this.types.length; i < max; i++) {
        cleanUp(this.types[i]);
      }
      for (int i = 0, max = this.localTypeCount; i < max; i++) {
        LocalTypeBinding localType = localTypes[i];
        // null out the type's scope backpointers
        localType.scope = null; // local members are already in the list
        localType.enclosingCase = null;
      }
    }

    for (int i = 0; i < this.numberInferredTypes; i++) {
      SourceTypeBinding binding = this.inferredTypes[i].binding;
      if (binding != null) binding.cleanup();
    }
    compilationResult.recoveryScannerData = null; // recovery is already done
  }
コード例 #2
0
 /*
  * Type checking for constructor, just another method, except for special check
  * for recursive constructor invocations.
  */
 public void resolveStatements() {
   SourceTypeBinding sourceType = this.scope.enclosingSourceType();
   if (!CharOperation.equals(sourceType.sourceName, this.selector)) {
     this.scope.problemReporter().missingReturnType(this);
   }
   if (this.binding != null && !this.binding.isPrivate()) {
     sourceType.tagBits |= TagBits.HasNonPrivateConstructor;
   }
   // if null ==> an error has occurs at parsing time ....
   if (this.constructorCall != null) {
     if (sourceType.id == TypeIds.T_JavaLangObject
         && this.constructorCall.accessMode != ExplicitConstructorCall.This) {
       this.constructorCall = null;
     } else {
       this.constructorCall.resolve(this.scope);
     }
   }
   if ((this.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0) {
     this.scope.problemReporter().methodNeedBody(this);
   }
   super.resolveStatements();
 }
  public void resolve(MethodScope initializationScope) {
    // the two <constant = Constant.NotAConstant> could be regrouped into
    // a single line but it is clearer to have two lines while the reason of their
    // existence is not at all the same. See comment for the second one.

    // --------------------------------------------------------
    if ((this.bits & ASTNode.HasBeenResolved) != 0) return;
    if (this.binding == null || !this.binding.isValidBinding()) return;

    this.bits |= ASTNode.HasBeenResolved;

    // check if field is hiding some variable - issue is that field binding already got inserted in
    // scope
    // thus must lookup separately in super type and outer context
    ClassScope classScope = initializationScope.enclosingClassScope();

    if (classScope != null) {
      checkHiding:
      {
        SourceTypeBinding declaringType = classScope.enclosingSourceType();
        checkHidingSuperField:
        {
          if (declaringType.superclass == null) break checkHidingSuperField;
          Binding existingVariable =
              classScope.findField(
                  declaringType.superclass, this.name, this, false /*do not resolve hidden field*/);
          if (existingVariable == null) break checkHidingSuperField; // keep checking outer scenario
          if (!existingVariable.isValidBinding())
            break checkHidingSuperField; // keep checking outer scenario
          if (existingVariable instanceof FieldBinding) {
            FieldBinding existingField = (FieldBinding) existingVariable;
            if (existingField.original() == this.binding)
              break checkHidingSuperField; // keep checking outer scenario
          }
          // collision with supertype field
          initializationScope.problemReporter().fieldHiding(this, existingVariable);
          break checkHiding; // already found a matching field
        }
        // only corner case is: lookup of outer field through static declaringType, which isn't
        // detected by #getBinding as lookup starts
        // from outer scope. Subsequent static contexts are detected for free.
        Scope outerScope = classScope.parent;
        if (outerScope.kind == Scope.COMPILATION_UNIT_SCOPE) break checkHiding;
        Binding existingVariable =
            outerScope.getBinding(
                this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
        if (existingVariable == null) break checkHiding;
        if (!existingVariable.isValidBinding()) break checkHiding;
        if (existingVariable == this.binding) break checkHiding;
        if (existingVariable instanceof FieldBinding) {
          FieldBinding existingField = (FieldBinding) existingVariable;
          if (existingField.original() == this.binding) break checkHiding;
          if (!existingField.isStatic() && declaringType.isStatic()) break checkHiding;
        }
        // collision with outer field or local variable
        initializationScope.problemReporter().fieldHiding(this, existingVariable);
      }
    }

    if (this.type != null) { // enum constants have no declared type
      this.type.resolvedType = this.binding.type; // update binding for type reference
    }

    FieldBinding previousField = initializationScope.initializedField;
    int previousFieldID = initializationScope.lastVisibleFieldID;
    try {
      initializationScope.initializedField = this.binding;
      initializationScope.lastVisibleFieldID = this.binding.id;

      //		resolveAnnotations(initializationScope, this.annotations, this.binding);
      // the resolution of the initialization hasn't been done
      if (this.initialization != null) {

        TypeBinding fieldType = this.binding.type;
        TypeBinding initializationType;
        this.initialization.setExpectedType(
            fieldType); // needed in case of generic method invocation
        if (this.initialization instanceof ArrayInitializer) {

          if ((initializationType =
                  this.initialization.resolveTypeExpecting(initializationScope, fieldType))
              != null) {
            ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType;
          }
        } else if ((initializationType = this.initialization.resolveType(initializationScope))
            != null) {

          if (fieldType
              != initializationType) // must call before computeConversion() and typeMismatchError()
          initializationScope
                .compilationUnitScope()
                .recordTypeConversion(fieldType, initializationType);
          if (this.initialization.isConstantValueOfTypeAssignableToType(
                  initializationType, fieldType)
              || (fieldType.isBaseType()
                  && BaseTypeBinding.isWidening(fieldType.id, initializationType.id))
              || initializationType.isCompatibleWith(fieldType)) {
          } else if (initializationScope.isBoxingCompatibleWith(initializationType, fieldType)
              || (initializationType.isBaseType() // narrowing then boxing ?
                  && initializationScope.compilerOptions().sourceLevel
                      >= ClassFileConstants.JDK1_5 // autoboxing
                  && !fieldType.isBaseType()
                  && initialization.isConstantValueOfTypeAssignableToType(
                      initializationType,
                      initializationScope.environment().computeBoxingType(fieldType)))) {
          } else {
            initializationScope
                .problemReporter()
                .typeMismatchError(initializationType, fieldType, this);
          }
        }
        // check for assignment with no effect
        if (this.binding == Assignment.getDirectBinding(this.initialization)) {
          initializationScope.problemReporter().assignmentHasNoEffect(this, this.name);
        }
      }
      // Resolve Javadoc comment if one is present
      if (this.javadoc != null) {
        /*
        if (classScope != null) {
        	this.javadoc.resolve(classScope);
        }
        */
        this.javadoc.resolve(initializationScope);
      } else if (this.binding.declaringClass != null
          && !this.binding.declaringClass.isLocalType()) {
        initializationScope
            .problemReporter()
            .javadocMissing(this.sourceStart, this.sourceEnd, this.binding.modifiers);
      }
    } finally {
      initializationScope.initializedField = previousField;
      initializationScope.lastVisibleFieldID = previousFieldID;
    }
  }