Ejemplo n.º 1
0
 @Override
 public Void visitNewClass(NewClassTree node, Void p) {
   AnnotatedDeclaredType type = atypeFactory.getAnnotatedType(node);
   ExpressionTree identifier = node.getIdentifier();
   if (identifier instanceof AnnotatedTypeTree) {
     AnnotatedTypeTree t = (AnnotatedTypeTree) identifier;
     for (AnnotationMirror a : atypeFactory.getAnnotatedType(t).getAnnotations()) {
       // is this an annotation of the nullness checker?
       boolean nullnessCheckerAnno =
           containsSameIgnoringValues(atypeFactory.getNullnessAnnotations(), a);
       if (nullnessCheckerAnno && !AnnotationUtils.areSame(NONNULL, a)) {
         // The type is not non-null => warning
         checker.report(Result.warning("new.class.type.invalid", type.getAnnotations()), node);
         // Note that other consistency checks are made by isValid.
       }
     }
     if (t.toString().contains("@PolyNull")) {
       // TODO: this is a hack, but PolyNull gets substituted
       // afterwards
       checker.report(Result.warning("new.class.type.invalid", type.getAnnotations()), node);
     }
   }
   // TODO: It might be nicer to introduce a framework-level
   // isValidNewClassType or some such.
   return super.visitNewClass(node, p);
 }
  @Override
  public Void visitBinary(BinaryTree node, Void p) {

    // No checking unless the operator is "==" or "!=".
    if (!(node.getKind() == Tree.Kind.EQUAL_TO || node.getKind() == Tree.Kind.NOT_EQUAL_TO))
      return super.visitBinary(node, p);

    ExpressionTree leftOp = node.getLeftOperand();
    ExpressionTree rightOp = node.getRightOperand();

    // Check passes if either arg is null.
    if (leftOp.getKind() == Tree.Kind.NULL_LITERAL || rightOp.getKind() == Tree.Kind.NULL_LITERAL)
      return super.visitBinary(node, p);

    AnnotatedTypeMirror left = atypeFactory.getAnnotatedType(leftOp);
    AnnotatedTypeMirror right = atypeFactory.getAnnotatedType(rightOp);

    // If either argument is a primitive, check passes due to auto-unboxing
    if (left.getKind().isPrimitive() || right.getKind().isPrimitive())
      return super.visitBinary(node, p);

    if (!(shouldCheckFor(leftOp) && shouldCheckFor(rightOp))) return super.visitBinary(node, p);

    // Syntactic checks for legal uses of ==
    if (suppressInsideComparison(node)) return super.visitBinary(node, p);
    if (suppressEarlyEquals(node)) return super.visitBinary(node, p);
    if (suppressEarlyCompareTo(node)) return super.visitBinary(node, p);

    if (suppressClassAnnotation(left, right)) {
      return super.visitBinary(node, p);
    }

    Element leftElt = null;
    Element rightElt = null;
    if (left
        instanceof org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType) {
      leftElt = ((DeclaredType) left.getUnderlyingType()).asElement();
    }
    if (right
        instanceof org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType) {
      rightElt = ((DeclaredType) right.getUnderlyingType()).asElement();
    }

    // if neither @Interned or @UsesObjectEquals, report error
    if (!(left.hasEffectiveAnnotation(INTERNED)
        || (leftElt != null && leftElt.getAnnotation(UsesObjectEquals.class) != null)))
      checker.report(Result.failure("not.interned", left), leftOp);
    if (!(right.hasEffectiveAnnotation(INTERNED)
        || (rightElt != null && rightElt.getAnnotation(UsesObjectEquals.class) != null)))
      checker.report(Result.failure("not.interned", right), rightOp);
    return super.visitBinary(node, p);
  }
 protected void reportValidityResult(
     final /*@CompilerMessageKey*/ String errorType,
     final AnnotatedTypeMirror type,
     final Tree p) {
   checker.report(Result.failure(errorType, type.getAnnotations(), type.toString()), p);
   isValid = false;
 }
 @Override
 public Void visitAnnotation(AnnotationTree node, Void p) {
   Element anno = TreeInfo.symbol((JCTree) node.getAnnotationType());
   if (anno.toString().equals(DefaultType.class.getName())) {
     checker.report(Result.failure("annotation.not.allowed.in.src", anno.toString()), node);
   }
   return super.visitAnnotation(node, p);
 }
Ejemplo n.º 5
0
  /**
   * Reports an error if a comparison of a @NonNull expression with the null literal is performed.
   */
  protected void checkForRedundantTests(BinaryTree node) {

    final ExpressionTree leftOp = node.getLeftOperand();
    final ExpressionTree rightOp = node.getRightOperand();

    // respect command-line option
    if (!checker.getLintOption(
        AbstractNullnessChecker.LINT_REDUNDANTNULLCOMPARISON,
        AbstractNullnessChecker.LINT_DEFAULT_REDUNDANTNULLCOMPARISON)) {
      return;
    }

    // equality tests
    if ((node.getKind() == Tree.Kind.EQUAL_TO || node.getKind() == Tree.Kind.NOT_EQUAL_TO)) {
      AnnotatedTypeMirror left = atypeFactory.getAnnotatedType(leftOp);
      AnnotatedTypeMirror right = atypeFactory.getAnnotatedType(rightOp);
      if (leftOp.getKind() == Tree.Kind.NULL_LITERAL && right.hasEffectiveAnnotation(NONNULL))
        checker.report(Result.warning(KNOWN_NONNULL, rightOp.toString()), node);
      else if (rightOp.getKind() == Tree.Kind.NULL_LITERAL && left.hasEffectiveAnnotation(NONNULL))
        checker.report(Result.warning(KNOWN_NONNULL, leftOp.toString()), node);
    }
  }
  /*
   * Method to implement the @UsesObjectEquals functionality.
   * If a class is marked @UsesObjectEquals, it must:
   *
   *    -not override .equals(Object)
   *    -be a subclass of Object or another class marked @UsesObjectEquals
   *
   * If a class is not marked @UsesObjectEquals, it must:
   *
   * 	  -not have a superclass marked @UsesObjectEquals
   *
   *
   * @see org.checkerframework.common.basetype.BaseTypeVisitor#visitClass(com.sun.source.tree.ClassTree, java.lang.Object)
   */
  @Override
  public Void visitClass(ClassTree node, Void p) {
    // Looking for an @UsesObjectEquals class declaration

    TypeElement elt = TreeUtils.elementFromDeclaration(node);
    UsesObjectEquals annotation = elt.getAnnotation(UsesObjectEquals.class);

    Tree superClass = node.getExtendsClause();
    Element elmt = null;
    if (superClass != null
        && (superClass instanceof IdentifierTree || superClass instanceof MemberSelectTree)) {
      elmt = TreeUtils.elementFromUse((ExpressionTree) superClass);
    }

    // if it's there, check to make sure does not override equals
    // and supertype is Object or @UsesObjectEquals
    if (annotation != null) {
      // check methods to ensure no .equals
      if (overridesEquals(node)) {
        checker.report(Result.failure("overrides.equals"), node);
      }

      if (!(superClass == null
          || (elmt != null && elmt.getAnnotation(UsesObjectEquals.class) != null))) {
        checker.report(Result.failure("superclass.unmarked"), node);
      }
    } else {
      // the class is not marked @UsesObjectEquals -> make sure its superclass isn't either.
      // this is impossible after design change making @UsesObjectEquals inherited?
      // check left in case of future design change back to non-inherited.
      if (superClass != null
          && (elmt != null && elmt.getAnnotation(UsesObjectEquals.class) != null)) {
        checker.report(Result.failure("superclass.marked"), node);
      }
    }

    return super.visitClass(node, p);
  }
  @Override
  public Void visitMethodInvocation(MethodInvocationTree node, Void p) {
    if (isInvocationOfEquals(node)) {
      AnnotatedTypeMirror recv = atypeFactory.getReceiverType(node);
      AnnotatedTypeMirror comp = atypeFactory.getAnnotatedType(node.getArguments().get(0));

      if (this.checker.getLintOption("dotequals", true)
          && recv.hasEffectiveAnnotation(INTERNED)
          && comp.hasEffectiveAnnotation(INTERNED))
        checker.report(Result.warning("unnecessary.equals"), node);
    }

    return super.visitMethodInvocation(node, p);
  }
Ejemplo n.º 8
0
  @Override
  public Void visitNewArray(NewArrayTree node, Void p) {
    AnnotatedArrayType type = atypeFactory.getAnnotatedType(node);
    AnnotatedTypeMirror componentType = type.getComponentType();
    if (componentType.hasEffectiveAnnotation(NONNULL)
        && !isNewArrayAllZeroDims(node)
        && !isNewArrayInToArray(node)
        && !TypesUtils.isPrimitive(componentType.getUnderlyingType())
        && checker.getLintOption("forbidnonnullarraycomponents", false)) {
      checker.report(
          Result.failure("new.array.type.invalid", componentType.getAnnotations(), type.toString()),
          node);
    }

    return super.visitNewArray(node, p);
  }
Ejemplo n.º 9
0
 /**
  * Issues a 'dereference.of.nullable' if the type is not of a {@link NonNull} type.
  *
  * @param tree the tree where the error is to reported
  * @param errMsg the error message (must be {@link CompilerMessageKey})
  */
 private void checkForNullability(ExpressionTree tree, /*@CompilerMessageKey*/ String errMsg) {
   AnnotatedTypeMirror type = atypeFactory.getAnnotatedType(tree);
   if (!type.hasEffectiveAnnotation(NONNULL)) {
     checker.report(Result.failure(errMsg, tree), tree);
   }
 }