@Override public Type get(VisitorState state) { return state.getTypeFromString(typeString); } };
@Override public Type get(VisitorState state) { return state.getTypeFromString("java.lang.Boolean"); } };
@Override public Type get(VisitorState state) { return state.getTypeFromString("java.lang.Void"); } };
@Override public boolean apply(Type type, VisitorState state) { Type stream = state.getTypeFromString("java.util.stream.Stream"); return ASTHelpers.isSubtype(type, stream, state); } };
@Override protected boolean isBadType(Type type, VisitorState state) { return ASTHelpers.isSubtype( type, state.getTypeFromString("com.google.protobuf.GeneratedMessage"), state); } }
@Override public void onMatchTopLevelClass( NullAway analysis, ClassTree tree, VisitorState state, Symbol.ClassSymbol classSymbol) { if (tbaseType == null) { tbaseType = Optional.ofNullable(state.getTypeFromString(TBASE_NAME)).map(state.getTypes()::erasure); } }
private boolean matchesType(Type type, VisitorState state) { return typeNames.stream() .anyMatch(typeName -> isSameType(type, state.getTypeFromString(typeName), state)); }
static boolean isThrowingFunctionalInterface(VisitorState state, Type clazzType) { return CLASSES_CONSIDERED_THROWING.stream() .anyMatch(t -> ASTHelpers.isSubtype(clazzType, state.getTypeFromString(t), state)); }
@Override protected boolean matchArgument(ExpressionTree tree, VisitorState state) { Type type = ASTHelpers.getType(tree); for (String className : OPTIONAL_CLASSES) { if (ASTHelpers.isSameType(type, state.getTypeFromString(className), state)) { return true; } } return false; } }
private boolean sideEffectFreeConstructor(TypeSymbol classType, VisitorState state) { if (classType.isInterface()) { return true; } for (String typeName : TYPE_WHITELIST) { if (ASTHelpers.isSameType(classType.type, state.getTypeFromString(typeName), state)) { return true; } } return false; } }
private static boolean hasFunctionAsArg(Tree param, VisitorState state) { return ASTHelpers.isSameType( ASTHelpers.getType(param), state.getTypeFromString(JAVA_UTIL_FUNCTION_FUNCTION), state); }
@Override public boolean matches(MethodInvocationTree tree, VisitorState state) { List<VarSymbol> parameters = ASTHelpers.getSymbol(tree).getParameters(); if (parameters.size() != 3) { return false; } return ASTHelpers.isSameType( parameters.get(0).asType(), state.getTypeFromString("java.lang.String"), state) && ASTHelpers.isSameType( parameters.get(1).asType(), parameters.get(2).asType(), state); } };
/** Convert a {@code String} or {@code File} argument to a {@code Path}. */ private String toPath(VisitorState state, Tree fileArg, SuggestedFix.Builder fix) { Type type = ASTHelpers.getType(fileArg); if (ASTHelpers.isSubtype(type, state.getSymtab().stringType, state)) { fix.addImport("java.nio.file.Paths"); return String.format("Paths.get(%s)", state.getSourceForNode(fileArg)); } else if (ASTHelpers.isSubtype(type, state.getTypeFromString("java.io.File"), state)) { return String.format("%s.toPath()", state.getSourceForNode(fileArg)); } else { throw new AssertionError("unexpected type: " + type); } }
/** Converts a {@code String} to a {@code File}. */ private Object toFile(VisitorState state, Tree fileArg, SuggestedFix.Builder fix) { Type type = ASTHelpers.getType(fileArg); if (ASTHelpers.isSubtype(type, state.getSymtab().stringType, state)) { fix.addImport("java.io.File"); return String.format("new File(%s)", state.getSourceForNode(fileArg)); } else if (ASTHelpers.isSubtype(type, state.getTypeFromString("java.io.File"), state)) { return state.getSourceForNode(fileArg); } else { throw new AssertionError("unexpected type: " + type); } }
private boolean isIgnoredReturnType(JCMethodDecl method, VisitorState state) { Type returnType = method.sym.getReturnType(); // Methods returning a primitive cannot return null. Also ignore Void-returning methods as // the only valid Void value is null, so it's implied. // TODO(kmb): Technically we should assume NULL when we see a call to a method that returns Void return returnType.isPrimitiveOrVoid() || state.getTypes().isSameType(returnType, state.getTypeFromString("java.lang.Void")); }
@Override public Description matchClass(ClassTree tree, VisitorState state) { Tree extendsClause = tree.getExtendsClause(); Type type = ASTHelpers.getType(extendsClause); if (ASTHelpers.isSameType(type, state.getTypeFromString("org.junit.Assert"), state)) { return describeMatch(extendsClause, fixAsserts(tree, state)); } return Description.NO_MATCH; }
@Override protected boolean matchArgument(ExpressionTree tree, VisitorState state) { if (!ASTHelpers.isSubtype( ASTHelpers.getType(tree), state.getTypeFromString("java.lang.Number"), state)) { return false; } Symbol sym = ASTHelpers.getSymbol(tree); if (sym instanceof Symbol.VarSymbol && isFinal(sym) && sym.isStatic()) { // Using a static final field as a sentinel is OK return false; } return true; }
@Override public Boolean visitMethod(MethodTree node, VisitorState state) { boolean prevInBoxedVoidReturningMethod = inBoxedVoidReturningMethod; Type returnType = ASTHelpers.getType(node.getReturnType()); Type boxedVoidType = state.getTypeFromString("java.lang.Void"); if (ASTHelpers.isSameType(returnType, boxedVoidType, state)) { inBoxedVoidReturningMethod = true; } boolean result = node.getBody() != null && node.getBody().accept(this, state); inBoxedVoidReturningMethod = prevInBoxedVoidReturningMethod; return result; }
@Override public Description matchVariable(VariableTree tree, VisitorState state) { if (!hasAnnotation(getSymbol(tree), "org.junit.Rule", state)) { return NO_MATCH; } if (!isSameType( getType(tree), state.getTypeFromString("org.junit.rules.ExpectedException"), state)) { return NO_MATCH; } return describeMatch(tree, SuggestedFix.delete(tree)); } }
/** * Checks that the return value of a functional interface is void. Note, we do not use * ASTHelpers.isVoidType here, return values of Void are actually type-checked. Only * void-returning functions silently ignore return values of any type. */ private static boolean functionalInterfaceReturnsObject(Type interfaceType, VisitorState state) { Type objectType = state.getTypeFromString("java.lang.Object"); return ASTHelpers.isSubtype( objectType, ASTHelpers.getUpperBound( state.getTypes().findDescriptorType(interfaceType).getReturnType(), state.getTypes()), state); }