/*

 * Copyright (c) 2009, 2017, 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.comp;

import java.io.IOException;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.Set;

import java.util.function.Consumer;

import java.util.function.Predicate;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

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.StandardLocation;

import com.sun.source.tree.ModuleTree.ModuleKind;

import com.sun.tools.javac.code.ClassFinder;

import com.sun.tools.javac.code.DeferredLintHandler;

import com.sun.tools.javac.code.Directive;

import com.sun.tools.javac.code.Directive.ExportsDirective;

import com.sun.tools.javac.code.Directive.ExportsFlag;

import com.sun.tools.javac.code.Directive.OpensDirective;

import com.sun.tools.javac.code.Directive.OpensFlag;

import com.sun.tools.javac.code.Directive.RequiresDirective;

import com.sun.tools.javac.code.Directive.RequiresFlag;

import com.sun.tools.javac.code.Directive.UsesDirective;

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

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.ModuleFinder;

import com.sun.tools.javac.code.Source;

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

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.MethodSymbol;

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

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

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

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Types;

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

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

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

import com.sun.tools.javac.resources.CompilerProperties.Errors;

import com.sun.tools.javac.resources.CompilerProperties.Warnings;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;

import com.sun.tools.javac.tree.JCTree.JCDirective;

import com.sun.tools.javac.tree.JCTree.JCExports;

import com.sun.tools.javac.tree.JCTree.JCExpression;

import com.sun.tools.javac.tree.JCTree.JCModuleDecl;

import com.sun.tools.javac.tree.JCTree.JCOpens;

import com.sun.tools.javac.tree.JCTree.JCProvides;

import com.sun.tools.javac.tree.JCTree.JCRequires;

import com.sun.tools.javac.tree.JCTree.JCUses;

import com.sun.tools.javac.tree.JCTree.Tag;

import com.sun.tools.javac.tree.TreeInfo;

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

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

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

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

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

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

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

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

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

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

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

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

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

import com.sun.tools.javac.code.Kinds;

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

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

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

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

import static com.sun.tools.javac.code.TypeTag.CLASS;

/**

 *  TODO: fill in

 *

 *  <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 Modules extends JCTree.Visitor {

    private static final String ALL_SYSTEM = "ALL-SYSTEM";

    private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";

    private final Log log;

    private final Names names;

    private final Symtab syms;

    private final Attr attr;

    private final Check chk;

    private final DeferredLintHandler deferredLintHandler;

    private final TypeEnvs typeEnvs;

    private final Types types;

    private final JavaFileManager fileManager;

    private final ModuleFinder moduleFinder;

    private final Source source;

    private final boolean allowModules;

    public final boolean multiModuleMode;

    private final String legacyModuleOverride;

    private final Name java_se;

    private final Name java_;

    ModuleSymbol defaultModule;

    private final String addExportsOpt;

    private Map<ModuleSymbol, Set<ExportsDirective>> addExports;

    private final String addReadsOpt;

    private Map<ModuleSymbol, Set<RequiresDirective>> addReads;

    private final String addModsOpt;

    private final Set<String> extraAddMods = new HashSet<>();

    private final String limitModsOpt;

    private final Set<String> extraLimitMods = new HashSet<>();

    private final String moduleVersionOpt;

    private final boolean lintOptions;

    private final boolean backgroundCompilation;

    private final boolean ideMode;

    private final JavaFileManager fm;

    private Set<ModuleSymbol> rootModules = null;

    private final Set<ModuleSymbol> warnedMissing = new HashSet<>();

    public PackageNameFinder findPackageInFile;

    public static Modules instance(Context context) {

        Modules instance = context.get(Modules.class);

        if (instance == null)

            instance = new Modules(context);

        return instance;

    }

    protected Modules(Context context) {

        context.put(Modules.class, this);

        log = Log.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        attr = Attr.instance(context);

        chk = Check.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        moduleFinder = ModuleFinder.instance(context);

        types = Types.instance(context);

        fileManager = context.get(JavaFileManager.class);

        source = Source.instance(context);

        allowModules = source.allowModules();

        Options options = Options.instance(context);

        lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);

        Collection<String> xmodules = options.keySet()

                                             .stream()

                                             .filter(opt -> opt.startsWith(XMODULES_PREFIX))

                                             .map(opt -> opt.substring(XMODULES_PREFIX.length()))

                                             .collect(Collectors.toList());

        legacyModuleOverride = xmodules.size() == 1 ? xmodules.iterator().next() : null;

        multiModuleMode = fileManager.hasLocation(StandardLocation.MODULE_SOURCE_PATH);

        ClassWriter classWriter = ClassWriter.instance(context);

        classWriter.multiModuleMode = multiModuleMode;

        JNIWriter jniWriter = JNIWriter.instance(context);

        jniWriter.multiModuleMode = multiModuleMode;

        java_se = names.fromString("java.se");

        java_ = names.fromString("java.");

        addExportsOpt = options.get(Option.ADD_EXPORTS);

        addReadsOpt = options.get(Option.ADD_READS);

        addModsOpt = options.get(Option.ADD_MODULES);

        limitModsOpt = options.get(Option.LIMIT_MODULES);

        moduleVersionOpt = options.get(Option.MODULE_VERSION);

        fm = context.get(JavaFileManager.class);

        backgroundCompilation = options.get("backgroundCompilation") != null;

        ideMode = options.get("ide") != null;

    }

    //where

        private static final String XMODULES_PREFIX = "-Xmodule:";

    int depth = -1;

    private void dprintln(String msg) {

        for (int i = 0; i < depth; i++)

            System.err.print("  ");

        System.err.println(msg);

    }

    public void addExtraAddModules(String... extras) {

        extraAddMods.addAll(Arrays.asList(extras));

    }

    public void addExtraLimitModules(String... extras) {

        extraLimitMods.addAll(Arrays.asList(extras));

    }

    boolean inInitModules;

    public void initModules(List<JCCompilationUnit> trees) {

        Assert.check(!inInitModules);

        try {

            inInitModules = true;

            if (rootModules == null) {

                enter(trees, modules -> {

                    Assert.checkNull(rootModules);

                    Assert.checkNull(allModules);

                    this.rootModules = modules;

                    setupAllModules(); //initialize the module graph

                    Assert.checkNonNull(allModules);

                    inInitModules = false;

                }, null);

            } else {

                enter(trees, null);

            }

        } finally {

            inInitModules = false;

        }

    }

    public boolean enter(List<JCCompilationUnit> trees, ClassSymbol c) {

        Assert.check(rootModules != null || inInitModules || !allowModules);

        return enter(trees, modules -> {}, c);

    }

    private boolean enter(List<JCCompilationUnit> trees, Consumer<Set<ModuleSymbol>> init, ClassSymbol c) {

        if (!allowModules) {

            for (JCCompilationUnit tree: trees) {

                tree.modle = syms.noModule;

            }

            defaultModule = syms.noModule;

            return true;

        }

        int startErrors = log.nerrors;

        depth++;

        try {

            // scan trees for module defs

            Set<ModuleSymbol> roots = enterModules(trees, c);

            setCompilationUnitModules(trees, roots, c);

            init.accept(roots);

            for (ModuleSymbol msym: roots) {

                msym.complete();

            }

        } catch (CompletionFailure ex) {

            chk.completionError(null, ex);

        } finally {

            depth--;

        }

        return (log.nerrors == startErrors);

    }

    public Completer getCompleter() {

        return mainCompleter;

    }

    public ModuleSymbol getDefaultModule() {

        return defaultModule;

    }

    public boolean modulesInitialized() {

        return allModules != null;

    }

    private Set<ModuleSymbol> enterModules(List<JCCompilationUnit> trees, ClassSymbol c) {

        Set<ModuleSymbol> modules = new LinkedHashSet<>();

        for (JCCompilationUnit tree : trees) {

            JavaFileObject prev = log.useSource(tree.sourcefile);

            try {

                enterModule(tree, c, modules);

            } finally {

                log.useSource(prev);

            }

        }

        return modules;

    }

    private void enterModule(JCCompilationUnit toplevel, ClassSymbol c, Set<ModuleSymbol> modules) {

        boolean isModuleInfo = toplevel.sourcefile.isNameCompatible("module-info", Kind.SOURCE);

        boolean isModuleDecl = toplevel.getModuleDecl() != null;

        if (isModuleDecl) {

            JCModuleDecl decl = toplevel.getModuleDecl();

            if (!isModuleInfo) {

                log.error(decl.pos(), Errors.ModuleDeclSbInModuleInfoJava);

            }

            Name name = TreeInfo.fullName(decl.qualId);

            ModuleSymbol sym;

            if (c != null) {

                sym = (ModuleSymbol) c.owner;

                Assert.checkNonNull(sym.name);

                Name treeName = TreeInfo.fullName(decl.qualId);

                if (sym.name != treeName) {

                    log.error(decl.pos(), Errors.ModuleNameMismatch(name, sym.name));

                }

            } else {

                sym = syms.enterModule(name);

                if ((sym.flags_field & Flags.FROMCLASS) == 0 && sym.module_info.sourcefile != null && sym.module_info.sourcefile != toplevel.sourcefile) {

                    log.error(decl.pos(), Errors.DuplicateModule(sym));

                    return;

                }

            }

            sym.completer = getSourceCompleter(toplevel);

            sym.module_info.sourcefile = toplevel.sourcefile;

            decl.sym = sym;

            if (multiModuleMode || modules.isEmpty()) {

                modules.add(sym);

            } else {

                log.error(toplevel.pos(), Errors.TooManyModules);

            }

            Env<AttrContext> provisionalEnv = new Env<>(decl, null);

            provisionalEnv.toplevel = toplevel;

            typeEnvs.put(sym, provisionalEnv);

        } else if (isModuleInfo) {

            if (multiModuleMode) {

                JCTree tree = toplevel.defs.isEmpty() ? toplevel : toplevel.defs.head;

                log.error(tree.pos(), Errors.ExpectedModule);

            }

        }

    }

    private void setCompilationUnitModules(List<JCCompilationUnit> trees, Set<ModuleSymbol> rootModules, ClassSymbol c) {

        // update the module for each compilation unit

        if (multiModuleMode) {

            checkNoAllModulePath();

            for (JCCompilationUnit tree: trees) {

                if (tree.modle != null) {

                    continue;

                }

                if (tree.defs.isEmpty()) {

                    tree.modle = syms.unnamedModule;

                    continue;

                }

                JavaFileObject prev = log.useSource(tree.sourcefile);

                try {

                    Location msplocn = getModuleLocation(tree);

                    Location plocn = fileManager.hasLocation(StandardLocation.PATCH_MODULE_PATH) ?

                            fileManager.getLocationForModule(StandardLocation.PATCH_MODULE_PATH,

                                                             tree.sourcefile) :

                            null;

                    if (plocn != null) {

                        Name name = names.fromString(fileManager.inferModuleName(plocn));

                        ModuleSymbol msym = moduleFinder.findModule(name);

                        tree.modle = msym;

                        rootModules.add(msym);

                        if (msplocn != null) {

                            Name mspname = names.fromString(fileManager.inferModuleName(msplocn));

                            if (name != mspname) {

                                log.error(tree.pos(), Errors.FilePatchedAndMsp(name, mspname));

                            }

                        }

                    } else if (msplocn != null) {

                        if (tree.getModuleDecl() != null) {

                            JavaFileObject canonical =

                                    fileManager.getJavaFileForInput(msplocn, "module-info", Kind.SOURCE);

                            if (canonical == null || !fileManager.isSameFile(canonical, tree.sourcefile)) {

                                log.error(tree.pos(), Errors.ModuleNotFoundOnModuleSourcePath);

                            }

                        }

                        Name name = names.fromString(fileManager.inferModuleName(msplocn));

                        ModuleSymbol msym;

                        JCModuleDecl decl = tree.getModuleDecl();

                        if (decl != null) {

                            msym = decl.sym;

                            if (msym.name != name) {

                                log.error(decl.qualId, Errors.ModuleNameMismatch(msym.name, name));

                            }

                        } else {

                            if (tree.getPackage() == null) {

                                log.error(tree.pos(), Errors.UnnamedPkgNotAllowedNamedModules);

                            }

                            msym = syms.enterModule(name);

                        }

                        if (msym.sourceLocation == null) {

                            msym.sourceLocation = msplocn;

                            if (fileManager.hasLocation(StandardLocation.PATCH_MODULE_PATH)) {

                                msym.patchLocation = fileManager.getLocationForModule(

                                        StandardLocation.PATCH_MODULE_PATH, msym.name.toString());

                            }

                            if (fileManager.hasLocation(StandardLocation.CLASS_OUTPUT)) {

                                Location outputLocn = fileManager.getLocationForModule(

                                        StandardLocation.CLASS_OUTPUT, msym.name.toString());

                                if (msym.patchLocation == null) {

                                    msym.classLocation = outputLocn;

                                } else {

                                    msym.patchOutputLocation = outputLocn;

                                }

                            }

                        }

                        tree.modle = msym;

                        rootModules.add(msym);

                    } else if (c != null && c.packge().modle == syms.unnamedModule) {

                        tree.modle = syms.unnamedModule;

                    } else {

                        if (tree.getModuleDecl() != null) {

                            log.error(tree.pos(), Errors.ModuleNotFoundOnModuleSourcePath);

                        } else {

                            log.error(tree.pos(), Errors.NotInModuleOnModuleSourcePath);

                        }

                        tree.modle = syms.errModule;

                        tree.modle.completer = sym -> completeModule((ModuleSymbol)sym);

                    }

                } catch (IOException e) {

                    throw new Error(e); // FIXME

                } finally {

                    log.useSource(prev);

                }

            }

            if (syms.unnamedModule.sourceLocation == null) {

                syms.unnamedModule.completer = getUnnamedModuleCompleter();

                syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;

                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

            }

            defaultModule = syms.unnamedModule;

        } else {

            ModuleSymbol module = null;

            if (defaultModule == null) {

                String moduleOverride = singleModuleOverride(trees);

                switch (rootModules.size()) {

                    case 0:

                        defaultModule = moduleFinder.findSingleModule();

                        if (defaultModule == syms.unnamedModule) {

                            if (moduleOverride != null) {

                                checkNoAllModulePath();

                                defaultModule = moduleFinder.findModule(names.fromString(moduleOverride));

                                if (legacyModuleOverride != null) {

                                    defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

                                }

                                defaultModule.patchOutputLocation = StandardLocation.CLASS_OUTPUT;

                            } else {

                                // Question: why not do findAllModules and initVisiblePackages here?

                                // i.e. body of unnamedModuleCompleter

                                defaultModule.completer = getUnnamedModuleCompleter();

                                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

                                defaultModule.classLocation = StandardLocation.CLASS_PATH;

                            }

                        } else {

                            checkNoAllModulePath();

                            defaultModule.complete();

                            // Question: why not do completeModule here?

                            defaultModule.completer = sym -> completeModule((ModuleSymbol) sym);

                            defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

                        }

                        rootModules.add(defaultModule);

                        break;

                    case 1:

                        checkNoAllModulePath();

                        defaultModule = rootModules.iterator().next();

                        defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

                        if (fileManager.hasLocation(StandardLocation.PATCH_MODULE_PATH)) {

                            try {

                                defaultModule.patchLocation = fileManager.getLocationForModule(

                                        StandardLocation.PATCH_MODULE_PATH, defaultModule.name.toString());

                            } catch (IOException ex) {

                                throw new Error(ex);

                            }

                        }

                        if (defaultModule.patchLocation == null) {

                            Location loc = StandardLocation.CLASS_OUTPUT;

                            if (!backgroundCompilation && !fm.hasLocation(StandardLocation.CLASS_OUTPUT)) {

                                for (Location baseLoc : new Location[] {

                                        StandardLocation.UPGRADE_MODULE_PATH,

                                        StandardLocation.SYSTEM_MODULES,

                                        StandardLocation.MODULE_PATH}) {

                                    try {

                                        final Location tmp = fm.getLocationForModule(

                                                baseLoc,

                                                defaultModule.name.toString());

                                        if(tmp != null) {

                                            loc = tmp;

                                            break;

                                        }

                                    } catch (IOException ioe) {

                                        //pass

                                    }

                                }

                            }

                            defaultModule.classLocation = loc;

                        } else {

                            defaultModule.patchOutputLocation = StandardLocation.CLASS_OUTPUT;

                        }

                        break;

                    default:

                        Assert.error("too many modules");

                }

            } else if (rootModules.size() == 1) {

                module = rootModules.iterator().next();

                module.complete();

                module.completer = sym -> completeModule((ModuleSymbol) sym);

            } else {

                Assert.check(rootModules.isEmpty());

                String moduleOverride = singleModuleOverride(trees);

                if (moduleOverride != null) {

                    module = moduleFinder.findModule(names.fromString(moduleOverride));

                } else {

                    module = defaultModule;

                }

                rootModules.add(module);

            }

            if (defaultModule != syms.unnamedModule) {

                syms.unnamedModule.completer = getUnnamedModuleCompleter();

                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

            }

            if (module == null) {

                module = defaultModule;

            }

            for (JCCompilationUnit tree: trees) {

                if (defaultModule != syms.unnamedModule

                        && defaultModule.sourceLocation == StandardLocation.SOURCE_PATH

                        && fileManager.hasLocation(StandardLocation.SOURCE_PATH)) {

                    checkSourceLocation(tree, module);

                }

                if (tree.modle == null) {

                    tree.modle = module;

                }

            }

        }

    }

    private void checkSourceLocation(JCCompilationUnit tree, ModuleSymbol msym) {

        // skip check if legacy module override still in use

        if (ideMode || legacyModuleOverride != null) {

            return;

        }

        try {

            JavaFileObject fo = tree.sourcefile;

            if (fileManager.contains(msym.sourceLocation, fo)) {

                return;

            }

            if (msym.patchLocation != null && fileManager.contains(msym.patchLocation, fo)) {

                return;

            }

            if (fileManager.hasLocation(StandardLocation.SOURCE_OUTPUT)) {

                if (fileManager.contains(StandardLocation.SOURCE_OUTPUT, fo)) {

                    return;

                }

            } else {

                if (fileManager.contains(StandardLocation.CLASS_OUTPUT, fo)) {

                    return;

                }

            }

        } catch (IOException e) {

            throw new Error(e);

        }

        JavaFileObject prev = log.useSource(tree.sourcefile);

        try {

            log.error(tree.pos(), "file.sb.on.source.or.patch.path.for.module");

        } finally {

            log.useSource(prev);

        }

    }

    private String singleModuleOverride(List<JCCompilationUnit> trees) {

        if (!fileManager.hasLocation(StandardLocation.PATCH_MODULE_PATH)) {

            return legacyModuleOverride;

        }

        Set<String> override = new LinkedHashSet<>();

        for (JCCompilationUnit tree : trees) {

            JavaFileObject fo = tree.sourcefile;

            try {

                Location loc =

                        fileManager.getLocationForModule(StandardLocation.PATCH_MODULE_PATH, fo);

                if (loc != null) {

                    override.add(fileManager.inferModuleName(loc));

                }

            } catch (IOException ex) {

                throw new Error(ex);

            }

        }

        switch (override.size()) {

            case 0: return legacyModuleOverride;

            case 1: return override.iterator().next();

            default:

                log.error(Errors.TooManyPatchedModules(override));

                return null;

        }

    }

    /**

     * Determine the location for the module on the module source path

     * or source output directory which contains a given CompilationUnit.

     * If the source output directory is unset, the class output directory

     * will be checked instead.

     * {@code null} is returned if no such module can be found.

     * @param tree the compilation unit tree

     * @return the location for the enclosing module

     * @throws IOException if there is a problem while searching for the module.

     */

    private Location getModuleLocation(JCCompilationUnit tree) throws IOException {

        JavaFileObject fo = tree.sourcefile;

        Location loc =

                fileManager.getLocationForModule(StandardLocation.MODULE_SOURCE_PATH, fo);

        if (loc == null) {

            Location sourceOutput = fileManager.hasLocation(StandardLocation.SOURCE_OUTPUT) ?

                    StandardLocation.SOURCE_OUTPUT : StandardLocation.CLASS_OUTPUT;

            loc =

                fileManager.getLocationForModule(sourceOutput, fo);

            if (loc != null) {

                loc = fileManager.getLocationForModule(StandardLocation.MODULE_SOURCE_PATH, fileManager.inferModuleName(loc));

            }

        }

        return loc;

    }

    private void checkNoAllModulePath() {

        if (addModsOpt != null && Arrays.asList(addModsOpt.split(",")).contains(ALL_MODULE_PATH)) {

            log.error(Errors.AddmodsAllModulePathInvalid);

        }

    }

    private final Completer mainCompleter = new Completer() {

        @Override

        public void complete(Symbol sym) throws CompletionFailure {

            ModuleSymbol msym = moduleFinder.findModule((ModuleSymbol) sym);

            if (msym.kind == ERR) {

                //make sure the module is initialized:

                msym.directives = List.nil();

                msym.exports = List.nil();

                msym.provides = List.nil();

                msym.requires = List.nil();

                msym.uses = List.nil();

            } else if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {

                setupAutomaticModule(msym);

            } else {

                msym.module_info.complete();

            }

            // If module-info comes from a .java file, the underlying

            // call of classFinder.fillIn will have called through the

            // source completer, to Enter, and then to Modules.enter,

            // which will call completeModule.

            // But, if module-info comes from a .class file, the underlying

            // call of classFinder.fillIn will just call ClassReader to read

            // the .class file, and so we call completeModule here.

            if (msym.module_info.classfile == null || msym.module_info.classfile.getKind() == Kind.CLASS) {

                completeModule(msym);

            }

        }

        @Override

        public String toString() {

            return "mainCompleter";

        }

    };

    private void setupAutomaticModule(ModuleSymbol msym) throws CompletionFailure {

        try {

            ListBuffer<Directive> directives = new ListBuffer<>();

            ListBuffer<ExportsDirective> exports = new ListBuffer<>();

            Set<String> seenPackages = new HashSet<>();

            for (JavaFileObject clazz : fileManager.list(msym.classLocation, "", EnumSet.of(Kind.CLASS), true)) {

                String binName = fileManager.inferBinaryName(msym.classLocation, clazz);

                String pack = binName.lastIndexOf('.') != (-1) ? binName.substring(0, binName.lastIndexOf('.')) : ""; //unnamed package????

                if (seenPackages.add(pack)) {

                    ExportsDirective d = new ExportsDirective(syms.enterPackage(msym, names.fromString(pack)), null);

                    //TODO: opens?

                    directives.add(d);

                    exports.add(d);

                }

            }

            msym.exports = exports.toList();

            msym.provides = List.nil();

            msym.requires = List.nil();

            msym.uses = List.nil();

            msym.directives = directives.toList();

            msym.flags_field |= Flags.ACYCLIC;

        } catch (IOException ex) {

            throw new IllegalStateException(ex);

        }

    }

    private void completeAutomaticModule(ModuleSymbol msym) throws CompletionFailure {

        ListBuffer<Directive> directives = new ListBuffer<>();

        directives.addAll(msym.directives);

        ListBuffer<RequiresDirective> requires = new ListBuffer<>();

        for (ModuleSymbol ms : allModules()) {

            if (ms == syms.unnamedModule || ms == msym)

                continue;

            Set<RequiresFlag> flags = (ms.flags_field & Flags.AUTOMATIC_MODULE) != 0 ?

                    EnumSet.of(RequiresFlag.TRANSITIVE) : EnumSet.noneOf(RequiresFlag.class);

            RequiresDirective d = new RequiresDirective(ms, flags);

            directives.add(d);

            requires.add(d);

        }

        RequiresDirective requiresUnnamed = new RequiresDirective(syms.unnamedModule);

        directives.add(requiresUnnamed);

        requires.add(requiresUnnamed);

        msym.requires = requires.toList();

        msym.directives = directives.toList();

    }

    private Completer getSourceCompleter(JCCompilationUnit tree) {

        return new Completer() {

            @Override

            public void complete(Symbol sym) throws CompletionFailure {

                ModuleSymbol msym = (ModuleSymbol) sym;

                msym.flags_field |= UNATTRIBUTED;

                ModuleVisitor v = new ModuleVisitor();

                JavaFileObject prev = log.useSource(tree.sourcefile);

                JCModuleDecl moduleDecl = tree.getModuleDecl();

                DiagnosticPosition prevLintPos = deferredLintHandler.setPos(moduleDecl.pos());

                try {

                    moduleDecl.accept(v);

                    completeModule(msym);

                    checkCyclicDependencies(moduleDecl);

                } finally {

                    log.useSource(prev);

                    deferredLintHandler.setPos(prevLintPos);

                    msym.flags_field &= ~UNATTRIBUTED;

                }

            }

            @Override

            public String toString() {

                return "SourceCompleter: " + tree.sourcefile.getName();

            }

        };

    }

    public boolean isRootModule(ModuleSymbol module) {

        Assert.checkNonNull(rootModules);

        return rootModules.contains(module);

    }

    public Set<ModuleSymbol> getRootModules() {

        Assert.checkNonNull(rootModules);

        return rootModules;

    }

    class ModuleVisitor extends JCTree.Visitor {

        private ModuleSymbol sym;

        private final Set<ModuleSymbol> allRequires = new HashSet<>();

        private final Map<PackageSymbol,List<ExportsDirective>> allExports = new HashMap<>();

        private final Map<PackageSymbol,List<OpensDirective>> allOpens = new HashMap<>();

        @Override

        public void visitModuleDef(JCModuleDecl tree) {

            sym = Assert.checkNonNull(tree.sym);

            if (tree.getModuleType() == ModuleKind.OPEN) {

                sym.flags.add(ModuleFlags.OPEN);

            }

            sym.flags_field |= (tree.mods.flags & Flags.DEPRECATED);

            sym.requires = List.nil();

            sym.exports = List.nil();

            sym.opens = List.nil();

            tree.directives.forEach(t -> t.accept(this));

            sym.requires = sym.requires.reverse();

            sym.exports = sym.exports.reverse();

            sym.opens = sym.opens.reverse();

            ensureJavaBase();

        }

        @Override

        public void visitRequires(JCRequires tree) {

            ModuleSymbol msym = lookupModule(tree.moduleName);

            Set<RequiresFlag> flags = EnumSet.noneOf(RequiresFlag.class);

            if (tree.isTransitive)

                flags.add(RequiresFlag.TRANSITIVE);

            if (tree.isStaticPhase)

                flags.add(RequiresFlag.STATIC_PHASE);

            RequiresDirective d = new RequiresDirective(msym, flags);

            tree.directive = d;

            if (msym.kind != MDL) {

                log.error(tree.moduleName.pos(), Errors.ModuleNotFound(msym));

                warnedMissing.add(msym);

            } else if (allRequires.contains(msym)) {

                log.error(tree.moduleName.pos(), Errors.DuplicateRequires(msym));

            } else {

                allRequires.add(msym);

                sym.requires = sym.requires.prepend(d);

            }

        }

        @Override

        public void visitExports(JCExports tree) {

            Name name = TreeInfo.fullName(tree.qualid);

            PackageSymbol packge = syms.enterPackage(sym, name);

            attr.setPackageSymbols(tree.qualid, packge);

            List<ExportsDirective> exportsForPackage = allExports.computeIfAbsent(packge, p -> List.nil());

            for (ExportsDirective d : exportsForPackage) {

                reportExportsConflict(tree, packge);

            }

            List<ModuleSymbol> toModules = null;

            if (tree.moduleNames != null) {

                Set<ModuleSymbol> to = new LinkedHashSet<>();

                for (JCExpression n: tree.moduleNames) {

                    ModuleSymbol msym = lookupModule(n);

                    chk.checkModuleExists(n.pos(), msym);

                    for (ExportsDirective d : exportsForPackage) {

                        checkDuplicateExportsToModule(n, msym, d);

                    }

                    if (!to.add(msym)) {

                        reportExportsConflictToModule(n, msym);

                    }

                }

                toModules = List.from(to);

            }

            if (toModules == null || !toModules.isEmpty()) {

                Set<ExportsFlag> flags = EnumSet.noneOf(ExportsFlag.class);

                ExportsDirective d = new ExportsDirective(packge, toModules, flags);

                sym.exports = sym.exports.prepend(d);

                tree.directive = d;

                allExports.put(packge, exportsForPackage.prepend(d));

            }

        }

        private void reportExportsConflict(JCExports tree, PackageSymbol packge) {

            log.error(tree.qualid.pos(), Errors.ConflictingExports(packge));

        }

        private void checkDuplicateExportsToModule(JCExpression name, ModuleSymbol msym,

                ExportsDirective d) {

            if (d.modules != null) {

                for (ModuleSymbol other : d.modules) {

                    if (msym == other) {

                        reportExportsConflictToModule(name, msym);

                    }

                }

            }

        }

        private void reportExportsConflictToModule(JCExpression name, ModuleSymbol msym) {

            log.error(name.pos(), Errors.ConflictingExportsToModule(msym));

        }

        @Override

        public void visitOpens(JCOpens tree) {

            Name name = TreeInfo.fullName(tree.qualid);

            PackageSymbol packge = syms.enterPackage(sym, name);

            attr.setPackageSymbols(tree.qualid, packge);

            if (sym.flags.contains(ModuleFlags.OPEN)) {

                log.error(tree.pos(), Errors.NoOpensUnlessStrong);

            }

            List<OpensDirective> opensForPackage = allOpens.computeIfAbsent(packge, p -> List.nil());

            for (OpensDirective d : opensForPackage) {

                reportOpensConflict(tree, packge);

            }

            List<ModuleSymbol> toModules = null;

            if (tree.moduleNames != null) {

                Set<ModuleSymbol> to = new LinkedHashSet<>();

                for (JCExpression n: tree.moduleNames) {

                    ModuleSymbol msym = lookupModule(n);

                    chk.checkModuleExists(n.pos(), msym);

                    for (OpensDirective d : opensForPackage) {

                        checkDuplicateOpensToModule(n, msym, d);

                    }

                    if (!to.add(msym)) {

                        reportOpensConflictToModule(n, msym);

                    }

                }

                toModules = List.from(to);

            }

            if (toModules == null || !toModules.isEmpty()) {

                Set<OpensFlag> flags = EnumSet.noneOf(OpensFlag.class);

                OpensDirective d = new OpensDirective(packge, toModules, flags);

                sym.opens = sym.opens.prepend(d);

                tree.directive = d;

                allOpens.put(packge, opensForPackage.prepend(d));

            }

        }

        private void reportOpensConflict(JCOpens tree, PackageSymbol packge) {

            log.error(tree.qualid.pos(), Errors.ConflictingOpens(packge));

        }

        private void checkDuplicateOpensToModule(JCExpression name, ModuleSymbol msym,

                OpensDirective d) {

            if (d.modules != null) {

                for (ModuleSymbol other : d.modules) {

                    if (msym == other) {

                        reportOpensConflictToModule(name, msym);

                    }

                }

            }

        }

        private void reportOpensConflictToModule(JCExpression name, ModuleSymbol msym) {

            log.error(name.pos(), Errors.ConflictingOpensToModule(msym));

        }

        @Override

        public void visitProvides(JCProvides tree) { }

        @Override

        public void visitUses(JCUses tree) { }

        private void ensureJavaBase() {

            if (sym.name == names.java_base)

                return;

            for (RequiresDirective d: sym.requires) {

                if (d.module.name == names.java_base)

                    return;

            }

            ModuleSymbol java_base = syms.enterModule(names.java_base);

            Directive.RequiresDirective d =

                    new Directive.RequiresDirective(java_base,

                            EnumSet.of(Directive.RequiresFlag.MANDATED));

            sym.requires = sym.requires.prepend(d);

        }

        private ModuleSymbol lookupModule(JCExpression moduleName) {

            Name name = TreeInfo.fullName(moduleName);

            ModuleSymbol msym = moduleFinder.findModule(name);

            TreeInfo.setSymbol(moduleName, msym);

            return msym;

        }

    }