Modules.java revision 3793:5a2b9f22ba5d 
1/*
2 * Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26
27package com.sun.tools.javac.comp;
28
29import java.io.IOException;
30import java.util.Arrays;
31import java.util.Collection;
32import java.util.Collections;
33import java.util.EnumSet;
34import java.util.HashMap;
35import java.util.HashSet;
36import java.util.LinkedHashMap;
37import java.util.LinkedHashSet;
38import java.util.Map;
39import java.util.Set;
40import java.util.function.Consumer;
41import java.util.function.Predicate;
42import java.util.regex.Matcher;
43import java.util.regex.Pattern;
44import java.util.stream.Stream;
45
46import javax.lang.model.SourceVersion;
47import javax.tools.JavaFileManager;
48import javax.tools.JavaFileManager.Location;
49import javax.tools.JavaFileObject;
50import javax.tools.JavaFileObject.Kind;
51import javax.tools.StandardLocation;
52
53import com.sun.source.tree.ModuleTree.ModuleKind;
54import com.sun.tools.javac.code.ClassFinder;
55import com.sun.tools.javac.code.DeferredLintHandler;
56import com.sun.tools.javac.code.Directive;
57import com.sun.tools.javac.code.Directive.ExportsDirective;
58import com.sun.tools.javac.code.Directive.ExportsFlag;
59import com.sun.tools.javac.code.Directive.OpensDirective;
60import com.sun.tools.javac.code.Directive.OpensFlag;
61import com.sun.tools.javac.code.Directive.RequiresDirective;
62import com.sun.tools.javac.code.Directive.RequiresFlag;
63import com.sun.tools.javac.code.Directive.UsesDirective;
64import com.sun.tools.javac.code.Flags;
65import com.sun.tools.javac.code.Kinds;
66import com.sun.tools.javac.code.Lint.LintCategory;
67import com.sun.tools.javac.code.ModuleFinder;
68import com.sun.tools.javac.code.Source;
69import com.sun.tools.javac.code.Symbol;
70import com.sun.tools.javac.code.Symbol.ClassSymbol;
71import com.sun.tools.javac.code.Symbol.Completer;
72import com.sun.tools.javac.code.Symbol.CompletionFailure;
73import com.sun.tools.javac.code.Symbol.MethodSymbol;
74import com.sun.tools.javac.code.Symbol.ModuleFlags;
75import com.sun.tools.javac.code.Symbol.ModuleSymbol;
76import com.sun.tools.javac.code.Symbol.PackageSymbol;
77import com.sun.tools.javac.code.Symtab;
78import com.sun.tools.javac.code.Type;
79import com.sun.tools.javac.code.Types;
80import com.sun.tools.javac.jvm.ClassWriter;
81import com.sun.tools.javac.jvm.JNIWriter;
82import com.sun.tools.javac.main.Option;
83import com.sun.tools.javac.resources.CompilerProperties.Errors;
84import com.sun.tools.javac.resources.CompilerProperties.Warnings;
85import com.sun.tools.javac.tree.JCTree;
86import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
87import com.sun.tools.javac.tree.JCTree.JCDirective;
88import com.sun.tools.javac.tree.JCTree.JCExports;
89import com.sun.tools.javac.tree.JCTree.JCExpression;
90import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
91import com.sun.tools.javac.tree.JCTree.JCOpens;
92import com.sun.tools.javac.tree.JCTree.JCPackageDecl;
93import com.sun.tools.javac.tree.JCTree.JCProvides;
94import com.sun.tools.javac.tree.JCTree.JCRequires;
95import com.sun.tools.javac.tree.JCTree.JCUses;
96import com.sun.tools.javac.tree.JCTree.Tag;
97import com.sun.tools.javac.tree.TreeInfo;
98import com.sun.tools.javac.util.Abort;
99import com.sun.tools.javac.util.Assert;
100import com.sun.tools.javac.util.Context;
101import com.sun.tools.javac.util.JCDiagnostic;
102import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
103import com.sun.tools.javac.util.List;
104import com.sun.tools.javac.util.ListBuffer;
105import com.sun.tools.javac.util.Log;
106import com.sun.tools.javac.util.Name;
107import com.sun.tools.javac.util.Names;
108import com.sun.tools.javac.util.Options;
109import com.sun.tools.javac.util.Position;
110
111import static com.sun.tools.javac.code.Flags.ABSTRACT;
112import static com.sun.tools.javac.code.Flags.ENUM;
113import static com.sun.tools.javac.code.Flags.PUBLIC;
114import static com.sun.tools.javac.code.Flags.UNATTRIBUTED;
115import static com.sun.tools.javac.code.Kinds.Kind.MDL;
116import static com.sun.tools.javac.code.Kinds.Kind.MTH;
117import static com.sun.tools.javac.code.TypeTag.CLASS;
118
119/**
120 *  TODO: fill in
121 *
122 *  <p><b>This is NOT part of any supported API.
123 *  If you write code that depends on this, you do so at your own risk.
124 *  This code and its internal interfaces are subject to change or
125 *  deletion without notice.</b>
126 */
127public class Modules extends JCTree.Visitor {
128    private static final String ALL_SYSTEM = "ALL-SYSTEM";
129    private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";
130
131    private final Log log;
132    private final Names names;
133    private final Symtab syms;
134    private final Attr attr;
135    private final Check chk;
136    private final DeferredLintHandler deferredLintHandler;
137    private final TypeEnvs typeEnvs;
138    private final Types types;
139    private final JavaFileManager fileManager;
140    private final ModuleFinder moduleFinder;
141    private final Source source;
142    private final boolean allowModules;
143
144    public final boolean multiModuleMode;
145
146    private final String moduleOverride;
147
148    private final Name java_se;
149    private final Name java_;
150
151    ModuleSymbol defaultModule;
152
153    private final String addExportsOpt;
154    private Map<ModuleSymbol, Set<ExportsDirective>> addExports;
155    private final String addReadsOpt;
156    private Map<ModuleSymbol, Set<RequiresDirective>> addReads;
157    private final String addModsOpt;
158    private final Set<String> extraAddMods = new HashSet<>();
159    private final String limitModsOpt;
160    private final Set<String> extraLimitMods = new HashSet<>();
161
162    private final boolean lintOptions;
163
164    private Set<ModuleSymbol> rootModules = null;
165
166    public static Modules instance(Context context) {
167        Modules instance = context.get(Modules.class);
168        if (instance == null)
169            instance = new Modules(context);
170        return instance;
171    }
172
173    protected Modules(Context context) {
174        context.put(Modules.class, this);
175        log = Log.instance(context);
176        names = Names.instance(context);
177        syms = Symtab.instance(context);
178        attr = Attr.instance(context);
179        chk = Check.instance(context);
180        deferredLintHandler = DeferredLintHandler.instance(context);
181        typeEnvs = TypeEnvs.instance(context);
182        moduleFinder = ModuleFinder.instance(context);
183        types = Types.instance(context);
184        fileManager = context.get(JavaFileManager.class);
185        source = Source.instance(context);
186        allowModules = source.allowModules();
187        Options options = Options.instance(context);
188
189        lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
190
191        moduleOverride = options.get(Option.XMODULE);
192
193        multiModuleMode = fileManager.hasLocation(StandardLocation.MODULE_SOURCE_PATH);
194        ClassWriter classWriter = ClassWriter.instance(context);
195        classWriter.multiModuleMode = multiModuleMode;
196        JNIWriter jniWriter = JNIWriter.instance(context);
197        jniWriter.multiModuleMode = multiModuleMode;
198
199        java_se = names.fromString("java.se");
200        java_ = names.fromString("java.");
201
202        addExportsOpt = options.get(Option.ADD_EXPORTS);
203        addReadsOpt = options.get(Option.ADD_READS);
204        addModsOpt = options.get(Option.ADD_MODULES);
205        limitModsOpt = options.get(Option.LIMIT_MODULES);
206    }
207
208    int depth = -1;
209    private void dprintln(String msg) {
210        for (int i = 0; i < depth; i++)
211            System.err.print("  ");
212        System.err.println(msg);
213    }
214
215    public void addExtraAddModules(String... extras) {
216        extraAddMods.addAll(Arrays.asList(extras));
217    }
218
219    public void addExtraLimitModules(String... extras) {
220        extraLimitMods.addAll(Arrays.asList(extras));
221    }
222
223    boolean inInitModules;
224    public void initModules(List<JCCompilationUnit> trees) {
225        Assert.check(!inInitModules);
226        try {
227            inInitModules = true;
228            Assert.checkNull(rootModules);
229            enter(trees, modules -> {
230                Assert.checkNull(rootModules);
231                Assert.checkNull(allModules);
232                this.rootModules = modules;
233                setupAllModules(); //initialize the module graph
234                Assert.checkNonNull(allModules);
235                inInitModules = false;
236            }, null);
237        } finally {
238            inInitModules = false;
239        }
240    }
241
242    public boolean enter(List<JCCompilationUnit> trees, ClassSymbol c) {
243        Assert.check(rootModules != null || inInitModules || !allowModules);
244        return enter(trees, modules -> {}, c);
245    }
246
247    private boolean enter(List<JCCompilationUnit> trees, Consumer<Set<ModuleSymbol>> init, ClassSymbol c) {
248        if (!allowModules) {
249            for (JCCompilationUnit tree: trees) {
250                tree.modle = syms.noModule;
251            }
252            defaultModule = syms.noModule;
253            return true;
254        }
255
256        int startErrors = log.nerrors;
257
258        depth++;
259        try {
260            // scan trees for module defs
261            Set<ModuleSymbol> roots = enterModules(trees, c);
262
263            setCompilationUnitModules(trees, roots);
264
265            init.accept(roots);
266
267            for (ModuleSymbol msym: roots) {
268                msym.complete();
269            }
270        } catch (CompletionFailure ex) {
271            log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, Position.NOPOS, "cant.access", ex.sym, ex.getDetailValue());
272            if (ex instanceof ClassFinder.BadClassFile) throw new Abort();
273        } finally {
274            depth--;
275        }
276
277        return (log.nerrors == startErrors);
278    }
279
280    public Completer getCompleter() {
281        return mainCompleter;
282    }
283
284    public ModuleSymbol getDefaultModule() {
285        return defaultModule;
286    }
287
288    public boolean modulesInitialized() {
289        return allModules != null;
290    }
291
292    private Set<ModuleSymbol> enterModules(List<JCCompilationUnit> trees, ClassSymbol c) {
293        Set<ModuleSymbol> modules = new LinkedHashSet<>();
294        for (JCCompilationUnit tree : trees) {
295            JavaFileObject prev = log.useSource(tree.sourcefile);
296            try {
297                enterModule(tree, c, modules);
298            } finally {
299                log.useSource(prev);
300            }
301        }
302        return modules;
303    }
304
305
306    private void enterModule(JCCompilationUnit toplevel, ClassSymbol c, Set<ModuleSymbol> modules) {
307        boolean isModuleInfo = toplevel.sourcefile.isNameCompatible("module-info", Kind.SOURCE);
308        boolean isModuleDecl = toplevel.getModuleDecl() != null;
309        if (isModuleDecl) {
310            JCModuleDecl decl = toplevel.getModuleDecl();
311            if (!isModuleInfo) {
312                log.error(decl.pos(), Errors.ModuleDeclSbInModuleInfoJava);
313            }
314            Name name = TreeInfo.fullName(decl.qualId);
315            ModuleSymbol sym;
316            if (c != null) {
317                sym = (ModuleSymbol) c.owner;
318                Assert.checkNonNull(sym.name);
319                Name treeName = TreeInfo.fullName(decl.qualId);
320                if (sym.name != treeName) {
321                    log.error(decl.pos(), Errors.ModuleNameMismatch(name, sym.name));
322                }
323            } else {
324                sym = syms.enterModule(name);
325                if (sym.module_info.sourcefile != null && sym.module_info.sourcefile != toplevel.sourcefile) {
326                    log.error(decl.pos(), Errors.DuplicateModule(sym));
327                    return;
328                }
329            }
330            sym.completer = getSourceCompleter(toplevel);
331            sym.module_info.sourcefile = toplevel.sourcefile;
332            decl.sym = sym;
333
334            if (multiModuleMode || modules.isEmpty()) {
335                modules.add(sym);
336            } else {
337                log.error(toplevel.pos(), Errors.TooManyModules);
338            }
339
340            Env<AttrContext> provisionalEnv = new Env<>(decl, null);
341
342            provisionalEnv.toplevel = toplevel;
343            typeEnvs.put(sym, provisionalEnv);
344        } else if (isModuleInfo) {
345            if (multiModuleMode) {
346                JCTree tree = toplevel.defs.isEmpty() ? toplevel : toplevel.defs.head;
347                log.error(tree.pos(), Errors.ExpectedModule);
348            }
349        }
350    }
351
352    private void setCompilationUnitModules(List<JCCompilationUnit> trees, Set<ModuleSymbol> rootModules) {
353        // update the module for each compilation unit
354        if (multiModuleMode) {
355            checkNoAllModulePath();
356            for (JCCompilationUnit tree: trees) {
357                if (tree.defs.isEmpty()) {
358                    tree.modle = syms.unnamedModule;
359                    continue;
360                }
361
362                JavaFileObject prev = log.useSource(tree.sourcefile);
363                try {
364                    Location locn = getModuleLocation(tree);
365                    if (locn != null) {
366                        Name name = names.fromString(fileManager.inferModuleName(locn));
367                        ModuleSymbol msym;
368                        JCModuleDecl decl = tree.getModuleDecl();
369                        if (decl != null) {
370                            msym = decl.sym;
371                            if (msym.name != name) {
372                                log.error(decl.qualId, Errors.ModuleNameMismatch(msym.name, name));
373                            }
374                        } else {
375                            msym = syms.enterModule(name);
376                        }
377                        if (msym.sourceLocation == null) {
378                            msym.sourceLocation = locn;
379                            if (fileManager.hasLocation(StandardLocation.CLASS_OUTPUT)) {
380                                msym.classLocation = fileManager.getLocationForModule(
381                                        StandardLocation.CLASS_OUTPUT, msym.name.toString());
382                            }
383                        }
384                        tree.modle = msym;
385                        rootModules.add(msym);
386                    } else {
387                        log.error(tree.pos(), Errors.UnnamedPkgNotAllowedNamedModules);
388                        tree.modle = syms.errModule;
389                    }
390                } catch (IOException e) {
391                    throw new Error(e); // FIXME
392                } finally {
393                    log.useSource(prev);
394                }
395            }
396            if (syms.unnamedModule.sourceLocation == null) {
397                syms.unnamedModule.completer = getUnnamedModuleCompleter();
398                syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;
399                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;
400            }
401            defaultModule = syms.unnamedModule;
402        } else {
403            if (defaultModule == null) {
404                switch (rootModules.size()) {
405                    case 0:
406                        defaultModule = moduleFinder.findSingleModule();
407                        if (defaultModule == syms.unnamedModule) {
408                            if (moduleOverride != null) {
409                                checkNoAllModulePath();
410                                defaultModule = moduleFinder.findModule(names.fromString(moduleOverride));
411                                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;
412                            } else {
413                                // Question: why not do findAllModules and initVisiblePackages here?
414                                // i.e. body of unnamedModuleCompleter
415                                defaultModule.completer = getUnnamedModuleCompleter();
416                                defaultModule.classLocation = StandardLocation.CLASS_PATH;
417                            }
418                        } else {
419                            checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleClasspath);
420                            checkNoAllModulePath();
421                            defaultModule.complete();
422                            // Question: why not do completeModule here?
423                            defaultModule.completer = new Completer() {
424                                @Override
425                                public void complete(Symbol sym) throws CompletionFailure {
426                                    completeModule((ModuleSymbol) sym);
427                                }
428                            };
429                        }
430                        rootModules.add(defaultModule);
431                        break;
432                    case 1:
433                        checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleSourcepath);
434                        checkNoAllModulePath();
435                        defaultModule = rootModules.iterator().next();
436                        defaultModule.classLocation = StandardLocation.CLASS_OUTPUT;
437                        break;
438                    default:
439                        Assert.error("too many modules");
440                }
441                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;
442            } else if (rootModules.size() == 1 && defaultModule == rootModules.iterator().next()) {
443                defaultModule.complete();
444                defaultModule.completer = sym -> completeModule((ModuleSymbol) sym);
445            } else {
446                Assert.check(rootModules.isEmpty());
447                rootModules.add(defaultModule);
448            }
449
450            if (defaultModule != syms.unnamedModule) {
451                syms.unnamedModule.completer = getUnnamedModuleCompleter();
452                if (moduleOverride == null) {
453                    syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;
454                }
455                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;
456            }
457
458            for (JCCompilationUnit tree: trees) {
459                tree.modle = defaultModule;
460            }
461        }
462    }
463
464    private Location getModuleLocation(JCCompilationUnit tree) throws IOException {
465        if (tree.getModuleDecl() != null) {
466            return getModuleLocation(tree.sourcefile, null);
467        } else if (tree.getPackage() != null) {
468            JCPackageDecl pkg = tree.getPackage();
469            return getModuleLocation(tree.sourcefile, TreeInfo.fullName(pkg.pid));
470        } else {
471            // code in unnamed module
472            return null;
473        }
474    }
475
476    private Location getModuleLocation(JavaFileObject fo, Name pkgName) throws IOException {
477        // For now, just check module source path.
478        // We may want to check source path as well.
479        return fileManager.getLocationForModule(StandardLocation.MODULE_SOURCE_PATH,
480                fo, (pkgName == null) ? null : pkgName.toString());
481    }
482
483    private void checkSpecifiedModule(List<JCCompilationUnit> trees, JCDiagnostic.Error error) {
484        if (moduleOverride != null) {
485            JavaFileObject prev = log.useSource(trees.head.sourcefile);
486            try {
487                log.error(trees.head.pos(), error);
488            } finally {
489                log.useSource(prev);
490            }
491        }
492    }
493
494    private void checkNoAllModulePath() {
495        if (addModsOpt != null && Arrays.asList(addModsOpt.split(",")).contains(ALL_MODULE_PATH)) {
496            log.error(Errors.AddmodsAllModulePathInvalid);
497        }
498    }
499
500    private final Completer mainCompleter = new Completer() {
501        @Override
502        public void complete(Symbol sym) throws CompletionFailure {
503            ModuleSymbol msym = moduleFinder.findModule((ModuleSymbol) sym);
504
505            if (msym.kind == Kinds.Kind.ERR) {
506                log.error(Errors.ModuleNotFound(msym));
507                //make sure the module is initialized:
508                msym.directives = List.nil();
509                msym.exports = List.nil();
510                msym.provides = List.nil();
511                msym.requires = List.nil();
512                msym.uses = List.nil();
513            } else if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
514                setupAutomaticModule(msym);
515            } else {
516                msym.module_info.complete();
517            }
518
519            // If module-info comes from a .java file, the underlying
520            // call of classFinder.fillIn will have called through the
521            // source completer, to Enter, and then to Modules.enter,
522            // which will call completeModule.
523            // But, if module-info comes from a .class file, the underlying
524            // call of classFinder.fillIn will just call ClassReader to read
525            // the .class file, and so we call completeModule here.
526            if (msym.module_info.classfile == null || msym.module_info.classfile.getKind() == Kind.CLASS) {
527                completeModule(msym);
528            }
529        }
530
531        @Override
532        public String toString() {
533            return "mainCompleter";
534        }
535    };
536
537    private void setupAutomaticModule(ModuleSymbol msym) throws CompletionFailure {
538        try {
539            ListBuffer<Directive> directives = new ListBuffer<>();
540            ListBuffer<ExportsDirective> exports = new ListBuffer<>();
541            Set<String> seenPackages = new HashSet<>();
542
543            for (JavaFileObject clazz : fileManager.list(msym.classLocation, "", EnumSet.of(Kind.CLASS), true)) {
544                String binName = fileManager.inferBinaryName(msym.classLocation, clazz);
545                String pack = binName.lastIndexOf('.') != (-1) ? binName.substring(0, binName.lastIndexOf('.')) : ""; //unnamed package????
546                if (seenPackages.add(pack)) {
547                    ExportsDirective d = new ExportsDirective(syms.enterPackage(msym, names.fromString(pack)), null);
548                    //TODO: opens?
549                    directives.add(d);
550                    exports.add(d);
551                }
552            }
553
554            msym.exports = exports.toList();
555            msym.provides = List.nil();
556            msym.requires = List.nil();
557            msym.uses = List.nil();
558            msym.directives = directives.toList();
559            msym.flags_field |= Flags.ACYCLIC;
560        } catch (IOException ex) {
561            throw new IllegalStateException(ex);
562        }
563    }
564
565    private void completeAutomaticModule(ModuleSymbol msym) throws CompletionFailure {
566        ListBuffer<Directive> directives = new ListBuffer<>();
567
568        directives.addAll(msym.directives);
569
570        ListBuffer<RequiresDirective> requires = new ListBuffer<>();
571
572        for (ModuleSymbol ms : allModules()) {
573            if (ms == syms.unnamedModule || ms == msym)
574                continue;
575            Set<RequiresFlag> flags = (ms.flags_field & Flags.AUTOMATIC_MODULE) != 0 ?
576                    EnumSet.of(RequiresFlag.TRANSITIVE) : EnumSet.noneOf(RequiresFlag.class);
577            RequiresDirective d = new RequiresDirective(ms, flags);
578            directives.add(d);
579            requires.add(d);
580        }
581
582        RequiresDirective requiresUnnamed = new RequiresDirective(syms.unnamedModule);
583        directives.add(requiresUnnamed);
584        requires.add(requiresUnnamed);
585
586        msym.requires = requires.toList();
587        msym.directives = directives.toList();
588    }
589
590    private Completer getSourceCompleter(JCCompilationUnit tree) {
591        return new Completer() {
592            @Override
593            public void complete(Symbol sym) throws CompletionFailure {
594                ModuleSymbol msym = (ModuleSymbol) sym;
595                msym.flags_field |= UNATTRIBUTED;
596                ModuleVisitor v = new ModuleVisitor();
597                JavaFileObject prev = log.useSource(tree.sourcefile);
598                try {
599                    JCModuleDecl moduleDecl = tree.getModuleDecl();
600                    moduleDecl.accept(v);
601                    completeModule(msym);
602                    checkCyclicDependencies(moduleDecl);
603                } finally {
604                    log.useSource(prev);
605                    msym.flags_field &= ~UNATTRIBUTED;
606                }
607            }
608
609            @Override
610            public String toString() {
611                return "SourceCompleter: " + tree.sourcefile.getName();
612            }
613
614        };
615    }
616
617    class ModuleVisitor extends JCTree.Visitor {
618        private ModuleSymbol sym;
619        private final Set<ModuleSymbol> allRequires = new HashSet<>();
620        private final Map<PackageSymbol,List<ExportsDirective>> allExports = new HashMap<>();
621        private final Map<PackageSymbol,List<OpensDirective>> allOpens = new HashMap<>();
622
623        @Override
624        public void visitModuleDef(JCModuleDecl tree) {
625            sym = Assert.checkNonNull(tree.sym);
626
627            if (tree.getModuleType() == ModuleKind.OPEN) {
628                sym.flags.add(ModuleFlags.OPEN);
629            }
630            sym.flags_field |= (tree.mods.flags & Flags.DEPRECATED);
631
632            sym.requires = List.nil();
633            sym.exports = List.nil();
634            sym.opens = List.nil();
635            tree.directives.forEach(t -> t.accept(this));
636            sym.requires = sym.requires.reverse();
637            sym.exports = sym.exports.reverse();
638            sym.opens = sym.opens.reverse();
639            ensureJavaBase();
640        }
641
642        @Override
643        public void visitRequires(JCRequires tree) {
644            ModuleSymbol msym = lookupModule(tree.moduleName);
645            if (msym.kind != MDL) {
646                log.error(tree.moduleName.pos(), Errors.ModuleNotFound(msym));
647            } else if (allRequires.contains(msym)) {
648                log.error(tree.moduleName.pos(), Errors.DuplicateRequires(msym));
649            } else {
650                allRequires.add(msym);
651                Set<RequiresFlag> flags = EnumSet.noneOf(RequiresFlag.class);
652                if (tree.isTransitive)
653                    flags.add(RequiresFlag.TRANSITIVE);
654                if (tree.isStaticPhase)
655                    flags.add(RequiresFlag.STATIC_PHASE);
656                RequiresDirective d = new RequiresDirective(msym, flags);
657                tree.directive = d;
658                sym.requires = sym.requires.prepend(d);
659            }
660        }
661
662        @Override
663        public void visitExports(JCExports tree) {
664            Name name = TreeInfo.fullName(tree.qualid);
665            PackageSymbol packge = syms.enterPackage(sym, name);
666            attr.setPackageSymbols(tree.qualid, packge);
667
668            if (tree.hasTag(Tag.OPENS) && sym.flags.contains(ModuleFlags.OPEN)) {
669                log.error(tree.pos(), Errors.NoOpensUnlessStrong);
670            }
671            List<ExportsDirective> exportsForPackage = allExports.computeIfAbsent(packge, p -> List.nil());
672            for (ExportsDirective d : exportsForPackage) {
673                reportExportsConflict(tree, packge);
674            }
675
676            List<ModuleSymbol> toModules = null;
677            if (tree.moduleNames != null) {
678                Set<ModuleSymbol> to = new LinkedHashSet<>();
679                for (JCExpression n: tree.moduleNames) {
680                    ModuleSymbol msym = lookupModule(n);
681                    if (msym.kind != MDL) {
682                        log.error(n.pos(), Errors.ModuleNotFound(msym));
683                    } else {
684                        for (ExportsDirective d : exportsForPackage) {
685                            checkDuplicateExportsToModule(n, msym, d);
686                        }
687                        if (!to.add(msym)) {
688                            reportExportsConflictToModule(n, msym);
689                        }
690                    }
691                }
692                toModules = List.from(to);
693            }
694
695            if (toModules == null || !toModules.isEmpty()) {
696                Set<ExportsFlag> flags = EnumSet.noneOf(ExportsFlag.class);
697                ExportsDirective d = new ExportsDirective(packge, toModules, flags);
698                sym.exports = sym.exports.prepend(d);
699                tree.directive = d;
700
701                allExports.put(packge, exportsForPackage.prepend(d));
702            }
703        }
704
705        private void reportExportsConflict(JCExports tree, PackageSymbol packge) {
706            log.error(tree.qualid.pos(), Errors.ConflictingExports(packge));
707        }
708
709        private void checkDuplicateExportsToModule(JCExpression name, ModuleSymbol msym,
710                ExportsDirective d) {
711            if (d.modules != null) {
712                for (ModuleSymbol other : d.modules) {
713                    if (msym == other) {
714                        reportExportsConflictToModule(name, msym);
715                    }
716                }
717            }
718        }
719
720        private void reportExportsConflictToModule(JCExpression name, ModuleSymbol msym) {
721            log.error(name.pos(), Errors.ConflictingExportsToModule(msym));
722        }
723
724        @Override
725        public void visitOpens(JCOpens tree) {
726            Name name = TreeInfo.fullName(tree.qualid);
727            PackageSymbol packge = syms.enterPackage(sym, name);
728            attr.setPackageSymbols(tree.qualid, packge);
729
730            if (sym.flags.contains(ModuleFlags.OPEN)) {
731                log.error(tree.pos(), Errors.NoOpensUnlessStrong);
732            }
733            List<OpensDirective> opensForPackage = allOpens.computeIfAbsent(packge, p -> List.nil());
734            for (OpensDirective d : opensForPackage) {
735                reportOpensConflict(tree, packge);
736            }
737
738            List<ModuleSymbol> toModules = null;
739            if (tree.moduleNames != null) {
740                Set<ModuleSymbol> to = new LinkedHashSet<>();
741                for (JCExpression n: tree.moduleNames) {
742                    ModuleSymbol msym = lookupModule(n);
743                    if (msym.kind != MDL) {
744                        log.error(n.pos(), Errors.ModuleNotFound(msym));
745                    } else {
746                        for (OpensDirective d : opensForPackage) {
747                            checkDuplicateOpensToModule(n, msym, d);
748                        }
749                        if (!to.add(msym)) {
750                            reportOpensConflictToModule(n, msym);
751                        }
752                    }
753                }
754                toModules = List.from(to);
755            }
756
757            if (toModules == null || !toModules.isEmpty()) {
758                Set<OpensFlag> flags = EnumSet.noneOf(OpensFlag.class);
759                OpensDirective d = new OpensDirective(packge, toModules, flags);
760                sym.opens = sym.opens.prepend(d);
761                tree.directive = d;
762
763                allOpens.put(packge, opensForPackage.prepend(d));
764            }
765        }
766
767        private void reportOpensConflict(JCOpens tree, PackageSymbol packge) {
768            log.error(tree.qualid.pos(), Errors.ConflictingOpens(packge));
769        }
770
771        private void checkDuplicateOpensToModule(JCExpression name, ModuleSymbol msym,
772                OpensDirective d) {
773            if (d.modules != null) {
774                for (ModuleSymbol other : d.modules) {
775                    if (msym == other) {
776                        reportOpensConflictToModule(name, msym);
777                    }
778                }
779            }
780        }
781
782        private void reportOpensConflictToModule(JCExpression name, ModuleSymbol msym) {
783            log.error(name.pos(), Errors.ConflictingOpensToModule(msym));
784        }
785
786        @Override
787        public void visitProvides(JCProvides tree) { }
788
789        @Override
790        public void visitUses(JCUses tree) { }
791
792        private void ensureJavaBase() {
793            if (sym.name == names.java_base)
794                return;
795
796            for (RequiresDirective d: sym.requires) {
797                if (d.module.name == names.java_base)
798                    return;
799            }
800
801            ModuleSymbol java_base = syms.enterModule(names.java_base);
802            Directive.RequiresDirective d =
803                    new Directive.RequiresDirective(java_base,
804                            EnumSet.of(Directive.RequiresFlag.MANDATED));
805            sym.requires = sym.requires.prepend(d);
806        }
807
808        private ModuleSymbol lookupModule(JCExpression moduleName) {
809            Name name = TreeInfo.fullName(moduleName);
810            ModuleSymbol msym = moduleFinder.findModule(name);
811            TreeInfo.setSymbol(moduleName, msym);
812            return msym;
813        }
814    }
815
816    public Completer getUsesProvidesCompleter() {
817        return sym -> {
818            ModuleSymbol msym = (ModuleSymbol) sym;
819
820            msym.complete();
821
822            Env<AttrContext> env = typeEnvs.get(msym);
823            UsesProvidesVisitor v = new UsesProvidesVisitor(msym, env);
824            JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
825            JCModuleDecl decl = env.toplevel.getModuleDecl();
826            DiagnosticPosition prevLintPos = deferredLintHandler.setPos(decl.pos());
827
828            try {
829                decl.accept(v);
830            } finally {
831                log.useSource(prev);
832                deferredLintHandler.setPos(prevLintPos);
833            }
834        };
835    }
836
837    class UsesProvidesVisitor extends JCTree.Visitor {
838        private final ModuleSymbol msym;
839        private final Env<AttrContext> env;
840
841        private final Set<ClassSymbol> allUses = new HashSet<>();
842        private final Map<ClassSymbol, Set<ClassSymbol>> allProvides = new HashMap<>();
843
844        public UsesProvidesVisitor(ModuleSymbol msym, Env<AttrContext> env) {
845            this.msym = msym;
846            this.env = env;
847        }
848
849        @Override @SuppressWarnings("unchecked")
850        public void visitModuleDef(JCModuleDecl tree) {
851            msym.directives = List.nil();
852            msym.provides = List.nil();
853            msym.uses = List.nil();
854            tree.directives.forEach(t -> t.accept(this));
855            msym.directives = msym.directives.reverse();
856            msym.provides = msym.provides.reverse();
857            msym.uses = msym.uses.reverse();
858
859            if (msym.requires.nonEmpty() && msym.requires.head.flags.contains(RequiresFlag.MANDATED))
860                msym.directives = msym.directives.prepend(msym.requires.head);
861
862            msym.directives = msym.directives.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));
863
864            checkForCorrectness();
865        }
866
867        @Override
868        public void visitExports(JCExports tree) {
869            if (tree.directive.packge.members().isEmpty()) {
870                log.error(tree.qualid.pos(), Errors.PackageEmptyOrNotFound(tree.directive.packge));
871            }
872            msym.directives = msym.directives.prepend(tree.directive);
873        }
874
875        @Override
876        public void visitOpens(JCOpens tree) {
877            if (tree.directive.packge.members().isEmpty() &&
878                ((tree.directive.packge.flags() & Flags.HAS_RESOURCE) == 0)) {
879                log.error(tree.qualid.pos(), Errors.PackageEmptyOrNotFound(tree.directive.packge));
880            }
881            msym.directives = msym.directives.prepend(tree.directive);
882        }
883
884        MethodSymbol noArgsConstructor(ClassSymbol tsym) {
885            for (Symbol sym : tsym.members().getSymbolsByName(names.init)) {
886                MethodSymbol mSym = (MethodSymbol)sym;
887                if (mSym.params().isEmpty()) {
888                    return mSym;
889                }
890            }
891            return null;
892        }
893
894        MethodSymbol factoryMethod(ClassSymbol tsym) {
895            for (Symbol sym : tsym.members().getSymbolsByName(names.provider, sym -> sym.kind == MTH)) {
896                MethodSymbol mSym = (MethodSymbol)sym;
897                if (mSym.isStatic() && (mSym.flags() & Flags.PUBLIC) != 0 && mSym.params().isEmpty()) {
898                    return mSym;
899                }
900            }
901            return null;
902        }
903
904        Map<Directive.ProvidesDirective, JCProvides> directiveToTreeMap = new HashMap<>();
905
906        @Override
907        public void visitProvides(JCProvides tree) {
908            Type st = attr.attribType(tree.serviceName, env, syms.objectType);
909            ClassSymbol service = (ClassSymbol) st.tsym;
910            ListBuffer<ClassSymbol> impls = new ListBuffer<>();
911            for (JCExpression implName : tree.implNames) {
912                Type it = attr.attribType(implName, env, syms.objectType);
913                ClassSymbol impl = (ClassSymbol) it.tsym;
914                //find provider factory:
915                MethodSymbol factory = factoryMethod(impl);
916                if (factory != null) {
917                    Type returnType = factory.type.getReturnType();
918                    if (!types.isSubtype(returnType, st)) {
919                        log.error(implName.pos(), Errors.ServiceImplementationProviderReturnMustBeSubtypeOfServiceInterface);
920                    }
921                } else {
922                    if (!types.isSubtype(it, st)) {
923                        log.error(implName.pos(), Errors.ServiceImplementationMustBeSubtypeOfServiceInterface);
924                    } else if ((impl.flags() & ABSTRACT) != 0) {
925                        log.error(implName.pos(), Errors.ServiceImplementationIsAbstract(impl));
926                    } else if (impl.isInner()) {
927                        log.error(implName.pos(), Errors.ServiceImplementationIsInner(impl));
928                    } else {
929                        MethodSymbol constr = noArgsConstructor(impl);
930                        if (constr == null) {
931                            log.error(implName.pos(), Errors.ServiceImplementationDoesntHaveANoArgsConstructor(impl));
932                        } else if ((constr.flags() & PUBLIC) == 0) {
933                            log.error(implName.pos(), Errors.ServiceImplementationNoArgsConstructorNotPublic(impl));
934                        }
935                    }
936                }
937                if (it.hasTag(CLASS)) {
938                    // For now, we just check the pair (service-type, impl-type) is unique
939                    // TODO, check only one provides per service type as well
940                    if (allProvides.computeIfAbsent(service, s -> new HashSet<>()).add(impl)) {
941                        impls.append(impl);
942                    } else {
943                        log.error(implName.pos(), Errors.DuplicateProvides(service, impl));
944                    }
945                }
946            }
947            if (st.hasTag(CLASS) && !impls.isEmpty()) {
948                Directive.ProvidesDirective d = new Directive.ProvidesDirective(service, impls.toList());
949                msym.provides = msym.provides.prepend(d);
950                msym.directives = msym.directives.prepend(d);
951                directiveToTreeMap.put(d, tree);
952            }
953        }
954
955        @Override
956        public void visitRequires(JCRequires tree) {
957            if (tree.directive != null) {
958                chk.checkDeprecated(tree.moduleName.pos(), msym, tree.directive.module);
959                msym.directives = msym.directives.prepend(tree.directive);
960            }
961        }
962
963        @Override
964        public void visitUses(JCUses tree) {
965            Type st = attr.attribType(tree.qualid, env, syms.objectType);
966            Symbol sym = TreeInfo.symbol(tree.qualid);
967            if ((sym.flags() & ENUM) != 0) {
968                log.error(tree.qualid.pos(), Errors.ServiceDefinitionIsEnum(st.tsym));
969            } else if (st.hasTag(CLASS)) {
970                ClassSymbol service = (ClassSymbol) st.tsym;
971                if (allUses.add(service)) {
972                    Directive.UsesDirective d = new Directive.UsesDirective(service);
973                    msym.uses = msym.uses.prepend(d);
974                    msym.directives = msym.directives.prepend(d);
975                } else {
976                    log.error(tree.pos(), Errors.DuplicateUses(service));
977                }
978            }
979        }
980
981        private void checkForCorrectness() {
982            for (Directive.ProvidesDirective provides : msym.provides) {
983                JCProvides tree = directiveToTreeMap.get(provides);
984                for (ClassSymbol impl : provides.impls) {
985                    /* The implementation must be defined in the same module as the provides directive
986                     * (else, error)
987                     */
988                    PackageSymbol implementationDefiningPackage = impl.packge();
989                    if (implementationDefiningPackage.modle != msym) {
990                        // TODO: should use tree for the implentation name, not the entire provides tree
991                        // TODO: should improve error message to identify the implementation type
992                        log.error(tree.pos(), Errors.ServiceImplementationNotInRightModule(implementationDefiningPackage.modle));
993                    }
994
995                    /* There is no inherent requirement that module that provides a service should actually
996                     * use it itself. However, it is a pointless declaration if the service package is not
997                     * exported and there is no uses for the service.
998                     */
999                    PackageSymbol interfaceDeclaringPackage = provides.service.packge();
1000                    boolean isInterfaceDeclaredInCurrentModule = interfaceDeclaringPackage.modle == msym;
1001                    boolean isInterfaceExportedFromAReadableModule =
1002                            msym.visiblePackages.get(interfaceDeclaringPackage.fullname) == interfaceDeclaringPackage;
1003                    if (isInterfaceDeclaredInCurrentModule && !isInterfaceExportedFromAReadableModule) {
1004                        // ok the interface is declared in this module. Let's check if it's exported
1005                        boolean warn = true;
1006                        for (ExportsDirective export : msym.exports) {
1007                            if (interfaceDeclaringPackage == export.packge) {
1008                                warn = false;
1009                                break;
1010                            }
1011                        }
1012                        if (warn) {
1013                            for (UsesDirective uses : msym.uses) {
1014                                if (provides.service == uses.service) {
1015                                    warn = false;
1016                                    break;
1017                                }
1018                            }
1019                        }
1020                        if (warn) {
1021                            log.warning(tree.pos(), Warnings.ServiceProvidedButNotExportedOrUsed(provides.service));
1022                        }
1023                    }
1024                }
1025            }
1026        }
1027    }
1028
1029    private Set<ModuleSymbol> allModules;
1030
1031    public Set<ModuleSymbol> allModules() {
1032        Assert.checkNonNull(allModules);
1033        return allModules;
1034    }
1035
1036    private void setupAllModules() {
1037        Assert.checkNonNull(rootModules);
1038        Assert.checkNull(allModules);
1039
1040        Set<ModuleSymbol> observable;
1041
1042        if (limitModsOpt == null && extraLimitMods.isEmpty()) {
1043            observable = null;
1044        } else {
1045            Set<ModuleSymbol> limitMods = new HashSet<>();
1046            if (limitModsOpt != null) {
1047                for (String limit : limitModsOpt.split(",")) {
1048                    if (!isValidName(limit))
1049                        continue;
1050                    limitMods.add(syms.enterModule(names.fromString(limit)));
1051                }
1052            }
1053            for (String limit : extraLimitMods) {
1054                limitMods.add(syms.enterModule(names.fromString(limit)));
1055            }
1056            observable = computeTransitiveClosure(limitMods, null);
1057            observable.addAll(rootModules);
1058            if (lintOptions) {
1059                for (ModuleSymbol msym : limitMods) {
1060                    if (!observable.contains(msym)) {
1061                        log.warning(LintCategory.OPTIONS,
1062                                Warnings.ModuleForOptionNotFound(Option.LIMIT_MODULES, msym));
1063                    }
1064                }
1065            }
1066        }
1067
1068        Predicate<ModuleSymbol> observablePred = sym -> observable == null || observable.contains(sym);
1069        Predicate<ModuleSymbol> systemModulePred = sym -> (sym.flags() & Flags.SYSTEM_MODULE) != 0;
1070        Set<ModuleSymbol> enabledRoot = new LinkedHashSet<>();
1071
1072        if (rootModules.contains(syms.unnamedModule)) {
1073            ModuleSymbol javaSE = syms.getModule(java_se);
1074            Predicate<ModuleSymbol> jdkModulePred;
1075
1076            if (javaSE != null && (observable == null || observable.contains(javaSE))) {
1077                jdkModulePred = sym -> {
1078                    sym.complete();
1079                    return   !sym.name.startsWith(java_)
1080                           && sym.exports.stream().anyMatch(e -> e.modules == null);
1081                };
1082                enabledRoot.add(javaSE);
1083            } else {
1084                jdkModulePred = sym -> true;
1085            }
1086
1087            for (ModuleSymbol sym : new HashSet<>(syms.getAllModules())) {
1088                if (systemModulePred.test(sym) && observablePred.test(sym) && jdkModulePred.test(sym)) {
1089                    enabledRoot.add(sym);
1090                }
1091            }
1092        }
1093
1094        enabledRoot.addAll(rootModules);
1095
1096        if (addModsOpt != null || !extraAddMods.isEmpty()) {
1097            Set<String> fullAddMods = new HashSet<>();
1098            fullAddMods.addAll(extraAddMods);
1099
1100            if (addModsOpt != null) {
1101                fullAddMods.addAll(Arrays.asList(addModsOpt.split(",")));
1102            }
1103
1104            for (String added : fullAddMods) {
1105                Stream<ModuleSymbol> modules;
1106                switch (added) {
1107                    case ALL_SYSTEM:
1108                        modules = syms.getAllModules()
1109                                      .stream()
1110                                      .filter(systemModulePred.and(observablePred));
1111                        break;
1112                    case ALL_MODULE_PATH:
1113                        modules = syms.getAllModules()
1114                                      .stream()
1115                                      .filter(systemModulePred.negate().and(observablePred));
1116                        break;
1117                    default:
1118                        if (!isValidName(added))
1119                            continue;
1120                        modules = Stream.of(syms.enterModule(names.fromString(added)));
1121                        break;
1122                }
1123                modules.forEach(sym -> {
1124                    enabledRoot.add(sym);
1125                    if (observable != null)
1126                        observable.add(sym);
1127                });
1128            }
1129        }
1130
1131        Set<ModuleSymbol> result = computeTransitiveClosure(enabledRoot, observable);
1132
1133        result.add(syms.unnamedModule);
1134
1135        allModules = result;
1136    }
1137
1138    public boolean isInModuleGraph(ModuleSymbol msym) {
1139        return allModules == null || allModules.contains(msym);
1140    }
1141
1142    private Set<ModuleSymbol> computeTransitiveClosure(Iterable<? extends ModuleSymbol> base, Set<ModuleSymbol> observable) {
1143        List<ModuleSymbol> todo = List.nil();
1144
1145        for (ModuleSymbol ms : base) {
1146            todo = todo.prepend(ms);
1147        }
1148
1149        Set<ModuleSymbol> result = new LinkedHashSet<>();
1150        result.add(syms.java_base);
1151
1152        while (todo.nonEmpty()) {
1153            ModuleSymbol current = todo.head;
1154            todo = todo.tail;
1155            if (observable != null && !observable.contains(current))
1156                continue;
1157            if (!result.add(current) || current == syms.unnamedModule || ((current.flags_field & Flags.AUTOMATIC_MODULE) != 0))
1158                continue;
1159            current.complete();
1160            for (RequiresDirective rd : current.requires) {
1161                todo = todo.prepend(rd.module);
1162            }
1163        }
1164
1165        return result;
1166    }
1167
1168    public ModuleSymbol getObservableModule(Name name) {
1169        ModuleSymbol mod = syms.getModule(name);
1170
1171        if (allModules().contains(mod)) {
1172            return mod;
1173        }
1174
1175        return null;
1176    }
1177
1178    private Completer getUnnamedModuleCompleter() {
1179        moduleFinder.findAllModules();
1180        return new Symbol.Completer() {
1181            @Override
1182            public void complete(Symbol sym) throws CompletionFailure {
1183                if (inInitModules) {
1184                    sym.completer = this;
1185                    return ;
1186                }
1187                ModuleSymbol msym = (ModuleSymbol) sym;
1188                Set<ModuleSymbol> allModules = new HashSet<>(allModules());
1189                allModules.remove(syms.unnamedModule);
1190                for (ModuleSymbol m : allModules) {
1191                    m.complete();
1192                }
1193                initVisiblePackages(msym, allModules);
1194            }
1195
1196            @Override
1197            public String toString() {
1198                return "unnamedModule Completer";
1199            }
1200        };
1201    }
1202
1203    private final Map<ModuleSymbol, Set<ModuleSymbol>> requiresTransitiveCache = new HashMap<>();
1204
1205    private void completeModule(ModuleSymbol msym) {
1206        if (inInitModules) {
1207            msym.completer = sym -> completeModule(msym);
1208            return ;
1209        }
1210
1211        if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
1212            completeAutomaticModule(msym);
1213        }
1214
1215        Assert.checkNonNull(msym.requires);
1216
1217        initAddReads();
1218
1219        msym.requires = msym.requires.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));
1220
1221        List<RequiresDirective> requires = msym.requires;
1222        List<RequiresDirective> previous = null;
1223
1224        while (requires.nonEmpty()) {
1225            if (!allModules().contains(requires.head.module)) {
1226                Env<AttrContext> env = typeEnvs.get(msym);
1227                if (env != null) {
1228                    JavaFileObject origSource = log.useSource(env.toplevel.sourcefile);
1229                    try {
1230                        log.error(/*XXX*/env.tree, Errors.ModuleNotFound(requires.head.module));
1231                    } finally {
1232                        log.useSource(origSource);
1233                    }
1234                } else {
1235                    Assert.check((msym.flags() & Flags.AUTOMATIC_MODULE) == 0);
1236                }
1237                if (previous != null) {
1238                    previous.tail = requires.tail;
1239                } else {
1240                    msym.requires.tail = requires.tail;
1241                }
1242            } else {
1243                previous = requires;
1244            }
1245            requires = requires.tail;
1246        }
1247
1248        Set<ModuleSymbol> readable = new LinkedHashSet<>();
1249        Set<ModuleSymbol> requiresTransitive = new HashSet<>();
1250
1251        for (RequiresDirective d : msym.requires) {
1252            d.module.complete();
1253            readable.add(d.module);
1254            Set<ModuleSymbol> s = retrieveRequiresTransitive(d.module);
1255            Assert.checkNonNull(s, () -> "no entry in cache for " + d.module);
1256            readable.addAll(s);
1257            if (d.flags.contains(RequiresFlag.TRANSITIVE)) {
1258                requiresTransitive.add(d.module);
1259                requiresTransitive.addAll(s);
1260            }
1261        }
1262
1263        requiresTransitiveCache.put(msym, requiresTransitive);
1264        initVisiblePackages(msym, readable);
1265        for (ExportsDirective d: msym.exports) {
1266            if (d.packge != null) {
1267                d.packge.modle = msym;
1268            }
1269        }
1270
1271    }
1272
1273    private Set<ModuleSymbol> retrieveRequiresTransitive(ModuleSymbol msym) {
1274        Set<ModuleSymbol> requiresTransitive = requiresTransitiveCache.get(msym);
1275
1276        if (requiresTransitive == null) {
1277            //the module graph may contain cycles involving automatic modules or --add-reads edges
1278            requiresTransitive = new HashSet<>();
1279
1280            Set<ModuleSymbol> seen = new HashSet<>();
1281            List<ModuleSymbol> todo = List.of(msym);
1282
1283            while (todo.nonEmpty()) {
1284                ModuleSymbol current = todo.head;
1285                todo = todo.tail;
1286                if (!seen.add(current))
1287                    continue;
1288                requiresTransitive.add(current);
1289                current.complete();
1290                Iterable<? extends RequiresDirective> requires;
1291                if (current != syms.unnamedModule) {
1292                    Assert.checkNonNull(current.requires, () -> current + ".requires == null; " + msym);
1293                    requires = current.requires;
1294                    for (RequiresDirective rd : requires) {
1295                        if (rd.isTransitive())
1296                            todo = todo.prepend(rd.module);
1297                    }
1298                } else {
1299                    for (ModuleSymbol mod : allModules()) {
1300                        todo = todo.prepend(mod);
1301                    }
1302                }
1303            }
1304
1305            requiresTransitive.remove(msym);
1306        }
1307
1308        return requiresTransitive;
1309    }
1310
1311    private void initVisiblePackages(ModuleSymbol msym, Collection<ModuleSymbol> readable) {
1312        initAddExports();
1313
1314        msym.visiblePackages = new LinkedHashMap<>();
1315
1316        Map<Name, ModuleSymbol> seen = new HashMap<>();
1317
1318        for (ModuleSymbol rm : readable) {
1319            if (rm == syms.unnamedModule)
1320                continue;
1321            addVisiblePackages(msym, seen, rm, rm.exports);
1322        }
1323
1324        addExports.forEach((exportsFrom, exports) -> {
1325            addVisiblePackages(msym, seen, exportsFrom, exports);
1326        });
1327    }
1328
1329    private void addVisiblePackages(ModuleSymbol msym,
1330                                    Map<Name, ModuleSymbol> seenPackages,
1331                                    ModuleSymbol exportsFrom,
1332                                    Collection<ExportsDirective> exports) {
1333        for (ExportsDirective d : exports) {
1334            if (d.modules == null || d.modules.contains(msym)) {
1335                Name packageName = d.packge.fullname;
1336                ModuleSymbol previousModule = seenPackages.get(packageName);
1337
1338                if (previousModule != null && previousModule != exportsFrom) {
1339                    Env<AttrContext> env = typeEnvs.get(msym);
1340                    JavaFileObject origSource = env != null ? log.useSource(env.toplevel.sourcefile)
1341                                                            : null;
1342                    DiagnosticPosition pos = env != null ? env.tree.pos() : null;
1343                    try {
1344                        log.error(pos, Errors.PackageClashFromRequires(msym, packageName,
1345                                                                      previousModule, exportsFrom));
1346                    } finally {
1347                        if (env != null)
1348                            log.useSource(origSource);
1349                    }
1350                    continue;
1351                }
1352
1353                seenPackages.put(packageName, exportsFrom);
1354                msym.visiblePackages.put(d.packge.fullname, d.packge);
1355            }
1356        }
1357    }
1358
1359    private void initAddExports() {
1360        if (addExports != null)
1361            return;
1362
1363        addExports = new LinkedHashMap<>();
1364        Set<ModuleSymbol> unknownModules = new HashSet<>();
1365
1366        if (addExportsOpt == null)
1367            return;
1368
1369        Pattern ep = Pattern.compile("([^/]+)/([^=]+)=(.*)");
1370        for (String s: addExportsOpt.split("\0+")) {
1371            if (s.isEmpty())
1372                continue;
1373            Matcher em = ep.matcher(s);
1374            if (!em.matches()) {
1375                continue;
1376            }
1377
1378            // Terminology comes from
1379            //  --add-exports module/package=target,...
1380            // Compare to
1381            //  module module { exports package to target, ... }
1382            String moduleName = em.group(1);
1383            String packageName = em.group(2);
1384            String targetNames = em.group(3);
1385
1386            if (!isValidName(moduleName))
1387                continue;
1388
1389            ModuleSymbol msym = syms.enterModule(names.fromString(moduleName));
1390            if (!isKnownModule(msym, unknownModules))
1391                continue;
1392
1393            if (!isValidName(packageName))
1394                continue;
1395            PackageSymbol p = syms.enterPackage(msym, names.fromString(packageName));
1396            p.modle = msym;  // TODO: do we need this?
1397
1398            List<ModuleSymbol> targetModules = List.nil();
1399            for (String toModule : targetNames.split("[ ,]+")) {
1400                ModuleSymbol m;
1401                if (toModule.equals("ALL-UNNAMED")) {
1402                    m = syms.unnamedModule;
1403                } else {
1404                    if (!isValidName(toModule))
1405                        continue;
1406                    m = syms.enterModule(names.fromString(toModule));
1407                    if (!isKnownModule(m, unknownModules))
1408                        continue;
1409                }
1410                targetModules = targetModules.prepend(m);
1411            }
1412
1413            Set<ExportsDirective> extra = addExports.computeIfAbsent(msym, _x -> new LinkedHashSet<>());
1414            ExportsDirective d = new ExportsDirective(p, targetModules);
1415            extra.add(d);
1416        }
1417    }
1418
1419    private boolean isKnownModule(ModuleSymbol msym, Set<ModuleSymbol> unknownModules) {
1420        if (allModules.contains(msym)) {
1421            return true;
1422        }
1423
1424        if (!unknownModules.contains(msym)) {
1425            if (lintOptions) {
1426                log.warning(LintCategory.OPTIONS,
1427                        Warnings.ModuleForOptionNotFound(Option.ADD_EXPORTS, msym));
1428            }
1429            unknownModules.add(msym);
1430        }
1431        return false;
1432    }
1433
1434    private void initAddReads() {
1435        if (addReads != null)
1436            return;
1437
1438        addReads = new LinkedHashMap<>();
1439
1440        if (addReadsOpt == null)
1441            return;
1442
1443        Pattern rp = Pattern.compile("([^=]+)=(.*)");
1444        for (String s : addReadsOpt.split("\0+")) {
1445            if (s.isEmpty())
1446                continue;
1447            Matcher rm = rp.matcher(s);
1448            if (!rm.matches()) {
1449                continue;
1450            }
1451
1452            // Terminology comes from
1453            //  --add-reads source-module=target-module,...
1454            // Compare to
1455            //  module source-module { requires target-module; ... }
1456            String sourceName = rm.group(1);
1457            String targetNames = rm.group(2);
1458
1459            if (!isValidName(sourceName))
1460                continue;
1461
1462            ModuleSymbol msym = syms.enterModule(names.fromString(sourceName));
1463            if (!allModules.contains(msym)) {
1464                if (lintOptions) {
1465                    log.warning(Warnings.ModuleForOptionNotFound(Option.ADD_READS, msym));
1466                }
1467                continue;
1468            }
1469
1470            for (String targetName : targetNames.split("[ ,]+", -1)) {
1471                ModuleSymbol targetModule;
1472                if (targetName.equals("ALL-UNNAMED")) {
1473                    targetModule = syms.unnamedModule;
1474                } else {
1475                    if (!isValidName(targetName))
1476                        continue;
1477                    targetModule = syms.enterModule(names.fromString(targetName));
1478                    if (!allModules.contains(targetModule)) {
1479                        if (lintOptions) {
1480                            log.warning(LintCategory.OPTIONS, Warnings.ModuleForOptionNotFound(Option.ADD_READS, targetModule));
1481                        }
1482                        continue;
1483                    }
1484                }
1485                addReads.computeIfAbsent(msym, m -> new HashSet<>())
1486                        .add(new RequiresDirective(targetModule, EnumSet.of(RequiresFlag.EXTRA)));
1487            }
1488        }
1489    }
1490
1491    private void checkCyclicDependencies(JCModuleDecl mod) {
1492        for (JCDirective d : mod.directives) {
1493            JCRequires rd;
1494            if (!d.hasTag(Tag.REQUIRES) || (rd = (JCRequires) d).directive == null)
1495                continue;
1496            Set<ModuleSymbol> nonSyntheticDeps = new HashSet<>();
1497            List<ModuleSymbol> queue = List.of(rd.directive.module);
1498            while (queue.nonEmpty()) {
1499                ModuleSymbol current = queue.head;
1500                queue = queue.tail;
1501                if (!nonSyntheticDeps.add(current))
1502                    continue;
1503                current.complete();
1504                if ((current.flags() & Flags.ACYCLIC) != 0)
1505                    continue;
1506                Assert.checkNonNull(current.requires, () -> current.toString());
1507                for (RequiresDirective dep : current.requires) {
1508                    if (!dep.flags.contains(RequiresFlag.EXTRA))
1509                        queue = queue.prepend(dep.module);
1510                }
1511            }
1512            if (nonSyntheticDeps.contains(mod.sym)) {
1513                log.error(rd.moduleName.pos(), Errors.CyclicRequires(rd.directive.module));
1514            }
1515            mod.sym.flags_field |= Flags.ACYCLIC;
1516        }
1517    }
1518
1519    private boolean isValidName(CharSequence name) {
1520        return SourceVersion.isName(name, Source.toSourceVersion(source));
1521    }
1522
1523    // DEBUG
1524    private String toString(ModuleSymbol msym) {
1525        return msym.name + "["
1526                + "kind:" + msym.kind + ";"
1527                + "locn:" + toString(msym.sourceLocation) + "," + toString(msym.classLocation) + ";"
1528                + "info:" + toString(msym.module_info.sourcefile) + ","
1529                            + toString(msym.module_info.classfile) + ","
1530                            + msym.module_info.completer
1531                + "]";
1532    }
1533
1534    // DEBUG
1535    String toString(Location locn) {
1536        return (locn == null) ? "--" : locn.getName();
1537    }
1538
1539    // DEBUG
1540    String toString(JavaFileObject fo) {
1541        return (fo == null) ? "--" : fo.getName();
1542    }
1543
1544    public void newRound() {
1545        rootModules = null;
1546        allModules = null;
1547    }
1548}
1549