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 and 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 and 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 pre order (before visiting its children) and decides whether this node's children should be traversed.
void	visit(NodeTraversal t, Node n, Node parent) Visits a node in postorder (after its children have been visited).

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 pre order (before visiting its children) and decides whether this node's children should be traversed. If children are traversed, they will be visited by NodeTraversal.Callback.visit(NodeTraversal, Node, Node) in postorder.

Implementations can have side effects (e.g. modifying the parse tree).

Specified by:

shouldTraverse in interface NodeTraversal.Callback

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 have been visited). A node is visited only if all its parents should be traversed (NodeTraversal.Callback.shouldTraverse(NodeTraversal, Node, Node)).

Implementations can have side effects (e.g. modifying the parse tree).

Specified by:

visit in interface NodeTraversal.Callback