Modules.java revision 3573:c4a18ee691c4 
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.Map.Entry;
40import java.util.Set;
41import java.util.function.Consumer;
42import java.util.function.Predicate;
43import java.util.regex.Matcher;
44import java.util.regex.Pattern;
45import java.util.stream.Stream;
46
47import javax.lang.model.SourceVersion;
48import javax.tools.JavaFileManager;
49import javax.tools.JavaFileManager.Location;
50import javax.tools.JavaFileObject;
51import javax.tools.JavaFileObject.Kind;
52import javax.tools.StandardLocation;
53
54import com.sun.tools.javac.code.ClassFinder;
55import com.sun.tools.javac.code.Directive;
56import com.sun.tools.javac.code.Directive.ExportsDirective;
57import com.sun.tools.javac.code.Directive.RequiresDirective;
58import com.sun.tools.javac.code.Directive.RequiresFlag;
59import com.sun.tools.javac.code.Directive.UsesDirective;
60import com.sun.tools.javac.code.Flags;
61import com.sun.tools.javac.code.Kinds;
62import com.sun.tools.javac.code.ModuleFinder;
63import com.sun.tools.javac.code.Source;
64import com.sun.tools.javac.code.Symbol;
65import com.sun.tools.javac.code.Symbol.ClassSymbol;
66import com.sun.tools.javac.code.Symbol.Completer;
67import com.sun.tools.javac.code.Symbol.CompletionFailure;
68import com.sun.tools.javac.code.Symbol.MethodSymbol;
69import com.sun.tools.javac.code.Symbol.ModuleSymbol;
70import com.sun.tools.javac.code.Symbol.PackageSymbol;
71import com.sun.tools.javac.code.Symtab;
72import com.sun.tools.javac.code.Type;
73import com.sun.tools.javac.code.Types;
74import com.sun.tools.javac.jvm.ClassWriter;
75import com.sun.tools.javac.jvm.JNIWriter;
76import com.sun.tools.javac.main.Option;
77import com.sun.tools.javac.resources.CompilerProperties.Errors;
78import com.sun.tools.javac.resources.CompilerProperties.Warnings;
79import com.sun.tools.javac.tree.JCTree;
80import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
81import com.sun.tools.javac.tree.JCTree.JCExports;
82import com.sun.tools.javac.tree.JCTree.JCExpression;
83import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
84import com.sun.tools.javac.tree.JCTree.JCPackageDecl;
85import com.sun.tools.javac.tree.JCTree.JCProvides;
86import com.sun.tools.javac.tree.JCTree.JCRequires;
87import com.sun.tools.javac.tree.JCTree.JCUses;
88import com.sun.tools.javac.tree.TreeInfo;
89import com.sun.tools.javac.util.Assert;
90import com.sun.tools.javac.util.Context;
91import com.sun.tools.javac.util.JCDiagnostic;
92import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
93import com.sun.tools.javac.util.List;
94import com.sun.tools.javac.util.ListBuffer;
95import com.sun.tools.javac.util.Log;
96import com.sun.tools.javac.util.Name;
97import com.sun.tools.javac.util.Names;
98import com.sun.tools.javac.util.Options;
99
100import static com.sun.tools.javac.code.Flags.UNATTRIBUTED;
101import static com.sun.tools.javac.code.Kinds.Kind.MDL;
102import static com.sun.tools.javac.code.TypeTag.CLASS;
103
104import com.sun.tools.javac.tree.JCTree.JCDirective;
105import com.sun.tools.javac.tree.JCTree.Tag;
106import com.sun.tools.javac.util.Abort;
107import com.sun.tools.javac.util.Position;
108
109import static com.sun.tools.javac.code.Flags.ABSTRACT;
110import static com.sun.tools.javac.code.Flags.ENUM;
111import static com.sun.tools.javac.code.Flags.PUBLIC;
112import static com.sun.tools.javac.tree.JCTree.Tag.MODULEDEF;
113
114/**
115 *  TODO: fill in
116 *
117 *  <p><b>This is NOT part of any supported API.
118 *  If you write code that depends on this, you do so at your own risk.
119 *  This code and its internal interfaces are subject to change or
120 *  deletion without notice.</b>
121 */
122public class Modules extends JCTree.Visitor {
123    private static final String ALL_SYSTEM = "ALL-SYSTEM";
124    private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";
125
126    private final Log log;
127    private final Names names;
128    private final Symtab syms;
129    private final Attr attr;
130    private final TypeEnvs typeEnvs;
131    private final Types types;
132    private final JavaFileManager fileManager;
133    private final ModuleFinder moduleFinder;
134    private final boolean allowModules;
135
136    public final boolean multiModuleMode;
137
138    private final String moduleOverride;
139
140    private final Name java_se;
141    private final Name java_;
142
143    ModuleSymbol defaultModule;
144
145    private final String addExportsOpt;
146    private Map<ModuleSymbol, Set<ExportsDirective>> addExports;
147    private final String addReadsOpt;
148    private Map<ModuleSymbol, Set<RequiresDirective>> addReads;
149    private final String addModsOpt;
150    private final String limitModsOpt;
151
152    private Set<ModuleSymbol> rootModules = null;
153
154    public static Modules instance(Context context) {
155        Modules instance = context.get(Modules.class);
156        if (instance == null)
157            instance = new Modules(context);
158        return instance;
159    }
160
161    protected Modules(Context context) {
162        context.put(Modules.class, this);
163        log = Log.instance(context);
164        names = Names.instance(context);
165        syms = Symtab.instance(context);
166        attr = Attr.instance(context);
167        typeEnvs = TypeEnvs.instance(context);
168        moduleFinder = ModuleFinder.instance(context);
169        types = Types.instance(context);
170        fileManager = context.get(JavaFileManager.class);
171        allowModules = Source.instance(context).allowModules();
172        Options options = Options.instance(context);
173
174        moduleOverride = options.get(Option.XMODULE);
175
176        multiModuleMode = fileManager.hasLocation(StandardLocation.MODULE_SOURCE_PATH);
177        ClassWriter classWriter = ClassWriter.instance(context);
178        classWriter.multiModuleMode = multiModuleMode;
179        JNIWriter jniWriter = JNIWriter.instance(context);
180        jniWriter.multiModuleMode = multiModuleMode;
181
182        java_se = names.fromString("java.se");
183        java_ = names.fromString("java.");
184
185        addExportsOpt = options.get(Option.ADD_EXPORTS);
186        addReadsOpt = options.get(Option.ADD_READS);
187        addModsOpt = options.get(Option.ADD_MODULES);
188        limitModsOpt = options.get(Option.LIMIT_MODULES);
189    }
190
191    int depth = -1;
192    private void dprintln(String msg) {
193        for (int i = 0; i < depth; i++)
194            System.err.print("  ");
195        System.err.println(msg);
196    }
197
198    boolean inInitModules;
199    public void initModules(List<JCCompilationUnit> trees, Collection<String> extraAddMods, Collection<String> extraLimitMods) {
200        Assert.check(!inInitModules);
201        try {
202            inInitModules = true;
203            Assert.checkNull(rootModules);
204            enter(trees, modules -> {
205                Assert.checkNull(rootModules);
206                Assert.checkNull(allModules);
207                this.rootModules = modules;
208                setupAllModules(extraAddMods, extraLimitMods); //initialize the module graph
209                Assert.checkNonNull(allModules);
210                inInitModules = false;
211            }, null);
212        } finally {
213            inInitModules = false;
214        }
215    }
216
217    public boolean enter(List<JCCompilationUnit> trees, ClassSymbol c) {
218        Assert.check(rootModules != null || inInitModules || !allowModules);
219        return enter(trees, modules -> {}, c);
220    }
221
222    private boolean enter(List<JCCompilationUnit> trees, Consumer<Set<ModuleSymbol>> init, ClassSymbol c) {
223        if (!allowModules) {
224            for (JCCompilationUnit tree: trees) {
225                tree.modle = syms.noModule;
226            }
227            defaultModule = syms.noModule;
228            return true;
229        }
230
231        int startErrors = log.nerrors;
232
233        depth++;
234        try {
235            // scan trees for module defs
236            Set<ModuleSymbol> roots = enterModules(trees, c);
237
238            setCompilationUnitModules(trees, roots);
239
240            init.accept(roots);
241
242            for (ModuleSymbol msym: roots) {
243                msym.complete();
244            }
245        } catch (CompletionFailure ex) {
246            log.error(JCDiagnostic.DiagnosticFlag.NON_DEFERRABLE, Position.NOPOS, "cant.access", ex.sym, ex.getDetailValue());
247            if (ex instanceof ClassFinder.BadClassFile) throw new Abort();
248        } finally {
249            depth--;
250        }
251
252        return (log.nerrors == startErrors);
253    }
254
255    public Completer getCompleter() {
256        return mainCompleter;
257    }
258
259    public ModuleSymbol getDefaultModule() {
260        return defaultModule;
261    }
262
263    private Set<ModuleSymbol> enterModules(List<JCCompilationUnit> trees, ClassSymbol c) {
264        Set<ModuleSymbol> modules = new LinkedHashSet<>();
265        for (JCCompilationUnit tree : trees) {
266            JavaFileObject prev = log.useSource(tree.sourcefile);
267            try {
268                enterModule(tree, c, modules);
269            } finally {
270                log.useSource(prev);
271            }
272        }
273        return modules;
274    }
275
276
277    private void enterModule(JCCompilationUnit toplevel, ClassSymbol c, Set<ModuleSymbol> modules) {
278        boolean isModuleInfo = toplevel.sourcefile.isNameCompatible("module-info", Kind.SOURCE);
279        boolean isModuleDecl = toplevel.defs.nonEmpty() && toplevel.defs.head.hasTag(MODULEDEF);
280        if (isModuleInfo && isModuleDecl) {
281            JCModuleDecl decl = (JCModuleDecl) toplevel.defs.head;
282            Name name = TreeInfo.fullName(decl.qualId);
283            ModuleSymbol sym;
284            if (c != null) {
285               sym = (ModuleSymbol) c.owner;
286               if (sym.name == null) {
287                   //ModuleFinder.findSingleModule creates a stub of a ModuleSymbol without a name,
288                   //fill the name here after the module-info.java has been parsed
289                   //also enter the ModuleSymbol among modules:
290                   syms.enterModule(sym, name);
291               } else {
292                   // TODO: validate name
293               }
294            } else {
295                sym = syms.enterModule(name);
296                if (sym.module_info.sourcefile != null && sym.module_info.sourcefile != toplevel.sourcefile) {
297                    log.error(decl.pos(), Errors.DuplicateModule(sym));
298                    return;
299                }
300            }
301            sym.completer = getSourceCompleter(toplevel);
302            sym.module_info.sourcefile = toplevel.sourcefile;
303            decl.sym = sym;
304
305            if (multiModuleMode || modules.isEmpty()) {
306                modules.add(sym);
307            } else {
308                log.error(toplevel.pos(), Errors.TooManyModules);
309            }
310
311            Env<AttrContext> provisionalEnv = new Env<>(decl, null);
312
313            provisionalEnv.toplevel = toplevel;
314            typeEnvs.put(sym, provisionalEnv);
315        } else if (isModuleInfo) {
316            if (multiModuleMode) {
317                JCTree tree = toplevel.defs.isEmpty() ? toplevel : toplevel.defs.head;
318                log.error(tree.pos(), Errors.ExpectedModule);
319            }
320        } else if (isModuleDecl) {
321            JCTree tree = toplevel.defs.head;
322            log.error(tree.pos(), Errors.ModuleDeclSbInModuleInfoJava);
323        }
324    }
325
326    private void setCompilationUnitModules(List<JCCompilationUnit> trees, Set<ModuleSymbol> rootModules) {
327        // update the module for each compilation unit
328        if (multiModuleMode) {
329            checkNoAllModulePath();
330            for (JCCompilationUnit tree: trees) {
331                if (tree.defs.isEmpty()) {
332                    tree.modle = syms.unnamedModule;
333                    continue;
334                }
335
336                JavaFileObject prev = log.useSource(tree.sourcefile);
337                try {
338                    Location locn = getModuleLocation(tree);
339                    if (locn != null) {
340                        Name name = names.fromString(fileManager.inferModuleName(locn));
341                        ModuleSymbol msym;
342                        if (tree.defs.head.hasTag(MODULEDEF)) {
343                            JCModuleDecl decl = (JCModuleDecl) tree.defs.head;
344                            msym = decl.sym;
345                            if (msym.name != name) {
346                                log.error(decl.qualId, Errors.ModuleNameMismatch(msym.name, name));
347                            }
348                        } else {
349                            msym = syms.enterModule(name);
350                        }
351                        if (msym.sourceLocation == null) {
352                            msym.sourceLocation = locn;
353                            if (fileManager.hasLocation(StandardLocation.CLASS_OUTPUT)) {
354                                msym.classLocation = fileManager.getModuleLocation(
355                                        StandardLocation.CLASS_OUTPUT, msym.name.toString());
356                            }
357                        }
358                        tree.modle = msym;
359                        rootModules.add(msym);
360                    } else {
361                        log.error(tree.pos(), Errors.UnnamedPkgNotAllowedNamedModules);
362                        tree.modle = syms.errModule;
363                    }
364                } catch (IOException e) {
365                    throw new Error(e); // FIXME
366                } finally {
367                    log.useSource(prev);
368                }
369            }
370            if (syms.unnamedModule.sourceLocation == null) {
371                syms.unnamedModule.completer = getUnnamedModuleCompleter();
372                syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;
373                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;
374            }
375            defaultModule = syms.unnamedModule;
376        } else {
377            if (defaultModule == null) {
378                switch (rootModules.size()) {
379                    case 0:
380                        defaultModule = moduleFinder.findSingleModule();
381                        if (defaultModule == syms.unnamedModule) {
382                            if (moduleOverride != null) {
383                                checkNoAllModulePath();
384                                defaultModule = moduleFinder.findModule(names.fromString(moduleOverride));
385                            } else {
386                                // Question: why not do findAllModules and initVisiblePackages here?
387                                // i.e. body of unnamedModuleCompleter
388                                defaultModule.completer = getUnnamedModuleCompleter();
389                                defaultModule.classLocation = StandardLocation.CLASS_PATH;
390                            }
391                        } else {
392                            checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleClasspath);
393                            checkNoAllModulePath();
394                            defaultModule.complete();
395                            // Question: why not do completeModule here?
396                            defaultModule.completer = new Completer() {
397                                @Override
398                                public void complete(Symbol sym) throws CompletionFailure {
399                                    completeModule((ModuleSymbol) sym);
400                                }
401                            };
402                        }
403                        rootModules.add(defaultModule);
404                        break;
405                    case 1:
406                        checkSpecifiedModule(trees, Errors.ModuleInfoWithXmoduleSourcepath);
407                        checkNoAllModulePath();
408                        defaultModule = rootModules.iterator().next();
409                        defaultModule.classLocation = StandardLocation.CLASS_OUTPUT;
410                        break;
411                    default:
412                        Assert.error("too many modules");
413                }
414                defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;
415            } else if (rootModules.size() == 1 && defaultModule == rootModules.iterator().next()) {
416                defaultModule.complete();
417                defaultModule.completer = sym -> completeModule((ModuleSymbol) sym);
418            } else {
419                Assert.check(rootModules.isEmpty());
420                rootModules.add(defaultModule);
421            }
422
423            if (defaultModule != syms.unnamedModule) {
424                syms.unnamedModule.completer = getUnnamedModuleCompleter();
425                syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;
426                syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;
427            }
428
429            for (JCCompilationUnit tree: trees) {
430                tree.modle = defaultModule;
431            }
432        }
433    }
434
435    private Location getModuleLocation(JCCompilationUnit tree) throws IOException {
436        switch (tree.defs.head.getTag()) {
437            case MODULEDEF:
438                return getModuleLocation(tree.sourcefile, null);
439
440            case PACKAGEDEF:
441                JCPackageDecl pkg = (JCPackageDecl) tree.defs.head;
442                return getModuleLocation(tree.sourcefile, TreeInfo.fullName(pkg.pid));
443
444            default:
445                // code in unnamed module
446                return null;
447        }
448    }
449
450    private Location getModuleLocation(JavaFileObject fo, Name pkgName) throws IOException {
451        // For now, just check module source path.
452        // We may want to check source path as well.
453        return fileManager.getModuleLocation(StandardLocation.MODULE_SOURCE_PATH,
454                fo, (pkgName == null) ? null : pkgName.toString());
455    }
456
457    private void checkSpecifiedModule(List<JCCompilationUnit> trees, JCDiagnostic.Error error) {
458        if (moduleOverride != null) {
459            JavaFileObject prev = log.useSource(trees.head.sourcefile);
460            try {
461                log.error(trees.head.pos(), error);
462            } finally {
463                log.useSource(prev);
464            }
465        }
466    }
467
468    private void checkNoAllModulePath() {
469        if (addModsOpt != null && Arrays.asList(addModsOpt.split(",")).contains(ALL_MODULE_PATH)) {
470            log.error(Errors.AddmodsAllModulePathInvalid);
471        }
472    }
473
474    private final Completer mainCompleter = new Completer() {
475        @Override
476        public void complete(Symbol sym) throws CompletionFailure {
477            ModuleSymbol msym = moduleFinder.findModule((ModuleSymbol) sym);
478
479            if (msym.kind == Kinds.Kind.ERR) {
480                log.error(Errors.CantFindModule(msym));
481                //make sure the module is initialized:
482                msym.directives = List.nil();
483                msym.exports = List.nil();
484                msym.provides = List.nil();
485                msym.requires = List.nil();
486                msym.uses = List.nil();
487            } else if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
488                setupAutomaticModule(msym);
489            } else {
490                msym.module_info.complete();
491            }
492
493            // If module-info comes from a .java file, the underlying
494            // call of classFinder.fillIn will have called through the
495            // source completer, to Enter, and then to Modules.enter,
496            // which will call completeModule.
497            // But, if module-info comes from a .class file, the underlying
498            // call of classFinder.fillIn will just call ClassReader to read
499            // the .class file, and so we call completeModule here.
500            if (msym.module_info.classfile == null || msym.module_info.classfile.getKind() == Kind.CLASS) {
501                completeModule(msym);
502            }
503        }
504
505        @Override
506        public String toString() {
507            return "mainCompleter";
508        }
509    };
510
511    private void setupAutomaticModule(ModuleSymbol msym) throws CompletionFailure {
512        try {
513            ListBuffer<Directive> directives = new ListBuffer<>();
514            ListBuffer<ExportsDirective> exports = new ListBuffer<>();
515            Set<String> seenPackages = new HashSet<>();
516
517            for (JavaFileObject clazz : fileManager.list(msym.classLocation, "", EnumSet.of(Kind.CLASS), true)) {
518                String binName = fileManager.inferBinaryName(msym.classLocation, clazz);
519                String pack = binName.lastIndexOf('.') != (-1) ? binName.substring(0, binName.lastIndexOf('.')) : ""; //unnamed package????
520                if (seenPackages.add(pack)) {
521                    ExportsDirective d = new ExportsDirective(syms.enterPackage(msym, names.fromString(pack)), null);
522                    directives.add(d);
523                    exports.add(d);
524                }
525            }
526
527            msym.exports = exports.toList();
528            msym.provides = List.nil();
529            msym.requires = List.nil();
530            msym.uses = List.nil();
531            msym.directives = directives.toList();
532            msym.flags_field |= Flags.ACYCLIC;
533        } catch (IOException ex) {
534            throw new IllegalStateException(ex);
535        }
536    }
537
538    private void completeAutomaticModule(ModuleSymbol msym) throws CompletionFailure {
539        ListBuffer<Directive> directives = new ListBuffer<>();
540
541        directives.addAll(msym.directives);
542
543        ListBuffer<RequiresDirective> requires = new ListBuffer<>();
544
545        for (ModuleSymbol ms : allModules()) {
546            if (ms == syms.unnamedModule || ms == msym)
547                continue;
548            Set<RequiresFlag> flags = (ms.flags_field & Flags.AUTOMATIC_MODULE) != 0 ?
549                    EnumSet.of(RequiresFlag.PUBLIC) : EnumSet.noneOf(RequiresFlag.class);
550            RequiresDirective d = new RequiresDirective(ms, flags);
551            directives.add(d);
552            requires.add(d);
553        }
554
555        RequiresDirective requiresUnnamed = new RequiresDirective(syms.unnamedModule);
556        directives.add(requiresUnnamed);
557        requires.add(requiresUnnamed);
558
559        msym.requires = requires.toList();
560        msym.directives = directives.toList();
561    }
562
563    private Completer getSourceCompleter(JCCompilationUnit tree) {
564        return new Completer() {
565            @Override
566            public void complete(Symbol sym) throws CompletionFailure {
567                ModuleSymbol msym = (ModuleSymbol) sym;
568                msym.flags_field |= UNATTRIBUTED;
569                ModuleVisitor v = new ModuleVisitor();
570                JavaFileObject prev = log.useSource(tree.sourcefile);
571                try {
572                    tree.defs.head.accept(v);
573                    checkCyclicDependencies((JCModuleDecl) tree.defs.head);
574                    completeModule(msym);
575                } finally {
576                    log.useSource(prev);
577                    msym.flags_field &= ~UNATTRIBUTED;
578                }
579            }
580
581            @Override
582            public String toString() {
583                return "SourceCompleter: " + tree.sourcefile.getName();
584            }
585
586        };
587    }
588
589    class ModuleVisitor extends JCTree.Visitor {
590        private ModuleSymbol sym;
591        private final Set<ModuleSymbol> allRequires = new HashSet<>();
592        private final Set<PackageSymbol> allExports = new HashSet<>();
593
594        @Override
595        public void visitModuleDef(JCModuleDecl tree) {
596            sym = Assert.checkNonNull(tree.sym);
597
598            sym.requires = List.nil();
599            sym.exports = List.nil();
600            tree.directives.forEach(t -> t.accept(this));
601            sym.requires = sym.requires.reverse();
602            sym.exports = sym.exports.reverse();
603            ensureJavaBase();
604        }
605
606        @Override
607        public void visitRequires(JCRequires tree) {
608            ModuleSymbol msym = lookupModule(tree.moduleName);
609            if (msym.kind != MDL) {
610                log.error(tree.moduleName.pos(), Errors.ModuleNotFound(msym));
611            } else if (allRequires.contains(msym)) {
612                log.error(tree.moduleName.pos(), Errors.DuplicateRequires(msym));
613            } else {
614                allRequires.add(msym);
615                Set<RequiresFlag> flags = EnumSet.noneOf(RequiresFlag.class);
616                if (tree.isPublic)
617                    flags.add(RequiresFlag.PUBLIC);
618                RequiresDirective d = new RequiresDirective(msym, flags);
619                tree.directive = d;
620                sym.requires = sym.requires.prepend(d);
621            }
622        }
623
624        @Override
625        public void visitExports(JCExports tree) {
626            Name name = TreeInfo.fullName(tree.qualid);
627            PackageSymbol packge = syms.enterPackage(sym, name);
628            attr.setPackageSymbols(tree.qualid, packge);
629            if (!allExports.add(packge)) {
630                log.error(tree.qualid.pos(), Errors.DuplicateExports(packge));
631            }
632
633            List<ModuleSymbol> toModules = null;
634            if (tree.moduleNames != null) {
635                Set<ModuleSymbol> to = new HashSet<>();
636                for (JCExpression n: tree.moduleNames) {
637                    ModuleSymbol msym = lookupModule(n);
638                    if (msym.kind != MDL) {
639                        log.error(n.pos(), Errors.ModuleNotFound(msym));
640                    } else if (!to.add(msym)) {
641                        log.error(n.pos(), Errors.DuplicateExports(msym));
642                    }
643                }
644                toModules = List.from(to);
645            }
646
647            if (toModules == null || !toModules.isEmpty()) {
648                ExportsDirective d = new ExportsDirective(packge, toModules);
649                tree.directive = d;
650                sym.exports = sym.exports.prepend(d);
651            }
652        }
653
654        @Override
655        public void visitProvides(JCProvides tree) { }
656
657        @Override
658        public void visitUses(JCUses tree) { }
659
660        private void ensureJavaBase() {
661            if (sym.name == names.java_base)
662                return;
663
664            for (RequiresDirective d: sym.requires) {
665                if (d.module.name == names.java_base)
666                    return;
667            }
668
669            ModuleSymbol java_base = syms.enterModule(names.java_base);
670            Directive.RequiresDirective d =
671                    new Directive.RequiresDirective(java_base,
672                            EnumSet.of(Directive.RequiresFlag.MANDATED));
673            sym.requires = sym.requires.prepend(d);
674        }
675
676        private ModuleSymbol lookupModule(JCExpression moduleName) {
677            try {
678            Name name = TreeInfo.fullName(moduleName);
679            ModuleSymbol msym = moduleFinder.findModule(name);
680            TreeInfo.setSymbol(moduleName, msym);
681            return msym;
682            } catch (Throwable t) {
683                System.err.println("Module " + sym + "; lookup export " + moduleName);
684                throw t;
685            }
686        }
687    }
688
689    public Completer getUsesProvidesCompleter() {
690        return sym -> {
691            ModuleSymbol msym = (ModuleSymbol) sym;
692
693            msym.complete();
694
695            Env<AttrContext> env = typeEnvs.get(msym);
696            UsesProvidesVisitor v = new UsesProvidesVisitor(msym, env);
697            JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
698            try {
699                env.toplevel.defs.head.accept(v);
700            } finally {
701                log.useSource(prev);
702            }
703        };
704    }
705
706    class UsesProvidesVisitor extends JCTree.Visitor {
707        private final ModuleSymbol msym;
708        private final Env<AttrContext> env;
709
710        private final Set<Directive.UsesDirective> allUses = new HashSet<>();
711        private final Set<Directive.ProvidesDirective> allProvides = new HashSet<>();
712
713        public UsesProvidesVisitor(ModuleSymbol msym, Env<AttrContext> env) {
714            this.msym = msym;
715            this.env = env;
716        }
717
718        @Override @SuppressWarnings("unchecked")
719        public void visitModuleDef(JCModuleDecl tree) {
720            msym.directives = List.nil();
721            msym.provides = List.nil();
722            msym.uses = List.nil();
723            tree.directives.forEach(t -> t.accept(this));
724            msym.directives = msym.directives.reverse();
725            msym.provides = msym.provides.reverse();
726            msym.uses = msym.uses.reverse();
727
728            if (msym.requires.nonEmpty() && msym.requires.head.flags.contains(RequiresFlag.MANDATED))
729                msym.directives = msym.directives.prepend(msym.requires.head);
730
731            msym.directives = msym.directives.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));
732
733            checkForCorrectness();
734        }
735
736        @Override
737        public void visitExports(JCExports tree) {
738            if (tree.directive.packge.members().isEmpty()) {
739                log.error(tree.qualid.pos(), Errors.PackageEmptyOrNotFound(tree.directive.packge));
740            }
741            msym.directives = msym.directives.prepend(tree.directive);
742        }
743
744        MethodSymbol noArgsConstructor(ClassSymbol tsym) {
745            for (Symbol sym : tsym.members().getSymbolsByName(names.init)) {
746                MethodSymbol mSym = (MethodSymbol)sym;
747                if (mSym.params().isEmpty()) {
748                    return mSym;
749                }
750            }
751            return null;
752        }
753
754        Map<Directive.ProvidesDirective, JCProvides> directiveToTreeMap = new HashMap<>();
755
756        @Override
757        public void visitProvides(JCProvides tree) {
758            Type st = attr.attribType(tree.serviceName, env, syms.objectType);
759            Type it = attr.attribType(tree.implName, env, syms.objectType);
760            ClassSymbol service = (ClassSymbol) st.tsym;
761            ClassSymbol impl = (ClassSymbol) it.tsym;
762            if (!types.isSubtype(it, st)) {
763                log.error(tree.implName.pos(), Errors.ServiceImplementationMustBeSubtypeOfServiceInterface);
764            }
765            if ((impl.flags() & ABSTRACT) != 0) {
766                log.error(tree.implName.pos(), Errors.ServiceImplementationIsAbstract(impl));
767            } else if (impl.isInner()) {
768                log.error(tree.implName.pos(), Errors.ServiceImplementationIsInner(impl));
769            } else if (service.isInner()) {
770                log.error(tree.serviceName.pos(), Errors.ServiceDefinitionIsInner(service));
771            } else {
772                MethodSymbol constr = noArgsConstructor(impl);
773                if (constr == null) {
774                    log.error(tree.implName.pos(), Errors.ServiceImplementationDoesntHaveANoArgsConstructor(impl));
775                } else if ((constr.flags() & PUBLIC) == 0) {
776                    log.error(tree.implName.pos(), Errors.ServiceImplementationNoArgsConstructorNotPublic(impl));
777                }
778            }
779            if (st.hasTag(CLASS) && it.hasTag(CLASS)) {
780                Directive.ProvidesDirective d = new Directive.ProvidesDirective(service, impl);
781                if (!allProvides.add(d)) {
782                    log.error(tree.pos(), Errors.DuplicateProvides(service, impl));
783                }
784                msym.provides = msym.provides.prepend(d);
785                msym.directives = msym.directives.prepend(d);
786                directiveToTreeMap.put(d, tree);
787            }
788        }
789
790        @Override
791        public void visitRequires(JCRequires tree) {
792            if (tree.directive != null) {
793                msym.directives = msym.directives.prepend(tree.directive);
794            }
795        }
796
797        @Override
798        public void visitUses(JCUses tree) {
799            Type st = attr.attribType(tree.qualid, env, syms.objectType);
800            Symbol sym = TreeInfo.symbol(tree.qualid);
801            if ((sym.flags() & ENUM) != 0) {
802                log.error(tree.qualid.pos(), Errors.ServiceDefinitionIsEnum(st.tsym));
803            } else if (st.hasTag(CLASS)) {
804                ClassSymbol service = (ClassSymbol) st.tsym;
805                Directive.UsesDirective d = new Directive.UsesDirective(service);
806                if (!allUses.add(d)) {
807                    log.error(tree.pos(), Errors.DuplicateUses(service));
808                }
809                msym.uses = msym.uses.prepend(d);
810                msym.directives = msym.directives.prepend(d);
811            }
812        }
813
814        private void checkForCorrectness() {
815            for (Directive.ProvidesDirective provides : allProvides) {
816                JCProvides tree = directiveToTreeMap.get(provides);
817                /* The implementation must be defined in the same module as the provides directive
818                 * (else, error)
819                 */
820                PackageSymbol implementationDefiningPackage = provides.impl.packge();
821                if (implementationDefiningPackage.modle != msym) {
822                    log.error(tree.pos(), Errors.ServiceImplementationNotInRightModule(implementationDefiningPackage.modle));
823                }
824
825                /* There is no inherent requirement that module that provides a service should actually
826                 * use it itself. However, it is a pointless declaration if the service package is not
827                 * exported and there is no uses for the service.
828                 */
829                PackageSymbol interfaceDeclaringPackage = provides.service.packge();
830                boolean isInterfaceDeclaredInCurrentModule = interfaceDeclaringPackage.modle == msym;
831                boolean isInterfaceExportedFromAReadableModule =
832                        msym.visiblePackages.get(interfaceDeclaringPackage.fullname) == interfaceDeclaringPackage;
833                if (isInterfaceDeclaredInCurrentModule && !isInterfaceExportedFromAReadableModule) {
834                    // ok the interface is declared in this module. Let's check if it's exported
835                    boolean warn = true;
836                    for (ExportsDirective export : msym.exports) {
837                        if (interfaceDeclaringPackage == export.packge) {
838                            warn = false;
839                            break;
840                        }
841                    }
842                    if (warn) {
843                        for (UsesDirective uses : msym.uses) {
844                            if (provides.service == uses.service) {
845                                warn = false;
846                                break;
847                            }
848                        }
849                    }
850                    if (warn) {
851                        log.warning(tree.pos(), Warnings.ServiceProvidedButNotExportedOrUsed(provides.service));
852                    }
853                }
854            }
855        }
856    }
857
858    private Set<ModuleSymbol> allModules;
859
860    public Set<ModuleSymbol> allModules() {
861        Assert.checkNonNull(allModules);
862        return allModules;
863    }
864
865    private void setupAllModules(Collection<String> extraAddMods, Collection<String> extraLimitMods) {
866        Assert.checkNonNull(rootModules);
867        Assert.checkNull(allModules);
868
869        Set<ModuleSymbol> observable;
870
871        if (limitModsOpt == null && extraLimitMods.isEmpty()) {
872            observable = null;
873        } else {
874            Set<ModuleSymbol> limitMods = new HashSet<>();
875            if (limitModsOpt != null) {
876                for (String limit : limitModsOpt.split(",")) {
877                    limitMods.add(syms.enterModule(names.fromString(limit)));
878                }
879            }
880            for (String limit : extraLimitMods) {
881                limitMods.add(syms.enterModule(names.fromString(limit)));
882            }
883            observable = computeTransitiveClosure(limitMods, null);
884            observable.addAll(rootModules);
885        }
886
887        Predicate<ModuleSymbol> observablePred = sym -> observable == null || observable.contains(sym);
888        Predicate<ModuleSymbol> systemModulePred = sym -> (sym.flags() & Flags.SYSTEM_MODULE) != 0;
889        Set<ModuleSymbol> enabledRoot = new LinkedHashSet<>();
890
891        if (rootModules.contains(syms.unnamedModule)) {
892            ModuleSymbol javaSE = syms.getModule(java_se);
893            Predicate<ModuleSymbol> jdkModulePred;
894
895            if (javaSE != null && (observable == null || observable.contains(javaSE))) {
896                jdkModulePred = sym -> {
897                    sym.complete();
898                    return   !sym.name.startsWith(java_)
899                           && sym.exports.stream().anyMatch(e -> e.modules == null);
900                };
901                enabledRoot.add(javaSE);
902            } else {
903                jdkModulePred = sym -> true;
904            }
905
906            for (ModuleSymbol sym : new HashSet<>(syms.getAllModules())) {
907                if (systemModulePred.test(sym) && observablePred.test(sym) && jdkModulePred.test(sym)) {
908                    enabledRoot.add(sym);
909                }
910            }
911        }
912
913        enabledRoot.addAll(rootModules);
914
915        if (addModsOpt != null || !extraAddMods.isEmpty()) {
916            Set<String> fullAddMods = new HashSet<>();
917            fullAddMods.addAll(extraAddMods);
918
919            if (addModsOpt != null) {
920                fullAddMods.addAll(Arrays.asList(addModsOpt.split(",")));
921            }
922
923            for (String added : fullAddMods) {
924                Stream<ModuleSymbol> modules;
925                switch (added) {
926                    case ALL_SYSTEM:
927                        modules = syms.getAllModules()
928                                      .stream()
929                                      .filter(systemModulePred.and(observablePred));
930                        break;
931                    case ALL_MODULE_PATH:
932                        modules = syms.getAllModules()
933                                      .stream()
934                                      .filter(systemModulePred.negate().and(observablePred));
935                        break;
936                    default:
937                        modules = Stream.of(syms.enterModule(names.fromString(added)));
938                        break;
939                }
940                modules.forEach(sym -> {
941                    enabledRoot.add(sym);
942                    if (observable != null)
943                        observable.add(sym);
944                });
945            }
946        }
947
948        Set<ModuleSymbol> result = computeTransitiveClosure(enabledRoot, observable);
949
950        result.add(syms.unnamedModule);
951
952        allModules = result;
953    }
954
955    private Set<ModuleSymbol> computeTransitiveClosure(Iterable<? extends ModuleSymbol> base, Set<ModuleSymbol> observable) {
956        List<ModuleSymbol> todo = List.nil();
957
958        for (ModuleSymbol ms : base) {
959            todo = todo.prepend(ms);
960        }
961
962        Set<ModuleSymbol> result = new LinkedHashSet<>();
963        result.add(syms.java_base);
964
965        while (todo.nonEmpty()) {
966            ModuleSymbol current = todo.head;
967            todo = todo.tail;
968            if (observable != null && !observable.contains(current))
969                continue;
970            if (!result.add(current) || current == syms.unnamedModule || ((current.flags_field & Flags.AUTOMATIC_MODULE) != 0))
971                continue;
972            current.complete();
973            for (RequiresDirective rd : current.requires) {
974                todo = todo.prepend(rd.module);
975            }
976        }
977
978        return result;
979    }
980
981    public ModuleSymbol getObservableModule(Name name) {
982        ModuleSymbol mod = syms.getModule(name);
983
984        if (allModules().contains(mod)) {
985            return mod;
986        }
987
988        return null;
989    }
990
991    private Completer getUnnamedModuleCompleter() {
992        moduleFinder.findAllModules();
993        return new Symbol.Completer() {
994            @Override
995            public void complete(Symbol sym) throws CompletionFailure {
996                ModuleSymbol msym = (ModuleSymbol) sym;
997                Set<ModuleSymbol> allModules = allModules();
998                for (ModuleSymbol m : allModules) {
999                    m.complete();
1000                }
1001                initVisiblePackages(msym, allModules);
1002            }
1003
1004            @Override
1005            public String toString() {
1006                return "unnamedModule Completer";
1007            }
1008        };
1009    }
1010
1011    private final Map<ModuleSymbol, Set<ModuleSymbol>> requiresPublicCache = new HashMap<>();
1012
1013    private void completeModule(ModuleSymbol msym) {
1014        if (inInitModules) {
1015            msym.completer = sym -> completeModule(msym);
1016            return ;
1017        }
1018
1019        if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
1020            completeAutomaticModule(msym);
1021        }
1022
1023        Assert.checkNonNull(msym.requires);
1024
1025        initAddReads();
1026
1027        msym.requires = msym.requires.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));
1028
1029        List<RequiresDirective> requires = msym.requires;
1030        List<RequiresDirective> previous = null;
1031
1032        while (requires.nonEmpty()) {
1033            if (!allModules().contains(requires.head.module)) {
1034                Env<AttrContext> env = typeEnvs.get(msym);
1035                if (env != null) {
1036                    JavaFileObject origSource = log.useSource(env.toplevel.sourcefile);
1037                    try {
1038                        log.error(/*XXX*/env.tree, Errors.ModuleNotFound(requires.head.module));
1039                    } finally {
1040                        log.useSource(origSource);
1041                    }
1042                } else {
1043                    Assert.check((msym.flags() & Flags.AUTOMATIC_MODULE) == 0);
1044                }
1045                if (previous != null) {
1046                    previous.tail = requires.tail;
1047                } else {
1048                    msym.requires.tail = requires.tail;
1049                }
1050            } else {
1051                previous = requires;
1052            }
1053            requires = requires.tail;
1054        }
1055
1056        Set<ModuleSymbol> readable = new LinkedHashSet<>();
1057        Set<ModuleSymbol> requiresPublic = new HashSet<>();
1058
1059        for (RequiresDirective d : msym.requires) {
1060            d.module.complete();
1061            readable.add(d.module);
1062            Set<ModuleSymbol> s = retrieveRequiresPublic(d.module);
1063            Assert.checkNonNull(s, () -> "no entry in cache for " + d.module);
1064            readable.addAll(s);
1065            if (d.flags.contains(RequiresFlag.PUBLIC)) {
1066                requiresPublic.add(d.module);
1067                requiresPublic.addAll(s);
1068            }
1069        }
1070
1071        requiresPublicCache.put(msym, requiresPublic);
1072        initVisiblePackages(msym, readable);
1073        for (ExportsDirective d: msym.exports) {
1074            d.packge.modle = msym;
1075        }
1076
1077    }
1078
1079    private Set<ModuleSymbol> retrieveRequiresPublic(ModuleSymbol msym) {
1080        Set<ModuleSymbol> requiresPublic = requiresPublicCache.get(msym);
1081
1082        if (requiresPublic == null) {
1083            //the module graph may contain cycles involving automatic modules or -XaddReads edges
1084            requiresPublic = new HashSet<>();
1085
1086            Set<ModuleSymbol> seen = new HashSet<>();
1087            List<ModuleSymbol> todo = List.of(msym);
1088
1089            while (todo.nonEmpty()) {
1090                ModuleSymbol current = todo.head;
1091                todo = todo.tail;
1092                if (!seen.add(current))
1093                    continue;
1094                requiresPublic.add(current);
1095                current.complete();
1096                Iterable<? extends RequiresDirective> requires;
1097                if (current != syms.unnamedModule) {
1098                    Assert.checkNonNull(current.requires, () -> current + ".requires == null; " + msym);
1099                    requires = current.requires;
1100                    for (RequiresDirective rd : requires) {
1101                        if (rd.isPublic())
1102                            todo = todo.prepend(rd.module);
1103                    }
1104                } else {
1105                    for (ModuleSymbol mod : allModules()) {
1106                        todo = todo.prepend(mod);
1107                    }
1108                }
1109            }
1110
1111            requiresPublic.remove(msym);
1112        }
1113
1114        return requiresPublic;
1115    }
1116
1117    private void initVisiblePackages(ModuleSymbol msym, Collection<ModuleSymbol> readable) {
1118        initAddExports();
1119
1120        msym.visiblePackages = new LinkedHashMap<>();
1121
1122        Map<Name, ModuleSymbol> seen = new HashMap<>();
1123
1124        for (ModuleSymbol rm : readable) {
1125            if (rm == syms.unnamedModule)
1126                continue;
1127            addVisiblePackages(msym, seen, rm, rm.exports);
1128        }
1129
1130        for (Entry<ModuleSymbol, Set<ExportsDirective>> addExportsEntry : addExports.entrySet())
1131            addVisiblePackages(msym, seen, addExportsEntry.getKey(), addExportsEntry.getValue());
1132    }
1133
1134    private void addVisiblePackages(ModuleSymbol msym,
1135                                    Map<Name, ModuleSymbol> seenPackages,
1136                                    ModuleSymbol exportsFrom,
1137                                    Collection<ExportsDirective> exports) {
1138        for (ExportsDirective d : exports) {
1139            if (d.modules == null || d.modules.contains(msym)) {
1140                Name packageName = d.packge.fullname;
1141                ModuleSymbol previousModule = seenPackages.get(packageName);
1142
1143                if (previousModule != null && previousModule != exportsFrom) {
1144                    Env<AttrContext> env = typeEnvs.get(msym);
1145                    JavaFileObject origSource = env != null ? log.useSource(env.toplevel.sourcefile)
1146                                                            : null;
1147                    DiagnosticPosition pos = env != null ? env.tree.pos() : null;
1148                    try {
1149                        log.error(pos, Errors.PackageClashFromRequires(msym, packageName,
1150                                                                      previousModule, exportsFrom));
1151                    } finally {
1152                        if (env != null)
1153                            log.useSource(origSource);
1154                    }
1155                    continue;
1156                }
1157
1158                seenPackages.put(packageName, exportsFrom);
1159                msym.visiblePackages.put(d.packge.fullname, d.packge);
1160            }
1161        }
1162    }
1163
1164    private void initAddExports() {
1165        if (addExports != null)
1166            return;
1167
1168        addExports = new LinkedHashMap<>();
1169
1170        if (addExportsOpt == null)
1171            return;
1172
1173//        System.err.println("Modules.addExports:\n   " + addExportsOpt.replace("\0", "\n   "));
1174
1175        Pattern ep = Pattern.compile("([^/]+)/([^=]+)=(.*)");
1176        for (String s: addExportsOpt.split("\0+")) {
1177            if (s.isEmpty())
1178                continue;
1179            Matcher em = ep.matcher(s);
1180            if (!em.matches()) {
1181                continue;
1182            }
1183
1184            // Terminology comes from
1185            //  -XaddExports:module/package=target,...
1186            // Compare to
1187            //  module module { exports package to target, ... }
1188            String moduleName = em.group(1);
1189            String packageName = em.group(2);
1190            String targetNames = em.group(3);
1191
1192            ModuleSymbol msym = syms.enterModule(names.fromString(moduleName));
1193            PackageSymbol p = syms.enterPackage(msym, names.fromString(packageName));
1194            p.modle = msym;  // TODO: do we need this?
1195
1196            List<ModuleSymbol> targetModules = List.nil();
1197            for (String toModule : targetNames.split("[ ,]+")) {
1198                ModuleSymbol m;
1199                if (toModule.equals("ALL-UNNAMED")) {
1200                    m = syms.unnamedModule;
1201                } else {
1202                    if (!SourceVersion.isName(toModule)) {
1203                        // TODO: error: invalid module name
1204                        continue;
1205                    }
1206                    m = syms.enterModule(names.fromString(toModule));
1207                }
1208                targetModules = targetModules.prepend(m);
1209            }
1210
1211            Set<ExportsDirective> extra = addExports.computeIfAbsent(msym, _x -> new LinkedHashSet<>());
1212            ExportsDirective d = new ExportsDirective(p, targetModules);
1213            extra.add(d);
1214        }
1215    }
1216
1217    private void initAddReads() {
1218        if (addReads != null)
1219            return;
1220
1221        addReads = new LinkedHashMap<>();
1222
1223        if (addReadsOpt == null)
1224            return;
1225
1226//        System.err.println("Modules.addReads:\n   " + addReadsOpt.replace("\0", "\n   "));
1227
1228        Pattern rp = Pattern.compile("([^=]+)=(.*)");
1229        for (String s : addReadsOpt.split("\0+")) {
1230            if (s.isEmpty())
1231                continue;
1232            Matcher rm = rp.matcher(s);
1233            if (!rm.matches()) {
1234                continue;
1235            }
1236
1237            // Terminology comes from
1238            //  -XaddReads:target-module=source-module,...
1239            // Compare to
1240            //  module target-module { requires source-module; ... }
1241            String targetName = rm.group(1);
1242            String sources = rm.group(2);
1243
1244            ModuleSymbol msym = syms.enterModule(names.fromString(targetName));
1245            for (String source : sources.split("[ ,]+")) {
1246                ModuleSymbol sourceModule;
1247                if (source.equals("ALL-UNNAMED")) {
1248                    sourceModule = syms.unnamedModule;
1249                } else {
1250                    if (!SourceVersion.isName(source)) {
1251                        // TODO: error: invalid module name
1252                        continue;
1253                    }
1254                    sourceModule = syms.enterModule(names.fromString(source));
1255                }
1256                addReads.computeIfAbsent(msym, m -> new HashSet<>())
1257                        .add(new RequiresDirective(sourceModule, EnumSet.of(RequiresFlag.EXTRA)));
1258            }
1259        }
1260    }
1261
1262    private void checkCyclicDependencies(JCModuleDecl mod) {
1263        for (JCDirective d : mod.directives) {
1264            JCRequires rd;
1265            if (!d.hasTag(Tag.REQUIRES) || (rd = (JCRequires) d).directive == null)
1266                continue;
1267            Set<ModuleSymbol> nonSyntheticDeps = new HashSet<>();
1268            List<ModuleSymbol> queue = List.of(rd.directive.module);
1269            while (queue.nonEmpty()) {
1270                ModuleSymbol current = queue.head;
1271                queue = queue.tail;
1272                if (!nonSyntheticDeps.add(current))
1273                    continue;
1274                current.complete();
1275                if ((current.flags() & Flags.ACYCLIC) != 0)
1276                    continue;
1277                Assert.checkNonNull(current.requires, () -> current.toString());
1278                for (RequiresDirective dep : current.requires) {
1279                    if (!dep.flags.contains(RequiresFlag.EXTRA))
1280                        queue = queue.prepend(dep.module);
1281                }
1282            }
1283            if (nonSyntheticDeps.contains(mod.sym)) {
1284                log.error(rd.moduleName.pos(), Errors.CyclicRequires(rd.directive.module));
1285            }
1286            mod.sym.flags_field |= Flags.ACYCLIC;
1287        }
1288    }
1289
1290    // DEBUG
1291    private String toString(ModuleSymbol msym) {
1292        return msym.name + "["
1293                + "kind:" + msym.kind + ";"
1294                + "locn:" + toString(msym.sourceLocation) + "," + toString(msym.classLocation) + ";"
1295                + "info:" + toString(msym.module_info.sourcefile) + ","
1296                            + toString(msym.module_info.classfile) + ","
1297                            + msym.module_info.completer
1298                + "]";
1299    }
1300
1301    // DEBUG
1302    String toString(Location locn) {
1303        return (locn == null) ? "--" : locn.getName();
1304    }
1305
1306    // DEBUG
1307    String toString(JavaFileObject fo) {
1308        return (fo == null) ? "--" : fo.getName();
1309    }
1310
1311    public void newRound() {
1312        rootModules = null;
1313        allModules = null;
1314    }
1315}
1316