private static Matcher<IdentifierTree> identifierHasName(final String name) { return (item, state) -> item.getName().contentEquals(name); }
private static Optional<String> getEnumName(ExpressionTree chronoField) { if (chronoField instanceof IdentifierTree) { // e.g., SECOND_OF_DAY return Optional.of(((IdentifierTree) chronoField).getName().toString()); } if (chronoField instanceof MemberSelectTree) { // e.g., ChronoField.SECOND_OF_DAY return Optional.of(((MemberSelectTree) chronoField).getIdentifier().toString()); } return Optional.empty(); } }
private static boolean isSuper(ExpressionTree tree) { return tree.getKind() == Kind.IDENTIFIER && ((IdentifierTree) tree).getName().contentEquals("super"); } }
private static Optional<String> getEnumName(ExpressionTree temporalUnit) { if (temporalUnit instanceof IdentifierTree) { // e.g., SECONDS return Optional.of(((IdentifierTree) temporalUnit).getName().toString()); } if (temporalUnit instanceof MemberSelectTree) { // e.g., ChronoUnit.SECONDS return Optional.of(((MemberSelectTree) temporalUnit).getIdentifier().toString()); } return Optional.empty(); } }
@Override public Void visitIdentifier(IdentifierTree node, Void unused) { checkForThis(node, node.getName(), thisClass, state); return super.visitIdentifier(node, null); }
private static boolean isIdentifierWithName(ExpressionTree tree, String name) { return tree.getKind() == IDENTIFIER && ((IdentifierTree) tree).getName().contentEquals(name); }
private static boolean hasSimpleName(AnnotationTree annotation, String name) { Tree annotationType = annotation.getAnnotationType(); javax.lang.model.element.Name simpleName; if (annotationType instanceof IdentifierTree) { simpleName = ((IdentifierTree) annotationType).getName(); } else if (annotationType instanceof MemberSelectTree) { simpleName = ((MemberSelectTree) annotationType).getIdentifier(); } else { return false; } return simpleName.contentEquals(name); }
@Override public Void visitIdentifier(IdentifierTree node, CastState state) { if (state.name.equals(node.getName())) { state.fix.replace(node, "((" + state.castToType + ") " + state.name + ")"); } return super.visitIdentifier(node, state); } }
@Override public boolean matches(ExpressionTree thisExpression, VisitorState state) { if (thisExpression.getKind().equals(Kind.IDENTIFIER)) { IdentifierTree identifier = (IdentifierTree) thisExpression; if (identifier.getName().contentEquals("this")) { return true; } } return false; } }
@Override public Symbol resolveTypeLiteral(ExpressionTree expr) { checkGuardedBy(expr instanceof IdentifierTree, "bad type literal: %s", expr); IdentifierTree ident = (IdentifierTree) expr; Symbol type = resolveType(ident.getName().toString(), SearchSuperTypes.YES); if (type instanceof Symbol.ClassSymbol) { return type; } return null; }
@Override public Symbol resolveEnclosingClass(ExpressionTree expr) { checkGuardedBy(expr instanceof IdentifierTree, "bad type literal: %s", expr); IdentifierTree ident = (IdentifierTree) expr; Symbol type = resolveType(ident.getName().toString(), SearchSuperTypes.NO); if (type instanceof Symbol.ClassSymbol) { return type; } return null; } }
private static Optional<TimeUnit> getTimeUnit(ExpressionTree timeUnit) { if (timeUnit instanceof IdentifierTree) { // e.g., SECONDS return Enums.getIfPresent(TimeUnit.class, ((IdentifierTree) timeUnit).getName().toString()); } if (timeUnit instanceof MemberSelectTree) { // e.g., TimeUnit.SECONDS return Enums.getIfPresent( TimeUnit.class, ((MemberSelectTree) timeUnit).getIdentifier().toString()); } return Optional.absent(); } }
private static boolean isThisIdentifier(ExpressionTree expressionTree) { return expressionTree.getKind().equals(IDENTIFIER) && ((IdentifierTree) expressionTree).getName().toString().equals("this"); }
boolean isThisAccess(Tree tree) { if (tree.getKind() == Kind.IDENTIFIER) { return true; } if (tree.getKind() != Kind.MEMBER_SELECT) { return false; } ExpressionTree selected = ((MemberSelectTree) tree).getExpression(); if (!(selected instanceof IdentifierTree)) { return false; } IdentifierTree ident = (IdentifierTree) selected; return ident.getName().contentEquals("this"); }
@Override public Void visitMemberSelect(MemberSelectTree node, Void unused) { checkForThis(node, node.getIdentifier(), thisClass, state); // Don't examine this.foo or MyClass.this.foo ExpressionTree left = node.getExpression(); if ((left instanceof IdentifierTree && ((IdentifierTree) left).getName().contentEquals("this")) || (left instanceof MemberSelectTree && ((MemberSelectTree) left).getIdentifier().contentEquals("this"))) { return null; } return super.visitMemberSelect(node, unused); }
private static boolean isOnThis(MethodInvocationTree tree) { ExpressionTree receiver = ASTHelpers.getReceiver(tree); if (receiver == null) { return true; } Name receiverName; switch (receiver.getKind()) { case IDENTIFIER: receiverName = ((IdentifierTree) receiver).getName(); break; case MEMBER_SELECT: receiverName = ((MemberSelectTree) receiver).getIdentifier(); break; default: return false; } return receiverName.contentEquals("this") || receiverName.contentEquals("super"); } }
@Override public Boolean visitMethodInvocation(MethodInvocationTree node, Void aVoid) { ExpressionTree receiver = ASTHelpers.getReceiver(node); return receiver instanceof IdentifierTree && ((IdentifierTree) receiver).getName().contentEquals("super") && overrides(ASTHelpers.getSymbol(method), ASTHelpers.getSymbol(node)); }
@Override public Choice<Unifier> visitIdentifier(IdentifierTree node, Unifier unifier) { Names names = Names.instance(unifier.getContext()); return node.getName().equals(names._super) ? Choice.<Unifier>none() : defaultAction(node, unifier); }
/** Returns true if this method invocation is of the form {@code super.foo()} */ private static boolean isSuperCall(Type type, MethodInvocationTree tree, VisitorState state) { if (tree.getMethodSelect().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree select = (MemberSelectTree) tree.getMethodSelect(); if (select.getExpression().getKind() == Kind.IDENTIFIER) { IdentifierTree ident = (IdentifierTree) select.getExpression(); return ident.getName().contentEquals("super"); } else if (select.getExpression().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree subSelect = (MemberSelectTree) select.getExpression(); return subSelect.getIdentifier().contentEquals("super") && ASTHelpers.isSameType(ASTHelpers.getType(subSelect.getExpression()), type, state); } } return false; }
@Override public Choice<Unifier> visitIdentifier(final IdentifierTree ident, Unifier unifier) { Symbol sym = ASTHelpers.getSymbol(ident); if (sym != null && sym.owner.type != null) { JCExpression thisIdent = unifier.thisExpression(sym.owner.type); return getIdentifier() .unify(ident.getName(), unifier) .thenChoose(unifications(getExpression(), thisIdent)) .thenChoose(unifications(type(), sym.asType())); } return Choice.none(); }