Package com.google.javascript.jscomp.modules

Class EsModuleProcessor

java.lang.Object

com.google.javascript.jscomp.modules.EsModuleProcessor

All Implemented Interfaces:

NodeTraversal.Callback

public final class EsModuleProcessor
extends java.lang.Object
implements NodeTraversal.Callback

Collects information related to and resolves ES imports and exports. Also performs several ES module related checks.

This information is stored outside of any Scope because it should never be recalculated. Recalculation is prevented for the following reasons:

• Calculation is expensive.
• When ES modules are hotswapped, we want the original information, not the "current" information, because it would show no other ES modules.

Suggested reading

Field Summary

Fields

Modifier and Type	Field	Description
static DiagnosticType	AMBIGUOUS_EXPORT_DEFINITION	Error occurs when there is an ambiguous export, which can happen if there are multiple export * from statements.
static DiagnosticType	CANNOT_PATH_IMPORT_CLOSURE_FILE
static DiagnosticType	CYCLIC_EXPORT_DEFINITION
static DiagnosticType	DUPLICATE_EXPORT
static DiagnosticType	IMPORTED_AMBIGUOUS_EXPORT
static DiagnosticType	NAMESPACE_IMPORT_CANNOT_USE_STAR

Method Summary

Modifier and Type	Method	Description
com.google.javascript.jscomp.modules.UnresolvedModule	process(ModuleMetadataMap.ModuleMetadata metadata, ModuleLoader.ModulePath path, Node script)
boolean	shouldTraverse(NodeTraversal t, Node n, Node parent)	Visits a node in preorder (before its children) and decides whether its children should be traversed.
void	visit(NodeTraversal t, Node n, Node parent)	Visits a node in postorder (after its children).

Methods inherited from class java.lang.Object

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

Field Detail

AMBIGUOUS_EXPORT_DEFINITION

public static final DiagnosticType AMBIGUOUS_EXPORT_DEFINITION

Error occurs when there is an ambiguous export, which can happen if there are multiple export * from statements. If two modules that were export * from'd have the same key as an export that export is now ambiguous. It can be resolved by exporting that key explicitly locally.

So if modules "first" and "second" both export "x" then this is ambiguous:

 export * from 'first';
 export * from 'second';
 

However we can resolve it by explicitly exporting an "x" locally:

 // Note: any one of these is a solution. Using 2 or more together causes a duplicate key error.

 // specifically export x from first
 export {x} from 'first';
 // specifically export x from second
 export {x} from 'second';
 // export our own x instead
 export let x;
 

Note: This is purposefully a warning. The spec does not treat this as an error. It is only an error if an import attempts to use an ambiguous name. But just having ambiguous names is not itself an error.

CYCLIC_EXPORT_DEFINITION

public static final DiagnosticType CYCLIC_EXPORT_DEFINITION

DUPLICATE_EXPORT

public static final DiagnosticType DUPLICATE_EXPORT

IMPORTED_AMBIGUOUS_EXPORT

public static final DiagnosticType IMPORTED_AMBIGUOUS_EXPORT

NAMESPACE_IMPORT_CANNOT_USE_STAR

public static final DiagnosticType NAMESPACE_IMPORT_CANNOT_USE_STAR

CANNOT_PATH_IMPORT_CLOSURE_FILE

public static final DiagnosticType CANNOT_PATH_IMPORT_CLOSURE_FILE

Method Detail

process

public com.google.javascript.jscomp.modules.UnresolvedModule process(ModuleMetadataMap.ModuleMetadata metadata,
                                                                     ModuleLoader.ModulePath path,
                                                                     Node script)

shouldTraverse

public boolean shouldTraverse(NodeTraversal t,
                              Node n,
                              Node parent)

Description copied from interface: NodeTraversal.Callback

Visits a node in preorder (before its children) and decides whether its children should be traversed. If the children should be traversed, they will be visited by NodeTraversal.Callback.shouldTraverse(NodeTraversal, Node, Node) in preorder and by NodeTraversal.Callback.visit(NodeTraversal, Node, Node) in postorder.

Siblings are always visited left-to-right.

Implementations can have side-effects (e.g. modify the parse tree). Removing the current node is legal, but removing or reordering nodes above the current node may cause nodes to be visited twice or not at all.

Specified by:

shouldTraverse in interface NodeTraversal.Callback

Parameters:

t - The current traversal.

n - The current node.

parent - The parent of the current node.

Returns:

whether the children of this node should be visited

visit

public void visit(NodeTraversal t,
                  Node n,
                  Node parent)

Description copied from interface: NodeTraversal.Callback

Visits a node in postorder (after its children). A node is visited in postorder iff NodeTraversal.Callback.shouldTraverse(NodeTraversal, Node, Node) returned true for its parent. In particular, the root node is never visited in postorder.

Siblings are always visited left-to-right.

Implementations can have side-effects (e.g. modify the parse tree). Removing the current node is legal, but removing or reordering nodes above the current node may cause nodes to be visited twice or not at all.

Specified by:

visit in interface NodeTraversal.Callback

Parameters:

t - The current traversal.

n - The current node.

parent - The parent of the current node.