Esempio n. 1
0
  public void bind(MethodScope scope, TypeBinding typeBinding, boolean used) {

    // record the resolved type into the type reference
    Binding existingVariable =
        scope.getBinding(this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
    if (existingVariable != null && existingVariable.isValidBinding()) {
      if (existingVariable instanceof LocalVariableBinding && this.hiddenVariableDepth == 0) {
        scope.problemReporter().redefineArgument(this);
      } else {
        boolean isSpecialArgument = false;
        if (existingVariable instanceof FieldBinding) {
          if (scope.isInsideConstructor()) {
            isSpecialArgument = true; // constructor argument
          } else {
            AbstractMethodDeclaration methodDecl = scope.referenceMethod();
            if (methodDecl != null && CharOperation.prefixEquals(SET, methodDecl.selector)) {
              isSpecialArgument = true; // setter argument
            }
          }
        }
        scope.problemReporter().localVariableHiding(this, existingVariable, isSpecialArgument);
      }
    }

    if (this.binding == null) {
      this.binding = new LocalVariableBinding(this, typeBinding, this.modifiers, true);
    } else if (!this.binding.type.isValidBinding()) {
      AbstractMethodDeclaration methodDecl = scope.referenceMethod();
      if (methodDecl != null) {
        MethodBinding methodBinding = methodDecl.binding;
        if (methodBinding != null) {
          methodBinding.tagBits |= TagBits.HasUnresolvedArguments;
        }
      }
    }
    scope.addLocalVariable(this.binding);
    resolveAnnotations(scope, this.annotations, this.binding);
    // true stand for argument instead of just local
    this.binding.declaration = this;
    this.binding.useFlag = used ? LocalVariableBinding.USED : LocalVariableBinding.UNUSED;
  }
Esempio n. 2
0
  public TypeBinding resolveForCatch(BlockScope scope) {
    // resolution on an argument of a catch clause
    // provide the scope with a side effect : insertion of a LOCAL
    // that represents the argument. The type must be from JavaThrowable

    TypeBinding exceptionType = this.type.resolveType(scope, true /* check bounds*/);
    boolean hasError;
    if (exceptionType == null) {
      hasError = true;
    } else {
      hasError = false;
      switch (exceptionType.kind()) {
        case Binding.PARAMETERIZED_TYPE:
          if (exceptionType.isBoundParameterizedType()) {
            hasError = true;
            scope.problemReporter().invalidParameterizedExceptionType(exceptionType, this);
            // fall thru to create the variable - avoids additional errors because the variable is
            // missing
          }
          break;
        case Binding.TYPE_PARAMETER:
          scope.problemReporter().invalidTypeVariableAsException(exceptionType, this);
          hasError = true;
          // fall thru to create the variable - avoids additional errors because the variable is
          // missing
          break;
      }
      if (exceptionType.findSuperTypeOriginatingFrom(TypeIds.T_JavaLangThrowable, true) == null
          && exceptionType.isValidBinding()) {
        scope.problemReporter().cannotThrowType(this.type, exceptionType);
        hasError = true;
        // fall thru to create the variable - avoids additional errors because the variable is
        // missing
      }
    }
    Binding existingVariable =
        scope.getBinding(this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
    if (existingVariable != null && existingVariable.isValidBinding()) {
      if (existingVariable instanceof LocalVariableBinding && this.hiddenVariableDepth == 0) {
        scope.problemReporter().redefineArgument(this);
      } else {
        scope.problemReporter().localVariableHiding(this, existingVariable, false);
      }
    }

    if ((this.type.bits & ASTNode.IsUnionType) != 0) {
      this.binding =
          new CatchParameterBinding(
              this,
              exceptionType,
              this.modifiers | ClassFileConstants.AccFinal,
              false); // argument decl, but local var  (where isArgument = false)
      this.binding.tagBits |= TagBits.MultiCatchParameter;
    } else {
      this.binding =
          new CatchParameterBinding(
              this,
              exceptionType,
              this.modifiers,
              false); // argument decl, but local var  (where isArgument = false)
    }
    resolveAnnotations(scope, this.annotations, this.binding);

    scope.addLocalVariable(this.binding);
    this.binding.setConstant(Constant.NotAConstant);
    if (hasError) return null;
    return exceptionType;
  }