1 /*

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

    27 package com.sun.tools.javac.comp;

    28 

    29 import java.io.IOException;

    30 import java.util.Arrays;

    31 import java.util.Collection;

    32 import java.util.Collections;

    33 import java.util.EnumSet;

    34 import java.util.HashMap;

    35 import java.util.HashSet;

    36 import java.util.LinkedHashMap;

    37 import java.util.LinkedHashSet;

    38 import java.util.Map;

    39 import java.util.Set;

    40 import java.util.function.Consumer;

    41 import java.util.function.Predicate;

    42 import java.util.regex.Matcher;

    43 import java.util.regex.Pattern;

    44 import java.util.stream.Collectors;

    45 import java.util.stream.Stream;

    46 

    47 import javax.lang.model.SourceVersion;

    48 import javax.tools.JavaFileManager;

    49 import javax.tools.JavaFileManager.Location;

    50 import javax.tools.JavaFileObject;

    51 import javax.tools.JavaFileObject.Kind;

    52 import javax.tools.StandardLocation;

    53 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   106 

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

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

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

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

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

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

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

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

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

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

   117 

   118 /**

   119  *  TODO: fill in

   120  *

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

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

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

   124  *  deletion without notice.</b>

   125  */

   126 public class Modules extends JCTree.Visitor {

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

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

   129 

   130     private final Log log;

   131     private final Names names;

   132     private final Symtab syms;

   133     private final Attr attr;

   134     private final Check chk;

   135     private final DeferredLintHandler deferredLintHandler;

   136     private final TypeEnvs typeEnvs;

   137     private final Types types;

   138     private final JavaFileManager fileManager;

   139     private final ModuleFinder moduleFinder;

   140     private final Source source;

   141     private final boolean allowModules;

   142     private final boolean allowAccessIntoSystem;

   143 

   144     public final boolean multiModuleMode;

   145 

   146     private final Name java_se;

   147     private final Name java_;

   148 

   149     ModuleSymbol defaultModule;

   150 

   151     private final String addExportsOpt;

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

   153     private final String addReadsOpt;

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

   155     private final String addModsOpt;

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

   157     private final String limitModsOpt;

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

   159     private final String moduleVersionOpt;

   160 

   161     private final boolean lintOptions;

   162 

   163     private Set<ModuleSymbol> rootModules = null;

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

   165 

   166     public PackageNameFinder findPackageInFile;

   167 

   168     public static Modules instance(Context context) {

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

   170         if (instance == null)

   171             instance = new Modules(context);

   172         return instance;

   173     }

   174 

   175     protected Modules(Context context) {

   176         context.put(Modules.class, this);

   177         log = Log.instance(context);

   178         names = Names.instance(context);

   179         syms = Symtab.instance(context);

   180         attr = Attr.instance(context);

   181         chk = Check.instance(context);

   182         deferredLintHandler = DeferredLintHandler.instance(context);

   183         typeEnvs = TypeEnvs.instance(context);

   184         moduleFinder = ModuleFinder.instance(context);

   185         types = Types.instance(context);

   186         fileManager = context.get(JavaFileManager.class);

   187         source = Source.instance(context);

   188         allowModules = source.allowModules();

   189         Options options = Options.instance(context);

   190 

   191         allowAccessIntoSystem = options.isUnset(Option.RELEASE);

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

   193 

   194         multiModuleMode = fileManager.hasLocation(StandardLocation.MODULE_SOURCE_PATH);

   195         ClassWriter classWriter = ClassWriter.instance(context);

   196         classWriter.multiModuleMode = multiModuleMode;

   197         JNIWriter jniWriter = JNIWriter.instance(context);

   198         jniWriter.multiModuleMode = multiModuleMode;

   199 

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

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

   202 

   203         addExportsOpt = options.get(Option.ADD_EXPORTS);

   204         addReadsOpt = options.get(Option.ADD_READS);

   205         addModsOpt = options.get(Option.ADD_MODULES);

   206         limitModsOpt = options.get(Option.LIMIT_MODULES);

   207         moduleVersionOpt = options.get(Option.MODULE_VERSION);

   208     }

   209     //where

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

   211 

   212     int depth = -1;

   213 

   214     public void addExtraAddModules(String... extras) {

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

   216     }

   217 

   218     boolean inInitModules;

   219     public void initModules(List<JCCompilationUnit> trees) {

   220         Assert.check(!inInitModules);

   221         try {

   222             inInitModules = true;

   223             Assert.checkNull(rootModules);

   224             enter(trees, modules -> {

   225                 Assert.checkNull(rootModules);

   226                 Assert.checkNull(allModules);

   227                 this.rootModules = modules;

   228                 setupAllModules(); //initialize the module graph

   229                 Assert.checkNonNull(allModules);

   230                 inInitModules = false;

   231             }, null);

   232         } finally {

   233             inInitModules = false;

   234         }

   235     }

   236 

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

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

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

   240     }

   241 

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

   243         if (!allowModules) {

   244             for (JCCompilationUnit tree: trees) {

   245                 tree.modle = syms.noModule;

   246             }

   247             defaultModule = syms.noModule;

   248             return true;

   249         }

   250 

   251         int startErrors = log.nerrors;

   252 

   253         depth++;

   254         try {

   255             // scan trees for module defs

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

   257 

   258             setCompilationUnitModules(trees, roots, c);

   259 

   260             init.accept(roots);

   261 

   262             for (ModuleSymbol msym: roots) {

   263                 msym.complete();

   264             }

   265         } catch (CompletionFailure ex) {

   266             chk.completionError(null, ex);

   267         } finally {

   268             depth--;

   269         }

   270 

   271         return (log.nerrors == startErrors);

   272     }

   273 

   274     public Completer getCompleter() {

   275         return mainCompleter;

   276     }

   277 

   278     public ModuleSymbol getDefaultModule() {

   279         return defaultModule;

   280     }

   281 

   282     public boolean modulesInitialized() {

   283         return allModules != null;

   284     }

   285 

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

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

   288         for (JCCompilationUnit tree : trees) {

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

   290             try {

   291                 enterModule(tree, c, modules);

   292             } finally {

   293                 log.useSource(prev);

   294             }

   295         }

   296         return modules;

   297     }

   298 

   299 

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

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

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

   303         if (isModuleDecl) {

   304             JCModuleDecl decl = toplevel.getModuleDecl();

   305             if (!isModuleInfo) {

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

   307             }

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

   309             ModuleSymbol sym;

   310             if (c != null) {

   311                 sym = (ModuleSymbol) c.owner;

   312                 Assert.checkNonNull(sym.name);

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

   314                 if (sym.name != treeName) {

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

   316                 }

   317             } else {

   318                 sym = syms.enterModule(name);

   319                 if (sym.module_info.sourcefile != null && sym.module_info.sourcefile != toplevel.sourcefile) {

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

   321                     return;

   322                 }

   323             }

   324             sym.completer = getSourceCompleter(toplevel);

   325             sym.module_info.sourcefile = toplevel.sourcefile;

   326             decl.sym = sym;

   327 

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

   329                 modules.add(sym);

   330             } else {

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

   332             }

   333 

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

   335 

   336             provisionalEnv.toplevel = toplevel;

   337             typeEnvs.put(sym, provisionalEnv);

   338         } else if (isModuleInfo) {

   339             if (multiModuleMode) {

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

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

   342             }

   343         }

   344     }

   345 

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

   347         // update the module for each compilation unit

   348         if (multiModuleMode) {

   349             checkNoAllModulePath();

   350             for (JCCompilationUnit tree: trees) {

   351                 if (tree.defs.isEmpty()) {

   352                     tree.modle = syms.unnamedModule;

   353                     continue;

   354                 }

   355 

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

   357                 try {

   358                     Location msplocn = getModuleLocation(tree);

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

   360                             fileManager.getLocationForModule(StandardLocation.PATCH_MODULE_PATH,

   361                                                              tree.sourcefile) :

   362                             null;

   363 

   364                     if (plocn != null) {

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

   366                         ModuleSymbol msym = moduleFinder.findModule(name);

   367                         tree.modle = msym;

   368                         rootModules.add(msym);

   369 

   370                         if (msplocn != null) {

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

   372                             if (name != mspname) {

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

   374                             }

   375                         }

   376                     } else if (msplocn != null) {

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

   378                             JavaFileObject canonical =

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

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

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

   382                             }

   383                         }

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

   385                         ModuleSymbol msym;

   386                         JCModuleDecl decl = tree.getModuleDecl();

   387                         if (decl != null) {

   388                             msym = decl.sym;

   389                             if (msym.name != name) {

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

   391                             }

   392                         } else {

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

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

   395                             }

   396                             msym = syms.enterModule(name);

   397                         }

   398                         if (msym.sourceLocation == null) {

   399                             msym.sourceLocation = msplocn;

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

   401                                 msym.patchLocation = fileManager.getLocationForModule(

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

   403                             }

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

   405                                 Location outputLocn = fileManager.getLocationForModule(

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

   407                                 if (msym.patchLocation == null) {

   408                                     msym.classLocation = outputLocn;

   409                                 } else {

   410                                     msym.patchOutputLocation = outputLocn;

   411                                 }

   412                             }

   413                         }

   414                         tree.modle = msym;

   415                         rootModules.add(msym);

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

   417                         tree.modle = syms.unnamedModule;

   418                     } else {

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

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

   421                         } else {

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

   423                         }

   424                         tree.modle = syms.errModule;

   425                     }

   426                 } catch (IOException e) {

   427                     throw new Error(e); // FIXME

   428                 } finally {

   429                     log.useSource(prev);

   430                 }

   431             }

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

   433                 syms.unnamedModule.completer = getUnnamedModuleCompleter();

   434                 syms.unnamedModule.sourceLocation = StandardLocation.SOURCE_PATH;

   435                 syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

   436             }

   437             defaultModule = syms.unnamedModule;

   438         } else {

   439             ModuleSymbol module = null;

   440             if (defaultModule == null) {

   441                 String moduleOverride = singleModuleOverride(trees);

   442                 switch (rootModules.size()) {

   443                     case 0:

   444                         defaultModule = moduleFinder.findSingleModule();

   445                         if (defaultModule == syms.unnamedModule) {

   446                             if (moduleOverride != null) {

   447                                 checkNoAllModulePath();

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

   449                                 defaultModule.patchOutputLocation = StandardLocation.CLASS_OUTPUT;

   450                             } else {

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

   452                                 // i.e. body of unnamedModuleCompleter

   453                                 defaultModule.completer = getUnnamedModuleCompleter();

   454                                 defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

   455                                 defaultModule.classLocation = StandardLocation.CLASS_PATH;

   456                             }

   457                         } else {

   458                             checkNoAllModulePath();

   459                             defaultModule.complete();

   460                             // Question: why not do completeModule here?

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

   462                             defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

   463                         }

   464                         rootModules.add(defaultModule);

   465                         break;

   466                     case 1:

   467                         checkNoAllModulePath();

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

   469                         defaultModule.sourceLocation = StandardLocation.SOURCE_PATH;

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

   471                             try {

   472                                 defaultModule.patchLocation = fileManager.getLocationForModule(

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

   474                             } catch (IOException ex) {

   475                                 throw new Error(ex);

   476                             }

   477                         }

   478                         if (defaultModule.patchLocation == null) {

   479                             defaultModule.classLocation = StandardLocation.CLASS_OUTPUT;

   480                         } else {

   481                             defaultModule.patchOutputLocation = StandardLocation.CLASS_OUTPUT;

   482                         }

   483                         break;

   484                     default:

   485                         Assert.error("too many modules");

   486                 }

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

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

   489                 module.complete();

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

   491             } else {

   492                 Assert.check(rootModules.isEmpty());

   493                 String moduleOverride = singleModuleOverride(trees);

   494                 if (moduleOverride != null) {

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

   496                 } else {

   497                     module = defaultModule;

   498                 }

   499                 rootModules.add(module);

   500             }

   501 

   502             if (defaultModule != syms.unnamedModule) {

   503                 syms.unnamedModule.completer = getUnnamedModuleCompleter();

   504                 syms.unnamedModule.classLocation = StandardLocation.CLASS_PATH;

   505             }

   506 

   507             if (module == null) {

   508                 module = defaultModule;

   509             }

   510 

   511             for (JCCompilationUnit tree : trees) {

   512                 if (defaultModule != syms.unnamedModule

   513                         && defaultModule.sourceLocation == StandardLocation.SOURCE_PATH

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

   515                     checkSourceLocation(tree, module);

   516                 }

   517                 tree.modle = module;

   518             }

   519         }

   520     }

   521 

   522     private void checkSourceLocation(JCCompilationUnit tree, ModuleSymbol msym) {

   523         try {

   524             JavaFileObject fo = tree.sourcefile;

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

   526                 return;

   527             }

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

   529                 return;

   530             }

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

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

   533                     return;

   534                 }

   535             } else {

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

   537                     return;

   538                 }

   539             }

   540         } catch (IOException e) {

   541             throw new Error(e);

   542         }

   543 

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

   545         try {

   546             log.error(tree.pos(), Errors.FileSbOnSourceOrPatchPathForModule);

   547         } finally {

   548             log.useSource(prev);

   549         }

   550     }

   551 

   552     private String singleModuleOverride(List<JCCompilationUnit> trees) {

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

   554             return null;

   555         }

   556 

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

   558         for (JCCompilationUnit tree : trees) {

   559             JavaFileObject fo = tree.sourcefile;

   560 

   561             try {

   562                 Location loc =

   563                         fileManager.getLocationForModule(StandardLocation.PATCH_MODULE_PATH, fo);

   564 

   565                 if (loc != null) {

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

   567                 }

   568             } catch (IOException ex) {

   569                 throw new Error(ex);

   570             }

   571         }

   572 

   573         switch (override.size()) {

   574             case 0: return null;

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

   576             default:

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

   578                 return null;

   579         }

   580     }

   581 

   582     /**

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

   584      * or source output directory which contains a given CompilationUnit.

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

   586      * will be checked instead.

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

   588      * @param tree the compilation unit tree

   589      * @return the location for the enclosing module

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

   591      */

   592     private Location getModuleLocation(JCCompilationUnit tree) throws IOException {

   593         JavaFileObject fo = tree.sourcefile;

   594 

   595         Location loc =

   596                 fileManager.getLocationForModule(StandardLocation.MODULE_SOURCE_PATH, fo);

   597         if (loc == null) {

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

   599                     StandardLocation.SOURCE_OUTPUT : StandardLocation.CLASS_OUTPUT;

   600             loc =

   601                 fileManager.getLocationForModule(sourceOutput, fo);

   602         }

   603         return loc;

   604     }

   605 

   606     private void checkNoAllModulePath() {

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

   608             log.error(Errors.AddmodsAllModulePathInvalid);

   609         }

   610     }

   611 

   612     private final Completer mainCompleter = new Completer() {

   613         @Override

   614         public void complete(Symbol sym) throws CompletionFailure {

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

   616 

   617             if (msym.kind == ERR) {

   618                 //make sure the module is initialized:

   619                 msym.directives = List.nil();

   620                 msym.exports = List.nil();

   621                 msym.provides = List.nil();

   622                 msym.requires = List.nil();

   623                 msym.uses = List.nil();

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

   625                 setupAutomaticModule(msym);

   626             } else {

   627                 msym.module_info.complete();

   628             }

   629 

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

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

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

   633             // which will call completeModule.

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

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

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

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

   638                 completeModule(msym);

   639             }

   640         }

   641 

   642         @Override

   643         public String toString() {

   644             return "mainCompleter";

   645         }

   646     };

   647 

   648     private void setupAutomaticModule(ModuleSymbol msym) throws CompletionFailure {

   649         try {

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

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

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

   653 

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

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

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

   657                 if (seenPackages.add(pack)) {

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

   659                     //TODO: opens?

   660                     directives.add(d);

   661                     exports.add(d);

   662                 }

   663             }

   664 

   665             msym.exports = exports.toList();

   666             msym.provides = List.nil();

   667             msym.requires = List.nil();

   668             msym.uses = List.nil();

   669             msym.directives = directives.toList();

   670             msym.flags_field |= Flags.ACYCLIC;

   671         } catch (IOException ex) {

   672             throw new IllegalStateException(ex);

   673         }

   674     }

   675 

   676     private void completeAutomaticModule(ModuleSymbol msym) throws CompletionFailure {

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

   678 

   679         directives.addAll(msym.directives);

   680 

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

   682 

   683         for (ModuleSymbol ms : allModules()) {

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

   685                 continue;

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

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

   688             RequiresDirective d = new RequiresDirective(ms, flags);

   689             directives.add(d);

   690             requires.add(d);

   691         }

   692 

   693         RequiresDirective requiresUnnamed = new RequiresDirective(syms.unnamedModule);

   694         directives.add(requiresUnnamed);

   695         requires.add(requiresUnnamed);

   696 

   697         msym.requires = requires.toList();

   698         msym.directives = directives.toList();

   699     }

   700 

   701     private Completer getSourceCompleter(JCCompilationUnit tree) {

   702         return new Completer() {

   703             @Override

   704             public void complete(Symbol sym) throws CompletionFailure {

   705                 ModuleSymbol msym = (ModuleSymbol) sym;

   706                 msym.flags_field |= UNATTRIBUTED;

   707                 ModuleVisitor v = new ModuleVisitor();

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

   709                 JCModuleDecl moduleDecl = tree.getModuleDecl();

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

   711 

   712                 try {

   713                     moduleDecl.accept(v);

   714                     completeModule(msym);

   715                     checkCyclicDependencies(moduleDecl);

   716                 } finally {

   717                     log.useSource(prev);

   718                     deferredLintHandler.setPos(prevLintPos);

   719                     msym.flags_field &= ~UNATTRIBUTED;

   720                 }

   721             }

   722 

   723             @Override

   724             public String toString() {

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

   726             }

   727 

   728         };

   729     }

   730 

   731     public boolean isRootModule(ModuleSymbol module) {

   732         Assert.checkNonNull(rootModules);

   733         return rootModules.contains(module);

   734     }

   735 

   736     public Set<ModuleSymbol> getRootModules() {

   737         Assert.checkNonNull(rootModules);

   738         return rootModules;

   739     }

   740 

   741     class ModuleVisitor extends JCTree.Visitor {

   742         private ModuleSymbol sym;

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

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

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

   746 

   747         @Override

   748         public void visitModuleDef(JCModuleDecl tree) {

   749             sym = Assert.checkNonNull(tree.sym);

   750 

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

   752                 sym.flags.add(ModuleFlags.OPEN);

   753             }

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

   755 

   756             sym.requires = List.nil();

   757             sym.exports = List.nil();

   758             sym.opens = List.nil();

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

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

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

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

   763             ensureJavaBase();

   764         }

   765 

   766         @Override

   767         public void visitRequires(JCRequires tree) {

   768             ModuleSymbol msym = lookupModule(tree.moduleName);

   769             if (msym.kind != MDL) {

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

   771                 warnedMissing.add(msym);

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

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

   774             } else {

   775                 allRequires.add(msym);

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

   777                 if (tree.isTransitive)

   778                     flags.add(RequiresFlag.TRANSITIVE);

   779                 if (tree.isStaticPhase)

   780                     flags.add(RequiresFlag.STATIC_PHASE);

   781                 RequiresDirective d = new RequiresDirective(msym, flags);

   782                 tree.directive = d;

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

   784             }

   785         }

   786 

   787         @Override

   788         public void visitExports(JCExports tree) {

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

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

   791             attr.setPackageSymbols(tree.qualid, packge);

   792 

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

   794             for (ExportsDirective d : exportsForPackage) {

   795                 reportExportsConflict(tree, packge);

   796             }

   797 

   798             List<ModuleSymbol> toModules = null;

   799             if (tree.moduleNames != null) {

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

   801                 for (JCExpression n: tree.moduleNames) {

   802                     ModuleSymbol msym = lookupModule(n);

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

   804                     for (ExportsDirective d : exportsForPackage) {

   805                         checkDuplicateExportsToModule(n, msym, d);

   806                     }

   807                     if (!to.add(msym)) {

   808                         reportExportsConflictToModule(n, msym);

   809                     }

   810                 }

   811                 toModules = List.from(to);

   812             }

   813 

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

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

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

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

   818                 tree.directive = d;

   819 

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

   821             }

   822         }

   823 

   824         private void reportExportsConflict(JCExports tree, PackageSymbol packge) {

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

   826         }

   827 

   828         private void checkDuplicateExportsToModule(JCExpression name, ModuleSymbol msym,

   829                 ExportsDirective d) {

   830             if (d.modules != null) {

   831                 for (ModuleSymbol other : d.modules) {

   832                     if (msym == other) {

   833                         reportExportsConflictToModule(name, msym);

   834                     }

   835                 }

   836             }

   837         }

   838 

   839         private void reportExportsConflictToModule(JCExpression name, ModuleSymbol msym) {

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

   841         }

   842 

   843         @Override

   844         public void visitOpens(JCOpens tree) {

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

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

   847             attr.setPackageSymbols(tree.qualid, packge);

   848 

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

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

   851             }

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

   853             for (OpensDirective d : opensForPackage) {

   854                 reportOpensConflict(tree, packge);

   855             }

   856 

   857             List<ModuleSymbol> toModules = null;

   858             if (tree.moduleNames != null) {

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

   860                 for (JCExpression n: tree.moduleNames) {

   861                     ModuleSymbol msym = lookupModule(n);

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

   863                     for (OpensDirective d : opensForPackage) {

   864                         checkDuplicateOpensToModule(n, msym, d);

   865                     }

   866                     if (!to.add(msym)) {

   867                         reportOpensConflictToModule(n, msym);

   868                     }

   869                 }

   870                 toModules = List.from(to);

   871             }

   872 

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

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

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

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

   877                 tree.directive = d;

   878 

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

   880             }

   881         }

   882 

   883         private void reportOpensConflict(JCOpens tree, PackageSymbol packge) {

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

   885         }

   886 

   887         private void checkDuplicateOpensToModule(JCExpression name, ModuleSymbol msym,

   888                 OpensDirective d) {

   889             if (d.modules != null) {

   890                 for (ModuleSymbol other : d.modules) {

   891                     if (msym == other) {

   892                         reportOpensConflictToModule(name, msym);

   893                     }

   894                 }

   895             }

   896         }

   897 

   898         private void reportOpensConflictToModule(JCExpression name, ModuleSymbol msym) {

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

   900         }

   901 

   902         @Override

   903         public void visitProvides(JCProvides tree) { }

   904 

   905         @Override

   906         public void visitUses(JCUses tree) { }

   907 

   908         private void ensureJavaBase() {

   909             if (sym.name == names.java_base)

   910                 return;

   911 

   912             for (RequiresDirective d: sym.requires) {

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

   914                     return;

   915             }

   916 

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

   918             Directive.RequiresDirective d =

   919                     new Directive.RequiresDirective(java_base,

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

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

   922         }

   923 

   924         private ModuleSymbol lookupModule(JCExpression moduleName) {

   925             Name name = TreeInfo.fullName(moduleName);

   926             ModuleSymbol msym = moduleFinder.findModule(name);

   927             TreeInfo.setSymbol(moduleName, msym);

   928             return msym;

   929         }

   930     }

   931 

   932     public Completer getUsesProvidesCompleter() {

   933         return sym -> {

   934             ModuleSymbol msym = (ModuleSymbol) sym;

   935 

   936             msym.complete();

   937 

   938             Env<AttrContext> env = typeEnvs.get(msym);

   939             UsesProvidesVisitor v = new UsesProvidesVisitor(msym, env);

   940             JavaFileObject prev = log.useSource(env.toplevel.sourcefile);

   941             JCModuleDecl decl = env.toplevel.getModuleDecl();

   942             DiagnosticPosition prevLintPos = deferredLintHandler.setPos(decl.pos());

   943 

   944             try {

   945                 decl.accept(v);

   946             } finally {

   947                 log.useSource(prev);

   948                 deferredLintHandler.setPos(prevLintPos);

   949             }

   950         };

   951     }

   952 

   953     class UsesProvidesVisitor extends JCTree.Visitor {

   954         private final ModuleSymbol msym;

   955         private final Env<AttrContext> env;

   956 

   957         private final Set<ClassSymbol> allUses = new HashSet<>();

   958         private final Map<ClassSymbol, Set<ClassSymbol>> allProvides = new HashMap<>();

   959 

   960         public UsesProvidesVisitor(ModuleSymbol msym, Env<AttrContext> env) {

   961             this.msym = msym;

   962             this.env = env;

   963         }

   964 

   965         @Override @SuppressWarnings("unchecked")

   966         public void visitModuleDef(JCModuleDecl tree) {

   967             msym.directives = List.nil();

   968             msym.provides = List.nil();

   969             msym.uses = List.nil();

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

   971             msym.directives = msym.directives.reverse();

   972             msym.provides = msym.provides.reverse();

   973             msym.uses = msym.uses.reverse();

   974 

   975             if (msym.requires.nonEmpty() && msym.requires.head.flags.contains(RequiresFlag.MANDATED))

   976                 msym.directives = msym.directives.prepend(msym.requires.head);

   977 

   978             msym.directives = msym.directives.appendList(List.from(addReads.getOrDefault(msym, Collections.emptySet())));

   979 

   980             checkForCorrectness();

   981         }

   982 

   983         @Override

   984         public void visitExports(JCExports tree) {

   985             Iterable<Symbol> packageContent = tree.directive.packge.members().getSymbols();

   986             List<JavaFileObject> filesToCheck = List.nil();

   987             boolean packageNotEmpty = false;

   988             for (Symbol sym : packageContent) {

   989                 if (sym.kind != Kinds.Kind.TYP)

   990                     continue;

   991                 ClassSymbol csym = (ClassSymbol) sym;

   992                 if (sym.completer.isTerminal() ||

   993                     csym.classfile.getKind() == Kind.CLASS) {

   994                     packageNotEmpty = true;

   995                     filesToCheck = List.nil();

   996                     break;

   997                 }

   998                 if (csym.classfile.getKind() == Kind.SOURCE) {

   999                     filesToCheck = filesToCheck.prepend(csym.classfile);

  1000                 }

  1001             }

  1002             for (JavaFileObject jfo : filesToCheck) {

  1003                 if (findPackageInFile.findPackageNameOf(jfo) == tree.directive.packge.fullname) {

  1004                     packageNotEmpty = true;

  1005                     break;

  1006                 }

  1007             }

  1008             if (!packageNotEmpty) {

  1009                 log.error(tree.qualid.pos(), Errors.PackageEmptyOrNotFound(tree.directive.packge));

  1010             }

  1011             msym.directives = msym.directives.prepend(tree.directive);

  1012         }

  1013 

  1014         @Override

  1015         public void visitOpens(JCOpens tree) {

  1016             chk.checkPackageExistsForOpens(tree.qualid, tree.directive.packge);

  1017             msym.directives = msym.directives.prepend(tree.directive);

  1018         }

  1019 

  1020         MethodSymbol noArgsConstructor(ClassSymbol tsym) {

  1021             for (Symbol sym : tsym.members().getSymbolsByName(names.init)) {

  1022                 MethodSymbol mSym = (MethodSymbol)sym;

  1023                 if (mSym.params().isEmpty()) {

  1024                     return mSym;

  1025                 }

  1026             }

  1027             return null;

  1028         }

  1029 

  1030         MethodSymbol factoryMethod(ClassSymbol tsym) {

  1031             for (Symbol sym : tsym.members().getSymbolsByName(names.provider, sym -> sym.kind == MTH)) {

  1032                 MethodSymbol mSym = (MethodSymbol)sym;

  1033                 if (mSym.isStatic() && (mSym.flags() & Flags.PUBLIC) != 0 && mSym.params().isEmpty()) {

  1034                     return mSym;

  1035                 }

  1036             }

  1037             return null;

  1038         }

  1039 

  1040         Map<Directive.ProvidesDirective, JCProvides> directiveToTreeMap = new HashMap<>();

  1041 

  1042         @Override

  1043         public void visitProvides(JCProvides tree) {

  1044             Type st = attr.attribType(tree.serviceName, env, syms.objectType);

  1045             ClassSymbol service = (ClassSymbol) st.tsym;

  1046             if (allProvides.containsKey(service)) {

  1047                 log.error(tree.serviceName.pos(), Errors.RepeatedProvidesForService(service));

  1048             }

  1049             ListBuffer<ClassSymbol> impls = new ListBuffer<>();

  1050             for (JCExpression implName : tree.implNames) {

  1051                 Type it;

  1052                 boolean prevVisitingServiceImplementation = env.info.visitingServiceImplementation;

  1053                 try {

  1054                     env.info.visitingServiceImplementation = true;

  1055                     it = attr.attribType(implName, env, syms.objectType);

  1056                 } finally {

  1057                     env.info.visitingServiceImplementation = prevVisitingServiceImplementation;

  1058                 }

  1059                 ClassSymbol impl = (ClassSymbol) it.tsym;

  1060                 if ((impl.flags_field & PUBLIC) == 0) {

  1061                     log.error(implName.pos(), Errors.NotDefPublic(impl, impl.location()));

  1062                 }

  1063                 //find provider factory:

  1064                 MethodSymbol factory = factoryMethod(impl);

  1065                 if (factory != null) {

  1066                     Type returnType = factory.type.getReturnType();

  1067                     if (!types.isSubtype(returnType, st)) {

  1068                         log.error(implName.pos(), Errors.ServiceImplementationProviderReturnMustBeSubtypeOfServiceInterface);

  1069                     }

  1070                 } else {

  1071                     if (!types.isSubtype(it, st)) {

  1072                         log.error(implName.pos(), Errors.ServiceImplementationMustBeSubtypeOfServiceInterface);

  1073                     } else if ((impl.flags() & ABSTRACT) != 0) {

  1074                         log.error(implName.pos(), Errors.ServiceImplementationIsAbstract(impl));

  1075                     } else if (impl.isInner()) {

  1076                         log.error(implName.pos(), Errors.ServiceImplementationIsInner(impl));

  1077                     } else {

  1078                         MethodSymbol constr = noArgsConstructor(impl);

  1079                         if (constr == null) {

  1080                             log.error(implName.pos(), Errors.ServiceImplementationDoesntHaveANoArgsConstructor(impl));

  1081                         } else if ((constr.flags() & PUBLIC) == 0) {

  1082                             log.error(implName.pos(), Errors.ServiceImplementationNoArgsConstructorNotPublic(impl));

  1083                         }

  1084                     }

  1085                 }

  1086                 if (it.hasTag(CLASS)) {

  1087                     if (allProvides.computeIfAbsent(service, s -> new HashSet<>()).add(impl)) {

  1088                         impls.append(impl);

  1089                     } else {

  1090                         log.error(implName.pos(), Errors.DuplicateProvides(service, impl));

  1091                     }

  1092                 }

  1093             }

  1094             if (st.hasTag(CLASS) && !impls.isEmpty()) {

  1095                 Directive.ProvidesDirective d = new Directive.ProvidesDirective(service, impls.toList());

  1096                 msym.provides = msym.provides.prepend(d);

  1097                 msym.directives = msym.directives.prepend(d);

  1098                 directiveToTreeMap.put(d, tree);

  1099             }

  1100         }

  1101 

  1102         @Override

  1103         public void visitRequires(JCRequires tree) {

  1104             if (tree.directive != null && allModules().contains(tree.directive.module)) {

  1105                 chk.checkDeprecated(tree.moduleName.pos(), msym, tree.directive.module);

  1106                 chk.checkModuleRequires(tree.moduleName.pos(), tree.directive);

  1107                 msym.directives = msym.directives.prepend(tree.directive);

  1108             }

  1109         }

  1110 

  1111         @Override

  1112         public void visitUses(JCUses tree) {

  1113             Type st = attr.attribType(tree.qualid, env, syms.objectType);

  1114             Symbol sym = TreeInfo.symbol(tree.qualid);

  1115             if ((sym.flags() & ENUM) != 0) {

  1116                 log.error(tree.qualid.pos(), Errors.ServiceDefinitionIsEnum(st.tsym));

  1117             } else if (st.hasTag(CLASS)) {

  1118                 ClassSymbol service = (ClassSymbol) st.tsym;

  1119                 if (allUses.add(service)) {

  1120                     Directive.UsesDirective d = new Directive.UsesDirective(service);

  1121                     msym.uses = msym.uses.prepend(d);

  1122                     msym.directives = msym.directives.prepend(d);

  1123                 } else {

  1124                     log.error(tree.pos(), Errors.DuplicateUses(service));

  1125                 }

  1126             }

  1127         }

  1128 

  1129         private void checkForCorrectness() {

  1130             for (Directive.ProvidesDirective provides : msym.provides) {

  1131                 JCProvides tree = directiveToTreeMap.get(provides);

  1132                 for (ClassSymbol impl : provides.impls) {

  1133                     /* The implementation must be defined in the same module as the provides directive

  1134                      * (else, error)