private void buildNewClass(NewClassTree tree) { currentBlock.elements.add(tree); ExpressionTree enclosingExpression = tree.enclosingExpression(); if (enclosingExpression != null) { build(enclosingExpression); } build(Lists.reverse(tree.arguments())); }
private static Symbol.TypeSymbol wrapperClassSymbol(NewClassTree newClassTree) { Symbol.TypeSymbol classSymbol = newClassTree.symbolType().symbol(); if (PRIMITIVE_TYPES_BY_WRAPPER.containsKey(newClassTree.symbolType().fullyQualifiedName()) && !newClassTree.arguments().isEmpty()) { return classSymbol; } return null; }
@Override public void visitNewClass(NewClassTree tree) { if (TARGETED_CLASS.contains(getclassName(tree)) && tree.arguments().size() == 1) { ExpressionTree argument = tree.arguments().get(0); if (argument.is(Tree.Kind.CHAR_LITERAL)) { String character = ((LiteralTree) argument).value(); context.reportIssue( this, argument, "Replace the constructor character parameter " + character + " with string parameter " + character.replace("'", "\"") + "."); } } }
@Override public void visitNewClass(NewClassTree syntaxNode) { final List<SymbolicValue> arguments = programState.peekValues(syntaxNode.arguments().size()); if (isOpeningResource(syntaxNode)) { Iterator<SymbolicValue> iterator = arguments.iterator(); for (ExpressionTree argument : syntaxNode.arguments()) { if (!iterator.hasNext()) { throw new IllegalStateException( "Mismatch between declared constructor arguments and argument values!"); } final Type type = argument.symbolType(); final SymbolicValue value = iterator.next(); if (isCloseable(type)) { constraintManager.setValueFactory(new WrappedValueFactory(value)); break; } } } else { closeArguments(syntaxNode.arguments(), 0); } }
private void checkForBoxing(ExpressionTree expression) { if (expression.is(Tree.Kind.NEW_CLASS)) { NewClassTree newClassTree = (NewClassTree) expression; Symbol.TypeSymbol classSymbol = wrapperClassSymbol(newClassTree); if (classSymbol != null) { ExpressionTree boxingArg = newClassTree.arguments().get(0); if (boxingArg.symbolType().isPrimitive()) { addBoxingIssue(newClassTree, classSymbol, boxingArg); } } } else if (expression.is(Tree.Kind.METHOD_INVOCATION)) { MethodInvocationTree methodInvocationTree = (MethodInvocationTree) expression; if (isValueOfInvocation(methodInvocationTree)) { ExpressionTree boxingArg = methodInvocationTree.arguments().get(0); addBoxingIssue(expression, methodInvocationTree.symbol().owner(), boxingArg); } } }
@Override public void visitNode(Tree tree) { if (hasSemantic()) { if (tree.is(Tree.Kind.METHOD_INVOCATION)) { visitMethodInvocationTree((MethodInvocationTree) tree); } else if (tree.is(Tree.Kind.VARIABLE)) { VariableTree variableTree = (VariableTree) tree; ExpressionTree initializer = variableTree.initializer(); if (initializer != null) { checkExpression(initializer, variableTree.type().symbolType()); } } else if (tree.is(Tree.Kind.ASSIGNMENT)) { AssignmentExpressionTree assignmentTree = (AssignmentExpressionTree) tree; checkExpression(assignmentTree.expression(), assignmentTree.symbolType()); } else { NewClassTree newClassTree = (NewClassTree) tree; Symbol.TypeSymbol classSymbol = wrapperClassSymbol(newClassTree); if (classSymbol != null) { checkForUnboxing(newClassTree.arguments().get(0)); } } } }