@Override public boolean matches(ExpressionTree expressionTree, VisitorState state) { if (expressionTree.getKind() == Kind.MEMBER_SELECT) { MemberSelectTree select = (MemberSelectTree) expressionTree; return select.getIdentifier().contentEquals("class") && classMatcher.matches(select.getExpression(), state); } return false; } };
@Override public Void visitMemberSelect(MemberSelectTree node, Void unused) { checkForThis(node, node.getIdentifier(), thisClass, state); // Don't examine this.foo or MyClass.this.foo ExpressionTree left = node.getExpression(); if ((left instanceof IdentifierTree && ((IdentifierTree) left).getName().contentEquals("this")) || (left instanceof MemberSelectTree && ((MemberSelectTree) left).getIdentifier().contentEquals("this"))) { return null; } return super.visitMemberSelect(node, unused); }
@Override public Choice<State<JCFieldAccess>> visitMemberSelect( final MemberSelectTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), expr -> maker().Select(expr, (Name) node.getIdentifier())); }
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: { ExpressionTree exp = ((MemberSelectTree) mid).getExpression(); 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 Scope scope = env.getScope(); TypeElement enclClass = scope.getEnclosingClass(); toolTipData = getMatchingParams(controller, type, controller.getElementUtilities().getMembers(type, acceptor), ((MemberSelectTree) mid).getIdentifier().toString(), types, controller.getTypes()); break; 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
boolean isMemberClass = false; if (selectedIdentifier != null) { Tree tree = ci.getTreeUtilities().pathFor(currentOffset).getLeaf(); if (tree.getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree mst = (MemberSelectTree) tree; el = ci.getTrees().getElement(ci.getTrees().getPath(ci.getCompilationUnit(), mst.getExpression())); if (el != null) { TypeMirror tm = el.asType(); if (tm.getKind().equals(TypeKind.DECLARED)) { currentElementPtr[0] = tm.toString(); 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; while (tree.getKind() != Tree.Kind.VARIABLE) { String fieldName = mst.getIdentifier().toString(); el = ci.getTrees().getElement(ci.getTrees().getPath(ci.getCompilationUnit(), mst.getExpression()));
final TreePath path = env.getPath(); TypeMirror actualType = type; if (path != null && path.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT) { actualType = adjustType(env, type, elem, new TreePath(path, ((MemberSelectTree)path.getLeaf()).getExpression())); final TreeUtilities tu = controller.getTreeUtilities(); TypeElement typeElem = actualType.getKind() == TypeKind.DECLARED ? (TypeElement) ((DeclaredType) actualType).asElement() : null; final boolean isStatic = elem != null && (elem.getKind().isClass() || elem.getKind().isInterface() || elem.getKind() == TYPE_PARAMETER) && elem.asType().getKind() != TypeKind.ERROR; final boolean isThisCall = elem != null && elem.getKind().isField() && elem.getSimpleName().contentEquals(THIS_KEYWORD); final boolean isSuperCall = elem != null && elem.getKind().isField() && elem.getSimpleName().contentEquals(SUPER_KEYWORD); final Scope scope = env.getScope(); if ((isThisCall || isSuperCall) && tu.isStaticContext(scope)) {
private Element getImportedElement(CompilationUnitTree cut, ImportTree imp) { Trees trees = copy.getTrees(); Tree qualIdent = imp.getQualifiedIdentifier(); if (qualIdent.getKind() != Tree.Kind.MEMBER_SELECT) { Element element = trees.getElement(TreePath.getPath(cut, qualIdent)); if (element == null) { String fqn = qualIdent.toString(); Name name = ((MemberSelectTree)qualIdent).getIdentifier(); if ("*".contentEquals(name)) { //NOI18N Element element = trees.getElement(TreePath.getPath(cut, ((MemberSelectTree)qualIdent).getExpression())); if (element == null) element = getElementByFQN(((MemberSelectTree)qualIdent).getExpression().toString()); return element; Element parent = trees.getElement(TreePath.getPath(cut, ((MemberSelectTree)qualIdent).getExpression())); if (parent == null) parent = getElementByFQN(((MemberSelectTree)qualIdent).getExpression().toString()); if (parent != null && (parent.getKind().isClass() || parent.getKind().isInterface())) { Scope s = trees.getScope(new TreePath(cut)); for (Element e : parent.getEnclosedElements()) { if (name == e.getSimpleName() && e.getModifiers().contains(Modifier.STATIC) && trees.isAccessible(s, e, (DeclaredType)parent.asType())) return e;
String prefix = env.getPrefix(); TreePath path = env.getPath(); MemberSelectTree fa = (MemberSelectTree) path.getLeaf(); CompilationController controller = env.getController(); CompilationUnitTree root = env.getRoot(); SourcePositions sourcePositions = env.getSourcePositions(); int expEndPos = (int) sourcePositions.getEndPosition(root, fa.getExpression()); boolean afterDot = false; boolean afterLt = false; insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); ExpressionTree exp = fa.getExpression(); TreePath expPath = new TreePath(path, exp); TypeMirror type = controller.getTrees().getTypeMirror(expPath); if (type != null) { Element el = controller.getTrees().getElement(expPath); EnumSet<ElementKind> kinds; DeclaredType baseType = null; if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName()); break;
tree.getQualifiedIdentifier().getKind() != Tree.Kind.MEMBER_SELECT) { return super.visitImport(tree, null); new TreePath(new TreePath(getCurrentPath(), qualIdent), qualIdent.getExpression()) : new TreePath(getCurrentPath(), tree.getQualifiedIdentifier()); Element decl = info.getTrees().getElement(tp); if (!tree.isStatic()) { if (star) { List<TypeElement> types = ElementFilter.typesIn(decl.getEnclosedElements()); for (TypeElement te : types) { assign = true; importedBySingleImport.add(decl); } else if (decl.getKind().isClass() || decl.getKind().isInterface()) { Name simpleName = star ? null : qualIdent.getIdentifier(); if (!e.getModifiers().contains(Modifier.STATIC)) continue; if (simpleName != null && !e.getSimpleName().equals(simpleName)) { continue; unresolvablePackageImports.add(tree); } else { addUnresolvableImport(qualIdent.getIdentifier(), tree);
@Override public Void visitImport(ImportTree node, Stack<Tree> p) { if (node.isStatic() && toFind.getModifiers().contains(Modifier.STATIC)) { Tree qualIdent = node.getQualifiedIdentifier(); if (qualIdent.getKind() == Kind.MEMBER_SELECT) { MemberSelectTree mst = (MemberSelectTree) qualIdent; if (toFind.getSimpleName().contentEquals(mst.getIdentifier())) { Element el = info.getTrees().getElement(new TreePath(getCurrentPath(), mst.getExpression())); if (el != null && el.equals(toFind.getEnclosingElement())) { Token<JavaTokenId> t = Utilities.getToken(info, doc, new TreePath(getCurrentPath(), mst)); if (t != null) usages.add(t); } } } } return super.visitImport(node, p); } }
private @NonNull VerifyResult fullVerifyElements(TreePath node, TreePath p) { Element nodeEl = info.getTrees().getElement(node); Element pEl = info.getTrees().getElement(p); if (!nodeEl.getModifiers().contains(Modifier.STATIC)) { if ((nodeEl.getKind().isClass() || nodeEl.getKind().isInterface())) { if (p.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT && node.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT) { Tree selector = ((MemberSelectTree)p.getLeaf()).getExpression(); if (getWildcardTreeName(selector) != null) { Element nodeSelector = info.getTrees().getElement(new TreePath(node, ((MemberSelectTree)node.getLeaf()).getExpression())); if (nodeSelector != null && (nodeSelector.getKind().isClass() || nodeSelector.getKind().isInterface())) { matchingResult = VerifyResult.NO_MATCH;
if (treePath.getLeaf().getKind() != Tree.Kind.MEMBER_SELECT) return null; MemberSelectTree memberSelectTree = (MemberSelectTree) treePath.getLeaf(); TreePath tp = treePath; while (tp!=null) { Kind treeKind = tp.getLeaf().getKind(); if (treeKind == Tree.Kind.IMPORT) { if (!((ImportTree) tp.getLeaf()).isStatic()) { Name simpleName = memberSelectTree.getIdentifier(); if (simpleName == null) { return null; TreePath declPath = new TreePath(new TreePath(treePath, memberSelectTree), memberSelectTree.getExpression()); TypeElement decl = (TypeElement) info.getTrees().getElement(declPath); if (decl==null) { return null; if (!e.getModifiers().contains(Modifier.STATIC)) { continue; if (!e.getSimpleName().equals(simpleName)) { continue;
SourcePositions sp = trees.getSourcePositions(); for (int treeIndex = 0; treeIndex < length; treeIndex++) { Tree node = treeNodes.get(treeIndex); Tree.Kind kind = node.getKind(); EditorContext.Operation op = null; if (kind.equals(Tree.Kind.METHOD_INVOCATION) || if (!ci.getTreeUtilities().isSynthetic(ci.getTrees().getPath(cu, node))) { int pos = (int) sp.getStartPosition(cu, node); EditorContext.Position startPosition = identifier = ((NewClassTree) node).getIdentifier(); methodName = "<init>"; TreePath iPath = TreePath.getPath(cu, identifier); TypeMirror type = trees.getTypeMirror(iPath); if (type.getKind() == TypeKind.ERROR) { } else { methodName = ((MemberSelectTree) identifier).getIdentifier().toString(); getStartPosFromMethodLength = true; ExpressionTree exp = ((MemberSelectTree) identifier).getExpression(); TreePath expPath = TreePath.getPath(cu, exp); TypeMirror type = trees.getTypeMirror(expPath); if (type.getKind() == TypeKind.ERROR) {
Tree expr = tree.getExpression(); TreePath tp = new TreePath(getCurrentPath(), expr); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.READ)); Element el = info.getTrees().getElement(getCurrentPath()); if (el != null && el.getKind().isField()) { handlePossibleIdentifier(getCurrentPath(), d == null ? EnumSet.of(UseTypes.READ) : d); if (el != null && (el.getKind().isClass() || el.getKind().isInterface()) && getCurrentPath().getParentPath().getLeaf().getKind() != Kind.NEW_CLASS) { handlePossibleIdentifier(getCurrentPath(), EnumSet.of(UseTypes.CLASS_USE)); tl.moveToEnd(tree.getExpression()); firstIdentifier(tree.getIdentifier().toString());
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); if (!"*".contentEquals(mst.getIdentifier())) { List<int[]> bag = new ArrayList<int[]>(); Token<JavaTokenId> tok = Utilities.getToken(info, doc, tp); if (tok != null) bag.add(new int[] {tok.offset(null), tok.offset(null) + tok.length()}); el = info.getTrees().getElement(new TreePath(tp, mst.getExpression())); if (el != null) { FindLocalUsagesQuery fluq = new FindLocalUsagesQuery(); 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()});
getEmbeddedOffset(span[0] + 1); TreePath path = controller.getTreeUtilities().pathFor(exactOffset); TreePath parent = path.getParentPath(); if (parent != null) { Tree parentLeaf = parent.getLeaf(); if ( parentLeaf.getKind() == Kind.METHOD_INVOCATION){ ExpressionTree select = ((MethodInvocationTree)parentLeaf). getMethodSelect(); if ( select.getKind() == Kind.MEMBER_SELECT ){ Scope scope = controller.getTrees().getScope(path); Element subjectClass = scope.getEnclosingClass(); Element method = controller.getTrees().getElement( new TreePath(path, select)); Element caller = controller.getTrees().getElement( new TreePath(path, ((MemberSelectTree)select).getExpression())); String methodName = method.getSimpleName().toString(); if ( FIRE.equals( methodName) && method instanceof ExecutableElement && caller instanceof VariableElement ) String variableName = caller.getSimpleName().toString(); TypeElement enclosingTypeElement = controller.getElementUtilities().
@Override public Description matchVariable(VariableTree tree, VisitorState state) { ExpressionTree initializer = stripNullCheck(tree.getInitializer(), state); Tree parent = state.getPath().getParentPath().getLeaf(); // must be a static class variable with member select initializer if (initializer == null || initializer.getKind() != MEMBER_SELECT || parent.getKind() != CLASS || !tree.getModifiers().getFlags().contains(STATIC)) { return Description.NO_MATCH; } MemberSelectTree rhs = (MemberSelectTree) initializer; Symbol rhsClass = ASTHelpers.getSymbol(rhs.getExpression()); Symbol lhsClass = ASTHelpers.getSymbol(parent); if (rhsClass != null && lhsClass != null && rhsClass.equals(lhsClass) && rhs.getIdentifier().contentEquals(tree.getName())) { return describeForVarDecl(tree, state); } return Description.NO_MATCH; }
private boolean isStarImport(ImportTree imp) { Tree qualIdent = imp.getQualifiedIdentifier(); boolean isStar = qualIdent.getKind() == Tree.Kind.MEMBER_SELECT && ((MemberSelectTree)qualIdent).getIdentifier().contentEquals("*"); // NOI18N return isStar; }
tree = ((MethodInvocationTree) tree).getMethodSelect(); pathBuilder.add(TreeUtils.getMethodName(tree) + "()"); if (tree.getKind() == Kind.IDENTIFIER) { tree = ((MemberSelectTree) tree).getExpression(); if (tree.getKind() == Kind.IDENTIFIER && ((IdentifierTree) tree).getName().contentEquals("this")) { return AccessPath.create(/*base=*/ null, pathBuilder.build()); if (tree.getKind() == Kind.IDENTIFIER) { return AccessPath.create(TreeUtils.elementFromTree(tree), pathBuilder.build());
statement.accept( new SimpleTreeVisitor<ExpressionTree, Void>() { @Override return NO_MATCH; ExpressionTree select = ((MethodInvocationTree) expr).getMethodSelect(); switch (select.getKind()) { case IDENTIFIER: break; case MEMBER_SELECT: ExpressionTree receiver = ((MemberSelectTree) select).getExpression(); if (receiver.getKind() != Kind.IDENTIFIER) { return NO_MATCH; if (!((IdentifierTree) receiver).getName().contentEquals("this")) { return NO_MATCH;