com.google.javascript.jscomp

Class ProcessDefines

java.lang.Object

com.google.javascript.jscomp.ProcessDefines

All Implemented Interfaces:

CompilerPass

class ProcessDefines
extends java.lang.Object
implements CompilerPass

Process variables annotated as @define. A define is a special constant that may be overridden by later files and manipulated by the compiler, much like C preprocessor #defines.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	ProcessDefines.CollectDefines Finds all assignments to @defines, and figures out the last value of the @define.
private static class	ProcessDefines.DefineInfo A simple class for storing information about a define.

Field Summary

Fields

Modifier and Type	Field and Description
private AbstractCompiler	compiler
(package private) static DiagnosticType	DEFINE_NOT_ASSIGNABLE_ERROR
private java.util.Map<java.lang.String,Node>	dominantReplacements
(package private) static DiagnosticType	INVALID_DEFINE_INIT_ERROR
(package private) static DiagnosticType	INVALID_DEFINE_TYPE_ERROR
private static java.util.Set<java.lang.String>	KNOWN_DEFINES Defines in this set will not be flagged with "unknown define" warnings.
private GlobalNamespace	namespace
(package private) static DiagnosticType	NON_GLOBAL_DEFINE_INIT_ERROR
private static MessageFormat	REASON_DEFINE_NOT_ASSIGNABLE
(package private) static DiagnosticType	UNKNOWN_DEFINE_WARNING

Constructor Summary

Constructors

Constructor and Description
ProcessDefines(AbstractCompiler compiler, java.util.Map<java.lang.String,Node> replacements) Create a pass that overrides define constants.

Method Summary

Modifier and Type	Method and Description
private java.util.Map<java.lang.String,ProcessDefines.DefineInfo>	collectDefines(Node root, GlobalNamespace namespace) Finds all defines, and creates a ProcessDefines.DefineInfo data structure for each one.
private static java.lang.String	format(MessageFormat format, java.lang.Object... params)
(package private) ProcessDefines	injectNamespace(GlobalNamespace namespace) Injects a pre-computed global namespace, so that the same namespace can be re-used for multiple check passes.
private boolean	isValidDefineType(JSTypeExpression expression) Only defines of literal number, string, or boolean are supported.
private void	overrideDefines(java.util.Map<java.lang.String,ProcessDefines.DefineInfo> allDefines)
void	process(Node externs, Node root) Process the JS with root node root.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

KNOWN_DEFINES

private static final java.util.Set<java.lang.String> KNOWN_DEFINES

Defines in this set will not be flagged with "unknown define" warnings. There are legacy flags that always set these defines, even when they might not be in the binary.

compiler

private final AbstractCompiler compiler

dominantReplacements

private final java.util.Map<java.lang.String,Node> dominantReplacements

namespace

private GlobalNamespace namespace

UNKNOWN_DEFINE_WARNING

static final DiagnosticType UNKNOWN_DEFINE_WARNING

INVALID_DEFINE_TYPE_ERROR

static final DiagnosticType INVALID_DEFINE_TYPE_ERROR

INVALID_DEFINE_INIT_ERROR

static final DiagnosticType INVALID_DEFINE_INIT_ERROR

NON_GLOBAL_DEFINE_INIT_ERROR

static final DiagnosticType NON_GLOBAL_DEFINE_INIT_ERROR

DEFINE_NOT_ASSIGNABLE_ERROR

static final DiagnosticType DEFINE_NOT_ASSIGNABLE_ERROR

REASON_DEFINE_NOT_ASSIGNABLE

private static final MessageFormat REASON_DEFINE_NOT_ASSIGNABLE

Constructor Detail

ProcessDefines

ProcessDefines(AbstractCompiler compiler,
               java.util.Map<java.lang.String,Node> replacements)

Create a pass that overrides define constants. TODO(nicksantos): Write a builder to help JSCompiler induce replacements from command-line flags

Parameters:

replacements - A hash table of names of defines to their replacements. All replacements must be literals.

Method Detail

injectNamespace

ProcessDefines injectNamespace(GlobalNamespace namespace)

Injects a pre-computed global namespace, so that the same namespace can be re-used for multiple check passes. Returns this for easy chaining.

process

public void process(Node externs,
                    Node root)

Description copied from interface: CompilerPass

Process the JS with root node root. Can modify the contents of each Node tree

Specified by:

process in interface CompilerPass

Parameters:

externs - Top of external JS tree

root - Top of JS tree

overrideDefines

private void overrideDefines(java.util.Map<java.lang.String,ProcessDefines.DefineInfo> allDefines)

format

private static java.lang.String format(MessageFormat format,
                                       java.lang.Object... params)

isValidDefineType

private boolean isValidDefineType(JSTypeExpression expression)

Only defines of literal number, string, or boolean are supported.

collectDefines

private java.util.Map<java.lang.String,ProcessDefines.DefineInfo> collectDefines(Node root,
                                                                                 GlobalNamespace namespace)

Finds all defines, and creates a ProcessDefines.DefineInfo data structure for each one.

Returns:

A map of ProcessDefines.DefineInfo structures, keyed by name.