Java MemberSelectTree.getIdentifier方法代码示例

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
@Override
public Object visitMemberSelect(MemberSelectTree node, Object p) {
    String s = node.getExpression().toString();
    Name id = node.getIdentifier();
    if (id.contentEquals("this") || id.contentEquals("super")) {
        // this.sym || super.sym
        return Boolean.TRUE;
    }
    if (s.endsWith("this") || s.endsWith("super")) {
        return Boolean.TRUE;
    }
    return node;
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
@Override
public Symbol visitMemberSelect(MemberSelectTree node, Env<AttrContext> env) {
    Symbol site = visit(node.getExpression(), env);
    if (site.kind == ERR)
        return site;
    Name name = (Name)node.getIdentifier();
    if (site.kind == PCK) {
        env.toplevel.packge = (PackageSymbol)site;
        return rs.findIdentInPackage(env, (TypeSymbol)site, name, TYP | PCK);
    } else {
        env.enclClass.sym = (ClassSymbol)site;
        return rs.findMemberType(env, site.asType(), name, (TypeSymbol)site);
    }
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
@Override
public Symbol visitMemberSelect(MemberSelectTree node, Env<AttrContext> env) {
    Symbol site = visit(node.getExpression(), env);
    if (site.kind == ERR || site.kind == ABSENT_TYP)
        return site;
    Name name = (Name)node.getIdentifier();
    if (site.kind == PCK) {
        env.toplevel.packge = (PackageSymbol)site;
        return rs.findIdentInPackage(env, (TypeSymbol)site, name, TYP | PCK);
    } else {
        env.enclClass.sym = (ClassSymbol)site;
        return rs.findMemberType(env, site.asType(), name, (TypeSymbol)site);
    }
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
@Override @DefinedBy(Api.COMPILER_TREE)
public Symbol visitMemberSelect(MemberSelectTree node, Env<AttrContext> env) {
    Symbol site = visit(node.getExpression(), env);
    if (site.kind == ERR || site.kind == ABSENT_TYP || site.kind == HIDDEN)
        return site;
    Name name = (Name)node.getIdentifier();
    if (site.kind == PCK) {
        env.toplevel.packge = (PackageSymbol)site;
        return rs.findIdentInPackage(env, (TypeSymbol)site, name,
                KindSelector.TYP_PCK);
    } else {
        env.enclClass.sym = (ClassSymbol)site;
        return rs.findMemberType(env, site.asType(), name, (TypeSymbol)site);
    }
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
/**
 * special handling of static imports
 * see #196685
 * 
 */
private Element getStaticallyImportedElement(TreePath treePath, CompilationInfo info) {
    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()) {
                return null;
            }
            break;    
        } else if (treeKind == Tree.Kind.MEMBER_SELECT || treeKind == Tree.Kind.IDENTIFIER) {
            tp = tp.getParentPath();
            continue;
        }
        return null;
    }
    
    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;
    }
    
    for (Element e : info.getElements().getAllMembers((TypeElement) decl)) {
        if (!e.getModifiers().contains(Modifier.STATIC)) {
            continue;
        }
        if (!e.getSimpleName().equals(simpleName)) {
            continue;
        }
        return e;
    }
    return null;
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
@Override
public Void visitImport(ImportTree tree, Void d) {
    if (parseErrorInImport(tree)) {
        return super.visitImport(tree, null);
    }
    if (tree.getQualifiedIdentifier() == null ||
        tree.getQualifiedIdentifier().getKind() != Tree.Kind.MEMBER_SELECT) {
        return super.visitImport(tree, null);
    }
    MemberSelectTree qualIdent = (MemberSelectTree) tree.getQualifiedIdentifier();
    boolean assign = false;
    
    // static imports and star imports only use the qualifier part
    boolean star = isStar(tree);
    TreePath tp = tree.isStatic() || star ?
            new TreePath(new TreePath(getCurrentPath(), qualIdent), qualIdent.getExpression()) :
            new TreePath(getCurrentPath(), tree.getQualifiedIdentifier());
    Element decl = info.getTrees().getElement(tp);
    
    import2Highlight.put(tree, getCurrentPath());
    if (decl != null && !isErroneous(decl)) {
        if (!tree.isStatic()) {
            if (star) {
                List<TypeElement> types = ElementFilter.typesIn(decl.getEnclosedElements());
                for (TypeElement te : types) {
                    assign = true;
                    if (!element2Import.containsKey(te)) {
                        element2Import.put(te, tree);
                    }
                }
            } else {
                element2Import.put(decl, tree);
                importedBySingleImport.add(decl);
            }
        } else if (decl.getKind().isClass() || decl.getKind().isInterface()) {
            Name simpleName = star ? null : qualIdent.getIdentifier();

            for (Element e : info.getElements().getAllMembers((TypeElement) decl)) {
                if (!e.getModifiers().contains(Modifier.STATIC)) continue;
                if (simpleName != null && !e.getSimpleName().equals(simpleName)) {
                    continue;
                }
                if (!star || !element2Import.containsKey(e)) {
                    element2Import.put(e, tree);
                }
                assign = true;
            }
        }
    }
    if (!assign) {
        if (!tree.isStatic() && star) {
            unresolvablePackageImports.add(tree);
        } else {
            addUnresolvableImport(qualIdent.getIdentifier(), tree);
        }
    }
    super.visitImport(tree, null);
    return null;
}
 

import com.sun.source.tree.MemberSelectTree; //导入方法依赖的package包/类
protected static Fix computeFixes(CompilationInfo info, TreePath treePath, int[] bounds, int[] kind, String[] simpleName) {
    if (treePath.getLeaf().getKind() != Kind.MEMBER_SELECT) {
        return null;
    }
    MemberSelectTree mst = (MemberSelectTree)treePath.getLeaf();
    Tree expression = mst.getExpression();
    TreePath expr = new TreePath(treePath, expression);
    
    TypeMirror tm = info.getTrees().getTypeMirror(expr);
    if (!Utilities.isValidType(tm)) {
        return null;
    }
    Element el = info.getTypes().asElement(tm);
    if (el == null || (!el.getKind().isClass() && !el.getKind().isInterface())) {
        return null;
    }
    
    TypeElement type = (TypeElement)el;
    
    if (isError(type)) {
        return null;
    }
    
    Name idName = null;
    
    if (expression.getKind() == Kind.MEMBER_SELECT) {
        MemberSelectTree exprSelect = (MemberSelectTree)expression;
        idName = exprSelect.getIdentifier();
    }
    
    if (expression.getKind() == Kind.IDENTIFIER) {
        IdentifierTree idt = (IdentifierTree)expression;
        idName = idt.getName();
    }
    
    if (idName != null) {
        if (idName.equals(type.getSimpleName())) {
            return null;
        }
        if (idName.equals(type.getQualifiedName())) {
            return null;
        }
    }
    
    Element used = info.getTrees().getElement(treePath);
    
    if (used == null || !used.getModifiers().contains(Modifier.STATIC)) {
        return null;
    }
    
    if (isError(used)) {
        return null;
    }
    
    if (used.getKind().isField()) {
        kind[0] = 0;
    } else {
        if (used.getKind() == ElementKind.METHOD) {
            kind[0] = 1;
        } else {
            kind[0] = 2;
        }
    }
    
    simpleName[0] = used.getSimpleName().toString();
    
    return new FixImpl(info, expr, type).toEditorFix();
}