Attachment #121924 for bug #215361

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 215361
Collapse All | Expand All




public class RefactoringTreeElement implements TreeElement {

    RefactoringElement element;
    private final Icon icon;

    RefactoringTreeElement(RefactoringElement element) {
        this.element = element;
        icon = element.getLookup().lookup(Icon.class);
    }

    @Override

    
    @Override
    public Icon getIcon() {
        return icon;
    }

    @Override

Lines 81-86 Link Here

(-)a/refactoring.api/src/org/netbeans/modules/refactoring/spi/impl/Bundle.properties (+1 lines)
81	LBL_Occurence=occurrence	81	LBL_Occurence=occurrence
82	LBL_Occurences=occurrences	82	LBL_Occurences=occurrences
83	LBL_Errors=errors	83	LBL_Errors=errors
		84	LBL_Hidden=filtered
84	LBL_UsagesWindow=&Find Usages Results	85	LBL_UsagesWindow=&Find Usages Results
85	LBL_RefactoringWindow=&Refactoring Preview	86	LBL_RefactoringWindow=&Refactoring Preview
86		87




        <apidef name="JavaRefactoringAPI">Java Refactoring API</apidef>
    </apidefs>
    <changes>
        <change id="JavaWhereUsedFilters">
            <api name="JavaRefactoringAPI"/>
            <summary>Added refactoring filter keys for find usages results.</summary>
            <version major="1" minor="39"/>
            <date day="10" month="7" year="2012"/>
            <author login="ralphbenjamin"/>
            <compatibility addition="yes"/>
            <description>
                <p>Added an enumeration with keys to identify different filters used by Java Refactoring's Find Usages.
                    IMPORT("filter-import")
                    COMMENT("filter-comment")
                    TESTFILE("filter-testfile")
                    READ("filter-read")
                    WRITE("filter-write")
                    READ_WRITE("filter-readwrite")
                </p>
            </description>
            <class package="org.netbeans.modules.refactoring.java.spi"
                   name="JavaWhereUsedFilters"/>
            <issue number="215361"/>
        </change>
        <change id="ReplaceConstructorWithBuilder-ReplaceConstructorWithFactory-InvertBoolean">
            <api name="JavaRefactoringAPI"/>
            <summary>New refactorings on board: ReplaceConstructorWithFactory,

Lines 2-8 Link Here

(-)a/refactoring.java/nbproject/project.properties (-1 / +1 lines)
2	javadoc.arch=${basedir}/arch.xml	2	javadoc.arch=${basedir}/arch.xml
3	javadoc.apichanges=${basedir}/apichanges.xml	3	javadoc.apichanges=${basedir}/apichanges.xml
4		4
5	spec.version.base=1.38.0	5	spec.version.base=1.39.0
6	#test configs	6	#test configs
7	test.config.find.includes=\	7	test.config.find.includes=\
8	**/FindUsagesSuite.class	8	**/FindUsagesSuite.class

Lines 185-191 Link Here

(-)a/refactoring.java/nbproject/project.xml (-1 / +1 lines)
185	<build-prerequisite/>	185	<build-prerequisite/>
186	<compile-dependency/>	186	<compile-dependency/>
187	<run-dependency>	187	<run-dependency>
188	<specification-version>1.28</specification-version>	188	<specification-version>1.29</specification-version>
189	</run-dependency>	189	</run-dependency>
190	</dependency>	190	</dependency>
191	<dependency>	191	<dependency>




import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.queries.SourceForBinaryQuery;
import org.netbeans.api.java.queries.SourceForBinaryQuery.Result;
import org.netbeans.api.java.queries.UnitTestForSourceQuery;
import org.netbeans.api.java.source.*;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;

        return "<default>"; //NOI18N
    }

    public static boolean isFromTestRoot(FileObject file, ClassPath cp) {
        boolean inTest = false;
        if (cp != null) {
            FileObject root = cp.findOwnerRoot(file);
            if (UnitTestForSourceQuery.findSources(root).length > 0) {
                inTest = true;
            }
        }
        return inTest;
    }

    private RefactoringUtils() {
    }
}




package org.netbeans.modules.refactoring.java;

import com.sun.source.tree.*;
import com.sun.source.tree.Tree.Kind;
import com.sun.source.util.SourcePositions;
import com.sun.source.util.TreePath;
import com.sun.source.util.Trees;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.swing.Icon;
import javax.swing.text.Position.Bias;
import org.netbeans.api.java.source.CompilationInfo;
import org.netbeans.api.java.source.TreeUtilities;
import org.netbeans.modules.refactoring.java.plugins.JavaWhereUsedQueryPlugin;
import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters.ReadWrite;
import org.netbeans.modules.refactoring.java.ui.UIUtilities;
import org.netbeans.modules.refactoring.java.ui.WhereUsedPanel;
import org.netbeans.modules.refactoring.java.ui.tree.ElementGripFactory;
import org.netbeans.modules.refactoring.spi.FiltersManager;
import org.netbeans.modules.refactoring.spi.SimpleRefactoringElementImplementation;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;

import org.openide.text.PositionBounds;
import org.openide.text.PositionRef;
import org.openide.util.Exceptions;
import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.lookup.Lookups;

public class WhereUsedElement extends SimpleRefactoringElementImplementation implements FiltersManager.Filterable {
    private PositionBounds bounds;
    private String displayText;
    private FileObject parentFile;
    private final JavaWhereUsedFilters.ReadWrite access;
    private final boolean inComment;
    private final boolean inImport;
    private final boolean inTestclass;

//    public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info) {
//        this(bounds, displayText, parentFile, tp, info, null, false, true);
//    }
//    
//    public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info, JavaWhereUsedFilters.ReadWrite access) {
//        this(bounds, displayText, parentFile, tp, info, access, false, false);
//    }
    
    public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info, ReadWrite access, boolean inTestclass, boolean inComment, boolean inImport) {
        this.bounds = bounds;
        this.displayText = displayText;
        this.parentFile = parentFile;
        if (tp != null) {
            ElementGripFactory.getDefault().put(parentFile, tp, info);
        }
        ElementGripFactory.getDefault().put(parentFile, inTestclass);
        this.access = access;
        this.inTestclass = inTestclass;
        this.inComment = inComment;
        this.inImport = inImport;
    }

    @Override

        if (composite==null) {
            composite = parentFile;
        }
        Icon icon = null;
        if(access != null) {
            switch(access) {
                case WRITE:
                    icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_write.png", false);
                    break;
                case READ_WRITE:
                    icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_readwrite.png", false);
                    break;
                default:
                case READ:
                    icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_read.png", false);
                    break;
            }
        } else if(inComment) {
            icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_comment.png", false);
        } else if(inImport) {
            icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_import.png", false);
        }
        return icon != null ? Lookups.fixed(composite, icon) : Lookups.singleton(composite);
    }

    @Override

    public FileObject getParentFile() {
        return parentFile;
    }

    public JavaWhereUsedFilters.ReadWrite getAccess() {
        return access;
    }
    
    public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, boolean inTest) {
        return create(compiler, tree, null, inTest, new AtomicBoolean());
    }
    
    public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, boolean inTest, AtomicBoolean inImport) {
        return create(compiler, tree, null, inTest, inImport);
    }
    
    public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, JavaWhereUsedFilters.ReadWrite access, boolean inTest, AtomicBoolean inImport) {
        CompilationUnitTree unit = tree.getCompilationUnit();
        CharSequence content = compiler.getSnapshot().getText();
        SourcePositions sp = compiler.getTrees().getSourcePositions();

            }
            t = tree.getLeaf();
        }
        
        boolean elementInImport = false;
        if(t.getKind() == Tree.Kind.IDENTIFIER || t.getKind() == Tree.Kind.MEMBER_SELECT) {
            TreePath enclosingTree = getEnclosingImportTree(tree);
            if(enclosingTree != null) {
                elementInImport = true;
                inImport.set(true);
            }
        }

        if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) {
            int[] pos = treeUtils.findNameSpan((ClassTree)t);

                end = start;
            }
        }

        assert start>0:"Cannot find start position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();
        assert end>0:"Cannot find end position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();
        LineMap lm = tree.getCompilationUnit().getLineMap();

                start==end && anonClassNameBug128074 ? NbBundle.getMessage(WhereUsedPanel.class, "LBL_AnonymousClass"):sb.toString().trim(),
                compiler.getFileObject(),
                tr,
                compiler, access, inTest, false, elementInImport);
    }
    
    private static String trimStart(String s) {

        return "";
    }
    
    public static WhereUsedElement create(int start, int end, CompilationInfo compiler, boolean inTest) {
        CharSequence content = compiler.getSnapshot().getText();
        LineMap lm = compiler.getCompilationUnit().getLineMap();
        long line = lm.getLineNumber(start);

        PositionRef ref1 = ces.createPositionRef(start, Bias.Forward);
        PositionRef ref2 = ces.createPositionRef(end, Bias.Forward);
        PositionBounds bounds = new PositionBounds(ref1, ref2);
        return new WhereUsedElement(bounds, sb.toString().trim(), compiler.getFileObject(), null, compiler, null, inTest, true, false);
    }
    
    private static TreePath getEnclosingImportTree(TreePath tp) {
        while(tp != null) {
            Tree tree = tp.getLeaf();
            if (tree.getKind() == Tree.Kind.IMPORT) {
                return tp;
            } 
            tp = tp.getParentPath();
        }
        return null;
    }
    
    private static TreePath getEnclosingTree(TreePath tp) {
        while(tp != null) {

        return null;
    }

    @Override
    public boolean filter(FiltersManager manager) {
        if(!inTestclass || (inTestclass && manager.isSelected(JavaWhereUsedFilters.TESTFILE.getKey()))) { 
            if (access != null) {
                return manager.isSelected(access.getKey());
            } else if (inComment) {
                return manager.isSelected(JavaWhereUsedFilters.COMMENT.getKey());
            } else if (inImport) {
                return manager.isSelected(JavaWhereUsedFilters.IMPORT.getKey());
            } else {
                return true;
            }
        } else {
            return false;
        }
    }
}

Lines 87-93 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/callhierarchy/CallOccurrence.java (-1 / +1 lines)
87		87
88	public static CallOccurrence createOccurrence(	88	public static CallOccurrence createOccurrence(
89	CompilationInfo javac, TreePath selection, Call parent) {	89	CompilationInfo javac, TreePath selection, Call parent) {
90	WhereUsedElement wue = WhereUsedElement.create(javac, selection);	90	WhereUsedElement wue = WhereUsedElement.create(javac, selection, false);
91	CallOccurrence c = new CallOccurrence();	91	CallOccurrence c = new CallOccurrence();
92	c.occurrence = TreePathHandle.create(selection, javac);	92	c.occurrence = TreePathHandle.create(selection, javac);
93	c.displayName = selection.getLeaf().toString();	93	c.displayName = selection.getLeaf().toString();




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.refactoring.java.plugins;

import com.sun.source.tree.*;
import com.sun.source.tree.Tree.Kind;
import com.sun.source.util.TreePath;
import com.sun.source.util.TreePathScanner;
import com.sun.source.util.Trees;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.lang.model.element.*;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementFilter;
import org.netbeans.api.java.lexer.JavaTokenId;
import org.netbeans.api.java.source.ClasspathInfo.PathKind;
import org.netbeans.api.java.source.CompilationController;
import org.netbeans.api.java.source.ElementUtilities;
import org.netbeans.api.java.source.JavaSource;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.modules.refactoring.java.RefactoringUtils;
import org.netbeans.modules.refactoring.java.WhereUsedElement;
import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
import org.netbeans.modules.refactoring.java.spi.ToPhaseException;
import org.openide.ErrorManager;
import org.openide.util.Exceptions;

/**
 *
 * @author Jan Becicka
 */
public class FindUsagesVisitor extends TreePathScanner<Tree, Element> {

    private Collection<TreePath> usages = new ArrayList<TreePath>();
    private Collection<WhereUsedElement> elements = new ArrayList<WhereUsedElement>();
    protected CompilationController workingCopy;
    private Collection<UsageInComment> usagesInComments = Collections.<UsageInComment>emptyList();
    private boolean findInComments = false;
    private final boolean fromTestRoot;
    private final AtomicBoolean inImport;

    public FindUsagesVisitor(CompilationController workingCopy) {
        this(workingCopy, false);
    }
    
    public FindUsagesVisitor(CompilationController workingCopy, boolean findInComments) {
        this(workingCopy, findInComments, RefactoringUtils.isFromTestRoot(workingCopy.getFileObject(), workingCopy.getClasspathInfo().getClassPath(PathKind.SOURCE)), new AtomicBoolean());
    }

    public FindUsagesVisitor(CompilationController workingCopy, boolean findInComments, boolean fromTestRoot, AtomicBoolean inImport) {
        try {
            setWorkingCopy(workingCopy);
        } catch (ToPhaseException ex) {
            Exceptions.printStackTrace(ex);
        }
        this.findInComments = findInComments;
        if (findInComments) {
            usagesInComments = new ArrayList<UsageInComment>();
        }
        this.fromTestRoot = fromTestRoot;
        this.inImport = inImport;
    }

    //<editor-fold defaultstate="collapsed" desc="Find in Comments">
    @Override
    public Tree visitCompilationUnit(CompilationUnitTree node, Element p) {
        if (findInComments) {
            String originalName = p.getSimpleName().toString();
            TokenSequence<JavaTokenId> ts = workingCopy.getTokenHierarchy().tokenSequence(JavaTokenId.language());

            while (ts.moveNext()) {
                Token t = ts.token();

                if (t.id() == JavaTokenId.BLOCK_COMMENT || t.id() == JavaTokenId.LINE_COMMENT || t.id() == JavaTokenId.JAVADOC_COMMENT) {
                    Scanner tokenizer = new Scanner(t.text().toString());
                    tokenizer.useDelimiter("[^a-zA-Z0-9_]"); //NOI18N

                    while (tokenizer.hasNext()) {
                        String current = tokenizer.next();
                        if (current.equals(originalName)) {

        }
        return super.visitCompilationUnit(node, p);
    }
    //</editor-fold>

    @Override
    public Tree visitIdentifier(IdentifierTree node, Element p) {
        addIfMatch(getCurrentPath(), node, p);
        return super.visitIdentifier(node, p);
    }

    @Override
    public Tree visitMemberSelect(MemberSelectTree node, Element p) {
        addIfMatch(getCurrentPath(), node,p);
        return super.visitMemberSelect(node, p);
    }
    
    @Override
    public Tree visitNewClass(NewClassTree node, Element p) {
        Trees trees = workingCopy.getTrees();
        ClassTree classTree = ((NewClassTree) node).getClassBody();
        if (classTree != null && p.getKind()==ElementKind.CONSTRUCTOR) {
            Element anonClass = workingCopy.getTrees().getElement(TreePath.getPath(workingCopy.getCompilationUnit(), classTree));
            if (anonClass==null) {
                Logger.getLogger("org.netbeans.modules.refactoring.java").severe("FindUsages cannot resolve " + classTree);
            } else {
                for (ExecutableElement c : ElementFilter.constructorsIn(anonClass.getEnclosedElements())) {
                    MethodTree t = workingCopy.getTrees().getTree(c);
                    TreePath superCall = trees.getPath(workingCopy.getCompilationUnit(), ((ExpressionStatementTree) t.getBody().getStatements().get(0)).getExpression());
                    Element superCallElement = trees.getElement(superCall);
                    if (superCallElement != null && superCallElement.equals(p) && !workingCopy.getTreeUtilities().isSynthetic(superCall)) {
                        addUsage(superCall);
                    }
                }
            }
        } else {
            addIfMatch(getCurrentPath(), node, p);
        }
        return super.visitNewClass(node, p);
    }
    
    private void addIfMatch(TreePath path, Tree tree, Element elementToFind) {
        if (workingCopy.getTreeUtilities().isSynthetic(path)) {
            if (ElementKind.CONSTRUCTOR != elementToFind.getKind()

        if (el == null) {
            path = path.getParentPath();
            if (path != null && path.getLeaf().getKind() == Kind.IMPORT) {
                ImportTree impTree = (ImportTree) path.getLeaf();
                if (!impTree.isStatic()) {
                    return;
                }

                if (el == null) {
                    return;
                }
                Iterator iter = workingCopy.getElementUtilities().getMembers(el.asType(), new ElementUtilities.ElementAcceptor() {
                    @Override
                    public boolean accept(Element e, TypeMirror type) {
                        return id.equals(e.getSimpleName());

                return;
            }
        }
        if (elementToFind != null && elementToFind.getKind() == ElementKind.METHOD && el.getKind() == ElementKind.METHOD) {
            if (el.equals(elementToFind) || workingCopy.getElements().overrides((ExecutableElement) el, (ExecutableElement) elementToFind, (TypeElement) elementToFind.getEnclosingElement())) {
                addUsage(path);
            }
        } else if (el.equals(elementToFind)) {
            final ElementKind kind = elementToFind.getKind();
            if(kind.isField() || kind == ElementKind.LOCAL_VARIABLE || kind == ElementKind.RESOURCE_VARIABLE) {
                JavaWhereUsedFilters.ReadWrite access = JavaWhereUsedFilters.ReadWrite.READ;
                TreePath parentPath = path.getParentPath();
                Tree parentTree = parentPath.getLeaf();
                Kind parentKind = parentTree.getKind();
                
                switch(parentKind) {
                    case ARRAY_ACCESS:
                    case MEMBER_SELECT:
                        // TODO: Check usages of arrays for writing
                        break;

                    case POSTFIX_INCREMENT:
                    case POSTFIX_DECREMENT:
                    case PREFIX_INCREMENT:
                    case PREFIX_DECREMENT:
                        access = JavaWhereUsedFilters.ReadWrite.READ_WRITE;
                        break;

                    case ASSIGNMENT: {
                        AssignmentTree assignmentTree = (AssignmentTree) parentTree;
                        ExpressionTree left = assignmentTree.getVariable();
                        if (left.equals(tree)) {
                            access = JavaWhereUsedFilters.ReadWrite.WRITE;
                        }
                        break;
                    }
                    case MULTIPLY_ASSIGNMENT:
                    case DIVIDE_ASSIGNMENT:
                    case REMAINDER_ASSIGNMENT:
                    case PLUS_ASSIGNMENT:
                    case MINUS_ASSIGNMENT:
                    case LEFT_SHIFT_ASSIGNMENT:
                    case RIGHT_SHIFT_ASSIGNMENT:
                    case UNSIGNED_RIGHT_SHIFT_ASSIGNMENT:
                    case AND_ASSIGNMENT:
                    case XOR_ASSIGNMENT:
                    case OR_ASSIGNMENT: {
                        CompoundAssignmentTree compoundAssignmentTree = (CompoundAssignmentTree) parentTree;
                        ExpressionTree left = compoundAssignmentTree.getVariable();
                        if (left.equals(tree)) {
                            access = JavaWhereUsedFilters.ReadWrite.READ_WRITE;
                        }
                        break;
                    }
                }
                addUsage(path, access);
            } else {
                addUsage(path);
            }
        }
    }

    /**
     *
     * @param workingCopy
     * @throws org.netbeans.modules.refactoring.java.spi.ToPhaseException
     */
    public final void setWorkingCopy(CompilationController workingCopy) throws ToPhaseException {
        this.workingCopy = workingCopy;
        try {
            if (this.workingCopy.toPhase(JavaSource.Phase.RESOLVED) != JavaSource.Phase.RESOLVED) {
                throw new ToPhaseException();
            }
        } catch (IOException ioe) {
            ErrorManager.getDefault().notify(ioe);
        }
    }

    public Collection<UsageInComment> getUsagesInComments() {
        return usagesInComments;
    }
    
    protected void addUsage(TreePath tp, JavaWhereUsedFilters.ReadWrite access) {
        assert tp != null;
        elements.add(WhereUsedElement.create(workingCopy, tp, access, fromTestRoot, inImport));
        usages.add(tp);
    }

    public boolean isInImport() {
        return inImport.get();
    }

    protected void addUsage(TreePath tp) {
        assert tp != null;
        elements.add(WhereUsedElement.create(workingCopy, tp, fromTestRoot, inImport));
        usages.add(tp);
    }
    
    public Collection<WhereUsedElement> getElements() {
        return elements;
    }
    
    public Collection<TreePath> getUsages() {
        return usages;
    }

    @Override
    public Tree visitIdentifier(IdentifierTree node, Element p) {
        addIfMatch(getCurrentPath(), node, p);
        return super.visitIdentifier(node, p);
    }

    @Override
    public Tree visitMemberSelect(MemberSelectTree node, Element p) {
        addIfMatch(getCurrentPath(), node, p);
        return super.visitMemberSelect(node, p);
    }

    @Override
    public Tree visitNewClass(NewClassTree node, Element p) {
        Trees trees = workingCopy.getTrees();
        ClassTree classTree = ((NewClassTree) node).getClassBody();
        if (classTree != null && p.getKind() == ElementKind.CONSTRUCTOR) {
            Element anonClass = workingCopy.getTrees().getElement(TreePath.getPath(workingCopy.getCompilationUnit(), classTree));
            if (anonClass == null) {
                Logger.getLogger("org.netbeans.modules.refactoring.java").log(Level.SEVERE, "FindUsages cannot resolve {0}", classTree); // NOI18N
            } else {
                for (ExecutableElement c : ElementFilter.constructorsIn(anonClass.getEnclosedElements())) {
                    MethodTree t = workingCopy.getTrees().getTree(c);
                    TreePath superCall = trees.getPath(workingCopy.getCompilationUnit(), ((ExpressionStatementTree) t.getBody().getStatements().get(0)).getExpression());
                    Element superCallElement = trees.getElement(superCall);
                    if (superCallElement != null && superCallElement.equals(p) && !workingCopy.getTreeUtilities().isSynthetic(superCall)) {
                        addUsage(superCall);
                    }
                }
            }
        } else {
            addIfMatch(getCurrentPath(), node, p);
        }
        return super.visitNewClass(node, p);
    }

    public static class UsageInComment {

        int from;
        int to;

        public UsageInComment(int from, int to) {
            this.from = from;
            this.to = to;
        }
    }
}





import com.sun.source.tree.Tree;
import com.sun.source.util.TreePath;
import java.io.IOException;
import java.net.URL;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.lang.model.element.Element;

import javax.lang.model.element.TypeElement;
import org.netbeans.api.fileinfo.NonRecursiveFolder;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.source.*;
import org.netbeans.api.java.source.ClassIndex.SearchScopeType;
import org.netbeans.api.java.source.*;
import org.netbeans.modules.refactoring.api.*;
import org.netbeans.modules.refactoring.java.RefactoringUtils;
import org.netbeans.modules.refactoring.java.SourceUtilsEx;
import org.netbeans.modules.refactoring.java.WhereUsedElement;
import org.netbeans.modules.refactoring.java.api.JavaRefactoringUtils;
import org.netbeans.modules.refactoring.java.api.WhereUsedQueryConstants;
import org.netbeans.modules.refactoring.java.plugins.FindUsagesVisitor.UsageInComment;
import org.netbeans.modules.refactoring.java.spi.JavaRefactoringPlugin;
import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters.ReadWrite;
import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.loaders.DataObject;
import org.openide.text.CloneableEditorSupport;
import org.openide.util.ImageUtilities;
import org.openide.util.NbBundle;
import org.openide.util.lookup.Lookups;

/**
 *
 * @author  Jan Becicka
 * @author  Ralph Ruijs
 */
public class JavaWhereUsedQueryPlugin extends JavaRefactoringPlugin implements FiltersDescription.Provider {
    private boolean fromLibrary;
    private WhereUsedQuery refactoring;
    private ClasspathInfo cp;

        fireProgressListenerStep(a.size());
        Problem problem = null;
        try {
            final FindTask findTask = new FindTask(elements);
            queryFiles(a, findTask);
        } catch (IOException e) {
            problem = createProblemAndLog(null, e);
        }

    }
    
    public static CloneableEditorSupport findCloneableEditorSupport(DataObject dob) {
        Object obj = dob.getLookup().lookup(org.openide.cookies.OpenCookie.class);
        if (obj instanceof CloneableEditorSupport) {
            return (CloneableEditorSupport)obj;
        }
        obj = dob.getLookup().lookup(org.openide.cookies.EditorCookie.class);
        if (obj instanceof CloneableEditorSupport) {
            return (CloneableEditorSupport)obj;
        }

    private boolean isSearchFromBaseClass() {
        return refactoring.getBooleanValue(WhereUsedQueryConstants.SEARCH_FROM_BASECLASS);
    }

    @Override
    public void addFilters(FiltersDescription filtersDescription) {
        filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.READ.getKey(), "Read filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_read.png", false));
        filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.WRITE.getKey(), "Write filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_write.png", false));
        filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.READ_WRITE.getKey(), "Read/Write filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_readwrite.png", false));
        filtersDescription.addFilter(JavaWhereUsedFilters.IMPORT.getKey(), "Import filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_import.png", false));
        filtersDescription.addFilter(JavaWhereUsedFilters.COMMENT.getKey(), "Comment filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_comment.png", false));
        filtersDescription.addFilter(JavaWhereUsedFilters.TESTFILE.getKey(), "Test filter", true,
                ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_test.png", false));
    }

    private EnumSet<JavaWhereUsedFilters.ReadWrite> usedAccessFilters = EnumSet.noneOf(JavaWhereUsedFilters.ReadWrite.class);
    private LinkedList<String> usedFilters = new LinkedList<String>();
    @Override
    public void enableFilters(FiltersDescription filtersDescription) {
        for (JavaWhereUsedFilters.ReadWrite filter : usedAccessFilters) {
            filtersDescription.enable(filter.getKey());
        }
        for (String string : usedFilters) {
            filtersDescription.enable(string);
        }
    }
    
    private class FindTask implements CancellableTask<CompilationController> {


                return;
            }
            
            final boolean fromTestRoot = RefactoringUtils.isFromTestRoot(compiler.getFileObject(), compiler.getClasspathInfo().getClassPath(ClasspathInfo.PathKind.SOURCE));
            AtomicBoolean inImport = new AtomicBoolean();
            if (isFindUsages()) {
                FindUsagesVisitor findVisitor = new FindUsagesVisitor(compiler, refactoring.getBooleanValue(WhereUsedQuery.SEARCH_IN_COMMENTS), fromTestRoot, inImport);
                findVisitor.scan(compiler.getCompilationUnit(), element);
                final Collection<UsageInComment> usagesInComments = findVisitor.getUsagesInComments();
                for (FindUsagesVisitor.UsageInComment usageInComment : usagesInComments) {
                    elements.add(refactoring, WhereUsedElement.create(usageInComment.from, usageInComment.to, compiler, fromTestRoot));
                }
                if(!usagesInComments.isEmpty()) {
                    usedFilters.add(JavaWhereUsedFilters.COMMENT.getKey());
                }
                Collection<WhereUsedElement> foundElements = findVisitor.getElements();
                for (WhereUsedElement el : foundElements) {
                    final ReadWrite access = el.getAccess();
                    if(access != null) {
                        usedAccessFilters.add(access);
                    }
                    elements.add(refactoring, el);
                }
                if(fromTestRoot && !foundElements.isEmpty()) {
                    usedFilters.add(JavaWhereUsedFilters.TESTFILE.getKey());
                }
            }
            Collection<TreePath> result = new ArrayList<TreePath>();
            if (element.getKind() == ElementKind.METHOD && isFindOverridingMethods()) {
                FindOverridingVisitor override = new FindOverridingVisitor(compiler);
                override.scan(compiler.getCompilationUnit(), element);

                result.addAll(subtypes.getUsages());
            }
            for (TreePath tree : result) {
                elements.add(refactoring, WhereUsedElement.create(compiler, tree, fromTestRoot, inImport));
            }
            if(fromTestRoot && !result.isEmpty()) {
                usedFilters.add(JavaWhereUsedFilters.TESTFILE.getKey());
            }
            if(inImport.get()) {
                usedFilters.add(JavaWhereUsedFilters.IMPORT.getKey());
            }
            fireProgressListenerStep();
        }
    }
    
    private static class FileComparator implements Comparator<FileObject> {

        @Override
        public int compare(FileObject o1, FileObject o2) {




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.refactoring.java.spi;

/**
 * Filters used by Java Find Usages plugins.
 * 
 * @author Ralph Benjamin Ruijs <ralphbenjamin@netbeans.org>
 * @since 1.39
 */
public enum JavaWhereUsedFilters {

    IMPORT("filter-import"),
    COMMENT("filter-comment"),
    TESTFILE("filter-testfile");
    private final String key;

    private JavaWhereUsedFilters(String key) {
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public static enum ReadWrite {

        READ("filter-read"),
        WRITE("filter-write"),
        READ_WRITE("filter-readwrite");
        private final String key;

        private ReadWrite(String key) {
            this.key = key;
        }

        public String getKey() {
            return key;
        }
    }
}

Lines 63-68 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/ui/tree/ElementGripFactory.java (+9 lines)
63		63
64	private static ElementGripFactory instance;	64	private static ElementGripFactory instance;
65	private final Map<FileObject, Interval> map = new WeakHashMap<FileObject, Interval>();	65	private final Map<FileObject, Interval> map = new WeakHashMap<FileObject, Interval>();
		66	private final Map<FileObject, Boolean> testFiles = new WeakHashMap<FileObject, Boolean>();
66		67
67	/**	68	/**
68	* Creates a new instance of ElementGripFactory	69	* Creates a new instance of ElementGripFactory
Lines 97-102 Link Here
97	Interval start = map.get(el.getFileObject());	98	Interval start = map.get(el.getFileObject());
98	return start.getParent(el);	99	return start.getParent(el);
99	}	100	}
		101
		102	public void put(FileObject parentFile, Boolean inTestfile) {
		103	testFiles.put(parentFile, inTestfile);
		104	}
		105
		106	public Boolean inTestFile(FileObject parentFile) {
		107	return testFiles.get(parentFile);
		108	}
100		109
101	public void put(FileObject parentFile, TreePath tp, CompilationInfo info) {	110	public void put(FileObject parentFile, TreePath tp, CompilationInfo info) {
102	Interval root = map.get(parentFile);	111	Interval root = map.get(parentFile);





package org.netbeans.modules.refactoring.java.ui.tree;

import java.awt.Image;
import java.beans.BeanInfo;
import javax.swing.Icon;
import javax.swing.ImageIcon;

import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.util.ImageUtilities;

/**
 *

    @Override
    public Icon getIcon() {
        try {
            ImageIcon imageIcon = new ImageIcon(DataObject.find(fo).getNodeDelegate().getIcon(BeanInfo.ICON_COLOR_16x16));
            Boolean inTestFile = ElementGripFactory.getDefault().inTestFile(fo);
            if(Boolean.TRUE == inTestFile) {
                Image mergeImages = ImageUtilities.mergeImages(imageIcon.getImage(),
                        ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_test.png", false).getImage(), 4, 4);
                imageIcon = new ImageIcon(mergeImages);
            }
            return imageIcon;
        } catch (DataObjectNotFoundException ex) {
            return null;
        }





import com.sun.source.tree.Tree;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import org.netbeans.modules.refactoring.api.RefactoringElement;
import org.netbeans.modules.refactoring.spi.ui.TreeElement;
import org.netbeans.modules.refactoring.spi.ui.TreeElementFactory;
import org.openide.util.Lookup;

/**
 *

    private RefactoringElement refactoringElement;
    private ElementGrip thisFeature;
    private ElementGrip parent;
    private Icon icon;
    
    RefactoringTreeElement(RefactoringElement element) {
        final Lookup lookup = element.getLookup();
        this.refactoringElement = element;
        thisFeature = getFeature(lookup.lookup(ElementGrip.class));
        parent = thisFeature;
        icon = lookup.lookup(Icon.class);
    }
    
    @Override


    @Override
    public Icon getIcon() {
        return icon;
    }

    @Override

Lines 98-106 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/ui/tree/TreeElementFactoryImpl.java (-2 / +3 lines)
98	else if (o instanceof Project) {	98	else if (o instanceof Project) {
99	result = new ProjectTreeElement((Project) o);	99	result = new ProjectTreeElement((Project) o);
100	} else if (o instanceof RefactoringElement) {	100	} else if (o instanceof RefactoringElement) {
101	ElementGrip grip = ((RefactoringElement) o).getLookup().lookup(ElementGrip.class);	101	RefactoringElement refactoringElement = (RefactoringElement) o;
		102	ElementGrip grip = (refactoringElement).getLookup().lookup(ElementGrip.class);
102	if (grip!=null) {	103	if (grip!=null) {
103	result = new RefactoringTreeElement((RefactoringElement) o);	104	result = new RefactoringTreeElement(refactoringElement);
104	}	105	}
105	}	106	}
106	if (result != null) {	107	if (result != null) {

Lines 390-395 Link Here

(-)a/refactoring.java/test/unit/src/org/netbeans/modules/refactoring/java/test/FindUsagesTest.java (-2 / +3 lines)
390	wuq[0].fastCheckParameters();	390	wuq[0].fastCheckParameters();
391	wuq[0].checkParameters();	391	wuq[0].checkParameters();
392	wuq[0].prepare(rs);	392	wuq[0].prepare(rs);
		393	rs.finished();
393	rs.doRefactoring(true);	394	rs.doRefactoring(true);
394		395
395	Collection<RefactoringElement> elems = rs.getRefactoringElements();	396	Collection<RefactoringElement> elems = rs.getRefactoringElements();
Lines 414-421 Link Here
414	}	415	}
415		416
416	public static Test suite() throws InterruptedException {	417	public static Test suite() throws InterruptedException {
417	return NbModuleSuite.create(NbModuleSuite.createConfiguration(FindUsagesTest.class)	418	return NbModuleSuite.createConfiguration(FindUsagesTest.class)
418	.clusters(".").enableModules(".")	419	.clusters(".").enableModules(".")
419	.gui(false));	420	.gui(false).suite();
420	}	421	}
421	}	422	}

Return to bug 215361

Lines 56-64 Link Here

(-)a/refactoring.api/src/org/netbeans/modules/refactoring/plugins/RefactoringTreeElement.java (-1 / +3 lines)
56	public class RefactoringTreeElement implements TreeElement {	56	public class RefactoringTreeElement implements TreeElement {
57		57
58	RefactoringElement element;	58	RefactoringElement element;
		59	private final Icon icon;
59		60
60	RefactoringTreeElement(RefactoringElement element) {	61	RefactoringTreeElement(RefactoringElement element) {
61	this.element = element;	62	this.element = element;
		63	icon = element.getLookup().lookup(Icon.class);
62	}	64	}
63		65
64	@Override	66	@Override
Lines 74-80 Link Here
74		76
75	@Override	77	@Override
76	public Icon getIcon() {	78	public Icon getIcon() {
77	return null;	79	return icon;
78	}	80	}
79		81
80	@Override	82	@Override

Lines 49-54 Link Here

(-)a/refactoring.java/apichanges.xml (+21 lines)
49	<apidef name="JavaRefactoringAPI">Java Refactoring API</apidef>	49	<apidef name="JavaRefactoringAPI">Java Refactoring API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="JavaWhereUsedFilters">
		53	<api name="JavaRefactoringAPI"/>
		54	<summary>Added refactoring filter keys for find usages results.</summary>
		55	<version major="1" minor="39"/>
		56	<date day="10" month="7" year="2012"/>
		57	<author login="ralphbenjamin"/>
		58	<compatibility addition="yes"/>
		59	<description>
		60	<p>Added an enumeration with keys to identify different filters used by Java Refactoring's Find Usages.
		61	IMPORT("filter-import")
		62	COMMENT("filter-comment")
		63	TESTFILE("filter-testfile")
		64	READ("filter-read")
		65	WRITE("filter-write")
		66	READ_WRITE("filter-readwrite")
		67	</p>
		68	</description>
		69	<class package="org.netbeans.modules.refactoring.java.spi"
		70	name="JavaWhereUsedFilters"/>
		71	<issue number="215361"/>
		72	</change>
52	<change id="ReplaceConstructorWithBuilder-ReplaceConstructorWithFactory-InvertBoolean">	73	<change id="ReplaceConstructorWithBuilder-ReplaceConstructorWithFactory-InvertBoolean">
53	<api name="JavaRefactoringAPI"/>	74	<api name="JavaRefactoringAPI"/>
54	<summary>New refactorings on board: ReplaceConstructorWithFactory,	75	<summary>New refactorings on board: ReplaceConstructorWithFactory,

Lines 66-71 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/RefactoringUtils.java (+12 lines)
66	import org.netbeans.api.java.project.JavaProjectConstants;	66	import org.netbeans.api.java.project.JavaProjectConstants;
67	import org.netbeans.api.java.queries.SourceForBinaryQuery;	67	import org.netbeans.api.java.queries.SourceForBinaryQuery;
68	import org.netbeans.api.java.queries.SourceForBinaryQuery.Result;	68	import org.netbeans.api.java.queries.SourceForBinaryQuery.Result;
		69	import org.netbeans.api.java.queries.UnitTestForSourceQuery;
69	import org.netbeans.api.java.source.*;	70	import org.netbeans.api.java.source.*;
70	import org.netbeans.api.project.FileOwnerQuery;	71	import org.netbeans.api.project.FileOwnerQuery;
71	import org.netbeans.api.project.Project;	72	import org.netbeans.api.project.Project;
Lines 978-983 Link Here
978	return "<default>"; //NOI18N	979	return "<default>"; //NOI18N
979	}	980	}
980		981
		982	public static boolean isFromTestRoot(FileObject file, ClassPath cp) {
		983	boolean inTest = false;
		984	if (cp != null) {
		985	FileObject root = cp.findOwnerRoot(file);
		986	if (UnitTestForSourceQuery.findSources(root).length > 0) {
		987	inTest = true;
		988	}
		989	}
		990	return inTest;
		991	}
		992
981	private RefactoringUtils() {	993	private RefactoringUtils() {
982	}	994	}
983	}	995	}

Lines 44-61 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/WhereUsedElement.java (-9 / +100 lines)
44	package org.netbeans.modules.refactoring.java;	44	package org.netbeans.modules.refactoring.java;
45		45
46	import com.sun.source.tree.*;	46	import com.sun.source.tree.*;
		47	import com.sun.source.tree.Tree.Kind;
47	import com.sun.source.util.SourcePositions;	48	import com.sun.source.util.SourcePositions;
48	import com.sun.source.util.TreePath;	49	import com.sun.source.util.TreePath;
49	import com.sun.source.util.Trees;	50	import com.sun.source.util.Trees;
		51	import java.util.concurrent.atomic.AtomicBoolean;
50	import javax.lang.model.element.Element;	52	import javax.lang.model.element.Element;
51	import javax.lang.model.element.ElementKind;	53	import javax.lang.model.element.ElementKind;
		54	import javax.swing.Icon;
52	import javax.swing.text.Position.Bias;	55	import javax.swing.text.Position.Bias;
53	import org.netbeans.api.java.source.CompilationInfo;	56	import org.netbeans.api.java.source.CompilationInfo;
54	import org.netbeans.api.java.source.TreeUtilities;	57	import org.netbeans.api.java.source.TreeUtilities;
55	import org.netbeans.modules.refactoring.java.plugins.JavaWhereUsedQueryPlugin;	58	import org.netbeans.modules.refactoring.java.plugins.JavaWhereUsedQueryPlugin;
		59	import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
		60	import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters.ReadWrite;
56	import org.netbeans.modules.refactoring.java.ui.UIUtilities;	61	import org.netbeans.modules.refactoring.java.ui.UIUtilities;
57	import org.netbeans.modules.refactoring.java.ui.WhereUsedPanel;	62	import org.netbeans.modules.refactoring.java.ui.WhereUsedPanel;
58	import org.netbeans.modules.refactoring.java.ui.tree.ElementGripFactory;	63	import org.netbeans.modules.refactoring.java.ui.tree.ElementGripFactory;
		64	import org.netbeans.modules.refactoring.spi.FiltersManager;
59	import org.netbeans.modules.refactoring.spi.SimpleRefactoringElementImplementation;	65	import org.netbeans.modules.refactoring.spi.SimpleRefactoringElementImplementation;
60	import org.openide.ErrorManager;	66	import org.openide.ErrorManager;
61	import org.openide.filesystems.FileObject;	67	import org.openide.filesystems.FileObject;
Lines 65-85 Link Here
65	import org.openide.text.PositionBounds;	71	import org.openide.text.PositionBounds;
66	import org.openide.text.PositionRef;	72	import org.openide.text.PositionRef;
67	import org.openide.util.Exceptions;	73	import org.openide.util.Exceptions;
		74	import org.openide.util.ImageUtilities;
68	import org.openide.util.Lookup;	75	import org.openide.util.Lookup;
69	import org.openide.util.NbBundle;	76	import org.openide.util.NbBundle;
70	import org.openide.util.lookup.Lookups;	77	import org.openide.util.lookup.Lookups;
71		78
72	public class WhereUsedElement extends SimpleRefactoringElementImplementation {	79	public class WhereUsedElement extends SimpleRefactoringElementImplementation implements FiltersManager.Filterable {
73	private PositionBounds bounds;	80	private PositionBounds bounds;
74	private String displayText;	81	private String displayText;
75	private FileObject parentFile;	82	private FileObject parentFile;
76	public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info) {	83	private final JavaWhereUsedFilters.ReadWrite access;
		84	private final boolean inComment;
		85	private final boolean inImport;
		86	private final boolean inTestclass;
		87
		88	// public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info) {
		89	// this(bounds, displayText, parentFile, tp, info, null, false, true);
		90	// }
		91	//
		92	// public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info, JavaWhereUsedFilters.ReadWrite access) {
		93	// this(bounds, displayText, parentFile, tp, info, access, false, false);
		94	// }
		95
		96	public WhereUsedElement(PositionBounds bounds, String displayText, FileObject parentFile, TreePath tp, CompilationInfo info, ReadWrite access, boolean inTestclass, boolean inComment, boolean inImport) {
77	this.bounds = bounds;	97	this.bounds = bounds;
78	this.displayText = displayText;	98	this.displayText = displayText;
79	this.parentFile = parentFile;	99	this.parentFile = parentFile;
80	if (tp!=null) {	100	if (tp != null) {
81	ElementGripFactory.getDefault().put(parentFile, tp, info);	101	ElementGripFactory.getDefault().put(parentFile, tp, info);
82	}	102	}
		103	ElementGripFactory.getDefault().put(parentFile, inTestclass);
		104	this.access = access;
		105	this.inTestclass = inTestclass;
		106	this.inComment = inComment;
		107	this.inImport = inImport;
83	}	108	}
84		109
85	@Override	110	@Override
Lines 93-99 Link Here
93	if (composite==null) {	118	if (composite==null) {
94	composite = parentFile;	119	composite = parentFile;
95	}	120	}
96	return Lookups.singleton(composite);	121	Icon icon = null;
		122	if(access != null) {
		123	switch(access) {
		124	case WRITE:
		125	icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_write.png", false);
		126	break;
		127	case READ_WRITE:
		128	icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_readwrite.png", false);
		129	break;
		130	default:
		131	case READ:
		132	icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_read.png", false);
		133	break;
		134	}
		135	} else if(inComment) {
		136	icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_comment.png", false);
		137	} else if(inImport) {
		138	icon = ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_import.png", false);
		139	}
		140	return icon != null ? Lookups.fixed(composite, icon) : Lookups.singleton(composite);
97	}	141	}
98		142
99	@Override	143	@Override
Lines 114-121 Link Here
114	public FileObject getParentFile() {	158	public FileObject getParentFile() {
115	return parentFile;	159	return parentFile;
116	}	160	}
		161
		162	public JavaWhereUsedFilters.ReadWrite getAccess() {
		163	return access;
		164	}
117		165
118	public static WhereUsedElement create(CompilationInfo compiler, TreePath tree) {	166	public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, boolean inTest) {
		167	return create(compiler, tree, null, inTest, new AtomicBoolean());
		168	}
		169
		170	public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, boolean inTest, AtomicBoolean inImport) {
		171	return create(compiler, tree, null, inTest, inImport);
		172	}
		173
		174	public static WhereUsedElement create(CompilationInfo compiler, TreePath tree, JavaWhereUsedFilters.ReadWrite access, boolean inTest, AtomicBoolean inImport) {
119	CompilationUnitTree unit = tree.getCompilationUnit();	175	CompilationUnitTree unit = tree.getCompilationUnit();
120	CharSequence content = compiler.getSnapshot().getText();	176	CharSequence content = compiler.getSnapshot().getText();
121	SourcePositions sp = compiler.getTrees().getSourcePositions();	177	SourcePositions sp = compiler.getTrees().getSourcePositions();
Lines 135-140 Link Here
135	}	191	}
136	t = tree.getLeaf();	192	t = tree.getLeaf();
137	}	193	}
		194
		195	boolean elementInImport = false;
		196	if(t.getKind() == Tree.Kind.IDENTIFIER \|\| t.getKind() == Tree.Kind.MEMBER_SELECT) {
		197	TreePath enclosingTree = getEnclosingImportTree(tree);
		198	if(enclosingTree != null) {
		199	elementInImport = true;
		200	inImport.set(true);
		201	}
		202	}
138		203
139	if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) {	204	if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) {
140	int[] pos = treeUtils.findNameSpan((ClassTree)t);	205	int[] pos = treeUtils.findNameSpan((ClassTree)t);
Lines 231-237 Link Here
231	end = start;	296	end = start;
232	}	297	}
233	}	298	}
234		299
235	assert start>0:"Cannot find start position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();	300	assert start>0:"Cannot find start position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();
236	assert end>0:"Cannot find end position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();	301	assert end>0:"Cannot find end position in file " + unit.getSourceFile().getName() + "\n tree=" + tree.toString();
237	LineMap lm = tree.getCompilationUnit().getLineMap();	302	LineMap lm = tree.getCompilationUnit().getLineMap();
Lines 264-270 Link Here
264	start==end && anonClassNameBug128074 ? NbBundle.getMessage(WhereUsedPanel.class, "LBL_AnonymousClass"):sb.toString().trim(),	329	start==end && anonClassNameBug128074 ? NbBundle.getMessage(WhereUsedPanel.class, "LBL_AnonymousClass"):sb.toString().trim(),
265	compiler.getFileObject(),	330	compiler.getFileObject(),
266	tr,	331	tr,
267	compiler);	332	compiler, access, inTest, false, elementInImport);
268	}	333	}
269		334
270	private static String trimStart(String s) {	335	private static String trimStart(String s) {
Lines 289-295 Link Here
289	return "";	354	return "";
290	}	355	}
291		356
292	public static WhereUsedElement create(int start, int end, CompilationInfo compiler) {	357	public static WhereUsedElement create(int start, int end, CompilationInfo compiler, boolean inTest) {
293	CharSequence content = compiler.getSnapshot().getText();	358	CharSequence content = compiler.getSnapshot().getText();
294	LineMap lm = compiler.getCompilationUnit().getLineMap();	359	LineMap lm = compiler.getCompilationUnit().getLineMap();
295	long line = lm.getLineNumber(start);	360	long line = lm.getLineNumber(start);
Lines 315-323 Link Here
315	PositionRef ref1 = ces.createPositionRef(start, Bias.Forward);	380	PositionRef ref1 = ces.createPositionRef(start, Bias.Forward);
316	PositionRef ref2 = ces.createPositionRef(end, Bias.Forward);	381	PositionRef ref2 = ces.createPositionRef(end, Bias.Forward);
317	PositionBounds bounds = new PositionBounds(ref1, ref2);	382	PositionBounds bounds = new PositionBounds(ref1, ref2);
318	return new WhereUsedElement(bounds, sb.toString().trim(), compiler.getFileObject(), null, compiler);	383	return new WhereUsedElement(bounds, sb.toString().trim(), compiler.getFileObject(), null, compiler, null, inTest, true, false);
319	}	384	}
320		385
		386	private static TreePath getEnclosingImportTree(TreePath tp) {
		387	while(tp != null) {
		388	Tree tree = tp.getLeaf();
		389	if (tree.getKind() == Tree.Kind.IMPORT) {
		390	return tp;
		391	}
		392	tp = tp.getParentPath();
		393	}
		394	return null;
		395	}
321		396
322	private static TreePath getEnclosingTree(TreePath tp) {	397	private static TreePath getEnclosingTree(TreePath tp) {
323	while(tp != null) {	398	while(tp != null) {
Lines 330-333 Link Here
330	return null;	405	return null;
331	}	406	}
332		407
		408	@Override
		409	public boolean filter(FiltersManager manager) {
		410	if(!inTestclass \|\| (inTestclass && manager.isSelected(JavaWhereUsedFilters.TESTFILE.getKey()))) {
		411	if (access != null) {
		412	return manager.isSelected(access.getKey());
		413	} else if (inComment) {
		414	return manager.isSelected(JavaWhereUsedFilters.COMMENT.getKey());
		415	} else if (inImport) {
		416	return manager.isSelected(JavaWhereUsedFilters.IMPORT.getKey());
		417	} else {
		418	return true;
		419	}
		420	} else {
		421	return false;
		422	}
		423	}
333	}	424	}

Lines 41-101 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/plugins/FindUsagesVisitor.java (-55 / +175 lines)
41	* Version 2 license, then the option applies only if the new code is	41	* Version 2 license, then the option applies only if the new code is
42	* made subject to such option by the copyright holder.	42	* made subject to such option by the copyright holder.
43	*/	43	*/
44
45	package org.netbeans.modules.refactoring.java.plugins;	44	package org.netbeans.modules.refactoring.java.plugins;
46		45
47	import com.sun.source.tree.*;	46	import com.sun.source.tree.*;
48	import com.sun.source.tree.Tree.Kind;	47	import com.sun.source.tree.Tree.Kind;
49	import com.sun.source.util.TreePath;	48	import com.sun.source.util.TreePath;
		49	import com.sun.source.util.TreePathScanner;
50	import com.sun.source.util.Trees;	50	import com.sun.source.util.Trees;
		51	import java.io.IOException;
51	import java.util.*;	52	import java.util.*;
		53	import java.util.concurrent.atomic.AtomicBoolean;
		54	import java.util.logging.Level;
52	import java.util.logging.Logger;	55	import java.util.logging.Logger;
53	import javax.lang.model.element.*;	56	import javax.lang.model.element.*;
54	import javax.lang.model.type.TypeMirror;	57	import javax.lang.model.type.TypeMirror;
55	import javax.lang.model.util.ElementFilter;	58	import javax.lang.model.util.ElementFilter;
56	import org.netbeans.api.java.lexer.JavaTokenId;	59	import org.netbeans.api.java.lexer.JavaTokenId;
		60	import org.netbeans.api.java.source.ClasspathInfo.PathKind;
57	import org.netbeans.api.java.source.CompilationController;	61	import org.netbeans.api.java.source.CompilationController;
58	import org.netbeans.api.java.source.ElementUtilities;	62	import org.netbeans.api.java.source.ElementUtilities;
		63	import org.netbeans.api.java.source.JavaSource;
59	import org.netbeans.api.lexer.Token;	64	import org.netbeans.api.lexer.Token;
60	import org.netbeans.api.lexer.TokenSequence;	65	import org.netbeans.api.lexer.TokenSequence;
		66	import org.netbeans.modules.refactoring.java.RefactoringUtils;
		67	import org.netbeans.modules.refactoring.java.WhereUsedElement;
		68	import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
		69	import org.netbeans.modules.refactoring.java.spi.ToPhaseException;
		70	import org.openide.ErrorManager;
		71	import org.openide.util.Exceptions;
61		72
62	/**	73	/**
63	*	74	*
64	* @author Jan Becicka	75	* @author Jan Becicka
65	*/	76	*/
66	public class FindUsagesVisitor extends FindVisitor {	77	public class FindUsagesVisitor extends TreePathScanner<Tree, Element> {
67		78
		79	private Collection<TreePath> usages = new ArrayList<TreePath>();
		80	private Collection<WhereUsedElement> elements = new ArrayList<WhereUsedElement>();
		81	protected CompilationController workingCopy;
		82	private Collection<UsageInComment> usagesInComments = Collections.<UsageInComment>emptyList();
68	private boolean findInComments = false;	83	private boolean findInComments = false;
69	private Collection<UsageInComment> usagesInComments = Collections.<UsageInComment>emptyList();	84	private final boolean fromTestRoot;
		85	private final AtomicBoolean inImport;
		86
70	public FindUsagesVisitor(CompilationController workingCopy) {	87	public FindUsagesVisitor(CompilationController workingCopy) {
71	super(workingCopy);	88	this(workingCopy, false);
		89	}
		90
		91	public FindUsagesVisitor(CompilationController workingCopy, boolean findInComments) {
		92	this(workingCopy, findInComments, RefactoringUtils.isFromTestRoot(workingCopy.getFileObject(), workingCopy.getClasspathInfo().getClassPath(PathKind.SOURCE)), new AtomicBoolean());
72	}	93	}
73		94
74	public Collection<UsageInComment> getUsagesInComments() {	95	public FindUsagesVisitor(CompilationController workingCopy, boolean findInComments, boolean fromTestRoot, AtomicBoolean inImport) {
75	return usagesInComments;	96	try {
76	}	97	setWorkingCopy(workingCopy);
77		98	} catch (ToPhaseException ex) {
78	public FindUsagesVisitor(CompilationController workingCopy, boolean findInComments) {	99	Exceptions.printStackTrace(ex);
79	super(workingCopy);	100	}
80	this.findInComments = findInComments;	101	this.findInComments = findInComments;
81	if (findInComments) {	102	if (findInComments) {
82	usagesInComments = new ArrayList<UsageInComment>();	103	usagesInComments = new ArrayList<UsageInComment>();
83	}	104	}
		105	this.fromTestRoot = fromTestRoot;
		106	this.inImport = inImport;
84	}	107	}
85		108
		109	//<editor-fold defaultstate="collapsed" desc="Find in Comments">
86	@Override	110	@Override
87	public Tree visitCompilationUnit(CompilationUnitTree node, Element p) {	111	public Tree visitCompilationUnit(CompilationUnitTree node, Element p) {
88	if (findInComments) {	112	if (findInComments) {
89	String originalName = p.getSimpleName().toString();	113	String originalName = p.getSimpleName().toString();
90	TokenSequence<JavaTokenId> ts = workingCopy.getTokenHierarchy().tokenSequence(JavaTokenId.language());	114	TokenSequence<JavaTokenId> ts = workingCopy.getTokenHierarchy().tokenSequence(JavaTokenId.language());
91		115
92	while (ts.moveNext()) {	116	while (ts.moveNext()) {
93	Token t = ts.token();	117	Token t = ts.token();
94		118
95	if (t.id() == JavaTokenId.BLOCK_COMMENT \|\| t.id() == JavaTokenId.LINE_COMMENT \|\| t.id() == JavaTokenId.JAVADOC_COMMENT) {	119	if (t.id() == JavaTokenId.BLOCK_COMMENT \|\| t.id() == JavaTokenId.LINE_COMMENT \|\| t.id() == JavaTokenId.JAVADOC_COMMENT) {
96	Scanner tokenizer = new Scanner(t.text().toString());	120	Scanner tokenizer = new Scanner(t.text().toString());
97	tokenizer.useDelimiter("[^a-zA-Z0-9_]"); //NOI18N	121	tokenizer.useDelimiter("[^a-zA-Z0-9_]"); //NOI18N
98		122
99	while (tokenizer.hasNext()) {	123	while (tokenizer.hasNext()) {
100	String current = tokenizer.next();	124	String current = tokenizer.next();
101	if (current.equals(originalName)) {	125	if (current.equals(originalName)) {
Lines 107-149 Link Here
107	}	131	}
108	return super.visitCompilationUnit(node, p);	132	return super.visitCompilationUnit(node, p);
109	}	133	}
		134	//</editor-fold>
110		135
111	@Override
112	public Tree visitIdentifier(IdentifierTree node, Element p) {
113	addIfMatch(getCurrentPath(), node, p);
114	return super.visitIdentifier(node, p);
115	}
116
117	@Override
118	public Tree visitMemberSelect(MemberSelectTree node, Element p) {
119	addIfMatch(getCurrentPath(), node,p);
120	return super.visitMemberSelect(node, p);
121	}
122
123	@Override
124	public Tree visitNewClass(NewClassTree node, Element p) {
125	Trees trees = workingCopy.getTrees();
126	ClassTree classTree = ((NewClassTree) node).getClassBody();
127	if (classTree != null && p.getKind()==ElementKind.CONSTRUCTOR) {
128	Element anonClass = workingCopy.getTrees().getElement(TreePath.getPath(workingCopy.getCompilationUnit(), classTree));
129	if (anonClass==null) {
130	Logger.getLogger("org.netbeans.modules.refactoring.java").severe("FindUsages cannot resolve " + classTree);
131	} else {
132	for (ExecutableElement c : ElementFilter.constructorsIn(anonClass.getEnclosedElements())) {
133	MethodTree t = workingCopy.getTrees().getTree(c);
134	TreePath superCall = trees.getPath(workingCopy.getCompilationUnit(), ((ExpressionStatementTree) t.getBody().getStatements().get(0)).getExpression());
135	Element superCallElement = trees.getElement(superCall);
136	if (superCallElement != null && superCallElement.equals(p) && !workingCopy.getTreeUtilities().isSynthetic(superCall)) {
137	addUsage(superCall);
138	}
139	}
140	}
141	} else {
142	addIfMatch(getCurrentPath(), node, p);
143	}
144	return super.visitNewClass(node, p);
145	}
146
147	private void addIfMatch(TreePath path, Tree tree, Element elementToFind) {	136	private void addIfMatch(TreePath path, Tree tree, Element elementToFind) {
148	if (workingCopy.getTreeUtilities().isSynthetic(path)) {	137	if (workingCopy.getTreeUtilities().isSynthetic(path)) {
149	if (ElementKind.CONSTRUCTOR != elementToFind.getKind()	138	if (ElementKind.CONSTRUCTOR != elementToFind.getKind()
Lines 158-164 Link Here
158	if (el == null) {	147	if (el == null) {
159	path = path.getParentPath();	148	path = path.getParentPath();
160	if (path != null && path.getLeaf().getKind() == Kind.IMPORT) {	149	if (path != null && path.getLeaf().getKind() == Kind.IMPORT) {
161	ImportTree impTree = (ImportTree)path.getLeaf();	150	ImportTree impTree = (ImportTree) path.getLeaf();
162	if (!impTree.isStatic()) {	151	if (!impTree.isStatic()) {
163	return;	152	return;
164	}	153	}
Lines 176-182 Link Here
176	if (el == null) {	165	if (el == null) {
177	return;	166	return;
178	}	167	}
179	Iterator iter = workingCopy.getElementUtilities().getMembers(el.asType(),new ElementUtilities.ElementAcceptor() {	168	Iterator iter = workingCopy.getElementUtilities().getMembers(el.asType(), new ElementUtilities.ElementAcceptor() {
180	@Override	169	@Override
181	public boolean accept(Element e, TypeMirror type) {	170	public boolean accept(Element e, TypeMirror type) {
182	return id.equals(e.getSimpleName());	171	return id.equals(e.getSimpleName());
Lines 192-213 Link Here
192	return;	181	return;
193	}	182	}
194	}	183	}
195	if (elementToFind!=null&& elementToFind.getKind() == ElementKind.METHOD && el.getKind() == ElementKind.METHOD) {	184	if (elementToFind != null && elementToFind.getKind() == ElementKind.METHOD && el.getKind() == ElementKind.METHOD) {
196	if (el.equals(elementToFind) \|\| workingCopy.getElements().overrides((ExecutableElement) el, (ExecutableElement) elementToFind, (TypeElement) elementToFind.getEnclosingElement())) {	185	if (el.equals(elementToFind) \|\| workingCopy.getElements().overrides((ExecutableElement) el, (ExecutableElement) elementToFind, (TypeElement) elementToFind.getEnclosingElement())) {
197	addUsage(getCurrentPath());	186	addUsage(path);
198	}	187	}
199	} else if (el.equals(elementToFind)) {	188	} else if (el.equals(elementToFind)) {
200	addUsage(getCurrentPath());	189	final ElementKind kind = elementToFind.getKind();
		190	if(kind.isField() \|\| kind == ElementKind.LOCAL_VARIABLE \|\| kind == ElementKind.RESOURCE_VARIABLE) {
		191	JavaWhereUsedFilters.ReadWrite access = JavaWhereUsedFilters.ReadWrite.READ;
		192	TreePath parentPath = path.getParentPath();
		193	Tree parentTree = parentPath.getLeaf();
		194	Kind parentKind = parentTree.getKind();
		195
		196	switch(parentKind) {
		197	case ARRAY_ACCESS:
		198	case MEMBER_SELECT:
		199	// TODO: Check usages of arrays for writing
		200	break;
		201
		202	case POSTFIX_INCREMENT:
		203	case POSTFIX_DECREMENT:
		204	case PREFIX_INCREMENT:
		205	case PREFIX_DECREMENT:
		206	access = JavaWhereUsedFilters.ReadWrite.READ_WRITE;
		207	break;
		208
		209	case ASSIGNMENT: {
		210	AssignmentTree assignmentTree = (AssignmentTree) parentTree;
		211	ExpressionTree left = assignmentTree.getVariable();
		212	if (left.equals(tree)) {
		213	access = JavaWhereUsedFilters.ReadWrite.WRITE;
		214	}
		215	break;
		216	}
		217	case MULTIPLY_ASSIGNMENT:
		218	case DIVIDE_ASSIGNMENT:
		219	case REMAINDER_ASSIGNMENT:
		220	case PLUS_ASSIGNMENT:
		221	case MINUS_ASSIGNMENT:
		222	case LEFT_SHIFT_ASSIGNMENT:
		223	case RIGHT_SHIFT_ASSIGNMENT:
		224	case UNSIGNED_RIGHT_SHIFT_ASSIGNMENT:
		225	case AND_ASSIGNMENT:
		226	case XOR_ASSIGNMENT:
		227	case OR_ASSIGNMENT: {
		228	CompoundAssignmentTree compoundAssignmentTree = (CompoundAssignmentTree) parentTree;
		229	ExpressionTree left = compoundAssignmentTree.getVariable();
		230	if (left.equals(tree)) {
		231	access = JavaWhereUsedFilters.ReadWrite.READ_WRITE;
		232	}
		233	break;
		234	}
		235	}
		236	addUsage(path, access);
		237	} else {
		238	addUsage(path);
		239	}
201	}	240	}
202	}	241	}
		242
		243	/**
		244	*
		245	* @param workingCopy
		246	* @throws org.netbeans.modules.refactoring.java.spi.ToPhaseException
		247	*/
		248	public final void setWorkingCopy(CompilationController workingCopy) throws ToPhaseException {
		249	this.workingCopy = workingCopy;
		250	try {
		251	if (this.workingCopy.toPhase(JavaSource.Phase.RESOLVED) != JavaSource.Phase.RESOLVED) {
		252	throw new ToPhaseException();
		253	}
		254	} catch (IOException ioe) {
		255	ErrorManager.getDefault().notify(ioe);
		256	}
		257	}
		258
		259	public Collection<UsageInComment> getUsagesInComments() {
		260	return usagesInComments;
		261	}
203		262
		263	protected void addUsage(TreePath tp, JavaWhereUsedFilters.ReadWrite access) {
		264	assert tp != null;
		265	elements.add(WhereUsedElement.create(workingCopy, tp, access, fromTestRoot, inImport));
		266	usages.add(tp);
		267	}
		268
		269	public boolean isInImport() {
		270	return inImport.get();
		271	}
		272
		273	protected void addUsage(TreePath tp) {
		274	assert tp != null;
		275	elements.add(WhereUsedElement.create(workingCopy, tp, fromTestRoot, inImport));
		276	usages.add(tp);
		277	}
		278
		279	public Collection<WhereUsedElement> getElements() {
		280	return elements;
		281	}
		282
		283	public Collection<TreePath> getUsages() {
		284	return usages;
		285	}
		286
		287	@Override
		288	public Tree visitIdentifier(IdentifierTree node, Element p) {
		289	addIfMatch(getCurrentPath(), node, p);
		290	return super.visitIdentifier(node, p);
		291	}
		292
		293	@Override
		294	public Tree visitMemberSelect(MemberSelectTree node, Element p) {
		295	addIfMatch(getCurrentPath(), node, p);
		296	return super.visitMemberSelect(node, p);
		297	}
		298
		299	@Override
		300	public Tree visitNewClass(NewClassTree node, Element p) {
		301	Trees trees = workingCopy.getTrees();
		302	ClassTree classTree = ((NewClassTree) node).getClassBody();
		303	if (classTree != null && p.getKind() == ElementKind.CONSTRUCTOR) {
		304	Element anonClass = workingCopy.getTrees().getElement(TreePath.getPath(workingCopy.getCompilationUnit(), classTree));
		305	if (anonClass == null) {
		306	Logger.getLogger("org.netbeans.modules.refactoring.java").log(Level.SEVERE, "FindUsages cannot resolve {0}", classTree); // NOI18N
		307	} else {
		308	for (ExecutableElement c : ElementFilter.constructorsIn(anonClass.getEnclosedElements())) {
		309	MethodTree t = workingCopy.getTrees().getTree(c);
		310	TreePath superCall = trees.getPath(workingCopy.getCompilationUnit(), ((ExpressionStatementTree) t.getBody().getStatements().get(0)).getExpression());
		311	Element superCallElement = trees.getElement(superCall);
		312	if (superCallElement != null && superCallElement.equals(p) && !workingCopy.getTreeUtilities().isSynthetic(superCall)) {
		313	addUsage(superCall);
		314	}
		315	}
		316	}
		317	} else {
		318	addIfMatch(getCurrentPath(), node, p);
		319	}
		320	return super.visitNewClass(node, p);
		321	}
		322
204	public static class UsageInComment {	323	public static class UsageInComment {
		324
205	int from;	325	int from;
206	int to;	326	int to;
		327
207	public UsageInComment(int from, int to) {	328	public UsageInComment(int from, int to) {
208	this.from = from;	329	this.from = from;
209	this.to = to;	330	this.to = to;
210	}	331	}
211	}	332	}
212	}	333	}
213

Lines 47-53 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/plugins/JavaWhereUsedQueryPlugin.java (-16 / +69 lines)
47	import com.sun.source.tree.Tree;	47	import com.sun.source.tree.Tree;
48	import com.sun.source.util.TreePath;	48	import com.sun.source.util.TreePath;
49	import java.io.IOException;	49	import java.io.IOException;
50	import java.net.URL;
51	import java.util.*;	50	import java.util.*;
52	import java.util.concurrent.atomic.AtomicBoolean;	51	import java.util.concurrent.atomic.AtomicBoolean;
53	import javax.lang.model.element.Element;	52	import javax.lang.model.element.Element;
Lines 56-86 Link Here
56	import javax.lang.model.element.TypeElement;	55	import javax.lang.model.element.TypeElement;
57	import org.netbeans.api.fileinfo.NonRecursiveFolder;	56	import org.netbeans.api.fileinfo.NonRecursiveFolder;
58	import org.netbeans.api.java.classpath.ClassPath;	57	import org.netbeans.api.java.classpath.ClassPath;
		58	import org.netbeans.api.java.source.*;
59	import org.netbeans.api.java.source.ClassIndex.SearchScopeType;	59	import org.netbeans.api.java.source.ClassIndex.SearchScopeType;
60	import org.netbeans.api.java.source.*;
61	import org.netbeans.modules.refactoring.api.*;	60	import org.netbeans.modules.refactoring.api.*;
62	import org.netbeans.modules.refactoring.java.RefactoringUtils;	61	import org.netbeans.modules.refactoring.java.RefactoringUtils;
63	import org.netbeans.modules.refactoring.java.SourceUtilsEx;	62	import org.netbeans.modules.refactoring.java.SourceUtilsEx;
64	import org.netbeans.modules.refactoring.java.WhereUsedElement;	63	import org.netbeans.modules.refactoring.java.WhereUsedElement;
65	import org.netbeans.modules.refactoring.java.api.JavaRefactoringUtils;	64	import org.netbeans.modules.refactoring.java.api.JavaRefactoringUtils;
66	import org.netbeans.modules.refactoring.java.api.WhereUsedQueryConstants;	65	import org.netbeans.modules.refactoring.java.api.WhereUsedQueryConstants;
		66	import org.netbeans.modules.refactoring.java.plugins.FindUsagesVisitor.UsageInComment;
67	import org.netbeans.modules.refactoring.java.spi.JavaRefactoringPlugin;	67	import org.netbeans.modules.refactoring.java.spi.JavaRefactoringPlugin;
		68	import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters;
		69	import org.netbeans.modules.refactoring.java.spi.JavaWhereUsedFilters.ReadWrite;
68	import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;	70	import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
69	import org.netbeans.spi.java.classpath.support.ClassPathSupport;	71	import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
70	import org.openide.ErrorManager;	72	import org.openide.ErrorManager;
71	import org.openide.filesystems.FileObject;	73	import org.openide.filesystems.FileObject;
		74	import org.openide.filesystems.FileSystem;
72	import org.openide.loaders.DataObject;	75	import org.openide.loaders.DataObject;
73	import org.openide.text.CloneableEditorSupport;	76	import org.openide.text.CloneableEditorSupport;
74	import org.openide.util.Exceptions;	77	import org.openide.util.ImageUtilities;
75	import org.openide.util.NbBundle;	78	import org.openide.util.NbBundle;
76	import org.openide.util.lookup.Lookups;
77		79
78	/**	80	/**
79	*	81	*
80	* @author Jan Becicka	82	* @author Jan Becicka
81	* @author Ralph Ruijs	83	* @author Ralph Ruijs
82	*/	84	*/
83	public class JavaWhereUsedQueryPlugin extends JavaRefactoringPlugin {	85	public class JavaWhereUsedQueryPlugin extends JavaRefactoringPlugin implements FiltersDescription.Provider {
84	private boolean fromLibrary;	86	private boolean fromLibrary;
85	private WhereUsedQuery refactoring;	87	private WhereUsedQuery refactoring;
86	private ClasspathInfo cp;	88	private ClasspathInfo cp;
Lines 340-346 Link Here
340	fireProgressListenerStep(a.size());	342	fireProgressListenerStep(a.size());
341	Problem problem = null;	343	Problem problem = null;
342	try {	344	try {
343	queryFiles(a, new FindTask(elements));	345	final FindTask findTask = new FindTask(elements);
		346	queryFiles(a, findTask);
344	} catch (IOException e) {	347	} catch (IOException e) {
345	problem = createProblemAndLog(null, e);	348	problem = createProblemAndLog(null, e);
346	}	349	}
Lines 379-389 Link Here
379	}	382	}
380		383
381	public static CloneableEditorSupport findCloneableEditorSupport(DataObject dob) {	384	public static CloneableEditorSupport findCloneableEditorSupport(DataObject dob) {
382	Object obj = dob.getCookie(org.openide.cookies.OpenCookie.class);	385	Object obj = dob.getLookup().lookup(org.openide.cookies.OpenCookie.class);
383	if (obj instanceof CloneableEditorSupport) {	386	if (obj instanceof CloneableEditorSupport) {
384	return (CloneableEditorSupport)obj;	387	return (CloneableEditorSupport)obj;
385	}	388	}
386	obj = dob.getCookie(org.openide.cookies.EditorCookie.class);	389	obj = dob.getLookup().lookup(org.openide.cookies.EditorCookie.class);
387	if (obj instanceof CloneableEditorSupport) {	390	if (obj instanceof CloneableEditorSupport) {
388	return (CloneableEditorSupport)obj;	391	return (CloneableEditorSupport)obj;
389	}	392	}
Lines 406-411 Link Here
406	private boolean isSearchFromBaseClass() {	409	private boolean isSearchFromBaseClass() {
407	return refactoring.getBooleanValue(WhereUsedQueryConstants.SEARCH_FROM_BASECLASS);	410	return refactoring.getBooleanValue(WhereUsedQueryConstants.SEARCH_FROM_BASECLASS);
408	}	411	}
		412
		413	@Override
		414	public void addFilters(FiltersDescription filtersDescription) {
		415	filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.READ.getKey(), "Read filter", true,
		416	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_read.png", false));
		417	filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.WRITE.getKey(), "Write filter", true,
		418	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_write.png", false));
		419	filtersDescription.addFilter(JavaWhereUsedFilters.ReadWrite.READ_WRITE.getKey(), "Read/Write filter", true,
		420	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_readwrite.png", false));
		421	filtersDescription.addFilter(JavaWhereUsedFilters.IMPORT.getKey(), "Import filter", true,
		422	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_import.png", false));
		423	filtersDescription.addFilter(JavaWhereUsedFilters.COMMENT.getKey(), "Comment filter", true,
		424	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_comment.png", false));
		425	filtersDescription.addFilter(JavaWhereUsedFilters.TESTFILE.getKey(), "Test filter", true,
		426	ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/java/resources/found_item_test.png", false));
		427	}
		428
		429	private EnumSet<JavaWhereUsedFilters.ReadWrite> usedAccessFilters = EnumSet.noneOf(JavaWhereUsedFilters.ReadWrite.class);
		430	private LinkedList<String> usedFilters = new LinkedList<String>();
		431	@Override
		432	public void enableFilters(FiltersDescription filtersDescription) {
		433	for (JavaWhereUsedFilters.ReadWrite filter : usedAccessFilters) {
		434	filtersDescription.enable(filter.getKey());
		435	}
		436	for (String string : usedFilters) {
		437	filtersDescription.enable(string);
		438	}
		439	}
409		440
410	private class FindTask implements CancellableTask<CompilationController> {	441	private class FindTask implements CancellableTask<CompilationController> {
411		442
Lines 442-456 Link Here
442	return;	473	return;
443	}	474	}
444		475
445	Collection<TreePath> result = new ArrayList<TreePath>();	476	final boolean fromTestRoot = RefactoringUtils.isFromTestRoot(compiler.getFileObject(), compiler.getClasspathInfo().getClassPath(ClasspathInfo.PathKind.SOURCE));
		477	AtomicBoolean inImport = new AtomicBoolean();
446	if (isFindUsages()) {	478	if (isFindUsages()) {
447	FindUsagesVisitor findVisitor = new FindUsagesVisitor(compiler, refactoring.getBooleanValue(WhereUsedQuery.SEARCH_IN_COMMENTS));	479	FindUsagesVisitor findVisitor = new FindUsagesVisitor(compiler, refactoring.getBooleanValue(WhereUsedQuery.SEARCH_IN_COMMENTS), fromTestRoot, inImport);
448	findVisitor.scan(compiler.getCompilationUnit(), element);	480	findVisitor.scan(compiler.getCompilationUnit(), element);
449	result.addAll(findVisitor.getUsages());	481	final Collection<UsageInComment> usagesInComments = findVisitor.getUsagesInComments();
450	for (FindUsagesVisitor.UsageInComment usageInComment : findVisitor.getUsagesInComments()) {	482	for (FindUsagesVisitor.UsageInComment usageInComment : usagesInComments) {
451	elements.add(refactoring, WhereUsedElement.create(usageInComment.from, usageInComment.to, compiler));	483	elements.add(refactoring, WhereUsedElement.create(usageInComment.from, usageInComment.to, compiler, fromTestRoot));
		484	}
		485	if(!usagesInComments.isEmpty()) {
		486	usedFilters.add(JavaWhereUsedFilters.COMMENT.getKey());
		487	}
		488	Collection<WhereUsedElement> foundElements = findVisitor.getElements();
		489	for (WhereUsedElement el : foundElements) {
		490	final ReadWrite access = el.getAccess();
		491	if(access != null) {
		492	usedAccessFilters.add(access);
		493	}
		494	elements.add(refactoring, el);
		495	}
		496	if(fromTestRoot && !foundElements.isEmpty()) {
		497	usedFilters.add(JavaWhereUsedFilters.TESTFILE.getKey());
452	}	498	}
453	}	499	}
		500	Collection<TreePath> result = new ArrayList<TreePath>();
454	if (element.getKind() == ElementKind.METHOD && isFindOverridingMethods()) {	501	if (element.getKind() == ElementKind.METHOD && isFindOverridingMethods()) {
455	FindOverridingVisitor override = new FindOverridingVisitor(compiler);	502	FindOverridingVisitor override = new FindOverridingVisitor(compiler);
456	override.scan(compiler.getCompilationUnit(), element);	503	override.scan(compiler.getCompilationUnit(), element);
Lines 462-474 Link Here
462	result.addAll(subtypes.getUsages());	509	result.addAll(subtypes.getUsages());
463	}	510	}
464	for (TreePath tree : result) {	511	for (TreePath tree : result) {
465	elements.add(refactoring, WhereUsedElement.create(compiler, tree));	512	elements.add(refactoring, WhereUsedElement.create(compiler, tree, fromTestRoot, inImport));
		513	}
		514	if(fromTestRoot && !result.isEmpty()) {
		515	usedFilters.add(JavaWhereUsedFilters.TESTFILE.getKey());
		516	}
		517	if(inImport.get()) {
		518	usedFilters.add(JavaWhereUsedFilters.IMPORT.getKey());
466	}	519	}
467	fireProgressListenerStep();	520	fireProgressListenerStep();
468	}	521	}
469	}	522	}
470		523
471	private static class FileComparator implements Comparator<FileObject> {	524	private static class FileComparator implements Comparator<FileObject> {
472		525
473	@Override	526	@Override
474	public int compare(FileObject o1, FileObject o2) {	527	public int compare(FileObject o1, FileObject o2) {

Line 0 Link Here

(-)a/refactoring.java/src/org/netbeans/modules/refactoring/java/spi/JavaWhereUsedFilters.java (+80 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.refactoring.java.spi;
		43
		44	/**
		45	* Filters used by Java Find Usages plugins.
		46	*
		47	* @author Ralph Benjamin Ruijs <ralphbenjamin@netbeans.org>
		48	* @since 1.39
		49	*/
		50	public enum JavaWhereUsedFilters {
		51
		52	IMPORT("filter-import"),
		53	COMMENT("filter-comment"),
		54	TESTFILE("filter-testfile");
		55	private final String key;
		56
		57	private JavaWhereUsedFilters(String key) {
		58	this.key = key;
		59	}
		60
		61	public String getKey() {
		62	return key;
		63	}
		64
65	public static enum ReadWrite {
66
67	READ("filter-read"),
68	WRITE("filter-write"),
69	READ_WRITE("filter-readwrite");
70	private final String key;
71
72	private ReadWrite(String key) {
73	this.key = key;
74	}
75
76	public String getKey() {
77	return key;
78	}
79	}
80	}