<code-name-base>org.netbeans.modules.java.platform</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.15</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.project.libraries</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.23</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

CTL_GoToImplementation=Go to Implementation

goto-implementation=Go to Implementation

LAB_IsOverridenAnnotation-override-is-overridden-combined=Overrides and is overridden

TP_COMBINED-override-is-overridden-combined=Overrides and is overridden

LAB_IsOverridenAnnotation-implements-is-overridden-combined=Implements and is overridden

TP_COMBINED-implements-is-overridden-combined=Implements and is overridden

#XXX: inside interfaces, but this should ideally be overrides/has implementations:

LAB_IsOverridenAnnotation-implements-has-implementations-combined=Implements and has implementations

TP_COMBINED-implements-has-implementations-combined=Implements and has implementations

LAB_IsOverriddenAnnotation=Is Overridden

LAB_OverridesAnnotation=Overrides

LAB_ImplementsAnnotation=Implements

LAB_HasImplementationsAnnotation=Has Implementations

LBL_NoMethod=No Method or Type

LBL_NoOverridingMethod=No overridding method found

LBL_NoOverridingType=No overridding type found

ERR_CycleInDependencies=Cycle in dependencies

LBL_ImplementorsOverriders=Implementors/Overridders

ERR_NoDependencies=Cannot detect project dependencies

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 2009 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.editor.overridden;

import com.sun.source.tree.Tree;

import java.util.Collection;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.lang.model.element.Element;

import javax.swing.text.BadLocationException;

import javax.swing.text.Position;

import javax.swing.text.StyledDocument;

import org.netbeans.api.java.source.CompilationInfo;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.java.source.JavaParserResultTask;

import org.netbeans.api.java.source.JavaSource.Phase;

import org.netbeans.modules.parsing.api.Snapshot;

import org.netbeans.modules.parsing.spi.Parser.Result;

import org.netbeans.modules.parsing.spi.Scheduler;

import org.netbeans.modules.parsing.spi.SchedulerEvent;

import org.netbeans.modules.parsing.spi.SchedulerTask;

import org.netbeans.modules.parsing.spi.TaskFactory;

import org.openide.text.NbDocument;

/**

 *

 * @author lahvac

 */

public class ComputeAnnotations extends JavaParserResultTask<Result> {

    private final AtomicBoolean cancel = new AtomicBoolean();

    public ComputeAnnotations() {

        super(Phase.RESOLVED);

    }

    @Override

    public void run(Result result, SchedulerEvent event) {

        cancel.set(false);

        CompilationInfo info = CompilationInfo.get(result);

        if (info.getChangedTree() != null) {

            //XXX: currently only method bodies are rebuilt.

            return ;

        }

        long start = System.currentTimeMillis();

        StyledDocument doc = (StyledDocument) result.getSnapshot().getSource().getDocument(false);

        if (doc == null) {

            return ;

        }

        List<IsOverriddenAnnotation> annotations = new LinkedList<IsOverriddenAnnotation>();

        createAnnotations(info, doc, new ComputeOverriding(cancel).process(info), false, annotations);

        createAnnotations(info, doc, new ComputeOverriders(cancel).process(info, null, null, false), true, annotations);

        if (cancel.get()) return ;

        AnnotationsHolder.get(info.getFileObject()).setNewAnnotations(annotations);

        long end = System.currentTimeMillis();

        Logger.getLogger("TIMER").log(Level.FINE, "Is Overridden Annotations", new Object[] {info.getFileObject(), end - start});

    }

    private void createAnnotations(CompilationInfo info, StyledDocument doc, Map<ElementHandle<? extends Element>, List<ElementDescription>> descriptions, boolean overridden, List<IsOverriddenAnnotation> annotations) {

        if (descriptions != null) {

            for (Entry<ElementHandle<? extends Element>, List<ElementDescription>> e : descriptions.entrySet()) {

                Element ee = e.getKey().resolve(info);

                Tree t = info.getTrees().getTree(ee);

                if (t == null) {

                    //XXX: log

                    continue;

                }

                AnnotationType type;

                String dn;

                if (overridden) {

                    if (ee.getEnclosingElement().getKind().isInterface() || ee.getKind().isInterface()) {

                        type = AnnotationType.HAS_IMPLEMENTATION;

                        dn = "Is Implemented";

                    } else {

                        type = AnnotationType.IS_OVERRIDDEN;

                        dn = "Is Overridden";

                    }

                } else {

                    if (ee.getEnclosingElement().getKind().isInterface() || ee.getKind().isInterface()) {

                        type = AnnotationType.IMPLEMENTS;

                        dn = "Implements";

                    } else {

                        type = AnnotationType.OVERRIDES;

                        dn = "Overrides";

                    }

                }

                Position pos = getPosition(doc, (int) info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), t));

                annotations.add(new IsOverriddenAnnotation(doc, pos, type, dn, e.getValue()));

            }

        }

    }

    @Override

    public int getPriority() {

        return Integer.MAX_VALUE;

    }

    @Override

    public Class<? extends Scheduler> getSchedulerClass() {

        return Scheduler.EDITOR_SENSITIVE_TASK_SCHEDULER;

    }

    @Override

    public void cancel() {

        cancel.set(true);

    }

    private static Position getPosition(final StyledDocument doc, final int offset) {

        class Impl implements Runnable {

            private Position pos;

            public void run() {

                if (offset < 0 || offset >= doc.getLength())

                    return ;

                try {

                    pos = doc.createPosition(offset - NbDocument.findLineColumn(doc, offset));

                } catch (BadLocationException ex) {

                    //should not happen?

                    Logger.getLogger(ComputeAnnotations.class.getName()).log(Level.FINE, null, ex);

                }

            }

        }

        Impl i = new Impl();

        doc.render(i);

        return i.pos;

    }

    public static final class FactoryImpl extends TaskFactory {

        @Override

        public Collection<? extends SchedulerTask> create(Snapshot snapshot) {

            return Collections.singleton(new ComputeAnnotations());

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 2009 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.editor.overridden;

import java.awt.Point;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.lang.model.element.Element;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.Types;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.java.queries.SourceForBinaryQuery;

import org.netbeans.api.java.source.ClassIndex;

import org.netbeans.api.java.source.ClassIndex.SearchKind;

import org.netbeans.api.java.source.ClassIndex.SearchScope;

import org.netbeans.api.java.source.ClasspathInfo;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.CompilationInfo;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.SourceUtils;

import org.netbeans.api.java.source.Task;

import org.netbeans.spi.java.classpath.support.ClassPathSupport;

import org.openide.DialogDisplayer;

import org.openide.NotifyDescriptor;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileStateInvalidException;

import org.openide.filesystems.URLMapper;

import org.openide.util.Exceptions;

import org.openide.util.Lookup;

import org.openide.util.NbBundle;

import org.openide.util.TopologicalSortException;

import org.openide.util.Utilities;

/**

 *

 * @author Jan Lahoda

 */

public class ComputeOverriders {

    private static final Logger LOG = Logger.getLogger(ComputeOverriders.class.getName());

    private final AtomicBoolean cancel;

    public ComputeOverriders(AtomicBoolean cancel) {

        this.cancel = cancel;

    }

    private static Set<URL> findReverseSourceRoots(final URL thisSourceRoot, Map<URL, List<URL>> sourceDeps, final FileObject thisFile) {

        long startTime = System.currentTimeMillis();

        try {

            //TODO: from SourceUtils (which filters out source roots that do not belong to open projects):

            //Create inverse dependencies

            final Map<URL, List<URL>> inverseDeps = new HashMap<URL, List<URL>> ();

            for (Map.Entry<URL,List<URL>> entry : sourceDeps.entrySet()) {

                final URL u1 = entry.getKey();

                final List<URL> l1 = entry.getValue();

                for (URL u2 : l1) {

                    List<URL> l2 = inverseDeps.get(u2);

                    if (l2 == null) {

                        l2 = new ArrayList<URL>();

                        inverseDeps.put (u2,l2);

                    }

                    l2.add (u1);

                }

            }

            //Collect dependencies

            final Set<URL> result = new HashSet<URL>();

            final LinkedList<URL> todo = new LinkedList<URL> ();

            todo.add (thisSourceRoot);

            while (!todo.isEmpty()) {

                final URL u = todo.removeFirst();

                if (!result.contains(u)) {

                    result.add (u);

                    final List<URL> ideps = inverseDeps.get(u);

                    if (ideps != null) {

                        todo.addAll (ideps);

                    }

                }

            }

            return result;

        } finally {

            long endTime = System.currentTimeMillis();

            Logger.getLogger("TIMER").log(Level.FINE, "Find Reverse Source Roots", //NOI18N

                    new Object[]{thisFile, endTime - startTime});

        }

    }

    private static FileObject findSourceRoot(FileObject file) {

        final ClassPath cp = ClassPath.getClassPath(file, ClassPath.SOURCE);

        if (cp != null) {

            return cp.findOwnerRoot(file);

        }

        //Null is a valid value for files which have no source path (default filesystem).

        return null;

    }

    private Set<URL> findBinaryRootsForSourceRoot(FileObject sourceRoot, Map<URL, List<URL>> binaryDeps) {

//      BinaryForSourceQuery.findBinaryRoots(thisSourceRoot).getRoots();

        Set<URL> result = new HashSet<URL>();

        for (URL bin : binaryDeps.keySet()) {

            if (cancel.get()) return Collections.emptySet();

            for (FileObject s : SourceForBinaryQuery.findSourceRoots(bin).getRoots()) {

                if (s == sourceRoot) {

                    result.add(bin);

                }

            }

        }

        return result;

    }

    Map<ElementHandle<? extends Element>, List<ElementDescription>> process(CompilationInfo info, TypeElement te, ExecutableElement ee, boolean interactive) {

        long startTime = System.currentTimeMillis();

        try {

            return processImpl(info, te, ee, interactive);

        } finally {

            Logger.getLogger("TIMER").log(Level.FINE, "Overridden - Total", //NOI18N

                new Object[] {info.getFileObject(), System.currentTimeMillis() - startTime});

        }

    }

    private Map<ElementHandle<? extends Element>, List<ElementDescription>> processImpl(CompilationInfo info, TypeElement te, ExecutableElement ee, boolean interactive) {

        FileObject file = info.getFileObject();

        FileObject thisSourceRoot = findSourceRoot(file);

        if (thisSourceRoot == null) {

            return null;

        }

        //XXX: special case "this" source root (no need to create a new JS and load the classes again for it):

//        reverseSourceRoots.add(thisSourceRoot);

//        LOG.log(Level.FINE, "reverseSourceRoots: {0}", reverseSourceRoots); //NOI18N

//                if (LOG.isLoggable(Level.FINE)) {

//                    LOG.log(Level.FINE, "method: {0}", ee.toString()); //NOI18N

//                }

        final Map<ElementHandle<TypeElement>, List<ElementHandle<ExecutableElement>>> methods = new HashMap<ElementHandle<TypeElement>, List<ElementHandle<ExecutableElement>>>();

        if (ee == null) {

            if (te == null) {

                fillInMethods(info.getTopLevelElements(), methods);

            } else {

                methods.put(ElementHandle.create(te), Collections.<ElementHandle<ExecutableElement>>emptyList());

            }

        } else {

            TypeElement owner = (TypeElement) ee.getEnclosingElement();

            methods.put(ElementHandle.create(owner), Collections.singletonList(ElementHandle.create(ee)));

        }

        final Map<ElementHandle<? extends Element>, List<ElementDescription>> overriding = new HashMap<ElementHandle<? extends Element>, List<ElementDescription>>();

        long startTime = System.currentTimeMillis();

        long[] classIndexTime = new long[1];

        final Map<URL, Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>> users = computeUsers(info, thisSourceRoot, methods.keySet(), classIndexTime, interactive);

        long endTime = System.currentTimeMillis();

        if (users == null) {

            return null;

        }

        Logger.getLogger("TIMER").log(Level.FINE, "Overridden Candidates - Class Index", //NOI18N

            new Object[] {file, classIndexTime[0]});

        Logger.getLogger("TIMER").log(Level.FINE, "Overridden Candidates - Total", //NOI18N

            new Object[] {file, endTime - startTime});

        for (Map.Entry<URL, Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>> data : users.entrySet()) {

            for (Map.Entry<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>> deps : data.getValue().entrySet()) {

                if (cancel.get()) return null;

                findOverriddenAnnotations(data.getKey(), deps.getValue(), deps.getKey(), methods.get(deps.getKey()), overriding);

            }

        }

        return overriding;

    }

    private static final ClassPath EMPTY = ClassPathSupport.createClassPath(new URL[0]);

    private static void fillInMethods(Iterable<? extends TypeElement> types, Map<ElementHandle<TypeElement>, List<ElementHandle<ExecutableElement>>> methods) {

        for (TypeElement te : types) {

            List<ElementHandle<ExecutableElement>> l = new LinkedList<ElementHandle<ExecutableElement>>();

            for (ExecutableElement ee : ElementFilter.methodsIn(te.getEnclosedElements())) {

                l.add(ElementHandle.create(ee));

            }

            methods.put(ElementHandle.create(te), l);

            fillInMethods(ElementFilter.typesIn(te.getEnclosedElements()), methods);

        }

    }

    private Set<ElementHandle<TypeElement>> computeUsers(URL source, Set<ElementHandle<TypeElement>> base, long[] classIndexCumulative) {

        ClasspathInfo cpinfo = ClasspathInfo.create(EMPTY, EMPTY, ClassPathSupport.createClassPath(source));

        return computeUsers(cpinfo, ClassIndex.SearchScope.SOURCE, base, classIndexCumulative);

    }

    private Set<ElementHandle<TypeElement>> computeUsers(ClasspathInfo cpinfo, SearchScope scope, Set<ElementHandle<TypeElement>> base, long[] classIndexCumulative) {

        long startTime = System.currentTimeMillis();

        try {

            List<ElementHandle<TypeElement>> l = new LinkedList<ElementHandle<TypeElement>>(base);

            Set<ElementHandle<TypeElement>> result = new HashSet<ElementHandle<TypeElement>>();

            while (!l.isEmpty()) {

                if (cancel.get()) return null;

                ElementHandle<TypeElement> eh = l.remove(0);

                result.add(eh);

                Set<ElementHandle<TypeElement>> typeElements = cpinfo.getClassIndex().getElements(eh, Collections.singleton(SearchKind.IMPLEMENTORS), EnumSet.of(scope));

                //XXX: Canceling

                if (typeElements != null) {

                    l.addAll(typeElements);

                }

            }

            return result;

        } finally {

            classIndexCumulative[0] += (System.currentTimeMillis() - startTime);

        }

    }

    static List<URL> reverseSourceRootsInOrderOverride;

    private List<URL> reverseSourceRootsInOrder(CompilationInfo info, URL thisSourceRoot, FileObject thisSourceRootFO, Map<URL, List<URL>> sourceDeps, Map<URL, List<URL>> binaryDeps, boolean interactive) {

        if (reverseSourceRootsInOrderOverride != null) {

            return reverseSourceRootsInOrderOverride;

        }

        Set<URL> sourceRootsSet;

        if (sourceDeps.containsKey(thisSourceRoot)) {

            sourceRootsSet = findReverseSourceRoots(thisSourceRoot, sourceDeps, info.getFileObject());

        } else {

            sourceRootsSet = new HashSet<URL>();

            for (URL binary : findBinaryRootsForSourceRoot(thisSourceRootFO, binaryDeps)) {

                List<URL> deps = binaryDeps.get(binary);

                if (deps != null) {

                    sourceRootsSet.addAll(deps);

                }

            }

        }

        List<URL> sourceRoots;

        try {

            sourceRoots = new LinkedList<URL>(Utilities.topologicalSort(sourceDeps.keySet(), sourceDeps));

        } catch (TopologicalSortException ex) {

            if (interactive) {

                Exceptions.attachLocalizedMessage(ex,NbBundle.getMessage(GoToImplementation.class, "ERR_CycleInDependencies"));

                Exceptions.printStackTrace(ex);

            } else {

                LOG.log(Level.FINE, null, ex);

            }

            return null;

        }

        sourceRoots.retainAll(sourceRootsSet);

        Collections.reverse(sourceRoots);

        return sourceRoots;

    }

    private Map<URL, Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>> computeUsers(CompilationInfo info, FileObject thisSourceRoot, Set<ElementHandle<TypeElement>> baseHandles, long[] classIndexCumulative, boolean interactive) {

        Map<URL, List<URL>> sourceDeps = getDependencies(false);

        Map<URL, List<URL>> binaryDeps = getDependencies(true);

        if (sourceDeps == null || binaryDeps == null) {

            if (interactive) {

                NotifyDescriptor nd = new NotifyDescriptor.Message(NbBundle.getMessage(GoToImplementation.class, "ERR_NoDependencies"), NotifyDescriptor.ERROR_MESSAGE);

                DialogDisplayer.getDefault().notifyLater(nd);

            } else {

                LOG.log(Level.FINE, NbBundle.getMessage(GoToImplementation.class, "ERR_NoDependencies"));

            }

            return null;

        }

        URL thisSourceRootURL;

        try {

            thisSourceRootURL = thisSourceRoot.getURL();

        } catch (FileStateInvalidException ex) {

            Exceptions.printStackTrace(ex);

            return null;

        }

        List<URL> sourceRoots = reverseSourceRootsInOrder(info, thisSourceRootURL, thisSourceRoot, sourceDeps, binaryDeps, interactive);

        if (sourceRoots == null) {

            return null;

        }

        Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>> auxHandles = new HashMap<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>();

        if (!sourceDeps.containsKey(thisSourceRootURL)) {

            Set<URL> binaryRoots = new HashSet<URL>();

            for (URL sr : sourceRoots) {

                List<URL> deps = sourceDeps.get(sr);

                if (deps != null) {

                    binaryRoots.addAll(deps);

                }

            }

            binaryRoots.retainAll(binaryDeps.keySet());

            for (ElementHandle<TypeElement> handle : baseHandles) {

                Set<ElementHandle<TypeElement>> types = computeUsers(ClasspathInfo.create(EMPTY, ClassPathSupport.createClassPath(binaryRoots.toArray(new URL[0])), EMPTY), SearchScope.DEPENDENCIES, Collections.singleton(handle), classIndexCumulative);

                if (types == null/*canceled*/ || cancel.get()) {

                    return null;

                }

                auxHandles.put(handle, types);

            }

        }

        Map<URL, Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>> result = new LinkedHashMap<URL, Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>>();

        for (URL file : sourceRoots) {

            for (ElementHandle<TypeElement> base : baseHandles) {

                if (cancel.get()) return null;

                Set<ElementHandle<TypeElement>> baseTypes = new HashSet<ElementHandle<TypeElement>>();

                baseTypes.add(base);

                Set<ElementHandle<TypeElement>> aux = auxHandles.get(base);

                if (aux != null) {

                    baseTypes.addAll(aux);

                }

                for (URL dep : sourceDeps.get(file)) {

                    Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>> depTypesMulti = result.get(dep);

                    Set<ElementHandle<TypeElement>> depTypes = depTypesMulti != null ? depTypesMulti.get(base) : null;

                    if (depTypes != null) {

                        baseTypes.addAll(depTypes);

                    }

                }

                Set<ElementHandle<TypeElement>> types = computeUsers(file, baseTypes, classIndexCumulative);

                if (types == null/*canceled*/ || cancel.get()) {

                    return null;

                }

                types.removeAll(baseTypes);

                Map<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>> currentUsers = result.get(file);

                if (currentUsers == null) {

                    result.put(file, currentUsers = new LinkedHashMap<ElementHandle<TypeElement>, Set<ElementHandle<TypeElement>>>());

                }

                currentUsers.put(base, types);

            }

        }

        return result;

    }

    private void findOverriddenAnnotations(

            URL sourceRoot,

            final Set<ElementHandle<TypeElement>> users,

            final ElementHandle<TypeElement> originalType,

            final List<ElementHandle<ExecutableElement>> methods,

            final Map<ElementHandle<? extends Element>, List<ElementDescription>> overriding) {

        if (!users.isEmpty()) {

            FileObject sourceRootFile = URLMapper.findFileObject(sourceRoot);

            ClasspathInfo cpinfo = ClasspathInfo.create(sourceRootFile);

            JavaSource js = JavaSource.create(cpinfo);

            try {

                js.runUserActionTask(new Task<CompilationController>() {

                    public void run(CompilationController controller) throws Exception {

                        Set<Element> seenElements = new HashSet<Element>();

                        Element resolvedOriginalType = originalType.resolve(controller);

                        if (resolvedOriginalType == null) {

                            return ;

                        }

                        for (ElementHandle<TypeElement> typeHandle : users) {

                            if (cancel.get()) return ;

                            TypeElement type = typeHandle.resolve(controller);

                            if (type == null || !seenElements.add(type)) {

                                continue;

                            }

                            Types types = controller.getTypes();

                            if (types.isSubtype(types.erasure(type.asType()), types.erasure(resolvedOriginalType.asType()))) {

                                List<ElementDescription> classOverriders = overriding.get(originalType);

                                if (classOverriders == null) {

                                    overriding.put(originalType, classOverriders = new LinkedList<ElementDescription>());

                                }

                                classOverriders.add(new ElementDescription(controller, type, true));

                                for (ElementHandle<ExecutableElement> originalMethodHandle : methods) {

                                    ExecutableElement originalMethod = originalMethodHandle.resolve(controller);

                                    if (originalMethod != null) {

                                        ExecutableElement overrider = getImplementationOf(controller, originalMethod, type);

                                        if (overrider == null) {

                                            continue;

                                        }

                                        List<ElementDescription> overriddingMethods = overriding.get(originalMethodHandle);

                                        if (overriddingMethods == null) {

                                            overriding.put(originalMethodHandle, overriddingMethods = new ArrayList<ElementDescription>());

                                        }

                                        overriddingMethods.add(new ElementDescription(controller, overrider, true));

                                    } else {

                                        Logger.getLogger("global").log(Level.SEVERE, "IsOverriddenAnnotationHandler: originalMethod == null!"); //NOI18N

                                    }

                                }

                            }

                        }

                    }

                }, true);

            } catch (Exception e) {

                Exceptions.printStackTrace(e);

            }

        }

    }

    private static ExecutableElement getImplementationOf(CompilationInfo info, ExecutableElement overridee, TypeElement implementor) {

        for (ExecutableElement overrider : ElementFilter.methodsIn(implementor.getEnclosedElements())) {

            if (info.getElements().overrides(overrider, overridee, implementor)) {

                return overrider;

            }

        }

        return null;

    }

    static void performGoToAction(List<ElementDescription> declarations, Point position) {

        String caption = NbBundle.getMessage(GoToImplementation.class, "LBL_ImplementorsOverriders");

        PopupUtil.showPopup(new IsOverriddenPopup(caption, declarations), caption, position.x, position.y, true, 0);

    }

    static Map<URL, List<URL>> dependenciesOverride;

    private static Map<URL, List<URL>> getDependencies(boolean binary) {

        if (dependenciesOverride != null) {

            return dependenciesOverride;

        }

        ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class);

        if (l == null) {

            return null;

        }

        Class clazz = null;

        String method = null;

        try {

            clazz = l.loadClass("org.netbeans.modules.parsing.impl.indexing.friendapi.IndexingController");

            method = binary ? "getBinaryRootDependencies" : "getRootDependencies";

        } catch (ClassNotFoundException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            try {

                clazz = l.loadClass("org.netbeans.modules.parsing.impl.indexing.RepositoryUpdater");

                method = binary ? "getDependencies" : "doesnotexist";

            } catch (ClassNotFoundException inner) {

                Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, inner);

                return null;

            }

        }

        try {

            Method getDefault = clazz.getDeclaredMethod("getDefault");

            Object instance = getDefault.invoke(null);

            Method dependenciesMethod = clazz.getDeclaredMethod(method);

            return (Map<URL, List<URL>>) dependenciesMethod.invoke(instance);

        } catch (IllegalAccessException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        } catch (IllegalArgumentException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        } catch (InvocationTargetException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        } catch (NoSuchMethodException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        } catch (SecurityException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        } catch (ClassCastException ex) {

            Logger.getLogger(GoToImplementation.class.getName()).log(Level.FINE, null, ex);

            return null;

        }

    }

}

import java.util.concurrent.atomic.AtomicBoolean;

import java.awt.Image;

import org.openide.util.ImageUtilities;

        this.overriddenFlag = overriddenFlag;

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2008-2009 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 2008-2009 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.editor.overridden;

import com.sun.source.tree.BlockTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.Tree.Kind;

import com.sun.source.util.SourcePositions;

import com.sun.source.util.TreePath;

import java.awt.Point;

import java.awt.event.ActionEvent;

import java.io.IOException;

import java.util.EnumSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.atomic.AtomicBoolean;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.TypeElement;

import javax.swing.SwingUtilities;

import javax.swing.text.Document;

import javax.swing.text.JTextComponent;

import org.netbeans.api.editor.EditorActionRegistration;

import org.netbeans.api.java.lexer.JavaTokenId;

import org.netbeans.api.java.source.CompilationController;

import org.netbeans.api.java.source.CompilationInfo;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.java.source.JavaSource;

import org.netbeans.api.java.source.JavaSource.Phase;

import org.netbeans.api.java.source.Task;

import org.netbeans.api.lexer.TokenSequence;

import org.netbeans.editor.BaseAction;

import org.netbeans.editor.ext.ExtKit;

import org.netbeans.modules.editor.java.JavaKit;

import org.netbeans.modules.java.editor.semantic.Utilities;

import org.openide.awt.StatusDisplayer;

import org.openide.util.Exceptions;

import org.openide.util.NbBundle;

@EditorActionRegistration(

        name = "goto-implementation",

        mimeType = JavaKit.JAVA_MIME_TYPE,

        popupText = "#CTL_GoToImplementation"

)

public final class GoToImplementation extends BaseAction {

    public GoToImplementation() {

        super(SAVE_POSITION | ABBREV_RESET);

//        putValue(SHORT_DESCRIPTION, NbBundle.getMessage(GoToImplementation.class, "CTL_GoToImplementation"));

//        String name = NbBundle.getMessage(GoToImplementation.class, "CTL_GoToImplementation_trimmed");

//        putValue(ExtKit.TRIMMED_TEXT,name);

//        putValue(POPUP_MENU_TEXT, name);

    }

    public void actionPerformed(ActionEvent e, final JTextComponent c) {

        try {

            JavaSource.forDocument(c.getDocument()).runUserActionTask(new Task<CompilationController>() {

                public void run(CompilationController parameter) throws Exception {

                    parameter.toPhase(Phase.RESOLVED);

                    Element el = resolveElement(parameter, c.getCaretPosition());

                    if (el == null) {

                        StatusDisplayer.getDefault().setStatusText(NbBundle.getMessage(GoToImplementation.class, "LBL_NoMethod"));

                        return ;

                    }

                    TypeElement type = el.getKind() == ElementKind.METHOD ? (TypeElement) el.getEnclosingElement() : (TypeElement) el;

                    ExecutableElement method = el.getKind() == ElementKind.METHOD ? (ExecutableElement) el : null;

                    Map<ElementHandle<? extends Element>, List<ElementDescription>> overriding = new ComputeOverriders(new AtomicBoolean()).process(parameter, type, method, true);

                    List<ElementDescription> overridingMethods = overriding.get(ElementHandle.create(el));

                    if (overridingMethods == null || overridingMethods.isEmpty()) {

                        String key = el.getKind() == ElementKind.METHOD ? "LBL_NoOverridingMethod" : "LBL_NoOverridingType";

                        StatusDisplayer.getDefault().setStatusText(NbBundle.getMessage(GoToImplementation.class, key));

                        return;

                    }

                    Point p = new Point(c.modelToView(c.getCaretPosition()).getLocation());

                    SwingUtilities.convertPointToScreen(p, c);

                    performGoToAction(overridingMethods, p);

                }

            }, true);

        } catch (IOException ex) {

            Exceptions.printStackTrace(ex);

        }

    }

    static void performGoToAction(List<ElementDescription> declarations, Point position) {

        String caption = NbBundle.getMessage(GoToImplementation.class, "LBL_ImplementorsOverriders");

        PopupUtil.showPopup(new IsOverriddenPopup(caption, declarations), caption, position.x, position.y, true, 0);

    }

    private static Set<ElementKind> SUPPORTED_ELEMENTS = EnumSet.of(ElementKind.METHOD, ElementKind.ANNOTATION_TYPE, ElementKind.CLASS, ElementKind.ENUM, ElementKind.INTERFACE);

    private static Element resolveElement(CompilationInfo info, int caret) {

        TreePath tp = info.getTreeUtilities().pathFor(caret);

        TokenSequence<JavaTokenId> ts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language());

        ts.move(caret);

        boolean isIdentifier = ts.moveNext() && ts.token().id() == JavaTokenId.IDENTIFIER;

        if (!isIdentifier) {

            ts.move(caret);

            isIdentifier = ts.movePrevious() && ts.token().id() == JavaTokenId.IDENTIFIER;

        }

        if (isIdentifier) {

            Element  elementUnderCaret = info.getTrees().getElement(tp);

            if (elementUnderCaret != null && SUPPORTED_ELEMENTS.contains(elementUnderCaret.getKind())) {

                return (Element) elementUnderCaret;

            }

        }

        Element el = resolveHeader(tp, info, caret);

        if (el == null) {

            tp = info.getTreeUtilities().pathFor(caret + 1);

            el = resolveHeader(tp, info, caret);

        }

        return el;

    }

    private static Element resolveHeader(TreePath tp, CompilationInfo info, int caret) {

        while (tp.getLeaf().getKind() != Kind.METHOD && tp.getLeaf().getKind() != Kind.CLASS && tp.getLeaf().getKind() != Kind.COMPILATION_UNIT) {

            tp = tp.getParentPath();

        }

        if (tp.getLeaf().getKind() == Kind.COMPILATION_UNIT) {

            return null;

        }

        long bodyStart;

        if (tp.getLeaf().getKind() == Kind.METHOD) {

            MethodTree mt = (MethodTree) tp.getLeaf();

            SourcePositions sp = info.getTrees().getSourcePositions();

            BlockTree body = mt.getBody();

            bodyStart = body != null ? sp.getStartPosition(info.getCompilationUnit(), body) : Integer.MAX_VALUE;

        } else {

            assert tp.getLeaf().getKind() == Kind.CLASS;

            Document doc = info.getSnapshot().getSource().getDocument(false);

            if (doc == null) {

                return null;

            }

            bodyStart = Utilities.findBodyStart(tp.getLeaf(), info.getCompilationUnit(), info.getTrees().getSourcePositions(), doc);

        }

        if (caret >= bodyStart) {

            return null;

        }

        Element el = info.getTrees().getElement(tp);

        if (el == null || !SUPPORTED_ELEMENTS.contains(el.getKind())) {

            return null;

        }

        return (Element) el;

    }

}

import java.awt.Toolkit;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.MissingResourceException;

import java.util.Set;

import java.util.logging.Logger;

import javax.swing.SwingUtilities;

import org.netbeans.api.java.source.ui.ElementOpen;

    private List<IsOverriddenAnnotation> findAnnotations(JTextComponent component, int offset) {

        FileObject file = getFile(component);

        if (file == null) {

            if (ErrorManager.getDefault().isLoggable(ErrorManager.WARNING)) {

                ErrorManager.getDefault().log(ErrorManager.WARNING, "component=" + component + " does not have a file specified in the document."); //NOI18N

            }

            return null;

        }

        AnnotationsHolder ah = AnnotationsHolder.get(file);

        if (ah == null) {

            Logger.getLogger(IsOverriddenAnnotationAction.class.getName()).log(Level.INFO, "component=" + component + " does not have attached a IsOverriddenAnnotationHandler"); //NOI18N

            return null;

        }