Package | Description |
---|---|
com.google.javascript.jscomp |
Provides the core compiler and its public API.
|
Modifier and Type | Class and Description |
---|---|
class |
TypedVar
Several methods in this class, such as
isVar throw an exception when called. |
private static class |
Var.Arguments
A special subclass of Var used to distinguish "arguments" in the current
scope.
|
Modifier and Type | Field and Description |
---|---|
private Var |
InlineVariables.AliasCandidate.alias |
(package private) Var |
ScopedAliases.AliasUsage.aliasVar |
private Var |
Scope.arguments |
private Var |
CoalesceVariableNames.LiveRangeChecker.def |
private Var |
AnalyzePrototypeProperties.AssignmentProperty.rootVar |
private Var |
AnalyzePrototypeProperties.LiteralProperty.rootVar |
private Var |
CoalesceVariableNames.LiveRangeChecker.use |
private Var |
AnalyzePrototypeProperties.GlobalFunction.var |
Modifier and Type | Field and Description |
---|---|
private java.util.Map<java.lang.String,Var> |
ScopedAliases.Traversal.aliases |
private com.google.common.collect.Multimap<Var,RemoveUnusedVars.Assign> |
RemoveUnusedVars.assignsByVar
Keep track of assigns to variables that we haven't referenced.
|
private java.util.Set<Var> |
PureFunctionIdentifier.FunctionInformation.blacklisted |
private java.util.Set<Var> |
CollapseVariableDeclarations.GatherCollapses.blacklistedVars |
private com.google.common.collect.Multimap<Var,Node> |
RemoveUnusedVars.classDefiningCalls
Subclass name -> class-defining call EXPR node.
|
private java.util.Deque<GraphColoring<Var,java.lang.Void>> |
CoalesceVariableNames.colorings |
private static java.util.Comparator<Var> |
CoalesceVariableNames.coloringTieBreaker |
private com.google.common.collect.Multimap<Var,RemoveUnusedVars.Continuation> |
RemoveUnusedVars.continuations
Keep track of continuations that are finished iff the variable they're
indexed by is referenced.
|
(package private) java.util.Set<Var> |
MustBeReachingVariableDef.Definition.depends |
private java.util.Set<Var> |
LiveVariablesAnalysis.escaped |
private java.util.Set<Var> |
MaybeReachingVariableUse.escaped |
private java.util.Set<Var> |
MustBeReachingVariableDef.escaped |
private java.util.Set<Var> |
ReferenceCollectingCallback.finishedFunctionTraverse |
private java.util.Set<Var> |
Normalize.DuplicateDeclarationHandler.hasOkDuplicateDeclaration |
private java.util.Set<Var> |
ConstCheck.initializedConstants |
private java.util.Set<Var> |
FlowSensitiveInlineVariables.inlinedNewDependencies |
private java.util.Set<Var> |
RenameVars.localBleedingFunctions |
private com.google.common.collect.ArrayListMultimap<Scope,Var> |
RenameVars.localBleedingFunctionsPerScope |
private java.util.List<Var> |
RemoveUnusedVars.maybeUnreferenced
Keep track of variables that might be unreferenced.
|
(package private) com.google.common.collect.Multimap<Var,Node> |
MaybeReachingVariableUse.ReachingUses.mayUseMap |
private java.util.Map<Var,CrossModuleCodeMotion.NamedInfo> |
CrossModuleCodeMotion.namedInfo |
(package private) java.util.Map<Var,MustBeReachingVariableDef.Definition> |
MustBeReachingVariableDef.MustDef.reachingDef |
private java.util.Set<Var> |
RemoveUnusedVars.referenced
Keep track of variables that we've referenced.
|
private com.google.common.collect.Multimap<Var,Node> |
Es6RewriteBlockScopedDeclaration.LoopClosureTransformer.referenceMap |
private java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> |
ReferenceCollectingCallback.referenceMap
Maps a given variable to a collection of references to that name.
|
private java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> |
ReferenceCollectingCallback.ReferenceMapWrapper.referenceMap |
private java.util.Set<Var> |
InlineObjectLiterals.InliningBehavior.staleVars
A list of variables that should not be inlined, because their
reference information is out of sync with the state of the AST.
|
private java.util.Set<Var> |
InlineVariables.InliningBehavior.staleVars
A list of variables that should not be inlined, because their
reference information is out of sync with the state of the AST.
|
private java.util.Set<Var> |
ReferenceCollectingCallback.startedFunctionTraverse
Traverse hoisted functions where they're referenced, not
where they're declared.
|
private java.util.Set<Var> |
PureFunctionIdentifier.FunctionInformation.taintedLocals |
private java.util.Map<Var,JsMessage> |
JsMessageVisitor.unnamedMessages |
private com.google.common.base.Predicate<Var> |
ReferenceCollectingCallback.varFilter
Only collect references for filtered variables.
|
private java.util.Set<Var> |
Es6RewriteBlockScopedDeclaration.LoopClosureTransformer.LoopObject.vars |
private java.util.Map<java.lang.String,Var> |
Scope.vars |
private java.util.Set<Var> |
StripCode.varsToRemove |
private com.google.common.collect.Multimap<Var,Node> |
ShadowVariables.varToNameUsage |
Modifier and Type | Method and Description |
---|---|
<T extends Var> |
Scope.getVars()
Return an iterator over all of the variables declared in this scope.
|
Modifier and Type | Method and Description |
---|---|
(package private) Var |
Scope.declare(java.lang.String name,
Node nameNode,
CompilerInput input)
Declares a variable.
|
(package private) Var |
TypedScope.declare(java.lang.String name,
Node nameNode,
CompilerInput input) |
Var |
Scope.getArgumentsVar()
Get a unique VAR object to represents "arguments" within this scope
|
Var |
TypedScope.getArgumentsVar() |
Var |
Var.getDeclaration() |
(package private) Var |
CoalesceVariableNames.LiveRangeChecker.getDef() |
Var |
Scope.getOwnSlot(java.lang.String name) |
Var |
AnalyzePrototypeProperties.Symbol.getRootVar()
The variable for the root of this symbol.
|
Var |
AnalyzePrototypeProperties.GlobalFunction.getRootVar() |
Var |
AnalyzePrototypeProperties.AssignmentProperty.getRootVar() |
Var |
AnalyzePrototypeProperties.LiteralProperty.getRootVar() |
Var |
Scope.getSlot(java.lang.String name) |
Var |
ReferenceCollectingCallback.Reference.getSymbol() |
Var |
Var.getSymbol() |
Var |
Scope.getVar(java.lang.String name)
Returns the variable, may be null
|
(package private) static Var |
Var.makeArgumentsVar(Scope scope) |
private Var |
AnalyzePrototypeProperties.ProcessProperties.maybeGetVar(NodeTraversal t,
Node maybeName) |
Modifier and Type | Method and Description |
---|---|
java.util.Set<Var> |
PureFunctionIdentifier.FunctionInformation.blacklisted() |
private UndiGraph<Var,java.lang.Void> |
CoalesceVariableNames.computeVariableNamesInterferenceGraph(NodeTraversal t,
ControlFlowGraph<Node> cfg,
java.util.Set<Var> escaped) |
java.lang.Iterable<Var> |
ReferenceCollectingCallback.getAllSymbols()
Gets the variables that were referenced in this callback.
|
java.lang.Iterable<? extends Var> |
Scope.getAllSymbols() |
java.util.Set<? extends Var> |
LiveVariablesAnalysis.getEscapedLocals() |
private com.google.common.base.Predicate<Var> |
InlineVariables.getFilterForMode() |
(package private) java.lang.Iterable<Var> |
Scope.getVarIterable()
Return an iterable over all of the variables declared in this scope
(except the special 'arguments' variable).
|
(package private) java.lang.Iterable<Var> |
TypedScope.getVarIterable() |
java.util.Set<Var> |
PureFunctionIdentifier.FunctionInformation.taintedLocals() |
Modifier and Type | Method and Description |
---|---|
private void |
ReferenceCollectingCallback.addReference(Var v,
ReferenceCollectingCallback.Reference reference) |
(package private) void |
PureFunctionIdentifier.FunctionInformation.addTaintedLocalObject(Var var) |
boolean |
InlineVariables.IdentifyConstants.apply(Var var) |
boolean |
InlineVariables.IdentifyLocals.apply(Var var) |
void |
PureFunctionIdentifier.FunctionInformation.blacklistLocal(Var var) |
private void |
VariableReferenceCheck.ReferenceCheckingBehavior.checkDefaultParam(Var param,
Scope scope,
java.util.Set<java.lang.String> varsInFunctionBody) |
private void |
VariableReferenceCheck.ReferenceCheckingBehavior.checkShadowParam(Var v,
Scope functionScope,
java.util.List<ReferenceCollectingCallback.Reference> references) |
private void |
VariableReferenceCheck.ReferenceCheckingBehavior.checkVar(Var v,
java.util.List<ReferenceCollectingCallback.Reference> references)
If the variable is declared more than once in a basic block, generate a
warning.
|
private void |
InferConsts.considerVar(Var v,
ReferenceCollectingCallback.ReferenceCollection refCollection) |
private void |
ShadowVariables.DoShadowVariables.doShadow(RenameVars.Assignment original,
RenameVars.Assignment toShadow,
Var var) |
(package private) static JSDocInfo.Visibility |
AccessControlUtils.getEffectiveNameVisibility(Node name,
Var var,
com.google.common.collect.ImmutableMap<StaticSourceFile,JSDocInfo.Visibility> fileVisibilityMap)
Returns the effective visibility of the given name.
|
private int |
RenameVars.getLocalVarIndex(Var v)
Returns the index within the scope stack.
|
private CrossModuleCodeMotion.NamedInfo |
CrossModuleCodeMotion.getNamedInfo(Var v)
get the information on a variable
|
ReferenceCollectingCallback.ReferenceCollection |
GlobalVarReferenceMap.getReferences(Var var) |
ReferenceCollectingCallback.ReferenceCollection |
ReferenceCollectingCallback.getReferences(Var v)
Gets the reference collection for the given variable.
|
ReferenceCollectingCallback.ReferenceCollection |
ReferenceCollectingCallback.ReferenceMap.getReferences(Var var) |
ReferenceCollectingCallback.ReferenceCollection |
ReferenceCollectingCallback.ReferenceMapWrapper.getReferences(Var var) |
Scope |
ReferenceCollectingCallback.getScope(Var var) |
(package private) void |
MakeDeclaredNamesUnique.ContextualRenameInverter.handleScopeVar(Var v)
For the Var declared in the current scope determine if it is possible
to revert the name to its original form without conflicting with other
values.
|
(package private) static boolean |
VarCheck.hasDuplicateDeclarationSuppression(Node n,
Var origVar) |
private void |
InlineVariables.InliningBehavior.inline(Var v,
ReferenceCollectingCallback.Reference decl,
ReferenceCollectingCallback.Reference init,
ReferenceCollectingCallback.Reference ref)
Do the actual work of inlining a single declaration into a single
reference.
|
private void |
InlineVariables.InliningBehavior.inlineDeclaredConstant(Var v,
Node value,
java.util.List<ReferenceCollectingCallback.Reference> refSet)
Inline a declared constant.
|
private void |
InlineVariables.InliningBehavior.inlineNonConstants(Var v,
ReferenceCollectingCallback.ReferenceCollection referenceInfo,
boolean maybeModifiedArguments) |
private void |
InlineVariables.InliningBehavior.inlineValue(Var v,
ReferenceCollectingCallback.Reference ref,
Node value)
Replace the given reference with the given value node.
|
private void |
InlineVariables.InliningBehavior.inlineWellDefinedVariable(Var v,
Node value,
java.util.List<ReferenceCollectingCallback.Reference> refSet)
Inline an immutable variable into all of its references.
|
private static boolean |
CoalesceVariableNames.LiveRangeChecker.isAssignTo(Var var,
Node n,
Node parent) |
private static boolean |
ConstCheck.isConstant(Var var)
Gets whether a variable is a constant initialized to a literal value at
the point where it is declared.
|
private boolean |
InlineVariables.InliningBehavior.isImmutableAndWellDefinedVariable(Var v,
ReferenceCollectingCallback.ReferenceCollection refInfo)
Determines whether the reference collection describes a variable that
is initialized to an immutable value, never modified, and defined before
every reference.
|
private boolean |
InlineVariables.InliningBehavior.isInlineableDeclaredConstant(Var var,
ReferenceCollectingCallback.ReferenceCollection refInfo)
Determines whether the given variable is declared as a constant
and may be inlined.
|
boolean |
LiveVariablesAnalysis.LiveVariableLattice.isLive(Var v) |
private static boolean |
CollapseVariableDeclarations.isNamedParameter(Var v) |
private static boolean |
MustBeReachingVariableDef.isParameter(Var v) |
private static boolean |
CoalesceVariableNames.LiveRangeChecker.isReadFrom(Var var,
Node name) |
private boolean |
RemoveUnusedVars.isRemovableVar(Var var) |
private boolean |
InlineVariables.InliningBehavior.isStringWorthInlining(Var var,
java.util.List<ReferenceCollectingCallback.Reference> refs)
Compute whether the given string is worth inlining.
|
private boolean |
InlineObjectLiterals.InliningBehavior.isVarInlineForbidden(Var var)
Whether the given variable is forbidden from being inlined.
|
private boolean |
InlineVariables.InliningBehavior.isVarInlineForbidden(Var var)
Whether the given variable is forbidden from being inlined.
|
private boolean |
RemoveUnusedVars.markReferencedVar(Var var)
Marks a var as referenced, recursing into any values of this var
that we skipped.
|
private void |
ReferenceCollectingCallback.outOfBandTraversal(Var v) |
private boolean |
AnalyzePrototypeProperties.ProcessProperties.processGlobalFunctionDeclaration(NodeTraversal t,
Node nameNode,
Var v)
Processes a NAME node to see if it's a global function declaration.
|
private void |
ScopedAliases.Traversal.recordAlias(Var aliasVar) |
private void |
RemoveUnusedVars.removeAllAssigns(Var var)
Remove all assigns to a var.
|
private void |
InlineObjectLiterals.InliningBehavior.replaceAssignmentExpression(Var v,
ReferenceCollectingCallback.Reference ref,
java.util.Map<java.lang.String,java.lang.String> varmap)
Replaces an assignment like x = {...} with t1=a,t2=b,t3=c,true.
|
(package private) void |
ConstCheck.reportError(NodeTraversal t,
Node n,
Var var,
java.lang.String name)
Reports a reassigned constant error.
|
private void |
InlineObjectLiterals.InliningBehavior.splitObject(Var v,
ReferenceCollectingCallback.Reference init,
ReferenceCollectingCallback.ReferenceCollection referenceInfo)
Splits up the object literal into individual variables, and
updates all uses.
|
(package private) void |
Scope.undeclare(Var var)
Undeclares a variable, to be used when the compiler optimizes out
a variable and removes it from the scope.
|
(package private) void |
TypedScope.undeclare(Var var) |
private boolean |
PureFunctionIdentifier.FunctionAnalyzer.varDeclaredInDifferentFunction(Var v,
Scope scope) |
private static boolean |
VariableVisibilityAnalysis.variableIsParameter(Var variable)
Returns true if the variable is a formal parameter.
|
Modifier and Type | Method and Description |
---|---|
(package private) static void |
DataFlowAnalysis.computeEscaped(Scope jsScope,
java.util.Set<Var> escaped,
AbstractCompiler compiler)
Compute set of escaped variables.
|
private UndiGraph<Var,java.lang.Void> |
CoalesceVariableNames.computeVariableNamesInterferenceGraph(NodeTraversal t,
ControlFlowGraph<Node> cfg,
java.util.Set<Var> escaped) |
(package private) boolean |
CoalesceVariableNames.CombinedLiveRangeChecker.connectIfCrossed(UndiGraph<Var,java.lang.Void> interferenceGraph) |
private boolean |
RemoveUnusedVars.CallSiteOptimizer.markUnreferencedFunctionArgs(Scope scope,
Node function,
java.util.Set<Var> referenced,
Node param,
int paramIndex,
boolean canChangeSignature)
For each unused function parameter, determine if it can be removed
from all the call sites, if so, remove it from the function signature
and the call sites otherwise replace the unused value where possible
with a constant (0).
|
void |
RemoveUnusedVars.CallSiteOptimizer.optimize(Scope fnScope,
java.util.Set<Var> referenced) |
private void |
GlobalVarReferenceMap.resetGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> globalRefMap)
Resets global var reference map with the new provide map.
|
(package private) abstract void |
AbstractCompiler.updateGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> refMapPatch,
Node collectionRoot)
Updates the list of references for variables in global scope.
|
(package private) void |
Compiler.updateGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> refMapPatch,
Node collectionRoot) |
(package private) void |
GlobalVarReferenceMap.updateGlobalVarReferences(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> refMapPatch,
Node root)
Updates the internal reference map based on the provided parameters.
|
Constructor and Description |
---|
AliasCandidate(Var alias,
ReferenceCollectingCallback.ReferenceCollection refInfo) |
AliasedNode(Var aliasVar,
Node aliasReference) |
AliasedTypeNode(Var aliasVar,
Node aliasReference) |
AliasUsage(Var aliasVar,
Node aliasReference) |
AssignmentProperty(Node node,
Var rootVar,
JSModule module) |
GlobalFunction(Node nameNode,
Var var,
JSModule module) |
LiteralProperty(Node key,
Node value,
Node map,
Node assign,
Var rootVar,
JSModule module) |
LiveRangeChecker(Var def,
Var use) |
Constructor and Description |
---|
MustDef(java.util.Iterator<Var> vars) |
ReferenceCollectingCallback(AbstractCompiler compiler,
ReferenceCollectingCallback.Behavior behavior,
com.google.common.base.Predicate<Var> varFilter)
Constructor only collects references that match the given variable.
|
ReferenceMapWrapper(java.util.Map<Var,ReferenceCollectingCallback.ReferenceCollection> referenceMap) |