/*

 * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.javac.code;

import java.io.IOException;

import java.nio.file.Path;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.Set;

import javax.lang.model.SourceVersion;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileManager.Location;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileObject.Kind;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import com.sun.tools.javac.api.ClassNamesForFileOraculum;

import com.sun.tools.javac.code.Scope.WriteableScope;

import com.sun.tools.javac.code.Symbol.ClassSymbol;

import com.sun.tools.javac.code.Symbol.Completer;

import com.sun.tools.javac.code.Symbol.CompletionFailure;

import com.sun.tools.javac.code.Symbol.ModuleSymbol;

import com.sun.tools.javac.code.Symbol.PackageSymbol;

import com.sun.tools.javac.code.Symbol.TypeSymbol;

import com.sun.tools.javac.comp.Annotate;

import com.sun.tools.javac.file.JRTIndex;

import com.sun.tools.javac.file.JavacFileManager;

import com.sun.tools.javac.jvm.ClassReader;

import com.sun.tools.javac.jvm.Profile;

import com.sun.tools.javac.main.Option;

import com.sun.tools.javac.platform.PlatformDescription;

import com.sun.tools.javac.util.*;

import static javax.tools.StandardLocation.*;

import static com.sun.tools.javac.code.Flags.*;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import com.sun.tools.javac.util.Dependencies.CompletionCause;

/**

 *  This class provides operations to locate class definitions

 *  from the source and class files on the paths provided to javac.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class ClassFinder {

    /** The context key for the class finder. */

    protected static final Context.Key<ClassFinder> classFinderKey = new Context.Key<>();

    ClassReader reader;

    private final Annotate annotate;

    /** Switch: verbose output.

     */

    boolean verbose;

    /**

     * Switch: cache completion failures unless -XDdev is used

     */

    private boolean cacheCompletionFailure;

    /**

     * Switch: prefer source files instead of newer when both source

     * and class are available

     **/

    protected boolean preferSource;

    /**

     * Switch: Search classpath and sourcepath for classes before the

     * bootclasspath

     */

    protected boolean userPathsFirst;

    /**

     * Switch: should read OTHER classfiles (.sig files) from PLATFORM_CLASS_PATH.

     */

    private boolean allowSigFiles;

    /** The log to use for verbose output

     */

    final Log log;

    /** The symbol table. */

    Symtab syms;

    /** The name table. */

    final Names names;

    /** Force a completion failure on this name

     */

    final Name completionFailureName;

    /** Access to files

     */

    private final JavaFileManager fileManager;

    /** Dependency tracker

     */

    private final Dependencies dependencies;

    /** Factory for diagnostics

     */

    JCDiagnostic.Factory diagFactory;

    private final ClassNamesForFileOraculum classNamesOraculum;

    /** Can be reassigned from outside:

     *  the completer to be used for ".java" files. If this remains unassigned

     *  ".java" files will not be loaded.

     */

    public Completer sourceCompleter = Completer.NULL_COMPLETER;

    /** The path name of the class file currently being read.

     */

    protected JavaFileObject currentClassFile = null;

    /** The class or method currently being read.

     */

    protected Symbol currentOwner = null;

    /**

     * The currently selected profile.

     */

    private final Profile profile;

    /**

     * Use direct access to the JRTIndex to access the temporary

     * replacement for the info that used to be in ct.sym.

     * In time, this will go away and be replaced by the module system.

     */

    private final JRTIndex jrtIndex;

    /**

     * Completer that delegates to the complete-method of this class.

     */

    private final Completer thisCompleter = this::complete;

    public Completer getCompleter() {

        return thisCompleter;

    }

    /** Get the ClassFinder instance for this invocation. */

    public static ClassFinder instance(Context context) {

        ClassFinder instance = context.get(classFinderKey);

        if (instance == null)

            instance = new ClassFinder(context);

        return instance;

    }

    /** Construct a new class finder. */

    protected ClassFinder(Context context) {

        context.put(classFinderKey, this);

        reader = ClassReader.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        fileManager = context.get(JavaFileManager.class);

        dependencies = Dependencies.instance(context);

        if (fileManager == null)

            throw new AssertionError("FileManager initialization error");

        diagFactory = JCDiagnostic.Factory.instance(context);

        classNamesOraculum = context.get(ClassNamesForFileOraculum.class);

        log = Log.instance(context);

        annotate = Annotate.instance(context);

        Options options = Options.instance(context);

        verbose = options.isSet(Option.VERBOSE);

        cacheCompletionFailure = options.isUnset("dev");

        preferSource = "source".equals(options.get("-Xprefer"));

        userPathsFirst = options.isSet(Option.XXUSERPATHSFIRST);

        allowSigFiles = context.get(PlatformDescription.class) != null;

        completionFailureName =

            options.isSet("failcomplete")

            ? names.fromString(options.get("failcomplete"))

            : null;

        // Temporary, until more info is available from the module system.

        boolean useCtProps;

        JavaFileManager fm = context.get(JavaFileManager.class);

        if (fm instanceof JavacFileManager) {

            JavacFileManager jfm = (JavacFileManager) fm;

            useCtProps = jfm.isDefaultBootClassPath() && jfm.isSymbolFileEnabled();

        } else if (fm.getClass().getName().equals("com.sun.tools.sjavac.comp.SmartFileManager")) {

            useCtProps = !options.isSet("ignore.symbol.file");

        } else {

            useCtProps = false;

        }

        jrtIndex = useCtProps && JRTIndex.isAvailable() ? JRTIndex.getSharedInstance() : null;

        profile = Profile.instance(context);

    }

/************************************************************************

 * Temporary ct.sym replacement

 *

 * The following code is a temporary substitute for the ct.sym mechanism

 * used in JDK 6 thru JDK 8.

 * This mechanism will eventually be superseded by the Jigsaw module system.

 ***********************************************************************/

    /**

     * Returns any extra flags for a class symbol.

     * This information used to be provided using private annotations

     * in the class file in ct.sym; in time, this information will be

     * available from the module system.

     */

    long getSupplementaryFlags(ClassSymbol c) {

        if (jrtIndex == null || !jrtIndex.isInJRT(c.classfile) || c.name == names.module_info) {

            return 0;

        }

        if (supplementaryFlags == null) {

            supplementaryFlags = new HashMap<>();

        }

        Long flags = supplementaryFlags.get(c.packge());

        if (flags == null) {

            long newFlags = 0;

            try {

                JRTIndex.CtSym ctSym = jrtIndex.getCtSym(c.packge().flatName());

                Profile minProfile = Profile.DEFAULT;

                if (ctSym.proprietary)

                    newFlags |= PROPRIETARY;

                if (ctSym.minProfile != null)

                    minProfile = Profile.lookup(ctSym.minProfile);

                if (profile != Profile.DEFAULT && minProfile.value > profile.value) {

                    newFlags |= NOT_IN_PROFILE;

                }

            } catch (IOException ignore) {

            }

            supplementaryFlags.put(c.packge(), flags = newFlags);

        }

        return flags;

    }

    private Map<PackageSymbol, Long> supplementaryFlags;

    public Runnable ap = null;

/************************************************************************

 * Loading Classes

 ***********************************************************************/

    /** Completion for classes to be loaded. Before a class is loaded

     *  we make sure its enclosing class (if any) is loaded.

     */

    private void complete(Symbol sym) throws CompletionFailure {

        try {

            if (sym.kind == TYP) {

                try {

                    ClassSymbol c = (ClassSymbol) sym;

                    dependencies.push(c, CompletionCause.CLASS_READER);

                    annotate.blockAnnotations();

                    Scope tempScope = c.members_field = new Scope.ErrorScope(c); // make sure it's always defined

                    completeOwners(c.owner);

                    completeEnclosing(c);

                    if (c.members_field == tempScope) { // do not fill in when already completed as a result of completing owners

                        try {

                            fillIn(c);

                        } catch (Abort a) {

                            syms.removeClass(c.packge().modle, c.flatname);

                        }

                    }

                } finally {

                    annotate.unblockAnnotationsNoFlush();

                    dependencies.pop();

                }

            } else if (sym.kind == PCK) {

                PackageSymbol p = (PackageSymbol)sym;

                try {

                    fillIn(p);

                } catch (IOException ex) {

                    throw new CompletionFailure(sym, ex.getLocalizedMessage()).initCause(ex);

                }

            }

            if (!reader.filling)

                annotate.flush(); // finish attaching annotations

        } finally {

            if (ap != null) {

                final Runnable r = ap;

                ap = null;

                r.run();

            }

        }

    }

    /** complete up through the enclosing package. */

    private void completeOwners(Symbol o) {

        if (o.kind != PCK) completeOwners(o.owner);

        o.complete();

    }

    /**

     * Tries to complete lexically enclosing classes if c looks like a

     * nested class.  This is similar to completeOwners but handles

     * the situation when a nested class is accessed directly as it is

     * possible with the Tree API or javax.lang.model.*.

     */

    private void completeEnclosing(ClassSymbol c) {

        if (c.owner.kind == PCK) {

            Symbol owner = c.owner;

            for (Name name : Convert.enclosingCandidates(Convert.shortName(c.name))) {

                Symbol encl = owner.members().findFirst(name);

                if (encl == null)

                    encl = syms.getClass(c.packge().modle, TypeSymbol.formFlatName(name, owner));

                if (encl != null)

                    encl.complete();

            }

        }

    }

    /** Fill in definition of class `c' from corresponding class or

     *  source file.

     */

    void fillIn(ClassSymbol c) {

        if (completionFailureName == c.fullname) {

            throw new CompletionFailure(c, "user-selected completion failure by class name");

        }

        currentOwner = c;

        JavaFileObject classfile = c.classfile;

        if (classfile != null) {

            JavaFileObject previousClassFile = currentClassFile;

            Symbol prevOwner = c.owner;

            Name prevName = c.fullname;

            try {

                if (reader.filling) {

                    Assert.error("Filling " + classfile.toUri() + " during " + previousClassFile);

                }

                currentClassFile = classfile;

                if (verbose) {

                    log.printVerbose("loading", currentClassFile.getName());

                }

                if (classfile.getKind() == JavaFileObject.Kind.CLASS ||

                    classfile.getKind() == JavaFileObject.Kind.OTHER) {

                    reader.readClassFile(c);

                    c.flags_field |= getSupplementaryFlags(c);

                } else {

                    if (!sourceCompleter.isTerminal()) {

                        if (!classfile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE)) {

                            sourceCompleter.complete(c);

                        }

                    } else {

                        throw new IllegalStateException("Source completer required to read "

                                                        + classfile.toUri());

                    }

                }

            } catch (BadClassFile cf) {

                //the symbol may be partially initialized, purge it:

                c.owner = prevOwner;

                c.members_field.getSymbols(sym -> sym.kind == TYP).forEach(sym -> {

                    ClassSymbol csym = (ClassSymbol) sym;

                    csym.owner = sym.packge();

                    csym.owner.members().enter(sym);

                    csym.fullname = sym.flatName();

                    csym.name = Convert.shortName(sym.flatName());

                    csym.reset();

                });

                c.fullname = prevName;

                c.name = Convert.shortName(prevName);

                c.reset();

                throw cf;

            } finally {

                currentClassFile = previousClassFile;

            }

        } else {

            throw classFileNotFound(c);

        }

    }

    // where

        private CompletionFailure classFileNotFound(ClassSymbol c) {

            JCDiagnostic diag =

                diagFactory.fragment("class.file.not.found", c.flatname);

            return newCompletionFailure(c, diag);

        }

        /** Static factory for CompletionFailure objects.

         *  In practice, only one can be used at a time, so we share one

         *  to reduce the expense of allocating new exception objects.

         */

        private CompletionFailure newCompletionFailure(TypeSymbol c,

                                                       JCDiagnostic diag) {

            if (!cacheCompletionFailure) {

                // log.warning("proc.messager",

                //             Log.getLocalizedString("class.file.not.found", c.flatname));

                // c.debug.printStackTrace();

                return new CompletionFailure(c, diag);

            } else {

                CompletionFailure result = cachedCompletionFailure;

                result.sym = c;

                result.diag = diag;

                return result;

            }

        }

        private final CompletionFailure cachedCompletionFailure =

            new CompletionFailure(null, (JCDiagnostic) null);

        {

            cachedCompletionFailure.setStackTrace(new StackTraceElement[0]);

        }

    /** Load a toplevel class with given fully qualified name

     *  The class is entered into `classes' only if load was successful.

     */

    public ClassSymbol loadClass(ModuleSymbol msym, Name flatname) throws CompletionFailure {

        Assert.checkNonNull(msym);

        Name packageName = Convert.packagePart(flatname);

        PackageSymbol ps = syms.lookupPackage(msym, packageName);

        Assert.checkNonNull(ps.modle, () -> "msym=" + msym + "; flatName=" + flatname);

        boolean absent = syms.getClass(ps.modle, flatname) == null;

        ClassSymbol c = syms.enterClass(ps.modle, flatname);

        if (c.members_field == null) {

            try {

                c.complete();

            } catch (CompletionFailure ex) {

                if (absent) syms.removeClass(ps.modle, flatname);

                throw ex;

            }

        }

        return c;

    }

/************************************************************************

 * Loading Packages

 ***********************************************************************/

    //TODO: for compatibility, remove eventually

    protected void includeClassFile(PackageSymbol p, JavaFileObject file) {

        String binaryName = fileManager.inferBinaryName(currentLoc, file);        

        includeClassFile(p, file, binaryName);

    }

    /** Include class corresponding to given class file in package,

     *  unless (1) we already have one the same kind (.class or .java), or

     *         (2) we have one of the other kind, and the given class file

     *             is older.

     */

    protected void includeClassFile(PackageSymbol p, JavaFileObject file, String binaryName) {

        if ((p.flags_field & EXISTS) == 0)

            for (Symbol q = p; q != null && q.kind == PCK; q = q.owner)

                q.flags_field |= EXISTS;

        JavaFileObject.Kind kind = file.getKind();

        int seen;

        if (kind == JavaFileObject.Kind.CLASS || kind == JavaFileObject.Kind.OTHER)

            seen = CLASS_SEEN;

        else

            seen = SOURCE_SEEN;

        int lastDot = binaryName.lastIndexOf(".");

        Name classname = names.fromString(binaryName.substring(lastDot + 1));

        boolean isPkgInfo = classname == names.package_info;

        ClassSymbol c = isPkgInfo

            ? p.package_info

            : (ClassSymbol) p.members_field.findFirst(classname);

        if (c == null) {

            c = syms.enterClass(p.modle, classname, p);

            if (c.classfile == null) // only update the file if's it's newly created

                c.classfile = file;

            if (isPkgInfo) {

                p.package_info = c;

            } else {

                if (c.owner == p)  // it might be an inner class

                    p.members_field.enter(c);

            }

        } else if (!preferCurrent && c.classfile != null && (c.flags_field & seen) == 0) {

            // if c.classfile == null, we are currently compiling this class

            // and no further action is necessary.

            // if (c.flags_field & seen) != 0, we have already encountered

            // a file of the same kind; again no further action is necessary.

            if ((c.flags_field & (CLASS_SEEN | SOURCE_SEEN)) != 0)

                c.classfile = preferredFileObject(file, c.classfile);

        } else if (c.classfile != null && isSigOverClass(c.classfile, file)) {

            c.classfile = file;

        }

        c.flags_field |= seen;

    }

    private boolean isSigOverClass(final JavaFileObject a, final JavaFileObject b) {

        String patha = a.getName().toLowerCase();

        String pathb = b.getName().toLowerCase();

        return pathb.endsWith(".sig") && patha.endsWith(".class");  //NOI18N

    }

    /** Implement policy to choose to derive information from a source

     *  file or a class file when both are present.  May be overridden

     *  by subclasses.

     */

    protected JavaFileObject preferredFileObject(JavaFileObject a,

                                           JavaFileObject b) {

        if (preferSource && !b.getName().toLowerCase().endsWith(".sig"))

            return (a.getKind() == JavaFileObject.Kind.SOURCE) ? a : b;

        else {

            long adate = a.getLastModified();

            long bdate = b.getLastModified();

            // 6449326: policy for bad lastModifiedTime in ClassReader

            //assert adate >= 0 && bdate >= 0;

            return (adate > bdate) ? a : b;

        }

    }

    /**

     * specifies types of files to be read when filling in a package symbol

     */

    // Note: overridden by JavadocClassFinder

    protected EnumSet<JavaFileObject.Kind> getPackageFileKinds() {

        return EnumSet.of(JavaFileObject.Kind.CLASS, JavaFileObject.Kind.SOURCE);

    }

    /**

     * this is used to support javadoc

     */

    protected void extraFileActions(PackageSymbol pack, JavaFileObject fe) {

    }

    protected Location currentLoc; // FIXME

    private boolean verbosePath = true;

    // Set to true when the currently selected file should be kept

    private boolean preferCurrent;

    /** Load directory of package into members scope.

     */

    private void fillIn(PackageSymbol p) throws IOException {

        if (p.members_field == null)

            p.members_field = WriteableScope.create(p);

        ModuleSymbol msym = p.modle;

        Assert.checkNonNull(msym, p::toString);

        msym.complete();

        if (msym == syms.noModule) {

            preferCurrent = false;

            if (userPathsFirst) {

                scanUserPaths(p, true);

                preferCurrent = true;

                scanPlatformPath(p);

            } else {

                scanPlatformPath(p);

                scanUserPaths(p, true);

            }

        } else if (msym.classLocation == StandardLocation.CLASS_PATH) {

            scanUserPaths(p, msym.sourceLocation == StandardLocation.SOURCE_PATH);

        } else {

            scanModulePaths(p, msym);

        }

    }

    // TODO: for now, this is a much simplified form of scanUserPaths

    // and (deliberately) does not default sourcepath to classpath.

    // But, we need to think about retaining existing behavior for

    // -classpath and -sourcepath for single module mode.

    // One plausible solution is to detect if the module's sourceLocation

    // is the same as the module's classLocation.

    private void scanModulePaths(PackageSymbol p, ModuleSymbol msym) throws IOException {

        Set<JavaFileObject.Kind> kinds = getPackageFileKinds();

        Set<JavaFileObject.Kind> classKinds = EnumSet.copyOf(kinds);

        classKinds.remove(JavaFileObject.Kind.SOURCE);

        boolean wantClassFiles = !classKinds.isEmpty();

        Set<JavaFileObject.Kind> sourceKinds = EnumSet.copyOf(kinds);

        sourceKinds.remove(JavaFileObject.Kind.CLASS);

        boolean wantSourceFiles = !sourceKinds.isEmpty();

        String packageName = p.fullname.toString();

        Location classLocn = msym.classLocation;

        Location sourceLocn = msym.sourceLocation;

        Location patchLocn = msym.patchLocation;

        Location patchOutLocn = msym.patchOutputLocation;

        boolean prevPreferCurrent = preferCurrent;

        try {

            preferCurrent = false;

            if (wantClassFiles && (patchOutLocn != null)) {

                fillIn(p, patchOutLocn,

                       list(patchOutLocn,

                            p,

                            packageName,

                            classKinds));

            }

            if ((wantClassFiles || wantSourceFiles) && (patchLocn != null)) {

                Set<JavaFileObject.Kind> combined = EnumSet.noneOf(JavaFileObject.Kind.class);

                combined.addAll(classKinds);

                combined.addAll(sourceKinds);

                fillIn(p, patchLocn,

                       list(patchLocn,

                            p,

                            packageName,

                            combined));

            }

            preferCurrent = true;

            if (wantClassFiles && (classLocn != null)) {

                fillIn(p, classLocn,

                       list(classLocn,

                            p,

                            packageName,

                            classKinds));

            }

            if (wantSourceFiles && (sourceLocn != null)) {

                fillIn(p, sourceLocn,

                       list(sourceLocn,

                            p,

                            packageName,

                            sourceKinds));

            }

        } finally {

            preferCurrent = prevPreferCurrent;

        }

    }

    /**

     * Scans class path and source path for files in given package.

     */

    private void scanUserPaths(PackageSymbol p, boolean includeSourcePath) throws IOException {

        Set<JavaFileObject.Kind> kinds = getPackageFileKinds();

        Set<JavaFileObject.Kind> classKinds = EnumSet.copyOf(kinds);

        classKinds.remove(JavaFileObject.Kind.SOURCE);

        boolean wantClassFiles = !classKinds.isEmpty();

        Set<JavaFileObject.Kind> sourceKinds = EnumSet.copyOf(kinds);

        sourceKinds.remove(JavaFileObject.Kind.CLASS);

        boolean wantSourceFiles = !sourceKinds.isEmpty();

        boolean haveSourcePath = includeSourcePath && fileManager.hasLocation(SOURCE_PATH);

        if (verbose && verbosePath) {

            if (fileManager instanceof StandardJavaFileManager) {

                StandardJavaFileManager fm = (StandardJavaFileManager)fileManager;

                if (haveSourcePath && wantSourceFiles) {

                    List<Path> path = List.nil();

                    for (Path sourcePath : fm.getLocationAsPaths(SOURCE_PATH)) {

                        path = path.prepend(sourcePath);

                    }

                    log.printVerbose("sourcepath", path.reverse().toString());

                } else if (wantSourceFiles) {

                    List<Path> path = List.nil();

                    for (Path classPath : fm.getLocationAsPaths(CLASS_PATH)) {

                        path = path.prepend(classPath);

                    }

                    log.printVerbose("sourcepath", path.reverse().toString());

                }

                if (wantClassFiles) {

                    List<Path> path = List.nil();

                    for (Path platformPath : fm.getLocationAsPaths(PLATFORM_CLASS_PATH)) {

                        path = path.prepend(platformPath);

                    }

                    for (Path classPath : fm.getLocationAsPaths(CLASS_PATH)) {

                        path = path.prepend(classPath);

                    }

                    log.printVerbose("classpath",  path.reverse().toString());

                }

            }

        }

        String packageName = p.fullname.toString();

        if (wantSourceFiles && !haveSourcePath) {

            fillIn(p, CLASS_PATH,

                   list(CLASS_PATH,

                        p,

                        packageName,

                        kinds));

        } else {

            if (wantClassFiles)

                fillIn(p, CLASS_PATH,

                       list(CLASS_PATH,

                            p,

                            packageName,

                            classKinds));

            if (wantSourceFiles)

                fillIn(p, SOURCE_PATH,

                       list(SOURCE_PATH,

                            p,

                            packageName,

                            sourceKinds));

        }

    }

    /**

     * Scans platform class path for files in given package.

     */

    private void scanPlatformPath(PackageSymbol p) throws IOException {

        fillIn(p, PLATFORM_CLASS_PATH,

               list(PLATFORM_CLASS_PATH,

                    p,

                    p.fullname.toString(),

                    allowSigFiles ? EnumSet.of(JavaFileObject.Kind.CLASS,

                                               JavaFileObject.Kind.OTHER)

                                  : EnumSet.of(JavaFileObject.Kind.CLASS)));

    }

    // where

        @SuppressWarnings("fallthrough")

        private void fillIn(PackageSymbol p,

                            Location location,

                            Iterable<JavaFileObject> files)

        {

            currentLoc = location;

            for (JavaFileObject fo : files) {

                switch (fo.getKind()) {

                case OTHER:

                    if (!isSigFile(location, fo)) {

                        extraFileActions(p, fo);

                        break;

                    }

                    //intentional fall-through:

                case CLASS:

                case SOURCE: {

                    String[] binaryNames = null;

                    if (classNamesOraculum != null) {

                        binaryNames = classNamesOraculum.divineClassName(fo);

                    }

                    if (binaryNames == null) {

                        String binaryName = fileManager.inferBinaryName(currentLoc, fo);

                        if (binaryName != null) {

                            binaryNames = new String[] {binaryName};

                        }

                    }

                    // TODO pass binaryName to includeClassFile

                    if (binaryNames != null) {

                        for (String binaryName : binaryNames) {

                            String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);

                            if (SourceVersion.isIdentifier(simpleName) ||

                                simpleName.equals("package-info"))

                                includeClassFile(p, fo);

                        }

                    }

                    break;

                }

                default:

                    extraFileActions(p, fo);

                    break;

                }

            }

            if (classNamesOraculum != null && location == SOURCE_PATH) {

                JavaFileObject[] sources = classNamesOraculum.divineSources(p.fullname.toString());

                if (sources != null) {

                    for (JavaFileObject fo : sources) {

                        for (String binaryName : classNamesOraculum.divineClassName(fo)) {

                            String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);

                            if (SourceVersion.isIdentifier(simpleName) ||

                                    simpleName.equals("package-info")) {

                                includeClassFile(p, fo, binaryName);

                            }

                        }

                    }

                }

            }

        }

        boolean isSigFile(Location location, JavaFileObject fo) {

            return location == PLATFORM_CLASS_PATH &&

                   allowSigFiles &&

                   fo.getName().endsWith(".sig");

        }

        Iterable<JavaFileObject> list(Location location,

                                      PackageSymbol p,

                                      String packageName,

                                      Set<Kind> kinds) throws IOException {

            Iterable<JavaFileObject> listed = fileManager.list(location,

                                                               packageName,

                                                               EnumSet.allOf(Kind.class),

                                                               false);

            return () -> new Iterator<JavaFileObject>() {

                private final Iterator<JavaFileObject> original = listed.iterator();

                private JavaFileObject next;

                @Override

                public boolean hasNext() {

                    if (next == null) {

                        while (original.hasNext()) {

                            JavaFileObject fo = original.next();

                            if (fo.getKind() != Kind.CLASS &&

                                fo.getKind() != Kind.SOURCE &&

                                !isSigFile(currentLoc, fo)) {

                                p.flags_field |= Flags.HAS_RESOURCE;

                            }

                            if (kinds.contains(fo.getKind())) {

                                next = fo;

                                break;

                            }

                        }

                    }

                    return next != null;

                }

                @Override

                public JavaFileObject next() {

                    if (!hasNext())

                        throw new NoSuchElementException();

                    JavaFileObject result = next;

                    next = null;

                    return result;

                }

            };

        }

    /**

     * Used for bad class definition files, such as bad .class files or

     * for .java files with unexpected package or class names.

     */

    public static class BadClassFile extends CompletionFailure {

        private static final long serialVersionUID = 0;

        public BadClassFile(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag,

                JCDiagnostic.Factory diagFactory) {

            super(sym, createBadClassFileDiagnostic(file, diag, diagFactory));

        }

        // where

        private static JCDiagnostic createBadClassFileDiagnostic(

                JavaFileObject file, JCDiagnostic diag, JCDiagnostic.Factory diagFactory) {

            String key = (file.getKind() == JavaFileObject.Kind.SOURCE

                        ? "bad.source.file.header" : "bad.class.file.header");

            return diagFactory.fragment(key, file, diag);

        }

    }

    public static class BadEnclosingMethodAttr extends BadClassFile {

        private static final long serialVersionUID = 0;

        public BadEnclosingMethodAttr(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag,

                JCDiagnostic.Factory diagFactory) {

            super(sym, file, diag, diagFactory);

        }

    }

}