com.google.javascript.jscomp.DefaultPassConfig Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of closure-compiler-linter Show documentation
Show all versions of closure-compiler-linter Show documentation
Closure Compiler is a JavaScript optimizing compiler. It parses your
JavaScript, analyzes it, removes dead code and rewrites and minimizes
what's left. It also checks syntax, variable references, and types, and
warns about common JavaScript pitfalls. It is used in many of Google's
JavaScript apps, including Gmail, Google Web Search, Google Maps, and
Google Docs.
This binary checks for style issues such as incorrect or missing JSDoc
usage, and missing goog.require() statements. It does not do more advanced
checks such as typechecking.
/*
* Copyright 2009 The Closure Compiler Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.javascript.jscomp;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.javascript.jscomp.PassFactory.createEmptyPass;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.ES2019;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.ES2019_MODULES;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.ES5;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.ES6;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.ES_NEXT;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.TYPESCRIPT;
import static com.google.javascript.jscomp.parsing.parser.FeatureSet.TYPE_CHECK_SUPPORTED;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.javascript.jscomp.AbstractCompiler.LifeCycleStage;
import com.google.javascript.jscomp.CompilerOptions.ExtractPrototypeMemberDeclarationsMode;
import com.google.javascript.jscomp.CompilerOptions.PropertyCollapseLevel;
import com.google.javascript.jscomp.CompilerOptions.Reach;
import com.google.javascript.jscomp.CoverageInstrumentationPass.CoverageReach;
import com.google.javascript.jscomp.CoverageInstrumentationPass.InstrumentOption;
import com.google.javascript.jscomp.ExtractPrototypeMemberDeclarations.Pattern;
import com.google.javascript.jscomp.NodeTraversal.Callback;
import com.google.javascript.jscomp.ScopedAliases.InvalidModuleGetHandling;
import com.google.javascript.jscomp.ijs.ConvertToTypedInterface;
import com.google.javascript.jscomp.lint.CheckArrayWithGoogObject;
import com.google.javascript.jscomp.lint.CheckConstantCaseNames;
import com.google.javascript.jscomp.lint.CheckDuplicateCase;
import com.google.javascript.jscomp.lint.CheckEmptyStatements;
import com.google.javascript.jscomp.lint.CheckEnums;
import com.google.javascript.jscomp.lint.CheckEs6ModuleFileStructure;
import com.google.javascript.jscomp.lint.CheckEs6Modules;
import com.google.javascript.jscomp.lint.CheckInterfaces;
import com.google.javascript.jscomp.lint.CheckJSDocStyle;
import com.google.javascript.jscomp.lint.CheckMissingSemicolon;
import com.google.javascript.jscomp.lint.CheckNoMutatedEs6Exports;
import com.google.javascript.jscomp.lint.CheckNullabilityModifiers;
import com.google.javascript.jscomp.lint.CheckNullableReturn;
import com.google.javascript.jscomp.lint.CheckPrimitiveAsObject;
import com.google.javascript.jscomp.lint.CheckPrototypeProperties;
import com.google.javascript.jscomp.lint.CheckProvidesSorted;
import com.google.javascript.jscomp.lint.CheckRequiresSorted;
import com.google.javascript.jscomp.lint.CheckUnusedLabels;
import com.google.javascript.jscomp.lint.CheckUselessBlocks;
import com.google.javascript.jscomp.modules.ModuleMapCreator;
import com.google.javascript.jscomp.parsing.ParserRunner;
import com.google.javascript.jscomp.parsing.parser.FeatureSet;
import com.google.javascript.rhino.IR;
import com.google.javascript.rhino.Node;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
/**
* Pass factories and meta-data for native JSCompiler passes.
*
* NOTE(dimvar): this needs some non-trivial refactoring. The pass config should
* use as little state as possible. The recommended way for a pass to leave
* behind some state for a subsequent pass is through the compiler object.
* Any other state remaining here should only be used when the pass config is
* creating the list of checks and optimizations, not after passes have started
* executing. For example, the field namespaceForChecks should be in Compiler.
*/
public final class DefaultPassConfig extends PassConfig {
/* For the --mark-as-compiled pass */
private static final String COMPILED_CONSTANT_NAME = "COMPILED";
/* Constant name for Closure's locale */
private static final String CLOSURE_LOCALE_CONSTANT_NAME = "goog.LOCALE";
static final DiagnosticType CANNOT_USE_PROTOTYPE_AND_VAR =
DiagnosticType.error("JSC_CANNOT_USE_PROTOTYPE_AND_VAR",
"Rename prototypes and inline variables cannot be used together.");
// Miscellaneous errors.
private static final java.util.regex.Pattern GLOBAL_SYMBOL_NAMESPACE_PATTERN =
java.util.regex.Pattern.compile("^[a-zA-Z0-9$_]+$");
/**
* A global namespace to share across checking passes.
*/
private transient GlobalNamespace namespaceForChecks = null;
/** A symbol table for registering references that get removed during preprocessing. */
private final transient PreprocessorSymbolTable.CachedInstanceFactory
preprocessorSymbolTableFactory = new PreprocessorSymbolTable.CachedInstanceFactory();
/**
* Global state necessary for doing hotswap recompilation of files with references to
* processed goog.modules.
*/
private transient ClosureRewriteModule.GlobalRewriteState moduleRewriteState = null;
public DefaultPassConfig(CompilerOptions options) {
super(options);
}
GlobalNamespace getGlobalNamespace() {
return namespaceForChecks;
}
@Nullable
PreprocessorSymbolTable getPreprocessorSymbolTable() {
return preprocessorSymbolTableFactory.getInstanceOrNull();
}
void maybeInitializeModuleRewriteState() {
if (options.allowsHotswapReplaceScript() && this.moduleRewriteState == null) {
this.moduleRewriteState = new ClosureRewriteModule.GlobalRewriteState();
}
}
@Override
protected List getTranspileOnlyPasses() {
List passes = new ArrayList<>();
if (options.needsTranspilationFrom(TYPESCRIPT)) {
passes.add(convertEs6TypedToEs6);
}
passes.add(markUntranspilableFeaturesAsRemoved);
passes.add(checkVariableReferencesForTranspileOnly);
passes.add(gatherModuleMetadataPass);
passes.add(createModuleMapPass);
if (options.getLanguageIn().toFeatureSet().has(FeatureSet.Feature.MODULES)) {
passes.add(rewriteGoogJsImports);
switch (options.getEs6ModuleTranspilation()) {
case COMPILE:
TranspilationPasses.addEs6ModulePass(passes, preprocessorSymbolTableFactory);
break;
case TO_COMMON_JS_LIKE_MODULES:
TranspilationPasses.addEs6ModuleToCjsPass(passes);
break;
case RELATIVIZE_IMPORT_PATHS:
TranspilationPasses.addEs6RewriteImportPathPass(passes);
break;
case NONE:
// nothing
break;
}
}
passes.add(checkSuper);
// It's important that the Dart super accessors pass run *before* es6ConvertSuper,
// which is a "late" ES6 pass. This is enforced in the assertValidOrder method.
if (options.dartPass && options.needsTranspilationFrom(ES6)) {
passes.add(dartSuperAccessorsPass);
}
TranspilationPasses.addPreTypecheckTranspilationPasses(passes, options);
TranspilationPasses.addPostCheckTranspilationPasses(passes, options);
if (options.needsTranspilationFrom(ES6)) {
if (options.rewritePolyfills) {
TranspilationPasses.addRewritePolyfillPass(passes);
}
}
passes.add(injectRuntimeLibraries);
assertAllOneTimePasses(passes);
assertValidOrderForChecks(passes);
return passes;
}
@Override
protected List getWhitespaceOnlyPasses() {
List passes = new ArrayList<>();
if (options.processCommonJSModules) {
passes.add(rewriteCommonJsModules);
} else if (options.getLanguageIn().toFeatureSet().has(FeatureSet.Feature.MODULES)) {
passes.add(rewriteScriptsToEs6Modules);
}
if (options.wrapGoogModulesForWhitespaceOnly) {
passes.add(whitespaceWrapGoogModules);
}
return passes;
}
private void addTypeCheckerPasses(List checks, CompilerOptions options) {
if (options.checkTypes || options.inferTypes) {
checks.add(resolveTypes);
checks.add(inferTypes);
if (options.checkTypes) {
checks.add(checkTypes);
} else {
checks.add(inferJsDocInfo);
}
// We assume that only clients who are going to re-compile, or do in-depth static analysis,
// will need the typed scope creator after the compile job.
if (!options.preservesDetailedSourceInfo() && !options.allowsHotswapReplaceScript()) {
checks.add(clearTypedScopePass);
}
}
}
private void addModuleRewritingPasses(List checks, CompilerOptions options) {
if (options.closurePass) {
checks.add(rewriteClosureImports);
}
if (options.getLanguageIn().toFeatureSet().has(FeatureSet.Feature.MODULES)) {
checks.add(rewriteGoogJsImports);
TranspilationPasses.addEs6ModulePass(checks, preprocessorSymbolTableFactory);
}
if (options.closurePass) {
checks.add(closureRewriteModule);
}
// TODO(b/141389184): include processClosureProvidesAndRequires here
}
@Override
protected List getChecks() {
List checks = new ArrayList<>();
if (options.shouldGenerateTypedExterns()) {
checks.add(addSyntheticScript);
checks.add(closureGoogScopeAliasesForIjs);
checks.add(closureRewriteClass);
checks.add(generateIjs);
checks.add(whitespaceWrapGoogModules);
checks.add(removeSyntheticScript);
return checks;
}
// Run this pass before any pass tries to inject new runtime libraries
checks.add(addSyntheticScript);
if (options.needsTranspilationFrom(TYPESCRIPT)) {
checks.add(convertEs6TypedToEs6);
}
if (!options.checksOnly) {
checks.add(markUntranspilableFeaturesAsRemoved);
}
checks.add(gatherGettersAndSetters);
checks.add(createEmptyPass("beforeStandardChecks"));
if (!options.processCommonJSModules
&& options.getLanguageIn().toFeatureSet().has(FeatureSet.Feature.MODULES)) {
checks.add(rewriteScriptsToEs6Modules);
}
// Run these passes after promoting scripts to modules, but before rewriting any other modules.
checks.add(gatherModuleMetadataPass);
checks.add(createModuleMapPass);
if (options.processCommonJSModules) {
checks.add(rewriteCommonJsModules);
}
// Note: ChromePass can rewrite invalid @type annotations into valid ones, so should run before
// JsDoc checks.
if (options.isChromePassEnabled()) {
checks.add(chromePass);
}
// Verify JsDoc annotations and check ES6 modules
checks.add(checkJsDocAndEs6Modules);
checks.add(checkTypeImportCodeReferences);
if (options.enables(DiagnosticGroups.LINT_CHECKS)) {
checks.add(lintChecks);
}
if (options.closurePass && options.enables(DiagnosticGroups.LINT_CHECKS)) {
checks.add(checkRequiresAndProvidesSorted);
}
if (options.enables(DiagnosticGroups.MISSING_REQUIRE)
|| options.enables(DiagnosticGroups.STRICT_MISSING_REQUIRE)
|| options.enables(DiagnosticGroups.EXTRA_REQUIRE)) {
checks.add(checkRequires);
}
checks.add(checkVariableReferences);
if (options.declaredGlobalExternsOnWindow) {
checks.add(declaredGlobalExternsOnWindow);
}
if (!options.processCommonJSModules) {
// TODO(ChadKillingsworth): move CommonJS module rewriting after VarCheck
checks.add(checkVars);
}
if (options.closurePass) {
checks.add(checkClosureImports);
}
checks.add(checkStrictMode);
if (options.closurePass) {
checks.add(closureCheckModule);
}
checks.add(checkSuper);
if (options.closurePass) {
checks.add(closureRewriteClass);
}
checks.add(checkSideEffects);
if (options.enables(DiagnosticGroups.MISSING_PROVIDE)) {
checks.add(checkProvides);
}
if (options.angularPass) {
checks.add(angularPass);
}
if (options.closurePass) {
checks.add(closureGoogScopeAliases);
}
// TODO(b/141389184): Move this after the Polymer pass
if (options.shouldRewriteModulesBeforeTypechecking()) {
addModuleRewritingPasses(checks, options);
}
if (options.closurePass) {
checks.add(closurePrimitives);
if (options.shouldRewriteModulesBeforeTypechecking()) {
checks.add(closureProvidesRequires);
}
}
// It's important that the PolymerPass run *after* the ClosurePrimitives and ChromePass rewrites
// and *before* the suspicious code checks. This is enforced in the assertValidOrder method.
if (options.polymerVersion != null) {
checks.add(polymerPass);
}
if (options.closurePass && options.checkMissingGetCssNameLevel.isOn()) {
checks.add(closureCheckGetCssName);
}
if (options.syntheticBlockStartMarker != null) {
// This pass must run before the first fold constants pass.
checks.add(createSyntheticBlocks);
}
if (options.processCommonJSModules) {
// TODO(ChadKillingsworth): remove this branch.
checks.add(checkVars);
}
if (options.inferConsts) {
checks.add(inferConsts);
}
if (options.computeFunctionSideEffects) {
checks.add(checkRegExp);
}
// It's important that the Dart super accessors pass run *before* es6ConvertSuper,
// which is a "late" ES6 pass. This is enforced in the assertValidOrder method.
if (options.dartPass && !options.getOutputFeatureSet().contains(ES6)) {
checks.add(dartSuperAccessorsPass);
}
// Passes running before this point should expect to see language features up to ES_2017.
checks.add(createEmptyPass(PassNames.BEFORE_PRE_TYPECHECK_TRANSPILATION));
TranspilationPasses.addPreTypecheckTranspilationPasses(checks, options);
if (options.rewritePolyfills && !options.checksOnly) {
TranspilationPasses.addRewritePolyfillPass(checks);
}
checks.add(injectRuntimeLibraries);
checks.add(createEmptyPass(PassNames.BEFORE_TYPE_CHECKING));
addTypeCheckerPasses(checks, options);
if (!options.shouldRewriteModulesBeforeTypechecking()) {
addModuleRewritingPasses(checks, options);
checks.add(closureProvidesRequires);
}
// TODO(b/124915436): Remove this pass completely after cleaning up the codebase.
if (!options.allowsHotswapReplaceScript()) {
checks.add(inlineTypeAliases);
}
// CheckSuspiciousCode requires type information, so must run after the type checker.
if (options.checkSuspiciousCode
|| options.enables(DiagnosticGroups.GLOBAL_THIS)
|| options.enables(DiagnosticGroups.DEBUGGER_STATEMENT_PRESENT)) {
checks.add(suspiciousCode);
}
if (options.j2clPassMode.shouldAddJ2clPasses()) {
checks.add(j2clSourceFileChecker);
}
if (!options.disables(DiagnosticGroups.CHECK_USELESS_CODE)
|| !options.disables(DiagnosticGroups.MISSING_RETURN)) {
checks.add(checkControlFlow);
}
// CheckAccessControls only works if check types is on.
if (options.isTypecheckingEnabled()
&& (!options.disables(DiagnosticGroups.ACCESS_CONTROLS)
|| options.enables(DiagnosticGroups.CONSTANT_PROPERTY))) {
checks.add(checkAccessControls);
}
checks.add(checkConsts);
// Analyzer checks must be run after typechecking.
if (options.enables(DiagnosticGroups.ANALYZER_CHECKS) && options.isTypecheckingEnabled()) {
checks.add(analyzerChecks);
}
if (options.checkGlobalNamesLevel.isOn()) {
checks.add(checkGlobalNames);
}
if (!options.getConformanceConfigs().isEmpty()) {
checks.add(checkConformance);
}
// Replace 'goog.getCssName' before processing defines but after the
// other checks have been done.
if (options.closurePass && !options.shouldPreserveGoogLibraryPrimitives()) {
checks.add(closureReplaceGetCssName);
}
if (options.getTweakProcessing().isOn()) {
checks.add(processTweaks);
}
if (options.checksOnly) {
// Run process defines here so that warnings/errors from that pass are emitted as part of
// checks.
// TODO(rluble): Split process defines into two stages, one that performs only checks to be
// run here, and the one that actually changes the AST that would run in the optimization
// phase.
checks.add(processDefines);
}
if (options.j2clPassMode.shouldAddJ2clPasses()) {
checks.add(j2clChecksPass);
}
if (options.shouldRunTypeSummaryChecksLate()) {
checks.add(generateIjs);
}
if (options.generateExports) {
checks.add(generateExports);
}
checks.add(createEmptyPass(PassNames.AFTER_STANDARD_CHECKS));
checks.add(removeSyntheticScript);
if (!options.checksOnly && options.j2clPassMode.shouldAddJ2clPasses()) {
checks.add(j2clPass);
}
if (!options.checksOnly) {
// At this point all checks have been done.
if (options.exportTestFunctions) {
checks.add(exportTestFunctions);
}
// There's no need to complete transpilation if we're only running checks.
TranspilationPasses.addPostCheckTranspilationPasses(checks, options);
if (options.needsTranspilationFrom(ES6)) {
// This pass used to be necessary to make the typechecker happy with class-side inheritance.
// It's not necessary for typechecking now that class transpilation is post-typechecking,
// but it turned out to be necessary to avoid CollapseProperties breaking static inheritance
// TODO(b/116054203): try to only run this pass when property collapsing is enabled during
// the optimizations. Even better, find a way to get rid of this pass completely.
checks.add(convertStaticInheritance);
}
}
assertAllOneTimePasses(checks);
assertValidOrderForChecks(checks);
checks.add(createEmptyPass(PassNames.BEFORE_SERIALIZATION));
return checks;
}
@Override
protected List getOptimizations() {
List passes = new ArrayList<>();
if (options.skipNonTranspilationPasses) {
return passes;
}
passes.add(removeWeakSources);
passes.add(garbageCollectChecks);
// i18n
// If you want to customize the compiler to use a different i18n pass,
// you can create a PassConfig that calls replacePassFactory
// to replace this.
if (options.replaceMessagesWithChromeI18n) {
passes.add(replaceMessagesForChrome);
} else if (options.messageBundle != null) {
passes.add(replaceMessages);
}
// Defines in code always need to be processed.
passes.add(processDefines);
if (options.getTweakProcessing().shouldStrip()
|| !options.stripTypes.isEmpty()
|| !options.stripNameSuffixes.isEmpty()
|| !options.stripTypePrefixes.isEmpty()
|| !options.stripNamePrefixes.isEmpty()) {
passes.add(stripCode);
}
passes.add(normalize);
// Create extern exports after the normalize because externExports depends on unique names.
if (options.isExternExportsEnabled() || options.externExportsPath != null) {
passes.add(externExports);
}
// Gather property names in externs so they can be queried by the
// optimizing passes.
passes.add(gatherExternProperties);
if (options.j2clPassMode.shouldAddJ2clPasses()) {
passes.add(j2clUtilGetDefineRewriterPass);
}
if (options.instrumentForCoverage) {
passes.add(instrumentForCodeCoverage);
}
if (options.runtimeTypeCheck) {
passes.add(runtimeTypeCheck);
}
passes.add(createEmptyPass(PassNames.BEFORE_STANDARD_OPTIMIZATIONS));
if (options.replaceIdGenerators) {
passes.add(replaceIdGenerators);
}
// Optimizes references to the arguments variable.
if (options.optimizeArgumentsArray) {
passes.add(optimizeArgumentsArray);
}
// Abstract method removal works best on minimally modified code, and also
// only needs to run once.
if (options.closurePass && (options.removeAbstractMethods || options.removeClosureAsserts)) {
passes.add(closureCodeRemoval);
}
if (options.removeJ2clAsserts) {
passes.add(j2clAssertRemovalPass);
}
// Property disambiguation should only run once and needs to be done
// soon after type checking, both so that it can make use of type
// information and so that other passes can take advantage of the renamed
// properties.
if (options.disambiguatePrivateProperties) {
passes.add(disambiguatePrivateProperties);
}
assertAllOneTimePasses(passes);
// Inline aliases so that following optimizations don't have to understand alias chains.
if (options.getPropertyCollapseLevel() == PropertyCollapseLevel.ALL) {
passes.add(aggressiveInlineAliases);
}
// Inline getters/setters in J2CL classes so that Object.defineProperties() calls (resulting
// from desugaring) don't block class stripping.
if (options.j2clPassMode.shouldAddJ2clPasses()
&& options.getPropertyCollapseLevel() == PropertyCollapseLevel.ALL) {
// Relies on collapseProperties-triggered aggressive alias inlining.
passes.add(j2clPropertyInlinerPass);
}
// Collapsing properties can undo constant inlining, so we do this before
// the main optimization loop.
if (options.getPropertyCollapseLevel() != PropertyCollapseLevel.NONE) {
passes.add(collapseProperties);
}
if (options.inferConsts) {
passes.add(inferConsts);
}
// TODO(mlourenco): Ideally this would be in getChecks() instead of getOptimizations(). But
// for that it needs to understand constant properties as well. See b/31301233#10.
// Needs to happen after inferConsts and collapseProperties. Detects whether invocations of
// the method goog.string.Const.from are done with an argument which is a string literal.
passes.add(checkConstParams);
// Running RemoveUnusedCode before disambiguate properties allows disambiguate properties to be
// more effective if code that would prevent disambiguation can be removed.
// TODO(b/66971163): Rename options since we're not actually using smartNameRemoval here now.
if (options.extraSmartNameRemoval && options.smartNameRemoval) {
// These passes remove code that is dead because of define flags.
// If the dead code is weakly typed, running these passes before property
// disambiguation results in more code removal.
// The passes are one-time on purpose. (The later runs are loopable.)
if (options.foldConstants && (options.inlineVariables || options.inlineLocalVariables)) {
passes.add(earlyInlineVariables);
passes.add(earlyPeepholeOptimizations);
}
passes.add(removeUnusedCodeOnce);
}
// Property disambiguation should only run once and needs to be done
// soon after type checking, both so that it can make use of type
// information and so that other passes can take advantage of the renamed
// properties.
if (options.shouldDisambiguateProperties() && options.isTypecheckingEnabled()) {
passes.add(disambiguateProperties);
}
if (options.computeFunctionSideEffects) {
passes.add(markPureFunctions);
}
if (options.smartNameRemoval) {
passes.addAll(getCodeRemovingPasses());
// TODO(b/66971163): Remove this early loop or rename the option that enables it
// to something more appropriate.
}
// This needs to come after the inline constants pass, which is run within
// the code removing passes.
if (options.closurePass) {
passes.add(closureOptimizePrimitives);
}
// ReplaceStrings runs after CollapseProperties in order to simplify
// pulling in values of constants defined in enums structures. It also runs
// after disambiguate properties and smart name removal so that it can
// correctly identify logging types and can replace references to string
// expressions.
if (!options.replaceStringsFunctionDescriptions.isEmpty()) {
passes.add(replaceStrings);
}
// TODO(user): This forces a first crack at crossChunkCodeMotion
// before devirtualization. Once certain functions are devirtualized,
// it confuses crossChunkCodeMotion ability to recognized that
// it is recursive.
// TODO(user): This is meant for a temporary quick win.
// In the future, we might want to improve our analysis in
// CrossChunkCodeMotion so we don't need to do this.
if (options.shouldRunCrossChunkCodeMotion()) {
passes.add(crossModuleCodeMotion);
}
// Method devirtualization benefits from property disambiguation so
// it should run after that pass but before passes that do
// optimizations based on global names (like cross module code motion
// and inline functions). Smart Name Removal does better if run before
// this pass.
if (options.devirtualizeMethods) {
passes.add(devirtualizeMethods);
}
if (options.customPasses != null) {
passes.add(getCustomPasses(
CustomPassExecutionTime.BEFORE_OPTIMIZATION_LOOP));
}
passes.add(createEmptyPass(PassNames.BEFORE_MAIN_OPTIMIZATIONS));
// Because FlowSensitiveInlineVariables does not operate on the global scope due to compilation
// time, we need to run it once before InlineFunctions so that we don't miss inlining
// opportunities when a function will be inlined into the global scope.
if (options.inlineVariables || options.inlineLocalVariables) {
passes.add(flowSensitiveInlineVariables);
}
passes.addAll(getMainOptimizationLoop());
passes.add(createEmptyPass(PassNames.AFTER_MAIN_OPTIMIZATIONS));
passes.add(createEmptyPass("beforeModuleMotion"));
if (options.shouldRunCrossChunkCodeMotion()) {
passes.add(crossModuleCodeMotion);
}
if (options.shouldRunCrossChunkMethodMotion()) {
passes.add(crossModuleMethodMotion);
}
passes.add(createEmptyPass("afterModuleMotion"));
// Some optimizations belong outside the loop because running them more
// than once would either have no benefit or be incorrect.
if (options.customPasses != null) {
passes.add(getCustomPasses(
CustomPassExecutionTime.AFTER_OPTIMIZATION_LOOP));
}
if (options.inlineVariables || options.inlineLocalVariables) {
passes.add(flowSensitiveInlineVariables);
// After inlining some of the variable uses, some variables are unused.
// Re-run remove unused vars to clean it up.
if (shouldRunRemoveUnusedCode()) {
passes.add(removeUnusedCodeOnce);
}
}
if (options.collapseAnonymousFunctions) {
passes.add(collapseAnonymousFunctions);
}
// Move functions before extracting prototype member declarations.
if (options.moveFunctionDeclarations
// renamePrefixNamescape relies on moveFunctionDeclarations
// to preserve semantics.
|| options.renamePrefixNamespace != null) {
passes.add(moveFunctionDeclarations);
}
if (options.anonymousFunctionNaming == AnonymousFunctionNamingPolicy.MAPPED) {
passes.add(nameMappedAnonymousFunctions);
}
// The mapped name anonymous function pass makes use of information that
// the extract prototype member declarations pass removes so the former
// happens before the latter.
if (options.extractPrototypeMemberDeclarations != ExtractPrototypeMemberDeclarationsMode.OFF) {
passes.add(extractPrototypeMemberDeclarations);
}
if (options.shouldAmbiguateProperties()
&& options.propertyRenaming == PropertyRenamingPolicy.ALL_UNQUOTED
&& options.isTypecheckingEnabled()) {
passes.add(ambiguateProperties);
}
if (options.propertyRenaming == PropertyRenamingPolicy.ALL_UNQUOTED) {
passes.add(renameProperties);
}
// Reserve global names added to the "windows" object.
if (options.reserveRawExports) {
passes.add(gatherRawExports);
}
// This comes after property renaming because quoted property names must
// not be renamed.
if (options.convertToDottedProperties) {
passes.add(convertToDottedProperties);
}
// Property renaming must happen before this pass runs since this
// pass may convert dotted properties into quoted properties. It
// is beneficial to run before alias strings, alias keywords and
// variable renaming.
if (options.rewriteFunctionExpressions) {
passes.add(rewriteFunctionExpressions);
}
// This comes after converting quoted property accesses to dotted property
// accesses in order to avoid aliasing property names.
if (!options.aliasableStrings.isEmpty() || options.aliasAllStrings) {
passes.add(aliasStrings);
}
if (options.coalesceVariableNames) {
// Passes after this point can no longer depend on normalized AST
// assumptions because the code is marked as un-normalized
passes.add(coalesceVariableNames);
// coalesceVariables creates identity assignments and more redundant code
// that can be removed, rerun the peephole optimizations to clean them
// up.
if (options.foldConstants) {
passes.add(peepholeOptimizationsOnce);
}
}
// Passes after this point can no longer depend on normalized AST assumptions.
passes.add(markUnnormalized);
if (options.collapseVariableDeclarations) {
passes.add(exploitAssign);
passes.add(collapseVariableDeclarations);
}
// This pass works best after collapseVariableDeclarations.
passes.add(denormalize);
if (options.variableRenaming != VariableRenamingPolicy.ALL) {
// If we're leaving some (or all) variables with their old names,
// then we need to undo any of the markers we added for distinguishing
// local variables ("x" -> "x$jscomp$1").
passes.add(invertContextualRenaming);
}
if (options.variableRenaming != VariableRenamingPolicy.OFF) {
passes.add(renameVars);
}
if (options.labelRenaming) {
passes.add(renameLabels);
}
if (options.foldConstants) {
passes.add(latePeepholeOptimizations);
}
if (options.anonymousFunctionNaming == AnonymousFunctionNamingPolicy.UNMAPPED) {
passes.add(nameUnmappedAnonymousFunctions);
}
// If side-effects were protected, remove the protection now.
if (options.shouldProtectHiddenSideEffects()) {
passes.add(stripSideEffectProtection);
}
if (options.renamePrefixNamespace != null) {
if (!GLOBAL_SYMBOL_NAMESPACE_PATTERN.matcher(
options.renamePrefixNamespace).matches()) {
throw new IllegalArgumentException(
"Illegal character in renamePrefixNamespace name: "
+ options.renamePrefixNamespace);
}
passes.add(rescopeGlobalSymbols);
}
// Safety checks
passes.add(checkAstValidity);
passes.add(varCheckValidity);
// Raise to ES6, if allowed
if (options.getOutputFeatureSet().contains(ES6)) {
passes.add(optimizeToEs6);
}
assertValidOrderForOptimizations(passes);
return passes;
}
/** Creates the passes for the main optimization loop. */
private List getMainOptimizationLoop() {
List passes = new ArrayList<>();
if (options.inlineGetters) {
passes.add(inlineSimpleMethods);
}
passes.addAll(getCodeRemovingPasses());
if (options.getInlineFunctionsLevel() != Reach.NONE) {
passes.add(inlineFunctions);
}
if (options.shouldInlineProperties() && options.isTypecheckingEnabled()) {
passes.add(inlineProperties);
}
if (options.removeUnusedVars || options.removeUnusedLocalVars) {
if (options.deadAssignmentElimination) {
passes.add(deadAssignmentsElimination);
// The Polymer source is usually not included in the compilation, but it creates
// getters/setters for many properties in compiled code. Dead property assignment
// elimination is only safe when it knows about getters/setters. Therefore, we skip
// it if the polymer pass is enabled.
if (options.polymerVersion == null) {
passes.add(deadPropertyAssignmentElimination);
}
}
}
if (options.optimizeCalls) {
passes.add(optimizeCalls);
}
if (options.j2clPassMode.shouldAddJ2clPasses()) {
passes.add(j2clConstantHoisterPass);
passes.add(j2clClinitPass);
}
assertAllLoopablePasses(passes);
return passes;
}
/** Creates several passes aimed at removing code. */
private List getCodeRemovingPasses() {
List passes = new ArrayList<>();
if (options.collapseObjectLiterals) {
passes.add(collapseObjectLiterals);
}
if (options.inlineVariables || options.inlineLocalVariables) {
passes.add(inlineVariables);
} else if (options.inlineConstantVars) {
passes.add(inlineConstants);
}
if (options.foldConstants) {
passes.add(peepholeOptimizations);
}
if (options.removeDeadCode) {
passes.add(removeUnreachableCode);
}
if (shouldRunRemoveUnusedCode()) {
passes.add(removeUnusedCode);
}
assertAllLoopablePasses(passes);
return passes;
}
private boolean shouldRunRemoveUnusedCode() {
return options.removeUnusedVars
|| options.removeUnusedLocalVars
|| options.removeUnusedPrototypeProperties
|| options.isRemoveUnusedClassProperties()
|| options.rewritePolyfills;
}
private final PassFactory checkSideEffects =
PassFactory.builderForHotSwap()
.setName("checkSideEffects")
.setInternalFactory(
(compiler) ->
new CheckSideEffects(
compiler,
options.checkSuspiciousCode,
options.shouldProtectHiddenSideEffects()))
.setFeatureSet(ES_NEXT)
.build();
/** Removes the "protector" functions that were added by CheckSideEffects. */
private final PassFactory stripSideEffectProtection =
PassFactory.builder()
.setName(PassNames.STRIP_SIDE_EFFECT_PROTECTION)
.setInternalFactory(CheckSideEffects.StripProtection::new)
.setFeatureSet(FeatureSet.latest())
.build();
/** Checks for code that is probably wrong (such as stray expressions). */
private final PassFactory suspiciousCode =
PassFactory.builderForHotSwap()
.setName("suspiciousCode")
.setInternalFactory(
(compiler) -> {
List sharedCallbacks = new ArrayList<>();
if (options.checkSuspiciousCode) {
sharedCallbacks.add(new CheckSuspiciousCode());
sharedCallbacks.add(new CheckDuplicateCase(compiler));
}
if (options.enables(DiagnosticGroups.GLOBAL_THIS)) {
sharedCallbacks.add(new CheckGlobalThis(compiler));
}
if (options.enables(DiagnosticGroups.DEBUGGER_STATEMENT_PRESENT)) {
sharedCallbacks.add(new CheckDebuggerStatement(compiler));
}
return combineChecks(compiler, sharedCallbacks);
})
.setFeatureSet(ES_NEXT)
.build();
/** Verify that all the passes are one-time passes. */
private static void assertAllOneTimePasses(List passes) {
for (PassFactory pass : passes) {
checkState(!pass.isRunInFixedPointLoop());
}
}
/** Verify that all the passes are multi-run passes. */
private static void assertAllLoopablePasses(List passes) {
for (PassFactory pass : passes) {
checkState(pass.isRunInFixedPointLoop());
}
}
/**
* Checks that {@code pass1} comes before {@code pass2} in {@code passList}, if both are present.
*/
private void assertPassOrder(
List passList, PassFactory pass1, PassFactory pass2, String msg) {
int pass1Index = passList.indexOf(pass1);
int pass2Index = passList.indexOf(pass2);
if (pass1Index != -1 && pass2Index != -1) {
checkState(pass1Index < pass2Index, msg);
}
}
/**
* Certain checks and rewriting passes need to run in a particular order. For example, the
* PolymerPass will not work correctly unless it runs after the goog.provide() processing. This
* enforces those constraints.
*
* @param checks The list of check passes
*/
private void assertValidOrderForChecks(List checks) {
assertPassOrder(
checks,
declaredGlobalExternsOnWindow,
checkVars,
"declaredGlobalExternsOnWindow must happen before VarCheck, which adds synthetic externs");
assertPassOrder(
checks,
chromePass,
checkJsDocAndEs6Modules,
"The ChromePass must run before after JsDoc and Es6 module checking.");
assertPassOrder(
checks,
closureRewriteModule,
processDefines,
"Must rewrite goog.module before processing @define's, so that @defines in modules work.");
assertPassOrder(
checks,
closurePrimitives,
polymerPass,
"The Polymer pass must run after goog.provide processing.");
assertPassOrder(
checks,
chromePass,
polymerPass,
"The Polymer pass must run after ChromePass processing.");
assertPassOrder(
checks,
polymerPass,
suspiciousCode,
"The Polymer pass must run before suspiciousCode processing.");
assertPassOrder(
checks,
dartSuperAccessorsPass,
TranspilationPasses.es6ConvertSuper,
"The Dart super accessors pass must run before ES6->ES3 super lowering.");
assertPassOrder(
checks,
addSyntheticScript,
gatherModuleMetadataPass,
"Cannot add a synthetic script node after module metadata creation.");
assertPassOrder(
checks,
closureRewriteModule,
removeSyntheticScript,
"Synthetic script node should be removed only after module rewriting.");
if (checks.contains(closureGoogScopeAliases)) {
checkState(
checks.contains(checkVariableReferences),
"goog.scope processing requires variable checking");
}
assertPassOrder(
checks,
checkVariableReferences,
closureGoogScopeAliases,
"Variable checking must happen before goog.scope processing.");
assertPassOrder(
checks,
gatherModuleMetadataPass,
closureCheckModule,
"Need to gather module metadata before checking closure modules.");
assertPassOrder(
checks,
gatherModuleMetadataPass,
createModuleMapPass,
"Need to gather module metadata before scanning modules.");
assertPassOrder(
checks,
createModuleMapPass,
rewriteCommonJsModules,
"Need to gather module information before rewriting CommonJS modules.");
assertPassOrder(
checks,
rewriteScriptsToEs6Modules,
gatherModuleMetadataPass,
"Need to gather module information after rewriting scripts to modules.");
assertPassOrder(
checks,
checkClosureImports,
rewriteClosureImports,
"Closure imports must be checked before they are rewritten.");
assertPassOrder(
checks,
j2clPass,
TranspilationPasses.rewriteGenerators,
"J2CL normalization should be done before generator re-writing.");
}
/**
* Certain optimizations need to run in a particular order. For example, OptimizeCalls must run
* before RemoveSuperMethodsPass, because the former can invalidate assumptions in the latter.
* This enforces those constraints.
* @param optimizations The list of optimization passes
*/
private void assertValidOrderForOptimizations(List optimizations) {
assertPassOrder(
optimizations,
processDefines,
j2clUtilGetDefineRewriterPass,
"J2CL define re-writing should be done after processDefines since it relies on "
+ "collectDefines which has side effects.");
}
/** Checks that all constructed classes are goog.require()d. */
private final PassFactory checkRequires =
PassFactory.builderForHotSwap()
.setName("checkMissingAndExtraRequires")
.setFeatureSet(ES_NEXT)
.setInternalFactory(
(compiler) ->
new CheckMissingAndExtraRequires(
compiler, CheckMissingAndExtraRequires.Mode.FULL_COMPILE))
.build();
/** Makes sure @constructor is paired with goog.provides(). */
private final PassFactory checkProvides =
PassFactory.builderForHotSwap()
.setName("checkProvides")
.setFeatureSet(ES_NEXT)
.setInternalFactory(CheckProvides::new)
.build();
private static final DiagnosticType GENERATE_EXPORTS_ERROR =
DiagnosticType.error(
"JSC_GENERATE_EXPORTS_ERROR",
"Exports can only be generated if export symbol/property functions are set.");
/** Verifies JSDoc annotations are used properly and checks for ES6 modules. */
private final PassFactory checkJsDocAndEs6Modules =
PassFactory.builderForHotSwap()
.setName("checkJsDocAndEs6Modules")
.setFeatureSet(FeatureSet.latest())
.setInternalFactory(
(compiler) ->
combineChecks(
compiler,
ImmutableList.of(new CheckJSDoc(compiler), new Es6CheckModule(compiler))))
.build();
/** Generates exports for @export annotations. */
private final PassFactory generateExports =
PassFactory.builder()
.setName(PassNames.GENERATE_EXPORTS)
.setInternalFactory(
(compiler) -> {
CodingConvention convention = compiler.getCodingConvention();
if (convention.getExportSymbolFunction() != null
&& convention.getExportPropertyFunction() != null) {
final GenerateExports pass =
new GenerateExports(
compiler,
options.exportLocalPropertyDefinitions,
convention.getExportSymbolFunction(),
convention.getExportPropertyFunction());
return new CompilerPass() {
@Override
public void process(Node externs, Node root) {
pass.process(externs, root);
compiler.addExportedNames(pass.getExportedVariableNames());
}
};
} else {
return new ErrorPass(compiler, GENERATE_EXPORTS_ERROR);
}
})
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory generateIjs =
PassFactory.builder()
.setName("generateIjs")
.setInternalFactory(ConvertToTypedInterface::new)
.setFeatureSet(ES_NEXT)
.build();
/** Generates exports for functions associated with JsUnit. */
private final PassFactory exportTestFunctions =
PassFactory.builder()
.setName(PassNames.EXPORT_TEST_FUNCTIONS)
.setInternalFactory(
(compiler) -> {
CodingConvention convention = compiler.getCodingConvention();
if (convention.getExportSymbolFunction() != null) {
return new ExportTestFunctions(
compiler,
convention.getExportSymbolFunction(),
convention.getExportPropertyFunction());
} else {
return new ErrorPass(compiler, GENERATE_EXPORTS_ERROR);
}
})
.setFeatureSet(ES_NEXT)
.build();
/** Raw exports processing pass. */
private final PassFactory gatherRawExports =
PassFactory.builder()
.setName(PassNames.GATHER_RAW_EXPORTS)
.setInternalFactory(
(compiler) -> {
final GatherRawExports pass = new GatherRawExports(compiler);
return new CompilerPass() {
@Override
public void process(Node externs, Node root) {
pass.process(externs, root);
compiler.addExportedNames(pass.getExportedVariableNames());
}
};
})
// Should be FeatureSet.latest() since it's a trivial pass, but must match "normalize"
// TODO(johnlenz): Update this and normalize to latest()
.setFeatureSet(ES2019_MODULES)
.build();
/** Closure pre-processing pass. */
private final PassFactory closurePrimitives =
PassFactory.builderForHotSwap()
.setName("closurePrimitives")
.setInternalFactory(
(compiler) -> {
preprocessorSymbolTableFactory.maybeInitialize(compiler);
final ProcessClosurePrimitives pass =
new ProcessClosurePrimitives(
compiler, preprocessorSymbolTableFactory.getInstanceOrNull());
return new HotSwapCompilerPass() {
@Override
public void process(Node externs, Node root) {
pass.process(externs, root);
compiler.addExportedNames(pass.getExportedVariableNames());
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
pass.hotSwapScript(scriptRoot, originalRoot);
}
};
})
.setFeatureSet(ES_NEXT)
.build();
/** Closure provide/require rewriting pass. */
private final PassFactory closureProvidesRequires =
PassFactory.builderForHotSwap()
.setName("closureProvidesRequires")
.setInternalFactory(
(compiler) -> {
preprocessorSymbolTableFactory.maybeInitialize(compiler);
return new ProcessClosureProvidesAndRequires(
compiler,
preprocessorSymbolTableFactory.getInstanceOrNull(),
options.brokenClosureRequiresLevel,
options.shouldPreservesGoogProvidesAndRequires());
})
.setFeatureSet(ES_NEXT)
.build();
/** Process AngularJS-specific annotations. */
private final PassFactory angularPass =
PassFactory.builderForHotSwap()
.setName(PassNames.ANGULAR_PASS)
.setInternalFactory(AngularPass::new)
.setFeatureSet(ES_NEXT)
.build();
/**
* The default i18n pass. A lot of the options are not configurable, because ReplaceMessages has a
* lot of legacy logic.
*/
private final PassFactory replaceMessages =
PassFactory.builder()
.setName(PassNames.REPLACE_MESSAGES)
.setInternalFactory(
(compiler) ->
new ReplaceMessages(
compiler,
options.messageBundle,
/* warn about message dupes */
true,
/* allow messages with goog.getMsg */
JsMessage.Style.CLOSURE,
/* if we can't find a translation, don't worry about it. */
false))
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory replaceMessagesForChrome =
PassFactory.builder()
.setName(PassNames.REPLACE_MESSAGES)
.setInternalFactory(
(compiler) ->
new ReplaceMessagesForChrome(
compiler,
new GoogleJsMessageIdGenerator(options.tcProjectId),
/* warn about message dupes */
true,
/* allow messages with goog.getMsg */
JsMessage.Style.CLOSURE))
.setFeatureSet(ES2019_MODULES)
.build();
/** Applies aliases and inlines goog.scope. */
private final PassFactory closureGoogScopeAliasesForIjs =
PassFactory.builderForHotSwap()
.setName("closureGoogScopeAliasesForIjs")
.setInternalFactory((compiler) -> ScopedAliases.builder(compiler).build())
.setFeatureSet(ES_NEXT)
.build();
/**
* Applies aliases and inlines goog.scope, storing information about the transformations
* performed.
*/
private final PassFactory closureGoogScopeAliases =
PassFactory.builderForHotSwap()
.setName("closureGoogScopeAliases")
.setInternalFactory(
(compiler) -> {
preprocessorSymbolTableFactory.maybeInitialize(compiler);
return ScopedAliases.builder(compiler)
.setPreprocessorSymbolTable(preprocessorSymbolTableFactory.getInstanceOrNull())
.setAliasTransformationHandler(options.getAliasTransformationHandler())
.setModuleMetadataMap(compiler.getModuleMetadataMap())
.setInvalidModuleGetHandling(InvalidModuleGetHandling.DELETE)
.build();
})
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory injectRuntimeLibraries =
PassFactory.builder()
.setName("InjectRuntimeLibraries")
.setInternalFactory(InjectRuntimeLibraries::new)
.setFeatureSet(ES_NEXT)
.build();
/** Desugars ES6_TYPED features into ES6 code. */
final PassFactory convertEs6TypedToEs6 =
PassFactory.builderForHotSwap()
.setName("convertEs6Typed")
.setInternalFactory(Es6TypedToEs6Converter::new)
.setFeatureSet(TYPESCRIPT)
.build();
private final PassFactory markUntranspilableFeaturesAsRemoved =
PassFactory.builder()
.setName("markUntranspilableFeaturesAsRemoved")
.setInternalFactory(
(compiler) ->
new MarkUntranspilableFeaturesAsRemoved(compiler, options.getOutputFeatureSet()))
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory convertStaticInheritance =
PassFactory.builder()
.setName("Es6StaticInheritance")
.setInternalFactory(Es6ToEs3ClassSideInheritance::new)
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
private final PassFactory inlineTypeAliases =
PassFactory.builder()
.setName(PassNames.INLINE_TYPE_ALIASES)
.setInternalFactory(InlineAliases::new)
.setFeatureSet(ES_NEXT)
.build();
/** Inlines type aliases if they are explicitly or effectively const. */
private final PassFactory aggressiveInlineAliases =
PassFactory.builder()
.setName("aggressiveInlineAliases")
.setInternalFactory(AggressiveInlineAliases::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory removeWeakSources =
PassFactory.builder()
.setName("removeWeakSources")
.setInternalFactory(RemoveWeakSources::new)
.setFeatureSet(FeatureSet.latest())
.build();
private final PassFactory declaredGlobalExternsOnWindow =
PassFactory.builder()
.setName(PassNames.DECLARED_GLOBAL_EXTERNS_ON_WINDOW)
.setInternalFactory(DeclaredGlobalExternsOnWindow::new)
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory checkTypeImportCodeReferences =
PassFactory.builder()
.setName("checkTypeImportCodeReferences")
.setInternalFactory(CheckTypeImportCodeReferences::new)
.setFeatureSet(FeatureSet.latest())
.build();
/** Rewrites goog.defineClass */
private final PassFactory closureRewriteClass =
PassFactory.builderForHotSwap()
.setName(PassNames.CLOSURE_REWRITE_CLASS)
.setInternalFactory(ClosureRewriteClass::new)
.setFeatureSet(ES_NEXT)
.build();
/** Checks of correct usage of goog.module */
private final PassFactory closureCheckModule =
PassFactory.builderForHotSwap()
.setName("closureCheckModule")
.setInternalFactory(
(compiler) -> new ClosureCheckModule(compiler, compiler.getModuleMetadataMap()))
.setFeatureSet(ES_NEXT)
.build();
/** Rewrites goog.module */
private final PassFactory closureRewriteModule =
PassFactory.builderForHotSwap()
.setName("closureRewriteModule")
.setInternalFactory(
(compiler) -> {
preprocessorSymbolTableFactory.maybeInitialize(compiler);
maybeInitializeModuleRewriteState();
return new ClosureRewriteModule(
compiler,
preprocessorSymbolTableFactory.getInstanceOrNull(),
moduleRewriteState);
})
.setFeatureSet(ES_NEXT)
.build();
/** Checks goog.require, goog.forwardDeclare, goog.requireType, and goog.module.get calls */
private final PassFactory checkClosureImports =
PassFactory.builderForHotSwap()
.setName("checkGoogRequires")
.setInternalFactory(
(compiler) -> new CheckClosureImports(compiler, compiler.getModuleMetadataMap()))
.setFeatureSet(ES_NEXT)
.build();
/** Rewrites goog.require, goog.forwardDeclare, goog.requireType, and goog.module.get calls */
private final PassFactory rewriteClosureImports =
PassFactory.builderForHotSwap()
.setName("rewriteClosureImports")
.setInternalFactory(
(compiler) ->
new RewriteClosureImports(
compiler,
compiler.getModuleMetadataMap(),
preprocessorSymbolTableFactory.getInstanceOrNull(),
// TODO(johnplaisted): Expand the Set of modules to rewrite in.
ImmutableSet.of()))
.setFeatureSet(ES_NEXT)
.build();
/** Rewrite imports for Closure Library's goog.js file to global goog references. */
private final PassFactory rewriteGoogJsImports =
PassFactory.builderForHotSwap()
.setName("rewriteGoogJsImports")
.setInternalFactory(
(compiler) ->
new RewriteGoogJsImports(
compiler,
RewriteGoogJsImports.Mode.LINT_AND_REWRITE,
compiler.getModuleMap()))
.setFeatureSet(ES_NEXT)
.build();
/** Checks that CSS class names are wrapped in goog.getCssName */
private final PassFactory closureCheckGetCssName =
PassFactory.builder()
.setName("closureCheckGetCssName")
.setInternalFactory(
(compiler) ->
new CheckMissingGetCssName(
compiler,
options.checkMissingGetCssNameLevel,
options.checkMissingGetCssNameBlacklist))
.setFeatureSet(ES_NEXT)
.build();
/**
* Processes goog.getCssName. The cssRenamingMap is used to lookup replacement values for the
* classnames. If null, the raw class names are inlined.
*/
private final PassFactory closureReplaceGetCssName =
PassFactory.builder()
.setName("closureReplaceGetCssName")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node jsRoot) {
Map newCssNames = null;
if (options.gatherCssNames) {
newCssNames = new HashMap<>();
}
ReplaceCssNames pass =
new ReplaceCssNames(compiler, newCssNames, options.cssRenamingWhitelist);
pass.process(externs, jsRoot);
compiler.setCssNames(newCssNames);
}
})
.setFeatureSet(ES_NEXT)
.build();
/**
* Creates synthetic blocks to prevent FoldConstants from moving code past markers in the source.
*/
private final PassFactory createSyntheticBlocks =
PassFactory.builder()
.setName("createSyntheticBlocks")
.setInternalFactory(
(compiler) ->
new CreateSyntheticBlocks(
compiler, options.syntheticBlockStartMarker, options.syntheticBlockEndMarker))
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory earlyPeepholeOptimizations =
PassFactory.builder()
.setName("earlyPeepholeOptimizations")
.setInternalFactory(
(compiler) -> {
boolean useTypesForOptimization =
compiler.getOptions().useTypesForLocalOptimization;
List peepholeOptimizations = new ArrayList<>();
peepholeOptimizations.add(new PeepholeRemoveDeadCode());
if (compiler.getOptions().j2clPassMode.shouldAddJ2clPasses()) {
peepholeOptimizations.add(
new J2clEqualitySameRewriterPass(useTypesForOptimization));
}
return new PeepholeOptimizationsPass(
compiler, "earlyPeepholeOptimizations", peepholeOptimizations);
})
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory earlyInlineVariables =
PassFactory.builder()
.setName("earlyInlineVariables")
.setInternalFactory(
(compiler) -> {
InlineVariables.Mode mode;
if (options.inlineVariables) {
mode = InlineVariables.Mode.ALL;
} else if (options.inlineLocalVariables) {
mode = InlineVariables.Mode.LOCALS_ONLY;
} else {
throw new IllegalStateException("No variable inlining option set.");
}
return new InlineVariables(compiler, mode, true);
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Various peephole optimizations. */
private static CompilerPass createPeepholeOptimizationsPass(
AbstractCompiler compiler, String passName) {
final boolean late = false;
final boolean useTypesForOptimization = compiler.getOptions().useTypesForLocalOptimization;
List optimizations = new ArrayList<>();
optimizations.add(new MinimizeExitPoints());
optimizations.add(new PeepholeMinimizeConditions(late));
optimizations.add(new PeepholeSubstituteAlternateSyntax(late));
optimizations.add(new PeepholeReplaceKnownMethods(late, useTypesForOptimization));
optimizations.add(new PeepholeRemoveDeadCode());
if (compiler.getOptions().j2clPassMode.shouldAddJ2clPasses()) {
optimizations.add(new J2clEqualitySameRewriterPass(useTypesForOptimization));
optimizations.add(new J2clStringValueOfRewriterPass());
}
optimizations.add(new PeepholeFoldConstants(late, useTypesForOptimization));
optimizations.add(new PeepholeCollectPropertyAssignments());
return new PeepholeOptimizationsPass(compiler, passName, optimizations);
}
/** Various peephole optimizations. */
private final PassFactory peepholeOptimizations =
PassFactory.builder()
.setName(PassNames.PEEPHOLE_OPTIMIZATIONS)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) ->
createPeepholeOptimizationsPass(compiler, PassNames.PEEPHOLE_OPTIMIZATIONS))
.setFeatureSet(ES2019_MODULES)
.build();
/** Various peephole optimizations. */
private final PassFactory peepholeOptimizationsOnce =
PassFactory.builder()
.setName(PassNames.PEEPHOLE_OPTIMIZATIONS)
.setInternalFactory(
(compiler) ->
createPeepholeOptimizationsPass(compiler, PassNames.PEEPHOLE_OPTIMIZATIONS))
.setFeatureSet(ES2019_MODULES)
.build();
/** Same as peepholeOptimizations but aggressively merges code together */
private final PassFactory latePeepholeOptimizations =
PassFactory.builder()
.setName("latePeepholeOptimizations")
.setInternalFactory(
(compiler) -> {
final boolean late = true;
final boolean useTypesForOptimization = options.useTypesForLocalOptimization;
return new PeepholeOptimizationsPass(
compiler,
"latePeepholeOptimizations",
new StatementFusion(options.aggressiveFusion),
new PeepholeRemoveDeadCode(),
new PeepholeMinimizeConditions(late),
new PeepholeSubstituteAlternateSyntax(late),
new PeepholeReplaceKnownMethods(late, useTypesForOptimization),
new PeepholeFoldConstants(late, useTypesForOptimization),
new PeepholeReorderConstantExpression());
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Checks that all variables are defined. */
private final PassFactory checkVars =
PassFactory.builderForHotSwap()
.setName(PassNames.CHECK_VARS)
.setInternalFactory(VarCheck::new)
.setFeatureSet(ES_NEXT)
.build();
/** Infers constants. */
private final PassFactory inferConsts =
PassFactory.builder()
.setName(PassNames.INFER_CONSTS)
.setInternalFactory(InferConsts::new)
.setFeatureSet(ES_NEXT)
.build();
/** Checks for RegExp references. */
private final PassFactory checkRegExp =
PassFactory.builder()
.setName(PassNames.CHECK_REG_EXP)
.setInternalFactory(
(compiler) -> {
final CheckRegExp pass = new CheckRegExp(compiler);
return new CompilerPass() {
@Override
public void process(Node externs, Node root) {
pass.process(externs, root);
compiler.setHasRegExpGlobalReferences(pass.isGlobalRegExpPropertiesUsed());
}
};
})
.setFeatureSet(ES_NEXT)
.build();
/** Checks that references to variables look reasonable. */
private final PassFactory checkVariableReferencesForTranspileOnly =
PassFactory.builderForHotSwap()
.setName(PassNames.CHECK_VARIABLE_REFERENCES)
.setInternalFactory((compiler) -> new VariableReferenceCheck(compiler, true))
.setFeatureSet(ES2019_MODULES)
.build();
/** Checks that references to variables look reasonable. */
private final PassFactory checkVariableReferences =
PassFactory.builderForHotSwap()
.setName(PassNames.CHECK_VARIABLE_REFERENCES)
.setInternalFactory(VariableReferenceCheck::new)
.setFeatureSet(ES_NEXT)
.build();
/** Checks that references to variables look reasonable. */
private final PassFactory checkSuper =
PassFactory.builderForHotSwap()
.setName("checkSuper")
.setInternalFactory(CheckSuper::new)
.setFeatureSet(ES_NEXT)
.build();
/** Creates a typed scope and adds types to the type registry. */
final PassFactory resolveTypes =
PassFactory.builderForHotSwap()
.setName(PassNames.RESOLVE_TYPES)
.setInternalFactory(GlobalTypeResolver::new)
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Clears the typed scope when we're done. */
private final PassFactory clearTypedScopePass =
PassFactory.builder()
.setName("clearTypedScopePass")
.setInternalFactory((compiler) -> new ClearTypedScope())
.setFeatureSet(FeatureSet.latest())
.build();
/** Runs type inference. */
final PassFactory inferTypes =
PassFactory.builderForHotSwap()
.setName(PassNames.INFER_TYPES)
.setInternalFactory(
(compiler) ->
new HotSwapCompilerPass() {
@Override
public void process(Node externs, Node root) {
checkNotNull(topScope);
checkNotNull(getTypedScopeCreator());
makeTypeInference(compiler).process(externs, root);
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
makeTypeInference(compiler).inferAllScopes(scriptRoot);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
private final PassFactory inferJsDocInfo =
PassFactory.builderForHotSwap()
.setName("inferJsDocInfo")
.setInternalFactory(
(compiler) ->
new HotSwapCompilerPass() {
@Override
public void process(Node externs, Node root) {
checkNotNull(topScope);
checkNotNull(getTypedScopeCreator());
makeInferJsDocInfo(compiler).process(externs, root);
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
makeInferJsDocInfo(compiler).hotSwapScript(scriptRoot, originalRoot);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Checks type usage */
private final PassFactory checkTypes =
PassFactory.builderForHotSwap()
.setName(PassNames.CHECK_TYPES)
.setInternalFactory(
(compiler) ->
new HotSwapCompilerPass() {
@Override
public void process(Node externs, Node root) {
checkNotNull(topScope);
checkNotNull(getTypedScopeCreator());
TypeCheck check = makeTypeCheck(compiler);
check.process(externs, root);
compiler.getErrorManager().setTypedPercent(check.getTypedPercent());
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
makeTypeCheck(compiler).check(scriptRoot, false);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/**
* Checks possible execution paths of the program for problems: missing return statements and dead
* code.
*/
private final PassFactory checkControlFlow =
PassFactory.builderForHotSwap()
.setName("checkControlFlow")
.setInternalFactory(
(compiler) -> {
List callbacks = new ArrayList<>();
if (!options.disables(DiagnosticGroups.CHECK_USELESS_CODE)) {
callbacks.add(new CheckUnreachableCode(compiler));
}
if (!options.disables(DiagnosticGroups.MISSING_RETURN)) {
callbacks.add(new CheckMissingReturn(compiler));
}
return combineChecks(compiler, callbacks);
})
.setFeatureSet(ES_NEXT)
.build();
/** Checks access controls. Depends on type-inference. */
private final PassFactory checkAccessControls =
PassFactory.builderForHotSwap()
.setName("checkAccessControls")
.setInternalFactory(
(compiler) ->
new CheckAccessControls(compiler, options.enforceAccessControlCodingConventions))
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
private final PassFactory lintChecks =
PassFactory.builderForHotSwap()
.setName(PassNames.LINT_CHECKS)
.setInternalFactory(
(compiler) -> {
ImmutableList.Builder callbacks =
ImmutableList.builder()
.add(new CheckConstantCaseNames(compiler))
.add(new CheckEmptyStatements(compiler))
.add(new CheckEnums(compiler))
.add(new CheckEs6ModuleFileStructure(compiler))
.add(new CheckEs6Modules(compiler))
.add(new CheckNoMutatedEs6Exports(compiler))
.add(new CheckInterfaces(compiler))
.add(new CheckJSDocStyle(compiler))
.add(new CheckMissingSemicolon(compiler))
.add(new CheckNullabilityModifiers(compiler))
.add(new CheckPrimitiveAsObject(compiler))
.add(new CheckPrototypeProperties(compiler))
.add(new CheckUnusedLabels(compiler))
.add(new CheckUselessBlocks(compiler));
return combineChecks(compiler, callbacks.build());
})
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory analyzerChecks =
PassFactory.builderForHotSwap()
.setName(PassNames.ANALYZER_CHECKS)
.setInternalFactory(
(compiler) -> {
ImmutableList.Builder callbacks = ImmutableList.builder();
if (options.enables(DiagnosticGroups.ANALYZER_CHECKS_INTERNAL)) {
callbacks
.add(new CheckNullableReturn(compiler))
.add(new CheckArrayWithGoogObject(compiler))
.add(new ImplicitNullabilityCheck(compiler));
}
// These are grouped together for better execution efficiency.
if (options.enables(DiagnosticGroups.UNUSED_PRIVATE_PROPERTY)) {
callbacks.add(new CheckUnusedPrivateProperties(compiler));
}
if (options.enables(DiagnosticGroups.MISSING_CONST_PROPERTY)) {
callbacks.add(new CheckConstPrivateProperties(compiler));
}
return combineChecks(compiler, callbacks.build());
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
private final PassFactory checkRequiresAndProvidesSorted =
PassFactory.builderForHotSwap()
.setName("checkRequiresAndProvidesSorted")
.setInternalFactory(
(compiler) -> {
return combineChecks(
compiler,
ImmutableList.of(
new CheckProvidesSorted(CheckProvidesSorted.Mode.COLLECT_AND_REPORT),
new CheckRequiresSorted(CheckRequiresSorted.Mode.COLLECT_AND_REPORT)));
})
.setFeatureSet(ES_NEXT)
.build();
/** Executes the given callbacks with a {@link CombinedCompilerPass}. */
private static HotSwapCompilerPass combineChecks(AbstractCompiler compiler,
List callbacks) {
checkArgument(!callbacks.isEmpty());
return new CombinedCompilerPass(compiler, callbacks);
}
/** A compiler pass that resolves types in the global scope. */
class GlobalTypeResolver implements HotSwapCompilerPass {
private AbstractCompiler compiler;
GlobalTypeResolver(AbstractCompiler compiler) {
this.compiler = compiler;
}
@Override
public void process(Node externs, Node root) {
this.compiler.setTypeCheckingHasRun(true);
if (topScope == null) {
regenerateGlobalTypedScope(compiler, root.getParent());
} else {
compiler.getTypeRegistry().resolveTypes();
}
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
patchGlobalTypedScope(compiler, scriptRoot);
}
}
/** A compiler pass that clears the global scope. */
class ClearTypedScope implements CompilerPass {
@Override
public void process(Node externs, Node root) {
clearTypedScope();
}
}
/** Checks global name usage. */
private final PassFactory checkGlobalNames =
PassFactory.builder()
.setName("checkGlobalNames")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node jsRoot) {
// Create a global namespace for analysis by check passes.
// Note that this class does all heavy computation lazily,
// so it's OK to create it here.
namespaceForChecks = new GlobalNamespace(compiler, externs, jsRoot);
new CheckGlobalNames(compiler, options.checkGlobalNamesLevel)
.injectNamespace(namespaceForChecks)
.process(externs, jsRoot);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Checks that the code is ES5 strict compliant. */
private final PassFactory checkStrictMode =
PassFactory.builder()
.setName("checkStrictMode")
.setInternalFactory(StrictModeCheck::new)
.setFeatureSet(ES_NEXT)
.build();
/** Process goog.tweak.getTweak() calls. */
private final PassFactory processTweaks =
PassFactory.builder()
.setName("processTweaks")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node jsRoot) {
new ProcessTweaks(
compiler,
options.getTweakProcessing().shouldStrip(),
options.getTweakReplacements())
.process(externs, jsRoot);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Override @define-annotated constants. */
private final PassFactory processDefines =
PassFactory.builder()
.setName("processDefines")
.setInternalFactory(
(compiler) ->
new ProcessDefines.Builder(compiler)
.putReplacements(compiler.getDefaultDefineValues())
.putReplacements(getAdditionalReplacements(options))
.putReplacements(options.getDefineReplacements())
.checksOnly(options.checksOnly)
.injectNamespace(() -> namespaceForChecks)
.build())
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/**
* Strips code for smaller compiled code. This is useful for removing debug statements to prevent
* leaking them publicly.
*/
private final PassFactory stripCode =
PassFactory.builder()
.setName("stripCode")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node jsRoot) {
CompilerOptions options = compiler.getOptions();
StripCode pass =
new StripCode(
compiler,
options.stripTypes,
options.stripNameSuffixes,
options.stripTypePrefixes,
options.stripNamePrefixes);
if (options.getTweakProcessing().shouldStrip()) {
pass.enableTweakStripping();
}
pass.process(externs, jsRoot);
}
})
.
// TODO(johnlenz): StripCode may be fooled by some newer features, like destructuring,
// an).build();
setFeatureSet(ES2019_MODULES)
.build();
/** Release references to data that is only needed during checks. */
final PassFactory garbageCollectChecks =
PassFactory.builderForHotSwap()
.setName("garbageCollectChecks")
.setInternalFactory(
(compiler) ->
new HotSwapCompilerPass() {
@Override
public void process(Node externs, Node jsRoot) {
// Kill the global namespace so that it can be garbage collected
// after all passes are through with it.
namespaceForChecks = null;
}
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
process(null, null);
}
})
.setFeatureSet(FeatureSet.latest())
.build();
/** Checks that all constants are not modified */
private final PassFactory checkConsts =
PassFactory.builder()
.setName("checkConsts")
.setInternalFactory(ConstCheck::new)
.setFeatureSet(ES_NEXT)
.build();
/** Checks that the arguments are constants */
private final PassFactory checkConstParams =
PassFactory.builder()
.setName(PassNames.CHECK_CONST_PARAMS)
.setInternalFactory(ConstParamCheck::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Inserts run-time type assertions for debugging. */
private final PassFactory runtimeTypeCheck =
PassFactory.builder()
.setName(PassNames.RUNTIME_TYPE_CHECK)
.setInternalFactory(
(compiler) -> new RuntimeTypeCheck(compiler, options.runtimeTypeCheckLogFunction))
.setFeatureSet(ES5)
.build();
/** Generates unique ids. */
private final PassFactory replaceIdGenerators =
PassFactory.builder()
.setName(PassNames.REPLACE_ID_GENERATORS)
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node root) {
ReplaceIdGenerators pass =
new ReplaceIdGenerators(
compiler,
options.idGenerators,
options.generatePseudoNames,
options.idGeneratorsMapSerialized,
options.xidHashFunction);
pass.process(externs, root);
compiler.setIdGeneratorMap(pass.getSerializedIdMappings());
}
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Replace strings. */
private final PassFactory replaceStrings =
PassFactory.builder()
.setName("replaceStrings")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node root) {
ReplaceStrings pass =
new ReplaceStrings(
compiler,
options.replaceStringsPlaceholderToken,
options.replaceStringsFunctionDescriptions,
options.replaceStringsReservedStrings,
options.replaceStringsInputMap);
pass.process(externs, root);
compiler.setStringMap(pass.getStringMap());
}
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Optimizes the "arguments" array. */
private final PassFactory optimizeArgumentsArray =
PassFactory.builder()
.setName(PassNames.OPTIMIZE_ARGUMENTS_ARRAY)
.setInternalFactory(OptimizeArgumentsArray::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Remove variables set to goog.abstractMethod. */
private final PassFactory closureCodeRemoval =
PassFactory.builder()
.setName("closureCodeRemoval")
.setInternalFactory(
(compiler) ->
new ClosureCodeRemoval(
compiler, options.removeAbstractMethods, options.removeClosureAsserts))
.setFeatureSet(ES2019_MODULES)
.build();
/** Special case optimizations for closure functions. */
private final PassFactory closureOptimizePrimitives =
PassFactory.builder()
.setName("closureOptimizePrimitives")
.setInternalFactory(
(compiler) ->
new ClosureOptimizePrimitives(
compiler,
compiler.getOptions().propertyRenaming == PropertyRenamingPolicy.ALL_UNQUOTED,
compiler.getOptions().getOutputFeatureSet().contains(ES6)))
.setFeatureSet(ES2019_MODULES)
.build();
/** Puts global symbols into a single object. */
private final PassFactory rescopeGlobalSymbols =
PassFactory.builder()
.setName("rescopeGlobalSymbols")
.setInternalFactory(
(compiler) ->
new RescopeGlobalSymbols(
compiler,
options.renamePrefixNamespace,
options.renamePrefixNamespaceAssumeCrossChunkNames))
.setFeatureSet(ES2019_MODULES)
.build();
/** Collapses names in the global scope. */
private final PassFactory collapseProperties =
PassFactory.builder()
.setName(PassNames.COLLAPSE_PROPERTIES)
.setInternalFactory(
(compiler) -> new CollapseProperties(compiler, options.getPropertyCollapseLevel()))
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrite properties as variables. */
private final PassFactory collapseObjectLiterals =
PassFactory.builder()
.setName(PassNames.COLLAPSE_OBJECT_LITERALS)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) -> new InlineObjectLiterals(compiler, compiler.getUniqueNameIdSupplier()))
.setFeatureSet(ES2019_MODULES)
.build();
/** Disambiguate property names based on the coding convention. */
private final PassFactory disambiguatePrivateProperties =
PassFactory.builder()
.setName(PassNames.DISAMBIGUATE_PRIVATE_PROPERTIES)
.setInternalFactory(DisambiguatePrivateProperties::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Disambiguate property names based on type information. */
private final PassFactory disambiguateProperties =
PassFactory.builder()
.setName(PassNames.DISAMBIGUATE_PROPERTIES)
.setInternalFactory(
(compiler) ->
new DisambiguateProperties(compiler, options.propertyInvalidationErrors))
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrite instance methods as static methods, to make them easier to inline. */
private final PassFactory devirtualizeMethods =
PassFactory.builder()
.setName(PassNames.DEVIRTUALIZE_METHODS)
.setInternalFactory(
(compiler) -> {
return OptimizeCalls.builder()
.setCompiler(compiler)
.setConsiderExterns(false)
.addPass(new DevirtualizeMethods(compiler))
.build();
})
.setFeatureSet(ES2019_MODULES)
.build();
/**
* Optimizes unused function arguments, unused return values, and inlines constant parameters.
* Also runs RemoveUnusedCode.
*/
private final PassFactory optimizeCalls =
PassFactory.builder()
.setName(PassNames.OPTIMIZE_CALLS)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) -> {
return OptimizeCalls.builder()
.setCompiler(compiler)
.setConsiderExterns(false)
// Remove unused return values.
.addPass(new OptimizeReturns(compiler))
// Remove all parameters that are constants or unused.
.addPass(new OptimizeParameters(compiler))
.build();
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Look for function calls that are pure, and annotate them that way. */
private final PassFactory markPureFunctions =
PassFactory.builder()
.setName("markPureFunctions")
.setInternalFactory(PureFunctionIdentifier.Driver::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Inlines variables heuristically. */
private final PassFactory inlineVariables =
PassFactory.builder()
.setName(PassNames.INLINE_VARIABLES)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) -> {
InlineVariables.Mode mode;
if (options.inlineVariables) {
mode = InlineVariables.Mode.ALL;
} else if (options.inlineLocalVariables) {
mode = InlineVariables.Mode.LOCALS_ONLY;
} else {
throw new IllegalStateException("No variable inlining option set.");
}
return new InlineVariables(compiler, mode, true);
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Inlines variables that are marked as constants. */
private final PassFactory inlineConstants =
PassFactory.builder()
.setName("inlineConstants")
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) ->
new InlineVariables(compiler, InlineVariables.Mode.CONSTANTS_ONLY, true))
.setFeatureSet(ES2019_MODULES)
.build();
/** Use data flow analysis to remove dead branches. */
private final PassFactory removeUnreachableCode =
PassFactory.builder()
.setName(PassNames.REMOVE_UNREACHABLE_CODE)
.setRunInFixedPointLoop(true)
.setInternalFactory(UnreachableCodeElimination::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Inlines simple methods, like getters */
private final PassFactory inlineSimpleMethods =
PassFactory.builder()
.setName("inlineSimpleMethods")
.setRunInFixedPointLoop(true)
.setInternalFactory(InlineSimpleMethods::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Kills dead assignments. */
private final PassFactory deadAssignmentsElimination =
PassFactory.builder()
.setName(PassNames.DEAD_ASSIGNMENT_ELIMINATION)
.setRunInFixedPointLoop(true)
.setInternalFactory(DeadAssignmentsElimination::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Kills dead property assignments. */
private final PassFactory deadPropertyAssignmentElimination =
PassFactory.builder()
.setName("deadPropertyAssignmentElimination")
.setRunInFixedPointLoop(true)
.setInternalFactory(DeadPropertyAssignmentElimination::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Inlines function calls. */
private final PassFactory inlineFunctions =
PassFactory.builder()
.setName(PassNames.INLINE_FUNCTIONS)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) ->
new InlineFunctions(
compiler,
compiler.getUniqueNameIdSupplier(),
options.getInlineFunctionsLevel(),
options.assumeStrictThis() || options.expectStrictModeInput(),
options.assumeClosuresOnlyCaptureReferences,
options.maxFunctionSizeAfterInlining))
.setFeatureSet(ES2019_MODULES)
.build();
/** Inlines constant properties. */
private final PassFactory inlineProperties =
PassFactory.builder()
.setName(PassNames.INLINE_PROPERTIES)
.setRunInFixedPointLoop(true)
.setInternalFactory(InlineProperties::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory removeUnusedCode =
PassFactory.builder()
.setName(PassNames.REMOVE_UNUSED_CODE)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) -> {
boolean preserveAnonymousFunctionNames =
options.anonymousFunctionNaming != AnonymousFunctionNamingPolicy.OFF;
return new RemoveUnusedCode.Builder(compiler)
.removeLocalVars(options.removeUnusedLocalVars)
.removeGlobals(options.removeUnusedVars)
.preserveFunctionExpressionNames(preserveAnonymousFunctionNames)
.removeUnusedPrototypeProperties(options.removeUnusedPrototypeProperties)
.allowRemovalOfExternProperties(
options.removeUnusedPrototypePropertiesInExterns)
.removeUnusedThisProperties(options.isRemoveUnusedClassProperties())
.removeUnusedObjectDefinePropertiesDefinitions(
options.isRemoveUnusedClassProperties())
.removeUnusedPolyfills(options.rewritePolyfills)
.assumeGettersArePure(options.getAssumeGettersArePure())
.build();
})
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory removeUnusedCodeOnce =
removeUnusedCode.toBuilder().setRunInFixedPointLoop(false).build();
/** Move global symbols to a deeper common module */
private final PassFactory crossModuleCodeMotion =
PassFactory.builder()
.setName(PassNames.CROSS_CHUNK_CODE_MOTION)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) ->
new CrossChunkCodeMotion(
compiler,
compiler.getModuleGraph(),
options.parentChunkCanSeeSymbolsDeclaredInChildren))
.setFeatureSet(ES2019_MODULES)
.build();
/** Move methods to a deeper common module */
private final PassFactory crossModuleMethodMotion =
PassFactory.builder()
.setName(PassNames.CROSS_CHUNK_METHOD_MOTION)
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) ->
new CrossChunkMethodMotion(
compiler,
compiler.getCrossModuleIdGenerator(),
// Only move properties in externs if we're not treating
// them as exports.
options.removeUnusedPrototypePropertiesInExterns,
options.crossChunkCodeMotionNoStubMethods))
.setFeatureSet(ES2019_MODULES)
.build();
/** A data-flow based variable inliner. */
private final PassFactory flowSensitiveInlineVariables =
PassFactory.builder()
.setName(PassNames.FLOW_SENSITIVE_INLINE_VARIABLES)
.setInternalFactory(FlowSensitiveInlineVariables::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Uses register-allocation algorithms to use fewer variables. */
private final PassFactory coalesceVariableNames =
PassFactory.builder()
.setName(PassNames.COALESCE_VARIABLE_NAMES)
.setInternalFactory(
(compiler) -> new CoalesceVariableNames(compiler, options.generatePseudoNames))
.setFeatureSet(ES2019_MODULES)
.build();
/** Some simple, local collapses (e.g., {@code var x; var y;} becomes {@code var x,y;}. */
private final PassFactory exploitAssign =
PassFactory.builder()
.setName(PassNames.EXPLOIT_ASSIGN)
.setInternalFactory(
(compiler) ->
new PeepholeOptimizationsPass(
compiler, PassNames.EXPLOIT_ASSIGN, new ExploitAssigns()))
.setFeatureSet(ES2019_MODULES)
.build();
/** Some simple, local collapses (e.g., {@code var x; var y;} becomes {@code var x,y;}. */
private final PassFactory collapseVariableDeclarations =
PassFactory.builder()
.setName(PassNames.COLLAPSE_VARIABLE_DECLARATIONS)
.setInternalFactory(CollapseVariableDeclarations::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Extracts common sub-expressions. */
private final PassFactory extractPrototypeMemberDeclarations =
PassFactory.builder()
.setName(PassNames.EXTRACT_PROTOTYPE_MEMBER_DECLARATIONS)
.setInternalFactory(
(compiler) -> {
Pattern pattern;
switch (options.extractPrototypeMemberDeclarations) {
case USE_GLOBAL_TEMP:
pattern = Pattern.USE_GLOBAL_TEMP;
break;
case USE_IIFE:
pattern = Pattern.USE_IIFE;
break;
default:
throw new IllegalStateException("unexpected");
}
return new ExtractPrototypeMemberDeclarations(compiler, pattern);
})
.setFeatureSet(ES2019)
.build();
/** Rewrites common function definitions to be more compact. */
private final PassFactory rewriteFunctionExpressions =
PassFactory.builder()
.setName(PassNames.REWRITE_FUNCTION_EXPRESSIONS)
.setInternalFactory(FunctionRewriter::new)
.setFeatureSet(FeatureSet.latest())
.build();
/** Collapses functions to not use the VAR keyword. */
private final PassFactory collapseAnonymousFunctions =
PassFactory.builder()
.setName(PassNames.COLLAPSE_ANONYMOUS_FUNCTIONS)
.setInternalFactory(CollapseAnonymousFunctions::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Moves function declarations to the top, to simulate actual hoisting. */
private final PassFactory moveFunctionDeclarations =
PassFactory.builder()
.setName(PassNames.MOVE_FUNCTION_DECLARATIONS)
.setInternalFactory(MoveFunctionDeclarations::new)
.setFeatureSet(ES2019)
.build();
private final PassFactory nameUnmappedAnonymousFunctions =
PassFactory.builder()
.setName(PassNames.NAME_ANONYMOUS_FUNCTIONS)
.setInternalFactory(NameAnonymousFunctions::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory nameMappedAnonymousFunctions =
PassFactory.builder()
.setName(PassNames.NAME_ANONYMOUS_FUNCTIONS)
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node root) {
NameAnonymousFunctionsMapped naf =
new NameAnonymousFunctionsMapped(
compiler, options.inputAnonymousFunctionNamingMap);
naf.process(externs, root);
compiler.setAnonymousFunctionNameMap(naf.getFunctionMap());
}
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Alias string literals with global variables, to avoid creating lots of transient objects. */
private final PassFactory aliasStrings =
PassFactory.builder()
.setName("aliasStrings")
.setInternalFactory(
(compiler) ->
new AliasStrings(
compiler,
compiler.getModuleGraph(),
options.aliasAllStrings ? null : options.aliasableStrings,
options.aliasStringsBlacklist,
options.outputJsStringUsage))
.setFeatureSet(ES2019_MODULES)
.build();
/**
* Renames properties so that the two properties that never appear on the same object get the same
* name.
*/
private final PassFactory ambiguateProperties =
PassFactory.builder()
.setName(PassNames.AMBIGUATE_PROPERTIES)
.setInternalFactory(
(compiler) ->
new AmbiguateProperties(
compiler,
options.getPropertyReservedNamingFirstChars(),
options.getPropertyReservedNamingNonFirstChars()))
.setFeatureSet(ES2019_MODULES)
.build();
/** Mark the point at which the normalized AST assumptions no longer hold. */
private final PassFactory markUnnormalized =
PassFactory.builder()
.setName("markUnnormalized")
.setInternalFactory(
(compiler) ->
new CompilerPass() {
@Override
public void process(Node externs, Node root) {
compiler.setLifeCycleStage(LifeCycleStage.RAW);
}
})
.setFeatureSet(FeatureSet.latest())
.build();
private final PassFactory normalize =
PassFactory.builder()
.setName(PassNames.NORMALIZE)
.setInternalFactory((compiler) -> new Normalize(compiler, false))
// TODO(johnlenz): Update this and gatherRawExports to latest()
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory externExports =
PassFactory.builder()
.setName(PassNames.EXTERN_EXPORTS)
.setInternalFactory(ExternExportsPass::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Denormalize the AST for code generation. */
private final PassFactory denormalize =
PassFactory.builder()
.setName("denormalize")
.setInternalFactory(Denormalize::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Inverting name normalization. */
private final PassFactory invertContextualRenaming =
PassFactory.builder()
.setName("invertContextualRenaming")
.setInternalFactory(
(compiler) -> {
return MakeDeclaredNamesUnique.getContextualRenameInverter(compiler);
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Renames properties. */
private final PassFactory renameProperties =
PassFactory.builder()
.setName("renameProperties")
.setInternalFactory(
(compiler) -> {
checkState(options.propertyRenaming == PropertyRenamingPolicy.ALL_UNQUOTED);
final VariableMap prevPropertyMap = options.inputPropertyMap;
return new CompilerPass() {
@Override
public void process(Node externs, Node root) {
RenameProperties rprop =
new RenameProperties(
compiler,
options.generatePseudoNames,
prevPropertyMap,
options.getPropertyReservedNamingFirstChars(),
options.getPropertyReservedNamingNonFirstChars(),
options.nameGenerator);
rprop.process(externs, root);
compiler.setPropertyMap(rprop.getPropertyMap());
}
};
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Renames variables. */
private final PassFactory renameVars =
PassFactory.builder()
.setName("renameVars")
.setInternalFactory(
(compiler) -> {
final VariableMap prevVariableMap = options.inputVariableMap;
return new CompilerPass() {
@Override
public void process(Node externs, Node root) {
compiler.setVariableMap(
runVariableRenaming(compiler, prevVariableMap, externs, root));
}
};
})
.setFeatureSet(ES2019_MODULES)
.build();
private VariableMap runVariableRenaming(
AbstractCompiler compiler, VariableMap prevVariableMap,
Node externs, Node root) {
char[] reservedChars =
options.anonymousFunctionNaming.getReservedCharacters();
boolean preserveAnonymousFunctionNames =
options.anonymousFunctionNaming != AnonymousFunctionNamingPolicy.OFF;
Set reservedNames = new HashSet<>();
if (options.renamePrefixNamespace != null) {
// don't use the prefix name as a global symbol.
reservedNames.add(options.renamePrefixNamespace);
}
reservedNames.addAll(compiler.getExportedNames());
reservedNames.addAll(ParserRunner.getReservedVars());
RenameVars rn = new RenameVars(
compiler,
options.renamePrefix,
options.variableRenaming == VariableRenamingPolicy.LOCAL,
preserveAnonymousFunctionNames,
options.generatePseudoNames,
options.shadowVariables,
options.preferStableNames,
prevVariableMap,
reservedChars,
reservedNames,
options.nameGenerator);
rn.process(externs, root);
return rn.getVariableMap();
}
/** Renames labels */
private final PassFactory renameLabels =
PassFactory.builder()
.setName("renameLabels")
.setInternalFactory(RenameLabels::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Convert bracket access to dot access */
private final PassFactory convertToDottedProperties =
PassFactory.builder()
.setName(PassNames.CONVERT_TO_DOTTED_PROPERTIES)
.setInternalFactory(ConvertToDottedProperties::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory checkAstValidity =
PassFactory.builder()
.setName("checkAstValidity")
.setInternalFactory(AstValidator::new)
.setFeatureSet(FeatureSet.latest())
.build();
/** Checks that all variables are defined. */
private final PassFactory varCheckValidity =
PassFactory.builder()
.setName("varCheckValidity")
.setInternalFactory((compiler) -> new VarCheck(compiler, true))
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory instrumentForCodeCoverage =
PassFactory.builder()
.setName("instrumentForCodeCoverage")
.setInternalFactory(
(compiler) -> {
// TODO(johnlenz): make global instrumentation an option
if (options.instrumentBranchCoverage) {
return new CoverageInstrumentationPass(
compiler, CoverageReach.CONDITIONAL, InstrumentOption.BRANCH_ONLY);
} else {
return new CoverageInstrumentationPass(compiler, CoverageReach.CONDITIONAL);
}
})
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Extern property names gathering pass. */
private final PassFactory gatherExternProperties =
PassFactory.builder()
.setName("gatherExternProperties")
.setInternalFactory(GatherExternProperties::new)
.setFeatureSet(ES2019_MODULES)
.build();
/**
* Runs custom passes that are designated to run at a particular time.
*
* TODO(nickreid): Deprecate this API
*/
private PassFactory getCustomPasses(final CustomPassExecutionTime executionTime) {
return PassFactory.builder()
.setName("runCustomPasses")
.setInternalFactory(
(compiler) -> {
return runInSerial(options.customPasses.get(executionTime));
})
.setFeatureSet(ES_NEXT)
.build();
}
/** Create a compiler pass that runs the given passes in serial. */
private static CompilerPass runInSerial(
final Collection passes) {
return new CompilerPass() {
@Override public void process(Node externs, Node root) {
for (CompilerPass pass : passes) {
pass.process(externs, root);
}
}
};
}
@VisibleForTesting
static Map getAdditionalReplacements(CompilerOptions options) {
Map additionalReplacements = new HashMap<>();
if (options.markAsCompiled || options.closurePass) {
additionalReplacements.put(COMPILED_CONSTANT_NAME, IR.trueNode());
}
if (options.closurePass && options.locale != null) {
additionalReplacements.put(CLOSURE_LOCALE_CONSTANT_NAME,
IR.string(options.locale));
}
return additionalReplacements;
}
/** Rewrites Polymer({}) */
private final PassFactory polymerPass =
PassFactory.builderForHotSwap()
.setName("polymerPass")
.setInternalFactory(
(compiler) ->
new PolymerPass(
compiler,
compiler.getOptions().polymerVersion,
compiler.getOptions().polymerExportPolicy,
compiler.getOptions().propertyRenaming
== PropertyRenamingPolicy.ALL_UNQUOTED))
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory chromePass =
PassFactory.builder()
.setName("chromePass")
.setInternalFactory(ChromePass::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrites the super accessors calls to support Dart Dev Compiler output. */
private final PassFactory dartSuperAccessorsPass =
PassFactory.builderForHotSwap()
.setName("dartSuperAccessorsPass")
.setInternalFactory(DartSuperAccessorsPass::new)
.setFeatureSet(ES_NEXT)
.build();
/** Rewrites J2CL constructs to be more optimizable. */
private final PassFactory j2clConstantHoisterPass =
PassFactory.builder()
.setName("j2clConstantHoisterPass")
.setRunInFixedPointLoop(true)
.setInternalFactory(J2clConstantHoisterPass::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Optimizes J2CL clinit methods. */
private final PassFactory j2clClinitPass =
PassFactory.builder()
.setName("j2clClinitPass")
.setRunInFixedPointLoop(true)
.setInternalFactory(
(compiler) -> {
List changedScopeNodes =
compiler.getChangedScopeNodesForPass("j2clClinitPass");
return new J2clClinitPrunerPass(compiler, changedScopeNodes);
})
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrites J2CL constructs to be more optimizable. */
private final PassFactory j2clPropertyInlinerPass =
PassFactory.builder()
.setName("j2clES6Pass")
.setInternalFactory(J2clPropertyInlinerPass::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrites J2CL constructs to be more optimizable. */
private final PassFactory j2clPass =
PassFactory.builder()
.setName("j2clPass")
.setInternalFactory(J2clPass::new)
.setFeatureSet(ES_NEXT)
.build();
/** Rewrites J2CL constructs to be more optimizable. */
private final PassFactory j2clUtilGetDefineRewriterPass =
PassFactory.builder()
.setName("j2clUtilGetDefineRewriterPass")
.setInternalFactory(J2clUtilGetDefineRewriterPass::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory j2clAssertRemovalPass =
PassFactory.builder()
.setName("j2clAssertRemovalPass")
.setInternalFactory(J2clAssertRemovalPass::new)
.setFeatureSet(ES2019_MODULES)
.build();
private final PassFactory j2clSourceFileChecker =
PassFactory.builder()
.setName("j2clSourceFileChecker")
.setInternalFactory(J2clSourceFileChecker::new)
.setFeatureSet(FeatureSet.latest())
.build();
private final PassFactory j2clChecksPass =
PassFactory.builder()
.setName("j2clChecksPass")
.setInternalFactory(J2clChecksPass::new)
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory checkConformance =
PassFactory.builder()
.setName(PassNames.CHECK_CONFORMANCE)
.setInternalFactory(
(compiler) ->
new CheckConformance(
compiler, ImmutableList.copyOf(options.getConformanceConfigs())))
.setFeatureSet(TYPE_CHECK_SUPPORTED)
.build();
/** Optimizations that output ES6 features. */
private final PassFactory optimizeToEs6 =
PassFactory.builder()
.setName("optimizeToEs6")
.setInternalFactory(SubstituteEs6Syntax::new)
.setFeatureSet(ES2019_MODULES)
.build();
/** Rewrites goog.module in whitespace only mode */
private final PassFactory whitespaceWrapGoogModules =
PassFactory.builderForHotSwap()
.setName("whitespaceWrapGoogModules")
.setInternalFactory(WhitespaceWrapGoogModules::new)
.setFeatureSet(FeatureSet.latest())
.build();
private final PassFactory rewriteCommonJsModules =
PassFactory.builder()
.setName(PassNames.REWRITE_COMMON_JS_MODULES)
.setInternalFactory(ProcessCommonJSModules::new)
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory rewriteScriptsToEs6Modules =
PassFactory.builder()
.setName(PassNames.REWRITE_SCRIPTS_TO_ES6_MODULES)
.setInternalFactory(Es6RewriteScriptsToModules::new)
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory gatherModuleMetadataPass =
PassFactory.builderForHotSwap()
.setName(PassNames.GATHER_MODULE_METADATA)
.setInternalFactory(
(compiler) -> {
// Force creation of the synthetic input so that we create metadata for it
compiler.getSynthesizedExternsInput();
return new GatherModuleMetadata(
compiler, options.processCommonJSModules, options.moduleResolutionMode);
})
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory createModuleMapPass =
PassFactory.builderForHotSwap()
.setName(PassNames.CREATE_MODULE_MAP)
.setInternalFactory(
(compiler) -> new ModuleMapCreator(compiler, compiler.getModuleMetadataMap()))
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory gatherGettersAndSetters =
PassFactory.builder()
.setName(PassNames.GATHER_GETTERS_AND_SETTERS)
.setInternalFactory(GatherGetterAndSetterProperties::new)
.setFeatureSet(ES_NEXT)
.build();
private final PassFactory addSyntheticScript =
PassFactory.builder()
.setName("ADD_SYNTHETIC_SCRIPT")
.setFeatureSet(TYPESCRIPT)
.setInternalFactory(
(compiler) -> (externs, js) -> compiler.initializeSyntheticCodeInput())
.build();
private final PassFactory removeSyntheticScript =
PassFactory.builder()
.setName("REMOVE_SYNTHETIC_SCRIPT")
.setFeatureSet(TYPESCRIPT)
.setInternalFactory((compiler) -> (externs, js) -> compiler.removeSyntheticCodeInput())
.build();
}