private static List<? extends TypeMirror> computeUnary(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    UnaryTree tree = (UnaryTree) parent.getLeaf();

    if (tree.getExpression() == error) {
      List<? extends TypeMirror> parentTypes =
          resolveType(types, info, parent.getParentPath(), tree, offset, null, null);

      if (parentTypes != null) {
        // may contain only "void", ignore:
        if (parentTypes.size() != 1) {
          return parentTypes;
        }
        if (parentTypes.get(0).getKind() != TypeKind.VOID) {
          return parentTypes;
        }
      }

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

      return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.INT));
    }

    return null;
  }
  private static List<? extends TypeMirror> computeVariableDeclaration(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    VariableTree vt = (VariableTree) parent.getLeaf();

    if (vt.getInitializer() == error) {
      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return Collections.singletonList(
          info.getTrees().getTypeMirror(new TreePath(parent, vt.getType())));
    }

    TreePath context = parent.getParentPath();
    if (vt.getType() != error || context == null) {
      return null;
    }

    switch (context.getLeaf().getKind()) {
      case ENHANCED_FOR_LOOP:
        ExpressionTree iterableTree = ((EnhancedForLoopTree) context.getLeaf()).getExpression();
        TreePath iterablePath = new TreePath(context, iterableTree);
        TypeMirror type = getIterableGenericType(info, iterablePath);
        types.add(ElementKind.LOCAL_VARIABLE);
        return Collections.singletonList(type);
      default:
        types.add(ElementKind.CLASS);
        return Collections.<TypeMirror>emptyList();
    }
  }
  private static List<? extends TypeMirror> computeParametrizedType(
      Set<ElementKind> types,
      CompilationInfo info,
      TreePath parent,
      Tree error,
      int offset,
      TypeMirror[] typeParameterBound,
      int[] numTypeParameters) {
    ParameterizedTypeTree ptt = (ParameterizedTypeTree) parent.getLeaf();

    if (ptt.getType() == error) {
      Tree gpt = parent.getParentPath().getLeaf();
      if (TreeUtilities.CLASS_TREE_KINDS.contains(gpt.getKind())
          && ((ClassTree) gpt).getExtendsClause() == ptt) {
        types.add(ElementKind.CLASS);
      } else if (TreeUtilities.CLASS_TREE_KINDS.contains(gpt.getKind())
          && ((ClassTree) gpt).getImplementsClause().contains(ptt)) {
        types.add(ElementKind.INTERFACE);
      } else {
        types.add(ElementKind.CLASS);
        types.add(ElementKind.INTERFACE);
      }

      if (numTypeParameters != null) {
        numTypeParameters[0] = ptt.getTypeArguments().size();
      }
      return null;
    }

    TypeMirror resolved = info.getTrees().getTypeMirror(parent);
    DeclaredType resolvedDT = null;

    if (resolved != null && resolved.getKind() == TypeKind.DECLARED) {
      resolvedDT = (DeclaredType) resolved;
    }

    int index = 0;

    for (Tree t : ptt.getTypeArguments()) {
      if (t == error) {
        if (resolvedDT != null && typeParameterBound != null) {
          List<? extends TypeMirror> typeArguments =
              ((DeclaredType) resolvedDT.asElement().asType()).getTypeArguments();

          if (typeArguments.size() > index) {
            typeParameterBound[0] = ((TypeVariable) typeArguments.get(index)).getUpperBound();
          }
        }

        types.add(ElementKind.CLASS); // XXX: class/interface/enum/annotation?
        return null;
      }

      index++;
    }

    return null;
  }
  private static TreePath findMethod(TreePath tp) {
    while (!STOP_LOOKING_FOR_METHOD.contains(tp.getLeaf().getKind())) {
      tp = tp.getParentPath();
    }

    if (tp.getLeaf().getKind() == Kind.METHOD) {
      return tp;
    }

    return null;
  }
 /**
  * Search up the hierarchy of elements for one of the given kind.
  *
  * @param kind the element's kind to search for
  * @param path the starting element
  * @return {@code null} if no element was found.
  */
 static TreePath getParentElementOfKind(Tree.Kind kind, TreePath path) {
   if (path != null) {
     TreePath tpath = path;
     while (tpath != null) {
       if (kind == tpath.getLeaf().getKind()) {
         return tpath;
       }
       tpath = tpath.getParentPath();
     }
   }
   return null;
 }
  /** {@inheritDoc} */
  @Override
  public boolean isSatisfiedBy(TreePath path) {
    do {
      Tree.Kind kind = path.getLeaf().getKind();
      if (kind == Tree.Kind.METHOD) return false;
      if (ASTPath.isClassEquiv(kind)) {
        return true;
      }
      path = path.getParentPath();
    } while (path != null && path.getLeaf() != null);

    return true;
  }
  @Override
  public List<ErrorDescription> run(CompilationInfo info, TreePath treePath) {
    Tree t = treePath.getLeaf();
    JTextComponent editor = EditorRegistry.lastFocusedComponent();
    Document doc = editor.getDocument();

    SourcePositions sp = info.getTrees().getSourcePositions();
    int start = (int) sp.getStartPosition(info.getCompilationUnit(), t);
    int end = (int) sp.getEndPosition(info.getCompilationUnit(), t);
    int endLine = info.getText().indexOf("\n", start);
    String line = info.getText().substring(start, endLine).trim();

    if (!Suppression.isSuppressed(line)) {
      return Collections.<ErrorDescription>singletonList(
          ErrorDescriptionFactory.createErrorDescription(
              Severity.HINT,
              ERROR_DESCRIPTION,
              createFixes(doc, start, endLine),
              info.getFileObject(),
              start,
              end));
    } else {
      return null;
    }
  }
  private static List<? extends TypeMirror> computeMethodInvocation(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    MethodInvocationTree nat = (MethodInvocationTree) parent.getLeaf();
    boolean errorInRealArguments = false;

    for (Tree param : nat.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]);
    }

    return null;
  }
  private static List<? extends TypeMirror> computeReturn(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ReturnTree rt = (ReturnTree) parent.getLeaf();

    if (rt.getExpression() == error) {
      TreePath method = findMethod(parent);

      if (method == null) {
        return null;
      }

      Element el = info.getTrees().getElement(method);

      if (el == null || el.getKind() != ElementKind.METHOD) {
        return null;
      }

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

      return Collections.singletonList(((ExecutableElement) el).getReturnType());
    }

    return null;
  }
  private static List<? extends TypeMirror> computeEnhancedForLoop(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    EnhancedForLoopTree efl = (EnhancedForLoopTree) parent.getLeaf();

    if (efl.getExpression() != error) {
      return null;
    }

    TypeMirror argument =
        info.getTrees()
            .getTypeMirror(
                new TreePath(new TreePath(parent, efl.getVariable()), efl.getVariable().getType()));

    if (argument == null) return null;

    if (argument.getKind().isPrimitive()) {
      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return Collections.singletonList(info.getTypes().getArrayType(argument));
    }

    TypeElement iterable = info.getElements().getTypeElement("java.lang.Iterable"); // NOI18N
    if (iterable == null) {
      return null;
    }

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

    return Collections.singletonList(info.getTypes().getDeclaredType(iterable, argument));
  }
  private static List<? extends TypeMirror> computeParenthesis(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ParenthesizedTree pt = (ParenthesizedTree) parent.getLeaf();

    if (pt.getExpression() != error) {
      return null;
    }

    TreePath parentParent = parent.getParentPath();
    List<? extends TypeMirror> upperTypes =
        resolveType(types, info, parentParent, pt, offset, null, null);

    if (upperTypes == null) {
      return null;
    }

    return upperTypes;
  }
  private static List<? extends TypeMirror> computeArrayAccess(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ArrayAccessTree aat = (ArrayAccessTree) parent.getLeaf();

    if (aat.getExpression() == error) {
      TreePath parentParent = parent.getParentPath();
      List<? extends TypeMirror> upperTypes =
          resolveType(types, info, parentParent, aat, offset, null, null);

      if (upperTypes == null) {
        return null;
      }

      List<TypeMirror> arrayTypes = new ArrayList<TypeMirror>();

      for (TypeMirror tm : upperTypes) {
        if (tm == null) continue;
        switch (tm.getKind()) {
          case VOID:
          case EXECUTABLE:
          case WILDCARD:
          case PACKAGE:
            continue;
        }

        arrayTypes.add(info.getTypes().getArrayType(tm));
      }

      if (arrayTypes.isEmpty()) return null;

      return arrayTypes;
    }

    if (aat.getIndex() == error) {
      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.INT));
    }

    return null;
  }
  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;
  }
  private static List<? extends TypeMirror> computeTypeParameter(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    TypeParameterTree tpt = (TypeParameterTree) parent.getLeaf();

    for (Tree t : tpt.getBounds()) {
      if (t == error) {
        types.add(ElementKind.CLASS); // XXX: class/interface/enum/annotation?
        return null;
      }
    }

    return null;
  }
  private static List<? extends TypeMirror> computeConditionalExpression(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ConditionalExpressionTree cet = (ConditionalExpressionTree) parent.getLeaf();

    if (cet.getCondition() == error) {
      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }

    if (cet.getTrueExpression() == error || cet.getFalseExpression() == error) {
      types.add(ElementKind.PARAMETER);
      types.add(ElementKind.LOCAL_VARIABLE);
      types.add(ElementKind.FIELD);

      return resolveType(types, info, parent.getParentPath(), cet, offset, null, null);
    }

    return null;
  }
  private static List<? extends TypeMirror> computeImport(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ImportTree tree = (ImportTree) parent.getLeaf();

    if (tree.getQualifiedIdentifier() == error) {
      types.add(ElementKind.ANNOTATION_TYPE);
      types.add(ElementKind.CLASS);
      types.add(ElementKind.ENUM);
      types.add(ElementKind.INTERFACE);

      return Collections.singletonList(
          info.getElements().getTypeElement("java.lang.Object").asType());
    }

    return null;
  }
  private static List<? extends TypeMirror> computeAssert(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssertTree at = (AssertTree) parent.getLeaf();

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

    if (at.getCondition() == error) {
      return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }

    if (at.getDetail() == error) {
      return Collections.singletonList(
          info.getElements().getTypeElement("java.lang.Object").asType());
    }

    return null;
  }
  private static List<? extends TypeMirror> computeAssignment(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssignmentTree at = (AssignmentTree) parent.getLeaf();
    TypeMirror type = null;

    if (at.getVariable() == error) {
      type = info.getTrees().getTypeMirror(new TreePath(parent, at.getExpression()));

      if (type != null) {
        // anonymous class?
        type = org.netbeans.modules.java.hints.errors.Utilities.convertIfAnonymous(type);

        if (type.getKind() == TypeKind.EXECUTABLE) {
          // TODO: does not actualy work, attempt to solve situations like:
          // t = Collections.emptyList()
          // t = Collections.<String>emptyList();
          // see also testCreateFieldMethod1 and testCreateFieldMethod2 tests:
          type = ((ExecutableType) type).getReturnType();
        }
      }
    }

    if (at.getExpression() == error) {
      type = info.getTrees().getTypeMirror(new TreePath(parent, at.getVariable()));
    }

    // class or field:
    if (type == null) {
      if (ErrorHintsProvider.ERR.isLoggable(ErrorManager.INFORMATIONAL)) {
        ErrorHintsProvider.ERR.log(ErrorManager.INFORMATIONAL, "offset=" + offset);
        ErrorHintsProvider.ERR.log(ErrorManager.INFORMATIONAL, "errorTree=" + error);
        ErrorHintsProvider.ERR.log(ErrorManager.INFORMATIONAL, "type=null");
      }

      return null;
    }

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

    return Collections.singletonList(type);
  }
  private static List<? extends TypeMirror> computeMemberSelect(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    // class or field:
    MemberSelectTree ms = (MemberSelectTree) parent.getLeaf();
    final TypeElement jlObject = info.getElements().getTypeElement("java.lang.Object");

    if (jlObject != null // may happen if the platform is broken
        && !"class"
            .equals(
                ms.getIdentifier()
                    .toString())) { // we obviously should not propose "Create Field" for
      // unknown.class:
      types.add(ElementKind.FIELD);
      types.add(ElementKind.CLASS);
      return Collections.singletonList(jlObject.asType());
    }

    return null;
  }
  private static List<? extends TypeMirror> computeClass(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    ClassTree ct = (ClassTree) parent.getLeaf();

    if (ct.getExtendsClause() == error) {
      types.add(ElementKind.CLASS);
      return null;
    }

    for (Tree t : ct.getImplementsClause()) {
      if (t == error) {
        types.add(ElementKind.INTERFACE);
        return null;
      }
    }

    // XXX: annotation types...

    return null;
  }
  /**
   * In the first enclosing class, find the top-level member that contains tree. TODO: should we
   * look whether these elements are enclosed within another class that is itself under
   * construction.
   *
   * <p>Are there any other type of top level objects?
   */
  private Tree findTopLevelClassMemberForTree(TreePath path) {
    ClassTree enclosingClass = TreeUtils.enclosingClass(path);
    if (enclosingClass != null) {

      List<? extends Tree> classMembers = enclosingClass.getMembers();
      TreePath searchPath = path;
      while (searchPath.getParentPath() != null && searchPath.getParentPath() != enclosingClass) {
        searchPath = searchPath.getParentPath();
        if (classMembers.contains(searchPath.getLeaf())) {
          return searchPath.getLeaf();
        }
      }
    }
    return null;
  }
  private static List<? extends TypeMirror> computeBinaryOperator(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    BinaryTree bt = (BinaryTree) parent.getLeaf();
    TreePath typeToResolve = null;

    if (bt.getLeftOperand() == error) {
      typeToResolve = new TreePath(parent, bt.getRightOperand());
    }

    if (bt.getRightOperand() == error) {
      typeToResolve = new TreePath(parent, bt.getLeftOperand());
    }

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

    return typeToResolve != null
        ? Collections.singletonList(info.getTrees().getTypeMirror(typeToResolve))
        : null;
  }
  private static List<? extends TypeMirror> computeNewArray(
      Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    NewArrayTree nat = (NewArrayTree) parent.getLeaf();

    if (nat.getType() == error) {
      types.add(ElementKind.CLASS);
      types.add(ElementKind.ENUM);
      types.add(ElementKind.INTERFACE);

      return null;
    }

    for (Tree dimension : nat.getDimensions()) {
      if (dimension == error) {
        types.add(ElementKind.PARAMETER);
        types.add(ElementKind.LOCAL_VARIABLE);
        types.add(ElementKind.FIELD);

        return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.INT));
      }
    }

    for (Tree init : nat.getInitializers()) {
      if (init == error) {
        TypeMirror whole = info.getTrees().getTypeMirror(parent);

        if (whole == null || whole.getKind() != TypeKind.ARRAY) return null;

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

        return Collections.singletonList(((ArrayType) whole).getComponentType());
      }
    }

    return null;
  }
Example #24
0
  private JCCompilationUnit toUnit(Element element) {
    TreePath path = trees == null ? null : trees.getPath(element);
    if (path == null) return null;

    return (JCCompilationUnit) path.getCompilationUnit();
  }
 @Override
 public void apply(TreePath path, Context context, DescriptionListener listener) {
   RefasterScanner.create(this, listener)
       .scan(path, prepareContext(context, (JCCompilationUnit) path.getCompilationUnit()));
 }
  public static List<? extends TypeMirror> resolveType(
      Set<ElementKind> types,
      CompilationInfo info,
      TreePath currentPath,
      Tree unresolved,
      int offset,
      TypeMirror[] typeParameterBound,
      int[] numTypeParameters) {
    switch (currentPath.getLeaf().getKind()) {
      case METHOD:
        return computeMethod(types, info, currentPath, typeParameterBound, unresolved, offset);
      case MEMBER_SELECT:
        return computeMemberSelect(types, info, currentPath, unresolved, offset);
      case ASSIGNMENT:
        return computeAssignment(types, info, currentPath, unresolved, offset);
      case ENHANCED_FOR_LOOP:
        return computeEnhancedForLoop(types, info, currentPath, unresolved, offset);
      case ARRAY_ACCESS:
        return computeArrayAccess(types, info, currentPath, unresolved, offset);
      case VARIABLE:
        return computeVariableDeclaration(types, info, currentPath, unresolved, offset);
      case ASSERT:
        return computeAssert(types, info, currentPath, unresolved, offset);
      case PARENTHESIZED:
        return computeParenthesis(types, info, currentPath, unresolved, offset);
      case DO_WHILE_LOOP:
        return computePrimitiveType(
            types,
            info,
            ((DoWhileLoopTree) currentPath.getLeaf()).getCondition(),
            unresolved,
            TypeKind.BOOLEAN);
      case FOR_LOOP:
        return computePrimitiveType(
            types,
            info,
            ((ForLoopTree) currentPath.getLeaf()).getCondition(),
            unresolved,
            TypeKind.BOOLEAN);
      case IF:
        return computePrimitiveType(
            types,
            info,
            ((IfTree) currentPath.getLeaf()).getCondition(),
            unresolved,
            TypeKind.BOOLEAN);
      case WHILE_LOOP:
        return computePrimitiveType(
            types,
            info,
            ((WhileLoopTree) currentPath.getLeaf()).getCondition(),
            unresolved,
            TypeKind.BOOLEAN);
      case SYNCHRONIZED:
        return computeReferenceType(
            types,
            info,
            ((SynchronizedTree) currentPath.getLeaf()).getExpression(),
            unresolved,
            "java.lang.Object");
      case THROW:
        return computeReferenceType(
            types,
            info,
            ((ThrowTree) currentPath.getLeaf()).getExpression(),
            unresolved,
            "java.lang.Exception");
      case INSTANCE_OF:
        return computeReferenceType(
            types,
            info,
            ((InstanceOfTree) currentPath.getLeaf()).getExpression(),
            unresolved,
            "java.lang.Object");
      case SWITCH:
        // TODO: should consider also values in the cases?:
        return computePrimitiveType(
            types,
            info,
            ((SwitchTree) currentPath.getLeaf()).getExpression(),
            unresolved,
            TypeKind.INT);
      case EXPRESSION_STATEMENT:
        return Collections.singletonList(info.getTypes().getNoType(TypeKind.VOID));

      case RETURN:
        return computeReturn(types, info, currentPath, unresolved, offset);
      case TYPE_PARAMETER:
        return computeTypeParameter(types, info, currentPath, unresolved, offset);
      case PARAMETERIZED_TYPE:
        return computeParametrizedType(
            types, info, currentPath, unresolved, offset, typeParameterBound, numTypeParameters);
      case ANNOTATION_TYPE:
      case CLASS:
      case ENUM:
      case INTERFACE:
        return computeClass(types, info, currentPath, unresolved, offset);

      case CONDITIONAL_EXPRESSION:
        return computeConditionalExpression(types, info, currentPath, unresolved, offset);

      case NEW_ARRAY:
        return computeNewArray(types, info, currentPath, unresolved, offset);

      case METHOD_INVOCATION:
        return computeMethodInvocation(types, info, currentPath, unresolved, offset);

      case NEW_CLASS:
        return computeNewClass(types, info, currentPath, unresolved, offset);

      case POSTFIX_INCREMENT:
      case POSTFIX_DECREMENT:
      case PREFIX_INCREMENT:
      case PREFIX_DECREMENT:
      case UNARY_PLUS:
      case UNARY_MINUS:
      case BITWISE_COMPLEMENT:
      case LOGICAL_COMPLEMENT:
        return computeUnary(types, info, currentPath, unresolved, offset);

      case MULTIPLY:
      case DIVIDE:
      case REMAINDER:
      case PLUS:
      case MINUS:
      case LEFT_SHIFT:
      case RIGHT_SHIFT:
      case UNSIGNED_RIGHT_SHIFT:
      case LESS_THAN:
      case GREATER_THAN:
      case LESS_THAN_EQUAL:
      case GREATER_THAN_EQUAL:
      case EQUAL_TO:
      case NOT_EQUAL_TO:
      case AND:
      case XOR:
      case OR:
      case CONDITIONAL_AND:
      case CONDITIONAL_OR:
        return computeBinaryOperator(types, info, currentPath, unresolved, offset);

      case MULTIPLY_ASSIGNMENT:
      case DIVIDE_ASSIGNMENT:
      case REMAINDER_ASSIGNMENT:
      case PLUS_ASSIGNMENT:
      case MINUS_ASSIGNMENT:
      case LEFT_SHIFT_ASSIGNMENT:
      case RIGHT_SHIFT_ASSIGNMENT:
      case UNSIGNED_RIGHT_SHIFT_ASSIGNMENT:
      case AND_ASSIGNMENT:
      case XOR_ASSIGNMENT:
      case OR_ASSIGNMENT:
        // XXX: return computeCompoundAssignment(types, info, currentPath, unresolved, offset);
        return null;

      case ARRAY_TYPE:
        return computeArrayType(types, info, currentPath, unresolved, offset);

      case IMPORT:
        return computeImport(types, info, currentPath, unresolved, offset);

      case BLOCK:
      case BREAK:
      case CATCH:
      case COMPILATION_UNIT:
      case CONTINUE:
      case IDENTIFIER:
      case TYPE_CAST:
      case TRY:
      case EMPTY_STATEMENT:
      case PRIMITIVE_TYPE:
      case LABELED_STATEMENT:
      case MODIFIERS:
      case ERRONEOUS:
      case OTHER:
      case INT_LITERAL:
      case LONG_LITERAL:
      case FLOAT_LITERAL:
      case DOUBLE_LITERAL:
      case BOOLEAN_LITERAL:
      case CHAR_LITERAL:
      case STRING_LITERAL:
      case NULL_LITERAL:
        // ignored:
        return null;

      case CASE:
      case ANNOTATION:
      case UNBOUNDED_WILDCARD:
      case EXTENDS_WILDCARD:
      case SUPER_WILDCARD:
        // XXX: currently unhandled
        return null;

      default:
        // should not happen unless set of Tree.Kind changes:
        return null;
    }
  }
Example #27
0
 /**
  * Given a TreePath, walks up the tree until it finds a node of the given type and returns the
  * path from that node to the top-level node in the path (typically a {@code
  * CompilationUnitTree}).
  */
 public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
   while (path != null && !(klass.isInstance(path.getLeaf()))) {
     path = path.getParentPath();
   }
   return path;
 }
 /** {@inheritDoc} */
 @Override
 public boolean isSatisfiedBy(TreePath path, Tree leaf) {
   assert path == null || path.getLeaf() == leaf;
   return isSatisfiedBy(path);
 }
  private static List<? extends TypeMirror> computeMethod(
      Set<ElementKind> types,
      CompilationInfo info,
      TreePath parent,
      TypeMirror[] typeParameterBound,
      Tree error,
      int offset) {
    // class or field:
    // check the error is in the body:
    // #92419: check for abstract method/method without body:
    MethodTree mt = (MethodTree) parent.getLeaf();

    if (mt.getReturnType() == error) {
      types.add(ElementKind.CLASS);
      types.add(ElementKind.INTERFACE);
      types.add(ElementKind.ENUM);
    }

    List<? extends ExpressionTree> throwList = mt.getThrows();
    if (throwList != null && !throwList.isEmpty()) {
      for (ExpressionTree t : throwList) {
        if (t == error) {
          types.add(ElementKind.CLASS);
          typeParameterBound[0] = info.getElements().getTypeElement("java.lang.Exception").asType();
          break;
        }
      }
    }

    if (mt.getBody() == null) {
      return null;
    }

    try {
      Document doc = info.getDocument();

      if (doc != null) { // XXX
        int bodyStart =
            Utilities.findBodyStart(
                parent.getLeaf(),
                info.getCompilationUnit(),
                info.getTrees().getSourcePositions(),
                doc);
        int bodyEnd =
            (int)
                info.getTrees()
                    .getSourcePositions()
                    .getEndPosition(info.getCompilationUnit(), parent.getLeaf());

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

        if (bodyStart <= offset && offset <= bodyEnd)
          return Collections.singletonList(
              info.getElements().getTypeElement("java.lang.Object").asType());
      }
    } catch (IOException ex) {
      Logger.getLogger("global").log(Level.INFO, ex.getMessage(), ex);
    }

    return null;
  }
Example #30
0
 /** Given a TreePath, walks up the tree until it finds a node of the given type. */
 public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
   path = findPathFromEnclosingNodeToTopLevel(path, klass);
   return (path == null) ? null : klass.cast(path.getLeaf());
 }