/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.netbeans.modules.refactoring.java;

import com.sun.source.tree.*;
import com.sun.source.util.TreePath;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.*;
import java.util.concurrent.Future;
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.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.*;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Types;
import javax.swing.text.Document;
import org.netbeans.api.annotations.common.NullUnknown;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.ClassPath.Entry;
import org.netbeans.api.java.classpath.GlobalPathRegistry;
import org.netbeans.api.java.classpath.JavaClassPathConstants;
import org.netbeans.api.java.platform.JavaPlatform;
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;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.refactoring.java.plugins.LocalVarScanner;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.openide.cookies.EditorCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.URLMapper;
import org.openide.text.CloneableEditorSupport;
import org.openide.text.NbDocument;
import org.openide.util.NbBundle;
import org.openide.util.Utilities;
import org.openide.windows.TopComponent;

/**
 *
 * @author Jan Becicka
 */
public class RefactoringUtils {

    private static final String JAVA_MIME_TYPE = "text/x-java"; // NOI18N
    private static final Logger LOG = Logger.getLogger(RefactoringUtils.class.getName());

    /**
     * Get all overriding methods for given ExecutableElement
     *
     * @param e
     * @param info
     * @return
     * @deprecated 
     */
    @Deprecated
    public static Collection<ExecutableElement> getOverridenMethods(ExecutableElement e, CompilationInfo info) {
        return getOverridenMethods(e, info.getElementUtilities().enclosingTypeElement(e), info);
    }

    private static Collection<ExecutableElement> getOverridenMethods(ExecutableElement e, TypeElement parent, CompilationInfo info) {
        ArrayList<ExecutableElement> result = new ArrayList<ExecutableElement>();

        TypeMirror sup = parent.getSuperclass();
        if (sup.getKind() == TypeKind.DECLARED) {
            TypeElement next = (TypeElement) ((DeclaredType) sup).asElement();
            ExecutableElement overriden = getMethod(e, next, info);
            result.addAll(getOverridenMethods(e, next, info));
            if (overriden != null) {
                result.add(overriden);
            }
        }
        for (TypeMirror tm : parent.getInterfaces()) {
            TypeElement next = (TypeElement) ((DeclaredType) tm).asElement();
            ExecutableElement overriden2 = getMethod(e, next, info);
            result.addAll(getOverridenMethods(e, next, info));
            if (overriden2 != null) {
                result.add(overriden2);
            }
        }
        return result;
    }

    private static ExecutableElement getMethod(ExecutableElement method, TypeElement type, CompilationInfo info) {
        for (ExecutableElement met : ElementFilter.methodsIn(type.getEnclosedElements())) {
            if (info.getElements().overrides(method, met, type)) {
                return met;
            }
        }
        return null;
    }

    public static Set<ElementHandle<TypeElement>> getImplementorsAsHandles(ClassIndex idx, ClasspathInfo cpInfo, TypeElement el, AtomicBoolean cancel) {
        LinkedList<ElementHandle<TypeElement>> elements = new LinkedList<ElementHandle<TypeElement>>(
                implementorsQuery(idx, ElementHandle.create(el)));
        Set<ElementHandle<TypeElement>> result = new HashSet<ElementHandle<TypeElement>>();
        while (!elements.isEmpty()) {
            if (cancel.get()) {
                return Collections.emptySet();
            }
            ElementHandle<TypeElement> next = elements.removeFirst();
            if (!result.add(next)) {
                // it is a duplicate; do not query again
                continue;
            }
            Set<ElementHandle<TypeElement>> foundElements = implementorsQuery(idx, next);
            elements.addAll(foundElements);
        }
        return result;
    }

    private static Set<ElementHandle<TypeElement>> implementorsQuery(ClassIndex idx, ElementHandle<TypeElement> next) {
        return idx.getElements(next,
                EnumSet.of(ClassIndex.SearchKind.IMPLEMENTORS),
                EnumSet.of(ClassIndex.SearchScope.SOURCE, ClassIndex.SearchScope.DEPENDENCIES));
    }

    /**
     * 
     * @param e
     * @param info
     * @param cancel 
     * @return
     * @deprecated
     */
    @Deprecated
    public static Collection<ExecutableElement> getOverridingMethods(ExecutableElement e, CompilationInfo info, AtomicBoolean cancel) {
        Collection<ExecutableElement> result = new ArrayList();
        TypeElement parentType = (TypeElement) e.getEnclosingElement();
        Set<ElementHandle<TypeElement>> subTypes = getImplementorsAsHandles(info.getClasspathInfo().getClassIndex(), info.getClasspathInfo(), parentType, cancel);
        for (ElementHandle<TypeElement> subTypeHandle : subTypes) {
            TypeElement type = subTypeHandle.resolve(info);
            if (type == null) {
                // #214462: removed logging, logs show coupling errors
                continue;
                // #120577: log info to find out what is going wrong
//                FileObject file = SourceUtils.getFile(subTypeHandle, info.getClasspathInfo());
//                if (file == null) {
//                    //Deleted file
//                    continue;
//                } else {
//                    throw new NullPointerException("#120577: Cannot resolve " + subTypeHandle + "; file: " + file + " Classpath: " + info.getClasspathInfo());
//                }
            }
            List<ExecutableElement> methods = new LinkedList<>(ElementFilter.methodsIn(type.getEnclosedElements()));
            // #253063 - Anonymous classes of enum constants are not returned by index, need to get them manually
            if(type.getKind() == ElementKind.ENUM) {
                for (VariableElement variableElement : ElementFilter.fieldsIn(type.getEnclosedElements())) {
                    TreePath varPath = info.getTrees().getPath(variableElement);
                    if(varPath != null && varPath.getLeaf().getKind() == Tree.Kind.VARIABLE) {
                        ExpressionTree initializer = ((VariableTree)varPath.getLeaf()).getInitializer();
                        if(initializer != null && initializer.getKind() == Tree.Kind.NEW_CLASS) {
                            NewClassTree ncTree = (NewClassTree) initializer;
                            ClassTree classBody = ncTree.getClassBody();
                            if(classBody != null) {
                                Element anonEl = info.getTrees().getElement(new TreePath(varPath, classBody));
                                if(anonEl != null) {
                                    methods.addAll(ElementFilter.methodsIn(anonEl.getEnclosedElements()));
                                }
                            }
                        }
                    }
                }
            }
            for (ExecutableElement method : methods) {
                if (info.getElements().overrides(method, e, type)) {
                    result.add(method);
                }
            }
        }
        return result;
    }
    
    public static CodeStyle getCodeStyle(CompilationInfo info) {
        if (info != null) {
            try {
                Document doc = info.getDocument();
                if (doc != null) {
                    CodeStyle cs = (CodeStyle)doc.getProperty(CodeStyle.class);
                    return cs != null ? cs : CodeStyle.getDefault(doc);
                }
            } catch (IOException ioe) {
                // ignore
            }

            FileObject file = info.getFileObject();
            if (file != null) {
                return CodeStyle.getDefault(file);
            }
        }

        return CodeStyle.getDefault((Document)null);
    }

    /**
     *
     * @param f
     * @return true if f is java
     */
    public static boolean isJavaFile(FileObject f) {
        return JAVA_MIME_TYPE.equals(FileUtil.getMIMEType(f, JAVA_MIME_TYPE));
    }

    /**
     * @param element
     * @param info
     * @return true if given element comes from library
     */
    public static boolean isFromLibrary(ElementHandle<? extends Element> element, ClasspathInfo info) {
        FileObject file = SourceUtils.getFile(element, info);
        if (file == null) {
            //no source for given element. Element is from library
            return true;
        }
        return FileUtil.getArchiveFile(file) != null;
    }

    /**
     * is given name valid package name
     *
     * @param name
     * @return
     */
    public static boolean isValidPackageName(String name) {
        if (name.endsWith(".")) //NOI18N
        {
            return false;
        }
        if (name.startsWith(".")) //NOI18N
        {
            return false;
        }
        if (name.contains("..")) //NOI18N
        {
            return false;
        }
        StringTokenizer tokenizer = new StringTokenizer(name, "."); // NOI18N
        while (tokenizer.hasMoreTokens()) {
            if (!Utilities.isJavaIdentifier(tokenizer.nextToken())) {
                return false;
            }
        }
        return true;
    }

    /**
     *
     * @param f
     * @return true if given file is in open project
     */
    public static boolean isFileInOpenProject(FileObject file) {
        assert file != null;
        // Future<Project[]> o.n.api.project.ui.OpenProjects.openProjects()
        Future<Project[]> openProjects = OpenProjects.getDefault().openProjects();
        if(!openProjects.isDone()) {
            return false;
        }
        Project p = FileOwnerQuery.getOwner(file);
        if (p == null) {
            return false;
        }
        return isOpenProject(p);
    }

    /**
     * Is given file on any source classpath?
     *
     * @param fo
     * @return
     * @deprecated 
     */
    @Deprecated
    public static boolean isOnSourceClasspath(FileObject fo) {
        Project pr = FileOwnerQuery.getOwner(fo);
        if (pr == null) {
            return false;
        }

        //workaround for 143542
        for (String type : new String[]{JavaProjectConstants.SOURCES_TYPE_JAVA, JavaProjectConstants.SOURCES_TYPE_RESOURCES}) {
            for (SourceGroup sg : ProjectUtils.getSources(pr).getSourceGroups(type)) {
                if (fo == sg.getRootFolder() || (FileUtil.isParentOf(sg.getRootFolder(), fo) && sg.contains(fo))) {
                    return ClassPath.getClassPath(fo, ClassPath.SOURCE) != null;
                }
            }
        }
        return false;
        //end of workaround
        //return ClassPath.getClassPath(fo, ClassPath.SOURCE)!=null;
    }

    /**
     * Is given file a root of source classpath?
     *
     * @param fo
     * @return
     */
    public static boolean isClasspathRoot(FileObject fo) {
        ClassPath cp = ClassPath.getClassPath(fo, ClassPath.SOURCE);
        return cp != null ? fo.equals(cp.findOwnerRoot(fo)) : false;
    }

    /**
     * Is the given file "java" && in open projects && on source classpath?
     *
     * @param file
     * @return
     * @deprecated 
     */
    @Deprecated
    public static boolean isRefactorable(FileObject file) {
        return file != null && isJavaFile(file) && isFileInOpenProject(file) && isOnSourceClasspath(file);
    }

    /**
     * returns package name for given folder. Folder must be on source classpath
     *
     * @param folder
     * @return
     */
    public static String getPackageName(FileObject folder) {
        assert folder.isFolder() : "argument must be folder";
        ClassPath cp = ClassPath.getClassPath(folder, ClassPath.SOURCE);
        if (cp == null) {
            // see http://www.netbeans.org/issues/show_bug.cgi?id=159228
            throw new IllegalStateException(String.format("No classpath for %s.", folder.getPath())); // NOI18N
        }
        return cp.getResourceName(folder, '.', false);
    }

    /**
     * get package name for given CompilationUnitTree
     *
     * @param unit
     * @return
     */
    public static String getPackageName(CompilationUnitTree unit) {
        assert unit != null;
        ExpressionTree name = unit.getPackageName();
        if (name == null) {
            //default package
            return "";
        }
        return name.toString();
    }

    /**
     * get package name for given url.
     *
     * @param url
     * @return
     */
    public static String getPackageName(URL url) {
        File f = null;
        try {
            f = FileUtil.normalizeFile(Utilities.toFile(url.toURI()));
        } catch (URISyntaxException ex) {
            throw new IllegalArgumentException(ex);
        }
        String suffix = "";

        do {
            FileObject fo = FileUtil.toFileObject(f);
            if (fo != null) {
                if ("".equals(suffix)) {
                    return getPackageName(fo);
                }
                String prefix = getPackageName(fo);
                return prefix + ("".equals(prefix) ? "" : ".") + suffix; // NOI18N
            }
            if (!"".equals(suffix)) {
                suffix = "." + suffix; // NOI18N
            }
            suffix = f.getPath().substring(f.getPath().lastIndexOf(File.separatorChar) + 1) + suffix; // NOI18N
            f = f.getParentFile();
        } while (f != null);
        throw new IllegalArgumentException("Cannot create package name for url " + url); // NOI18N
    }

    /**
     * creates or finds FileObject according to
     *
     * @param url
     * @return FileObject
     */
    public static FileObject getOrCreateFolder(URL url) throws IOException {
        try {
            FileObject result = URLMapper.findFileObject(url);
            if (result != null) {
                return result;
            }
            File f = new File(url.toURI());

            result = FileUtil.createFolder(f);
            return result;
        } catch (URISyntaxException ex) {
            throw new IOException(ex);
        }
    }

    /**
     *
     * @param url
     * @return
     * @throws IOException
     */
    public static FileObject getClassPathRoot(URL url) throws IOException {
        FileObject result = getRootFileObject(url);
        if(result == null) {
            return null;
        }
        ClassPath classPath = ClassPath.getClassPath(result, ClassPath.SOURCE);
        if(classPath == null) {
            return null;
        }
        return classPath.findOwnerRoot(result);
    }

    /**
     * Get all supertypes for given type
     *
     * @param type
     * @param info
     * @return
     * @deprecated 
     */
    @Deprecated
    public static Collection<TypeElement> getSuperTypes(TypeElement type, CompilationInfo info) {
        Collection<TypeElement> result = new HashSet<TypeElement>();
        LinkedList<TypeElement> l = new LinkedList<TypeElement>();
        l.add(type);
        while (!l.isEmpty()) {
            TypeElement t = l.removeFirst();
            TypeElement superClass = typeToElement(t.getSuperclass(), info);
            if (superClass != null) {
                result.add(superClass);
                l.addLast((TypeElement) superClass);
            }
            Collection<TypeElement> interfaces = typesToElements(t.getInterfaces(), info);
            result.addAll(interfaces);
            l.addAll(interfaces);
        }
        return result;
    }

    /**
     * get supertypes of given types
     *
     * @param type
     * @param info
     * @param sourceOnly true if only types defined in open project should be
     * searched
     * @return
     * @deprecated 
     */
    @Deprecated
    public static Collection<TypeElement> getSuperTypes(TypeElement type, CompilationInfo info, boolean sourceOnly) {
        if (!sourceOnly) {
            return getSuperTypes(type, info);
        }
        Collection<TypeElement> result = new HashSet<TypeElement>();
        for (TypeElement el : getSuperTypes(type, info)) {
            ElementHandle<TypeElement> handle = ElementHandle.create(el);
            FileObject file = SourceUtils.getFile(handle, info.getClasspathInfo());
            if (file != null && isFileInOpenProject(file) && !isFromLibrary(handle, info.getClasspathInfo())) {
                result.add(el);
            }
        }
        return result;
    }

    public static TypeElement typeToElement(TypeMirror type, CompilationInfo info) {
        return (TypeElement) info.getTypes().asElement(type);
    }

    private static boolean isOpenProject(Project p) {
        return OpenProjects.getDefault().isProjectOpen(p);
    }

    private static Collection<TypeElement> typesToElements(Collection<? extends TypeMirror> types, CompilationInfo info) {
        Collection<TypeElement> result = new HashSet();
        for (TypeMirror tm : types) {
            result.add(typeToElement(tm, info));
        }
        return result;
    }

    public static Collection<FileObject> elementsToFile(Collection<? extends Element> elements, ClasspathInfo cpInfo) {
        Collection<FileObject> result = new HashSet();
        for (Element handle : elements) {
            result.add(SourceUtils.getFile(handle, cpInfo));
        }
        return result;
    }

    public static boolean elementExistsIn(TypeElement target, Element member, CompilationInfo info) {
        for (Element currentMember : target.getEnclosedElements()) {
            if (currentMember.getKind().equals(member.getKind())
                    && currentMember.getSimpleName().equals(member.getSimpleName())) {
                if (currentMember.getKind() == ElementKind.METHOD) {
                    ExecutableElement exMethod = (ExecutableElement) currentMember;
                    ExecutableElement method = (ExecutableElement) member;
                    if (exMethod.getParameters().size() == method.getParameters().size()) {
                        boolean sameParameters = true;
                        for (int j = 0; j < exMethod.getParameters().size(); j++) {
                            TypeMirror exType = ((VariableElement) exMethod.getParameters().get(j)).asType();
                            TypeMirror paramType = method.getParameters().get(j).asType();
                            if (!info.getTypes().isSameType(exType, paramType)) {
                                sameParameters = false;
                            }
                        }
                        if (sameParameters) {
                            return true;
                        }
                    }
                } else {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * @param fqn
     * @param info
     * @return
     */
    public static boolean typeExists(String fqn, CompilationInfo info) {
        return info.getElements().getTypeElement(fqn) != null;
    }

    /**
     * create ClasspathInfo for specified files includes dependencies
     *
     * @param files
     * @return
     * @deprecated 
     */
    @Deprecated
    public static ClasspathInfo getClasspathInfoFor(FileObject... files) {
        return getClasspathInfoFor(true, files);
    }

    /**
     * create ClasspathInfo for specified files
     *
     * @param dependencies
     * @param files
     * @return
     */
    public static ClasspathInfo getClasspathInfoFor(boolean dependencies, FileObject... files) {
        return getClasspathInfoFor(dependencies, false, files);
    }

    /**
     * create ClasspathInfo for specified files
     *
     * @param dependencies include dependencies
     * @param backSource libraries replaces by sources using
     * SourceForBinaryQuery
     * @param files
     * @return
     */
    @SuppressWarnings("CollectionContainsUrl")
    public static ClasspathInfo getClasspathInfoFor(boolean dependencies, boolean backSource, FileObject... files) {
        assert files.length > 0;
        Set<URL> dependentSourceRoots = new HashSet();
        Set<URL> dependentCompileRoots = new HashSet();
        ClassPath nullPath = ClassPathSupport.createClassPath(new FileObject[0]);
        ClassPath boot = null;
        ClassPath moduleBoot = null;
        ClassPath compile = null;
        ClassPath moduleCompile = null;
        ClassPath moduleClass = null;        
        for (FileObject fo : files) {
            ClassPath cp = null;
            FileObject ownerRoot = null;
            if (fo != null) {
                cp = ClassPath.getClassPath(fo, ClassPath.SOURCE);
                if (cp != null) {
                    ownerRoot = cp.findOwnerRoot(fo);
                }
            }
            if (cp != null && ownerRoot != null && FileUtil.getArchiveFile(ownerRoot) == null) {
                for (FileObject src : cp.getRoots()) { // Keep all source roots from cp. Needed if project has multiple source roots.
                URL sourceRoot = URLMapper.findURL(src, URLMapper.INTERNAL);
                if (dependencies) {
                    Set<URL> urls = SourceUtils.getDependentRoots(sourceRoot, false);
                    Set<ClassPath> cps = GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE);
                    Set<URL> toRetain = new HashSet<URL>();
                    for (ClassPath path : cps) {
                        for (ClassPath.Entry e : path.entries()) {
                            toRetain.add(e.getURL());
                        }
                    }
                    Set<URL> compileUrls = new HashSet<URL>(urls);
                    urls.retainAll(toRetain);
                    compileUrls.removeAll(toRetain);
                    dependentSourceRoots.addAll(urls);
                    dependentCompileRoots.addAll(compileUrls);
                } else {
                    dependentSourceRoots.add(sourceRoot);
                }
                if (FileOwnerQuery.getOwner(fo) != null) {
                    for (FileObject f : cp.getRoots()) {
                        dependentCompileRoots.add(URLMapper.findURL(f, URLMapper.INTERNAL));
                    }
                }
                }
            } else {
                for (ClassPath scp : GlobalPathRegistry.getDefault().getPaths(ClassPath.SOURCE)) {
                    for (FileObject root : scp.getRoots()) {
                        dependentSourceRoots.add(URLMapper.findURL(root, URLMapper.INTERNAL));
                    }
                }
            }
            
            if(fo != null) {
                ClassPath fboot = ClassPath.getClassPath(fo, ClassPath.BOOT);
                ClassPath fmoduleboot = ClassPath.getClassPath(fo, JavaClassPathConstants.MODULE_BOOT_PATH);
                ClassPath fcompile = ClassPath.getClassPath(fo, ClassPath.COMPILE);
                ClassPath fmodulecompile = ClassPath.getClassPath(fo, JavaClassPathConstants.MODULE_COMPILE_PATH);
                ClassPath fmoduleclass = ClassPath.getClassPath(fo, JavaClassPathConstants.MODULE_CLASS_PATH);
                //When file[0] is a class file, there is no compile cp but execute cp
                //try to get it
                if (fcompile == null) {
                    fcompile = ClassPath.getClassPath(fo, ClassPath.EXECUTE);
                }
                //If no cp found at all log the file and use nullPath since the ClasspathInfo.create
                //doesn't accept null compile or boot cp.
                if (fcompile == null) {
                    LOG.log(Level.WARNING, "No classpath for: {0} {1}", new Object[]{FileUtil.getFileDisplayName(fo), FileOwnerQuery.getOwner(fo)}); //NOI18N
                } else {
                    compile = compile != null ? merge(compile, fcompile) : fcompile;
                }
                
                if (fboot != null) {
                    boot = boot != null ? merge(boot, fboot) : fboot;
                }
                if (fmoduleboot != null) {
                    moduleBoot = moduleBoot != null ? merge(moduleBoot, fmoduleboot) : fmoduleboot;
                }
                if (fmodulecompile != null) {
                    moduleCompile = moduleCompile != null ? merge(moduleCompile, fmodulecompile) : fmodulecompile;
                }
                if (fmoduleclass != null) {
                    moduleClass = moduleClass != null ? merge(moduleClass, fmoduleclass) : fmoduleclass;
                }
            }
        }

        if (backSource) {
            for (FileObject file : files) {
                if (file != null) {
                    ClassPath source = ClassPath.getClassPath(file, ClassPath.COMPILE);
                    for (Entry root : source.entries()) {
                        Result r = SourceForBinaryQuery.findSourceRoots(root.getURL());
                        for (FileObject root2 : r.getRoots()) {
                            dependentSourceRoots.add(URLMapper.findURL(root2, URLMapper.INTERNAL));
                        }
                    }
                }
            }
        }

        ClassPath rcp = ClassPathSupport.createClassPath(dependentSourceRoots.toArray(new URL[dependentSourceRoots.size()]));
        if (compile == null) {
            compile = nullPath;
        }
        compile = merge(compile, ClassPathSupport.createClassPath(dependentCompileRoots.toArray(new URL[dependentCompileRoots.size()])));
        if (boot == null) {
            boot = JavaPlatform.getDefault().getBootstrapLibraries();
        }
        return new ClasspathInfo.Builder(boot == null ? nullPath : boot)
                .setModuleBootPath(moduleBoot == null ? boot == null? nullPath : boot : moduleBoot)
                .setClassPath(compile)
                .setModuleCompilePath(moduleCompile)
                .setModuleClassPath(moduleClass)
                .setSourcePath(rcp).
                build();
    }


    /**
     * @param handle
     * @return  
     */
    public static FileObject getFileObject(TreePathHandle handle) {
        ElementHandle elementHandle = handle.getElementHandle();
        if (elementHandle == null ) {
            return handle.getFileObject();
        }
       ClasspathInfo info = getClasspathInfoFor(false, handle.getFileObject()); 
       return SourceUtils.getFile(elementHandle, info);
    }    
    /**
     * create ClasspathInfo for specified handles
     *
     * @param handles
     * @return
     */
    public static ClasspathInfo getClasspathInfoFor(TreePathHandle... handles) {
        FileObject[] result = new FileObject[handles.length];
        int i = 0;
        for (TreePathHandle handle : handles) {
            FileObject fo = getFileObject(handle);
            if (i == 0 && fo == null) {
                result = new FileObject[handles.length + 1];
                result[i++] = handle.getFileObject();
            }
            result[i++] = fo;
        }
        return getClasspathInfoFor(result);
    }

    /**
     * Finds type parameters from
     * <code>typeArgs</code> list that are referenced by
     * <code>tm</code> type.
     *
     * @param utils compilation type utils
     * @param typeArgs modifiable list of type parameters to search; found types
     * will be removed (performance reasons).
     * @param result modifiable list that will contain referenced type
     * parameters
     * @param tm parametrized type to analyze
     */
    public static void findUsedGenericTypes(Types utils, List<TypeMirror> typeArgs, Set<TypeMirror> result, TypeMirror tm) {
        if (typeArgs.isEmpty()) {
            return;
        } else if (tm.getKind() == TypeKind.TYPEVAR) {
            TypeVariable type = (TypeVariable) tm;
            int index = findTypeIndex(utils, typeArgs, type);
            if (index >= 0) {
                result.add(typeArgs.get(index));
            } else {
                TypeMirror low = type.getLowerBound();
                if (low != null && low.getKind() != TypeKind.NULL) {
                    findUsedGenericTypes(utils, typeArgs, result, low);
                }
                TypeMirror up = type.getUpperBound();
                if (up != null) {
                    findUsedGenericTypes(utils, typeArgs, result, up);
                }
                int idx = findTypeIndex(utils, typeArgs, type);
                if (idx >= 0) {
                    result.add(typeArgs.get(idx));
                }
            }
        } else if (tm.getKind() == TypeKind.DECLARED) {
            DeclaredType type = (DeclaredType) tm;
            for (TypeMirror tp : type.getTypeArguments()) {
                findUsedGenericTypes(utils, typeArgs, result, tp);
            }
        } else if (tm.getKind() == TypeKind.WILDCARD) {
            WildcardType type = (WildcardType) tm;
            TypeMirror ex = type.getExtendsBound();
            if (ex != null) {
                findUsedGenericTypes(utils, typeArgs, result, ex);
            }
            TypeMirror su = type.getSuperBound();
            if (su != null) {
                findUsedGenericTypes(utils, typeArgs, result, su);
            }
        }
    }

    private static int findTypeIndex(Types utils, List<TypeMirror> typeArgs, TypeMirror type) {
        int i = -1;
        for (TypeMirror typeArg : typeArgs) {
            i++;
            if (utils.isSameType(type, typeArg)) {
                return i;
            }
        }
        return -1;
    }

    public static List<TypeMirror> filterTypes(List<TypeMirror> source, Set<TypeMirror> used) {
        List<TypeMirror> result = new ArrayList<TypeMirror>(source.size());

        for (TypeMirror tm : source) {
            if (used.contains(tm)) {
                result.add(tm);
            }
        }

        return result;
    }

    /**
     * translates list of elements to list of types
     *
     * @param typeParams elements
     * @return types
     * @deprecated 
     */
    @Deprecated
    public static List<TypeMirror> resolveTypeParamsAsTypes(List<? extends Element> typeParams) {
        if (typeParams.isEmpty()) {
            return Collections.<TypeMirror>emptyList();
        }
        List<TypeMirror> typeArgs = new ArrayList<TypeMirror>(typeParams.size());
        for (Element elm : typeParams) {
            typeArgs.add(elm.asType());
        }
        return typeArgs;
    }

    /**
     * finds the nearest enclosing ClassTree on
     * <code>path</code> that is class or interface or enum or annotation type
     * and is or is not annonymous. In case no ClassTree is found the first top
     * level ClassTree is returned.
     *
     * Especially useful for selecting proper tree to refactor.
     *
     * @param javac javac
     * @param path path to search
     * @param isClass stop on class
     * @param isInterface stop on interface
     * @param isEnum stop on enum
     * @param isAnnotation stop on annotation type
     * @param isAnonymous check if class or interface is annonymous
     * @return path to the enclosing ClassTree
     * @deprecated 
     */
    @Deprecated
    public static @NullUnknown
    TreePath findEnclosingClass(CompilationInfo javac, TreePath path, boolean isClass, boolean isInterface, boolean isEnum, boolean isAnnotation, boolean isAnonymous) {
        if (path == null) {
            return null;
        }
        Tree selectedTree = path.getLeaf();
        TreeUtilities utils = javac.getTreeUtilities();
        while (true) {
            if (TreeUtilities.CLASS_TREE_KINDS.contains(selectedTree.getKind())) {
                ClassTree classTree = (ClassTree) selectedTree;
                if (isEnum && utils.isEnum(classTree)
                        || isInterface && utils.isInterface(classTree)
                        || isAnnotation && utils.isAnnotation(classTree)
                        || isClass && !(utils.isInterface(classTree) || utils.isEnum(classTree) || utils.isAnnotation(classTree))) {

                    Tree.Kind parentKind = path.getParentPath().getLeaf().getKind();
                    if (isAnonymous || Tree.Kind.NEW_CLASS != parentKind) {
                        break;
                    }
                }
            }

            path = path.getParentPath();
            if (path == null) {
                List<? extends Tree> typeDecls = javac.getCompilationUnit().getTypeDecls();
                if (typeDecls.isEmpty()) {
                    return null;
                }
                selectedTree = typeDecls.get(0);
                if (selectedTree.getKind().asInterface() == ClassTree.class) {
                    return javac.getTrees().getPath(javac.getCompilationUnit(), selectedTree);
                } else {
                    return null;
                }
            }
            selectedTree = path.getLeaf();
        }
        return path;
    }

    //XXX: copied from SourceUtils.addImports. Ideally, should be on one place only:
    public static CompilationUnitTree addImports(CompilationUnitTree cut, List<String> toImport, TreeMaker make)
            throws IOException {
        // do not modify the list given by the caller (may be reused or immutable).
        toImport = new ArrayList<String>(toImport);
        Collections.sort(toImport);

        List<ImportTree> imports = new ArrayList<ImportTree>(cut.getImports());
        int currentToImport = toImport.size() - 1;
        int currentExisting = imports.size() - 1;

        while (currentToImport >= 0 && currentExisting >= 0) {
            String currentToImportText = toImport.get(currentToImport);

            while (currentExisting >= 0 && (imports.get(currentExisting).isStatic() || imports.get(currentExisting).getQualifiedIdentifier().toString().compareTo(currentToImportText) > 0)) {
                currentExisting--;
            }

            if (currentExisting >= 0) {
                imports.add(currentExisting + 1, make.Import(make.Identifier(currentToImportText), false));
                currentToImport--;
            }
        }
        // we are at the head of import section and we still have some imports
        // to add, put them to the very beginning
        while (currentToImport >= 0) {
            String importText = toImport.get(currentToImport);
            imports.add(0, make.Import(make.Identifier(importText), false));
            currentToImport--;
        }
        // return a copy of the unit with changed imports section
        return make.CompilationUnit(cut.getPackageAnnotations(), cut.getPackageName(), imports, cut.getTypeDecls(), cut.getSourceFile());
    }

    /**
     * transforms passed modifiers to abstract form
     *
     * @param make a tree maker
     * @param oldMods modifiers of method or class
     * @return the abstract form of ModifiersTree
     */
    public static ModifiersTree makeAbstract(TreeMaker make, ModifiersTree oldMods) {
        if (oldMods.getFlags().contains(Modifier.ABSTRACT)) {
            return oldMods;
        }
        Set<Modifier> flags = new HashSet<Modifier>(oldMods.getFlags());
        flags.add(Modifier.ABSTRACT);
        flags.remove(Modifier.FINAL);
        return make.Modifiers(flags, oldMods.getAnnotations());
    }

    public static String variableClashes(String newName, TreePath tp, CompilationInfo info) {
        LocalVarScanner lookup = new LocalVarScanner(info, newName);
        TreePath scopeBlok = tp;
        EnumSet set = EnumSet.of(Tree.Kind.BLOCK, Tree.Kind.FOR_LOOP, Tree.Kind.METHOD);
        while (scopeBlok != null && !set.contains(scopeBlok.getLeaf().getKind())) {
            scopeBlok = scopeBlok.getParentPath();
        }
        if(scopeBlok == null) {
            return null;
        }
        Element var = info.getTrees().getElement(tp);
        if (var != null) {
            lookup.scan(scopeBlok, var);
        }

        if (lookup.hasRefernces()) {
            return NbBundle.getMessage(RefactoringUtils.class, "MSG_LocVariableClash",newName);
        }

        TreePath temp = tp;
        while (temp != null && temp.getLeaf().getKind() != Tree.Kind.METHOD) {
            Scope scope = info.getTrees().getScope(temp);
            for (Element el : scope.getLocalElements()) {
                if (el.getSimpleName().toString().equals(newName)) {
                    return NbBundle.getMessage(RefactoringUtils.class, "MSG_LocVariableClash",newName);
                }
            }
            temp = temp.getParentPath();
        }
        return null;
    }

    public static boolean isSetter(CompilationInfo info, ExecutableElement el, Element propertyElement) {
        CodeStyle codeStyle = getCodeStyle(info);
        String setterName = CodeStyleUtils.computeSetterName(
                propertyElement.getSimpleName(),
                propertyElement.getModifiers().contains(Modifier.STATIC),
                codeStyle);

        return el.getSimpleName().contentEquals(setterName)
                && el.getReturnType().getKind() == TypeKind.VOID
                && el.getParameters().size() == 1
                && info.getTypes().isSameType(el.getParameters().iterator().next().asType(), propertyElement.asType());
    }

    public static boolean isGetter(CompilationInfo info, ExecutableElement el, Element propertyElement) {
        CodeStyle codeStyle = getCodeStyle(info);
        String getterName = CodeStyleUtils.computeGetterName(
                propertyElement.getSimpleName(),
                propertyElement.asType().getKind() == TypeKind.BOOLEAN,
                propertyElement.getModifiers().contains(Modifier.STATIC),
                codeStyle);
        return el.getSimpleName().contentEquals(getterName)
                && info.getTypes().isSameType(el.getReturnType(),propertyElement.asType())
                && el.getParameters().isEmpty();
    }
    
    public static String removeFieldPrefixSuffix(Element var, CodeStyle cs) {
        boolean isStatic = var.getModifiers().contains(Modifier.STATIC);
        return CodeStyleUtils.removePrefixSuffix(var.getSimpleName(),
                isStatic ? cs.getStaticFieldNamePrefix() : cs.getFieldNamePrefix(),
                isStatic ? cs.getStaticFieldNameSuffix() : cs.getFieldNameSuffix());
    }
    
    public static String addParamPrefixSuffix(CharSequence name, CodeStyle cs) {
        return CodeStyleUtils.addPrefixSuffix(name,
                cs.getParameterNamePrefix(),
                cs.getParameterNameSuffix());
    }

    public static String getTestMethodName(String propertyName) {
	return "test" + CodeStyleUtils.getCapitalizedName(propertyName); //NOI18N
    }

    public static boolean isWeakerAccess(Set<Modifier> modifiers, Set<Modifier> modifiers0) {
        return accessLevel(modifiers) < accessLevel(modifiers0);
    }

    private static int accessLevel(Set<Modifier> modifiers) {
        if (modifiers.contains(Modifier.PRIVATE)) {
            return 0;
        }
        if (modifiers.contains(Modifier.PROTECTED)) {
            return 2;
        }
        if (modifiers.contains(Modifier.PUBLIC)) {
            return 3;
        }
        return 1;
    }

    public static String getAccess(Set<Modifier> modifiers) {
        if (modifiers.contains(Modifier.PRIVATE)) {
            return "private"; //NOI18N
        }
        if (modifiers.contains(Modifier.PROTECTED)) {
            return "protected"; //NOI18N
        }
        if (modifiers.contains(Modifier.PUBLIC)) {
            return "public"; //NOI18N
        }
        return "<default>"; //NOI18N
    }

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

    public static FileObject getRootFileObject(URL url) throws IOException {
        FileObject result = URLMapper.findFileObject(url);
        File f;
        try {
            f = result != null ? null : FileUtil.normalizeFile(Utilities.toFile(url.toURI())); //NOI18N
        } catch (URISyntaxException ex) {
            throw new IOException(ex);
        }
        while (result == null && f != null) {
            result = FileUtil.toFileObject(f);
            f = f.getParentFile();
        }
        return result;
    }

    @SuppressWarnings("CollectionContainsUrl")
    public static ClassPath merge(final ClassPath... cps) {
        final Set<URL> roots = new LinkedHashSet<URL>(cps.length);
        for (final ClassPath cp : cps) {
            if (cp != null) {
                for (final ClassPath.Entry entry : cp.entries()) {
                    final URL root = entry.getURL();
                    if (!roots.contains(root)) {
                        roots.add(root);
                    }
                }
            }
        }
        return ClassPathSupport.createClassPath(roots.toArray(new URL[roots.size()]));
    }

    public static boolean isFromEditor(EditorCookie ec) {
        if (ec != null && NbDocument.findRecentEditorPane(ec) != null) {
            TopComponent activetc = TopComponent.getRegistry().getActivated();
            if (activetc instanceof CloneableEditorSupport.Pane) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * Checks if the element is a method or constructor. Returns {@code false} for {@code null} input.
     * @param e element to check
     * @return true iff the element is a constructor or method.
     */
    public static boolean isExecutableElement(Element e) {
        if (e == null) {
            return false;
        }
        ElementKind ek = e.getKind();
        return ek == ElementKind.CONSTRUCTOR || ek == ElementKind.METHOD;
    }

    private RefactoringUtils() {
    }
}