return false; Tree parent = path.getParentPath().getLeaf(); if (parent.getKind() != Tree.Kind.BLOCK) { return false; int idx = block.getStatements().indexOf(path.getLeaf()); if (idx == -1 || idx == block.getStatements().size() - 1) { return false; StatementTree next = block.getStatements().get(idx + 1); if (!(next instanceof TryTree)) { return false; tryTree .getFinallyBlock() .accept( new TreeScanner<Void, Void>() { @Override
@Override public boolean apply(Tree tree) { switch (tree.getKind()) { case CLASS: return ((ClassTree) tree).getModifiers().getFlags().contains(STATIC); case METHOD: return ((MethodTree) tree).getModifiers().getFlags().contains(STATIC); case VARIABLE: return ((VariableTree) tree).getModifiers().getFlags().contains(STATIC); case BLOCK: return ((BlockTree) tree).isStatic(); case ENUM: case ANNOTATION_TYPE: case INTERFACE: return true; default: throw new AssertionError("unknown member type:" + tree.getKind()); } } });
@Override public boolean matches(MethodTree method, VisitorState state) { List<? extends VariableTree> parameters = method.getParameters(); if (!parameters.isEmpty()) { return false; } BlockTree body = method.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } return EMPTY_SET.matches(((ReturnTree) onlyStatement).getExpression(), state); } };
if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; String type = variable.getType().toString(); if (type.endsWith("PropertyChangeSupport")) { // NOI18N alreadyUpdated[0] = true; TreeMaker make = wc.getTreeMaker(); ClassTree modifiedClass = clazz; Tree transientType = make.Type(transientMirror); AnnotationTree transientTree = make.Annotation(transientType, Collections.EMPTY_LIST); ModifiersTree modifiers = make.Modifiers(Modifier.PRIVATE, Collections.singletonList(transientTree)); BlockTree block = method.getBody(); if (block.getStatements().size() != 1) continue; StatementTree statement = block.getStatements().get(0); if (statement.getKind() != Tree.Kind.EXPRESSION_STATEMENT) continue; ExpressionTree expression = ((ExpressionStatementTree)statement).getExpression(); if (expression.getKind() != Tree.Kind.ASSIGNMENT) continue; if (!parameter.getName().toString().equals(parName)) continue; ExpressionTree persistentVariable = assignment.getVariable(); String parameterName = parameter.getName().toString();
@Override public Stream<TypeElement> localTypes(TypeElement tel) { final List<? extends Element> enclosedElements = tel.getEnclosedElements(); return Stream .concat(ElementFilter.constructorsIn(enclosedElements).stream() , ElementFilter.methodsIn(enclosedElements).stream()) .flatMap(exEl -> unNull(JTrees.getTree(exEl)) .flatMap(methodTree -> unNull(JTrees.getPath(exEl)) .flatMap(methodPath -> unNull(methodTree.getBody()) .flatMap(methodBody -> unNull(methodBody.getStatements()) .map(statements -> { final List<TypeElement> typeElts = ElementFilter.typesIn(statements .stream() .filter(OpenJdkSpecificApi::isClassDecl) .flatMap(cdl -> Opt .asStream(unNull(TreePath.getPath(methodPath, cdl)) .flatMap(path -> unNull(JTrees.getElement(path))))) .collect(Collectors.toList())); return typeElts.stream(); })))) .orElseGet(Stream::empty)); }
TreePath path = env.getPath(); while (path != null) { Tree tree = path.getLeaf(); if (tree.getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mi = (MethodInvocationTree) tree; CompilationUnitTree root = env.getRoot(); int j = 0; for (Tree t : argTypes) { types[j++] = controller.getTrees().getTypeMirror(new TreePath(path, t)); path = new TreePath(path, mid); switch (mid.getKind()) { case MEMBER_SELECT: { ExpressionTree exp = ((MemberSelectTree) mid).getExpression(); path = new TreePath(path, exp); final Trees trees = controller.getTrees(); 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); final boolean isSuperCall = element != null && element.getKind().isField() && element.getSimpleName().contentEquals(SUPER_KEYWORD); final Trees trees = controller.getTrees(); final TypeElement enclClass = scope.getEnclosingClass(); final boolean isStatic = enclClass != null ? (tu.isStaticContext(scope) || (env.getPath().getLeaf().getKind() == Tree.Kind.BLOCK && ((BlockTree) env.getPath().getLeaf()).isStatic())) : false; ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { @Override
private Env getEnvImpl(CompilationController controller, TreePath orig, TreePath path, TreePath pPath, TreePath gpPath, int offset, String prefix, boolean upToOffset) throws IOException { Tree tree = path != null ? path.getLeaf() : null; Tree parent = pPath != null ? pPath.getLeaf() : null; Tree grandParent = gpPath != null ? gpPath.getLeaf() : null; SourcePositions sourcePositions = controller.getTrees().getSourcePositions(); CompilationUnitTree root = controller.getCompilationUnit(); TreeUtilities tu = controller.getTreeUtilities(); if (upToOffset && TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())) { controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); return new Env(offset, prefix, controller, orig, sourcePositions, null); } else if (parent != null && tree.getKind() == Tree.Kind.BLOCK && (parent.getKind() == Tree.Kind.METHOD || TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()))) { controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); int blockPos = (int) sourcePositions.getStartPosition(root, tree); String blockText = controller.getText().substring(blockPos, upToOffset ? offset : (int) sourcePositions.getEndPosition(root, tree)); final SourcePositions[] sp = new SourcePositions[1]; final StatementTree block = (((BlockTree) tree).isStatic() ? tu.parseStaticBlock(blockText, sp) : tu.parseStatement(blockText, sp)); if (block == null) { return null; stmts = ((BlockTree) path.getLeaf()).getStatements(); break; case FOR_LOOP: final StatementTree block = (((BlockTree) blockPath.getLeaf()).isStatic() ? tu.parseStaticBlock(blockText, sp) : tu.parseStatement(blockText, sp)); if (block == null) { return null; stmts = ((BlockTree) path.getLeaf()).getStatements(); break;
type = controller.getTrees().getTypeMirror(new TreePath(path, ((AssignmentTree) tree).getVariable())); if (type == null) { return null; if (parentPath != null && parentPath.getLeaf().getKind() == Tree.Kind.ANNOTATION && type.getKind() == TypeKind.EXECUTABLE) { type = ((ExecutableType) type).getReturnType(); while (dim-- > 0) { return null; if (methodOrLambdaPath.getLeaf().getKind() == Tree.Kind.METHOD) { Tree retTree = ((MethodTree) methodOrLambdaPath.getLeaf()).getReturnType(); if (retTree == null) { return null; type = controller.getTrees().getTypeMirror(new TreePath(methodOrLambdaPath, retTree)); if (type == null && JavaSource.Phase.RESOLVED.compareTo(controller.getPhase()) > 0) { controller.toPhase(Phase.RESOLVED); for (ExpressionTree thr : ((MethodTree) methodPath.getLeaf()).getThrows()) { final Trees trs = controller.getTrees(); final TypeElement enclClass = scope.getEnclosingClass(); final boolean isStatic = enclClass != null ? (tu.isStaticContext(scope) || (env.getPath().getLeaf().getKind() == Tree.Kind.BLOCK && ((BlockTree) env.getPath().getLeaf()).isStatic())) : false; if (SUPER_KEYWORD.equals(name) && enclClass != null) { ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() {
Trees trees = Trees.instance(processingEnv); ClassTree tree = trees.getTree(el); if (member.getKind() == Tree.Kind.METHOD) { MethodTree m = (MethodTree) member; if (m.getName().toString().equals("<init>")) { BlockTree body = m.getBody(); List<? extends StatementTree> b = body.getStatements(); if (member.getKind() == Tree.Kind.VARIABLE) { VariableTree t = (VariableTree) member; if (t.getInitializer() != null) return false; if (member.getKind() == Tree.Kind.BLOCK) {
SourcePositions sourcePositions = info.getTrees().getSourcePositions(); TreePath path = pathFor(pos); CompilationUnitTree root = path.getCompilationUnit(); switch (path.getLeaf().getKind()) { case BLOCK: stmts = ((BlockTree)path.getLeaf()).getStatements(); break; case FOR_LOOP: break; case METHOD: stmts = ((MethodTree)path.getLeaf()).getParameters(); break; path = new TreePath(path, tree); Scope scope = info.getTrees().getScope(path); if (TreeUtilities.CLASS_TREE_KINDS.contains(path.getLeaf().getKind())) { TokenSequence<JavaTokenId> ts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language()); ts.move(pos);
return; TreeMaker tm = wc.getTreeMaker(); Tree tree = from; switch (from.getKind()) { case METHOD: tree = tm.setLabel(from, ((MethodTree)from).getName()); break; case VARIABLE: tree = tm.setLabel(from, ((VariableTree)from).getName()); break; case BLOCK: tree = tm.Block(((BlockTree)from).getStatements(), ((BlockTree)from).isStatic()); GeneratorUtilities gu = GeneratorUtilities.get(wc); gu.copyComments(from, tree, true); break; boolean before = (int)wc.getTrees().getSourcePositions().getStartPosition(wc.getCompilationUnit(), from) >= offset; if (fromIdx >=0 && toIdx >= 0 && toIdx - fromIdx > 0) { for (int i = toIdx - 1; i >= fromIdx; i--) {
if (readByteMethod.getBody() != null) { // Null-check for native/abstract overrides of read() List<? extends StatementTree> statements = readByteMethod.getBody().getStatements(); if (statements.size() == 1) { Tree tree = statements.get(0); if (tree.getKind() == Kind.RETURN && ASTHelpers.constValue(((ReturnTree) tree).getExpression()) != null) { return Description.NO_MATCH; ASTHelpers.findPathFromEnclosingNodeToTopLevel(state.getPath(), ClassTree.class); while (enclosingPath != null) { ClassTree klazz = (ClassTree) enclosingPath.getLeaf(); if (JUnitMatchers.isTestCaseDescendant.matches(klazz, state) || hasAnnotation(JUnitMatchers.JUNIT4_RUN_WITH_ANNOTATION).matches(klazz, state)) {
Document doc = null; try { doc = copy.getDocument(); if (doc == null) { doc = copy.getSnapshot().getSource().getDocument(true); SourcePositions sp = copy.getTrees().getSourcePositions(); TreeUtilities utils = copy.getTreeUtilities(); CompilationUnitTree compilationUnit = copy.getCompilationUnit(); if (member.getKind() == Tree.Kind.VARIABLE) { v = new FieldRefVisitor(clazz, vt.getModifiers().getFlags().contains(Modifier.STATIC)); v.registerTreeName(member, vt.getName()); if (member.getKind() == Tree.Kind.BLOCK) { v = new FieldRefVisitor(clazz, ((BlockTree)member).isStatic()); TreePath classTP = new TreePath(new TreePath(compilationUnit), clazz); v.scan(classTP, null); idx = Math.min(maxIndex, idx); return copy.getTreeMaker().insertClassMember(clazz, idx, member);
ClassTree clazz = null; for (Tree typeDecl : cu.getTypeDecls()) { if (TreeUtilities.CLASS_TREE_KINDS.contains(typeDecl.getKind())) { clazz = (ClassTree) typeDecl; break; if (clMember.getKind() == Tree.Kind.METHOD) { MethodTree method = (MethodTree)clMember; String methodName = method.getName().toString(); if ("initComponents".equals(methodName)) { // NOI18N for (StatementTree statement : method.getBody().getStatements()) { if (statement.getKind() == Tree.Kind.VARIABLE) { VariableTree var = (VariableTree)statement; if (varName.equals(var.getName().toString())) { variable = var; if (clMember.getKind() == Tree.Kind.VARIABLE) { VariableTree var = (VariableTree)clMember; if (varName.equals(var.getName().toString())) { variable = var; Tree type = variable.getType(); if (type.getKind() == Tree.Kind.PARAMETERIZED_TYPE) { ParameterizedTypeTree params = (ParameterizedTypeTree)type;
@Override public String visitMethod(MethodTree node, Void v) { StringBuilder out = new StringBuilder(); BlockTree body = node.getBody(); ModifiersTree modifiers = node.getModifiers(); String name = node.getName().toString(); List<? extends VariableTree> parameters = node.getParameters(); Tree returnType = node.getReturnType(); out.append(t.accept(this, v)); out.append(par.accept(this, v)); if (returnType != null) { out.append(" : "); out.append(returnType.accept(this, v)); out.append(body.accept(this, v)); Tree defaultValue = node.getDefaultValue(); if (defaultValue != null) { out.append(" = "); out.append(defaultValue.accept(this, v));
private static boolean isLastStatementInBlock(@Nullable TreePath pathToStatement) { if (pathToStatement == null) { return false; } Tree parent = pathToStatement.getParentPath().getLeaf(); if (!(parent instanceof BlockTree)) { return false; } return getLast(((BlockTree) parent).getStatements()).equals(pathToStatement.getLeaf()); }
Set<Element> result = new LinkedHashSet<>(); Set<Element> safeInitMethods = new LinkedHashSet<>(); Tree enclosingBlockOrMethod = enclosingBlockPath.getLeaf(); if (enclosingBlockOrMethod instanceof VariableTree) { return Collections.emptySet(); enclosingBlockOrMethod instanceof BlockTree ? (BlockTree) enclosingBlockOrMethod : ((MethodTree) enclosingBlockOrMethod).getBody(); List<? extends StatementTree> statements = blockTree.getStatements(); Tree readExprTree = pathToRead.getLeaf(); int readStartPos = getStartPos((JCTree) readExprTree); TreePath classTreePath = enclosingBlockPath; while (!(classTreePath.getLeaf() instanceof ClassTree)) { classTreePath = classTreePath.getParentPath(); if (classTreePath == null) { if (curStmt.getKind().equals(Tree.Kind.TRY)) { TryTree tryTree = (TryTree) curStmt;
int initPos = ((JCTree) var.getInitializer()).getStartPosition(); int eqPos = pos + state.getSourceForNode(var).substring(0, initPos - pos).lastIndexOf('='); fix.replace( String.format( ";\ntry (%s stream = %s) {\n%s =", streamType, state.getSourceForNode(tree), var.getName())); } else { Tree grandParent = parentPath.getParentPath().getLeaf(); if (!(grandParent instanceof BlockTree)) { return; List<? extends StatementTree> statements = ((BlockTree) grandParent).getStatements(); int idx = statements.indexOf(parent); int lastUse = idx; statements .get(i) .accept( new TreeScanner<Void, Void>() { @Override state.getEndPosition(((VariableTree) parent).getInitializer()), state.getEndPosition(parent), ") {");
public Object run(WorkingCopy wc) { ExecutableElement execElement = execElementHandle.resolve(wc); BlockTree block = wc.getTrees().getTree(execElement).getBody(); List<? extends StatementTree> stmts = block.getStatements(); if(stmts.size() > 0) { StatementTree stmt = stmts.get(stmts.size() - 1); if(stmt.getKind() == Tree.Kind.RETURN) { ReturnTree ret = (ReturnTree)stmt; ExpressionTree expr = ret.getExpression(); if(expr.getKind() == Tree.Kind.NULL_LITERAL) { Tree newExpr = wc.getTreeMaker().Literal(newStr); wc.rewrite(expr, newExpr); } } } return null; } }, javaClass.getFileObject());
public Object run(CompilationInfo cinfo) { List<Statement> stmts = new ArrayList<Statement>(); ExecutableElement execElement = execElementHandle.resolve(cinfo); BlockTree block = cinfo.getTrees().getTree(execElement).getBody(); SourcePositions sp = cinfo.getTrees().getSourcePositions(); long offset = -1; int stmtsLen = block.getStatements().size(); if(stmtsLen > 0) { offset = sp.getStartPosition(cinfo.getCompilationUnit(), block.getStatements().get(0)); }else { offset = sp.getEndPosition(cinfo.getCompilationUnit(), block);