@Override public UMethodDecl visitMethod(MethodTree decl, Void v) { return UMethodDecl.create( visitModifiers(decl.getModifiers(), null), decl.getName(), templateType(decl.getReturnType()), cast(templateStatements(decl.getParameters()), UVariableDecl.class), templateExpressions(decl.getThrows()), (UBlock) template(decl.getBody())); }
@Override public Description matchMethod(MethodTree methodTree, VisitorState state) { DocTreePath path = getDocTreePath(state); if (path != null) { ImmutableSet<String> parameters = methodTree.getParameters().stream() .map(v -> v.getName().toString()) .collect(toImmutableSet()); ImmutableSet<String> typeParameters = methodTree.getTypeParameters().stream() .map(t -> t.getName().toString()) .collect(toImmutableSet()); new ParamsChecker(state, methodTree, parameters, typeParameters).scan(path, null); } return Description.NO_MATCH; }
@Override public Description matchMethod(MethodTree tree, VisitorState state) { return handle(tree, tree.getName(), tree.getModifiers(), state); }
@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; }
Tree tree = currentPath.getLeaf(); TypeElement te; if (TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())) { te = (TypeElement) ci.getTrees().getElement(currentPath); } else { Scope scope = ci.getTreeUtilities().scopeFor(currentOffset); el = scope.getEnclosingMethod(); if (el != null) { currentElementPtr[0] = el.getSimpleName().toString(); if (currentElementPtr[0].equals("<init>")) { currentElementPtr[0] = el.getEnclosingElement().getSimpleName().toString(); Tree tree = path != null ? path.getLeaf() : null; String name = ((MethodTree)tree).getName().toString(); if (name.equals("<init>") && scope.getEnclosingClass() != null) { name = scope.getEnclosingClass().getSimpleName().toString(); while (tree.getKind() != Tree.Kind.VARIABLE) { currentElementPtr[0] = ((VariableTree) tree).getName().toString();
insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName()); } else if (parent.getKind() == Tree.Kind.VARIABLE && ((VariableTree) parent).getType() == fa) { kinds = EnumSet.of(CLASS, ENUM, ANNOTATION_TYPE, INTERFACE); } else if (parent.getKind() == Tree.Kind.METHOD && ((MethodTree) parent).getThrows().contains(fa)) { Types types = controller.getTypes(); if (!options.contains(Options.ALL_COMPLETION) && ((MethodTree) parent).getBody() != null) { controller.toPhase(Phase.RESOLVED); exs = controller.getTreeUtilities().getUncaughtExceptions(new TreePath(path, ((MethodTree) parent).getBody())); Trees trees = controller.getTrees(); for (ExpressionTree thr : ((MethodTree) parent).getThrows()) { if (sourcePositions.getEndPosition(root, thr) >= offset) { break; baseType = controller.getTypes().getDeclaredType(te); } else if (parent.getKind() == Tree.Kind.METHOD && ((MethodTree) parent).getDefaultValue() == fa) { if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName());
for (Iterator it = classMemberElements.iterator(); it.hasNext(); ) { Element elm = (Element) it.next(); if (elm.getKind() == ElementKind.METHOD || elm.getKind() == ElementKind.CONSTRUCTOR) { String name; if (elm.getKind() == ElementKind.CONSTRUCTOR && !methodName.equals("<init>")) { name = elm.getEnclosingElement().getSimpleName().toString(); } else { SourcePositions positions = ci.getTrees().getSourcePositions(); Tree tree = ci.getTrees().getTree(elm); if (tree == null) { ErrorManager.getDefault().log(ErrorManager.WARNING, if (tree.getKind() == Tree.Kind.METHOD) { MethodTree mt = (MethodTree) tree; ModifiersTree modt = mt.getModifiers(); if (modt != null) { List<? extends AnnotationTree> annotations = modt.getAnnotations(); if (annotations != null && annotations.size() > 0) { pos = (int) positions.getEndPosition(ci.getCompilationUnit(), annotations.get(annotations.size() - 1));
String name; if (jcm.name == jcm.name.table.names.init) { TreePath path = info.getTrees().getPath(info.getCompilationUnit(), jcm); if (path == null) { return null; Element em = info.getTrees().getElement(path); Element clazz; if (em == null || (clazz = em.getEnclosingElement()) == null || !clazz.getKind().isClass()) { return null; name = clazz.getSimpleName().toString(); } else { name = method.getName().toString();
for (Tree t : tree.getThrows()) { TreePath tp = new TreePath(getCurrentPath(), t); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.CLASS_USE)); Element el = info.getTrees().getElement(getCurrentPath()); scan(tree.getModifiers(), null); tl.moveToEnd(tree.getModifiers()); scan(tree.getTypeParameters(), null); tl.moveToEnd(tree.getTypeParameters()); scan(tree.getReturnType(), EnumSet.of(UseTypes.CLASS_USE)); tl.moveToEnd(tree.getReturnType()); if (tree.getReturnType() != null) { name = tree.getName().toString(); } else { while (tp != null && !TreeUtilities.CLASS_TREE_KINDS.contains(tp.getLeaf().getKind())) { tp = tp.getParentPath(); scan(tree.getParameters(), paramsUseTypes); scan(tree.getThrows(), null); scan(tree.getDefaultValue(), null); recursionDetector = (el != null && el.getKind() == ElementKind.METHOD) ? (ExecutableElement) el : null; scan(tree.getBody(), null);
private MethodTree createMethod(final ExecutableElement element, final TypeElement clazz, final boolean isImplement) { final TreeMaker make = copy.getTreeMaker(); MethodTree prototype = createMethod((DeclaredType)clazz.asType(), element); ModifiersTree mt = prototype.getModifiers(); if (copy.getSourceVersion().compareTo(SourceVersion.RELEASE_5) >= 0) { boolean generate = true; mt = make.addModifiersAnnotation(prototype.getModifiers(), make.Annotation(make.Identifier("Override"), Collections.<ExpressionTree>emptyList())); mt = make.addModifiersModifier(mt, Modifier.ABSTRACT); MethodTree method = make.Method(mt, prototype.getName(), prototype.getReturnType(), prototype.getTypeParameters(), prototype.getParameters(), prototype.getThrows(), bodyTemplate, null); if (method.getBody() != null) { if (containsErrors(method.getBody())) { copy.rewrite(method.getBody(), make.Block(Collections.<StatementTree>emptyList(), false)); } else { Trees trees = copy.getTrees(); TreePath path = trees.getPath(clazz); if (path == null) { path = new TreePath(copy.getCompilationUnit()); Scope s = trees.getScope(path); BlockTree body = method.getBody(); copy.getTreeUtilities().attributeTree(body, s); body = importFQNs(body); copy.rewrite(method.getBody(), body);
Tree lastTree = null; int state = 0; for (Tree thr : mth.getThrows()) { int thrPos = (int) sourcePositions.getEndPosition(root, thr); if (thrPos == Diagnostic.NOPOS || offset <= thrPos) { for (VariableTree param : mth.getParameters()) { int parPos = (int) sourcePositions.getEndPosition(root, param); if (parPos == Diagnostic.NOPOS || offset <= parPos) { Tree retType = mth.getReturnType(); if (retType != null) { int retPos = (int) sourcePositions.getEndPosition(root, retType); for (TypeParameterTree tp : mth.getTypeParameters()) { int tpPos = (int) sourcePositions.getEndPosition(root, tp); if (tpPos == Diagnostic.NOPOS || offset <= tpPos) { Tree mods = mth.getModifiers(); if (mods != null) { int modsPos = (int) sourcePositions.getEndPosition(root, mods); if (!options.contains(Options.ALL_COMPLETION) && mth.getBody() != null) { controller.toPhase(Phase.RESOLVED); Set<TypeMirror> exs = controller.getTreeUtilities().getUncaughtExceptions(new TreePath(path, mth.getBody())); Elements elements = controller.getElements(); for (TypeMirror ex : exs) { if (ex.getKind() == TypeKind.DECLARED && startsWith(env, ((DeclaredType) ex).asElement().getSimpleName().toString()) && (Utilities.isShowDeprecatedMembers() || !elements.isDeprecated(((DeclaredType) ex).asElement()))
TreeUtilities tu = info.getTreeUtilities(); TreePath tp = tu.pathFor(caretPosition); if (tp.getParentPath() != null && tp.getParentPath().getLeaf().getKind() == Kind.ANNOTATED_TYPE) { if (typePath != null && typePath.getParentPath().getLeaf().getKind() == Kind.METHOD) { Tree type = decl.getReturnType(); && isIn(cu, info.getTrees().getSourcePositions(), type, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); for (Tree exc : decl.getThrows()) { if ( node.getBoolean(MarkOccurencesSettingsNames.EXCEPTIONS, true) && 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); boolean isExtends = ctree.getExtendsClause() == typePath.getLeaf(); boolean isImplements = false; for (Tree t : ctree.getImplementsClause()) { Tree superClass = ((ClassTree) tp.getLeaf()).getExtendsClause();
return null; Tree leaf = decl.getLeaf(); rightTrees.addAll(method.getParameters()); rightTrees.addAll(method.getThrows()); rightTrees.add(method.getBody()); Name name = method.getName(); if (method.getReturnType() == null) name = ((ClassTree) decl.getParentPath().getLeaf()).getSimpleName(); return findIdentifierSpanImpl(info, leaf, method.getReturnType(), rightTrees, name.toString(), info.getCompilationUnit(), info.getTrees().getSourcePositions()); if (class2Kind.get(VariableTree.class).contains(leaf.getKind())) { VariableTree var = (VariableTree) leaf; if (class2Kind.get(MemberSelectTree.class).contains(leaf.getKind())) { return findIdentifierSpanImpl(info, (MemberSelectTree) leaf, info.getCompilationUnit(), info.getTrees().getSourcePositions()); if (class2Kind.get(MemberReferenceTree.class).contains(leaf.getKind())) { if (class2Kind.get(ClassTree.class).contains(leaf.getKind())) { String name = ((ClassTree) leaf).getSimpleName().toString();
private MethodTree modifyMethodTypeParameter(MethodTree method, int index, TypeParameterTree typeParameter, Operation op) { MethodTree copy = Method( method.getModifiers(), method.getName(), method.getReturnType(), c(method.getTypeParameters(), index, typeParameter, op), method.getParameters(), method.getThrows(), method.getBody(), (ExpressionTree) method.getDefaultValue() ); return copy; }
@Override public Void visitThrows(ThrowsTree throwsTree, Void unused) { ReferenceTree exName = throwsTree.getExceptionName(); Type type = (Type) JavacTrees.instance(state.context) .getElement(new DocTreePath(getCurrentPath(), exName)) .asType(); if (type != null && isCheckedException(type)) { if (methodTree.getThrows().stream().noneMatch(t -> isSubtype(type, getType(t), state))) { state.reportMatch( buildDescription(diagnosticPosition(getCurrentPath(), state)) .addFix(Utils.replace(throwsTree, "", state)) .build()); } } return super.visitThrows(throwsTree, null); }
@Nullable @Override public Type visitReturn(ReturnTree tree, Void unused) { for (TreePath path = parent; path != null; path = path.getParentPath()) { Tree enclosing = path.getLeaf(); switch (enclosing.getKind()) { case METHOD: return getType(((MethodTree) enclosing).getReturnType()); case LAMBDA_EXPRESSION: return visitLambdaExpression((LambdaExpressionTree) enclosing, null); default: // fall out } } throw new AssertionError("return not enclosed by method or lambda"); }
Trees trees = Trees.instance(processingEnv); ClassTree tree = trees.getTree(el); for (Tree member : tree.getMembers()) { 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) {
@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)); }
boolean removeStatement(WorkingCopy wc, StatementTree stmtTree) { ExecutableElement execElement = execElementHandle.resolve(wc); if(execElement != null) { BlockTree blockTree = wc.getTrees().getTree(execElement).getBody(); BlockTree newBlockTree = wc.getTreeMaker().removeBlockStatement(blockTree, stmtTree); wc.rewrite(blockTree, newBlockTree); return true; } return false; }
public R visitMethod(MethodTree node, P p) { R r = scan(node.getModifiers(), p); r = scanAndReduce(node.getReturnType(), p, r); r = scanAndReduce(node.getTypeParameters(), p, r); r = scanAndReduce(node.getParameters(), p, r); r = scanAndReduce(node.getReceiverParameter(), p, r); r = scanAndReduce(node.getThrows(), p, r); r = scanAndReduce(node.getBody(), p, r); r = scanAndReduce(node.getDefaultValue(), p, r); return r; }