コード例 #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);
 }
コード例 #2
0
  private static List<? extends TypeMirror> computeNewClass(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    NewClassTree nct = (NewClassTree) parent.getLeaf();
    boolean errorInRealArguments = false;

    for (Tree param : nct.getArguments()) {
      errorInRealArguments |= param == error;
    }

    if (errorInRealArguments) {
      TypeMirror[] proposedType = new TypeMirror[1];
      int[] proposedIndex = new int[1];
      ExecutableElement ee =
          org.netbeans.modules.editor.java.Utilities.fuzzyResolveMethodInvocation(
              info, parent, proposedType, proposedIndex);

      if (ee == null) { // cannot be resolved
        return null;
      }

      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return Collections.singletonList(proposedType[0]);
    }

    Tree id = nct.getIdentifier();

    if (id.getKind() == Kind.PARAMETERIZED_TYPE) {
      id = ((ParameterizedTypeTree) id).getType();
    }

    if (id == error) {
      return resolveType(
          EnumSet.noneOf(ElementKind.class), info, parent.getParentPath(), nct, offset, null, null);
    }

    return null;
  }
コード例 #3
0
 @Override
 public Void visitNewClass(NewClassTree node, AnnotatedTypeMirror p) {
   super.visitNewClass(node, p);
   if (useFbc) {
     boolean allCommitted = true;
     Type type = ((JCTree) node).type;
     for (ExpressionTree a : node.getArguments()) {
       final AnnotatedTypeMirror t = getAnnotatedType(a);
       allCommitted &= (isCommitted(t) || isFbcBottom(t));
     }
     if (!allCommitted) {
       p.replaceAnnotation(createFreeAnnotation(type));
     }
   }
   return null;
 }
コード例 #4
0
    @Override
    public Void visitNewClass(NewClassTree tree, AnnotatedTypeMirror type) {
      boolean wrapperClass =
          TypesUtils.isBoxedPrimitive(type.getUnderlyingType())
              || TypesUtils.isDeclaredOfName(type.getUnderlyingType(), "java.lang.String");

      if (wrapperClass
          || (isUnderlyingTypeAValue(type)
              && methodIsStaticallyExecutable(TreeUtils.elementFromUse(tree)))) {
        // get arugment values
        List<? extends ExpressionTree> arguments = tree.getArguments();
        ArrayList<List<?>> argValues;
        if (arguments.size() > 0) {
          argValues = new ArrayList<List<?>>();
          for (ExpressionTree argument : arguments) {
            AnnotatedTypeMirror argType = getAnnotatedType(argument);
            List<?> values = getValues(argType, argType.getUnderlyingType());
            if (values.isEmpty()) {
              // values aren't known, so don't try to evaluate the
              // method
              return null;
            }
            argValues.add(values);
          }
        } else {
          argValues = null;
        }
        // Evaluate method
        List<?> returnValues =
            evalutator.evaluteConstrutorCall(argValues, tree, type.getUnderlyingType());
        AnnotationMirror returnType =
            resultAnnotationHandler(type.getUnderlyingType(), returnValues, tree);
        type.replaceAnnotation(returnType);
      }

      return null;
    }
コード例 #5
0
  private Pair<ParameterizedTypeTree, AnnotatedDeclaredType> extractParameterizedTypeTree(
      Tree tree, AnnotatedDeclaredType type) {
    ParameterizedTypeTree typeargtree = null;

    switch (tree.getKind()) {
      case VARIABLE:
        Tree lt = ((VariableTree) tree).getType();
        if (lt instanceof ParameterizedTypeTree) {
          typeargtree = (ParameterizedTypeTree) lt;
        } else {
          // System.out.println("Found a: " + lt);
        }
        break;
      case PARAMETERIZED_TYPE:
        typeargtree = (ParameterizedTypeTree) tree;
        break;
      case NEW_CLASS:
        NewClassTree nct = (NewClassTree) tree;
        ExpressionTree nctid = nct.getIdentifier();
        if (nctid.getKind() == Tree.Kind.PARAMETERIZED_TYPE) {
          typeargtree = (ParameterizedTypeTree) nctid;
          /*
           * This is quite tricky... for anonymous class instantiations,
           * the type at this point has no type arguments. By doing the
           * following, we get the type arguments again.
           */
          type = (AnnotatedDeclaredType) atypeFactory.getAnnotatedType(typeargtree);
        }
        break;
      case ANNOTATED_TYPE:
        AnnotatedTypeTree tr = (AnnotatedTypeTree) tree;
        ExpressionTree undtr = tr.getUnderlyingType();
        if (undtr instanceof ParameterizedTypeTree) {
          typeargtree = (ParameterizedTypeTree) undtr;
        } else if (undtr instanceof IdentifierTree) {
          // @Something D -> Nothing to do
        } else {
          // TODO: add more test cases to ensure that nested types are
          // handled correctly,
          // e.g. @Nullable() List<@Nullable Object>[][]
          Pair<ParameterizedTypeTree, AnnotatedDeclaredType> p =
              extractParameterizedTypeTree(undtr, type);
          typeargtree = p.first;
          type = p.second;
        }
        break;
      case IDENTIFIER:
      case ARRAY_TYPE:
      case NEW_ARRAY:
      case MEMBER_SELECT:
      case UNBOUNDED_WILDCARD:
      case EXTENDS_WILDCARD:
      case SUPER_WILDCARD:
      case TYPE_PARAMETER:
        // Nothing to do.
        // System.out.println("Found a: " + (tree instanceof
        // ParameterizedTypeTree));
        break;
      default:
        // the parameterized type is the result of some expression tree.
        // No need to do anything further.
        break;
        // System.err.printf("TypeValidator.visitDeclared unhandled tree: %s of kind %s\n",
        //                 tree, tree.getKind());
    }

    return Pair.of(typeargtree, type);
  }