Code with Finding: |
class ExternExportsPass.Export {
/**
* Appends the exported function and all paths necessary for the path to be
* declared. For example, for a property "a.b.c", the initializers for
* paths "a", "a.b" will be appended (if they have not already) and a.b.c
* will be initialized with the exported version of the function:
* <pre>
* var a = {};
* a.b = {};
* a.b.c = function(x,y) { }
* </pre>
*/
protected void appendExtern(String path, Node functionToExport) {
List<String> pathPrefixes = computePathPrefixes(path);
for (int i = 0; i < pathPrefixes.size(); ++i) {
String pathPrefix = pathPrefixes.get(i);
/* The complete path (the last path prefix) must be emitted and
* it gets initialized to the externed version of the value.
*/
boolean isCompletePathPrefix = (i == pathPrefixes.size() - 1);
boolean skipPathPrefix = pathPrefix.endsWith(".prototype")
|| (alreadyExportedPaths.contains(pathPrefix)
&& !isCompletePathPrefix);
if (!skipPathPrefix) {
Node initializer;
/* Namespaces get initialized to {}, functions to
* externed versions of their value, and if we can't
* figure out where the value came from we initialize
* it to {}.
*
* Since externs are always exported in sorted order,
* we know that if we export a.b = function() {} and later
* a.b.c = function then a.b will always be in alreadyExportedPaths
* when we emit a.b.c and thus we will never overwrite the function
* exported for a.b with a namespace.
*/
if (isCompletePathPrefix && functionToExport != null) {
initializer = createExternFunction(functionToExport);
} else {
initializer = new Node(Token.OBJECTLIT);
}
appendPathDefinition(pathPrefix, initializer);
}
}
}
}
|