1 /*
   2  * Copyright (c) 1999, 2023, 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 package com.sun.tools.javac.main;
  27 
  28 import java.io.*;
  29 import java.nio.file.FileSystemNotFoundException;
  30 import java.nio.file.InvalidPathException;
  31 import java.nio.file.ReadOnlyFileSystemException;
  32 import java.util.Collection;
  33 import java.util.Collections;
  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.MissingResourceException;
  40 import java.util.Queue;
  41 import java.util.ResourceBundle;
  42 import java.util.Set;
  43 import java.util.function.Function;
  44 
  45 import javax.annotation.processing.Processor;
  46 import javax.lang.model.SourceVersion;
  47 import javax.lang.model.element.ElementVisitor;
  48 import javax.tools.DiagnosticListener;
  49 import javax.tools.JavaFileManager;
  50 import javax.tools.JavaFileObject;
  51 import javax.tools.JavaFileObject.Kind;
  52 import javax.tools.StandardLocation;
  53 
  54 import com.sun.source.util.TaskEvent;
  55 import com.sun.tools.javac.api.MultiTaskListener;
  56 import com.sun.tools.javac.code.*;
  57 import com.sun.tools.javac.code.Lint.LintCategory;
  58 import com.sun.tools.javac.code.Source.Feature;
  59 import com.sun.tools.javac.code.Symbol.ClassSymbol;
  60 import com.sun.tools.javac.code.Symbol.CompletionFailure;
  61 import com.sun.tools.javac.code.Symbol.PackageSymbol;
  62 import com.sun.tools.javac.comp.*;
  63 import com.sun.tools.javac.comp.CompileStates.CompileState;
  64 import com.sun.tools.javac.file.JavacFileManager;
  65 import com.sun.tools.javac.jvm.*;
  66 import com.sun.tools.javac.parser.*;
  67 import com.sun.tools.javac.platform.PlatformDescription;
  68 import com.sun.tools.javac.processing.*;
  69 import com.sun.tools.javac.tree.*;
  70 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
  71 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
  72 import com.sun.tools.javac.tree.JCTree.JCExpression;
  73 import com.sun.tools.javac.tree.JCTree.JCLambda;
  74 import com.sun.tools.javac.tree.JCTree.JCMemberReference;
  75 import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
  76 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
  77 import com.sun.tools.javac.util.*;
  78 import com.sun.tools.javac.util.Context.Key;
  79 import com.sun.tools.javac.util.DefinedBy.Api;
  80 import com.sun.tools.javac.util.JCDiagnostic.Factory;
  81 import com.sun.tools.javac.util.Log.DiagnosticHandler;
  82 import com.sun.tools.javac.util.Log.DiscardDiagnosticHandler;
  83 import com.sun.tools.javac.util.Log.WriterKind;
  84 
  85 import static com.sun.tools.javac.code.Kinds.Kind.*;
  86 
  87 import com.sun.tools.javac.code.Lint;
  88 import com.sun.tools.javac.code.Lint.LintCategory;
  89 import com.sun.tools.javac.code.Symbol.ModuleSymbol;
  90 
  91 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  92 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
  93 import com.sun.tools.javac.resources.CompilerProperties.Notes;
  94 import com.sun.tools.javac.resources.CompilerProperties.Warnings;
  95 
  96 import static com.sun.tools.javac.code.TypeTag.CLASS;
  97 import static com.sun.tools.javac.main.Option.*;
  98 import com.sun.tools.javac.tree.JCTree.JCBindingPattern;
  99 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
 100 
 101 import static javax.tools.StandardLocation.CLASS_OUTPUT;
 102 import static javax.tools.StandardLocation.ANNOTATION_PROCESSOR_PATH;
 103 
 104 import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
 105 import com.sun.tools.javac.tree.JCTree.JCRecordPattern;
 106 import com.sun.tools.javac.tree.JCTree.JCSwitch;
 107 import com.sun.tools.javac.tree.JCTree.JCSwitchExpression;
 108 
 109 /** This class could be the main entry point for GJC when GJC is used as a
 110  *  component in a larger software system. It provides operations to
 111  *  construct a new compiler, and to run a new compiler on a set of source
 112  *  files.
 113  *
 114  *  <p><b>This is NOT part of any supported API.
 115  *  If you write code that depends on this, you do so at your own risk.
 116  *  This code and its internal interfaces are subject to change or
 117  *  deletion without notice.</b>
 118  */
 119 public class JavaCompiler {
 120     /** The context key for the compiler. */
 121     public static final Context.Key<JavaCompiler> compilerKey = new Context.Key<>();
 122 
 123     /** Get the JavaCompiler instance for this context. */
 124     public static JavaCompiler instance(Context context) {
 125         JavaCompiler instance = context.get(compilerKey);
 126         if (instance == null)
 127             instance = new JavaCompiler(context);
 128         return instance;
 129     }
 130 
 131     /** The current version number as a string.
 132      */
 133     public static String version() {
 134         return version("release");  // mm.nn.oo[-milestone]
 135     }
 136 
 137     /** The current full version number as a string.
 138      */
 139     public static String fullVersion() {
 140         return version("full"); // mm.mm.oo[-milestone]-build
 141     }
 142 
 143     private static final String versionRBName = "com.sun.tools.javac.resources.version";
 144     private static ResourceBundle versionRB;
 145 
 146     private static String version(String key) {
 147         if (versionRB == null) {
 148             try {
 149                 versionRB = ResourceBundle.getBundle(versionRBName);
 150             } catch (MissingResourceException e) {
 151                 return Log.getLocalizedString("version.not.available");
 152             }
 153         }
 154         try {
 155             return versionRB.getString(key);
 156         }
 157         catch (MissingResourceException e) {
 158             return Log.getLocalizedString("version.not.available");
 159         }
 160     }
 161 
 162     /**
 163      * Control how the compiler's latter phases (attr, flow, desugar, generate)
 164      * are connected. Each individual file is processed by each phase in turn,
 165      * but with different compile policies, you can control the order in which
 166      * each class is processed through its next phase.
 167      *
 168      * <p>Generally speaking, the compiler will "fail fast" in the face of
 169      * errors, although not aggressively so. flow, desugar, etc become no-ops
 170      * once any errors have occurred. No attempt is currently made to determine
 171      * if it might be safe to process a class through its next phase because
 172      * it does not depend on any unrelated errors that might have occurred.
 173      */
 174     protected static enum CompilePolicy {
 175         /**
 176          * Attribute everything, then do flow analysis for everything,
 177          * then desugar everything, and only then generate output.
 178          * This means no output will be generated if there are any
 179          * errors in any classes.
 180          */
 181         SIMPLE,
 182 
 183         /**
 184          * Groups the classes for each source file together, then process
 185          * each group in a manner equivalent to the {@code SIMPLE} policy.
 186          * This means no output will be generated if there are any
 187          * errors in any of the classes in a source file.
 188          */
 189         BY_FILE,
 190 
 191         /**
 192          * Completely process each entry on the todo list in turn.
 193          * -- this is the same for 1.5.
 194          * Means output might be generated for some classes in a compilation unit
 195          * and not others.
 196          */
 197         BY_TODO;
 198 
 199         static CompilePolicy decode(String option) {
 200             if (option == null)
 201                 return DEFAULT_COMPILE_POLICY;
 202             else if (option.equals("simple"))
 203                 return SIMPLE;
 204             else if (option.equals("byfile"))
 205                 return BY_FILE;
 206             else if (option.equals("bytodo"))
 207                 return BY_TODO;
 208             else
 209                 return DEFAULT_COMPILE_POLICY;
 210         }
 211     }
 212 
 213     private static final CompilePolicy DEFAULT_COMPILE_POLICY = CompilePolicy.BY_TODO;
 214 
 215     protected static enum ImplicitSourcePolicy {
 216         /** Don't generate or process implicitly read source files. */
 217         NONE,
 218         /** Generate classes for implicitly read source files. */
 219         CLASS,
 220         /** Like CLASS, but generate warnings if annotation processing occurs */
 221         UNSET;
 222 
 223         static ImplicitSourcePolicy decode(String option) {
 224             if (option == null)
 225                 return UNSET;
 226             else if (option.equals("none"))
 227                 return NONE;
 228             else if (option.equals("class"))
 229                 return CLASS;
 230             else
 231                 return UNSET;
 232         }
 233     }
 234 
 235     /** The log to be used for error reporting.
 236      */
 237     public Log log;
 238 
 239     /** Whether or not the options lint category was initially disabled
 240      */
 241     boolean optionsCheckingInitiallyDisabled;
 242 
 243     /** Factory for creating diagnostic objects
 244      */
 245     JCDiagnostic.Factory diagFactory;
 246 
 247     /** The tree factory module.
 248      */
 249     protected TreeMaker make;
 250 
 251     /** The class finder.
 252      */
 253     protected ClassFinder finder;
 254 
 255     /** The class reader.
 256      */
 257     protected ClassReader reader;
 258 
 259     /** The class writer.
 260      */
 261     protected ClassWriter writer;
 262 
 263     /** The native header writer.
 264      */
 265     protected JNIWriter jniWriter;
 266 
 267     /** The module for the symbol table entry phases.
 268      */
 269     protected Enter enter;
 270 
 271     /** The symbol table.
 272      */
 273     protected Symtab syms;
 274 
 275     /** The language version.
 276      */
 277     protected Source source;
 278 
 279     /** The preview language version.
 280      */
 281     protected Preview preview;
 282 
 283     /** The module for code generation.
 284      */
 285     protected Gen gen;
 286 
 287     /** The name table.
 288      */
 289     protected Names names;
 290 
 291     /** The attributor.
 292      */
 293     protected Attr attr;
 294 
 295     /** The analyzer
 296      */
 297     protected Analyzer analyzer;
 298 
 299     /** The attributor.
 300      */
 301     protected Check chk;
 302 
 303     /** The flow analyzer.
 304      */
 305     protected Flow flow;
 306 
 307     /** The modules visitor
 308      */
 309     protected Modules modules;
 310 
 311     /** The module finder
 312      */
 313     protected ModuleFinder moduleFinder;
 314 
 315     /** The diagnostics factory
 316      */
 317     protected JCDiagnostic.Factory diags;
 318 
 319     protected DeferredCompletionFailureHandler dcfh;
 320 
 321     /** The type eraser.
 322      */
 323     protected TransTypes transTypes;
 324 
 325     /** The syntactic sugar desweetener.
 326      */
 327     protected Lower lower;
 328 
 329     /** The annotation annotator.
 330      */
 331     protected Annotate annotate;
 332 
 333     /** Force a completion failure on this name
 334      */
 335     protected final Name completionFailureName;
 336 
 337     /** Type utilities.
 338      */
 339     protected Types types;
 340 
 341     /** Access to file objects.
 342      */
 343     protected JavaFileManager fileManager;
 344 
 345     /** Factory for parsers.
 346      */
 347     protected ParserFactory parserFactory;
 348 
 349     /** Broadcasting listener for progress events
 350      */
 351     protected MultiTaskListener taskListener;
 352 
 353     /**
 354      * SourceCompleter that delegates to the readSourceFile method of this class.
 355      */
 356     protected final Symbol.Completer sourceCompleter =
 357             sym -> readSourceFile((ClassSymbol) sym);
 358 
 359     /**
 360      * Command line options.
 361      */
 362     protected Options options;
 363 
 364     protected Context context;
 365 
 366     /**
 367      * Flag set if any annotation processing occurred.
 368      **/
 369     protected boolean annotationProcessingOccurred;
 370 
 371     /**
 372      * Flag set if any implicit source files read.
 373      **/
 374     protected boolean implicitSourceFilesRead;
 375 
 376     private boolean enterDone;
 377 
 378     protected CompileStates compileStates;
 379 
 380     /** Construct a new compiler using a shared context.
 381      */
 382     @SuppressWarnings("this-escape")
 383     public JavaCompiler(Context context) {
 384         this.context = context;
 385         context.put(compilerKey, this);
 386 
 387         // if fileManager not already set, register the JavacFileManager to be used
 388         if (context.get(JavaFileManager.class) == null)
 389             JavacFileManager.preRegister(context);
 390 
 391         names = Names.instance(context);
 392         log = Log.instance(context);
 393         diagFactory = JCDiagnostic.Factory.instance(context);
 394         finder = ClassFinder.instance(context);
 395         reader = ClassReader.instance(context);
 396         make = TreeMaker.instance(context);
 397         writer = ClassWriter.instance(context);
 398         jniWriter = JNIWriter.instance(context);
 399         enter = Enter.instance(context);
 400         todo = Todo.instance(context);
 401 
 402         fileManager = context.get(JavaFileManager.class);
 403         parserFactory = ParserFactory.instance(context);
 404         compileStates = CompileStates.instance(context);
 405 
 406         try {
 407             // catch completion problems with predefineds
 408             syms = Symtab.instance(context);
 409         } catch (CompletionFailure ex) {
 410             // inlined Check.completionError as it is not initialized yet
 411             log.error(Errors.CantAccess(ex.sym, ex.getDetailValue()));
 412         }
 413         source = Source.instance(context);
 414         preview = Preview.instance(context);
 415         attr = Attr.instance(context);
 416         analyzer = Analyzer.instance(context);
 417         chk = Check.instance(context);
 418         gen = Gen.instance(context);
 419         flow = Flow.instance(context);
 420         transTypes = TransTypes.instance(context);
 421         lower = Lower.instance(context);
 422         annotate = Annotate.instance(context);
 423         types = Types.instance(context);
 424         taskListener = MultiTaskListener.instance(context);
 425         modules = Modules.instance(context);
 426         moduleFinder = ModuleFinder.instance(context);
 427         diags = Factory.instance(context);
 428         dcfh = DeferredCompletionFailureHandler.instance(context);
 429 
 430         finder.sourceCompleter = sourceCompleter;
 431         modules.findPackageInFile = this::findPackageInFile;
 432         moduleFinder.moduleNameFromSourceReader = this::readModuleName;
 433 
 434         options = Options.instance(context);
 435         // See if lint options checking was explicitly disabled by the
 436         // user; this is distinct from the options check being
 437         // enabled/disabled.
 438         optionsCheckingInitiallyDisabled =
 439             options.isSet(Option.XLINT_CUSTOM, "-options") ||
 440             options.isSet(Option.XLINT_CUSTOM, "none");
 441 
 442         verbose       = options.isSet(VERBOSE);
 443         sourceOutput  = options.isSet(PRINTSOURCE); // used to be -s
 444         lineDebugInfo = options.isUnset(G_CUSTOM) ||
 445                         options.isSet(G_CUSTOM, "lines");
 446         genEndPos     = options.isSet(XJCOV) ||
 447                         context.get(DiagnosticListener.class) != null;
 448         devVerbose    = options.isSet("dev");
 449         processPcks   = options.isSet("process.packages");
 450         werror        = options.isSet(WERROR);
 451 
 452         verboseCompilePolicy = options.isSet("verboseCompilePolicy");
 453 
 454         compilePolicy = CompilePolicy.decode(options.get("compilePolicy"));
 455 
 456         implicitSourcePolicy = ImplicitSourcePolicy.decode(options.get("-implicit"));
 457 
 458         completionFailureName =
 459             options.isSet("failcomplete")
 460             ? names.fromString(options.get("failcomplete"))
 461             : null;
 462 
 463         shouldStopPolicyIfError =
 464             options.isSet("should-stop.at") // backwards compatible
 465             ? CompileState.valueOf(options.get("should-stop.at"))
 466             : options.isSet("should-stop.ifError")
 467             ? CompileState.valueOf(options.get("should-stop.ifError"))
 468             : CompileState.INIT;
 469         shouldStopPolicyIfNoError =
 470             options.isSet("should-stop.ifNoError")
 471             ? CompileState.valueOf(options.get("should-stop.ifNoError"))
 472             : CompileState.GENERATE;
 473 
 474         if (options.isUnset("diags.legacy"))
 475             log.setDiagnosticFormatter(RichDiagnosticFormatter.instance(context));
 476 
 477         PlatformDescription platformProvider = context.get(PlatformDescription.class);
 478 
 479         if (platformProvider != null)
 480             closeables = closeables.prepend(platformProvider);
 481 
 482         silentFail = new Symbol(ABSENT_TYP, 0, names.empty, Type.noType, syms.rootPackage) {
 483             @DefinedBy(Api.LANGUAGE_MODEL)
 484             public <R, P> R accept(ElementVisitor<R, P> v, P p) {
 485                 return v.visitUnknown(this, p);
 486             }
 487             @Override
 488             public boolean exists() {
 489                 return false;
 490             }
 491         };
 492 
 493     }
 494 
 495     /* Switches:
 496      */
 497 
 498     /** Verbose output.
 499      */
 500     public boolean verbose;
 501 
 502     /** Emit plain Java source files rather than class files.
 503      */
 504     public boolean sourceOutput;
 505 
 506 
 507     /** Generate code with the LineNumberTable attribute for debugging
 508      */
 509     public boolean lineDebugInfo;
 510 
 511     /** Switch: should we store the ending positions?
 512      */
 513     public boolean genEndPos;
 514 
 515     /** Switch: should we debug ignored exceptions
 516      */
 517     protected boolean devVerbose;
 518 
 519     /** Switch: should we (annotation) process packages as well
 520      */
 521     protected boolean processPcks;
 522 
 523     /** Switch: treat warnings as errors
 524      */
 525     protected boolean werror;
 526 
 527     /** Switch: is annotation processing requested explicitly via
 528      * CompilationTask.setProcessors?
 529      */
 530     protected boolean explicitAnnotationProcessingRequested = false;
 531 
 532     /**
 533      * The policy for the order in which to perform the compilation
 534      */
 535     protected CompilePolicy compilePolicy;
 536 
 537     /**
 538      * The policy for what to do with implicitly read source files
 539      */
 540     protected ImplicitSourcePolicy implicitSourcePolicy;
 541 
 542     /**
 543      * Report activity related to compilePolicy
 544      */
 545     public boolean verboseCompilePolicy;
 546 
 547     /**
 548      * Policy of how far to continue compilation after errors have occurred.
 549      * Set this to minimum CompileState (INIT) to stop as soon as possible
 550      * after errors.
 551      */
 552     public CompileState shouldStopPolicyIfError;
 553 
 554     /**
 555      * Policy of how far to continue compilation when no errors have occurred.
 556      * Set this to maximum CompileState (GENERATE) to perform full compilation.
 557      * Set this lower to perform partial compilation, such as -proc:only.
 558      */
 559     public CompileState shouldStopPolicyIfNoError;
 560 
 561     /** A queue of all as yet unattributed classes.
 562      */
 563     public Todo todo;
 564 
 565     /** A list of items to be closed when the compilation is complete.
 566      */
 567     public List<Closeable> closeables = List.nil();
 568 
 569     /** The set of currently compiled inputfiles, needed to ensure
 570      *  we don't accidentally overwrite an input file when -s is set.
 571      *  initialized by `compile'.
 572      */
 573     protected Set<JavaFileObject> inputFiles = new HashSet<>();
 574 
 575     /** Used by the resolveBinaryNameOrIdent to say that the given type cannot be found, and that
 576      *  an error has already been produced about that.
 577      */
 578     private final Symbol silentFail;
 579 
 580     protected boolean shouldStop(CompileState cs) {
 581         CompileState shouldStopPolicy = (errorCount() > 0 || unrecoverableError())
 582             ? shouldStopPolicyIfError
 583             : shouldStopPolicyIfNoError;
 584         return cs.isAfter(shouldStopPolicy);
 585     }
 586 
 587     /** The number of errors reported so far.
 588      */
 589     public int errorCount() {
 590         if (werror && log.nerrors == 0 && log.nwarnings > 0) {
 591             log.error(Errors.WarningsAndWerror);
 592         }
 593         return log.nerrors;
 594     }
 595 
 596     protected final <T> Queue<T> stopIfError(CompileState cs, Queue<T> queue) {
 597         return shouldStop(cs) ? new ListBuffer<T>() : queue;
 598     }
 599 
 600     protected final <T> List<T> stopIfError(CompileState cs, List<T> list) {
 601         return shouldStop(cs) ? List.nil() : list;
 602     }
 603 
 604     /** The number of warnings reported so far.
 605      */
 606     public int warningCount() {
 607         return log.nwarnings;
 608     }
 609 
 610     /** Try to open input stream with given name.
 611      *  Report an error if this fails.
 612      *  @param filename   The file name of the input stream to be opened.
 613      */
 614     public CharSequence readSource(JavaFileObject filename) {
 615         try {
 616             inputFiles.add(filename);
 617             return filename.getCharContent(false);
 618         } catch (IOException e) {
 619             log.error(Errors.ErrorReadingFile(filename, JavacFileManager.getMessage(e)));
 620             return null;
 621         }
 622     }
 623 
 624     /** Parse contents of input stream.
 625      *  @param filename     The name of the file from which input stream comes.
 626      *  @param content      The characters to be parsed.
 627      */
 628     protected JCCompilationUnit parse(JavaFileObject filename, CharSequence content) {
 629         return parse(filename, content, false);
 630     }
 631 
 632     /** Parse contents of input stream.
 633      *  @param filename     The name of the file from which input stream comes.
 634      *  @param content      The characters to be parsed.
 635      *  @param silent       true if TaskListeners should not be notified
 636      */
 637     private JCCompilationUnit parse(JavaFileObject filename, CharSequence content, boolean silent) {
 638         long msec = now();
 639         JCCompilationUnit tree = make.TopLevel(List.nil());
 640         if (content != null) {
 641             if (verbose) {
 642                 log.printVerbose("parsing.started", filename);
 643             }
 644             if (!taskListener.isEmpty() && !silent) {
 645                 TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, filename);
 646                 taskListener.started(e);
 647                 keepComments = true;
 648                 genEndPos = true;
 649             }
 650             Parser parser = parserFactory.newParser(content, keepComments(), genEndPos,
 651                                 lineDebugInfo, filename.isNameCompatible("module-info", Kind.SOURCE));
 652             tree = parser.parseCompilationUnit();
 653             if (verbose) {
 654                 log.printVerbose("parsing.done", Long.toString(elapsed(msec)));
 655             }
 656         }
 657 
 658         tree.sourcefile = filename;
 659 
 660         if (content != null && !taskListener.isEmpty() && !silent) {
 661             TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, tree);
 662             taskListener.finished(e);
 663         }
 664 
 665         return tree;
 666     }
 667     // where
 668         public boolean keepComments = false;
 669         protected boolean keepComments() {
 670             return keepComments || sourceOutput;
 671         }
 672 
 673 
 674     /** Parse contents of file.
 675      *  @param filename     The name of the file to be parsed.
 676      */
 677     @Deprecated
 678     public JCTree.JCCompilationUnit parse(String filename) {
 679         JavacFileManager fm = (JavacFileManager)fileManager;
 680         return parse(fm.getJavaFileObjectsFromStrings(List.of(filename)).iterator().next());
 681     }
 682 
 683     /** Parse contents of file.
 684      *  @param filename     The name of the file to be parsed.
 685      */
 686     public JCTree.JCCompilationUnit parse(JavaFileObject filename) {
 687         JavaFileObject prev = log.useSource(filename);
 688         try {
 689             JCTree.JCCompilationUnit t = parse(filename, readSource(filename));
 690             if (t.endPositions != null)
 691                 log.setEndPosTable(filename, t.endPositions);
 692             return t;
 693         } finally {
 694             log.useSource(prev);
 695         }
 696     }
 697 
 698     /** Resolve an identifier which may be the binary name of a class or
 699      * the Java name of a class or package.
 700      * @param name      The name to resolve
 701      */
 702     public Symbol resolveBinaryNameOrIdent(String name) {
 703         ModuleSymbol msym;
 704         String typeName;
 705         int sep = name.indexOf('/');
 706         if (sep == -1) {
 707             msym = modules.getDefaultModule();
 708             typeName = name;
 709         } else if (Feature.MODULES.allowedInSource(source)) {
 710             Name modName = names.fromString(name.substring(0, sep));
 711 
 712             msym = moduleFinder.findModule(modName);
 713             typeName = name.substring(sep + 1);
 714         } else {
 715             log.error(Errors.InvalidModuleSpecifier(name));
 716             return silentFail;
 717         }
 718 
 719         return resolveBinaryNameOrIdent(msym, typeName);
 720     }
 721 
 722     /** Resolve an identifier which may be the binary name of a class or
 723      * the Java name of a class or package.
 724      * @param msym      The module in which the search should be performed
 725      * @param name      The name to resolve
 726      */
 727     public Symbol resolveBinaryNameOrIdent(ModuleSymbol msym, String name) {
 728         try {
 729             Name flatname = names.fromString(name.replace("/", "."));
 730             return finder.loadClass(msym, flatname);
 731         } catch (CompletionFailure ignore) {
 732             return resolveIdent(msym, name);
 733         }
 734     }
 735 
 736     /** Resolve an identifier.
 737      * @param msym      The module in which the search should be performed
 738      * @param name      The identifier to resolve
 739      */
 740     public Symbol resolveIdent(ModuleSymbol msym, String name) {
 741         if (name.equals(""))
 742             return syms.errSymbol;
 743         JavaFileObject prev = log.useSource(null);
 744         try {
 745             JCExpression tree = null;
 746             for (String s : name.split("\\.", -1)) {
 747                 if (!SourceVersion.isIdentifier(s)) // TODO: check for keywords
 748                     return syms.errSymbol;
 749                 tree = (tree == null) ? make.Ident(names.fromString(s))
 750                                       : make.Select(tree, names.fromString(s));
 751             }
 752             JCCompilationUnit toplevel =
 753                 make.TopLevel(List.nil());
 754             toplevel.modle = msym;
 755             toplevel.packge = msym.unnamedPackage;
 756             return attr.attribIdent(tree, toplevel);
 757         } finally {
 758             log.useSource(prev);
 759         }
 760     }
 761 
 762     /** Generate code and emit a class file for a given class
 763      *  @param env    The attribution environment of the outermost class
 764      *                containing this class.
 765      *  @param cdef   The class definition from which code is generated.
 766      */
 767     JavaFileObject genCode(Env<AttrContext> env, JCClassDecl cdef) throws IOException {
 768         try {
 769             if (gen.genClass(env, cdef) && (errorCount() == 0))
 770                 return writer.writeClass(cdef.sym);
 771         } catch (ClassWriter.PoolOverflow ex) {
 772             log.error(cdef.pos(), Errors.LimitPool);
 773         } catch (ClassWriter.StringOverflow ex) {
 774             log.error(cdef.pos(),
 775                       Errors.LimitStringOverflow(ex.value.substring(0, 20)));
 776         } catch (CompletionFailure ex) {
 777             chk.completionError(cdef.pos(), ex);
 778         }
 779         return null;
 780     }
 781 
 782     /** Emit plain Java source for a class.
 783      *  @param env    The attribution environment of the outermost class
 784      *                containing this class.
 785      *  @param cdef   The class definition to be printed.
 786      */
 787     JavaFileObject printSource(Env<AttrContext> env, JCClassDecl cdef) throws IOException {
 788         JavaFileObject outFile
 789            = fileManager.getJavaFileForOutput(CLASS_OUTPUT,
 790                                                cdef.sym.flatname.toString(),
 791                                                JavaFileObject.Kind.SOURCE,
 792                                                null);
 793         if (inputFiles.contains(outFile)) {
 794             log.error(cdef.pos(), Errors.SourceCantOverwriteInputFile(outFile));
 795             return null;
 796         } else {
 797             try (BufferedWriter out = new BufferedWriter(outFile.openWriter())) {
 798                 new Pretty(out, true).printUnit(env.toplevel, cdef);
 799                 if (verbose)
 800                     log.printVerbose("wrote.file", outFile.getName());
 801             }
 802             return outFile;
 803         }
 804     }
 805 
 806     /** Compile a source file that has been accessed by the class finder.
 807      *  @param c          The class the source file of which needs to be compiled.
 808      */
 809     private void readSourceFile(ClassSymbol c) throws CompletionFailure {
 810         readSourceFile(null, c);
 811     }
 812 
 813     /** Compile a ClassSymbol from source, optionally using the given compilation unit as
 814      *  the source tree.
 815      *  @param tree the compilation unit in which the given ClassSymbol resides,
 816      *              or null if should be parsed from source
 817      *  @param c    the ClassSymbol to complete
 818      */
 819     public void readSourceFile(JCCompilationUnit tree, ClassSymbol c) throws CompletionFailure {
 820         if (completionFailureName == c.fullname) {
 821             throw new CompletionFailure(
 822                 c, () -> diagFactory.fragment(Fragments.UserSelectedCompletionFailure), dcfh);
 823         }
 824         JavaFileObject filename = c.classfile;
 825         JavaFileObject prev = log.useSource(filename);
 826 
 827         if (tree == null) {
 828             try {
 829                 tree = parse(filename, filename.getCharContent(false));
 830             } catch (IOException e) {
 831                 log.error(Errors.ErrorReadingFile(filename, JavacFileManager.getMessage(e)));
 832                 tree = make.TopLevel(List.<JCTree>nil());
 833             } finally {
 834                 log.useSource(prev);
 835             }
 836         }
 837 
 838         if (!taskListener.isEmpty()) {
 839             TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree);
 840             taskListener.started(e);
 841         }
 842 
 843         // Process module declarations.
 844         // If module resolution fails, ignore trees, and if trying to
 845         // complete a specific symbol, throw CompletionFailure.
 846         // Note that if module resolution failed, we may not even
 847         // have enough modules available to access java.lang, and
 848         // so risk getting FatalError("no.java.lang") from MemberEnter.
 849         if (!modules.enter(List.of(tree), c)) {
 850             throw new CompletionFailure(c, () -> diags.fragment(Fragments.CantResolveModules), dcfh);
 851         }
 852 
 853         enter.complete(List.of(tree), c);
 854 
 855         if (!taskListener.isEmpty()) {
 856             TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree);
 857             taskListener.finished(e);
 858         }
 859 
 860         if (enter.getEnv(c) == null) {
 861             boolean isPkgInfo =
 862                 tree.sourcefile.isNameCompatible("package-info",
 863                                                  JavaFileObject.Kind.SOURCE);
 864             boolean isModuleInfo =
 865                 tree.sourcefile.isNameCompatible("module-info",
 866                                                  JavaFileObject.Kind.SOURCE);
 867             if (isModuleInfo) {
 868                 if (enter.getEnv(tree.modle) == null) {
 869                     JCDiagnostic diag =
 870                         diagFactory.fragment(Fragments.FileDoesNotContainModule);
 871                     throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory, dcfh);
 872                 }
 873             } else if (isPkgInfo) {
 874                 if (enter.getEnv(tree.packge) == null) {
 875                     JCDiagnostic diag =
 876                         diagFactory.fragment(Fragments.FileDoesNotContainPackage(c.location()));
 877                     throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory, dcfh);
 878                 }
 879             } else {
 880                 JCDiagnostic diag =
 881                         diagFactory.fragment(Fragments.FileDoesntContainClass(c.getQualifiedName()));
 882                 throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory, dcfh);
 883             }
 884         }
 885 
 886         implicitSourceFilesRead = true;
 887     }
 888 
 889     /** Track when the JavaCompiler has been used to compile something. */
 890     private boolean hasBeenUsed = false;
 891     private long start_msec = 0;
 892     public long elapsed_msec = 0;
 893 
 894     public void compile(List<JavaFileObject> sourceFileObject)
 895         throws Throwable {
 896         compile(sourceFileObject, List.nil(), null, List.nil());
 897     }
 898 
 899     /**
 900      * Main method: compile a list of files, return all compiled classes
 901      *
 902      * @param sourceFileObjects file objects to be compiled
 903      * @param classnames class names to process for annotations
 904      * @param processors user provided annotation processors to bypass
 905      * discovery, {@code null} means that no processors were provided
 906      * @param addModules additional root modules to be used during
 907      * module resolution.
 908      */
 909     public void compile(Collection<JavaFileObject> sourceFileObjects,
 910                         Collection<String> classnames,
 911                         Iterable<? extends Processor> processors,
 912                         Collection<String> addModules)
 913     {
 914         if (!taskListener.isEmpty()) {
 915             taskListener.started(new TaskEvent(TaskEvent.Kind.COMPILATION));
 916         }
 917 
 918         if (processors != null && processors.iterator().hasNext())
 919             explicitAnnotationProcessingRequested = true;
 920         // as a JavaCompiler can only be used once, throw an exception if
 921         // it has been used before.
 922         if (hasBeenUsed)
 923             checkReusable();
 924         hasBeenUsed = true;
 925 
 926         // forcibly set the equivalent of -Xlint:-options, so that no further
 927         // warnings about command line options are generated from this point on
 928         options.put(XLINT_CUSTOM.primaryName + "-" + LintCategory.OPTIONS.option, "true");
 929         options.remove(XLINT_CUSTOM.primaryName + LintCategory.OPTIONS.option);
 930 
 931         start_msec = now();
 932 
 933         try {
 934             initProcessAnnotations(processors, sourceFileObjects, classnames);
 935 
 936             for (String className : classnames) {
 937                 int sep = className.indexOf('/');
 938                 if (sep != -1) {
 939                     modules.addExtraAddModules(className.substring(0, sep));
 940                 }
 941             }
 942 
 943             for (String moduleName : addModules) {
 944                 modules.addExtraAddModules(moduleName);
 945             }
 946 
 947             // These method calls must be chained to avoid memory leaks
 948             processAnnotations(
 949                 enterTrees(
 950                         stopIfError(CompileState.ENTER,
 951                                 initModules(stopIfError(CompileState.ENTER, parseFiles(sourceFileObjects))))
 952                 ),
 953                 classnames
 954             );
 955 
 956             // If it's safe to do so, skip attr / flow / gen for implicit classes
 957             if (taskListener.isEmpty() &&
 958                     implicitSourcePolicy == ImplicitSourcePolicy.NONE) {
 959                 todo.retainFiles(inputFiles);
 960             }
 961 
 962             if (!CompileState.ATTR.isAfter(shouldStopPolicyIfNoError)) {
 963                 switch (compilePolicy) {
 964                 case SIMPLE:
 965                     generate(desugar(flow(attribute(todo))));
 966                     break;
 967 
 968                 case BY_FILE: {
 969                         Queue<Queue<Env<AttrContext>>> q = todo.groupByFile();
 970                         while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) {
 971                             generate(desugar(flow(attribute(q.remove()))));
 972                         }
 973                     }
 974                     break;
 975 
 976                 case BY_TODO:
 977                     while (!todo.isEmpty())
 978                         generate(desugar(flow(attribute(todo.remove()))));
 979                     break;
 980 
 981                 default:
 982                     Assert.error("unknown compile policy");
 983                 }
 984             }
 985         } catch (Abort ex) {
 986             if (devVerbose)
 987                 ex.printStackTrace(System.err);
 988 
 989             // In case an Abort was thrown before processAnnotations could be called,
 990             // we could have deferred diagnostics that haven't been reported.
 991             if (deferredDiagnosticHandler != null) {
 992                 deferredDiagnosticHandler.reportDeferredDiagnostics();
 993                 log.popDiagnosticHandler(deferredDiagnosticHandler);
 994             }
 995         } finally {
 996             if (verbose) {
 997                 elapsed_msec = elapsed(start_msec);
 998                 log.printVerbose("total", Long.toString(elapsed_msec));
 999             }
1000 
1001             reportDeferredDiagnostics();
1002 
1003             if (!log.hasDiagnosticListener()) {
1004                 printCount("error", errorCount());
1005                 printCount("warn", warningCount());
1006                 printSuppressedCount(errorCount(), log.nsuppressederrors, "count.error.recompile");
1007                 printSuppressedCount(warningCount(), log.nsuppressedwarns, "count.warn.recompile");
1008             }
1009             if (!taskListener.isEmpty()) {
1010                 taskListener.finished(new TaskEvent(TaskEvent.Kind.COMPILATION));
1011             }
1012             close();
1013             if (procEnvImpl != null)
1014                 procEnvImpl.close();
1015         }
1016     }
1017 
1018     protected void checkReusable() {
1019         throw new AssertionError("attempt to reuse JavaCompiler");
1020     }
1021 
1022     /**
1023      * The list of classes explicitly supplied on the command line for compilation.
1024      * Not always populated.
1025      */
1026     private List<JCClassDecl> rootClasses;
1027 
1028     /**
1029      * Parses a list of files.
1030      */
1031    public List<JCCompilationUnit> parseFiles(Iterable<JavaFileObject> fileObjects) {
1032        return InitialFileParser.instance(context).parse(fileObjects);
1033    }
1034 
1035    public List<JCCompilationUnit> parseFiles(Iterable<JavaFileObject> fileObjects, boolean force) {
1036        if (!force && shouldStop(CompileState.PARSE))
1037            return List.nil();
1038 
1039         //parse all files
1040         ListBuffer<JCCompilationUnit> trees = new ListBuffer<>();
1041         Set<JavaFileObject> filesSoFar = new HashSet<>();
1042         for (JavaFileObject fileObject : fileObjects) {
1043             if (!filesSoFar.contains(fileObject)) {
1044                 filesSoFar.add(fileObject);
1045                 trees.append(parse(fileObject));
1046             }
1047         }
1048         return trees.toList();
1049     }
1050 
1051    /**
1052     * Returns true iff the compilation will continue after annotation processing
1053     * is done.
1054     */
1055     public boolean continueAfterProcessAnnotations() {
1056         return !shouldStop(CompileState.ATTR);
1057     }
1058 
1059     public List<JCCompilationUnit> initModules(List<JCCompilationUnit> roots) {
1060         modules.initModules(roots);
1061         if (roots.isEmpty()) {
1062             enterDone();
1063         }
1064         return roots;
1065     }
1066 
1067     /**
1068      * Enter the symbols found in a list of parse trees.
1069      * As a side-effect, this puts elements on the "todo" list.
1070      * Also stores a list of all top level classes in rootClasses.
1071      */
1072     public List<JCCompilationUnit> enterTrees(List<JCCompilationUnit> roots) {
1073         //enter symbols for all files
1074         if (!taskListener.isEmpty()) {
1075             for (JCCompilationUnit unit: roots) {
1076                 TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, unit);
1077                 taskListener.started(e);
1078             }
1079         }
1080 
1081         enter.main(roots);
1082 
1083         enterDone();
1084 
1085         if (!taskListener.isEmpty()) {
1086             for (JCCompilationUnit unit: roots) {
1087                 TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, unit);
1088                 taskListener.finished(e);
1089             }
1090         }
1091 
1092         // If generating source, or if tracking public apis,
1093         // then remember the classes declared in
1094         // the original compilation units listed on the command line.
1095         if (sourceOutput) {
1096             ListBuffer<JCClassDecl> cdefs = new ListBuffer<>();
1097             for (JCCompilationUnit unit : roots) {
1098                 for (List<JCTree> defs = unit.defs;
1099                      defs.nonEmpty();
1100                      defs = defs.tail) {
1101                     if (defs.head instanceof JCClassDecl classDecl)
1102                         cdefs.append(classDecl);
1103                 }
1104             }
1105             rootClasses = cdefs.toList();
1106         }
1107 
1108         // Ensure the input files have been recorded. Although this is normally
1109         // done by readSource, it may not have been done if the trees were read
1110         // in a prior round of annotation processing, and the trees have been
1111         // cleaned and are being reused.
1112         for (JCCompilationUnit unit : roots) {
1113             inputFiles.add(unit.sourcefile);
1114         }
1115 
1116         return roots;
1117     }
1118 
1119     /**
1120      * Set to true to enable skeleton annotation processing code.
1121      * Currently, we assume this variable will be replaced more
1122      * advanced logic to figure out if annotation processing is
1123      * needed.
1124      */
1125     boolean processAnnotations = false;
1126 
1127     Log.DeferredDiagnosticHandler deferredDiagnosticHandler;
1128 
1129     /**
1130      * Object to handle annotation processing.
1131      */
1132     private JavacProcessingEnvironment procEnvImpl = null;
1133 
1134     /**
1135      * Check if we should process annotations.
1136      * If so, and if no scanner is yet registered, then set up the DocCommentScanner
1137      * to catch doc comments, and set keepComments so the parser records them in
1138      * the compilation unit.
1139      *
1140      * @param processors user provided annotation processors to bypass
1141      * discovery, {@code null} means that no processors were provided
1142      */
1143     public void initProcessAnnotations(Iterable<? extends Processor> processors,
1144                                        Collection<? extends JavaFileObject> initialFiles,
1145                                        Collection<String> initialClassNames) {
1146         // Process annotations if processing is not disabled and there
1147         // is at least one Processor available.
1148         if (options.isSet(PROC, "none")) {
1149             processAnnotations = false;
1150         } else if (procEnvImpl == null) {
1151             procEnvImpl = JavacProcessingEnvironment.instance(context);
1152             procEnvImpl.setProcessors(processors);
1153             processAnnotations = procEnvImpl.atLeastOneProcessor();
1154 
1155             if (processAnnotations) {
1156                 if (!explicitAnnotationProcessingRequested() &&
1157                     !optionsCheckingInitiallyDisabled) {
1158                     log.note(Notes.ImplicitAnnotationProcessing);
1159                 }
1160 
1161                 options.put("parameters", "parameters");
1162                 reader.saveParameterNames = true;
1163                 keepComments = true;
1164                 genEndPos = true;
1165                 if (!taskListener.isEmpty())
1166                     taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
1167                 deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
1168                 procEnvImpl.getFiler().setInitialState(initialFiles, initialClassNames);
1169             } else { // free resources
1170                 procEnvImpl.close();
1171             }
1172         }
1173     }
1174 
1175     // TODO: called by JavacTaskImpl
1176     public void processAnnotations(List<JCCompilationUnit> roots) {
1177         processAnnotations(roots, List.nil());
1178     }
1179 
1180     /**
1181      * Process any annotations found in the specified compilation units.
1182      * @param roots a list of compilation units
1183      */
1184     // Implementation note: when this method is called, log.deferredDiagnostics
1185     // will have been set true by initProcessAnnotations, meaning that any diagnostics
1186     // that are reported will go into the log.deferredDiagnostics queue.
1187     // By the time this method exits, log.deferDiagnostics must be set back to false,
1188     // and all deferredDiagnostics must have been handled: i.e. either reported
1189     // or determined to be transient, and therefore suppressed.
1190     public void processAnnotations(List<JCCompilationUnit> roots,
1191                                    Collection<String> classnames) {
1192         if (shouldStop(CompileState.PROCESS)) {
1193             // Errors were encountered.
1194             // Unless all the errors are resolve errors, the errors were parse errors
1195             // or other errors during enter which cannot be fixed by running
1196             // any annotation processors.
1197             if (processAnnotations) {
1198                 deferredDiagnosticHandler.reportDeferredDiagnostics();
1199                 log.popDiagnosticHandler(deferredDiagnosticHandler);
1200                 return ;
1201             }
1202         }
1203 
1204         // ASSERT: processAnnotations and procEnvImpl should have been set up by
1205         // by initProcessAnnotations
1206 
1207         // NOTE: The !classnames.isEmpty() checks should be refactored to Main.
1208 
1209         if (!processAnnotations) {
1210             // If there are no annotation processors present, and
1211             // annotation processing is to occur with compilation,
1212             // emit a warning.
1213             if (options.isSet(PROC, "only")) {
1214                 log.warning(Warnings.ProcProcOnlyRequestedNoProcs);
1215                 todo.clear();
1216             }
1217             // If not processing annotations, classnames must be empty
1218             if (!classnames.isEmpty()) {
1219                 log.error(Errors.ProcNoExplicitAnnotationProcessingRequested(classnames));
1220             }
1221             Assert.checkNull(deferredDiagnosticHandler);
1222             return ; // continue regular compilation
1223         }
1224 
1225         Assert.checkNonNull(deferredDiagnosticHandler);
1226 
1227         try {
1228             List<ClassSymbol> classSymbols = List.nil();
1229             List<PackageSymbol> pckSymbols = List.nil();
1230             if (!classnames.isEmpty()) {
1231                  // Check for explicit request for annotation
1232                  // processing
1233                 if (!explicitAnnotationProcessingRequested()) {
1234                     log.error(Errors.ProcNoExplicitAnnotationProcessingRequested(classnames));
1235                     deferredDiagnosticHandler.reportDeferredDiagnostics();
1236                     log.popDiagnosticHandler(deferredDiagnosticHandler);
1237                     return ; // TODO: Will this halt compilation?
1238                 } else {
1239                     boolean errors = false;
1240                     for (String nameStr : classnames) {
1241                         Symbol sym = resolveBinaryNameOrIdent(nameStr);
1242                         if (sym == null ||
1243                             (sym.kind == PCK && !processPcks) ||
1244                             sym.kind == ABSENT_TYP) {
1245                             if (sym != silentFail)
1246                                 log.error(Errors.ProcCantFindClass(nameStr));
1247                             errors = true;
1248                             continue;
1249                         }
1250                         try {
1251                             if (sym.kind == PCK)
1252                                 sym.complete();
1253                             if (sym.exists()) {
1254                                 if (sym.kind == PCK)
1255                                     pckSymbols = pckSymbols.prepend((PackageSymbol)sym);
1256                                 else
1257                                     classSymbols = classSymbols.prepend((ClassSymbol)sym);
1258                                 continue;
1259                             }
1260                             Assert.check(sym.kind == PCK);
1261                             log.warning(Warnings.ProcPackageDoesNotExist(nameStr));
1262                             pckSymbols = pckSymbols.prepend((PackageSymbol)sym);
1263                         } catch (CompletionFailure e) {
1264                             log.error(Errors.ProcCantFindClass(nameStr));
1265                             errors = true;
1266                             continue;
1267                         }
1268                     }
1269                     if (errors) {
1270                         deferredDiagnosticHandler.reportDeferredDiagnostics();
1271                         log.popDiagnosticHandler(deferredDiagnosticHandler);
1272                         return ;
1273                     }
1274                 }
1275             }
1276             try {
1277                 annotationProcessingOccurred =
1278                         procEnvImpl.doProcessing(roots,
1279                                                  classSymbols,
1280                                                  pckSymbols,
1281                                                  deferredDiagnosticHandler);
1282                 // doProcessing will have handled deferred diagnostics
1283             } finally {
1284                 procEnvImpl.close();
1285             }
1286         } catch (CompletionFailure ex) {
1287             log.error(Errors.CantAccess(ex.sym, ex.getDetailValue()));
1288             if (deferredDiagnosticHandler != null) {
1289                 deferredDiagnosticHandler.reportDeferredDiagnostics();
1290                 log.popDiagnosticHandler(deferredDiagnosticHandler);
1291             }
1292         }
1293     }
1294 
1295     private boolean unrecoverableError() {
1296         if (deferredDiagnosticHandler != null) {
1297             for (JCDiagnostic d: deferredDiagnosticHandler.getDiagnostics()) {
1298                 if (d.getKind() == JCDiagnostic.Kind.ERROR && !d.isFlagSet(RECOVERABLE))
1299                     return true;
1300             }
1301         }
1302         return false;
1303     }
1304 
1305     boolean explicitAnnotationProcessingRequested() {
1306         return
1307             explicitAnnotationProcessingRequested ||
1308             explicitAnnotationProcessingRequested(options, fileManager);
1309     }
1310 
1311     static boolean explicitAnnotationProcessingRequested(Options options, JavaFileManager fileManager) {
1312         return
1313             options.isSet(PROCESSOR) ||
1314             options.isSet(PROCESSOR_PATH) ||
1315             options.isSet(PROCESSOR_MODULE_PATH) ||
1316             options.isSet(PROC, "only") ||
1317             options.isSet(PROC, "full") ||
1318             options.isSet(A) ||
1319             options.isSet(XPRINT) ||
1320             fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH);
1321         // Skipping -XprintRounds and -XprintProcessorInfo
1322     }
1323 
1324     public void setDeferredDiagnosticHandler(Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
1325         this.deferredDiagnosticHandler = deferredDiagnosticHandler;
1326     }
1327 
1328     /**
1329      * Attribute a list of parse trees, such as found on the "todo" list.
1330      * Note that attributing classes may cause additional files to be
1331      * parsed and entered via the SourceCompleter.
1332      * Attribution of the entries in the list does not stop if any errors occur.
1333      * @return a list of environments for attribute classes.
1334      */
1335     public Queue<Env<AttrContext>> attribute(Queue<Env<AttrContext>> envs) {
1336         ListBuffer<Env<AttrContext>> results = new ListBuffer<>();
1337         while (!envs.isEmpty())
1338             results.append(attribute(envs.remove()));
1339         return stopIfError(CompileState.ATTR, results);
1340     }
1341 
1342     /**
1343      * Attribute a parse tree.
1344      * @return the attributed parse tree
1345      */
1346     public Env<AttrContext> attribute(Env<AttrContext> env) {
1347         if (compileStates.isDone(env, CompileState.ATTR))
1348             return env;
1349 
1350         if (verboseCompilePolicy)
1351             printNote("[attribute " + env.enclClass.sym + "]");
1352         if (verbose)
1353             log.printVerbose("checking.attribution", env.enclClass.sym);
1354 
1355         if (!taskListener.isEmpty()) {
1356             TaskEvent e = newAnalyzeTaskEvent(env);
1357             taskListener.started(e);
1358         }
1359 
1360         JavaFileObject prev = log.useSource(
1361                                   env.enclClass.sym.sourcefile != null ?
1362                                   env.enclClass.sym.sourcefile :
1363                                   env.toplevel.sourcefile);
1364         try {
1365             attr.attrib(env);
1366             if (errorCount() > 0 && !shouldStop(CompileState.ATTR)) {
1367                 //if in fail-over mode, ensure that AST expression nodes
1368                 //are correctly initialized (e.g. they have a type/symbol)
1369                 attr.postAttr(env.tree);
1370             }
1371             compileStates.put(env, CompileState.ATTR);
1372         }
1373         finally {
1374             log.useSource(prev);
1375         }
1376 
1377         return env;
1378     }
1379 
1380     /**
1381      * Perform dataflow checks on attributed parse trees.
1382      * These include checks for definite assignment and unreachable statements.
1383      * If any errors occur, an empty list will be returned.
1384      * @return the list of attributed parse trees
1385      */
1386     public Queue<Env<AttrContext>> flow(Queue<Env<AttrContext>> envs) {
1387         ListBuffer<Env<AttrContext>> results = new ListBuffer<>();
1388         for (Env<AttrContext> env: envs) {
1389             flow(env, results);
1390         }
1391         return stopIfError(CompileState.FLOW, results);
1392     }
1393 
1394     /**
1395      * Perform dataflow checks on an attributed parse tree.
1396      */
1397     public Queue<Env<AttrContext>> flow(Env<AttrContext> env) {
1398         ListBuffer<Env<AttrContext>> results = new ListBuffer<>();
1399         flow(env, results);
1400         return stopIfError(CompileState.FLOW, results);
1401     }
1402 
1403     /**
1404      * Perform dataflow checks on an attributed parse tree.
1405      */
1406     protected void flow(Env<AttrContext> env, Queue<Env<AttrContext>> results) {
1407         if (compileStates.isDone(env, CompileState.FLOW)) {
1408             results.add(env);
1409             return;
1410         }
1411 
1412         try {
1413             if (shouldStop(CompileState.FLOW))
1414                 return;
1415 
1416             if (verboseCompilePolicy)
1417                 printNote("[flow " + env.enclClass.sym + "]");
1418             JavaFileObject prev = log.useSource(
1419                                                 env.enclClass.sym.sourcefile != null ?
1420                                                 env.enclClass.sym.sourcefile :
1421                                                 env.toplevel.sourcefile);
1422             try {
1423                 make.at(Position.FIRSTPOS);
1424                 TreeMaker localMake = make.forToplevel(env.toplevel);
1425                 flow.analyzeTree(env, localMake);
1426                 compileStates.put(env, CompileState.FLOW);
1427 
1428                 if (shouldStop(CompileState.FLOW))
1429                     return;
1430 
1431                 analyzer.flush(env);
1432 
1433                 results.add(env);
1434             }
1435             finally {
1436                 log.useSource(prev);
1437             }
1438         }
1439         finally {
1440             if (!taskListener.isEmpty()) {
1441                 TaskEvent e = newAnalyzeTaskEvent(env);
1442                 taskListener.finished(e);
1443             }
1444         }
1445     }
1446 
1447     private TaskEvent newAnalyzeTaskEvent(Env<AttrContext> env) {
1448         JCCompilationUnit toplevel = env.toplevel;
1449         ClassSymbol sym;
1450         if (env.enclClass.sym == syms.predefClass) {
1451             if (TreeInfo.isModuleInfo(toplevel)) {
1452                 sym = toplevel.modle.module_info;
1453             } else if (TreeInfo.isPackageInfo(toplevel)) {
1454                 sym = toplevel.packge.package_info;
1455             } else {
1456                 throw new IllegalStateException("unknown env.toplevel");
1457             }
1458         } else {
1459             sym = env.enclClass.sym;
1460         }
1461 
1462         return new TaskEvent(TaskEvent.Kind.ANALYZE, toplevel, sym);
1463     }
1464 
1465     /**
1466      * Prepare attributed parse trees, in conjunction with their attribution contexts,
1467      * for source or code generation.
1468      * If any errors occur, an empty list will be returned.
1469      * @return a list containing the classes to be generated
1470      */
1471     public Queue<Pair<Env<AttrContext>, JCClassDecl>> desugar(Queue<Env<AttrContext>> envs) {
1472         ListBuffer<Pair<Env<AttrContext>, JCClassDecl>> results = new ListBuffer<>();
1473         for (Env<AttrContext> env: envs)
1474             desugar(env, results);
1475         return stopIfError(CompileState.FLOW, results);
1476     }
1477 
1478     HashMap<Env<AttrContext>, Queue<Pair<Env<AttrContext>, JCClassDecl>>> desugaredEnvs = new HashMap<>();
1479 
1480     /**
1481      * Prepare attributed parse trees, in conjunction with their attribution contexts,
1482      * for source or code generation. If the file was not listed on the command line,
1483      * the current implicitSourcePolicy is taken into account.
1484      * The preparation stops as soon as an error is found.
1485      */
1486     protected void desugar(final Env<AttrContext> env, Queue<Pair<Env<AttrContext>, JCClassDecl>> results) {
1487         if (shouldStop(CompileState.TRANSTYPES))
1488             return;
1489 
1490         if (implicitSourcePolicy == ImplicitSourcePolicy.NONE
1491                 && !inputFiles.contains(env.toplevel.sourcefile)) {
1492             return;
1493         }
1494 
1495         if (!modules.multiModuleMode && env.toplevel.modle != modules.getDefaultModule()) {
1496             //can only generate classfiles for a single module:
1497             return;
1498         }
1499 
1500         if (compileStates.isDone(env, CompileState.LOWER)) {
1501             results.addAll(desugaredEnvs.get(env));
1502             return;
1503         }
1504 
1505         /**
1506          * Ensure that superclasses of C are desugared before C itself. This is
1507          * required for two reasons: (i) as erasure (TransTypes) destroys
1508          * information needed in flow analysis and (ii) as some checks carried
1509          * out during lowering require that all synthetic fields/methods have
1510          * already been added to C and its superclasses.
1511          */
1512         class ScanNested extends TreeScanner {
1513             Set<Env<AttrContext>> dependencies = new LinkedHashSet<>();
1514             protected boolean hasLambdas;
1515             protected boolean hasPatterns;
1516             @Override
1517             public void visitClassDef(JCClassDecl node) {
1518                 Type st = types.supertype(node.sym.type);
1519                 boolean envForSuperTypeFound = false;
1520                 while (!envForSuperTypeFound && st.hasTag(CLASS)) {
1521                     ClassSymbol c = st.tsym.outermostClass();
1522                     Env<AttrContext> stEnv = enter.getEnv(c);
1523                     if (stEnv != null && env != stEnv) {
1524                         if (dependencies.add(stEnv)) {
1525                             boolean prevHasLambdas = hasLambdas;
1526                             boolean prevHasPatterns = hasPatterns;
1527                             try {
1528                                 scan(stEnv.tree);
1529                             } finally {
1530                                 /*
1531                                  * ignore any updates to hasLambdas and hasPatterns
1532                                  * made during the nested scan, this ensures an
1533                                  * initialized LambdaToMethod or TransPatterns is
1534                                  * available only to those classes that contain
1535                                  * lambdas or patterns, respectivelly
1536                                  */
1537                                 hasLambdas = prevHasLambdas;
1538                                 hasPatterns = prevHasPatterns;
1539                             }
1540                         }
1541                         envForSuperTypeFound = true;
1542                     }
1543                     st = types.supertype(st);
1544                 }
1545                 super.visitClassDef(node);
1546             }
1547             @Override
1548             public void visitLambda(JCLambda tree) {
1549                 hasLambdas = true;
1550                 super.visitLambda(tree);
1551             }
1552             @Override
1553             public void visitReference(JCMemberReference tree) {
1554                 hasLambdas = true;
1555                 super.visitReference(tree);
1556             }
1557             @Override
1558             public void visitBindingPattern(JCBindingPattern tree) {
1559                 hasPatterns = true;
1560                 super.visitBindingPattern(tree);
1561             }
1562             @Override
1563             public void visitRecordPattern(JCRecordPattern that) {
1564                 hasPatterns = true;
1565                 super.visitRecordPattern(that);
1566             }
1567             @Override
1568             public void visitSwitch(JCSwitch tree) {
1569                 hasPatterns |= tree.patternSwitch;
1570                 super.visitSwitch(tree);
1571             }
1572             @Override
1573             public void visitSwitchExpression(JCSwitchExpression tree) {
1574                 hasPatterns |= tree.patternSwitch;
1575                 super.visitSwitchExpression(tree);
1576             }
1577         }
1578         ScanNested scanner = new ScanNested();
1579         scanner.scan(env.tree);
1580         for (Env<AttrContext> dep: scanner.dependencies) {
1581         if (!compileStates.isDone(dep, CompileState.FLOW))
1582             desugaredEnvs.put(dep, desugar(flow(attribute(dep))));
1583         }
1584 
1585         //We need to check for error another time as more classes might
1586         //have been attributed and analyzed at this stage
1587         if (shouldStop(CompileState.TRANSTYPES))
1588             return;
1589 
1590         if (verboseCompilePolicy)
1591             printNote("[desugar " + env.enclClass.sym + "]");
1592 
1593         JavaFileObject prev = log.useSource(env.enclClass.sym.sourcefile != null ?
1594                                   env.enclClass.sym.sourcefile :
1595                                   env.toplevel.sourcefile);
1596         try {
1597             //save tree prior to rewriting
1598             JCTree untranslated = env.tree;
1599 
1600             make.at(Position.FIRSTPOS);
1601             TreeMaker localMake = make.forToplevel(env.toplevel);
1602 
1603             if (env.tree.hasTag(JCTree.Tag.PACKAGEDEF) || env.tree.hasTag(JCTree.Tag.MODULEDEF)) {
1604                 if (!(sourceOutput)) {
1605                     if (shouldStop(CompileState.LOWER))
1606                         return;
1607                     List<JCTree> def = lower.translateTopLevelClass(env, env.tree, localMake);
1608                     if (def.head != null) {
1609                         Assert.check(def.tail.isEmpty());
1610                         results.add(new Pair<>(env, (JCClassDecl)def.head));
1611                     }
1612                 }
1613                 return;
1614             }
1615 
1616             if (shouldStop(CompileState.TRANSTYPES))
1617                 return;
1618 
1619             env.tree = transTypes.translateTopLevelClass(env.tree, localMake);
1620             compileStates.put(env, CompileState.TRANSTYPES);
1621 
1622             if (shouldStop(CompileState.TRANSLITERALS))
1623                 return;
1624 
1625             env.tree = TransLiterals.instance(context).translateTopLevelClass(env, env.tree, localMake);
1626             compileStates.put(env, CompileState.TRANSLITERALS);
1627 
1628             if (shouldStop(CompileState.TRANSPATTERNS))
1629                 return;
1630 
1631             if (scanner.hasPatterns) {
1632                 env.tree = TransPatterns.instance(context).translateTopLevelClass(env, env.tree, localMake);
1633             }
1634 
1635             compileStates.put(env, CompileState.TRANSPATTERNS);
1636 
1637             if (scanner.hasLambdas) {
1638                 if (shouldStop(CompileState.UNLAMBDA))
1639                     return;
1640 
1641                 env.tree = LambdaToMethod.instance(context).translateTopLevelClass(env, env.tree, localMake);
1642                 compileStates.put(env, CompileState.UNLAMBDA);
1643             }
1644 
1645             if (shouldStop(CompileState.LOWER))
1646                 return;
1647 
1648             if (sourceOutput) {
1649                 //emit standard Java source file, only for compilation
1650                 //units enumerated explicitly on the command line
1651                 JCClassDecl cdef = (JCClassDecl)env.tree;
1652                 if (untranslated instanceof JCClassDecl classDecl &&
1653                     rootClasses.contains(classDecl)) {
1654                     results.add(new Pair<>(env, cdef));
1655                 }
1656                 return;
1657             }
1658 
1659             //translate out inner classes
1660             List<JCTree> cdefs = lower.translateTopLevelClass(env, env.tree, localMake);
1661             compileStates.put(env, CompileState.LOWER);
1662 
1663             if (shouldStop(CompileState.LOWER))
1664                 return;
1665 
1666             //generate code for each class
1667             for (List<JCTree> l = cdefs; l.nonEmpty(); l = l.tail) {
1668                 JCClassDecl cdef = (JCClassDecl)l.head;
1669                 results.add(new Pair<>(env, cdef));
1670             }
1671         }
1672         finally {
1673             log.useSource(prev);
1674         }
1675 
1676     }
1677 
1678     /** Generates the source or class file for a list of classes.
1679      * The decision to generate a source file or a class file is
1680      * based upon the compiler's options.
1681      * Generation stops if an error occurs while writing files.
1682      */
1683     public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue) {
1684         generate(queue, null);
1685     }
1686 
1687     public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue, Queue<JavaFileObject> results) {
1688         if (shouldStop(CompileState.GENERATE))
1689             return;
1690 
1691         for (Pair<Env<AttrContext>, JCClassDecl> x: queue) {
1692             Env<AttrContext> env = x.fst;
1693             JCClassDecl cdef = x.snd;
1694 
1695             if (verboseCompilePolicy) {
1696                 printNote("[generate " + (sourceOutput ? " source" : "code") + " " + cdef.sym + "]");
1697             }
1698 
1699             if (!taskListener.isEmpty()) {
1700                 TaskEvent e = new TaskEvent(TaskEvent.Kind.GENERATE, env.toplevel, cdef.sym);
1701                 taskListener.started(e);
1702             }
1703 
1704             JavaFileObject prev = log.useSource(env.enclClass.sym.sourcefile != null ?
1705                                       env.enclClass.sym.sourcefile :
1706                                       env.toplevel.sourcefile);
1707             try {
1708                 JavaFileObject file;
1709                 if (sourceOutput) {
1710                     file = printSource(env, cdef);
1711                 } else {
1712                     if (fileManager.hasLocation(StandardLocation.NATIVE_HEADER_OUTPUT)
1713                             && jniWriter.needsHeader(cdef.sym)) {
1714                         jniWriter.write(cdef.sym);
1715                     }
1716                     file = genCode(env, cdef);
1717                 }
1718                 if (results != null && file != null)
1719                     results.add(file);
1720             } catch (IOException
1721                     | UncheckedIOException
1722                     | FileSystemNotFoundException
1723                     | InvalidPathException
1724                     | ReadOnlyFileSystemException ex) {
1725                 log.error(cdef.pos(),
1726                           Errors.ClassCantWrite(cdef.sym, ex.getMessage()));
1727                 return;
1728             } finally {
1729                 log.useSource(prev);
1730             }
1731 
1732             if (!taskListener.isEmpty()) {
1733                 TaskEvent e = new TaskEvent(TaskEvent.Kind.GENERATE, env.toplevel, cdef.sym);
1734                 taskListener.finished(e);
1735             }
1736         }
1737     }
1738 
1739         // where
1740         Map<JCCompilationUnit, Queue<Env<AttrContext>>> groupByFile(Queue<Env<AttrContext>> envs) {
1741             // use a LinkedHashMap to preserve the order of the original list as much as possible
1742             Map<JCCompilationUnit, Queue<Env<AttrContext>>> map = new LinkedHashMap<>();
1743             for (Env<AttrContext> env: envs) {
1744                 Queue<Env<AttrContext>> sublist = map.get(env.toplevel);
1745                 if (sublist == null) {
1746                     sublist = new ListBuffer<>();
1747                     map.put(env.toplevel, sublist);
1748                 }
1749                 sublist.add(env);
1750             }
1751             return map;
1752         }
1753 
1754         JCClassDecl removeMethodBodies(JCClassDecl cdef) {
1755             final boolean isInterface = (cdef.mods.flags & Flags.INTERFACE) != 0;
1756             class MethodBodyRemover extends TreeTranslator {
1757                 @Override
1758                 public void visitMethodDef(JCMethodDecl tree) {
1759                     tree.mods.flags &= ~Flags.SYNCHRONIZED;
1760                     for (JCVariableDecl vd : tree.params)
1761                         vd.mods.flags &= ~Flags.FINAL;
1762                     tree.body = null;
1763                     super.visitMethodDef(tree);
1764                 }
1765                 @Override
1766                 public void visitVarDef(JCVariableDecl tree) {
1767                     if (tree.init != null && tree.init.type.constValue() == null)
1768                         tree.init = null;
1769                     super.visitVarDef(tree);
1770                 }
1771                 @Override
1772                 public void visitClassDef(JCClassDecl tree) {
1773                     ListBuffer<JCTree> newdefs = new ListBuffer<>();
1774                     for (List<JCTree> it = tree.defs; it.tail != null; it = it.tail) {
1775                         JCTree t = it.head;
1776                         switch (t.getTag()) {
1777                         case CLASSDEF:
1778                             if (isInterface ||
1779                                 (((JCClassDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
1780                                 (((JCClassDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCClassDecl) t).sym.packge().getQualifiedName() == names.java_lang)
1781                                 newdefs.append(t);
1782                             break;
1783                         case METHODDEF:
1784                             if (isInterface ||
1785                                 (((JCMethodDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
1786                                 ((JCMethodDecl) t).sym.name == names.init ||
1787                                 (((JCMethodDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCMethodDecl) t).sym.packge().getQualifiedName() == names.java_lang)
1788                                 newdefs.append(t);
1789                             break;
1790                         case VARDEF:
1791                             if (isInterface || (((JCVariableDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
1792                                 (((JCVariableDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCVariableDecl) t).sym.packge().getQualifiedName() == names.java_lang)
1793                                 newdefs.append(t);
1794                             break;
1795                         default:
1796                             break;
1797                         }
1798                     }
1799                     tree.defs = newdefs.toList();
1800                     super.visitClassDef(tree);
1801                 }
1802             }
1803             MethodBodyRemover r = new MethodBodyRemover();
1804             return r.translate(cdef);
1805         }
1806 
1807     public void reportDeferredDiagnostics() {
1808         if (errorCount() == 0
1809                 && annotationProcessingOccurred
1810                 && implicitSourceFilesRead
1811                 && implicitSourcePolicy == ImplicitSourcePolicy.UNSET) {
1812             if (explicitAnnotationProcessingRequested())
1813                 log.warning(Warnings.ProcUseImplicit);
1814             else
1815                 log.warning(Warnings.ProcUseProcOrImplicit);
1816         }
1817         chk.reportDeferredDiagnostics();
1818         preview.reportDeferredDiagnostics();
1819         if (log.compressedOutput) {
1820             log.mandatoryNote(null, Notes.CompressedDiags);
1821         }
1822     }
1823 
1824     public void enterDone() {
1825         enterDone = true;
1826         annotate.enterDone();
1827     }
1828 
1829     public boolean isEnterDone() {
1830         return enterDone;
1831     }
1832 
1833     private Name readModuleName(JavaFileObject fo) {
1834         return parseAndGetName(fo, t -> {
1835             JCModuleDecl md = t.getModuleDecl();
1836 
1837             return md != null ? TreeInfo.fullName(md.getName()) : null;
1838         });
1839     }
1840 
1841     private Name findPackageInFile(JavaFileObject fo) {
1842         return parseAndGetName(fo, t -> t.getPackage() != null ?
1843                                         TreeInfo.fullName(t.getPackage().getPackageName()) : null);
1844     }
1845 
1846     private Name parseAndGetName(JavaFileObject fo,
1847                                  Function<JCTree.JCCompilationUnit, Name> tree2Name) {
1848         DiagnosticHandler dh = new DiscardDiagnosticHandler(log);
1849         JavaFileObject prevSource = log.useSource(fo);
1850         try {
1851             JCTree.JCCompilationUnit t = parse(fo, fo.getCharContent(false), true);
1852             return tree2Name.apply(t);
1853         } catch (IOException e) {
1854             return null;
1855         } finally {
1856             log.popDiagnosticHandler(dh);
1857             log.useSource(prevSource);
1858         }
1859     }
1860 
1861     /** Close the compiler, flushing the logs
1862      */
1863     public void close() {
1864         rootClasses = null;
1865         finder = null;
1866         reader = null;
1867         make = null;
1868         writer = null;
1869         enter = null;
1870         if (todo != null)
1871             todo.clear();
1872         todo = null;
1873         parserFactory = null;
1874         syms = null;
1875         source = null;
1876         attr = null;
1877         chk = null;
1878         gen = null;
1879         flow = null;
1880         transTypes = null;
1881         lower = null;
1882         annotate = null;
1883         types = null;
1884 
1885         log.flush();
1886         try {
1887             fileManager.flush();
1888         } catch (IOException e) {
1889             throw new Abort(e);
1890         } finally {
1891             if (names != null)
1892                 names.dispose();
1893             names = null;
1894 
1895             FatalError fatalError = null;
1896             for (Closeable c: closeables) {
1897                 try {
1898                     c.close();
1899                 } catch (IOException e) {
1900                     if (fatalError == null) {
1901                         JCDiagnostic msg = diagFactory.fragment(Fragments.FatalErrCantClose);
1902                         fatalError = new FatalError(msg, e);
1903                     } else {
1904                         fatalError.addSuppressed(e);
1905                     }
1906                 }
1907             }
1908             if (fatalError != null) {
1909                 throw fatalError;
1910             }
1911             closeables = List.nil();
1912         }
1913     }
1914 
1915     protected void printNote(String lines) {
1916         log.printRawLines(Log.WriterKind.NOTICE, lines);
1917     }
1918 
1919     /** Print numbers of errors and warnings.
1920      */
1921     public void printCount(String kind, int count) {
1922         if (count != 0) {
1923             String key;
1924             if (count == 1)
1925                 key = "count." + kind;
1926             else
1927                 key = "count." + kind + ".plural";
1928             log.printLines(WriterKind.ERROR, key, String.valueOf(count));
1929             log.flush(Log.WriterKind.ERROR);
1930         }
1931     }
1932 
1933     private void printSuppressedCount(int shown, int suppressed, String diagKey) {
1934         if (suppressed > 0) {
1935             int total = shown + suppressed;
1936             log.printLines(WriterKind.ERROR, diagKey,
1937                     String.valueOf(shown), String.valueOf(total));
1938             log.flush(Log.WriterKind.ERROR);
1939         }
1940     }
1941 
1942     private static long now() {
1943         return System.currentTimeMillis();
1944     }
1945 
1946     private static long elapsed(long then) {
1947         return now() - then;
1948     }
1949 
1950     public void newRound() {
1951         inputFiles.clear();
1952         todo.clear();
1953     }
1954 
1955     public interface InitialFileParserIntf {
1956         public List<JCCompilationUnit> parse(Iterable<JavaFileObject> files);
1957     }
1958 
1959     public static class InitialFileParser implements InitialFileParserIntf {
1960 
1961         public static final Key<InitialFileParserIntf> initialParserKey = new Key<>();
1962 
1963         public static InitialFileParserIntf instance(Context context) {
1964             InitialFileParserIntf instance = context.get(initialParserKey);
1965             if (instance == null)
1966                 instance = new InitialFileParser(context);
1967             return instance;
1968         }
1969 
1970         private final JavaCompiler compiler;
1971 
1972         private InitialFileParser(Context context) {
1973             context.put(initialParserKey, this);
1974             this.compiler = JavaCompiler.instance(context);
1975         }
1976 
1977         @Override
1978         public List<JCCompilationUnit> parse(Iterable<JavaFileObject> fileObjects) {
1979            return compiler.parseFiles(fileObjects, false);
1980         }
1981     }
1982 }