Compiler

java.lang.Object
- com.google.javascript.jscomp.AbstractCompiler
- - com.google.javascript.jscomp.Compiler

All Implemented Interfaces:

SourceExcerptProvider
```
public class Compiler
extends AbstractCompiler
```
Compiler (and the other classes in this package) does the following:
- parses JS code
- checks for undefined variables
- performs optimizations such as constant folding and constants inlining
- renames variables (to short names)
- outputs compact JavaScript code
External variables are declared in 'externs' files. For instance, the file may include definitions for global javascript/browser objects such as window, document.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Compiler.CodeBuilder` Stores a buffer of text to which more can be appended.
`private static class`	`Compiler.SyntheticExternsPosition`

Nested classes/interfaces inherited from class com.google.javascript.jscomp.AbstractCompiler
AbstractCompiler.ConfigContext, AbstractCompiler.LifeCycleStage

Nested classes/interfaces inherited from interface com.google.javascript.jscomp.SourceExcerptProvider
SourceExcerptProvider.ExcerptFormatter, SourceExcerptProvider.SourceExcerpt

Field Summary

Fields
Modifier and Type	Field and Description
`private ReverseAbstractInterpreter`	`abstractInterpreter`
`private java.util.List<CodeChangeHandler>`	`codeChangeHandlers`
`private java.util.Map<java.lang.String,java.util.List<Comment>>`	`commentsPerFile`
`private CompilerExecutor`	`compilerExecutor`
`private static java.lang.String`	`CONFIG_RESOURCE`
`(package private) static java.lang.String`	`CROSS_MODULE_CODE_MOTION_NAME`
`(package private) static java.lang.String`	`CROSS_MODULE_METHOD_MOTION_NAME`
`private java.lang.String`	`currentPassName`
`private Tracer`	`currentTracer`
`private java.lang.StringBuilder`	`debugLog` Debugging information
`(package private) CodingConvention`	`defaultCodingConvention` Detects Google-specific coding conventions.
`private com.google.common.collect.ImmutableMap<java.lang.String,Node>`	`defaultDefineValues`
`private ErrorReporter`	`defaultErrorReporter`
`private SimpleDefinitionFinder`	`defFinder`
`(package private) static DiagnosticType`	`DUPLICATE_EXTERN_INPUT`
`(package private) static DiagnosticType`	`DUPLICATE_INPUT`
`private static DiagnosticType`	`EMPTY_MODULE_LIST_ERROR`
`private static DiagnosticType`	`EMPTY_ROOT_MODULE_ERROR`
`private ErrorManager`	`errorManager`
`(package private) Node`	`externAndJsRoot`
`private java.lang.String`	`externExports` The externs created from the exports.
`private java.util.Set<java.lang.String>`	`externProperties`
`private java.util.List<CompilerInput>`	`externs`
`private Config`	`externsParserConfig`
`(package private) Node`	`externsRoot`
`private FunctionInformationMap`	`functionInformationMap` The function information map
`private GlobalVarReferenceMap`	`globalRefMap`
`private boolean`	`hasRegExpGlobalReferences` Whether to assume there are references to the RegExp Global object properties.
`private java.util.Map<java.lang.String,Node>`	`injectedLibraries`
`private java.util.List<CompilerInput>`	`inputs`
`private java.util.Map<InputId,CompilerInput>`	`inputsById`
`(package private) Node`	`jsRoot`
`private CompilerOptions.LanguageMode`	`languageMode`
`private java.lang.String`	`lastJsSource`
`private java.lang.String`	`lastPassName`
`private static java.util.logging.Logger`	`logger` Logger for the whole com.google.javascript.jscomp domain - setting configuration for this logger affects all loggers in other classes within the compiler.
`(package private) static DiagnosticType`	`MISSING_ENTRY_ERROR`
`(package private) static DiagnosticType`	`MISSING_MODULE_ERROR`
`(package private) static DiagnosticType`	`MODULE_DEPENDENCY_ERROR`
`private JSModuleGraph`	`moduleGraph`
`private java.util.List<JSModule>`	`modules`
`static DiagnosticType`	`MOTION_ITERATIONS_ERROR`
`private ErrorReporter`	`oldErrorReporter`
`static DiagnosticType`	`OPTIMIZE_LOOP_ERROR` Error strings used for reporting JSErrors
`(package private) CompilerOptions`	`options`
`private com.google.common.base.Function<java.lang.String,SourceFile>`	`originalSourcesLoader`
`private java.io.PrintStream`	`outStream`
`private Config`	`parserConfig`
`(package private) static java.lang.String`	`PARSING_PASS_NAME`
`private PassConfig`	`passes`
`private static com.google.common.base.Joiner`	`pathJoiner`
`private PhaseOptimizer`	`phaseOptimizer`
`private double`	`progress`
`protected RecentChange`	`recentChange`
`private PassFactory`	`sanityCheck`
`(package private) static java.lang.String`	`SINGLETON_MODULE_NAME`
`private SourceMap`	`sourceMap` The source code map
`private java.util.concurrent.ConcurrentHashMap<java.lang.String,SourceFile>`	`sourceMapOriginalSources`
`private GlobalTypeInfo`	`symbolTable`
`private CompilerInput`	`synthesizedExternsInput`
`private CompilerInput`	`synthesizedExternsInputAtEnd`
`(package private) static java.lang.String`	`SYNTHETIC_EXTERNS` Name of the synthetic input that holds synthesized externs.
`(package private) static java.lang.String`	`SYNTHETIC_EXTERNS_AT_END` Name of the synthetic input that holds synthesized externs which must be at the end of the externs AST.
`private int`	`syntheticCodeId`
`PerformanceTracker`	`tracker`
`private JSTypeRegistry`	`typeRegistry`
`private TypeValidator`	`typeValidator`
`private int`	`uniqueNameId` Ids for function inlining so that each declared name remains unique.
`private WarningsGuard`	`warningsGuard`

Fields inherited from class com.google.javascript.jscomp.AbstractCompiler
needsEs6DartRuntime, needsEs6Runtime, READ_ERROR

Constructor Summary

Constructors
Constructor and Description
`Compiler()` Creates a Compiler that reports errors and warnings to its logger.
`Compiler(ErrorManager errorManager)` Creates a Compiler that uses a custom error manager.
`Compiler(java.io.PrintStream stream)` Creates a Compiler that reports errors and warnings to an output stream.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`addChangeHandler(CodeChangeHandler handler)` Register a listener for code change events.
`(package private) void`	`addComments(java.lang.String filename, java.util.List<Comment> comments)`
`void`	`addNewScript(JsAst ast)` Adds a new Script AST to the compile state.
`(package private) boolean`	`addNewSourceAst(JsAst ast)` Add a new source input dynamically.
`(package private) void`	`addToDebugLog(java.lang.String str)` Called from the compiler passes, adds debug info
`(package private) void`	`afterPass(java.lang.String passName)` Will be called after each pass finishes.
`(package private) boolean`	`areNodesEqualForInlining(Node n1, Node n2)` Are the nodes equal for the purpose of inlining? If type aware optimizations are on, type equality is checked.
`(package private) void`	`beforePass(java.lang.String passName)` Will be called before each pass runs.
`SymbolTable`	`buildKnownSymbolTable()`
`void`	`check()`
`private void`	`checkFirstModule(java.util.List<JSModule> modules)` Verifies that at least one module has been provided and that the first one has at least one source code input.
`private Result`	`compile()`
`<T1 extends SourceFile,T2 extends SourceFile> Result`	`compile(java.util.List<T1> externs, java.util.List<T2> inputs, CompilerOptions options)` Compiles a list of inputs.
`Result`	`compile(SourceFile extern, SourceFile input, CompilerOptions options)`
`private void`	`compileInternal()`
`<T extends SourceFile> Result`	`compileModules(java.util.List<T> externs, java.util.List<JSModule> modules, CompilerOptions options)` Compiles a list of modules.
`(package private) ControlFlowGraph<Node>`	`computeCFG()` Control Flow Analysis.
`protected Config`	`createConfig(Config.LanguageMode mode)`
`(package private) static java.lang.String`	`createFillFileName(java.lang.String moduleName)` Empty modules get an empty "fill" file, so that we can move code into an empty module.
`private MessageFormatter`	`createMessageFormatter()` Creates a message formatter instance corresponding to the value of `CompilerOptions`.
`(package private) PassConfig`	`createPassConfigInternal()` Create the passes object.
`void`	`disableThreads()` Disable threads.
`(package private) void`	`endPass()` Marks the end of a pass.
`(package private) DefaultPassConfig`	`ensureDefaultPassConfig()`
`(package private) Node`	`ensureLibraryInjected(java.lang.String resourceName, boolean normalizeAndUniquifyNames)` The subdir js/ contains libraries of code that we inject at compile-time only if requested by this function.
`private void`	`externExports()`
`private static void`	`fillEmptyModules(java.util.List<JSModule> modules)` Fill any empty modules with a place holder file.
`(package private) void`	`forwardDeclareType(java.lang.String typeName)`
`private static java.util.List<CompilerInput>`	`getAllInputsFromModules(java.util.List<JSModule> modules)` Builds a single list of all module inputs.
`java.lang.String`	`getAstDotGraph()` Gets the DOT graph of the AST generated at the end of compilation.
`private PassConfig`	`getCleanupPassConfig()`
`CodingConvention`	`getCodingConvention()` Gets the current coding convention.
`java.util.List<Comment>`	`getComments(java.lang.String filename)` Returns all the comments from the given file.
`(package private) CssRenamingMap`	`getCssRenamingMap()` Gets the CssRenamingMap.
`(package private) com.google.common.collect.ImmutableMap<java.lang.String,Node>`	`getDefaultDefineValues()` Gets a map of default @define values.
`(package private) ErrorReporter`	`getDefaultErrorReporter()` Gets a default error reporter for injecting into Rhino.
`(package private) JSModuleGraph`	`getDegenerateModuleGraph()` Gets a module graph.
`protected DiagnosticGroups`	`getDiagnosticGroups()` The warning classes that are available from the command-line, and are suppressible by the `@suppress` annotation.
`int`	`getErrorCount()` Gets the number of errors.
`CheckLevel`	`getErrorLevel(JSError error)`
`ErrorManager`	`getErrorManager()` Gets the error manager.
`JSError[]`	`getErrors()` Returns the array of errors (never null).
`(package private) java.util.Set<java.lang.String>`	`getExternProperties()` Gets the names of the properties defined in externs or null if GatherExternProperties pass was not run yet.
`(package private) java.util.List<CompilerInput>`	`getExternsForTesting()`
`(package private) java.util.List<CompilerInput>`	`getExternsInOrder()` Gets the externs in the order in which they are being processed.
`(package private) FunctionInformationMap`	`getFunctionalInformationMap()`
`(package private) GlobalVarReferenceMap`	`getGlobalVarReferences()` This can be used to get the list of all references to all global variables based on all previous calls to `updateGlobalVarReferences`.
`(package private) java.lang.Iterable<TypeValidator.TypeMismatch>`	`getImplicitInterfaceUses()` Gets all types that are used implicitly as a matching structural interface type.
`CompilerInput`	`getInput(InputId id)` Looks up an input (possibly an externs input) by input id.
`java.util.Map<InputId,CompilerInput>`	`getInputsById()` Returns an unmodifiable view of the compiler inputs indexed by id.
`(package private) java.util.List<CompilerInput>`	`getInputsForTesting()`
`(package private) java.util.List<CompilerInput>`	`getInputsInOrder()` Gets the inputs in the order in which they are being processed.
`(package private) Node`	`getJsRoot()` Returns the root of the source tree, ignoring externs
`(package private) CompilerOptions.LanguageMode`	`getLanguageMode()` The language mode of the current root node.
`(package private) java.lang.String`	`getLastPassName()` Gets the last pass name set by setProgress.
`(package private) JSModuleGraph`	`getModuleGraph()` Gets the module graph.
`(package private) Node`	`getNodeForCodeInsertion(JSModule module)` Gets a suitable SCRIPT node to serve as a parent for code insertion.
`(package private) CompilerOptions`	`getOptions()`
`(package private) Config`	`getParserConfig(AbstractCompiler.ConfigContext context)` Returns the parser configuration for the specified context.
`(package private) PassConfig`	`getPassConfig()`
`double`	`getProgress()`
`(package private) VariableMap`	`getPropertyMap()`
`private static java.lang.String`	`getRelativeTo(java.lang.String relative, java.lang.String base)` Returns the relative path, resolved relative to the base path, where the base path is interpreted as a filename rather than a directory.
`static java.lang.String`	`getReleaseDate()` Returns the compiler date baked into the jar.
`static java.lang.String`	`getReleaseVersion()` Returns the compiler version baked into the jar.
`Result`	`getResult()` Returns the result of the compilation.
`ReverseAbstractInterpreter`	`getReverseAbstractInterpreter()` Get an interpreter for type analysis.
`Node`	`getRoot()` Returns the root node of the AST, which includes both externs and source.
`(package private) SimpleDefinitionFinder`	`getSimpleDefinitionFinder()` Used by three passes that run in sequence (optimize-returns, optimize-parameters, remove-unused-variables), to avoid having them recompute it independently.
`(package private) SourceFile`	`getSourceFileByName(java.lang.String sourceName)` Looks up a source file by name.
`java.lang.String`	`getSourceLine(java.lang.String sourceName, int lineNumber)` Get the line indicated by the line number.
`SourceMap`	`getSourceMap()`
`Mapping.OriginalMapping`	`getSourceMapping(java.lang.String sourceName, int lineNumber, int columnNumber)` If the source file is associated with an inputSourceMap, does a lookup for the original file position based on this source map.
`Region`	`getSourceRegion(java.lang.String sourceName, int lineNumber)` Get a region around the indicated line number.
`(package private) GlobalTypeInfo`	`getSymbolTable()` Used only by the new type inference
`(package private) CompilerInput`	`getSynthesizedExternsInput()`
`(package private) CompilerInput`	`getSynthesizedExternsInputAtEnd()`
`TypedScope`	`getTopScope()` Gets the top scope.
`MemoizedScopeCreator`	`getTypedScopeCreator()` Gets a memoized scope creator with type information.
`TypeIRegistry`	`getTypeIRegistry()`
`(package private) java.lang.Iterable<TypeValidator.TypeMismatch>`	`getTypeMismatches()` Gets the central registry of type violations.
`JSTypeRegistry`	`getTypeRegistry()` Gets a central registry of type information from the compiled JS.
`(package private) TypeValidator`	`getTypeValidator()` Only used by passes in the old type checker.
`(package private) com.google.common.base.Supplier<java.lang.String>`	`getUniqueNameIdSupplier()` Generates unique ids.
`(package private) VariableMap`	`getVariableMap()`
`int`	`getWarningCount()` Gets the number of warnings.
`JSError[]`	`getWarnings()` Returns the array of warnings (never null).
`boolean`	`hasErrors()` Consults the `ErrorManager` to see if we've encountered errors that should halt compilation.
`(package private) boolean`	`hasHaltingErrors()`
`(package private) boolean`	`hasRegExpGlobalReferences()`
`(package private) boolean`	`hasScopeChanged(Node n)` True iff a function changed since the last time a pass was run
`(package private) void`	`hoistExterns()` Hoists inputs with the @externs annotation into the externs list.
`(package private) void`	`hoistNoCompileFiles()` Hoists inputs with the @nocompile annotation out of the inputs.
`<T1 extends SourceFile,T2 extends SourceFile> void`	`init(java.util.List<T1> externs, java.util.List<T2> inputs, CompilerOptions options)` Initializes the instance state needed for a compile job.
`private void`	`initAST()` Sets up the skeleton of the AST (the externs and root).
`private void`	`initBasedOnOptions()` Do any initialization that is dependent on the compiler options.
`(package private) void`	`initCompilerOptionsIfTesting()`
`(package private) void`	`initInputsByIdMap()` Creates a map to make looking up an input by name fast.
`<T extends SourceFile> void`	`initModules(java.util.List<T> externs, java.util.List<JSModule> modules, CompilerOptions options)` Initializes the instance state needed for a compile job if the sources are in modules.
`void`	`initOptions(CompilerOptions options)` Initializes the compiler options.
`(package private) void`	`initWarningsGuard(WarningsGuard warningsGuard)`
`boolean`	`isIdeMode()` Returns true if compiling in IDE mode.
`static java.lang.String`	`joinPathParts(java.lang.String... pathParts)` Creates an OS specific path string from parts
`(package private) Node`	`loadLibraryCode(java.lang.String resourceName, boolean normalizeAndUniquifyNames)` Load a library as a resource
`private <T extends SourceFile> java.util.List<CompilerInput>`	`makeCompilerInput(java.util.List<T> files, boolean isExtern)`
`private void`	`maybeSanityCheck()`
`protected CompilerOptions`	`newCompilerOptions()` Allow subclasses to override the default CompileOptions object.
`(package private) CompilerInput`	`newExternInput(java.lang.String name, Compiler.SyntheticExternsPosition pos)`
`(package private) Tracer`	`newTracer(java.lang.String passName)` Returns a new tracer for the given pass name.
`private int`	`nextUniqueNameId()` Creates a new id for making unique names.
`void`	`normalize()`
`void`	`optimize()`
`(package private) void`	`orderInputs()`
`void`	`parse()`
`Node`	`parse(SourceFile file)`
`(package private) Node`	`parseInputs()` Parses the externs and main inputs.
`(package private) Node`	`parseSyntheticCode(java.lang.String js)` Parses code for injecting.
`(package private) Node`	`parseSyntheticCode(java.lang.String fileName, java.lang.String js)` Parses code for injecting, and associate it with a given source file.
`(package private) Node`	`parseTestCode(java.lang.String js)` Parses code for testing.
`(package private) boolean`	`precheck()` Carry out any special checks or procedures that need to be done before proceeding with rest of the compilation process.
`(package private) void`	`prepareAst(Node root)` Normalizes the types of AST nodes in the given tree, and annotates any nodes to which the coding convention applies so that passes can read the annotations instead of using the coding convention.
`(package private) void`	`process(CompilerPass p)` Runs a given compiler-pass by calling its `process()` method.
`(package private) void`	`processAMDAndCommonJSModules()` Transforms AMD and CJS modules to something closure compiler can process and creates JSModules and the corresponding dependency tree on the way.
`(package private) void`	`processEs6Modules()`
`private void`	`processNewScript(JsAst ast, Node originalRoot)`
`(package private) CompilerInput`	`putCompilerInput(InputId id, CompilerInput input)`
`void`	`rebuildInputsFromModules()` Rebuilds the internal list of inputs by iterating over all modules.
`protected void`	`reconcileOptionsWithGuards()` When the CompilerOptions and its WarningsGuard overlap, reconcile any discrepencies.
`(package private) void`	`recordFunctionInformation()`
`(package private) void`	`removeChangeHandler(CodeChangeHandler handler)` Remove a listener for code change events.
`protected void`	`removeExternInput(InputId id)` Removes an input file from AST.
`private void`	`removeSyntheticVarsInput()`
`private void`	`repartitionInputs()`
`(package private) boolean`	`replaceIncrementalSourceAst(JsAst ast)` Replace a source input dynamically.
`void`	`replaceScript(JsAst ast)` Replaces one file in a hot-swap mode.
`void`	`report(JSError error)` Report an error or warning.
`(package private) void`	`reportChangeToEnclosingScope(Node n)` Passes that do cross-scope modifications use this (eg, InlineVariables)
`void`	`reportCodeChange()` Report code changes.
`(package private) void`	`resetUniqueNameId()` Resets the unique name id counter
`private void`	`runCustomPasses(CustomPassExecutionTime executionTime)` Runs custom passes that are designated to run at a particular time.
`private void`	`runHotSwap(Node originalRoot, Node js, PassConfig passConfig)` Execute the passes from a PassConfig instance over a single replaced file.
`private void`	`runHotSwapPass(Node originalRoot, Node js, PassFactory passFactory)`
`(package private) <T> T`	`runInCompilerThread(java.util.concurrent.Callable<T> callable)`
`private void`	`runSanityCheck()`
`(package private) void`	`setCssRenamingMap(CssRenamingMap map)` Sets the CssRenamingMap.
`(package private) void`	`setDefaultDefineValues(com.google.common.collect.ImmutableMap<java.lang.String,Node> values)` Stores a map of default @define values.
`void`	`setErrorManager(ErrorManager errorManager)` Sets the error manager.
`(package private) void`	`setExternProperties(java.util.Set<java.lang.String> externProperties)` Sets the names of the properties defined in externs.
`(package private) void`	`setHasRegExpGlobalReferences(boolean references)` Set if RegExp global properties are used.
`(package private) void`	`setLanguageMode(CompilerOptions.LanguageMode mode)`
`static void`	`setLoggingLevel(java.util.logging.Level level)` Sets the logging level for the com.google.javascript.jscomp package.
`(package private) void`	`setOriginalSourcesLoader(com.google.common.base.Function<java.lang.String,SourceFile> originalSourcesLoader)`
`void`	`setPassConfig(PassConfig passes)`
`(package private) void`	`setPhaseOptimizer(PhaseOptimizer po)` Some tests don't want to call the compiler "wholesale," they may not want to call check and/or optimize.
`(package private) void`	`setProgress(double newProgress, java.lang.String passName)` Sets the progress percentage as well as the name of the last pass that ran (if available).
`(package private) void`	`setScope(Node n)` Let the PhaseOptimizer know which scope a pass is currently analyzing
`(package private) void`	`setSimpleDefinitionFinder(SimpleDefinitionFinder defFinder)`
`(package private) void`	`setSymbolTable(GlobalTypeInfo symbolTable)`
`void`	`setTimeout(int timeout)` Sets the timeout when Compiler is run in a thread
`(package private) void`	`startPass(java.lang.String passName)` Marks the beginning of a pass.
`(package private) void`	`stopTracer(Tracer t, java.lang.String passName)`
`(package private) void`	`stripCode(java.util.Set<java.lang.String> stripTypes, java.util.Set<java.lang.String> stripNameSuffixes, java.util.Set<java.lang.String> stripTypePrefixes, java.util.Set<java.lang.String> stripNamePrefixes)` Strips code for smaller compiled code.
`(package private) void`	`throwInternalError(java.lang.String message, java.lang.Exception cause)` Report an internal error.
`java.lang.String`	`toSource()` Converts the main parse tree back to JS code.
`void`	`toSource(Compiler.CodeBuilder cb, int inputSeqNum, Node root)` Writes out JS code from a root node.
`java.lang.String`	`toSource(JSModule module)` Converts the parse tree for a module back to JS code.
`java.lang.String`	`toSource(Node n)` Generates JavaScript source code for an AST, doesn't generate source map info.
`private java.lang.String`	`toSource(Node n, SourceMap sourceMap, boolean firstOutput)` Generates JavaScript source code for an AST.
`java.lang.String[]`	`toSourceArray()` Converts the parse tree for each input back to JS code.
`java.lang.String[]`	`toSourceArray(JSModule module)` Converts the parse tree for each input in a module back to JS code.
`(package private) void`	`updateGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> refMapPatch, Node collectionRoot)` Updates the list of references for variables in global scope.

Methods inherited from class com.google.javascript.jscomp.AbstractCompiler
getLifeCycleStage, setLifeCycleStage

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SINGLETON_MODULE_NAME
```
static final java.lang.String SINGLETON_MODULE_NAME
```
    See Also:
    
    Constant Field Values
  - MODULE_DEPENDENCY_ERROR
```
static final DiagnosticType MODULE_DEPENDENCY_ERROR
```
  - MISSING_ENTRY_ERROR
```
static final DiagnosticType MISSING_ENTRY_ERROR
```
  - MISSING_MODULE_ERROR
```
static final DiagnosticType MISSING_MODULE_ERROR
```
  - PARSING_PASS_NAME
```
static final java.lang.String PARSING_PASS_NAME
```
    See Also:
    
    Constant Field Values
  - CROSS_MODULE_CODE_MOTION_NAME
```
static final java.lang.String CROSS_MODULE_CODE_MOTION_NAME
```
    See Also:
    
    Constant Field Values
  - CROSS_MODULE_METHOD_MOTION_NAME
```
static final java.lang.String CROSS_MODULE_METHOD_MOTION_NAME
```
    See Also:
    
    Constant Field Values
  - CONFIG_RESOURCE
```
private static final java.lang.String CONFIG_RESOURCE
```
    See Also:
    
    Constant Field Values
  - options
```
CompilerOptions options
```
  - passes
```
private PassConfig passes
```
  - externs
```
private java.util.List<CompilerInput> externs
```
  - modules
```
private java.util.List<JSModule> modules
```
  - moduleGraph
```
private JSModuleGraph moduleGraph
```
  - inputs
```
private java.util.List<CompilerInput> inputs
```
  - errorManager
```
private ErrorManager errorManager
```
  - warningsGuard
```
private WarningsGuard warningsGuard
```
  - injectedLibraries
```
private final java.util.Map<java.lang.String,Node> injectedLibraries
```
  - externsRoot
```
Node externsRoot
```
  - jsRoot
```
Node jsRoot
```
  - externAndJsRoot
```
Node externAndJsRoot
```
  - lastJsSource
```
private java.lang.String lastJsSource
```
  - languageMode
```
private CompilerOptions.LanguageMode languageMode
```
    See Also:
    
    getLanguageMode()
  - inputsById
```
private java.util.Map<InputId,CompilerInput> inputsById
```
  - originalSourcesLoader
```
private com.google.common.base.Function<java.lang.String,SourceFile> originalSourcesLoader
```
  - sourceMapOriginalSources
```
private java.util.concurrent.ConcurrentHashMap<java.lang.String,SourceFile> sourceMapOriginalSources
```
  - commentsPerFile
```
private java.util.Map<java.lang.String,java.util.List<Comment>> commentsPerFile
```
  - sourceMap
```
private SourceMap sourceMap
```
    The source code map
  - externExports
```
private java.lang.String externExports
```
    The externs created from the exports.
  - uniqueNameId
```
private int uniqueNameId
```
    Ids for function inlining so that each declared name remains unique.
  - hasRegExpGlobalReferences
```
private boolean hasRegExpGlobalReferences
```
    Whether to assume there are references to the RegExp Global object properties.
  - functionInformationMap
```
private FunctionInformationMap functionInformationMap
```
    The function information map
  - debugLog
```
private final java.lang.StringBuilder debugLog
```
    Debugging information
  - defaultCodingConvention
```
CodingConvention defaultCodingConvention
```
    Detects Google-specific coding conventions.
  - typeRegistry
```
private JSTypeRegistry typeRegistry
```
  - parserConfig
```
private Config parserConfig
```
  - externsParserConfig
```
private Config externsParserConfig
```
  - abstractInterpreter
```
private ReverseAbstractInterpreter abstractInterpreter
```
  - typeValidator
```
private TypeValidator typeValidator
```
  - phaseOptimizer
```
private PhaseOptimizer phaseOptimizer
```
  - tracker
```
public PerformanceTracker tracker
```
  - defFinder
```
private SimpleDefinitionFinder defFinder
```
  - symbolTable
```
private GlobalTypeInfo symbolTable
```
  - oldErrorReporter
```
private final ErrorReporter oldErrorReporter
```
  - defaultErrorReporter
```
private final ErrorReporter defaultErrorReporter
```
  - OPTIMIZE_LOOP_ERROR
```
public static final DiagnosticType OPTIMIZE_LOOP_ERROR
```
    Error strings used for reporting JSErrors
  - MOTION_ITERATIONS_ERROR
```
public static final DiagnosticType MOTION_ITERATIONS_ERROR
```
  - compilerExecutor
```
private final CompilerExecutor compilerExecutor
```
  - logger
```
private static final java.util.logging.Logger logger
```
    Logger for the whole com.google.javascript.jscomp domain - setting configuration for this logger affects all loggers in other classes within the compiler.
  - outStream
```
private final java.io.PrintStream outStream
```
  - globalRefMap
```
private GlobalVarReferenceMap globalRefMap
```
  - progress
```
private volatile double progress
```
  - lastPassName
```
private java.lang.String lastPassName
```
  - externProperties
```
private java.util.Set<java.lang.String> externProperties
```
  - pathJoiner
```
private static final com.google.common.base.Joiner pathJoiner
```
  - EMPTY_MODULE_LIST_ERROR
```
private static final DiagnosticType EMPTY_MODULE_LIST_ERROR
```
  - EMPTY_ROOT_MODULE_ERROR
```
private static final DiagnosticType EMPTY_ROOT_MODULE_ERROR
```
  - DUPLICATE_INPUT
```
static final DiagnosticType DUPLICATE_INPUT
```
  - DUPLICATE_EXTERN_INPUT
```
static final DiagnosticType DUPLICATE_EXTERN_INPUT
```
  - sanityCheck
```
private final PassFactory sanityCheck
```
  - currentTracer
```
private Tracer currentTracer
```
  - currentPassName
```
private java.lang.String currentPassName
```
  - syntheticCodeId
```
private int syntheticCodeId
```
  - recentChange
```
protected final RecentChange recentChange
```
  - codeChangeHandlers
```
private final java.util.List<CodeChangeHandler> codeChangeHandlers
```
  - SYNTHETIC_EXTERNS
```
static final java.lang.String SYNTHETIC_EXTERNS
```
    Name of the synthetic input that holds synthesized externs.
    
    See Also:
    
    Constant Field Values
  - SYNTHETIC_EXTERNS_AT_END
```
static final java.lang.String SYNTHETIC_EXTERNS_AT_END
```
    Name of the synthetic input that holds synthesized externs which must be at the end of the externs AST.
    
    See Also:
    
    Constant Field Values
  - synthesizedExternsInput
```
private CompilerInput synthesizedExternsInput
```
  - synthesizedExternsInputAtEnd
```
private CompilerInput synthesizedExternsInputAtEnd
```
  - defaultDefineValues
```
private com.google.common.collect.ImmutableMap<java.lang.String,Node> defaultDefineValues
```
- Constructor Detail
  - Compiler
```
public Compiler()
```
    Creates a Compiler that reports errors and warnings to its logger.
  - Compiler
```
public Compiler(java.io.PrintStream stream)
```
    Creates a Compiler that reports errors and warnings to an output stream.
  - Compiler
```
public Compiler(ErrorManager errorManager)
```
    Creates a Compiler that uses a custom error manager.
- Method Detail
  - setErrorManager
```
public void setErrorManager(ErrorManager errorManager)
```
    Sets the error manager.
    
    Parameters:
    
    errorManager - the error manager, it cannot be null
  - createMessageFormatter
```
private MessageFormatter createMessageFormatter()
```
    Creates a message formatter instance corresponding to the value of CompilerOptions.
  - setOriginalSourcesLoader
```
void setOriginalSourcesLoader(com.google.common.base.Function<java.lang.String,SourceFile> originalSourcesLoader)
```
  - initOptions
```
public void initOptions(CompilerOptions options)
```
    Initializes the compiler options. It's called as part of a normal compile() job. Public for the callers that are not doing a normal compile() job.
  - initWarningsGuard
```
void initWarningsGuard(WarningsGuard warningsGuard)
```
  - reconcileOptionsWithGuards
```
protected void reconcileOptionsWithGuards()
```
    When the CompilerOptions and its WarningsGuard overlap, reconcile any discrepencies.
  - init
```
public <T1 extends SourceFile,T2 extends SourceFile> void init(java.util.List<T1> externs,
                                                               java.util.List<T2> inputs,
                                                               CompilerOptions options)
```
    Initializes the instance state needed for a compile job.
  - initModules
```
public <T extends SourceFile> void initModules(java.util.List<T> externs,
                                               java.util.List<JSModule> modules,
                                               CompilerOptions options)
```
    Initializes the instance state needed for a compile job if the sources are in modules.
  - initBasedOnOptions
```
private void initBasedOnOptions()
```
    Do any initialization that is dependent on the compiler options.
  - makeCompilerInput
```
private <T extends SourceFile> java.util.List<CompilerInput> makeCompilerInput(java.util.List<T> files,
                                                                               boolean isExtern)
```
  - checkFirstModule
```
private void checkFirstModule(java.util.List<JSModule> modules)
```
    Verifies that at least one module has been provided and that the first one has at least one source code input.
  - createFillFileName
```
static java.lang.String createFillFileName(java.lang.String moduleName)
```
    Empty modules get an empty "fill" file, so that we can move code into an empty module.
  - joinPathParts
```
public static java.lang.String joinPathParts(java.lang.String... pathParts)
```
    Creates an OS specific path string from parts
  - fillEmptyModules
```
private static void fillEmptyModules(java.util.List<JSModule> modules)
```
    Fill any empty modules with a place holder file. It makes any cross module motion easier.
  - rebuildInputsFromModules
```
public void rebuildInputsFromModules()
```
    Rebuilds the internal list of inputs by iterating over all modules. This is necessary if inputs have been added to or removed from a module after the init(List, List, CompilerOptions) call.
  - getAllInputsFromModules
```
private static java.util.List<CompilerInput> getAllInputsFromModules(java.util.List<JSModule> modules)
```
    Builds a single list of all module inputs. Verifies that it contains no duplicates.
  - getRelativeTo
```
private static java.lang.String getRelativeTo(java.lang.String relative,
                                              java.lang.String base)
```
    Returns the relative path, resolved relative to the base path, where the base path is interpreted as a filename rather than a directory. E.g.: getRelativeTo("../foo/bar.js", "baz/bam/qux.js") --> "baz/foo/bar.js"
  - initInputsByIdMap
```
void initInputsByIdMap()
```
    Creates a map to make looking up an input by name fast. Also checks for duplicate inputs.
  - initAST
```
private void initAST()
```
    Sets up the skeleton of the AST (the externs and root).
  - compile
```
public Result compile(SourceFile extern,
                      SourceFile input,
                      CompilerOptions options)
```
  - compile
```
public <T1 extends SourceFile,T2 extends SourceFile> Result compile(java.util.List<T1> externs,
                                                                    java.util.List<T2> inputs,
                                                                    CompilerOptions options)
```
    Compiles a list of inputs.
  - compileModules
```
public <T extends SourceFile> Result compileModules(java.util.List<T> externs,
                                                    java.util.List<JSModule> modules,
                                                    CompilerOptions options)
```
    Compiles a list of modules.
  - compile
```
private Result compile()
```
  - disableThreads
```
public void disableThreads()
```
    Disable threads. This is for clients that run on AppEngine and don't have threads.
  - setTimeout
```
public void setTimeout(int timeout)
```
    Sets the timeout when Compiler is run in a thread
    
    Parameters:
    
    timeout - seconds to wait before timeout
  - runInCompilerThread
```
<T> T runInCompilerThread(java.util.concurrent.Callable<T> callable)
```
  - compileInternal
```
private void compileInternal()
```
  - parse
```
public void parse()
```
  - getPassConfig
```
PassConfig getPassConfig()
```
  - createPassConfigInternal
```
PassConfig createPassConfigInternal()
```
    Create the passes object. Clients should use setPassConfig instead of overriding this.
  - setPassConfig
```
public void setPassConfig(PassConfig passes)
```
    Parameters:
    
    passes - The PassConfig to use with this Compiler.
    
    Throws:
    
    java.lang.NullPointerException - if passes is null
    
    java.lang.IllegalStateException - if this.passes has already been assigned
  - precheck
```
boolean precheck()
```
    Carry out any special checks or procedures that need to be done before proceeding with rest of the compilation process.
    
    Returns:
    
    true, to continue with compilation
  - check
```
public void check()
```
  - externExports
```
private void externExports()
```
  - process
```
void process(CompilerPass p)
```
    Description copied from class: AbstractCompiler
    
    Runs a given compiler-pass by calling its process() method.
    
    Specified by:
    
    process in class AbstractCompiler
    
    Parameters:
    
    p - The pass to be run.
  - maybeSanityCheck
```
private void maybeSanityCheck()
```
  - runSanityCheck
```
private void runSanityCheck()
```
  - stripCode
```
void stripCode(java.util.Set<java.lang.String> stripTypes,
               java.util.Set<java.lang.String> stripNameSuffixes,
               java.util.Set<java.lang.String> stripTypePrefixes,
               java.util.Set<java.lang.String> stripNamePrefixes)
```
    Strips code for smaller compiled code. This is useful for removing debug statements to prevent leaking them publicly.
  - runCustomPasses
```
private void runCustomPasses(CustomPassExecutionTime executionTime)
```
    Runs custom passes that are designated to run at a particular time.
  - startPass
```
void startPass(java.lang.String passName)
```
    Marks the beginning of a pass.
  - endPass
```
void endPass()
```
    Marks the end of a pass.
  - beforePass
```
final void beforePass(java.lang.String passName)
```
    Description copied from class: AbstractCompiler
    
    Will be called before each pass runs.
    
    Specified by:
    
    beforePass in class AbstractCompiler
  - afterPass
```
final void afterPass(java.lang.String passName)
```
    Description copied from class: AbstractCompiler
    
    Will be called after each pass finishes.
    
    Specified by:
    
    afterPass in class AbstractCompiler
  - newTracer
```
Tracer newTracer(java.lang.String passName)
```
    Returns a new tracer for the given pass name.
  - stopTracer
```
void stopTracer(Tracer t,
                java.lang.String passName)
```
  - getResult
```
public Result getResult()
```
    Returns the result of the compilation.
  - getErrors
```
public JSError[] getErrors()
```
    Returns the array of errors (never null).
  - getWarnings
```
public JSError[] getWarnings()
```
    Returns the array of warnings (never null).
  - getRoot
```
public Node getRoot()
```
    Description copied from class: AbstractCompiler
    
    Returns the root node of the AST, which includes both externs and source.
    
    Specified by:
    
    getRoot in class AbstractCompiler
  - getLanguageMode
```
CompilerOptions.LanguageMode getLanguageMode()
```
    Description copied from class: AbstractCompiler
    
    The language mode of the current root node. This will match the languageIn field of the CompilerOptions before transpilation happens, and match the languageOut field after transpilation.
    
    Specified by:
    
    getLanguageMode in class AbstractCompiler
  - setLanguageMode
```
void setLanguageMode(CompilerOptions.LanguageMode mode)
```
    Specified by:
    
    setLanguageMode in class AbstractCompiler
  - nextUniqueNameId
```
private int nextUniqueNameId()
```
    Creates a new id for making unique names.
  - resetUniqueNameId
```
void resetUniqueNameId()
```
    Resets the unique name id counter
  - getUniqueNameIdSupplier
```
com.google.common.base.Supplier<java.lang.String> getUniqueNameIdSupplier()
```
    Description copied from class: AbstractCompiler
    
    Generates unique ids.
    
    Specified by:
    
    getUniqueNameIdSupplier in class AbstractCompiler
  - areNodesEqualForInlining
```
boolean areNodesEqualForInlining(Node n1,
                                 Node n2)
```
    Description copied from class: AbstractCompiler
    
    Are the nodes equal for the purpose of inlining? If type aware optimizations are on, type equality is checked.
    
    Specified by:
    
    areNodesEqualForInlining in class AbstractCompiler
  - getInput
```
public CompilerInput getInput(InputId id)
```
    Description copied from class: AbstractCompiler
    
    Looks up an input (possibly an externs input) by input id. May return null.
    
    Specified by:
    
    getInput in class AbstractCompiler
  - removeExternInput
```
protected void removeExternInput(InputId id)
```
    Removes an input file from AST.
    
    Parameters:
    
    id - The id of the input to be removed.
  - newExternInput
```
CompilerInput newExternInput(java.lang.String name,
                             Compiler.SyntheticExternsPosition pos)
```
  - putCompilerInput
```
CompilerInput putCompilerInput(InputId id,
                               CompilerInput input)
```
  - replaceIncrementalSourceAst
```
boolean replaceIncrementalSourceAst(JsAst ast)
```
    Replace a source input dynamically. Intended for incremental re-compilation. If the new source input doesn't parse, then keep the old input in the AST and return false.
    
    Returns:
    
    Whether the new AST was attached successfully.
  - addNewSourceAst
```
boolean addNewSourceAst(JsAst ast)
```
    Add a new source input dynamically. Intended for incremental compilation.
    If the new source input doesn't parse, it will not be added, and a false will be returned.
    
    Parameters:
    
    ast - the JS Source to add.
    
    Returns:
    
    true if the source was added successfully, false otherwise.
    
    Throws:
    
    java.lang.IllegalStateException - if an input for this ast already exists.
  - getModuleGraph
```
JSModuleGraph getModuleGraph()
```
    Description copied from class: AbstractCompiler
    
    Gets the module graph. May return null if there aren't at least two modules.
    
    Specified by:
    
    getModuleGraph in class AbstractCompiler
  - getDegenerateModuleGraph
```
JSModuleGraph getDegenerateModuleGraph()
```
    Gets a module graph. This will always return a module graph, even in the degenerate case when there's only one module.
  - getTypeIRegistry
```
public TypeIRegistry getTypeIRegistry()
```
    Specified by:
    
    getTypeIRegistry in class AbstractCompiler
  - getTypeRegistry
```
public JSTypeRegistry getTypeRegistry()
```
    Description copied from class: AbstractCompiler
    
    Gets a central registry of type information from the compiled JS.
    
    Specified by:
    
    getTypeRegistry in class AbstractCompiler
  - forwardDeclareType
```
void forwardDeclareType(java.lang.String typeName)
```
    Specified by:
    
    forwardDeclareType in class AbstractCompiler
  - getTypedScopeCreator
```
public MemoizedScopeCreator getTypedScopeCreator()
```
    Description copied from class: AbstractCompiler
    
    Gets a memoized scope creator with type information. Only used by jsdev.
    
    Specified by:
    
    getTypedScopeCreator in class AbstractCompiler
  - ensureDefaultPassConfig
```
DefaultPassConfig ensureDefaultPassConfig()
```
  - buildKnownSymbolTable
```
public SymbolTable buildKnownSymbolTable()
```
  - getTopScope
```
public TypedScope getTopScope()
```
    Description copied from class: AbstractCompiler
    
    Gets the top scope.
    
    Specified by:
    
    getTopScope in class AbstractCompiler
  - getReverseAbstractInterpreter
```
public ReverseAbstractInterpreter getReverseAbstractInterpreter()
```
    Description copied from class: AbstractCompiler
    
    Get an interpreter for type analysis.
    
    Specified by:
    
    getReverseAbstractInterpreter in class AbstractCompiler
  - getTypeValidator
```
TypeValidator getTypeValidator()
```
    Description copied from class: AbstractCompiler
    
    Only used by passes in the old type checker.
    
    Specified by:
    
    getTypeValidator in class AbstractCompiler
  - getTypeMismatches
```
java.lang.Iterable<TypeValidator.TypeMismatch> getTypeMismatches()
```
    Description copied from class: AbstractCompiler
    
    Gets the central registry of type violations.
    
    Specified by:
    
    getTypeMismatches in class AbstractCompiler
  - getImplicitInterfaceUses
```
java.lang.Iterable<TypeValidator.TypeMismatch> getImplicitInterfaceUses()
```
    Description copied from class: AbstractCompiler
    
    Gets all types that are used implicitly as a matching structural interface type. These are recorded as TypeMismatchs only for convenience
    
    Specified by:
    
    getImplicitInterfaceUses in class AbstractCompiler
  - getSymbolTable
```
GlobalTypeInfo getSymbolTable()
```
    Description copied from class: AbstractCompiler
    
    Used only by the new type inference
    
    Specified by:
    
    getSymbolTable in class AbstractCompiler
  - setSymbolTable
```
void setSymbolTable(GlobalTypeInfo symbolTable)
```
    Specified by:
    
    setSymbolTable in class AbstractCompiler
  - getSimpleDefinitionFinder
```
SimpleDefinitionFinder getSimpleDefinitionFinder()
```
    Description copied from class: AbstractCompiler
    
    Used by three passes that run in sequence (optimize-returns, optimize-parameters, remove-unused-variables), to avoid having them recompute it independently.
    
    Specified by:
    
    getSimpleDefinitionFinder in class AbstractCompiler
  - setSimpleDefinitionFinder
```
void setSimpleDefinitionFinder(SimpleDefinitionFinder defFinder)
```
    Specified by:
    
    setSimpleDefinitionFinder in class AbstractCompiler
  - parseInputs
```
Node parseInputs()
```
    Parses the externs and main inputs.
    
    Returns:
    
    A synthetic root node whose two children are the externs root and the main root
  - orderInputs
```
void orderInputs()
```
  - hoistExterns
```
void hoistExterns()
```
    Hoists inputs with the @externs annotation into the externs list.
  - hoistNoCompileFiles
```
void hoistNoCompileFiles()
```
    Hoists inputs with the @nocompile annotation out of the inputs.
  - repartitionInputs
```
private void repartitionInputs()
```
  - processEs6Modules
```
void processEs6Modules()
```
  - processAMDAndCommonJSModules
```
void processAMDAndCommonJSModules()
```
    Transforms AMD and CJS modules to something closure compiler can process and creates JSModules and the corresponding dependency tree on the way.
  - parse
```
public Node parse(SourceFile file)
```
  - parseSyntheticCode
```
Node parseSyntheticCode(java.lang.String js)
```
    Description copied from class: AbstractCompiler
    
    Parses code for injecting.
    
    Specified by:
    
    parseSyntheticCode in class AbstractCompiler
  - newCompilerOptions
```
protected CompilerOptions newCompilerOptions()
```
    Allow subclasses to override the default CompileOptions object.
  - initCompilerOptionsIfTesting
```
void initCompilerOptionsIfTesting()
```
  - parseSyntheticCode
```
Node parseSyntheticCode(java.lang.String fileName,
                        java.lang.String js)
```
    Description copied from class: AbstractCompiler
    
    Parses code for injecting, and associate it with a given source file.
    
    Specified by:
    
    parseSyntheticCode in class AbstractCompiler
  - parseTestCode
```
Node parseTestCode(java.lang.String js)
```
    Description copied from class: AbstractCompiler
    
    Parses code for testing.
    
    Specified by:
    
    parseTestCode in class AbstractCompiler
  - getDefaultErrorReporter
```
ErrorReporter getDefaultErrorReporter()
```
    Description copied from class: AbstractCompiler
    
    Gets a default error reporter for injecting into Rhino.
    
    Specified by:
    
    getDefaultErrorReporter in class AbstractCompiler
  - toSource
```
public java.lang.String toSource()
```
    Converts the main parse tree back to JS code.
  - toSourceArray
```
public java.lang.String[] toSourceArray()
```
    Converts the parse tree for each input back to JS code.
  - toSource
```
public java.lang.String toSource(JSModule module)
```
    Converts the parse tree for a module back to JS code.
  - toSourceArray
```
public java.lang.String[] toSourceArray(JSModule module)
```
    Converts the parse tree for each input in a module back to JS code.
  - toSource
```
public void toSource(Compiler.CodeBuilder cb,
                     int inputSeqNum,
                     Node root)
```
    Writes out JS code from a root node. If printing input delimiters, this method will attach a comment to the start of the text indicating which input the output derived from. If there were any preserve annotations within the root's source, they will also be printed in a block comment at the beginning of the output.
  - toSource
```
public java.lang.String toSource(Node n)
```
    Generates JavaScript source code for an AST, doesn't generate source map info.
    
    Specified by:
    
    toSource in class AbstractCompiler
  - toSource
```
private java.lang.String toSource(Node n,
                                  SourceMap sourceMap,
                                  boolean firstOutput)
```
    Generates JavaScript source code for an AST.
  - optimize
```
public void optimize()
```
  - setCssRenamingMap
```
void setCssRenamingMap(CssRenamingMap map)
```
    Description copied from class: AbstractCompiler
    
    Sets the CssRenamingMap.
    
    Specified by:
    
    setCssRenamingMap in class AbstractCompiler
  - getCssRenamingMap
```
CssRenamingMap getCssRenamingMap()
```
    Description copied from class: AbstractCompiler
    
    Gets the CssRenamingMap.
    
    Specified by:
    
    getCssRenamingMap in class AbstractCompiler
  - computeCFG
```
ControlFlowGraph<Node> computeCFG()
```
    Control Flow Analysis.
  - normalize
```
public void normalize()
```
  - prepareAst
```
void prepareAst(Node root)
```
    Description copied from class: AbstractCompiler
    
    Normalizes the types of AST nodes in the given tree, and annotates any nodes to which the coding convention applies so that passes can read the annotations instead of using the coding convention.
    
    Specified by:
    
    prepareAst in class AbstractCompiler
  - recordFunctionInformation
```
void recordFunctionInformation()
```
  - addChangeHandler
```
void addChangeHandler(CodeChangeHandler handler)
```
    Description copied from class: AbstractCompiler
    
    Register a listener for code change events.
    
    Specified by:
    
    addChangeHandler in class AbstractCompiler
  - removeChangeHandler
```
void removeChangeHandler(CodeChangeHandler handler)
```
    Description copied from class: AbstractCompiler
    
    Remove a listener for code change events.
    
    Specified by:
    
    removeChangeHandler in class AbstractCompiler
  - setScope
```
void setScope(Node n)
```
    Description copied from class: AbstractCompiler
    
    Let the PhaseOptimizer know which scope a pass is currently analyzing
    
    Specified by:
    
    setScope in class AbstractCompiler
  - getJsRoot
```
Node getJsRoot()
```
    Description copied from class: AbstractCompiler
    
    Returns the root of the source tree, ignoring externs
    
    Specified by:
    
    getJsRoot in class AbstractCompiler
  - hasScopeChanged
```
boolean hasScopeChanged(Node n)
```
    Description copied from class: AbstractCompiler
    
    True iff a function changed since the last time a pass was run
    
    Specified by:
    
    hasScopeChanged in class AbstractCompiler
  - reportChangeToEnclosingScope
```
void reportChangeToEnclosingScope(Node n)
```
    Description copied from class: AbstractCompiler
    
    Passes that do cross-scope modifications use this (eg, InlineVariables)
    
    Specified by:
    
    reportChangeToEnclosingScope in class AbstractCompiler
  - setPhaseOptimizer
```
void setPhaseOptimizer(PhaseOptimizer po)
```
    Some tests don't want to call the compiler "wholesale," they may not want to call check and/or optimize. With this method, tests can execute custom optimization loops.
  - reportCodeChange
```
public void reportCodeChange()
```
    Description copied from class: AbstractCompiler
    
    Report code changes. Passes should call reportCodeChange when they alter the JS tree. This is verified by CompilerTestCase. This allows us to optimize to a fixed point.
    
    Specified by:
    
    reportCodeChange in class AbstractCompiler
  - getCodingConvention
```
public CodingConvention getCodingConvention()
```
    Description copied from class: AbstractCompiler
    
    Gets the current coding convention.
    
    Specified by:
    
    getCodingConvention in class AbstractCompiler
  - isIdeMode
```
public boolean isIdeMode()
```
    Description copied from class: AbstractCompiler
    
    Returns true if compiling in IDE mode.
    
    Specified by:
    
    isIdeMode in class AbstractCompiler
  - getParserConfig
```
Config getParserConfig(AbstractCompiler.ConfigContext context)
```
    Description copied from class: AbstractCompiler
    
    Returns the parser configuration for the specified context.
    
    Specified by:
    
    getParserConfig in class AbstractCompiler
  - createConfig
```
protected Config createConfig(Config.LanguageMode mode)
```
  - getDiagnosticGroups
```
protected DiagnosticGroups getDiagnosticGroups()
```
    The warning classes that are available from the command-line, and are suppressible by the @suppress annotation.
  - report
```
public void report(JSError error)
```
    Description copied from class: AbstractCompiler
    
    Report an error or warning.
    
    Specified by:
    
    report in class AbstractCompiler
  - getErrorLevel
```
public CheckLevel getErrorLevel(JSError error)
```
    Specified by:
    
    getErrorLevel in class AbstractCompiler
    
    Returns:
    
    The error level the given error object will be reported at.
  - throwInternalError
```
void throwInternalError(java.lang.String message,
                        java.lang.Exception cause)
```
    Report an internal error.
    
    Specified by:
    
    throwInternalError in class AbstractCompiler
  - getErrorCount
```
public int getErrorCount()
```
    Gets the number of errors.
  - getWarningCount
```
public int getWarningCount()
```
    Gets the number of warnings.
  - hasHaltingErrors
```
boolean hasHaltingErrors()
```
    Specified by:
    
    hasHaltingErrors in class AbstractCompiler
    
    Returns:
    
    Whether any errors have been encountered that should stop the compilation process.
  - hasErrors
```
public boolean hasErrors()
```
    Consults the ErrorManager to see if we've encountered errors that should halt compilation.
    If CompilerOptions.ideMode is true, this function always returns false without consulting the error manager. The error manager will continue to be told about new errors and warnings, but the compiler will complete compilation of all inputs.
  - addToDebugLog
```
void addToDebugLog(java.lang.String str)
```
    Called from the compiler passes, adds debug info
    
    Specified by:
    
    addToDebugLog in class AbstractCompiler
  - getSourceFileByName
```
SourceFile getSourceFileByName(java.lang.String sourceName)
```
    Description copied from class: AbstractCompiler
    
    Looks up a source file by name. May return null.
    
    Specified by:
    
    getSourceFileByName in class AbstractCompiler
  - getSourceMapping
```
public Mapping.OriginalMapping getSourceMapping(java.lang.String sourceName,
                                                int lineNumber,
                                                int columnNumber)
```
    Description copied from interface: SourceExcerptProvider
    
    If the source file is associated with an inputSourceMap, does a lookup for the original file position based on this source map.
  - getSourceLine
```
public java.lang.String getSourceLine(java.lang.String sourceName,
                                      int lineNumber)
```
    Description copied from interface: SourceExcerptProvider
    
    Get the line indicated by the line number. This call will return only the specific line.
    
    lineNumber - the line number, 1 being the first line of the file
    
    Returns:
    
    the line indicated, or null if it does not exist
  - getSourceRegion
```
public Region getSourceRegion(java.lang.String sourceName,
                              int lineNumber)
```
    Description copied from interface: SourceExcerptProvider
    
    Get a region around the indicated line number. The exact definition of a region is implementation specific, but it must contain the line indicated by the line number. A region must not start or end by a carriage return.
    
    lineNumber - the line number, 1 being the first line of the file
    
    Returns:
    
    the region around the line number indicated, or null if it does not exist
  - getNodeForCodeInsertion
```
Node getNodeForCodeInsertion(JSModule module)
```
    Description copied from class: AbstractCompiler
    
    Gets a suitable SCRIPT node to serve as a parent for code insertion. If module contains any inputs, the returned node will be the SCRIPT node corresponding to its first input. If module is empty, on the other hand, then the returned node will be the first SCRIPT node in a non-empty module that module depends on (the deepest one possible).
    
    Specified by:
    
    getNodeForCodeInsertion in class AbstractCompiler
    
    Parameters:
    
    module - A module. If null, will return the first SCRIPT node of all modules.
    
    Returns:
    
    A SCRIPT node (never null).
  - getSourceMap
```
public SourceMap getSourceMap()
```
  - getVariableMap
```
VariableMap getVariableMap()
```
  - getPropertyMap
```
VariableMap getPropertyMap()
```
  - getOptions
```
CompilerOptions getOptions()
```
    Specified by:
    
    getOptions in class AbstractCompiler
  - getFunctionalInformationMap
```
FunctionInformationMap getFunctionalInformationMap()
```
  - setLoggingLevel
```
public static void setLoggingLevel(java.util.logging.Level level)
```
    Sets the logging level for the com.google.javascript.jscomp package.
  - getAstDotGraph
```
public java.lang.String getAstDotGraph()
                                throws java.io.IOException
```
    Gets the DOT graph of the AST generated at the end of compilation.
    
    Throws:
    
    java.io.IOException
  - getErrorManager
```
public ErrorManager getErrorManager()
```
    Description copied from class: AbstractCompiler
    
    Gets the error manager.
    
    Specified by:
    
    getErrorManager in class AbstractCompiler
  - getInputsInOrder
```
java.util.List<CompilerInput> getInputsInOrder()
```
    Description copied from class: AbstractCompiler
    
    Gets the inputs in the order in which they are being processed. Only for use by AbstractCompilerRunner.
    
    Specified by:
    
    getInputsInOrder in class AbstractCompiler
  - getInputsById
```
public java.util.Map<InputId,CompilerInput> getInputsById()
```
    Returns an unmodifiable view of the compiler inputs indexed by id.
  - getExternsInOrder
```
java.util.List<CompilerInput> getExternsInOrder()
```
    Gets the externs in the order in which they are being processed.
  - getInputsForTesting
```
java.util.List<CompilerInput> getInputsForTesting()
```
  - getExternsForTesting
```
java.util.List<CompilerInput> getExternsForTesting()
```
  - hasRegExpGlobalReferences
```
boolean hasRegExpGlobalReferences()
```
    Specified by:
    
    hasRegExpGlobalReferences in class AbstractCompiler
    
    Returns:
    
    Whether the AST contains references to the RegExp global object properties.
  - setHasRegExpGlobalReferences
```
void setHasRegExpGlobalReferences(boolean references)
```
    Description copied from class: AbstractCompiler
    
    Set if RegExp global properties are used.
    
    Specified by:
    
    setHasRegExpGlobalReferences in class AbstractCompiler
    
    Parameters:
    
    references - Whether there are references to the RegExp global object properties.
  - updateGlobalVarReferences
```
void updateGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> refMapPatch,
                               Node collectionRoot)
```
    Description copied from class: AbstractCompiler
    
    Updates the list of references for variables in global scope.
    
    Specified by:
    
    updateGlobalVarReferences in class AbstractCompiler
    
    Parameters:
    
    refMapPatch - Maps each variable to all of its references; may contain references collected from the whole AST or only a SCRIPT sub-tree.
    
    collectionRoot - The root of sub-tree in which reference collection has been done. This should either be a SCRIPT node (if collection is done on a single file) or it is assumed that collection is on full AST.
  - getGlobalVarReferences
```
GlobalVarReferenceMap getGlobalVarReferences()
```
    Description copied from class: AbstractCompiler
    
    This can be used to get the list of all references to all global variables based on all previous calls to updateGlobalVarReferences.
    
    Specified by:
    
    getGlobalVarReferences in class AbstractCompiler
    
    Returns:
    
    The reference collection map associated to global scope variable.
  - getSynthesizedExternsInput
```
CompilerInput getSynthesizedExternsInput()
```
    Specified by:
    
    getSynthesizedExternsInput in class AbstractCompiler
    
    Returns:
    
    a CompilerInput that can be modified to add additional extern definitions to the beginning of the externs AST
  - getSynthesizedExternsInputAtEnd
```
CompilerInput getSynthesizedExternsInputAtEnd()
```
    Specified by:
    
    getSynthesizedExternsInputAtEnd in class AbstractCompiler
    
    Returns:
    
    a CompilerInput that can be modified to add additional extern definitions to the end of the externs AST
  - getProgress
```
public double getProgress()
```
    Specified by:
    
    getProgress in class AbstractCompiler
    
    Returns:
    
    a number in [0,1] range indicating an approximate progress of the last compile. Note this should only be used as a hint and no assumptions should be made on accuracy, even a completed compile may choose not to set this to 1.0 at the end.
  - getLastPassName
```
java.lang.String getLastPassName()
```
    Description copied from class: AbstractCompiler
    
    Gets the last pass name set by setProgress.
    
    Specified by:
    
    getLastPassName in class AbstractCompiler
  - setProgress
```
void setProgress(double newProgress,
                 java.lang.String passName)
```
    Description copied from class: AbstractCompiler
    
    Sets the progress percentage as well as the name of the last pass that ran (if available).
    
    Specified by:
    
    setProgress in class AbstractCompiler
    
    Parameters:
    
    newProgress - A precentage expressed as a double in the range [0, 1]. Use -1 if you just want to set the last pass name.
  - setExternProperties
```
void setExternProperties(java.util.Set<java.lang.String> externProperties)
```
    Description copied from class: AbstractCompiler
    
    Sets the names of the properties defined in externs.
    
    Specified by:
    
    setExternProperties in class AbstractCompiler
    
    Parameters:
    
    externProperties - The set of property names defined in externs.
  - getExternProperties
```
java.util.Set<java.lang.String> getExternProperties()
```
    Description copied from class: AbstractCompiler
    
    Gets the names of the properties defined in externs or null if GatherExternProperties pass was not run yet.
    
    Specified by:
    
    getExternProperties in class AbstractCompiler
  - replaceScript
```
public void replaceScript(JsAst ast)
```
    Replaces one file in a hot-swap mode. The given JsAst should be made from a new version of a file that already was present in the last compile call. If the file is new, this will silently ignored.
    
    Parameters:
    
    ast - the ast of the file that is being replaced
  - addNewScript
```
public void addNewScript(JsAst ast)
```
    Adds a new Script AST to the compile state. If a script for the same file already exists the script will not be added, instead a call to #replaceScript should be used.
    
    Parameters:
    
    ast - the ast of the new file
  - processNewScript
```
private void processNewScript(JsAst ast,
                              Node originalRoot)
```
  - runHotSwap
```
private void runHotSwap(Node originalRoot,
                        Node js,
                        PassConfig passConfig)
```
    Execute the passes from a PassConfig instance over a single replaced file.
  - runHotSwapPass
```
private void runHotSwapPass(Node originalRoot,
                            Node js,
                            PassFactory passFactory)
```
  - getCleanupPassConfig
```
private PassConfig getCleanupPassConfig()
```
  - removeSyntheticVarsInput
```
private void removeSyntheticVarsInput()
```
  - ensureLibraryInjected
```
Node ensureLibraryInjected(java.lang.String resourceName,
                           boolean normalizeAndUniquifyNames)
```
    Description copied from class: AbstractCompiler
    
    The subdir js/ contains libraries of code that we inject at compile-time only if requested by this function. Notice that these libraries will almost always create global symbols.
    
    Specified by:
    
    ensureLibraryInjected in class AbstractCompiler
    
    Parameters:
    
    resourceName - The name of the library. For example, if "base" is is specified, then we load js/base.js
    
    normalizeAndUniquifyNames - Whether to normalize the library code and make names unique.
    
    Returns:
    
    If new code was injected, returns the last expression node of the library. If the caller needs to add additional code, they should add it as the next sibling of this node. If new code was not injected, returns null.
  - loadLibraryCode
```
Node loadLibraryCode(java.lang.String resourceName,
                     boolean normalizeAndUniquifyNames)
```
    Load a library as a resource
  - getReleaseVersion
```
@GwtIncompatible(value="java.util.ResourceBundle")
public static java.lang.String getReleaseVersion()
```
    Returns the compiler version baked into the jar.
  - getReleaseDate
```
@GwtIncompatible(value="java.util.ResourceBundle")
public static java.lang.String getReleaseDate()
```
    Returns the compiler date baked into the jar.
  - addComments
```
void addComments(java.lang.String filename,
                 java.util.List<Comment> comments)
```
    Specified by:
    
    addComments in class AbstractCompiler
  - getComments
```
public java.util.List<Comment> getComments(java.lang.String filename)
```
    Description copied from class: AbstractCompiler
    
    Returns all the comments from the given file.
    
    Specified by:
    
    getComments in class AbstractCompiler
  - setDefaultDefineValues
```
void setDefaultDefineValues(com.google.common.collect.ImmutableMap<java.lang.String,Node> values)
```
    Description copied from class: AbstractCompiler
    
    Stores a map of default @define values. These values can be overriden by values specifically set in the CompilerOptions.
    
    Specified by:
    
    setDefaultDefineValues in class AbstractCompiler
  - getDefaultDefineValues
```
com.google.common.collect.ImmutableMap<java.lang.String,Node> getDefaultDefineValues()
```
    Description copied from class: AbstractCompiler
    
    Gets a map of default @define values. These values can be overriden by values specifically set in the CompilerOptions.
    
    Specified by:
    
    getDefaultDefineValues in class AbstractCompiler

Class Compiler

Nested Class Summary

Nested classes/interfaces inherited from class com.google.javascript.jscomp.AbstractCompiler

Nested classes/interfaces inherited from interface com.google.javascript.jscomp.SourceExcerptProvider

Field Summary

Fields inherited from class com.google.javascript.jscomp.AbstractCompiler

Constructor Summary

Method Summary

Methods inherited from class com.google.javascript.jscomp.AbstractCompiler

Methods inherited from class java.lang.Object

Field Detail

SINGLETON_MODULE_NAME

MODULE_DEPENDENCY_ERROR

MISSING_ENTRY_ERROR

MISSING_MODULE_ERROR

PARSING_PASS_NAME

CROSS_MODULE_CODE_MOTION_NAME

CROSS_MODULE_METHOD_MOTION_NAME

CONFIG_RESOURCE

options

passes

externs

modules

moduleGraph

inputs

errorManager

warningsGuard

injectedLibraries

externsRoot

jsRoot

externAndJsRoot

lastJsSource

languageMode

inputsById

originalSourcesLoader

sourceMapOriginalSources

commentsPerFile

sourceMap

externExports

uniqueNameId

hasRegExpGlobalReferences

functionInformationMap

debugLog

defaultCodingConvention

typeRegistry

parserConfig

externsParserConfig

abstractInterpreter

typeValidator

phaseOptimizer

tracker

defFinder

symbolTable

oldErrorReporter

defaultErrorReporter

OPTIMIZE_LOOP_ERROR

MOTION_ITERATIONS_ERROR

compilerExecutor

logger

outStream

globalRefMap

progress

lastPassName

externProperties

pathJoiner

EMPTY_MODULE_LIST_ERROR

EMPTY_ROOT_MODULE_ERROR

DUPLICATE_INPUT

DUPLICATE_EXTERN_INPUT

sanityCheck

currentTracer

currentPassName

syntheticCodeId

recentChange

codeChangeHandlers

SYNTHETIC_EXTERNS

SYNTHETIC_EXTERNS_AT_END

synthesizedExternsInput

synthesizedExternsInputAtEnd

defaultDefineValues