Java TreePathHandle.create方法代码示例

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
static void prepareTypeVars(TreePath method, CompilationInfo info, Map<TypeMirror, TreePathHandle> typeVar2Def, List<TreePathHandle> typeVars) throws IllegalArgumentException {
    if (method.getLeaf().getKind() == Kind.METHOD) {
        MethodTree mt = (MethodTree) method.getLeaf();

        for (TypeParameterTree tv : mt.getTypeParameters()) {
            TreePath def = new TreePath(method, tv);
            TypeMirror type = info.getTrees().getTypeMirror(def);

            if (type != null && type.getKind() == TypeKind.TYPEVAR) {
                TreePathHandle tph = TreePathHandle.create(def, info);

                typeVar2Def.put(type, tph);
                typeVars.add(tph);
            }
        }
    }
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
@Override
public List<Fix> run(CompilationInfo compilationInfo, String diagnosticKey, int offset, TreePath treePath, Data<Void> data) {
    if (treePath.getLeaf().getKind() == Kind.METHOD) {
        MethodTree mt = (MethodTree) treePath.getLeaf();
        TreePath parentPath = treePath.getParentPath();
        ClassTree ct = (ClassTree) parentPath.getLeaf();
        Trees trees = compilationInfo.getTrees();
        Types types = compilationInfo.getTypes();
        TreeUtilities tu = compilationInfo.getTreeUtilities();
        TypeMirror type = types.erasure(trees.getTypeMirror(treePath));
        if (!Utilities.isValidType(type)) {
            return null;
        }
        for (Tree member : ct.getMembers()) {
            TreePath memberPath = new TreePath(parentPath, member);
            if (member.getKind() == Kind.METHOD && "<init>".contentEquals(((MethodTree)member).getName()) //NOI18N
                    && !tu.isSynthetic(memberPath) && types.isSameType(types.erasure(trees.getTypeMirror(memberPath)), type)) {
                return null;
            }
        }
        RenameConstructorFix fix = new RenameConstructorFix(compilationInfo.getSnapshot().getSource(), TreePathHandle.create(treePath, compilationInfo), offset, mt.getName(), ct.getSimpleName());
        return Collections.<Fix>singletonList(fix);
    }
    return null;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public static MemberInfo<TreePathHandle> create(TreePath tpath, CompilationInfo c) {
    String format = ElementHeaders.NAME;
    Group g = null;
    Element el = c.getTrees().getElement(tpath);
    if (el == null) {
        return null;
    }
    if (el.getKind() == ElementKind.FIELD) {
        format += " : " + ElementHeaders.TYPE; // NOI18N
        g=Group.FIELD;
    } else if (el.getKind() == ElementKind.METHOD) {
        format += ElementHeaders.PARAMETERS + " : " + ElementHeaders.TYPE; // NOI18N
        g=Group.METHOD;
    } else if (el.getKind().isInterface()) {
        g=Group.IMPLEMENTS;
        format = "implements " + format; // NOI18N
    }

    MemberInfo<TreePathHandle> mi = new MemberInfo<TreePathHandle>(TreePathHandle.create(tpath, c), el.getSimpleName().toString(), ElementHeaders.getHeader(el, c, format), ElementIcons.getElementIcon(el.getKind(), el.getModifiers()));
    mi.modifiers = el.getModifiers();
    mi.group = g;
    return mi;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
/**
 * Creates an 'introduce constant' fix.
 *
 * Note: the fix will not reference CompilationInfo and will remember only handles to TreePaths.
 *
 * @param resolved the path for expression or variable declaration to convert
 * @param info compilation context
 * @param value the actual expression or a variable initializer.
 * @param guessedName proposed name
 * @param numDuplicates number of other duplicates
 * @param offset offset for the hint
 * @param variableRewrite if variable name should be changed (?)
 * @param cancel cancel flag
 * @return
 */
static IntroduceFieldFix createConstant(TreePath resolved, CompilationInfo info, TreePath value, String guessedName, int numDuplicates, int offset, boolean variableRewrite, AtomicBoolean cancel) {
    CodeStyle cs = CodeStyle.getDefault(info.getFileObject());
    boolean isConstant = checkConstantExpression(info, value);
    TreePath constantTarget = isConstant ? findAcceptableConstantTarget(info, resolved) : null;
    if (!isConstant || constantTarget == null || cancel.get()) {
        return null;
    }
    TreePathHandle h = TreePathHandle.create(resolved, info);
    String varName;
    if (variableRewrite) {
        varName = guessedName;
    } else {
        String proposed = Utilities.toConstantName(guessedName);
        varName = Utilities.makeNameUnique(info, info.getTrees().getScope(constantTarget), proposed, cs.getStaticFieldNamePrefix(), cs.getStaticFieldNameSuffix());
    }
    ClassTree clazz = (ClassTree)constantTarget.getLeaf();
    Element el = info.getTrees().getElement(constantTarget);
    if (el == null || !(el.getKind().isClass() || el.getKind().isInterface())) {
        return null;
    }
    IntroduceConstantFix fix = new IntroduceConstantFix(h, info.getJavaSource(), varName, numDuplicates, offset, TreePathHandle.create(constantTarget, info));
    fix.setTargetIsInterface(clazz.getKind() == Tree.Kind.INTERFACE);
    return fix;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public AddParameterOrLocalFix(CompilationInfo info,
                              TypeMirror type, String name,
                              ElementKind kind,
                              int /*!!!Position*/ unresolvedVariable) {
    this.file = info.getFileObject();
    if (type.getKind() == TypeKind.NULL || type.getKind() == TypeKind.NONE) {
        TypeElement te = info.getElements().getTypeElement("java.lang.Object"); // NOI18N
        if (te != null) {
            type = te.asType();
            this.type = TypeMirrorHandle.create(type);
        } else {
            this.type = null;
        }
    } else {
        this.type = TypeMirrorHandle.create(type);
    }
    this.name = name;
    this.kind = kind;

    TreePath treePath = info.getTreeUtilities().pathFor(unresolvedVariable + 1);
    tpHandle = new TreePathHandle[1];
    tpHandle[0] = TreePathHandle.create(treePath, info);
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
private static ErrorDescription compute(HintContext ctx, String methodName) {
    TreePath message = ctx.getVariables().get("$message");
    List<List<TreePath>> sorted = Utilities.splitStringConcatenationToElements(ctx.getInfo(), message);

    if (sorted.size() <= 1) {
        return null;
    }

    //check for erroneous trees:
    for (List<TreePath> tps : sorted)
        for (TreePath tp : tps)
            if (tp.getLeaf().getKind() == Kind.ERRONEOUS) return null;

    FixImpl fix = new FixImpl(NbBundle.getMessage(LoggerStringConcat.class, "MSG_LoggerStringConcat_fix"), methodName, TreePathHandle.create(ctx.getPath(), ctx.getInfo()), TreePathHandle.create(message, ctx.getInfo()));

    return ErrorDescriptionFactory.forTree(ctx, message, NbBundle.getMessage(LoggerStringConcat.class, "MSG_LoggerStringConcat"), fix.toEditorFix());
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public AddCastFix(CompilationInfo info, TreePath expression, TreePath idealTypeTree, TypeMirror targetType) {
    super(info, expression);
    this.idealTypeTree = idealTypeTree != null ? TreePathHandle.create(idealTypeTree, info) : null;
    this.targetType = TypeMirrorHandle.create(targetType);
    this.treeName = Utilities.shortDisplayName(info, (ExpressionTree) expression.getLeaf());
    this.type = org.netbeans.modules.editor.java.Utilities.getTypeName(info, targetType, false).toString();
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public ReplaceIndexedForEachLoop(CompilationInfo info, TreePath tp, TreePath arr, List<TreePath> toReplace, Set<String> definedVariables) {
    super(info, tp);
    this.arrHandle = arr == null ? null : TreePathHandle.create(arr, info);
    this.toReplace = new ArrayList<>();
    
    for (TreePath tr : toReplace) {
        this.toReplace.add(TreePathHandle.create(tr, info));
    }
    this.definedVariables = definedVariables;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public JavaFix createFix(String fixLabel, boolean alwaysDefault) {
    TreePathHandle nHandle = nullBranch == null ? null : TreePathHandle.create(nullBranch, ctx.getInfo());
    ConvertToSwitch fix = new ConvertToSwitch(ctx.getInfo(),
                             ctx.getPath(),
                             TreePathHandle.create(variable, ctx.getInfo()),
                             nHandle,
                             literal2Statement,
                             isControlNotNull(), fixLabel);
    if (alwaysDefault) {
        fix.addDefaultAlways();
    }
    return fix;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
static TreePathHandle resolveSelection(TreePathHandle source, CompilationInfo javac) {
    TreePath resolvedPath = source.resolve(javac);
    TreePath path = resolvedPath;
    Element resolvedElement = source.resolveElement(javac);
    while (path != null && resolvedElement == null) {
        path = path.getParentPath();
        if (path == null) {
            return null;
        }
        resolvedElement = javac.getTrees().getElement(path);
    }

    return path == resolvedPath ? source : TreePathHandle.create(path, javac);
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
private ExtractInterfaceRefactoringUI(TreePath path, CompilationInfo info) {
    // compute source type
    this.name = ElementHeaders.getHeader(path, info, ElementHeaders.NAME);
    this.sourceType = TreePathHandle.create(path, info);
    // create an instance of pull up refactoring object
    refactoring = new ExtractInterfaceRefactoring(sourceType);
    refactoring.getContext().add(info.getClasspathInfo());
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
/** Creates a new instance of PullUpRefactoringUI
 * @param selectedElements Elements the refactoring action was invoked on.
 */
public PullUpRefactoringUI(TreePathHandle selectedElements, CompilationInfo info) {
    initialMembers = new HashSet();
    TreePathHandle selectedPath = PushDownRefactoringUI.resolveSelection(selectedElements, info);

    if (selectedPath != null) {
        Element selected = selectedPath.resolveElement(info);
        sourceKind = selected.getKind();
        initialMembers.add(MemberInfo.create(selected, info));
        // compute source type and members that should be pre-selected from the
        // set of elements the action was invoked on

       // create an instance of pull up refactoring object
        if (!(selected instanceof TypeElement)) {
            selected = info.getElementUtilities().enclosingTypeElement(selected);
        }
        TreePath tp = info.getTrees().getPath(selected);
        TreePathHandle sourceType = TreePathHandle.create(tp, info);
        description = ElementHeaders.getHeader(tp, info, ElementHeaders.NAME);
        refactoring = new PullUpRefactoring(sourceType);
        refactoring.getContext().add(info.getClasspathInfo());
    } else {
        // put the unresolvable selection to refactoring,
        // user notification is provided by PullUpRefactoringPlugin.preCheck
        refactoring = new PullUpRefactoring(selectedElements);
    }
    
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
private boolean isUsed(Tree memberTree, ModifiersTree mods) {
    if (!mods.getFlags().contains(Modifier.PRIVATE)) {
        // I don't want to search the world, better to ignore
        return true;
    }
    TreePath t = new TreePath(getControllerPath(), memberTree);
    TreePathHandle hnd = TreePathHandle.create(t, wcopy);
    WhereUsedQuery a = new WhereUsedQuery(Lookups.fixed(hnd));
    RefactoringSession session = RefactoringSession.create("Find usages");
    a.prepare(session);
    boolean used = !session.getRefactoringElements().isEmpty();
    session.finished();
    
    return used;
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
public void testLookup() throws Exception {
    prepareTest("test/Test.java", "package test; public class Test {}");

    TreePath tp = new TreePath(new TreePath(info.getCompilationUnit()), info.getCompilationUnit().getTypeDecls().get(0));
    TreePathHandle tph = TreePathHandle.create(tp, info);
    Element el = info.getTrees().getElement(tp);

    assertNotNull(el);

    final AtomicInteger counter = new AtomicInteger();
    
    Description d = Description.element(new ClassMemberPanelUI() {
        @Override public FileObject getFileObject() {
            counter.incrementAndGet();
            return info.getFileObject();
        }
    }, "test", ElementHandle.create(el), info.getClasspathInfo(), Collections.emptySet(), -1, false,
        el.getEnclosingElement().getKind() == ElementKind.PACKAGE);
    
    Node n = new ElementNode(d);

    assertEquals("#164874: should not compute FileObject eagerly", 0, counter.get());
    
    assertEquals(info.getFileObject(), n.getLookup().lookup(FileObject.class));
    assertEquals(1, counter.get());

    assertEquals(tph.resolve(info).getLeaf(), n.getLookup().lookup(TreePathHandle.class).resolve(info).getLeaf());
}
 

import org.netbeans.api.java.source.TreePathHandle; //导入方法依赖的package包/类
static ClassToInvoke compileToClass(CompilationInfo ci, String code, int codeOffset,
                                    JavaSource js, FileObject fo, int line,
                                    TreePath treePath, Tree tree,
                                    boolean staticContext) throws InvalidExpressionException {
    TreePathHandle tph = TreePathHandle.create(treePath, ci);
    String className = INVOCATION_CLASS_NAME + LAST_CLASS_ID.incrementAndGet();
    IntroduceClass introClass = new IntroduceClass(code, codeOffset, staticContext);
    boolean success = introClass.computeIntroduceMethod(tph, ci, treePath, tree);
    if (!success) {
        return null;
    }
    String methodInvoke = introClass.getMethodInvoke();
    String fullCode;
    Map<String, byte[]> compiledClass;
    try {
        fullCode = introClass.computeIntroduceClass(className, fo);
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
        compiledClass = CodeCompiler.compile(fo, js, fullCode, diagnostics);
        if (compiledClass == null) {
            return null;
        }
        for (Diagnostic<? extends JavaFileObject> diag : diagnostics.getDiagnostics()) {
            if (Diagnostic.Kind.ERROR.equals(diag.getKind()) &&
                diag.getSource().isNameCompatible(className, JavaFileObject.Kind.CLASS)) {
                
                throw new InvalidExpressionException(diag.getMessage(null));
            }
        }
    } catch (IOException ioe) {
        throw new InvalidExpressionException(ioe);
    }
    String classFQN = null;
    Map<String, byte[]> innerClasses = null;
    for (String ccName : compiledClass.keySet()) {
        if (ccName.endsWith(className)) {
            classFQN = ccName;
        } else if (ccName.contains(className)) {
            // A sub-class
            if (innerClasses == null) {
                innerClasses = new LinkedHashMap<>();
            }
            innerClasses.put(ccName, compiledClass.get(ccName));
        }
    }
    if (classFQN == null) {
        return null;
    }
    return new ClassToInvoke(classFQN,
                             compiledClass.get(classFQN),
                             "new "+className+"()."+methodInvoke,
                             innerClasses);
}