We need to inline all required names since there are certain well-known Closure symbols * (like goog.asserts) that later stages of the compiler check for and cannot handle aliases. * *
We use this to rewrite something like: * *
* import {x} from '';
* const {assert} = goog.require('goog.asserts');
* assert(x);
*
*
* To:
*
*
* import {x} from '';
* goog.asserts.assert(x);
*
*
* Because if we used an alias like below the assertion would not be recognized:
*
*
* import {x} from '';
* const {assert} = goog.asserts;
* assert(x);
*
*/
// TODO(johnplaisted): This is actually incorrect if the require'd thing is mutated. But we need
// it so that things like goog.asserts work. Mutated closure symbols are a lot rarer than needing
// to use asserts and the like. Until there's a better solution to finding aliases of well known
// symbols we have to inline anything that is require'd.
private MapThis is used when the namespace is not part of the input so that this pass can be fault * tolerant and still rewrite to something. Some tools don't care about rewriting correctly and * just want the type information of this module (e.g. clutz). */ private ModuleMetadata getFallbackMetadataForNamespace(String namespace) { // Assume a provide'd file to be consistent with goog.module rewriting. ModuleMetadata.Builder builder = ModuleMetadata.builder() .moduleType(ModuleMetadataMap.ModuleType.GOOG_PROVIDE) .usesClosure(true) .isTestOnly(false); builder.googNamespacesBuilder().add(namespace); return builder.build(); } private void visitRequireOrGet( NodeTraversal t, Node requireCall, Node parent, boolean isRequire) { if (!requireCall.hasTwoChildren() || !requireCall.getLastChild().isString()) { t.report(requireCall, INVALID_REQUIRE_NAMESPACE); return; } // Module has already been turned into a script at this point. if (isRequire && !t.getScope().isGlobal()) { t.report(requireCall, INVALID_CLOSURE_CALL_SCOPE_ERROR); return; } String namespace = requireCall.getLastChild().getString(); boolean isStoredInDeclaration = NodeUtil.isDeclaration(parent.getParent()); if (isStoredInDeclaration && !parent.getParent().isConst()) { compiler.report(JSError.make(parent.getParent(), LHS_OF_GOOG_REQUIRE_MUST_BE_CONST)); } ModuleMetadata m = moduleMetadataMap.getModulesByGoogNamespace().get(namespace); if (m == null) { t.report(requireCall, MISSING_MODULE_OR_PROVIDE, namespace); m = getFallbackMetadataForNamespace(namespace); } if (isStoredInDeclaration) { if (isRequire) { Node toDetach; if (parent.isDestructuringLhs()) { checkState(parent.getFirstChild().isObjectPattern()); toDetach = parent.getParent(); for (Node child : parent.getFirstChild().children()) { if (child.isStringKey()) { checkState(child.getFirstChild().isName()); namesToInlineByAlias.put( child.getFirstChild().getString(), ModuleRenaming.getGlobalName(m, namespace) + "." + child.getString()); } else { checkState(child.isName()); namesToInlineByAlias.put( child.getString(), ModuleRenaming.getGlobalName(m, namespace) + "." + child.getString()); } } } else if (parent.isName()) { namesToInlineByAlias.put(parent.getString(), ModuleRenaming.getGlobalName(m, namespace)); toDetach = parent.getParent(); } else { checkState(parent.isExprResult()); toDetach = parent; } toDetach.detach(); } else { Node replacement = NodeUtil.newQName(compiler, ModuleRenaming.getGlobalName(m, namespace)) .srcrefTree(requireCall); parent.replaceChild(requireCall, replacement); } } else { checkState(requireCall.getParent().isExprResult()); requireCall.getParent().detach(); } } /** * Traverses a node tree and * *
* import * as foo from './foo';
* import {doBar} from './bar';
*
* console.log(doBar);
*
*
* @param n Alias node. In the example above alias nodes are foo, doBar, and doBar.
* @param module Name of the module currently being processed.
*/
private void maybeAddAliasToSymbolTable(Node n, String module) {
if (preprocessorSymbolTable == null) {
return;
}
n.putBooleanProp(Node.MODULE_ALIAS, true);
// Alias can be used in js types. Types have node type STRING and not NAME so we have to
// use their name as string.
String nodeName =
n.isString() || n.isImportStar()
? n.getString()
: preprocessorSymbolTable.getQualifiedName(n);
// We need to include module as part of the name because aliases are local to current module.
// Aliases with the same name from different module should be completely different entities.
String name = "alias_" + module + "_" + nodeName;
preprocessorSymbolTable.addReference(n, name);
}
/**
* Add reference to a file that current module imports. Example:
*
* * import * as qux from '../some/file.js'; ** *
Will add a reference to file.js on the string node `'../some/file.js'`. * * @param importStringNode String node from the import statement that references imported file. In * the example above it is the '../some/file.js' STRING node. * @param importedFilePath Absolute path to the imported file. In the example above it can be * myproject/folder/some/file.js */ private void maybeAddImportedFileReferenceToSymbolTable( Node importStringNode, String importedFilePath) { if (preprocessorSymbolTable == null) { return; } // If this if the first import that mentions importedFilePath then we need to create a SCRIPT // node for the imported file. if (preprocessorSymbolTable.getSlot(importedFilePath) == null) { Node scriptNode = compiler.getScriptNode(importedFilePath); if (scriptNode != null) { preprocessorSymbolTable.addReference(scriptNode, importedFilePath); } } preprocessorSymbolTable.addReference(importStringNode, importedFilePath); } }