jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java

equal deleted inserted replaced

-:4caf88912b7f
+:3b41f1c69604
 import java.util.ResourceBundle;
 import java.util.Set;
 import javax.annotation.processing.Processor;
 import javax.lang.model.SourceVersion;
+import javax.lang.model.element.ElementVisitor;
 import javax.tools.DiagnosticListener;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardLocation;
 import com.sun.tools.javac.tree.JCTree.JCLambda;
 import com.sun.tools.javac.tree.JCTree.JCMemberReference;
 import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.util.*;
+import com.sun.tools.javac.util.DefinedBy.Api;
+import com.sun.tools.javac.util.JCDiagnostic.Factory;
 import com.sun.tools.javac.util.Log.WriterKind;
 import static com.sun.tools.javac.code.Kinds.Kind.*;
+import com.sun.tools.javac.code.Symbol.ModuleSymbol;
+import com.sun.tools.javac.resources.CompilerProperties.Errors;
+import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import static com.sun.tools.javac.code.TypeTag.CLASS;
 import static com.sun.tools.javac.main.Option.*;
 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
 import static javax.tools.StandardLocation.CLASS_OUTPUT;
 /** This class could be the main entry point for GJC when GJC is used as a
 *  component in a larger software system. It provides operations to
 *  construct a new compiler, and to run a new compiler on a set of source
 /** The flow analyzer.
 */
 protected Flow flow;
+/** The modules visitor
+*/
+protected Modules modules;
+/** The module finder
+*/
+protected ModuleFinder moduleFinder;
+/** The diagnostics factory
+*/
+protected JCDiagnostic.Factory diags;
 /** The type eraser.
 */
 protected TransTypes transTypes;
 /** The syntactic sugar desweetener.
 /**
 * Flag set if any implicit source files read.
 **/
 protected boolean implicitSourceFilesRead;
+protected boolean enterDone;
 protected CompileStates compileStates;
 /** Construct a new compiler using a shared context.
 */
 transTypes = TransTypes.instance(context);
 lower = Lower.instance(context);
 annotate = Annotate.instance(context);
 types = Types.instance(context);
 taskListener = MultiTaskListener.instance(context);
+modules = Modules.instance(context);
+moduleFinder = ModuleFinder.instance(context);
+diags = Factory.instance(context);
 finder.sourceCompleter = sourceCompleter;
 options = Options.instance(context);
 PlatformDescription platformProvider = context.get(PlatformDescription.class);
 if (platformProvider != null)
 closeables = closeables.prepend(platformProvider);
+silentFail = new Symbol(ABSENT_TYP, 0, names.empty, Type.noType, syms.rootPackage) {
+@DefinedBy(Api.LANGUAGE_MODEL)
+public <R, P> R accept(ElementVisitor<R, P> v, P p) {
+return v.visitUnknown(this, p);
+}
+@Override
+public boolean exists() {
+return false;
+}
+};
 }
 /* Switches:
 */
 /** The set of currently compiled inputfiles, needed to ensure
 *  we don't accidentally overwrite an input file when -s is set.
 *  initialized by `compile'.
 */
 protected Set<JavaFileObject> inputFiles = new HashSet<>();
+/** Used by the resolveBinaryNameOrIdent to say that the given type cannot be found, and that
+*  an error has already been produced about that.
+*/
+private final Symbol silentFail;
 protected boolean shouldStop(CompileState cs) {
 CompileState shouldStopPolicy = (errorCount() > 0 || unrecoverableError())
 ? shouldStopPolicyIfError
 : shouldStopPolicyIfNoError;
 /** Resolve an identifier which may be the binary name of a class or
 * the Java name of a class or package.
 * @param name      The name to resolve
 */
 public Symbol resolveBinaryNameOrIdent(String name) {
+ModuleSymbol msym;
+String typeName;
+int sep = name.indexOf('/');
+if (sep == -1) {
+msym = modules.getDefaultModule();
+typeName = name;
+} else if (source.allowModules() && !options.isSet("noModules")) {
+Name modName = names.fromString(name.substring(0, sep));
+msym = moduleFinder.findModule(modName);
+typeName = name.substring(sep + 1);
+} else {
+log.error(Errors.InvalidModuleSpecifier(name));
+return silentFail;
+}
+return resolveBinaryNameOrIdent(msym, typeName);
+}
+/** Resolve an identifier which may be the binary name of a class or
+* the Java name of a class or package.
+* @param msym      The module in which the search should be performed
+* @param name      The name to resolve
+*/
+public Symbol resolveBinaryNameOrIdent(ModuleSymbol msym, String name) {
 try {
 Name flatname = names.fromString(name.replace("/", "."));
-return finder.loadClass(flatname);
+return finder.loadClass(msym, flatname);
 } catch (CompletionFailure ignore) {
-return resolveIdent(name);
+return resolveIdent(msym, name);
 }
 }
 /** Resolve an identifier.
+* @param msym      The module in which the search should be performed
 * @param name      The identifier to resolve
 */
-public Symbol resolveIdent(String name) {
+public Symbol resolveIdent(ModuleSymbol msym, String name) {
 if (name.equals(""))
 return syms.errSymbol;
 JavaFileObject prev = log.useSource(null);
 try {
 JCExpression tree = null;
 tree = (tree == null) ? make.Ident(names.fromString(s))
 : make.Select(tree, names.fromString(s));
 }
 JCCompilationUnit toplevel =
 make.TopLevel(List.<JCTree>nil());
-toplevel.packge = syms.unnamedPackage;
+toplevel.modle = msym;
+toplevel.packge = msym.unnamedPackage;
 return attr.attribIdent(tree, toplevel);
 } finally {
 log.useSource(prev);
 }
 }
 if (!taskListener.isEmpty()) {
 TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree);
 taskListener.started(e);
 }
+// Process module declarations.
+// If module resolution fails, ignore trees, and if trying to
+// complete a specific symbol, throw CompletionFailure.
+// Note that if module resolution failed, we may not even
+// have enough modules available to access java.lang, and
+// so risk getting FatalError("no.java.lang") from MemberEnter.
+if (!modules.enter(List.of(tree), c)) {
+throw new CompletionFailure(c, diags.fragment("cant.resolve.modules"));
+}
 enter.complete(List.of(tree), c);
 if (!taskListener.isEmpty()) {
 TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree);
 taskListener.finished(e);
 if (enter.getEnv(c) == null) {
 boolean isPkgInfo =
 tree.sourcefile.isNameCompatible("package-info",
 JavaFileObject.Kind.SOURCE);
-if (isPkgInfo) {
+boolean isModuleInfo =
+tree.sourcefile.isNameCompatible("module-info",
+JavaFileObject.Kind.SOURCE);
+if (isModuleInfo) {
+if (enter.getEnv(tree.modle) == null) {
+JCDiagnostic diag =
+diagFactory.fragment("file.does.not.contain.module");
+throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory);
+}
+} else if (isPkgInfo) {
 if (enter.getEnv(tree.packge) == null) {
 JCDiagnostic diag =
 diagFactory.fragment("file.does.not.contain.package",
 c.location());
 throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory);
 try {
 initProcessAnnotations(processors);
 // These method calls must be chained to avoid memory leaks
 processAnnotations(
-enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
+enterTrees(
-classnames);
+stopIfError(CompileState.PARSE,
+initModules(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))))
+),
+classnames
+);
 // If it's safe to do so, skip attr / flow / gen for implicit classes
 if (taskListener.isEmpty() &&
 implicitSourcePolicy == ImplicitSourcePolicy.NONE) {
 todo.retainFiles(inputFiles);
 * Also stores a list of all top level classes in rootClasses.
 */
 public List<JCCompilationUnit> enterTreesIfNeeded(List<JCCompilationUnit> roots) {
 if (shouldStop(CompileState.ATTR))
 return List.nil();
-return enterTrees(roots);
+return enterTrees(initModules(roots));
+}
+public List<JCCompilationUnit> initModules(List<JCCompilationUnit> roots) {
+List<JCCompilationUnit> result = initModules(roots, null);
+if (roots.isEmpty()) {
+enterDone = true;
+}
+return result;
+}
+List<JCCompilationUnit> initModules(List<JCCompilationUnit> roots, ClassSymbol c) {
+modules.enter(roots, c);
+return roots;
 }
 /**
 * Enter the symbols found in a list of parse trees.
 * As a side-effect, this puts elements on the "todo" list.
 taskListener.started(e);
 }
 }
 enter.main(roots);
+enterDone = true;
 if (!taskListener.isEmpty()) {
 for (JCCompilationUnit unit: roots) {
 TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, unit);
 taskListener.finished(e);
 for (String nameStr : classnames) {
 Symbol sym = resolveBinaryNameOrIdent(nameStr);
 if (sym == null ||
 (sym.kind == PCK && !processPcks) ||
 sym.kind == ABSENT_TYP) {
-log.error("proc.cant.find.class", nameStr);
+if (sym != silentFail)
+log.error(Errors.ProcCantFindClass(nameStr));
 errors = true;
 continue;
 }
 try {
 if (sym.kind == PCK)
 else
 classSymbols = classSymbols.prepend((ClassSymbol)sym);
 continue;
 }
 Assert.check(sym.kind == PCK);
-log.warning("proc.package.does.not.exist", nameStr);
+log.warning(Warnings.ProcPackageDoesNotExist(nameStr));
 pckSymbols = pckSymbols.prepend((PackageSymbol)sym);
 } catch (CompletionFailure e) {
-log.error("proc.cant.find.class", nameStr);
+log.error(Errors.ProcCantFindClass(nameStr));
 errors = true;
 continue;
 }
 }
 if (errors) {
 static boolean explicitAnnotationProcessingRequested(Options options) {
 return
 options.isSet(PROCESSOR) ||
 options.isSet(PROCESSORPATH) ||
+options.isSet(PROCESSORMODULEPATH) ||
 options.isSet(PROC, "only") ||
 options.isSet(XPRINT);
 }
 public void setDeferredDiagnosticHandler(Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
 JCTree untranslated = env.tree;
 make.at(Position.FIRSTPOS);
 TreeMaker localMake = make.forToplevel(env.toplevel);
-if (env.tree.hasTag(JCTree.Tag.PACKAGEDEF)) {
+if (env.tree.hasTag(JCTree.Tag.PACKAGEDEF) || env.tree.hasTag(JCTree.Tag.MODULEDEF)) {
 if (!(sourceOutput)) {
 if (shouldStop(CompileState.LOWER))
 return;
-List<JCTree> pdef = lower.translateTopLevelClass(env, env.tree, localMake);
+List<JCTree> def = lower.translateTopLevelClass(env, env.tree, localMake);
-if (pdef.head != null) {
+if (def.head != null) {
-Assert.check(pdef.tail.isEmpty());
+Assert.check(def.tail.isEmpty());
-results.add(new Pair<>(env, (JCClassDecl)pdef.head));
+results.add(new Pair<>(env, (JCClassDecl)def.head));
 }
 }
 return;
 }
 if (log.compressedOutput) {
 log.mandatoryNote(null, "compressed.diags");
 }
 }
+public boolean isEnterDone() {
+return enterDone;
+}
 /** Close the compiler, flushing the logs
 */
 public void close() {
 rootClasses = null;
 finder = null;

changeset 36526	3b41f1c69604
parent 36155	1555ce1fcb4f
child 39587	76c453568ffa