@Override public UNewClass visitNewClass(NewClassTree tree, Void v) { return UNewClass.create( tree.getEnclosingExpression() == null ? null : template(tree.getEnclosingExpression()), templateTypeExpressions(tree.getTypeArguments()), template(tree.getIdentifier()), templateExpressions(tree.getArguments()), (tree.getClassBody() == null) ? null : visitClass(tree.getClassBody(), null)); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { // 1. Check any enclosing expression like a dereference JCExpression receiverTree = (JCExpression) tree.getEnclosingExpression(); if (receiverTree != null) { Description result = checkExpression( receiverTree, state, qual -> String.format( "Outer object %s for %s is %s null", receiverTree, tree.getIdentifier(), qual)); if (result != null) { return result; } } // 2. Check call arguments like a method call return checkCallArguments(tree.getArguments(), getSymbol(tree), state); }
@Override public Description matchNewClass(NewClassTree newClassTree, VisitorState state) { if (state.getPath().getParentPath().getLeaf().getKind() != Kind.EXPRESSION_STATEMENT) { return Description.NO_MATCH; if (newClassTree.getClassBody() == null) { return Description.NO_MATCH; if (!newClassTree.getArguments().isEmpty()) { return Description.NO_MATCH; for (Tree def : newClassTree.getClassBody().getMembers()) { switch (def.getKind()) { case VARIABLE: if (!sideEffectFreeConstructor(((JCTree) newClassTree.getIdentifier()).type.tsym, state)) { return Description.NO_MATCH;
int j = 0; for (Tree t : argTypes) { types[j++] = controller.getTrees().getTypeMirror(new TreePath(path, t)); Tree mid = mi.getMethodSelect(); path = new TreePath(path, mid); switch (mid.getKind()) { case MEMBER_SELECT: { final TypeMirror type = trees.getTypeMirror(path); final Element element = trees.getElement(path); final boolean isStatic = element != null && (element.getKind().isClass() || element.getKind().isInterface() || element.getKind() == TYPE_PARAMETER); SourcePositions sourcePositions = env.getSourcePositions(); int startPos = lastTree != null ? (int) sourcePositions.getStartPosition(root, lastTree) : offset; int pos = (int) sourcePositions.getEndPosition(root, nc.getIdentifier()); List<Tree> argTypes = getArgumentsUpToPos(env, nc.getArguments(), pos, startPos, false); if (argTypes != null) { controller.toPhase(JavaSource.Phase.RESOLVED); path = new TreePath(path, nc.getIdentifier()); if (type != null && type.getKind() == TypeKind.ERROR && path.getLeaf().getKind() == Tree.Kind.PARAMETERIZED_TYPE) { final boolean isAnonymous = nc.getClassBody() != null || (el != null && (el.getKind().isInterface() || el.getModifiers().contains(ABSTRACT))); ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { @Override
insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); boolean inImport = false; boolean insideNew = false; if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && ((ClassTree) parent).getExtendsClause() == fa) { kinds = EnumSet.of(CLASS); env.afterExtends(); } else if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && ((ClassTree) parent).getImplementsClause().contains(fa)) { kinds = EnumSet.of(INTERFACE); } else if (parent.getKind() == Tree.Kind.IMPORT) { inImport = true; kinds = ((ImportTree) parent).isStatic() ? EnumSet.of(CLASS, ENUM, INTERFACE, ANNOTATION_TYPE, FIELD, METHOD, ENUM_CONSTANT) : EnumSet.of(CLASS, ANNOTATION_TYPE, ENUM, INTERFACE); } else if (parent.getKind() == Tree.Kind.NEW_CLASS && ((NewClassTree) parent).getIdentifier() == fa) { insideNew = true; kinds = EnumSet.of(CLASS, INTERFACE, ANNOTATION_TYPE); break; if (parent.getKind() == Tree.Kind.NEW_CLASS && ((NewClassTree) parent).getIdentifier() == fa && prefix != null) { String typeName = controller.getElementUtilities().getElementName(el, true) + "." + prefix; //NOI18N TypeMirror tm = controller.getTreeUtilities().parseType(typeName, env.getScope().getEnclosingClass()); if (parent.getKind() == Tree.Kind.NEW_CLASS && ((NewClassTree) parent).getIdentifier() == fa && prefix != null) { String typeName = controller.getElementUtilities().getElementName(el, true) + "." + prefix; //NOI18N TypeMirror tm = controller.getTreeUtilities().parseType(typeName, env.getScope().getEnclosingClass());
controller.toPhase(Phase.RESOLVED); TypeElement tel = controller.getElements().getTypeElement("java.lang.Throwable"); //NOI18N DeclaredType base = path.getParentPath().getLeaf().getKind() == Tree.Kind.THROW && tel != null ? controller.getTypes().getDeclaredType(tel) : null; TypeElement toExclude = null; if (nc.getIdentifier().getKind() == Tree.Kind.IDENTIFIER && prefix != null) { TypeMirror tm = controller.getTreeUtilities().parseType(prefix, env.getScope().getEnclosingClass()); if (tm != null && tm.getKind() == TypeKind.DECLARED) { TypeElement te = (TypeElement) ((DeclaredType) tm).asElement(); addMembers(env, tm, te, EnumSet.of(CONSTRUCTOR), base, false, true, false); ExpressionTree encl = nc.getEnclosingExpression(); if (!options.contains(Options.ALL_COMPLETION)) { Set<? extends TypeMirror> smarts = getSmartTypes(env); } else if ((tm.getKind() == TypeKind.DECLARED || tm.getKind() == TypeKind.ERROR) && startsWith(env, ((DeclaredType) tm).asElement().getSimpleName().toString())) { results.add(itemFactory.createArrayItem(env.getController(), (ArrayType) smart, anchorOffset, env.getReferencesCount(), env.getController().getElements())); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE), base); } else { TypeMirror enclType = controller.getTrees().getTypeMirror(new TreePath(path, nc.getEnclosingExpression())); case GTGTGT: controller = env.getController(); TypeMirror tm = controller.getTrees().getTypeMirror(new TreePath(path, nc.getIdentifier())); addMembers(env, tm, ((DeclaredType) tm).asElement(), EnumSet.of(CONSTRUCTOR), null, false, false, false); break;
SourcePositions sp = trees.getSourcePositions(); Tree.Kind kind = node.getKind(); EditorContext.Operation op = null; if (kind.equals(Tree.Kind.METHOD_INVOCATION) || TreePath nodePath = trees.getPath(cu, node); if (nodePath != null && !ci.getTreeUtilities().isSynthetic(nodePath)) { Element methodElement = ci.getTrees().getElement(nodePath); boolean isNativeMethod = (methodElement != null) && methodElement.getModifiers().contains(Modifier.NATIVE); boolean getStartPosFromMethodLength = false; if (kind.equals(Tree.Kind.NEW_CLASS)) { identifier = ((NewClassTree) node).getIdentifier(); methodName = "<init>"; TreePath iPath = TreePath.getPath(cu, identifier); if (iPath == null) { return null; // No path to the identifier... if (type == null || type.getKind() == TypeKind.ERROR) { assert type.getKind() == TypeKind.DECLARED; TypeElement te = (TypeElement) types.asElement(type); methodClassType = ElementUtilities.getBinaryName(te); } else { if (type == null || type.getKind() == TypeKind.ERROR) {
CompilationUnitTree root = env.getRoot(); SourcePositions sourcePositions = env.getSourcePositions(); List<Tree> argTypes = getArgumentsUpToPos(env, nct.getArguments(), (int) sourcePositions.getEndPosition(root, nct.getIdentifier()), env.getOffset(), true); if (argTypes != null) { controller.toPhase(Phase.RESOLVED); int j = 0; for (Tree t : argTypes) { types[j++] = controller.getTrees().getTypeMirror(new TreePath(path, t)); path = new TreePath(path, nct.getIdentifier()); final Trees trees = controller.getTrees(); final TypeMirror type = trees.getTypeMirror(path); final Element el = trees.getElement(path); final Scope scope = env.getScope(); final boolean isAnonymous = nct.getClassBody() != null || (el != null && (el.getKind().isInterface() || el.getModifiers().contains(ABSTRACT))); ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { @Override
protected List<int[]> processImpl(CompilationInfo info, Preferences node, Document doc, int caretPosition) { caretPosition = info.getSnapshot().getEmbeddedOffset(caretPosition); TokenSequence<JavaTokenId> cts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language()); CompilationUnitTree cu = info.getCompilationUnit(); if (tp.getParentPath() != null && tp.getParentPath().getLeaf().getKind() == Kind.ANNOTATED_TYPE) { if (typePath != null && typePath.getParentPath().getLeaf().getKind() == Kind.METHOD) { && isIn(cu, info.getTrees().getSourcePositions(), type, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); && isIn(cu, info.getTrees().getSourcePositions(), exc, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); if (typePath != null && ((typePath.getParentPath().getLeaf().getKind() == Kind.UNION_TYPE int bodyStart = Utilities.findBodyStart(info, ctree, cu, info.getTrees().getSourcePositions(), doc); TreePath c = new TreePath(tp.getParentPath(), ((NewClassTree) tp.getParentPath().getLeaf()).getIdentifier()); setLocalUsages(fluq); try { for (Element element : el.getEnclosedElements()) { if (element.getModifiers().contains(Modifier.STATIC)) { for (Token t : fluq.findUsages(element, info, doc)) { bag.add(new int[] {t.offset(null), t.offset(null) + t.length()});
SourcePositions sp = trees.getSourcePositions(); if (!ci.getTreeUtilities().isSynthetic(ci.getTrees().getPath(cu, node))) { int pos = (int) sp.getStartPosition(cu, node); EditorContext.Position startPosition = boolean getStartPosFromMethodLength = false; if (kind.equals(Tree.Kind.NEW_CLASS)) { identifier = ((NewClassTree) node).getIdentifier(); methodName = "<init>"; TreePath iPath = TreePath.getPath(cu, identifier); TypeMirror type = trees.getTypeMirror(iPath); if (type.getKind() == TypeKind.ERROR) { assert type.getKind() == TypeKind.DECLARED; TypeElement te = (TypeElement) types.asElement(type); methodClassType = ElementUtilities.getBinaryName(te); } else { identifier = ((MethodInvocationTree) node).getMethodSelect(); if (identifier.getKind() == Tree.Kind.IDENTIFIER) { methodName = ((IdentifierTree) identifier).getName().toString(); TreePath iPath = TreePath.getPath(cu, identifier);
@Override public Void visitNewClass(NewClassTree node, Stack<Tree> p) { if (instantRename) { return super.visitNewClass(node, p); } Element el = info.getTrees().getElement(getCurrentPath()); if (toFind.equals(el) && node.getIdentifier() != null) { Token<JavaTokenId> t = Utilities.getToken(info, doc, new TreePath(getCurrentPath(), node.getIdentifier())); if (t != null) usages.add(t); return null; } if (el != null && toFind.equals(el.getEnclosingElement())) { return null; } return super.visitNewClass(node, p); }
Tree exp = tree.getEnclosingExpression(); if (exp instanceof IdentifierTree) { handlePossibleIdentifier(new TreePath(getCurrentPath(), exp), EnumSet.of(UseTypes.READ)); Tree ident = tree.getIdentifier(); if (ident.getKind() == Kind.PARAMETERIZED_TYPE) { tp = new TreePath(new TreePath(getCurrentPath(), ident), ((ParameterizedTypeTree) ident).getType()); } else { tp = new TreePath(getCurrentPath(), ident); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.EXECUTE), info.getTrees().getElement(getCurrentPath()), true, true); Element clazz = info.getTrees().getElement(tp); for (Tree expr : tree.getArguments()) { if (expr instanceof IdentifierTree) { handlePossibleIdentifier(new TreePath(getCurrentPath(), expr), EnumSet.of(UseTypes.READ)); scan(tree.getEnclosingExpression(), null); scan(tree.getIdentifier(), null); scan(tree.getTypeArguments(), null); scan(tree.getArguments(), EnumSet.of(UseTypes.READ)); scan(tree.getClassBody(), null);
String mname = memSelTree.getIdentifier().toString(); List<? extends ExpressionTree> params = mInvoke.getArguments(); int count = params.size(); Object[] argv = new Object[count]; String cname = null; Element elem = cinfo.getTrees().getElement(cinfo.getTrees().getPath(cinfo.getCompilationUnit(), memSelTree)); Object object = null; if(elem instanceof ExecutableElement) { Class cls = getClass(cinfo, newClassTree.getIdentifier()); if(cls == null) { return null; List<? extends ExpressionTree> params = newClassTree.getArguments(); int count = params.size(); Object[] argv = new Object[count]; Class[] argvt = new Class[count]; java.lang.reflect.Constructor ctor = null; Element elem = cinfo.getTrees().getElement(cinfo.getTrees().getPath(cinfo.getCompilationUnit(), newClassTree)); if(elem instanceof ExecutableElement) { ExecutableElement ctorElem = (ExecutableElement)elem;
private Description handleFileReader(NewClassTree tree, VisitorState state) { Tree arg = getOnlyElement(tree.getArguments()); Tree parent = state.getPath().getParentPath().getLeaf(); Tree toReplace = BUFFERED_READER.matches(parent, state) ? parent : tree; Description.Builder description = buildDescription(tree); fileReaderFix(description, state, arg, toReplace); return description.build(); }
boolean alreadyHandled = false; if (getCurrentPath().getParentPath().getLeaf().getKind() == Kind.NEW_CLASS) { NewClassTree nct = (NewClassTree) getCurrentPath().getParentPath().getLeaf(); alreadyHandled = nct.getTypeArguments().contains(tree) || nct.getIdentifier() == tree; if (getCurrentPath().getParentPath().getParentPath().getLeaf().getKind() == Kind.NEW_CLASS) { NewClassTree nct = (NewClassTree) getCurrentPath().getParentPath().getParentPath().getLeaf(); Tree leafToTest = getCurrentPath().getParentPath().getLeaf(); alreadyHandled = nct.getTypeArguments().contains(leafToTest) || nct.getIdentifier() == leafToTest;
List<String> keepingSideEffects = new ArrayList<>(); for (TreePath path = usageSite; !(path.getLeaf() instanceof StatementTree); path = path.getParentPath()) { List<? extends ExpressionTree> arguments; if (path.getLeaf() instanceof MethodInvocationTree) { arguments = ((MethodInvocationTree) path.getLeaf()).getArguments(); } else if (path.getLeaf() instanceof NewClassTree) { arguments = ((NewClassTree) path.getLeaf()).getArguments(); } else { continue;
.getArguments()); Tree toReplace = null; for (TreePath path = state.getPath().getParentPath(); path != null; path = path.getParentPath()) { Tree enclosing = path.getLeaf(); if (unmodifiableMatcher.matches(enclosing, state)) { unmodifiable = enclosing; if (immutableType.equals("ImmutableMap") && args.size() > 5) { String typeArguments = tree.getIdentifier() instanceof ParameterizedTypeTree ? ((ParameterizedTypeTree) tree.getIdentifier()) .getTypeArguments().stream() .map(state::getSourceForNode) state.getEndPosition(tree.getIdentifier()), state.getEndPosition(tree), "(" + replacement + ")");
Type type = types.unboxedTypeOrType(getType(tree)); if (types.isSameType(type, state.getSymtab().booleanType)) { Object value = literalValue(tree.getArguments().iterator().next()); if (value instanceof Boolean) { return SuggestedFix.replace(tree, literalFix((boolean) value, autoboxFix)); JCTree.JCExpression arg = (JCTree.JCExpression) getOnlyElement(tree.getArguments()); Type argType = getType(arg); if (autoboxFix && argType.isPrimitive()) { JCTree parent = (JCTree) state.getPath().getParentPath().getParentPath().getLeaf(); if (TO_STRING.matches(parent, state)) { String typeName = state.getSourceForNode(tree.getIdentifier()); DoubleAndFloatStatus doubleAndFloatStatus = doubleAndFloatStatus(state, type, argType); if (HASH_CODE.matches(parent, state)) {
StreamSupport.stream(path.spliterator(), false) .filter(tree -> tree instanceof ClassTree) .map(ClassTree.class::cast) PackageSymbol enclosingPackage = ((JCCompilationUnit) path.getCompilationUnit()).packge; Set<Modifier> modifiers = var.getModifiers(); path, (curr, parent) -> curr.getKind() == Kind.LAMBDA_EXPRESSION || (curr.getKind() == Kind.NEW_CLASS && ((NewClassTree) curr).getClassBody() != null) || (curr.getKind() == Kind.CLASS && parent.getKind() == Kind.BLOCK), (curr, unused) -> Objects.equals(var.owner, ASTHelpers.getSymbol(curr)))) { if ((var.flags() & (Flags.FINAL | Flags.EFFECTIVELY_FINAL)) == 0) {
private static Optional<Fix> stringBufferFix(VisitorState state) { Tree tree = state.getPath().getLeaf(); Tree parent = state.getPath().getParentPath().getLeaf(); if (!(parent instanceof VariableTree)) { return Optional.empty(); .replace(newClassTree.getIdentifier(), "StringBuilder") .replace(varTree.getType(), "StringBuilder") .build());