com.google.javascript.jscomp.AbstractCommandLineRunner Maven / Gradle / Ivy

At minimum, this is what will be printed when `--version` is passed. */ protected abstract String getVersionText(); @GwtIncompatible("Unnecessary") private static InputStream getExternsInput() { InputStream input = AbstractCommandLineRunner.class.getResourceAsStream("/externs.zip"); if (input == null) { // In some environments, the externs.zip is relative to this class. input = AbstractCommandLineRunner.class.getResourceAsStream("externs.zip"); } checkNotNull(input); return input; } /** Runs the Compiler and calls System.exit() with the exit status of the compiler. */ @GwtIncompatible("Unnecessary") public final void run() { int result; try { result = doRun(); } catch (FlagUsageException e) { err.println(e.getMessage()); result = -1; } catch (Throwable t) { t.printStackTrace(err); result = -2; } exitCodeReceiver.apply(result); } /** Returns the PrintStream for writing errors associated with this AbstractCommandLineRunner. */ @GwtIncompatible("Unnecessary") protected final PrintStream getErrorPrintStream() { return err; } @GwtIncompatible("Unnecessary") public List parseJsonFilesFromInputStream() throws IOException { List jsonFiles = new ArrayList<>(); try (JsonReader reader = new JsonReader(new InputStreamReader(this.in, inputCharset))) { reader.beginArray(); while (reader.hasNext()) { JsonFileSpec jsonFile = gson.fromJson(reader, JsonFileSpec.class); jsonFiles.add(jsonFile); } reader.endArray(); } return jsonFiles; } /** * Creates inputs from a list of files. * * @param files A list of flag entries indicates js and zip file names. * @param allowStdIn Whether '-' is allowed appear as a filename to represent stdin. If true, '-' * is only allowed to appear once. * @param jsChunkSpecs A list chunk specs. * @return An array of inputs */ @GwtIncompatible("Unnecessary") private List createInputs( List> files, boolean allowStdIn, List jsChunkSpecs) throws IOException { return createInputs(files, /* jsonFiles= */ null, allowStdIn, jsChunkSpecs); } /** * Creates inputs from a list of source files and json files. * * @param files A list of flag entries indicates js and zip file names. * @param jsonFiles A list of json encoded files. * @param jsChunkSpecs A list chunk specs. * @return An array of inputs */ @GwtIncompatible("Unnecessary") private List createInputs( List> files, List jsonFiles, List jsChunkSpecs) throws IOException { return createInputs(files, jsonFiles, /* allowStdIn= */ false, jsChunkSpecs); } /** * Creates inputs from a list of source files, zips and json files. * *

Can be overridden by subclasses who want to pull files from different places. * * @param files A list of flag entries indicates js and zip file names * @param jsonFiles A list of json encoded files. * @param allowStdIn Whether '-' is allowed appear as a filename to represent stdin. If true, '-' * is only allowed to appear once. * @param jsChunkSpecs A list chunk specs. * @return An array of inputs */ @GwtIncompatible("Unnecessary") protected List createInputs( List> files, @Nullable List jsonFiles, boolean allowStdIn, List jsChunkSpecs) throws IOException { List inputs = new ArrayList<>(files.size()); boolean usingStdin = false; int jsChunkIndex = 0; JsChunkSpec jsChunkSpec = Iterables.getFirst(jsChunkSpecs, null); int cumulatedInputFilesExpected = jsChunkSpec == null ? Integer.MAX_VALUE : jsChunkSpec.getNumInputs(); for (int i = 0; i < files.size(); i++) { FlagEntry file = files.get(i); String filename = file.value; if (file.flag == JsSourceType.JS_ZIP) { if (this.config.typedAstListInputFilename != null) { throw new FlagUsageException("Can't use TypedASTs with --zip."); } if (!"-".equals(filename)) { List newFiles = SourceFile.fromZipFile(filename, inputCharset); // Update the manifest maps for new zip entries. if (rootRelativePathsMap.containsKey(filename)) { String rootFilename = rootRelativePathsMap.get(filename); for (SourceFile zipEntry : newFiles) { String zipEntryName = zipEntry.getName(); checkState(zipEntryName.contains(filename)); String zipmap = zipEntryName.replace(filename, rootFilename); rootRelativePathsMap.put(zipEntryName, zipmap); } } inputs.addAll(newFiles); if (jsChunkSpec != null) { jsChunkSpec.numJsFiles += newFiles.size() - 1; } } } else if (!"-".equals(filename)) { SourceKind kind = file.flag == JsSourceType.WEAKDEP ? SourceKind.WEAK : SourceKind.STRONG; SourceFile newFile = SourceFile.builder() .withPath(filename) .withCharset(inputCharset) .withKind(kind) .build(); inputs.add(newFile); } else { if (this.config.typedAstListInputFilename != null) { throw new FlagUsageException("Can't use TypedASTs with stdin."); } if (!config.defaultToStdin) { throw new FlagUsageException("Can't specify stdin."); } if (usingStdin) { throw new FlagUsageException("Can't specify stdin twice."); } if (!config.outputManifests.isEmpty()) { throw new FlagUsageException( "Manifest files cannot be generated when the input is from stdin."); } if (!config.outputBundles.isEmpty()) { throw new FlagUsageException( "Bundle files cannot be generated when the input is from stdin."); } this.err.println(WAITING_FOR_INPUT_WARNING); inputs.add( SourceFile.builder() .withPath("stdin") .withContent(this.in) .withCharset(inputCharset) .build()); usingStdin = true; } if (i >= cumulatedInputFilesExpected - 1) { jsChunkIndex++; if (jsChunkIndex < jsChunkSpecs.size()) { jsChunkSpec = jsChunkSpecs.get(jsChunkIndex); cumulatedInputFilesExpected += jsChunkSpec.getNumInputs(); } } } if (jsonFiles != null) { for (JsonFileSpec jsonFile : jsonFiles) { inputs.add(SourceFile.fromCode(jsonFile.getPath(), jsonFile.getSrc())); } } return inputs; } /** * Removes input --ijs files whose basename matches an input --js or --weakdep file. * * @throws FlagUsageException If there are both input --ijs files and module specs. */ @GwtIncompatible("Unnecessary") private ImmutableList deduplicateIjsFiles( List> files, List moduleRoots, boolean hasModuleSpecs) { ImmutableList.Builder errors = ImmutableList.builder(); // First pass: collect the (module root relative) names of --js and --weakdep files. Map relativeToAbsoluteName = new LinkedHashMap<>(); for (FlagEntry file : files) { // TODO(tjgq): Handle zip files. if (file.flag == JsSourceType.JS || file.flag == JsSourceType.WEAKDEP) { String absoluteName = file.value; String relativeName = getModuleRootRelativeName(absoluteName, moduleRoots); relativeToAbsoluteName.put(relativeName, absoluteName); } } // Second pass: drop --ijs files whose (module root relative) name matches a --js or --weakdep // file. Iterator> iterator = files.iterator(); while (iterator.hasNext()) { FlagEntry file = iterator.next(); if (file.flag == JsSourceType.IJS) { if (hasModuleSpecs) { throw new FlagUsageException("--ijs is incompatible with --chunk or --module."); } String absoluteName = file.value; if (!absoluteName.endsWith(".i.js")) { errors.add(JSError.make(IjsErrors.BAD_IJS_FILE_NAME, absoluteName)); continue; } String relativeName = getModuleRootRelativeName(absoluteName, moduleRoots); String relativeNonIjsName = relativeName.substring(0, relativeName.length() - ".i.js".length()); if (relativeToAbsoluteName.containsKey(relativeNonIjsName)) { errors.add( JSError.make( IjsErrors.CONFLICTING_IJS_FILE, relativeToAbsoluteName.get(relativeNonIjsName), absoluteName)); iterator.remove(); } } } return errors.build(); } private String getModuleRootRelativeName(String filename, List moduleRoots) { for (String moduleRoot : moduleRoots) { if (filename.startsWith(moduleRoot + "/")) { return filename.substring(moduleRoot.length() + 1); } } return filename; } /** Creates JS source code inputs from a list of files. */ @GwtIncompatible("Unnecessary") private @Nullable List createSourceInputs( List jsChunkSpecs, List> files, List jsonFiles, List moduleRoots) throws IOException { if (isInTestMode()) { return inputsSupplierForTesting != null ? inputsSupplierForTesting.get() : null; } if (files.isEmpty() && jsonFiles == null && config.defaultToStdin) { // Request to read from stdin. files = ImmutableList.of(new FlagEntry(JsSourceType.JS, "-")); } for (JSError error : deduplicateIjsFiles(files, moduleRoots, !jsChunkSpecs.isEmpty())) { compiler.report(error); } try { if (jsonFiles != null) { return createInputs(files, jsonFiles, jsChunkSpecs); } else { return createInputs(files, true, jsChunkSpecs); } } catch (FlagUsageException e) { throw new FlagUsageException("Bad --js flag. " + e.getMessage()); } } /** Creates JS extern inputs from a list of files. */ @GwtIncompatible("Unnecessary") private List createExternInputs(List files) throws IOException { List> externFiles = new ArrayList<>(); for (String file : files) { externFiles.add(new FlagEntry(JsSourceType.EXTERN, file)); } try { return createInputs(externFiles, false, new ArrayList()); } catch (FlagUsageException e) { throw new FlagUsageException("Bad --externs flag. " + e.getMessage()); } } /** * Creates chunk objects from a list of chunk specifications. * * @param specs A list of chunk specifications, not null or empty. * @param inputs A list of JS file paths, not null * @return An array of module objects */ public static List createJsChunks(List specs, List inputs) { checkState(specs != null); checkState(!specs.isEmpty()); checkState(inputs != null); List chunkNames = new ArrayList<>(specs.size()); Map chunksByName = new LinkedHashMap<>(); Map modulesFileCountMap = new LinkedHashMap<>(); int numJsFilesExpected = 0; int minJsFilesRequired = 0; for (JsChunkSpec spec : specs) { if (chunksByName.containsKey(spec.name)) { throw new FlagUsageException("Duplicate module name: " + spec.name); } JSChunk chunk = new JSChunk(spec.name); for (String dep : spec.deps) { JSChunk other = chunksByName.get(dep); if (other == null) { throw new FlagUsageException( "Module '" + spec.name + "' depends on unknown module '" + dep + "'. Be sure to list modules in dependency order."); } chunk.addDependency(other); } // We will allow modules of zero input. if (spec.numJsFiles < 0) { numJsFilesExpected = -1; } else { minJsFilesRequired += spec.numJsFiles; } if (numJsFilesExpected >= 0) { numJsFilesExpected += spec.numJsFiles; } // Add modules in reverse order so that source files are allocated to // modules in reverse order. This allows the first module // (presumably the base module) to have a size of 'auto' chunkNames.add(0, spec.name); modulesFileCountMap.put(spec.name, spec.numJsFiles); chunksByName.put(spec.name, chunk); } final int totalNumJsFiles = inputs.size(); if (numJsFilesExpected >= 0 || minJsFilesRequired > totalNumJsFiles) { if (minJsFilesRequired > totalNumJsFiles) { numJsFilesExpected = minJsFilesRequired; } if (numJsFilesExpected > totalNumJsFiles) { throw new FlagUsageException( "Not enough JS files specified. Expected " + numJsFilesExpected + " but found " + totalNumJsFiles); } else if (numJsFilesExpected < totalNumJsFiles) { throw new FlagUsageException( "Too many JS files specified. Expected " + numJsFilesExpected + " but found " + totalNumJsFiles); } } int numJsFilesLeft = totalNumJsFiles; int moduleIndex = 0; for (String chunkName : chunkNames) { // Parse module inputs. int numJsFiles = modulesFileCountMap.get(chunkName); JSChunk chunk = chunksByName.get(chunkName); // Check if the first chunk specified 'auto' for the number of files if (moduleIndex == chunkNames.size() - 1 && numJsFiles == -1) { numJsFiles = numJsFilesLeft; } List moduleFiles = inputs.subList(numJsFilesLeft - numJsFiles, numJsFilesLeft); for (CompilerInput input : moduleFiles) { chunk.add(input); } numJsFilesLeft -= numJsFiles; moduleIndex++; } return new ArrayList<>(chunksByName.values()); } /** * Validates the module name. Can be overridden by subclasses. * * @param name The module name */ @GwtIncompatible("Unnecessary") protected void checkModuleName(String name) { if (!TokenStream.isJSIdentifier(name)) { throw new FlagUsageException("Invalid module name: '" + name + "'"); } } /** * Parses module wrapper specifications. * * @param specs A list of module wrapper specifications, not null. The spec format is: * name:wrapper. Wrappers. * @param chunks The JS chunks whose wrappers are specified * @return A map from module name to module wrapper. Modules with no wrapper will have the empty * string as their value in this map. */ public static Map parseModuleWrappers( List specs, Iterable chunks) { checkState(specs != null); Map wrappers = new LinkedHashMap<>(); // Prepopulate the map with module names. for (JSChunk c : chunks) { wrappers.put(c.getName(), ""); } for (String spec : specs) { // Format is ":". int pos = spec.indexOf(':'); if (pos == -1) { throw new FlagUsageException( "Expected module wrapper to have " + ": format: " + spec); } // Parse module name. String name = spec.substring(0, pos); if (!wrappers.containsKey(name)) { throw new FlagUsageException("Unknown module: '" + name + "'"); } String wrapper = spec.substring(pos + 1); // Support for %n% and %output% wrapper = wrapper.replace("%output%", "%s").replace("%n%", "\n"); if (!wrapper.contains("%s")) { throw new FlagUsageException("No %s placeholder in module wrapper: '" + wrapper + "'"); } wrappers.put(name, wrapper); } return wrappers; } /** * Parses module output name specifications. * * @param specs A list of module output name specifications, not null. The spec format is: {@code * name:output_file}. * @return A map from module name to module output file name, if declared. Modules with no * predeclared output file name will have no entry in this map. */ private static ImmutableMap parseModuleOutputFiles(List specs) { checkArgument(specs != null); ImmutableMap.Builder outputFilesBuilder = ImmutableMap.builder(); for (String spec : specs) { // Format is ":". int pos = spec.indexOf(':'); if (pos == -1) { throw new FlagUsageException( "Expected chunk_output_file to have " + ": format: " + spec); } String name = spec.substring(0, pos); String filename = spec.substring(pos + 1); outputFilesBuilder.put(name, filename); } return outputFilesBuilder.buildOrThrow(); } /** * Returns the output file name for a chunk. * *

For chunks with predeclared output file names specified using {@code --chunk_output_file}, * the output file name is {@code /} * *

Otherwise, the output file name is {@code /.js} */ @GwtIncompatible("Unnecessary") @VisibleForTesting String getChunkOutputFileName(JSChunk m) { if (parsedModuleOutputFiles == null) { parsedModuleOutputFiles = parseModuleOutputFiles(config.moduleOutputFiles); } String outputFile = parsedModuleOutputFiles.get(m.getName()); if (outputFile != null) { return config.moduleOutputPathPrefix + outputFile; } return config.moduleOutputPathPrefix + m.getName() + ".js"; } /** Returns the conformance file name for a chunk. */ @GwtIncompatible("Unnecessary") @VisibleForTesting String getChunkConformanceFileName(JSChunk m) { if (parsedModuleConformanceFiles == null) { parsedModuleConformanceFiles = parseModuleOutputFiles(config.moduleConformanceFiles); } return parsedModuleConformanceFiles.get(m.getName()); } @VisibleForTesting @GwtIncompatible("Unnecessary") void writeModuleOutput(String fileName, Appendable out, LicenseTracker lt, JSChunk m) throws IOException { if (parsedModuleWrappers == null) { parsedModuleWrappers = parseModuleWrappers( config.moduleWrapper, ImmutableList.copyOf(compiler.getChunkGraph().getAllChunks())); } if (!isOutputInJson()) { maybeCreateDirsForPath(fileName); } String baseName = new File(fileName).getName(); writeOutput( out, compiler, lt, m, parsedModuleWrappers.get(m.getName()).replace("%basename%", baseName), "%s", null, fileName); } /** * Writes code to an output stream, optionally wrapping it in an arbitrary wrapper that contains a * placeholder where the code should be inserted. * * @param chunk Which chunk to write. If this is null, write the entire AST. */ @GwtIncompatible("Unnecessary") void writeOutput( Appendable out, Compiler compiler, LicenseTracker licenseTracker, @Nullable JSChunk chunk, String wrapper, String codePlaceholder, @Nullable Function escaper, String filename) throws IOException { if (compiler.getOptions().outputJs == OutputJs.SENTINEL) { out.append("// No JS output because the compiler was run in checks-only mode.\n"); return; } checkState(compiler.getOptions().outputJs == OutputJs.NORMAL); String code = chunk == null ? compiler.toSource() : compiler.toSource(licenseTracker, chunk); writeOutput(out, compiler, code, wrapper, codePlaceholder, escaper, filename); } /** * Writes code to an output stream, optionally wrapping it in an arbitrary wrapper that contains a * placeholder where the code should be inserted. */ @GwtIncompatible("Unnecessary") @VisibleForTesting void writeOutput( Appendable out, Compiler compiler, String code, String wrapper, String codePlaceholder, @Nullable Function escaper, String filename) throws IOException { int pos = wrapper.indexOf(codePlaceholder); if (pos != -1) { String prefix = ""; if (pos > 0) { prefix = wrapper.substring(0, pos); out.append(prefix); } out.append(escaper == null ? code : escaper.apply(code)); int suffixStart = pos + codePlaceholder.length(); if (suffixStart != wrapper.length()) { // Something after placeholder? out.append(wrapper.substring(suffixStart)); } // Make sure we always end output with a line feed. out.append('\n'); // If we have a source map, adjust its offsets to match // the code WITHIN the wrapper. if (compiler != null && compiler.getSourceMap() != null) { compiler.getSourceMap().setWrapperPrefix(prefix); } } else { out.append(code); out.append('\n'); } } /** Creates any directories necessary to write a file that will have a given path prefix. */ @GwtIncompatible("Unnecessary") private static void maybeCreateDirsForPath(String pathPrefix) { if (!Strings.isNullOrEmpty(pathPrefix)) { File parent = new File(pathPrefix).getParentFile(); if (parent != null) { parent.mkdirs(); } } } @GwtIncompatible("Unnecessary") private Appendable createDefaultOutput() throws IOException { boolean writeOutputToFile = !config.jsOutputFile.isEmpty(); if (writeOutputToFile) { return fileNameToLegacyOutputWriter(config.jsOutputFile); } else { return streamToLegacyOutputWriter(defaultJsOutput); } } @GwtIncompatible("Unnecessary") private static void closeAppendable(Appendable output) throws IOException { if (output instanceof Flushable) { ((Flushable) output).flush(); } if (output instanceof Closeable) { ((Closeable) output).close(); } } /** * Parses command-line arguments and runs the compiler. * * @return system exit status */ @GwtIncompatible("Unnecessary") protected int doRun() throws IOException { CompileMetricsRecorderInterface metricsRecorder = getCompileMetricsRecorder(); metricsRecorder.recordActionStart(); if (this.config.printVersion) { this.defaultJsOutput.println(this.getVersionText()); this.defaultJsOutput.flush(); return 0; } Compiler.setLoggingLevel(Level.parse(config.loggingLevel)); compiler = createCompiler(); B options = createOptions(); setRunOptions(options); @Nullable String typedAstListInputFilename = config.typedAstListInputFilename; List externs = createExterns(options); List chunks = null; rootRelativePathsMap = constructRootRelativePathsMap(); boolean writeOutputToFile = !config.jsOutputFile.isEmpty(); List outputFileNames = new ArrayList<>(); if (writeOutputToFile) { outputFileNames.add(config.jsOutputFile); } boolean createCommonJsModules = false; if (options.getProcessCommonJSModules() && (config.module.size() == 1 && "auto".equals(config.module.get(0)))) { createCommonJsModules = true; config.module.remove(0); } List jsChunkSpecs = new ArrayList<>(); for (int i = 0; i < config.module.size(); i++) { jsChunkSpecs.add(JsChunkSpec.create(config.module.get(i), i == 0)); } List jsonFiles = null; if (config.jsonStreamMode == JsonStreamMode.IN || config.jsonStreamMode == JsonStreamMode.BOTH) { jsonFiles = parseJsonFilesFromInputStream(); ImmutableMap.Builder inputSourceMaps = new ImmutableMap.Builder<>(); ImmutableMap.Builder inputPathByWebpackId = new ImmutableMap.Builder<>(); boolean foundJsonInputSourceMap = false; for (JsonFileSpec jsonFile : jsonFiles) { if (jsonFile.getSourceMap() != null && jsonFile.getSourceMap().length() > 0) { String sourceMapPath = jsonFile.getPath() + ".map"; SourceFile sourceMap = SourceFile.fromCode(sourceMapPath, jsonFile.getSourceMap()); inputSourceMaps.put(jsonFile.getPath(), new SourceMapInput(sourceMap)); foundJsonInputSourceMap = true; } if (jsonFile.getWebpackId() != null) { inputPathByWebpackId.put(jsonFile.getWebpackId(), jsonFile.getPath()); } } if (foundJsonInputSourceMap) { inputSourceMaps.putAll(options.inputSourceMaps); options.inputSourceMaps = inputSourceMaps.buildOrThrow(); } compiler.initWebpackMap(inputPathByWebpackId.buildOrThrow()); } else { ImmutableMap emptyMap = ImmutableMap.of(); compiler.initWebpackMap(emptyMap); } options.setDoLateLocalization(config.shouldDoLateLocalization()); options.setAlwaysGatherSourceMapInfo(config.shouldAlwaysGatherSourceMapInfo()); compiler.initOptions(options); List sources = createSourceInputs(jsChunkSpecs, config.mixedJsSources, jsonFiles, config.moduleRoots); if (!jsChunkSpecs.isEmpty()) { if (isInTestMode()) { chunks = chunksSupplierForTesting.get(); } else { if (JsonStreamMode.IN.equals(config.jsonStreamMode) || JsonStreamMode.NONE.equals(config.jsonStreamMode)) { for (JsChunkSpec m : jsChunkSpecs) { checkModuleName(m.getName()); } } ImmutableList.Builder inputs = ImmutableList.builder(); for (SourceFile source : sources) { inputs.add(new CompilerInput(source, /* isExtern= */ false)); } chunks = createJsChunks(jsChunkSpecs, inputs.build()); } for (JSChunk m : chunks) { outputFileNames.add(getChunkOutputFileName(m)); } if (typedAstListInputFilename != null) { this.initChunksWithTypedAstFilesystem(externs, chunks, options, typedAstListInputFilename); } else { compiler.initChunks(externs, chunks, options); } } else { if (typedAstListInputFilename != null) { this.initWithTypedAstFilesystem(externs, sources, options, typedAstListInputFilename); } else { compiler.init(externs, sources, options); } } // Release temporary data structures now that the compiler has // been initialized jsChunkSpecs = null; jsonFiles = null; externs = null; sources = null; Result result; // We won't want to process results for cases where compilation is only partially done. boolean shouldProcessResults = true; if (config.skipNormalOutputs) { metricsRecorder.recordActionName("skip normal outputs"); // TODO(bradfordcsmith): Should we be ignoring possible init/initChunks() errors here? compiler.orderInputsWithLargeStack(); result = null; } else if (compiler.hasErrors()) { metricsRecorder.recordActionName("initialization errors occurred"); // init() or initChunks() encountered an error. compiler.generateReport(); result = compiler.getResult(); } else if (options.getInstrumentForCoverageOnly()) { result = instrumentForCoverage(metricsRecorder); } else if (config.shouldSaveAfterStage1()) { result = performStage1andSave(config.getSaveCompilationStateToFilename(), metricsRecorder); // Don't output any results, since compilation isn't done yet. shouldProcessResults = false; } else if (config.shouldRestoreTypedAstsPerformStage2AndSave()) { result = restoreTypedAstsPerformStage2AndSave( config.getSaveCompilationStateToFilename(), metricsRecorder); // Don't output any results, since compilation isn't done yet. shouldProcessResults = false; } else if (config.shouldRestoreTypedAstsPerformStages2And3()) { result = restoreTypedAstsPerformStages2and3(metricsRecorder); } else if (config.shouldRestoreAndPerformStage2AndSave()) { result = restoreAndPerformStage2AndSave( config.getContinueSavedCompilationFileName(), config.getSaveCompilationStateToFilename(), metricsRecorder); // Don't output any results, since compilation isn't done yet. shouldProcessResults = false; } else if (config.shouldRestoreAndPerformStages2And3()) { result = restoreAndPerformStages2and3( config.getContinueSavedCompilationFileName(), metricsRecorder); if (chunks != null) { chunks = ImmutableList.copyOf(compiler.getChunks()); } } else if (config.shouldRestoreAndPerformStage3()) { result = restoreAndPerformStage3(config.getContinueSavedCompilationFileName(), metricsRecorder); if (chunks != null) { chunks = ImmutableList.copyOf(compiler.getChunks()); } } else { result = performFullCompilation(metricsRecorder); } if (createCommonJsModules) { // For Commonchunks construct modules from actual inputs. chunks = ImmutableList.copyOf(compiler.getChunks()); for (JSChunk c : chunks) { outputFileNames.add(getChunkOutputFileName(c)); } } for (String outputFileName : outputFileNames) { if (compiler.getSourceFileByName(outputFileName) != null) { compiler.report(JSError.make(OUTPUT_SAME_AS_INPUT_ERROR, outputFileName)); return 1; } } int exitStatus = shouldProcessResults ? processResults(result, chunks, options) : getExitStatusForResult(result); metricsRecorder.recordResultMetrics(compiler, result); return exitStatus; } /** * Child classes should override this if they want to actually record metrics about the * compilation. */ protected CompileMetricsRecorderInterface getCompileMetricsRecorder() { return new DummyCompileMetricsRecorder(); } @GwtIncompatible("Unnecessary") private Result performStage1andSave( String filename, CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("stage 1"); try (BufferedOutputStream serializedOutputStream = new BufferedOutputStream(new FileOutputStream(filename))) { compiler.parseForCompilation(); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage1Passes(); } if (!compiler.hasErrors()) { compiler.saveState(serializedOutputStream); } compiler.performPostCompilationTasks(); } catch (IOException e) { compiler.report(JSError.make(COULD_NOT_SERIALIZE_AST, filename)); } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private void initWithTypedAstFilesystem( List externs, List sources, CompilerOptions options, String filename) { try (GZIPInputStream typedAstListStream = new GZIPInputStream(new FileInputStream(filename), GZIPPED_TYPEDAST_BUFFER_SIZE)) { compiler.initWithTypedAstFilesystem(externs, sources, options, typedAstListStream); } catch (IOException e) { compiler.report(JSError.make(COULD_NOT_DESERIALIZE_AST, filename)); } } @GwtIncompatible("Unnecessary") private void initChunksWithTypedAstFilesystem( List externs, List chunks, CompilerOptions options, String filename) { try (GZIPInputStream typedAstListStream = new GZIPInputStream(new FileInputStream(filename), GZIPPED_TYPEDAST_BUFFER_SIZE)) { compiler.initChunksWithTypedAstFilesystem(externs, chunks, options, typedAstListStream); } catch (IOException e) { compiler.report(JSError.make(COULD_NOT_DESERIALIZE_AST, filename)); } } @GwtIncompatible("Unnecessary") private Result restoreTypedAstsPerformStage2AndSave( String outputFilename, CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("parse & optimize"); try { if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage2Passes(); if (!compiler.hasErrors()) { try (BufferedOutputStream serializedOutputStream = new BufferedOutputStream(new FileOutputStream(outputFilename))) { compiler.saveState(serializedOutputStream); } catch (IOException e) { compiler.report(JSError.make(COULD_NOT_SERIALIZE_AST, outputFilename)); } compiler.performPostCompilationTasks(); } } } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result restoreTypedAstsPerformStages2and3( CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("skip-checks compile"); try { if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage2Passes(); if (!compiler.hasErrors()) { compiler.stage3Passes(); } compiler.performPostCompilationTasks(); } } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result restoreAndPerformStage2AndSave( String inputFilename, String outputFilename, CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("stage 2/3"); try (BufferedInputStream serializedInputStream = new BufferedInputStream(new FileInputStream(inputFilename))) { compiler.restoreState(serializedInputStream); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage2Passes(); if (!compiler.hasErrors()) { try (BufferedOutputStream serializedOutputStream = new BufferedOutputStream(new FileOutputStream(outputFilename))) { compiler.saveState(serializedOutputStream); } catch (IOException e) { compiler.report(JSError.make(COULD_NOT_SERIALIZE_AST, outputFilename)); } compiler.performPostCompilationTasks(); } } } catch (IOException | ClassNotFoundException e) { compiler.report(JSError.make(COULD_NOT_DESERIALIZE_AST, inputFilename)); } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result restoreAndPerformStages2and3( String filename, CompileMetricsRecorderInterface metricsRecorder) { // From the outside this looks like the second stage of a 2-stage compile. metricsRecorder.recordActionName("stage 2/2"); try (BufferedInputStream serializedInputStream = new BufferedInputStream(new FileInputStream(filename))) { compiler.restoreState(serializedInputStream); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage2Passes(); if (!compiler.hasErrors()) { compiler.stage3Passes(); } } compiler.performPostCompilationTasks(); } catch (IOException | ClassNotFoundException e) { compiler.report(JSError.make(COULD_NOT_DESERIALIZE_AST, filename)); } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result restoreAndPerformStage3( String filename, CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("stage 3/3"); try (BufferedInputStream serializedInputStream = new BufferedInputStream(new FileInputStream(filename))) { compiler.restoreState(serializedInputStream); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage3Passes(); } compiler.performPostCompilationTasks(); } catch (IOException | ClassNotFoundException e) { compiler.report(JSError.make(COULD_NOT_DESERIALIZE_AST, filename)); } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result performFullCompilation(CompileMetricsRecorderInterface metricsRecorder) { // This is the code path taken when "building" a library by just checking it for errors // and generating an .ijs file and also when doing a full compilation. metricsRecorder.recordActionName( compiler.getOptions().checksOnly ? "checks-only" : "full compile"); try { compiler.parseForCompilation(); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.stage1Passes(); if (!compiler.hasErrors()) { compiler.stage2Passes(); if (!compiler.hasErrors()) { compiler.stage3Passes(); } } compiler.performPostCompilationTasks(); } } finally { // Make sure we generate a report of errors and warnings even if the compiler throws an // exception somewhere. compiler.generateReport(); } return compiler.getResult(); } @GwtIncompatible("Unnecessary") private Result instrumentForCoverage(CompileMetricsRecorderInterface metricsRecorder) { metricsRecorder.recordActionName("instrument for coverage"); try { compiler.parseForCompilation(); if (!compiler.hasErrors()) { metricsRecorder.recordStartState(compiler); compiler.instrumentForCoverage(); } } finally { compiler.generateReport(); } return compiler.getResult(); } /** Processes the results of the compile job, and returns an error code. */ @GwtIncompatible("Unnecessary") int processResults(Result result, List chunks, B options) throws IOException { if (config.printAst) { if (compiler.getRoot() == null) { return 1; } else { Appendable jsOutput = createDefaultOutput(); ControlFlowGraph cfg = compiler.computeCFG(); DotFormatter.appendDot(compiler.getRoot().getLastChild(), cfg, jsOutput); jsOutput.append('\n'); closeAppendable(jsOutput); return 0; } } if (config.printTree) { if (compiler.getRoot() == null) { compiler.report(JSError.make(NO_TREE_GENERATED_ERROR)); return 1; } else { Appendable jsOutput = createDefaultOutput(); compiler.getJsRoot().appendStringTree(jsOutput); jsOutput.append("\n"); closeAppendable(jsOutput); return 0; } } if (config.printTreeJson) { if (compiler.getRoot() == null) { compiler.report(JSError.make(NO_TREE_GENERATED_ERROR)); return 1; } else { Appendable jsOutput = createDefaultOutput(); compiler.getJsRoot().appendJsonTree(jsOutput); closeAppendable(jsOutput); return 0; } } if (config.skipNormalOutputs) { // Output the manifest and bundle files if requested. outputManifest(); outputBundle(); outputChunkGraphJson(); return 0; } else if (options.outputJs != OutputJs.NONE && result.success) { outputChunkGraphJson(); if (chunks == null) { outputSingleBinary(options); // Output the source map if requested. // If output files are being written to stdout as a JSON string, // outputSingleBinary will have added the sourcemap to the output file if (!isOutputInJson()) { outputSourceMap(options, config.jsOutputFile); } } else { DiagnosticType error = outputModuleBinaryAndSourceMaps(compiler.getChunkGraph(), options); if (error != null) { compiler.report(JSError.make(error)); return 1; } } // Output the externs if required. if (options.getExternExportsPath() != null) { try (Writer eeOut = openExternExportsStream(options, config.jsOutputFile)) { eeOut.append(result.externExport); } } // Output the variable and property name maps if requested. outputNameMaps(); // Output the ReplaceStrings map if requested outputStringMap(); // Output the manifest and bundle files if requested. outputManifest(); outputBundle(); // Output the production instrumentation param mapping if requested. outputInstrumentationMapping(); if (isOutputInJson()) { outputJsonStream(); } } return getExitStatusForResult(result); } private static int getExitStatusForResult(Result result) { // return 0 if no errors, the error count otherwise return min(result.errors.size(), 0x7f); } @GwtIncompatible("Unnecessary") Function getJavascriptEscaper() { return SourceCodeEscapers.javascriptEscaper().asFunction(); } @GwtIncompatible("Unnecessary") void outputSingleBinary(B options) throws IOException { Function escaper = null; String marker = OUTPUT_MARKER; if (config.outputWrapper.contains(OUTPUT_MARKER_JS_STRING)) { marker = OUTPUT_MARKER_JS_STRING; escaper = getJavascriptEscaper(); } if (isOutputInJson()) { this.filesToStreamOut.add(createJsonFile(options, marker, escaper)); } else { if (!config.jsOutputFile.isEmpty()) { maybeCreateDirsForPath(config.jsOutputFile); } Appendable jsOutput = createDefaultOutput(); writeOutput( jsOutput, compiler, // So long as the JSChunk arg is null the compiler will write all sources to jsOutput // Use single-binary license tracking to dedupe licenses among all the inputs new SingleBinaryLicenseTracker(compiler), (JSChunk) null, config.outputWrapper, marker, escaper, config.jsOutputFile); closeAppendable(jsOutput); } } /** Save the compiler output to a JsonFileSpec to be later written to stdout */ @GwtIncompatible("Unnecessary") JsonFileSpec createJsonFile(B options, String outputMarker, Function escaper) throws IOException { Appendable jsOutput = new StringBuilder(); writeOutput( jsOutput, compiler, // So long as the JSChunk arg is null the compiler will write all sources to jsOutput // Use single-binary license tracking to dedupe licenses among all the inputs new SingleBinaryLicenseTracker(compiler), (JSChunk) null, config.outputWrapper, outputMarker, escaper, config.jsOutputFile); JsonFileSpec jsonOutput = new JsonFileSpec( jsOutput.toString(), Strings.isNullOrEmpty(config.jsOutputFile) ? "compiled.js" : config.jsOutputFile); if (options.shouldGatherSourceMapInfo()) { StringBuilder sourcemap = new StringBuilder(); compiler.getSourceMap().appendTo(sourcemap, jsonOutput.getPath()); jsonOutput.setSourceMap(sourcemap.toString()); } return jsonOutput; } @GwtIncompatible("Unnecessary") void outputJsonStream() throws IOException { try (JsonWriter jsonWriter = new JsonWriter(new BufferedWriter(new OutputStreamWriter(defaultJsOutput, UTF_8)))) { Gson gsonOut = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); Type filesCollectionType = new TypeToken>() {}.getType(); gsonOut.toJson(this.filesToStreamOut, filesCollectionType, jsonWriter); } } @GwtIncompatible("Unnecessary") private @Nullable DiagnosticType outputModuleBinaryAndSourceMaps( JSChunkGraph chunkGraph, B options) throws IOException { Iterable modules = chunkGraph.getAllChunks(); parsedModuleWrappers = parseModuleWrappers(config.moduleWrapper, modules); if (!isOutputInJson()) { // make sure the method generates all dirs up to the latest / maybeCreateDirsForPath(config.moduleOutputPathPrefix + "dummy"); } // If the source map path is in fact a pattern for each // module, create a stream per-module. Otherwise, create // a single source map. Writer mapFileOut = null; // When the json_streams flag is specified, sourcemaps are always generated // per module if (!(shouldGenerateMapPerModule(options) || !options.shouldGatherSourceMapInfo() || config.jsonStreamMode == JsonStreamMode.OUT || config.jsonStreamMode == JsonStreamMode.BOTH)) { // warn that this is not supported return INVALID_MODULE_SOURCEMAP_PATTERN; } ChunkGraphAwareLicenseTracker mlicenseTracker = new ChunkGraphAwareLicenseTracker(compiler); for (JSChunk m : modules) { if (m.getName().equals(JSChunk.WEAK_CHUNK_NAME)) { // Skip the weak module, which is always empty. continue; } if (isOutputInJson()) { this.filesToStreamOut.add(createJsonFileFromModule(m)); } else { if (shouldGenerateMapPerModule(options)) { mapFileOut = fileNameToOutputWriter2(expandSourceMapPath(options, m)); } String moduleFilename = getChunkOutputFileName(m); maybeCreateDirsForPath(moduleFilename); try (Writer writer = fileNameToLegacyOutputWriter(moduleFilename)) { if (options.shouldGatherSourceMapInfo()) { compiler.resetAndIntitializeSourceMap(); } mlicenseTracker.setCurrentChunkContext(m); writeModuleOutput(moduleFilename, writer, mlicenseTracker, m); if (options.shouldGatherSourceMapInfo()) { compiler.getSourceMap().appendTo(mapFileOut, moduleFilename); } } if (shouldGenerateMapPerModule(options) && mapFileOut != null) { mapFileOut.close(); mapFileOut = null; } } } if (mapFileOut != null) { mapFileOut.close(); } return null; } /** Given an output module, convert it to a JSONFileSpec with associated sourcemap */ @GwtIncompatible("Unnecessary") private JsonFileSpec createJsonFileFromModule(JSChunk chunk) throws IOException { compiler.resetAndIntitializeSourceMap(); String filename = getChunkOutputFileName(chunk); StringBuilder output = new StringBuilder(); writeModuleOutput(filename, output, new ScriptNodeLicensesOnlyTracker(compiler), chunk); JsonFileSpec jsonFile = new JsonFileSpec(output.toString(), filename); StringBuilder moduleSourceMap = new StringBuilder(); compiler.getSourceMap().appendTo(moduleSourceMap, getChunkOutputFileName(chunk)); jsonFile.setSourceMap(moduleSourceMap.toString()); return jsonFile; } /** * Query the flag for the input charset, and return a Charset object representing the selection. * * @return Charset to use when reading inputs * @throws FlagUsageException if flag is not a valid Charset name. */ @GwtIncompatible("Unnecessary") private Charset getInputCharset() { if (!config.charset.isEmpty()) { if (!Charset.isSupported(config.charset)) { throw new FlagUsageException(config.charset + " is not a valid charset name."); } return Charset.forName(config.charset); } return UTF_8; } /** * Query the flag for the output charset. * *

Let the outputCharset be the same as the input charset... except if we're reading in UTF-8 * by default. By tradition, we've always output ASCII to avoid various hiccups with different * browsers, proxies and firewalls. * * @return Name of the charset to use when writing outputs. Guaranteed to be a supported charset. * @throws FlagUsageException if flag is not a valid Charset name. */ @GwtIncompatible("Unnecessary") private Charset getLegacyOutputCharset() { if (!config.charset.isEmpty()) { if (!Charset.isSupported(config.charset)) { throw new FlagUsageException(config.charset + " is not a valid charset name."); } return Charset.forName(config.charset); } return US_ASCII; } /** * Query the flag for the output charset. Defaults to UTF-8. * * @throws FlagUsageException if flag is not a valid Charset name. */ @GwtIncompatible("Unnecessary") private Charset getOutputCharset2() { if (!config.charset.isEmpty()) { if (!Charset.isSupported(config.charset)) { throw new FlagUsageException(config.charset + " is not a valid charset name."); } return Charset.forName(config.charset); } return UTF_8; } @GwtIncompatible("Unnecessary") protected List createExterns(CompilerOptions options) throws IOException { return isInTestMode() ? externsSupplierForTesting.get() : createExternInputs(config.externs); } /** * Returns true if and only if a source map file should be generated for each module, as opposed * to one unified map. This is specified by having the source map pattern include the %outname% * variable. */ @GwtIncompatible("Unnecessary") protected boolean shouldGenerateMapPerModule(B options) { return options.shouldGatherSourceMapInfo() && options.getSourceMapOutputPath().contains("%outname%"); } /** * Returns a stream for outputting the generated externs file. * * @param options The options to the Compiler. * @param path The path of the generated JS source file. * @return The stream or null if no extern-ed exports are being generated. */ @GwtIncompatible("Unnecessary") private @Nullable Writer openExternExportsStream(B options, String path) throws IOException { final String externExportsPath = options.getExternExportsPath(); if (externExportsPath == null) { return null; } String exPath = externExportsPath; if (!exPath.contains(File.separator)) { File outputFile = new File(path); exPath = outputFile.getParent() + File.separatorChar + exPath; } return fileNameToOutputWriter2(exPath); } /** * Expand a file path specified on the command-line. * *

Most file paths on the command-line allow an %outname% placeholder. The placeholder will * expand to a different value depending on the current output mode. There are three scenarios: * *

1) Single JS output, single extra output: sub in jsOutputPath. 2) Multiple JS output, single * extra output: sub in the base module name. 3) Multiple JS output, multiple extra output: sub in * the module output file. * *

Passing a JSChunk to this function automatically triggers case #3. Otherwise, we'll use * strategy #1 or #2 based on the current output mode. */ @GwtIncompatible("Unnecessary") private String expandCommandLinePath(String path, @Nullable JSChunk forChunk) { String sub; if (forChunk != null) { sub = getChunkOutputFileName(forChunk); } else if (!config.module.isEmpty()) { sub = config.moduleOutputPathPrefix; } else { sub = config.jsOutputFile; } return path.replace("%outname%", sub); } /** Expansion function for source map. */ @VisibleForTesting @GwtIncompatible("Unnecessary") @Nullable String expandSourceMapPath(B options, @Nullable JSChunk forChunk) { if (!options.shouldGatherSourceMapInfo()) { return null; } return expandCommandLinePath(options.getSourceMapOutputPath(), forChunk); } /** * Converts a file name into a Writer taking in account the output charset. Returns null if the * file name is null. */ @GwtIncompatible("Unnecessary") private @Nullable Writer fileNameToLegacyOutputWriter(String fileName) throws IOException { if (fileName == null) { return null; } if (isInTestMode()) { return new StringWriter(); } return streamToLegacyOutputWriter(filenameToOutputStream(fileName)); } /** * Converts a file name into a Writer taking in account the output charset. Returns null if the * file name is null. */ @GwtIncompatible("Unnecessary") private @Nullable Writer fileNameToOutputWriter2(String fileName) throws IOException { if (fileName == null) { return null; } if (isInTestMode()) { return new StringWriter(); } return streamToOutputWriter2(filenameToOutputStream(fileName)); } /** Converts a file name into a Outputstream. Returns null if the file name is null. */ @GwtIncompatible("Unnecessary") protected @Nullable OutputStream filenameToOutputStream(String fileName) throws IOException { if (fileName == null) { return null; } return new FileOutputStream(fileName); } /** Create a writer with the legacy output charset. */ @GwtIncompatible("Unnecessary") private Writer streamToLegacyOutputWriter(OutputStream stream) { if (legacyOutputCharset == null) { return createWriter(stream, UTF_8); } else { return createWriter(stream, legacyOutputCharset); } } /** Create a writer with the newer output charset. */ @GwtIncompatible("Unnecessary") private Writer streamToOutputWriter2(OutputStream stream) { if (outputCharset2 == null) { return createWriter(stream, UTF_8); } else { return createWriter(stream, outputCharset2); } } /** Creates a buffered Writer that writes to the given stream using the given encoding. */ @GwtIncompatible("Unnecessary") Writer createWriter(OutputStream stream, Charset charset) { return new BufferedWriter(new OutputStreamWriter(stream, charset)); } /** * Outputs the source map found in the compiler to the proper path if one exists. * * @param options The options to the Compiler. */ @GwtIncompatible("Unnecessary") private void outputSourceMap(B options, String associatedName) throws IOException { if (!options.shouldGatherSourceMapInfo() || options.getSourceMapOutputPath().equals("/dev/null")) { return; } String outName = expandSourceMapPath(options, null); maybeCreateDirsForPath(outName); try (Writer out = fileNameToOutputWriter2(outName)) { compiler.getSourceMap().appendTo(out, associatedName); } } /** * Returns the path at which to output map file(s) based on the path at which the JS binary will * be placed. * * @return The path in which to place the generated map file(s). */ @GwtIncompatible("Unnecessary") private String getMapPath(String outputFile) { String basePath = ""; if (outputFile.isEmpty()) { // If we have a js_module_binary rule, output the maps // at modulename_props_map.out, etc. if (!config.moduleOutputPathPrefix.isEmpty()) { basePath = config.moduleOutputPathPrefix; } else { basePath = "jscompiler"; } } else { // Get the path of the output file. File file = new File(outputFile); String outputFileName = file.getName(); // Strip the .js from the name. if (outputFileName.endsWith(".js")) { outputFileName = outputFileName.substring(0, outputFileName.length() - 3); } String fileParent = file.getParent(); if (fileParent == null) { basePath = outputFileName; } else { basePath = file.getParent() + File.separatorChar + outputFileName; } } return basePath; } /** * Outputs the variable and property name maps for the specified compiler if the proper FLAGS are * set. */ @GwtIncompatible("Unnecessary") private void outputNameMaps() throws IOException { String propertyMapOutputPath = null; String variableMapOutputPath = null; // Check the create_name_map_files FLAG. if (config.createNameMapFiles) { String basePath = getMapPath(config.jsOutputFile); propertyMapOutputPath = basePath + "_props_map.out"; variableMapOutputPath = basePath + "_vars_map.out"; } // Check the individual FLAGS. if (!config.variableMapOutputFile.isEmpty()) { if (variableMapOutputPath != null) { throw new FlagUsageException( "The flags variable_map_output_file and " + "create_name_map_files cannot both be used simultaneously."); } variableMapOutputPath = config.variableMapOutputFile; } if (!config.propertyMapOutputFile.isEmpty()) { if (propertyMapOutputPath != null) { throw new FlagUsageException( "The flags property_map_output_file and " + "create_name_map_files cannot both be used simultaneously."); } propertyMapOutputPath = config.propertyMapOutputFile; } // Output the maps. if (variableMapOutputPath != null && compiler.getVariableMap() != null) { compiler.getVariableMap().save(variableMapOutputPath); } if (propertyMapOutputPath != null && compiler.getPropertyMap() != null) { compiler.getPropertyMap().save(propertyMapOutputPath); } } /** * Outputs the string map generated by the {@link ReplaceStrings} pass if an output path exists. */ @GwtIncompatible("Unnecessary") private void outputStringMap() throws IOException { if (!config.stringMapOutputPath.isEmpty()) { if (compiler.getStringMap() == null) { // Ensure an empty file is created if there is no string map. // This avoids confusing some build tools that expect to see the file, even if it is empty. if (!(new File(config.stringMapOutputPath).createNewFile())) { throw new IOException("Could not create file: " + config.stringMapOutputPath); } } else { compiler.getStringMap().save(config.stringMapOutputPath); } } } /** * Create a map of constant names to constant values from a textual description of the map. * * @param definitions A list of overriding definitions for defines in the form {@code * [=]}, where {@code } is a number, boolean, or single-quoted string without * single quotes. */ @VisibleForTesting public static void createDefineReplacements(List definitions, CompilerOptions options) { // Parse the definitions for (String override : definitions) { String[] assignment = override.split("=", 2); String defName = assignment[0]; if (defName.length() > 0) { String defValue = assignment.length == 1 ? "true" : assignment[1]; boolean isTrue = defValue.equals("true"); boolean isFalse = defValue.equals("false"); if (isTrue || isFalse) { options.setDefineToBooleanLiteral(defName, isTrue); continue; } else if (defValue.length() > 1 && ((defValue.charAt(0) == '\'' && defValue.charAt(defValue.length() - 1) == '\'') || (defValue.charAt(0) == '\"' && defValue.charAt(defValue.length() - 1) == '\"'))) { // If the value starts and ends with a single quote, // we assume that it's a string. String maybeStringVal = defValue.substring(1, defValue.length() - 1); if (maybeStringVal.indexOf(defValue.charAt(0)) == -1) { options.setDefineToStringLiteral(defName, maybeStringVal); continue; } } else { try { double value = Double.parseDouble(defValue); options.setDefineToDoubleLiteral(defName, value); continue; } catch (NumberFormatException e) { // do nothing, it will be caught at the end } if (defValue.length() > 0) { options.setDefineToStringLiteral(defName, defValue); continue; } } } throw new RuntimeException("--define flag syntax invalid: " + override); } } /** * Returns true if and only if a manifest or bundle should be generated for each module, as * opposed to one unified manifest. */ @GwtIncompatible("Unnecessary") private boolean shouldGenerateOutputPerModule(String output) { return !config.module.isEmpty() && output != null && output.contains("%outname%"); } @GwtIncompatible("Unnecessary") private void outputManifest() throws IOException { outputManifestOrBundle(config.outputManifests, true); } @GwtIncompatible("Unnecessary") private void outputBundle() throws IOException { outputManifestOrBundle(config.outputBundles, false); } @GwtIncompatible("Unnecessary") private void outputInstrumentationMapping() throws IOException { if (!Strings.isNullOrEmpty(config.instrumentationMappingFile)) { String path = expandCommandLinePath(config.instrumentationMappingFile, /* forChunk= */ null); compiler.getInstrumentationMapping().save(path); } } /** * Writes the manifest or bundle of all compiler input files that were included as controlled by * --dependency_mode, if requested. */ @GwtIncompatible("Unnecessary") private void outputManifestOrBundle(List outputFiles, boolean isManifest) throws IOException { if (outputFiles.isEmpty()) { return; } for (String output : outputFiles) { if (output.isEmpty()) { continue; } if (shouldGenerateOutputPerModule(output)) { // Generate per-module manifests or bundles. Iterable chunks = compiler.getChunkGraph().getAllChunks(); for (JSChunk chunk : chunks) { try (Writer out = fileNameToOutputWriter2(expandCommandLinePath(output, chunk))) { if (isManifest) { printManifestTo(chunk, out); } else { printBundleTo(chunk, out); } } } } else { // Generate a single file manifest or bundle. try (Writer out = fileNameToOutputWriter2(expandCommandLinePath(output, null))) { if (config.module.isEmpty()) { // For a single-module compilation, generate a single headerless manifest or bundle // containing only the strong files. JSChunk chunk = compiler.getChunkGraph().getChunkByName(JSChunk.STRONG_CHUNK_NAME); if (isManifest) { printManifestTo(chunk, out); } else { printBundleTo(chunk, out); } } else { // For a multi-module compilation, generate a single manifest file with module headers. printChunkGraphManifestOrBundleTo(compiler.getChunkGraph(), out, isManifest); } } } } } /** Creates a file containing the current module graph in JSON serialization. */ @GwtIncompatible("Unnecessary") private void outputChunkGraphJson() throws IOException { if (config.outputModuleDependencies != null && config.outputModuleDependencies.length() != 0) { try (Writer out = fileNameToOutputWriter2(config.outputModuleDependencies)) { printChunkGraphJsonTo(out); } } } /** Prints the current module graph as JSON. */ @VisibleForTesting @GwtIncompatible("Unnecessary") void printChunkGraphJsonTo(Appendable out) throws IOException { out.append(compiler.getChunkGraph().toJson().toString()); } /** Prints a set of modules to the manifest or bundle file. */ @VisibleForTesting @GwtIncompatible("Unnecessary") void printChunkGraphManifestOrBundleTo(JSChunkGraph graph, Appendable out, boolean isManifest) throws IOException { Joiner commas = Joiner.on(","); boolean requiresNewline = false; for (JSChunk chunk : graph.getAllChunks()) { if (!isManifest && chunk.isWeak()) { // Skip the weak module on a multi-module bundle, but not a multi-module manifest. continue; } if (requiresNewline) { out.append("\n"); } if (isManifest) { // See CommandLineRunnerTest to see what the format of this // manifest looks like. String dependencies = commas.join(chunk.getSortedDependencyNames()); out.append( String.format( "{%s%s}\n", chunk.getName(), dependencies.isEmpty() ? "" : ":" + dependencies)); printManifestTo(chunk, out); } else { printBundleTo(chunk, out); } requiresNewline = true; } } /** * Prints a list of input names (using root-relative paths), delimited by newlines, to the * manifest file. */ @VisibleForTesting @GwtIncompatible("Unnecessary") void printManifestTo(JSChunk chunk, Appendable out) throws IOException { for (CompilerInput input : chunk.getInputs()) { String name = input.getName(); // Ignore fill files created by the compiler to facilitate cross-module code motion. if (Compiler.isFillFileName(name)) { continue; } String rootRelativePath = rootRelativePathsMap.get(name); String displayName = rootRelativePath != null ? rootRelativePath : name; out.append(displayName); out.append("\n"); } } /** * Prints all the input contents, starting with a comment that specifies the input file name * (using root-relative paths) before each file. */ @VisibleForTesting @GwtIncompatible("Unnecessary") void printBundleTo(JSChunk chunk, Appendable out) throws IOException { ImmutableList inputs = chunk.getInputs(); // Prebuild ASTs before they're needed in getLoadFlags, for performance and because // StackOverflowErrors can be hit if not prebuilt. if (compiler.getOptions().numParallelThreads > 1) { new PrebuildAst(compiler, compiler.getOptions().numParallelThreads).prebuild(inputs); } if (!compiler.getOptions().preventLibraryInjection) { // ES6 modules will need a runtime in a bundle. Skip appending this runtime if there are no // ES6 modules to cut down on size. for (CompilerInput input : inputs) { if (input.isEs6Module()) { appendRuntimeTo(out); break; } } } for (CompilerInput input : inputs) { String name = input.getName(); String code = input.getSourceFile().getCode(); // Ignore empty fill files created by the compiler to facilitate cross-module code motion. // Note that non-empty fill files (ones whose code has actually been moved into) are still // emitted. In particular, this ensures that if there are no (real) inputs the bundle will be // empty. if (Compiler.isFillFileName(name) && code.isEmpty()) { continue; } String rootRelativePath = rootRelativePathsMap.get(name); String displayName = rootRelativePath != null ? rootRelativePath : input.getName(); out.append("//"); out.append(displayName); out.append("\n"); prepForBundleAndAppendTo(out, input, code); out.append("\n"); } } /** * Construct and return the input root path map. The key is the exec path of each input file, and * the value is the corresponding root relative path. */ @GwtIncompatible("Unnecessary") private Map constructRootRelativePathsMap() { Map rootRelativePathsMap = new LinkedHashMap<>(); for (String mapString : config.manifestMaps) { int colonIndex = mapString.indexOf(':'); checkState(colonIndex > 0); String execPath = mapString.substring(0, colonIndex); String rootRelativePath = mapString.substring(colonIndex + 1); checkState(rootRelativePath.indexOf(':') == -1); rootRelativePathsMap.put(execPath, rootRelativePath); } return rootRelativePathsMap; } /** * Configurations for the command line configs. Designed for easy building, so that we can * decouple the flags-parsing library from the actual configuration options. * *