All Classes

Class	Description
AbstractCommandLineRunner<A extends Compiler,B extends CompilerOptions>	Implementations of AbstractCommandLineRunner translate flags into Java API calls on the Compiler.
AbstractCommandLineRunner.CommandLineConfig	Configurations for the command line configs.
AbstractCommandLineRunner.CommandLineConfig.ErrorFormatOption	Set of options that can be used with the --formatting flag.
AbstractCommandLineRunner.FlagEntry<T>	A pair from flag to its value.
AbstractCommandLineRunner.JsModuleSpec	Represents a specification for a js module.
AbstractCommandLineRunner.JsonFileSpec	Representation of a source file from an encoded json stream input
AbstractCommandLineRunner.JsSourceType	Flag types for JavaScript source files.
AbstractCompiler	An abstract compiler, to help remove the circular dependency of passes on JSCompiler.
AbstractCompiler.LifeCycleStage	What point in optimizations we're in.
AbstractMessageFormatter	Abstract message formatter providing default behavior for implementations of MessageFormatter needing a SourceExcerptProvider.
AbstractScope<S extends AbstractScope<S,V>,V extends AbstractVar<S,V>>	Scope contains information about a variable scope in JavaScript.
AbstractVar<S extends AbstractScope<S,V>,V extends AbstractVar<S,V>>	Used by Scope to store information about variables.
AccessControlUtils	Helper functions for computing the visibility of names and properties in JavaScript source code.
AdjacencyGraph<N,E>	A minimal graph interface.
AllowlistWarningsGuard	An extension of WarningsGuard that provides functionality to maintain a list of warnings (white-list).
AllType	All type, representing all values.
AmbiguateProperties	Renames unrelated properties to the same name, using Colors provided by the typechecker.
Annotatable	Object that has an annotation.
Annotation	Information that can be annotated to a GraphNode or Graph.GraphEdge.
AntErrorManager	An error manager that pipes warnings and errors properly into the Ant task infrastructure.
ApplySuggestedFixes	Class that applies suggested fixes to code or files.
ArgumentListTree
ArrayLiteralExpressionTree
ArrayPatternTree
AstAnalyzer	Logic for answering questions about portions of the AST.
AstManipulations	Utilities to abstract away certain common AST manipulations
AstValidator	This class walks the AST and validates that the structure is correct.
AstValidator.ViolationHandler	Violation handler
AwaitExpressionTree	Represents an await expression.
Base64	A utility class for working with Base64 values.
Base64VLQ	We encode our variable length numbers as base64 encoded strings with the least significant digit coming first.
Base64VLQ.CharIterator	A simple interface for advancing through a sequence of characters, that communicates that advance back to the source.
BaseTranspiler	Basic Transpiler implementation for outputting ES5 code.
BaseTranspiler.CompileResult	The source together with the additional compilation results.
BaseTranspiler.CompilerSupplier	Wraps the Compiler into a more relevant interface, making it easy to test the Transpiler without depending on implementation details of the Compiler itself.
BasicErrorManager	Deprecated.
BigIntType	BigInt type.
BinaryOperatorTree
Binding	Represents a variable bound by an import or export statement, or goog.require.
BlackHoleErrorManager	An ErrorManager that silently swallows all messages.
BlockTree
BooleanLiteralSet	A set in the domain {true,false}.
BooleanType	Boolean type.
BranchCoverageInstrumentationCallback	Instrument branch coverage for javascript.
BreakStatementTree
BrowserModuleResolver	Resolution algorithm for Browsers.
BrowserWithTransformedPrefixesModuleResolver	Limited superset of the BrowserModuleResolver that allows for replacing some path prefixes before resolving.
BrowserWithTransformedPrefixesModuleResolver.Factory	Factory for BrowserWithTransformedPrefixesModuleResolver.
ByPathWarningsGuard	An implementation of a WarningsGuard that can modify the CheckLevel based on the file that caused the warning, and whether this file matches a set of paths (specified either as include or exclude of path name parts).
CachedTransformer	A Transformer that caches output from a delegate transformer.
CachingTranspiler	A transpiler implementation that delegates to a lower-level implementation on a cache miss.
CallExpressionTree
CaseCanonicalize	Implements the ECMAScript 5 Canonicalize operation used to specify how case-insensitive regular expressions match.
CaseClauseTree
CatchTree
ChainableReverseAbstractInterpreter	Chainable reverse abstract interpreter providing basic functionality.
ChangeVerifier	A Class to assist in AST change tracking verification.
CheckArrayWithGoogObject	Lints against passing arrays to goog.object methods with the intention of iterating over them as though with a for-in loop, which is discouraged with arrays.
CheckConformance	Provides a framework for checking code against a set of user configured conformance rules.
CheckConformance.InvalidRequirementSpec
CheckConformance.Rule
CheckConstantCaseNames	This pass looks for module-level variable declarations that use CONSTANT_CASE, according to the Google style guide, and verifies that they are also annotated @const or are in a const clause.
CheckDefaultExportOfGoogModule	Check that the goog.module does not use a default export.
CheckDuplicateCase	Check for duplicate case labels in a switch statement Eg: switch (foo) { case 1: case 1: } This is normally an indication of a programmer error.
CheckEmptyStatements	Check for empty statements (i.e.
CheckEnums	Checks the following: Whether there are duplicate values in enums.
CheckEs6ModuleFileStructure	Checks the file structure of ES6 modules.
CheckEs6Modules	Miscellaneous checks for style in ES6 modules.
CheckExtraRequires	Walks the AST looking for usages of qualified names, and 'goog.require's of those names.
CheckInterfaces	Checks for errors related to interfaces.
CheckJSDocStyle	Checks for various JSDoc-related style issues, such as function definitions without JsDoc, params with no corresponding @param annotation, coding conventions not being respected, etc.
CheckLevel	Controls checking levels of certain options.
CheckLevelLegacy	Enum used in flags to control the behavior of JS compiler checks.
CheckMissingAndExtraRequires	Deprecated. The compiler pass that provides "missing require" checking is {@link #com.google.javascript.jscomp.CheckMissingRequires}
CheckMissingRequires	A pass to detect references to fully qualified Closure namespaces.
CheckMissingSemicolon	Check for statements that should end with a semicolon according to the Google style guide.
CheckNoMutatedEs6Exports	Checks that exports of ES6 modules are not mutated outside of module initialization.
CheckNullabilityModifiers	Checks for missing or redundant nullability modifiers.
CheckNullableReturn	Checks when a function is annotated as returning {SomeType} (nullable) but actually always returns {!SomeType}, i.e.
CheckPathsBetweenNodes<N,E>	See constructor, CheckPathsBetweenNodes(DiGraph, DiGraphNode, DiGraphNode, Predicate, Predicate), for a description of this algorithm.
CheckPrimitiveAsObject	Check for explicit creation of the object equivalents of primitive types (e.g.
CheckPrototypeProperties	Checks when a mutable property is assigned to a prototype.
CheckProvidesSorted	Checks that goog.provide statements are sorted and deduplicated, exposing the necessary information to produce a suggested fix.
CheckProvidesSorted.Mode	Operation modes.
CheckRequiresSorted	Checks that Closure import statements (goog.require, goog.requireType, and goog.forwardDeclare) are sorted and deduplicated, exposing the necessary information to produce a suggested fix.
CheckRequiresSorted.Mode	Operation modes.
CheckTypeImportCodeReferences	Checks for invalid code references to type-only imports (i.e., goog.requireType).
CheckTypeSummaryWarningsGuard	A warnings guard that demotes the errors found in type summary files to be less severe, leaving only the errors found in the original source.
CheckUnusedLabels	Check for unused labels blocks.
CheckUselessBlocks	Check for useless blocks.
CheckVar	Check for `var` (prefer `const` or `let`).
ChromeCodingConvention	Coding convention used by the Chrome team to compile Chrome's JS.
ChromePass	Compiler pass for Chrome-specific needs.
ClassDeclarationTree
ClosureBundler	A utility class to assist in creating JS bundle files.
ClosureCheckModule	Checks that goog.module() is used correctly.
ClosureCodingConvention	This describes the Closure-specific JavaScript coding conventions.
ClosurePrimitive	Enum of primitive functions that the compiler recognizes
ClosureReverseAbstractInterpreter	A reverse abstract interpreter (RAI) for specific closure patterns such as goog.isObject.
CodeConsumer	Abstracted consumer of the CodeGenerator output.
CodeGenerator	CodeGenerator generates codes from a parse tree, sending it to the specified CodeConsumer.
CodeGenerator.Context	Information on the current context.
CodePrinter	CodePrinter prints out JS code in either pretty format or compact format.
CodePrinter.Builder
CodePrinter.Builder.CodeGeneratorFactory
CodePrinter.Format	Specifies a format for code generation.
CodeReplacement	Class that represents a set of changes to make to the code.
CodingConvention	CodingConvention defines a set of hooks to customize the behavior of the Compiler for a specific team/company.
CodingConvention.AssertionFunctionLookup	This stores a relation from either name or Closure Primitive to assertion function
CodingConvention.AssertionFunctionSpec	A description of a JavaScript function that will throw an exception when either: One of its parameters does not match the return type of the function One of its parameters is falsy.
CodingConvention.AssertionFunctionSpec.AssertionKind
CodingConvention.AssertionFunctionSpec.Builder
CodingConvention.Bind	Bind class
CodingConvention.Cache	Cache class
CodingConvention.DelegateRelationship	Delegates provides a mechanism and structure for identifying where classes can call out to optional code to augment their functionality.
CodingConvention.ObjectLiteralCast	An object literal cast provides a mechanism to cast object literals to other types without a warning.
CodingConvention.SubclassRelationship	Record subclass relations
CodingConvention.SubclassType	Specify the kind of inheritance
CodingConventions	Helper classes for dealing with coding conventions.
CodingConventions.Proxy	A convention that wraps another.
Color	A simplified version of a Closure or TS type for use by optimizations
ColorDeserializer	Convert a TypePool (from a single compilation) into Colors.
ColorDeserializer.InvalidSerializedFormatException	Error emitted when the deserializer sees a serialized type it cannot support deserialize
ColorRegistry	Memoizes all native color instances
CommaExpressionTree
CommandLineRunner	CommandLineRunner translates flags into Java API calls on the Compiler.
CommandLineRunner.FormattingOption	Set of options that can be used with the --formatting flag.
Comment	placeholder class
Comment.Type
CompilationLevel	A CompilationLevel represents the level of optimization that should be applied when compiling JavaScript code.
Compiler	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.
Compiler.CodeBuilder	Stores a buffer of text to which more can be appended.
Compiler.ExternalSourceLoader	Subclasses are responsible for loading sources that were not provided as explicit inputs to the compiler.
CompilerBasedTransformer	A source transformer base class.
CompilerBasedTransformer.CompileResult	The source together with the additional compilation results.
CompilerBasedTransformer.CompilerSupplier	Wraps the Compiler into a more relevant interface, making it easy to test the CompilerBasedTransformer without depending on implementation details of the Compiler itself.
CompilerInput	A class for the internal representation of an input to the compiler.
CompilerInput.ModuleType	JavaScript module type.
CompilerInputProvider	A provider mapping a InputId to a CompilerInput.
CompilerOptions	Compiler options
CompilerOptions.AliasTransformation	A Role Specific Interface for the JS Compiler to report aliases used to change the code during a compile.
CompilerOptions.AliasTransformationHandler	A Role Specific Interface for JS Compiler that represents a data holder object which is used to store goog.scope alias code changes to code made during a compile.
CompilerOptions.DevMode	When to do the extra validity checks
CompilerOptions.Environment	An environment specifies the built-in externs that are loaded for a given compilation.
CompilerOptions.Es6ModuleTranspilation	How ES6 modules should be transformed.
CompilerOptions.ExtractPrototypeMemberDeclarationsMode
CompilerOptions.IncrementalCheckMode
CompilerOptions.InstrumentOption	An option to determine what level of code instrumentation is performed, if any
CompilerOptions.IsolationMode	What kind of isolation is going to be used
CompilerOptions.J2clPassMode	A mode enum used to indicate whether J2clPass should be enabled, disabled, or enabled automatically if there is any J2cl source file (i.e.
CompilerOptions.LanguageMode	A language mode applies to the whole compilation job.
CompilerOptions.OutputJs	What type of JS file should be output by this compilation
CompilerOptions.PropertyCollapseLevel
CompilerOptions.Reach	A common enum for compiler passes that can run either globally or locally.
CompilerOptions.TracerMode	How much tracing we want to do
CompilerOptions.TweakProcessing	Option for the ProcessTweaks pass
CompilerOptionsPreprocessor	Checks for combinations of options that are incompatible, i.e.
CompilerOptionsPreprocessor.InvalidOptionsException	Exception to indicate incompatible options in the CompilerOptions.
CompilerPass	Interface for classes that can compile JS.
CompileTask	This class implements a simple Ant task to do almost the same as CommandLineRunner.
ComposeWarningsGuard	WarningsGuard that represents just a chain of other guards.
ComprehensionForTree
ComprehensionIfTree
ComprehensionTree
ComprehensionTree.ComprehensionType
ComputedPropertyDefinitionTree	Represents a computed property in an object literal.
ComputedPropertyGetterTree
ComputedPropertyMethodTree
ComputedPropertySetterTree
ConditionalExpressionTree
Config	Configuration for the AST factory.
Config.Builder	Builder for a Config.
Config.JsDocParsing	Whether to parse the descriptions of JsDoc comments.
Config.LanguageMode	JavaScript mode
Config.RunMode	Whether to keep going after encountering a parse error.
Config.StrictMode	Level of language strictness required for the input source code.
ConformanceAllowlister	Creates or updates conformance whitelist entries.
ConformancePassConfig	Runs only the user-supplied conformance checks and any earlier passes required by conformance.
ConformanceRules	Standard conformance rules.
ConformanceRules.AbstractRule	A conformance rule implementation to support things common to all rules such as allowlisting and reporting.
ConformanceRules.BanCreateDom	Ban goog.dom.createDom and goog.dom.DomHelper#createDom with parameters specified in value in the format tagname.attribute, e.g.
ConformanceRules.BanCreateElement	Bans document.createElement and similar methods with string literal parameter specified in value, e.g.
ConformanceRules.BanExpose	Banned @expose
ConformanceRules.BanForOf	Banned for/of loops
ConformanceRules.BanGlobalVars	Banned global var declarations.
ConformanceRules.BanNullDeref	Banned dereferencing null or undefined types.
ConformanceRules.BanThrowOfNonErrorTypes	Banned throw of non-error object types.
ConformanceRules.BanUnknownDirectThisPropsReferences	Banned unknown type references of the form "this.prop" unless - it is immediately cast, - it is a @template type (until template type restricts are enabled) or - the value is unused.
ConformanceRules.BanUnknownThis	Banned unknown "this" types.
ConformanceRules.BanUnknownTypedClassPropsReferences	Banned unknown type references of the form "instance.prop" unless (a) it is immediately cast/asserted, or (b) it is a @template type (until template type restrictions are enabled), or (c) the value is unused, or (d) the source object type is unknown (to avoid error cascades)
ConformanceRules.BanUnresolvedType	Banned accessing properties from objects that are unresolved forward-declared type names.
ConformanceRules.ConformanceLevel	Possible check check results
ConformanceRules.ConformanceResult	Classes extending AbstractRule must return ConformanceResult from their checkConformance implementation.
ConformanceRules.RequireFileoverviewVisibility	Requires source files to contain a top-level @fileoverview block with an explicit visibility annotation.
ConformanceRules.RequireUseStrict	Require "use strict" rule
ConformanceRules.StrictBanUnresolvedType	Ban any use of unresolved forward-declared types
ContinueStatementTree
ControlFlowAnalysis	This is a compiler pass that computes a control flow graph.
ControlFlowGraph<N>	Control flow graph.
ControlFlowGraph.AbstractCfgNodeTraversalCallback	Abstract callback to visit a control flow graph node without going into subtrees of the node that are also represented by other control flow graph nodes.
ControlFlowGraph.Branch	The edge object for the control flow graph.
ConvertToTypedInterface	The goal of this pass is to shrink the AST, preserving only typing, not behavior.
ConvertTypesToColors	Pass to convert JSType objects from TypeChecking that are attached to the AST into Color objects whose sole use is to enable running optimizations.
CoverageInstrumentationPass	This code implements the instrumentation pass over the AST (returned by JSCompiler).
CoverageInstrumentationPass.CoverageReach	Configures which statements in the AST should be instrumented
CoverageInstrumenter	A source transformer for instrmenting code for coverage data collection.
CoverageInstrumenter.CompilerSupplier	Supply options for coverage.
CrossChunkMethodMotion	Move prototype methods into later chunks.
CrossChunkReferenceCollector	Collects global variable references for use by CrossChunkCodeMotion.
CssRenamingMap	Interface used by ReplaceCssNames to substitute CSS class names.
CssRenamingMap.ByPart	ByPart renaming map
CssRenamingMap.ByWhole	ByWhole renaming map
CssRenamingMap.Style	Kind of renaming map
CustomPassExecutionTime	Custom pass type.
DartSuperAccessorsPass	Converts super getter and setter calls in order to support the output of the Dart Dev Compiler (https://github.com/dart-lang/dev_compiler).
DeadPropertyAssignmentElimination	An optimization pass that finds and removes dead property assignments within functions and classes.
DebuggerStatementTree
DebugInfo	Useful debugging info for Color objects that may or may not be populated, and thus should not effect their value.
DebugInfo.Builder	Builder for DebugInfo
DefaultClauseTree
DefaultDependencyResolver	Class for resolving Closure dependencies.
DefaultExterns	Contains information on default externs files.
DefaultNameGenerator	A simple class for generating unique JavaScript variable/property names.
DefaultParameterTree
DefaultPassConfig	Pass factories and meta-data for native JSCompiler passes.
DependencyFile	SourceFile containing dependency information.
DependencyInfo	A data structure for JS dependency information for a single .js file.
DependencyInfo.Base	Abstract base implementation that defines derived accessors such as DependencyInfo.Base.isModule().
DependencyInfo.Require	A dependency link between two files, e.g.
DependencyInfo.Require.Type
DependencyInfo.Util	Utility methods.
DependencyOptions	Options for how to manage dependencies between input files.
DependencyOptions.DependencyMode	Describes how the compiler should manage dependencies.
DependencyResolver	Interface for DependencyResolver to keep in line with DefaultDependencyResolver, which doesn't provide an interface.
DepsFileRegexParser	A parser that can extract dependency information from existing deps.js files.
DepsGenerator	Generates deps.js files by scanning JavaScript files for calls to goog.provide(), goog.require() and goog.addDependency().
DepsGenerator.InclusionStrategy
DestructuredTarget	Represents a single target inside a destructuring pattern, whether another pattern or a lhs expression.
DiagnosticGroup	Group a set of related diagnostic types together, so that they can be toggled on and off as one unit.
DiagnosticGroupPathSuppressingWarningsGuard	A warnings guard that suppresses warnings for a particular diagnostic group for a file that contains the specified substring.
DiagnosticGroups	Named groups of DiagnosticTypes exposed by Compiler.
DiagnosticGroupWarningsGuard	Sets the level for a particular DiagnosticGroup.
DiagnosticToSuppressionMapper	Used to print a map from diagnostic id to suppression.
DiagnosticType	The type of a compile or analysis error.
DiGraph<N,E>	A generic directed graph.
DiGraph.DiGraphEdge<N,E>	A generic directed graph edge.
DiGraph.DiGraphNode<N,E>	A generic directed graph node.
DisambiguateProperties	DisambiguateProperties renames properties to disambiguate between unrelated fields with the same name.
DisambiguateProperties2	Assembles the various parts of the diambiguator to execute them as a compiler pass.
DotFormatter	DotFormatter prints out a dot file of the Abstract Syntax Tree.
DoWhileStatementTree
DToA
DynamicImportTree	Represents a dynamic import expression.
EmptyMessageBundle	An implementation of MessageBundle that has no translations.
EmptyStatementTree
EnumElementType	The type of individual elements of an enum type (see EnumType).
EnumType	An enum type representing a branded collection of elements.
ErrorFormat	Error formats available.
ErrorHandler	The error handler is any generic sink for warnings and errors, after they've passed through any filtering WarningsGuards.
ErrorManager	The error manager is in charge of storing, organizing and displaying errors and warnings generated by the compiler.
ErrorReporter	A conduit for reporting errors and warnings to the user.
ErrorReporter	This is interface defines a protocol for the reporting of errors during JavaScript translation or execution.
ErrorToFixMapper	Maps a JSError to a list of SuggestedFixes, if possible.
Es6CheckModule	Checks that ES6 Modules are used correctly, and do not reference undefined keywords or features.
Es6ConvertSuper	Converts super.method() calls and adds constructors to any classes that lack them.
Es6ConvertSuperConstructorCalls	Converts super() calls.
Es6ExtractClasses	Extracts ES6 classes defined in function calls to local constants.
Es6ForOfConverter	Converts ES6 "for of" loops to ES5.
Es6NormalizeShorthandProperties	Normalizes shorthand object properties.
Es6RelativizeImportPaths	Rewrites ES6 import paths to be relative after resolving according to the compiler's module resolver.
Es6RenameVariablesInParamLists	Renames declarations and references in function bodies to avoid shadowing names referenced in the parameter list, in default values or computed properties.
Es6RewriteArrowFunction	Converts ES6 arrow functions to standard anonymous ES3 functions.
Es6RewriteBlockScopedDeclaration	Rewrite "let"s and "const"s as "var"s.
Es6RewriteBlockScopedFunctionDeclaration	Rewrite block-scoped function declarations as "let"s.
Es6RewriteClass	Converts ES6 classes to valid ES5 or ES3 code.
Es6RewriteClassExtendsExpressions	Extracts ES6 class extends expressions and creates an alias.
Es6RewriteDestructuring	Rewrites destructuring patterns and default parameters to valid ES3 code or to a different form of destructuring.
Es6RewriteModules	Rewrites a ES6 module into a form that can be safely concatenated.
Es6RewriteModulesToCommonJsModules	Rewrites an ES6 module to a CommonJS-like module for the sake of per-file transpilation + bunlding (e.g.
Es6RewriteRestAndSpread	Converts REST parameters and SPREAD expressions.
Es6RewriteScriptsToModules	Rewrites a script which was imported as a module into an ES6 module.
Es6SortedDependencies<INPUT extends DependencyInfo>	A sorted list of inputs following the ES6 module ordering spec.
Es6SplitVariableDeclarations	Splits variable declarations that declare multiple variables into separate declarations, if at least one of the declarations is a destructuring declaration.
Es6ToEs3ClassSideInheritance	Rewrites static inheritance to explicitly copy inherited properties from superclass to subclass so that the optimizer knows the subclass has those properties.
Es6ToEs3Util	Util functions for converting Es6 to Es5
Es7RewriteExponentialOperator	Replaces the ES7 `**` and `**=` operators to calls to `Math.pow`.
EsModuleProcessor	Collects information related to and resolves ES imports and exports.
Export	An exported name in a module.
ExportDeclarationTree
ExportSpecifierTree
ExportTestFunctions	Generates goog.exportSymbol for test functions, so they can be recognized by the test runner, even if the code is compiled.
ExpressionStatementTree
FeatureSet	Represents various aspects of language version and support.
FeatureSet.Feature	Specific features that can be included in a FeatureSet.
FieldCleanupPass	A CleanupPass implementation that will remove all field declarations on JSTypes contributed by the original file.
FileAwareWarningsGuard	An abstract WarningsGuard that provides an additional getScriptNodeForError() method for accessing the containing SCRIPT node of the AST in a robust way.
FilePosition	Represents a position in a source file.
FinallyTree
FindModuleDependencies	Find and update any direct dependencies of an input.
FixedPointGraphTraversal<N,E>	A utility class for doing fixed-point computations.
FixedPointGraphTraversal.EdgeCallback<Node,Edge>	Edge callback
FixingErrorManager	An error manager that finds a SuggestedFix for all errors if possible.
FlagUsageException	An exception thrown when command-line flags are used incorrectly.
FlowScope	A symbol table for inferring types during data flow analysis.
ForAwaitOfStatementTree	Represents a for-await-of statement, which was added in ES2018
ForInStatementTree
FormalParameterListTree
ForOfStatementTree
ForStatementTree
FunctionDeclarationTree
FunctionDeclarationTree.Builder	Builds a FunctionDeclarationTree.
FunctionDeclarationTree.Kind
FunctionParamBuilder	A builder for the list representing FunctionType Parameters
FunctionType	This derived type provides extended information about a function, including its return type and argument types.
FunctionType.Builder	A builder class for function and arrow types.
FunctionType.Parameter	Models a single JavaScript parameter.
GatherGetterAndSetterProperties	Finds getter and setter properties in the AST.
GatherModuleMetadata	Gathers metadata around modules that is useful for checking imports / requires and creates a ModuleMetadataMap.
GenerateExports	Generates goog.exportSymbol/goog.exportProperty for the @export annotation.
GetAccessorTree
GoogBindToArrow	Replaces goog.bind(..., this) with arrow functions.
GoogEsImports	Utilties for ES imports for Closure files, for example import array from 'goog:goog.array';.
GoogleCodingConvention	This describes the Google-specific JavaScript coding conventions.
GoogleJsMessageIdGenerator	An JsMessage.IdGenerator designed to play nicely with Google's Translation systems.
Graph<N,E>	The base generic class for graph-like data structure and algorithms in the compiler.
Graph.GraphEdge<N,E>	A generic edge.
GraphColoring<N,E>	Annotates the graph with a color in a way that no connected node will have the same color.
GraphColoring.Color	The color of a node
GraphColoring.GreedyGraphColoring<N,E>	Greedily assign nodes with high degree unique colors.
GraphNode<N,E>	A generic node.
GraphReachability<N,E>	Computes all the reachable nodes.
GraphReachability.EdgeTuple<N,E>	Represents a Source Node and an Edge.
GraphvizGraph	A graph that can be dumped to a Graphviz DOT file.
GraphvizGraph.GraphvizEdge	A Graphviz edge.
GraphvizGraph.GraphvizNode	A Graphviz node.
GwtProperties	GWT-compatible helper for dealing with Java .properties files.
HamtPMap<K,V>	An immutable sorted map with efficient (persistent) updates.
HasCompiler	An interface for objects that can provide a compiler instance.
HotSwapCompilerPass	Interface for compiler passes that can be used in a hot-swap fashion.
IdentifierExpressionTree
Identifiers	JS identifier parsing utilities.
IdentifierToken	A token representing an identifier.
IdGenerator	Id generator used in CrossModuleMotion.
IdMappingUtil	A utility class for generating and parsing id mappings held by ReplaceIdGenerators.
IfStatementTree
IjsErrors	IJS-related errors occurring outside the ConvertToTypedInterface pass.
IllegalFormatCodePointException
IllegalFormatConversionException
IllegalFormatFlagsException
IllegalFormatPrecisionException
IllegalFormatWidthException
ImplicitNullabilityCheck	Warn about types in JSDoc that are implicitly nullable.
ImplicitNullabilityCheck.Nullability	Represents the types of implicit nullability errors caught by this pass: a) implicitly nonnull (missing a "!"), and b) implicitly nullable (missing a "?").
ImplicitNullabilityCheck.Result	Information to represent a single "implicit nullability result", including the JSDoc string node that needs a "!" or "?" to be explicit, as well as an enum indicating which of the two nullability cases were found ("!" or "?").
Import	An imported name in a module.
ImportDeclarationTree
ImportMetaExpressionTree	Represents 'new.target'.
ImportSpecifierTree
InjectTranspilationRuntimeLibraries	Injects JS library code that may be needed by the transpiled form of the input source code.
InputId	An id used uniquely identify a CompilerInput
InvalidatingTypes	Keeps track of "invalidating types" that force type-based optimizations to back off, specifically for InlineProperties, AmbiguateProperties, and DisambiguateProperties.
InvalidatingTypes.Builder	Builder
IR	An AST construction helper class
IterRestTree
IterSpreadTree
J2clAssertRemovalPass	An optimization pass to remove J2CL Asserts.$assert.
J2clChecksPass	Performs correctness checks which are specific to J2CL-generated patterns.
J2clClinitPrunerPass	An optimization pass to prune J2CL clinits.
J2clConstantHoisterPass	An optimization pass for J2CL-generated code to hoist some constant assignments out clinit method to declaration phase so they could be used by other optimization passes for static evaluation.
J2clEqualitySameRewriterPass	An optimization pass to re-write J2CL Equality.$same.
J2clPass	A normalization pass to inline some J2CL calls to enable other optimizations.
J2clPropertyInlinerPass	This pass targets J2CL output.
J2clSuppressWarningsGuard	A warnings guard that suppresses some warnings incompatible with J2CL.
J2clUtilGetDefineRewriterPass	A normalization pass to re-write Util.$getDefine calls to make them work in compiled mode.
JsAst	Generates an AST for a JavaScript source file.
JsAst.ParseResult	Simple class to share parse results between compilation jobs
JsAst.RhinoError	Representation of Rhino parser error.
JSDocInfo	JSDoc information describing JavaScript code.
JSDocInfo.Marker	Defines a class for containing the parsing information for this JSDocInfo.
JSDocInfo.NamePosition	A piece of information (found in a marker) which contains a position with a name node.
JSDocInfo.StringPosition	A piece of information (found in a marker) which contains a position with a string.
JSDocInfo.TypePosition	A piece of information (found in a marker) which contains a position with a type expression syntax tree.
JSDocInfo.Visibility	Visibility categories.
JSDocInfoBuilder	A builder for JSDocInfo objects.
JsDocInfoParser	A parser for JSDoc comments.
JSDocInfoPrinter	Prints a JSDocInfo, used for preserving type annotations in ES6 transpilation.
JsdocSerializer	Utilities for serializing and deserializing JSDoc necessary for optimzations.
JsDocTokenStream	This class implements the scanner for JsDoc strings.
JSError	Compile error description.
JsFileFullParser	A parser that extracts dependency information from a .js file, including goog.require, goog.provide, goog.module, import/export statements, and JSDoc annotations related to dependency management.
JsFileFullParser.FileInfo	The dependency information contained in a .js source file.
JsFileFullParser.FileInfo.ModuleType	The module system declared by the file, e.g.
JsFileFullParser.Reporter	Interface for reporting errors.
JsFileLineParser	Base class for classes that parse JavaScript sources on a line-by-line basis.
JsFileRegexParser	A parser that can extract dependency information from a .js file, including goog.require, goog.provide, goog.module, import statements, and export statements.
JSIdentifier	Utility class to hold isJSIdentifier.
JsMessage	A representation of a translatable message in JavaScript source code.
JsMessage.Builder	Contains functionality for creating JS messages.
JsMessage.IdGenerator	ID generator
JsMessage.PlaceholderReference	A reference to a placeholder in a translatable message.
JsMessage.Style	Message style that could be used for JS code parsing.
JsMessageDefinition	Container class that holds information about JS message source.
JsMessageExtractor	Extracts messages and message comments from JS code.
JsMessageVisitor	Traverses across parsed tree and finds I18N messages.
JSModule	A JavaScript module has a unique name, consists of a list of compiler inputs, and can depend on other modules.
JSModuleGraph	A JSModule dependency graph that assigns a depth to each module and can answer depth-related queries about them.
JSModuleGraph.MissingModuleException	Another exception class
JSModuleGraph.ModuleDependenceException	Exception class for declaring when the modules being fed into a JSModuleGraph as input aren't in dependence order, and so can't be processed for caching of various dependency-related queries.
JsonErrorReportGenerator	An error report generator that prints error and warning data to the print stream as an array of JSON objects.
JsSourceMatcher	A Matcher that can take arbitrary JS source code and use it as a template to find matches in other source code.
JSType	Represents JavaScript value types.
JSType.HasPropertyKind	A tristate value returned from canPropertyBeDefined.
JSType.Nullability	Specifies how to express nullability of reference types in annotation strings and error messages.
JSType.SubtypingMode	In files translated from Java, we typecheck null and undefined loosely.
JSType.TypePair	a data structure that represents a pair of types
JSTypeExpression	When parsing a jsdoc, a type-annotation string is parsed to a type AST.
JSTypeNative	Constants corresponding to types that are built into a JavaScript engine and other types that occur very often in the type system.
JSTypeRegistry	The type registry is used to resolve named types.
JSTypeRegistry.PropDefinitionKind	A tristate value returned from canPropertyBeDefined.
JSTypeResolver	A state machine for resolving all JSType instances.
Keywords	The JavaScript keywords.
LabelledStatementTree
LateEs6ToEs3Converter	Converts ES6 code to valid ES5 code.
LatticeElement	A lattice element.
LazyParsedDependencyInfo	A DependencyInfo class that determines load flags by parsing the AST just-in-time.
LightweightMessageFormatter	Lightweight message formatter.
LinkedDirectedGraph<N,E>	A directed graph using ArrayLists within nodes to store edge information.
LinkedDirectedGraph.LinkedDiGraphEdge<N,E>	A directed graph edge that stores the source and destination nodes at each edge.
LinkedDirectedGraph.LinkedDiGraphNode<N,E>	A directed graph node that stores outgoing edges and incoming edges as an list within the node itself.
LinkedUndirectedGraph<N,E>	An undirected graph using linked list within nodes to store edge information.
Linter	Tool for running just the lint checks which can be run on a single file at a time.
Linter.Builder	Builder for a Linter that allows some customization.
LinterMain	Minimal binary that just runs the "lint" checks which can be run on a single file at a time.
LiteralExpressionTree
LiteralToken	A token representing a javascript literal.
LogFile	A simple interface for writing to a human readable log file.
LoggerErrorManager	An error manager that logs errors and warnings using a logger in addition to collecting them in memory.
LookaheadErrorReporter	An error reporter that throws exceptions for parse errors.
LookaheadErrorReporter.ParseException
LowestCommonAncestorFinder<N,E>	Implements a lowest common ancestor search algorithm.
LowestCommonAncestorFinder.Factory<N,E>	An abstraction for LowestCommonAncestorFinder::new.
MapDiagnosticToSuppression	Prints out a map from diagnostic id to suppression.
MarkUntranspilableFeaturesAsRemoved	Looks for presence of features that are not supported for transpilation (mostly new RegExp features).
Match	Object that contains the information for a given match.
Matcher	Interface for a class that knows how to match a Node for a specific pattern.
Matchers	Class that contains common Matchers that are useful to everyone.
MemberExpressionTree
MemberLookupExpressionTree
MessageBundle	An interface for providing alternative values for user-visible messages in JavaScript code.
MessageFormatter	Format warnings and errors.
MissingFormatArgumentException
MissingFormatWidthException
MissingPrimaryExpressionTree
Module	Information for modules, particularly ES modules, that is useful for rewriting.
Module.Builder	Builder for Module.
ModuleIdentifier	Basic information on an entry point module.
ModuleLoader	Provides compile-time locate semantics for ES6 and CommonJS modules.
ModuleLoader.ModuleResolverFactory	An enum used to specify what algorithm to use to locate non path-based modules
ModuleLoader.PathEscaper	Indicates whether to escape characters in paths.
ModuleLoader.PathResolver	An enum indicating whether to absolutize paths.
ModuleLoader.ResolutionMode	Standard path base resolution algorithms that are accepted as a command line flag.
ModuleMap	A map containing information about all modules in the compilation.
ModuleMapCreator	Creates a ModuleMap.
ModuleMetadataMap	Contains metadata around modules (or scripts) that is useful for checking imports / requires.
ModuleMetadataMap.ModuleMetadata	Struct containing basic information about a module/script including its type and goog namespaces.
ModuleMetadataMap.ModuleMetadata.Builder	Builder for ModuleMetadataMap.ModuleMetadata.
ModuleMetadataMap.ModuleType	Various types of Javascript modules and scripts that can be found in the JS Compiler.
ModuleNames	Static methods related to module names.
ModuleRequestResolver	Resolves requests for other modules.
ModuleResolver	Base class for algorithms that resolve JavaScript module references to input files.
NamedType	A NamedType is a named reference to some other type.
NameGenerator	A class that generates unique JavaScript variable/property names.
NativeColorId	All color representing native JavaScript objects that have special behavior during optimizations.
NewExpressionTree
NewTargetExpressionTree	Represents 'new.target'.
Node	This class implements the root of the intermediate representation.
Node.AncestorIterable	Iterator to go up the ancestor tree.
Node.SideEffectFlags	A helper class for getting and setting invocation side-effect flags.
Node.TypeDeclarationNode	Represents a node in the type declaration AST.
NodeMetadata	Class that holds metadata (or meta objects) for use by JsFlume that aren't contained within the Node itself.
NodeModuleResolver	Resolution algorithm for NodeJS.
NodeModuleResolver.Factory	Factory for NodeModuleResolver.
NodeTraversal	NodeTraversal allows an iteration through the nodes in the parse tree, and facilitates the optimizations on the parse tree.
NodeTraversal.AbstractModuleCallback	Abstract callback that knows when a global script, goog.provide file, goog.module, goog.loadModule, ES module or CommonJS module is entered or exited.
NodeTraversal.AbstractPostOrderCallback	Abstract callback to visit all nodes in postorder.
NodeTraversal.AbstractPostOrderCallbackInterface	Abstract callback to visit all nodes in postorder.
NodeTraversal.AbstractPreOrderCallback	Abstract callback to visit all nodes in preorder.
NodeTraversal.AbstractScopedCallback	Abstract scoped callback to visit all nodes in postorder.
NodeTraversal.AbstractShallowCallback	Abstract callback to visit all nodes but not traverse into function bodies.
NodeTraversal.AbstractShallowStatementCallback	Abstract callback to visit all structure and statement nodes but doesn't traverse into functions or expressions.
NodeTraversal.Callback	Callback for tree-based traversals
NodeTraversal.ChangeScopeRootCallback	Callback for passes that iterate over a list of change scope roots (FUNCTIONs and SCRIPTs)
NodeTraversal.ExternsSkippingCallback	Abstract callback to visit all non-extern nodes in postorder.
NodeTraversal.ScopedCallback	Callback that also knows about scope changes
NodeUtil	NodeUtil contains generally useful AST utilities.
NodeUtil.GoogRequire	Represents a goog.require'd namespace and property inside a module.
NodeUtil.ValueType
NodeUtil.Visitor	Interface for use with the visit method.
NominalTypeBuilder	Builder interface for declaring properties on class-like (nominal) types.
NonJSDocComment	Minimal class holding information about a nonJSDoc comment's source location and contents
NoObjectType	The bottom Object type, representing the subclass of all objects.
NoResolvedType	An unresolved type that was forward declared.
NoType	Bottom type, representing the subclass of any value or object.
NullTree	Represents a null parse tree element.
NullType	Null type.
NumberType	Number type.
ObjectLiteralExpressionTree
ObjectPatternTree
ObjectRestTree
ObjectSpreadTree
ObjectType	Object type.
OptionalCallExpressionTree	Creates a OptionalCallExpressionTree that represents a call expression within an optional chain.
OptionalMemberExpressionTree	Creates a OptionalMemberExpressionTree that represents a getprop expression within an optional chain.
OptionalMemberLookupExpressionTree	Creates a OptionalMemberExpressionTree that represents a getprop expression within an optional chain.
Outcome	An enum for representing boolean outcomes.
Outcome	An enum for representing truthiness and nullishness of outcomes.
ParenExpressionTree
Parser	Parses a javascript file.
Parser.Config
Parser.Config.Mode
ParserRunner	parser runner
ParserRunner.ParseResult	Holds results of parsing.
ParseTree	An abstract syntax tree for JavaScript parse trees.
ParseTreeType	The types of concrete parse trees.
ParsingUtil	Utility functions for parsing that don't depend on the compiler.
PassConfig	Pass factories and meta-data for native Compiler passes.
PassConfig.PassConfigDelegate	An implementation of PassConfig that just proxies all its method calls into an inner class.
PassFactory	A factory for creating JSCompiler passes based on the Options injected.
PassFactory.Builder	A builder for a PassFactory.
PassNames	If the name of a pass is used in more than one place in the source, it's good to create a symbolic name here.
PathUtil	Utility methods for manipulation of UNIX-like paths.
PerformanceTracker	A PerformanceTracker collects statistics about the runtime of each pass, and how much a pass impacts the size of the compiled output, before and after gzip.
PerformanceTracker.Stats	A Stats object contains statistics about a pass run, such as running time, size changes, etc
PMap<K,V>	A minimal interface for null-hostile, persistent immutable maps.
PMap.Reconciler<K,V>	See PMap.reconcile(com.google.javascript.rhino.PMap<K, V>, com.google.javascript.rhino.PMap.Reconciler<K, V>).
PolymerExportPolicy	How to handle exports/externs for Polymer properties and methods.
PredefinedName	The set of all non-keyword, non-reserved words used in javascript.
PrintStreamErrorManager	Deprecated. , Please use the {#SortingErrorManger} with a {#PrintStreamErrorReportGenerator} instead.
PrintStreamErrorReportGenerator	An error report generator that prints errors and warnings to the print stream provided.
ProcessCommonJSModules	Rewrites a CommonJS module http://wiki.commonjs.org/wiki/Modules/1.1.1 into a form that can be safely concatenated.
ProgramTree
Property	A property slot of an object.
Property.OwnedProperty	A property instance associated with particular owner type.
PropertyNameAssignmentTree
PropertyRenamingDiagnostics	Shared diagnotic type related to property renaming.
PropertyRenamingPolicy	Policies to determine how properties should be renamed.
PrototypeObjectType	The object type represents instances of JavaScript objects such as Object, Date, Function.
ProxyObjectType	An object type which uses composition to delegate all calls.
QualifiedName	Abstraction over a qualified name.
RandomNameGenerator	A class for generating unique, randomized JavaScript variable/property names.
RecordType	A record (structural) type.
RecordTypeBuilder	A builder for record types.
RecoverableJsAst	An implementation of SourceAst that avoids re-creating the AST unless it was manually cleared.
RefactoringDriver	Primary driver of a refactoring.
RefactoringDriver.Builder
RefactoringUtils	Utility methods for refactoring Java code.
RefasterJsScanner	Class that drives the RefasterJs refactoring by matching against a provided template JS file and then applying a transformation based off the template JS.
Reference	Represents a single declaration or reference to a variable.
ReferenceCollectingCallback	A helper class for passes that want to access all information about where a variable is referenced and declared at once and then make a decision as to how it should be handled, possibly inlining, reordering, or generating warnings.
ReferenceCollectingCallback.Behavior	Way for callers to add specific behavior during traversal that utilizes the built-up reference information.
ReferenceCollection	A collection of references.
ReferenceMap	Maps Vars to their references.
RegExpTree	An AST for JavaScript regular expressions.
RegExpTree.Alternation	Represents the possibilities ["foo", "bar" ] for a RegExp /foo|bar/
RegExpTree.Anchor	Represents an anchor, namely ^ or $.
RegExpTree.BackReference	Represents a reference to a previous group such as \1 or \2
RegExpTree.CapturingGroup	Represents a capturing group such as (asdf)
RegExpTree.Charset	Represents a set of possible characters structured as [a-zA-Z] or [^a-zA-Z]
RegExpTree.Concatenation	Represents a series of nodes chained one after another such as (?:...)[a-z]*(...)
RegExpTree.Empty	Represents an empty portion of a RegExp such as the middle of "||"
RegExpTree.LookaheadAssertion	Represents a lookahead assertion such as (?=...) or (?!...)
RegExpTree.LookbehindAssertion	Represents a lookbehind assertion such as (?<=...) or (?<!...)
RegExpTree.NamedBackReference	Represents a reference to a previous named group
RegExpTree.NamedCaptureGroup	Represents a named capture group
RegExpTree.RegExpTreeAtom	Represents a node that never has children such as an anchor or charset.
RegExpTree.Repetition	Represents a repeating item such as ...+, ...*, or ...{0,1}
RegExpTree.Text	Represents a run of non-special characters such as "foobar"
RegExpTree.UnicodePropertyEscape	Represents a Unicode Property Escape such as in /\p{Script=Greek}/u
RegExpTree.WordBoundary	Represents \b or \B
Region	Source code region.
RenamingMap	Interface used by to substitute names.
ReplacedStringsDecoder	A decoder for strings encoded by the ReplaceStrings JS compiler pass.
ResourceLoader	Utility class that handles resource loading.
Result	Compilation results
ReturnStatementTree
ReverseAbstractInterpreter	This interface defines what reversed abstract interpreters provide.
RewriteAsyncFunctions	Converts async functions to valid ES6 generator functions code.
RewriteAsyncIteration	Converts async generator functions into a function returning a new $jscomp.AsyncGenWrapper around the original block and awaits/yields converted to yields of ActionRecords.
RewriteGoogJsImports	Looks for references to Closure's goog.js file and globalizes.
RewriteGoogJsImports.Mode	Possible traversal modes - either linting or linting+rewriting.
RewriteJsonToModule	Rewrites a JSON file to be a module export.
RewriteNullishCoalesceOperator	Replaces the ES2020 `??` operator with conditional (?:).
RewriteObjectSpread	Converts object spread to valid ES2017 code.
RewritePolyfills	Injects polyfill libraries to ensure that ES6+ library functions are available.
Scanner	Scans javascript source code into tokens.
Scanner	Class that developers should implement to perform a JsFlume refactoring.
Scanner.CommentRecorder
Scope	Scope contains information about a variable scope in JavaScript.
ScriptMetadata	A summary of a script for use during fixes.
SemanticReverseAbstractInterpreter	A reverse abstract interpreter using the semantics of the JavaScript language as a means to reverse interpret computations.
SerializationOptions	Congiguration options for serialization time.
ServiceException	An exception thrown by the compilation service.
SetAccessorTree
ShowByPathWarningsGuard	Control whether warnings should be restricted or suppressed for specified paths.
ShowByPathWarningsGuard.ShowType	Controls whether warnings should be restricted to a specified path or suppressed within the specified path.
SimpleDependencyInfo	A class to hold JS dependency information for a single .js file.
SimpleDependencyInfo.Builder	Builder for constructing instances of SimpleDependencyInfo.
SimpleErrorReporter	A simple ErrorReporter that collects warnings and errors and makes them accessible via SimpleErrorReporter.errors and SimpleErrorReporter.warnings.
SimpleFormat	This is a hacked apart version of the Apache Harmony String.format class with all parts outside of the GWT subset removed.
SimpleReference<T extends StaticTypedSlot>	A simple immutable reference.
SimpleRegion	Simple region.
SimpleSlot	The minimum implementation of StaticTypedSlot.
SimpleSourceFile	A simple implementation of StaticSourceFile for testing.
SingletonColorFields	Fields present on a color representing a primitive or object.
SingletonColorFields.Builder	Builder for a singleton color.
SortedDependencies<INPUT extends DependencyInfo>	A sorted list of inputs with dependency information.
SortedDependencies.MissingProvideException
SortingErrorManager	A customizable error manager that sorts all errors and warnings reported to it, and has customizable output through the SortingErrorManager.ErrorReportGenerator interface.
SortingErrorManager.ErrorReportGenerator	Strategy for customizing the output format of the error report
Source	An abstract representation of a source file.
Source.Builder	Builder for Source instances.
Source.Transformer	An automorphic transformation on sources.
SourceAst	An interface for accessing the AST root of an input.
SourceCodeEscapers	A factory for Escaper instances used to escape strings for safe use in various common programming languages.
SourceExcerptProvider	A source excerpt provider is responsible for building source code excerpt of specific locations, such as a specific line or a region around a given line number.
SourceExcerptProvider.ExcerptFormatter	A excerpt formatter is responsible of formatting source excerpts.
SourceExcerptProvider.SourceExcerpt	Source excerpt variety.
SourceFile	An interface for representing source files for the Compilation Service.
SourceFile	A source file.
SourceFile	An abstract representation of a source file that provides access to language-neutral features.
SourceFile.Builder	A builder interface for source files.
SourceFile.Generator	A JavaScript source code provider.
SourceFileMapping	A SourceFileMapping maps a source file, line, and column into an Mapping.OriginalMapping.
SourceMap	Collects information mapping the generated (compiled) source back to its original source for debugging purposes.
SourceMap.DetailLevel	Source maps can be very large different levels of detail can be specified.
SourceMap.Format	An enumeration of available source map formats
SourceMap.LocationMapping	Function that mape a "destination" location to use within the source map.
SourceMap.PrefixLocationMapping	Simple SourceMap.LocationMapping that strips a prefix from a location.
SourceMapConsumer	A SourceMapConsumer is a SourceMapping provide that can parse from a raw string.
SourceMapConsumerFactory	Detect and parse the provided source map.
SourceMapConsumerV3	Class for parsing version 3 of the SourceMap format, as produced by the Closure Compiler, etc.
SourceMapConsumerV3.EntryVisitor
SourceMapFormat	A list of currently support SourceMap format revisions.
SourceMapGenerator	Collects information mapping the generated (compiled) source back to its original source for debugging purposes
SourceMapGeneratorFactory
SourceMapGeneratorV3	Collects information mapping the generated (compiled) source back to its original source for debugging purposes.
SourceMapGeneratorV3.ExtensionMergeAction	This interface provides the merging strategy when an extension conflict appears because of merging two source maps on method SourceMapGeneratorV3.mergeMapSection(int, int, java.lang.String).
SourceMapInput	A lazy-loaded SourceMapConsumerV3 instance.
SourceMapObject	Wraps a JsonObject to provide a V3 source map.
SourceMapObjectParser	Java implementation of the source map parser.
SourceMapParseException	Throw if an invalid or unknown source map is encountered.
SourceMapping	Interface for provide a way of mapping (line, column) positions back to positions in the original (uncompiled) source code.
SourceMappingReversable	A SourceMappingReversable is a SourceMapping that can provide the reverse (source → target) source mapping.
SourceMapResolver	Utility class for resolving source maps and files referenced in source maps.
SourceMapSection	A class representing a partial source map.
SourceMapSection.SectionType
SourceMapSupplier	A class for mapping source map names to the actual contents.
SourcePosition	A position in a source string - includes offset, line and column.
SourcePosition<T>	Represents a position in some piece of source code, with an associated item of type T found at that position.
SourceRange	A range of positions in a source string.
StandardUnionFind<E>	A Union-Find implementation.
StaticRef	The StaticRef tells us all the ways that a StaticSlot is used in a program.
StaticScope	The StaticScope interface must be implemented by any object that defines variables for the purposes of static analysis.
StaticSlot	The StaticSlot interface must be implemented by variables that can appear as members of a StaticScope.
StaticSourceFile	The StaticSourceFile contains information about a compiler input.
StaticSourceFile.SourceKind	Source kinds.
StaticSymbolTable<S extends StaticSlot,R extends StaticRef>	Lookup references by the symbols that they refer to.
StaticTypedRef	The StaticTypedRef tells us all the ways that a StaticTypedSlot is used in a program.
StaticTypedScope	The StaticTypedScope interface must be implemented by any object that defines variables for the purposes of static analysis.
StaticTypedSlot	The StaticTypedSlot interface must be implemented by variables that can appear as members of a StaticTypedScope.
StrictWarningsGuard	All warnings should be reported as errors.
StringLiteralToken	A single or double quoted JavaScript string literal.
StringType	String type.
SubGraph<N,E>	An interface representing a subgraph that provides adjacency calculation to a node.
SuggestedFix	Object representing the fixes to apply to the source code to create the refactoring CL.
SuggestedFix.Builder	Builder class for SuggestedFix that contains helper functions to manipulate JS nodes.
SuggestedFix.MatchedNodeInfo	Information about the node that was matched for the suggested fix.
SuperExpressionTree
SwitchStatementTree
SymbolTable	A symbol table for people that want to use Closure Compiler as an indexer.
SymbolTable.Reference	Reference
SymbolTable.Symbol	A symbol-table entry
SymbolTable.SymbolScope	Scope of a symbol
SymbolType	Symbol type.
SyncCompilerFeatures	Sets compiler feature set to features used in the externs and sources
SyntacticScopeCreator	The syntactic scope creator scans the parse tree to create a Scope object containing all the variable declarations in that scope.
SyntacticScopeCreator.ScopeFactory	A simple API for injecting the use of alternative Scope classes
SyntheticAst	An AST generated totally by the compiler.
TemplateAstMatcher	A matcher that can take an arbitrary AST and use it as a template to find matches in another.
TemplateLiteralExpressionTree	Template literal production in ES6.
TemplateLiteralPortionTree	A production representing a literal portion of a template literal.
TemplateLiteralToken	A token representing a javascript template literal substring.
TemplateSubstitutionTree	A production representing the expression to be evaluated and substituted into a template literal.
TemplateType	A placeholder type, used as keys in TemplateTypeMaps.
TemplateTypeMap	Manages a mapping from TemplateType to its resolved JSType.
TemplateTypeReplacer	Specializes TemplatizedTypes according to provided bindings.
TemplatizedType	An object type with declared template types, such as Array<string>.
TernaryValue	An enum for ternary logic.
ThisExpressionTree
ThreadSafeDelegatingErrorManager	A simple delegating ErrorManager that provides a thread-safe wrapper for the one being delegated.
ThrowStatementTree
Token	A Token in a javascript file.
Token	This class implements the JavaScript scanner.
TokenStream	This class implements the JavaScript scanner.
TokenType
TokenUtil	Helper methods for parsing JavaScript.
TransformAMDToCJSModule	Rewrites an AMD module https://github.com/amdjs/amdjs-api/wiki/AMD to a CommonJS module.
TranspilationException	An unchecked exception thrown when transpilation fails due to one or more errors in the input script.
TranspilationPasses	Provides a single place to manage transpilation passes.
Transpiler	A source transformer for lowering JS language versions.
Transpiler	Common interface for a transpiler.
TranspilerBuilder	Basic Transpiler implementation for outputting ES5 code.
TranspileResult	The result of transpiling a single file.
TryStatementTree
TypeCheck	Checks the types of JS expressions against any declared type information.
TypeDeclarationsIR	An AST construction helper class for TypeDeclarationNode
TypedScope	TypedScope contains information about variables and their types.
TypedVar	AbstractVar subclass for use with TypedScope.
TypeMatchingStrategy	The different strategies for matching the JSType of nodes.
TypeMatchingStrategy.MatchResult	The result of comparing two different JSType instances.
TypeMismatch	Signals that the first type and the second type have been used interchangeably.
TypePoolCreator<T>	Class that aids in building a pool of serialized types
TypeTransformationParser	A parser for the type transformation expressions (TTL-Exp) as in @template T := TTL-Exp =:
TypeTransformationParser.Keywords	Keywords of the type transformation language
TypeTransformationParser.OperationKind	The classification of the keywords
UnaryExpressionTree
UndiGraph<N,E>	A generic undirected graph.
UndiGraph.UndiGraphEdge<N,E>	A generic undirected graph edge.
UndiGraph.UndiGraphNode<N,E>	A generic undirected graph node.
UnionFind<E>	Union-Find is a classical algorithm used to find connected components in graph theory.
UnionType	A type that may be any one of a set of types, and thus has the intersection of the properties of those types.
UnionType.Builder	Implements type unioning logic, since UnionTypes only actually need to perform unioning operations when being (re)built.
UniqueIdSupplier	Generates unique String Ids when requested via a compiler instance.
UnknownFormatConversionException
UnknownType	The Unknown type.
UpdateExpressionTree	Represents UpdateExpression productions from the spec.
UpdateExpressionTree.OperatorPosition	Position of the operator relative to the operand.
Util
Var	Used by Scope to store information about variables.
VariableDeclarationListTree
VariableDeclarationTree
VariableMap	Stores the mapping from original variable name to new variable names.
VariableRenamingPolicy	Policies to determine which variables should be renamed.
VariableStatementTree
VirtualFile	Class used to represent a "virtual" file.
Visitor<T>	A vistor for JSTypes.
Visitor.WithDefaultCase<T>	A type visitor with a default behaviour.
VoidType	Void type whose only element is the undefined value.
Warning	Simple representation of a warning flag in Ant
WarningLevel	Convert the warnings level to an Options object.
WarningsGuard	Class that allows to flexibly manage what to do with a reported warning/error.
WarningsGuard.Priority	Priority
WebpackModuleResolver	Resolution algorithm for Webpack.
WebpackModuleResolver.Factory	Uses a lookup map provided by webpack to locate modules from a numeric id used during import
WhileStatementTree
WhitespaceWrapGoogModules	Replicates the effect of ClosureBundler in whitespace-only mode and wraps goog.modules in goog.loadModule calls.
WithStatementTree
Xid	A simple utility for shortening identifiers in a stable way.
Xid.HashFunction	Strategy for selecting the underlying hash code function to be used by Xid.
XtbMessageBundle	A MessageBundle that parses messages from an XML Translation Bundle (XTB) file.
YieldExpressionTree