private PrimitiveCheck getPrimitiveCheck(Type type) { if (!type.isPrimitive()) { return null; } for (PrimitiveCheck primitiveCheck : primitiveChecks) { if (type.isPrimitive(primitiveCheck.tag)) { return primitiveCheck; } } return null; }
private static Set<Type> primitiveWrappers(Set<Type> types) { if (types.stream().allMatch(Type::isPrimitive)) { return types; } return types.stream().map(t -> !t.isPrimitive() ? t : ((JavaType) t).primitiveWrapperType()).collect(Collectors.toCollection(LinkedHashSet::new)); }
private void checkShiftWithoutByteSecuring(ExpressionTree shiftExpr, ExpressionTree byteExpr) { if (shifts.contains(shiftExpr) && !byteContainments.contains(byteExpr) && byteExpr.symbolType().isPrimitive(Primitives.BYTE)) { context.reportIssue(this, byteExpr, "Prevent \"int\" promotion by adding \"& 0xff\" to this expression."); } }
private void checkExpression(ExpressionTree expression, Type implicitType) { if (implicitType.isPrimitive()) { checkForBoxing(expression); } else { checkForUnboxing(expression); } }
private void checkExpression(ExpressionTree expression, org.sonar.plugins.java.api.semantic.Type implicitType) { if (implicitType.isPrimitive()) { checkForBoxing(expression); } else { checkForUnboxing(expression); } }
private void checkExpression(ExpressionTree expression, Type implicitType) { if (implicitType.isPrimitive()) { checkForBoxing(expression); } else { checkForUnboxing(expression); } }
private static boolean isValidSerialVersionUid(Symbol.VariableSymbol serialVersionUidSymbol) { return serialVersionUidSymbol.isStatic() && serialVersionUidSymbol.isFinal() && serialVersionUidSymbol.type().isPrimitive(Type.Primitives.LONG); }
@Override public void visitNode(Tree tree) { if (!hasSemantic()) { return; } MethodTree methodTree = (MethodTree) tree; TypeTree returnType = methodTree.returnType(); if (returnType.symbolType().isPrimitive()) { findNullableAnnotation(methodTree) .ifPresent(annotation -> reportIssue(returnType, String.format("\"%s\" annotation should not be used on primitive types", annotation))); } }
private static boolean parameterCanBeNull(Symbol variableSymbol, boolean nullableParameters) { if (variableSymbol.type().isPrimitive()) { return false; } return isAnnotatedNullable(variableSymbol) || (nullableParameters && !isAnnotatedNonNull(variableSymbol)); }
private static boolean autoboxing(Type argumentType, Type collectionParameterType) { return argumentType.isPrimitive() && ((JavaType) collectionParameterType).isPrimitiveWrapper() && isSubtypeOf(((JavaType) argumentType).primitiveWrapperType(), collectionParameterType); } }
@Override public void visitNode(Tree tree) { ((ClassTree) tree).members() .stream() .filter(m -> m.is(Tree.Kind.VARIABLE)) .map(m -> ((VariableTree) m)) .filter(v -> ModifiersUtils.hasModifier(v.modifiers(), Modifier.VOLATILE)) .filter(v -> !v.type().symbolType().isPrimitive()) .forEach(v -> reportIssue(ModifiersUtils.getModifier(v.modifiers(), Modifier.VOLATILE), v.type(), getMessage(v))); }
private static boolean isSerializable(Type type) { if (type.isPrimitive()) { return true; } if (isSerializableArray(type)) { return true; } if (isParametrized(type)) { return isSerializableParametrized((ParametrizedTypeJavaType) type); } return type.isSubtypeOf("java.io.Serializable"); }
private static boolean isStaticNotVolatileObject(IdentifierTree variable) { Symbol symbol = variable.symbol(); if (symbol.isUnknown()) { return false; } return isStaticNotFinalNotVolatile(symbol) && !symbol.type().isPrimitive(); }
private static boolean isStaticNotVolatileObject(IdentifierTree variable) { Symbol symbol = variable.symbol(); if (symbol.isUnknown()) { return false; } return isStaticNotFinalNotVolatile(symbol) && !symbol.type().isPrimitive(); }
MethodInvariantContext(MethodTree methodTree) { this.methodTree = methodTree; TypeTree returnType = methodTree.returnType(); this.returnStatementTrees = extractReturnStatements(methodTree); methodToCheck = !isConstructorOrVoid(methodTree, returnType) && returnStatementTrees.size() > 1; returnImmutableType = methodToCheck && (returnType.symbolType().isPrimitive() || returnType.symbolType().is("java.lang.String")); }
MethodInvariantContext(MethodTree methodTree) { this.methodTree = methodTree; TypeTree returnType = methodTree.returnType(); this.returnStatementTrees = extractReturnStatements(methodTree); methodToCheck = !isConstructorOrVoid(methodTree, returnType) && returnStatementTrees.size() > 1; returnImmutableType = methodToCheck && (returnType.symbolType().isPrimitive() || returnType.symbolType().is("java.lang.String")); }
@Override public void visitNode(Tree tree) { SynchronizedStatementTree syncStatement = (SynchronizedStatementTree) tree; Type expressionType = syncStatement.expression().symbolType(); if (expressionType.isPrimitive() || isForbiddenType(expressionType)) { reportIssue(syncStatement.expression(), "Synchronize on a new \"Object\" instead."); } }
@Override public void visitTypeCast(TypeCastTree tree) { Type type = tree.type().symbolType(); if (type.isPrimitive()) { SymbolicValue sv = programState.peekValue(); if (isZero(sv)) { reuseSymbolicValue(sv); } else if (isNonZero(sv)) { deferConstraint(ZeroConstraint.NON_ZERO); } } }
private void checkVariable(VariableTree member) { if (ModifiersUtils.hasModifier(member.modifiers(), Modifier.FINAL)) { return; } ExpressionTree initializer = member.initializer(); if (initializer != null) { initializer = ExpressionUtils.skipParentheses(initializer); if (isDefault(initializer, member.type().symbolType().isPrimitive())) { reportIssue(initializer, "Remove this initialization to \"" + ((LiteralTree) initializer).value() + "\", the compiler will do that for you."); } } }
private void checkVariable(VariableTree member) { if (ModifiersUtils.hasModifier(member.modifiers(), Modifier.FINAL)) { return; } ExpressionTree initializer = member.initializer(); if (initializer != null) { initializer = ExpressionUtils.skipParentheses(initializer); if (isDefault(initializer, member.type().symbolType().isPrimitive())) { reportIssue(initializer, "Remove this initialization to \"" + ((LiteralTree) initializer).value() + "\", the compiler will do that for you."); } } }