Adds support for importing external helpers.

Author: rbuckton

src/compiler/checker.ts

@@ -17385,6 +17385,11 @@ namespace ts {
 
         function isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean {
             node = getParseTreeNode(node);
+            // Purely synthesized nodes are always emitted.
+            if (node === undefined) {
+                return true;
+            }
+
             if (isAliasSymbolDeclaration(node)) {
                 const symbol = getSymbolOfNode(node);
                 if (symbol && getSymbolLinks(symbol).referenced) {

src/compiler/commandLineParser.ts

@@ -415,6 +415,11 @@ namespace ts {
             name: "strictNullChecks",
             type: "boolean",
             description: Diagnostics.Enable_strict_null_checks
+        },
+        {
+            name: "importHelpers",
+            type: "boolean",
+            description: Diagnostics.Import_emit_helpers_from_tslib
         }
     ];
 

src/compiler/diagnosticMessages.json

@@ -2772,6 +2772,10 @@
         "category": "Error",
         "code": 6131
     },
+    "Import emit helpers from 'tslib'.": {
+        "category": "Message",
+        "code": 6132
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -2106,48 +2106,56 @@ const _super = (function (geti, seti) {
         }
 
         function emitEmitHelpers(node: SourceFile) {
-            let helpersEmitted = false;
-
             // Only emit helpers if the user did not say otherwise.
-            if (!compilerOptions.noEmitHelpers) {
-                // Only Emit __extends function when target ES5.
-                // For target ES6 and above, we can emit classDeclaration as is.
-                if ((languageVersion < ScriptTarget.ES6) && (!extendsEmitted && node.flags & NodeFlags.HasClassExtends)) {
-                    writeLines(extendsHelper);
-                    extendsEmitted = true;
-                    helpersEmitted = true;
-                }
+            if (compilerOptions.noEmitHelpers) {
+                return false;
+            }
 
-                if (compilerOptions.jsx !== JsxEmit.Preserve && !assignEmitted && (node.flags & NodeFlags.HasJsxSpreadAttribute)) {
-                    writeLines(assignHelper);
-                    assignEmitted = true;
-                }
+            // Don't emit helpers if we can import them.
+            if (compilerOptions.importHelpers
+                && (isExternalModule(node) || compilerOptions.isolatedModules)) {
+                return false;
+            }
 
-                if (!decorateEmitted && node.flags & NodeFlags.HasDecorators) {
-                    writeLines(decorateHelper);
-                    if (compilerOptions.emitDecoratorMetadata) {
-                        writeLines(metadataHelper);
-                    }
+            let helpersEmitted = false;
 
-                    decorateEmitted = true;
-                    helpersEmitted = true;
-                }
+            // Only Emit __extends function when target ES5.
+            // For target ES6 and above, we can emit classDeclaration as is.
+            if ((languageVersion < ScriptTarget.ES6) && (!extendsEmitted && node.flags & NodeFlags.HasClassExtends)) {
+                writeLines(extendsHelper);
+                extendsEmitted = true;
+                helpersEmitted = true;
+            }
 
-                if (!paramEmitted && node.flags & NodeFlags.HasParamDecorators) {
-                    writeLines(paramHelper);
-                    paramEmitted = true;
-                    helpersEmitted = true;
-                }
+            if (compilerOptions.jsx !== JsxEmit.Preserve && !assignEmitted && (node.flags & NodeFlags.HasJsxSpreadAttribute)) {
+                writeLines(assignHelper);
+                assignEmitted = true;
+            }
 
-                if (!awaiterEmitted && node.flags & NodeFlags.HasAsyncFunctions) {
-                    writeLines(awaiterHelper);
-                    awaiterEmitted = true;
-                    helpersEmitted = true;
+            if (!decorateEmitted && node.flags & NodeFlags.HasDecorators) {
+                writeLines(decorateHelper);
+                if (compilerOptions.emitDecoratorMetadata) {
+                    writeLines(metadataHelper);
                 }
 
-                if (helpersEmitted) {
-                    writeLine();
-                }
+                decorateEmitted = true;
+                helpersEmitted = true;
+            }
+
+            if (!paramEmitted && node.flags & NodeFlags.HasParamDecorators) {
+                writeLines(paramHelper);
+                paramEmitted = true;
+                helpersEmitted = true;
+            }
+
+            if (!awaiterEmitted && node.flags & NodeFlags.HasAsyncFunctions) {
+                writeLines(awaiterHelper);
+                awaiterEmitted = true;
+                helpersEmitted = true;
+            }
+
+            if (helpersEmitted) {
+                writeLine();
             }
 
             return helpersEmitted;

src/compiler/factory.ts

@@ -800,30 +800,31 @@ namespace ts {
             updated.fileName = node.fileName;
             updated.path = node.path;
             updated.text = node.text;
-            updated.amdDependencies = node.amdDependencies;
-            updated.moduleName = node.moduleName;
-            updated.referencedFiles = node.referencedFiles;
-            updated.typeReferenceDirectives = node.typeReferenceDirectives;
-            updated.languageVariant = node.languageVariant;
-            updated.isDeclarationFile = node.isDeclarationFile;
-            updated.renamedDependencies = node.renamedDependencies;
-            updated.hasNoDefaultLib = node.hasNoDefaultLib;
-            updated.languageVersion = node.languageVersion;
-            updated.scriptKind = node.scriptKind;
-            updated.externalModuleIndicator = node.externalModuleIndicator;
-            updated.commonJsModuleIndicator = node.commonJsModuleIndicator;
-            updated.identifiers = node.identifiers;
-            updated.nodeCount = node.nodeCount;
-            updated.identifierCount = node.identifierCount;
-            updated.symbolCount = node.symbolCount;
-            updated.parseDiagnostics = node.parseDiagnostics;
-            updated.bindDiagnostics = node.bindDiagnostics;
-            updated.lineMap = node.lineMap;
-            updated.classifiableNames = node.classifiableNames;
-            updated.resolvedModules = node.resolvedModules;
-            updated.resolvedTypeReferenceDirectiveNames = node.resolvedTypeReferenceDirectiveNames;
-            updated.imports = node.imports;
-            updated.moduleAugmentations = node.moduleAugmentations;
+            if (node.amdDependencies !== undefined) updated.amdDependencies = node.amdDependencies;
+            if (node.moduleName !== undefined) updated.moduleName = node.moduleName;
+            if (node.referencedFiles !== undefined) updated.referencedFiles = node.referencedFiles;
+            if (node.typeReferenceDirectives !== undefined) updated.typeReferenceDirectives = node.typeReferenceDirectives;
+            if (node.languageVariant !== undefined) updated.languageVariant = node.languageVariant;
+            if (node.isDeclarationFile !== undefined) updated.isDeclarationFile = node.isDeclarationFile;
+            if (node.renamedDependencies !== undefined) updated.renamedDependencies = node.renamedDependencies;
+            if (node.hasNoDefaultLib !== undefined) updated.hasNoDefaultLib = node.hasNoDefaultLib;
+            if (node.languageVersion !== undefined) updated.languageVersion = node.languageVersion;
+            if (node.scriptKind !== undefined) updated.scriptKind = node.scriptKind;
+            if (node.externalModuleIndicator !== undefined) updated.externalModuleIndicator = node.externalModuleIndicator;
+            if (node.commonJsModuleIndicator !== undefined) updated.commonJsModuleIndicator = node.commonJsModuleIndicator;
+            if (node.identifiers !== undefined) updated.identifiers = node.identifiers;
+            if (node.nodeCount !== undefined) updated.nodeCount = node.nodeCount;
+            if (node.identifierCount !== undefined) updated.identifierCount = node.identifierCount;
+            if (node.symbolCount !== undefined) updated.symbolCount = node.symbolCount;
+            if (node.parseDiagnostics !== undefined) updated.parseDiagnostics = node.parseDiagnostics;
+            if (node.bindDiagnostics !== undefined) updated.bindDiagnostics = node.bindDiagnostics;
+            if (node.lineMap !== undefined) updated.lineMap = node.lineMap;
+            if (node.classifiableNames !== undefined) updated.classifiableNames = node.classifiableNames;
+            if (node.resolvedModules !== undefined) updated.resolvedModules = node.resolvedModules;
+            if (node.resolvedTypeReferenceDirectiveNames !== undefined) updated.resolvedTypeReferenceDirectiveNames = node.resolvedTypeReferenceDirectiveNames;
+            if (node.imports !== undefined) updated.imports = node.imports;
+            if (node.moduleAugmentations !== undefined) updated.moduleAugmentations = node.moduleAugmentations;
+            if (node.tslib !== undefined) updated.tslib = node.tslib;
             return updateNode(updated, node);
         }
 
@@ -923,6 +924,12 @@ namespace ts {
         return node;
     }
 
+    export function createNamespaceImport(name: Identifier): NamespaceImport {
+        const node = <NamespaceImport>createNode(SyntaxKind.NamespaceImport);
+        node.name = name;
+        return node;
+    }
+
     export function createNamedImports(elements: NodeArray<ImportSpecifier>, location?: TextRange): NamedImports {
         const node = <NamedImports>createNode(SyntaxKind.NamedImports, location);
         node.elements = elements;
@@ -1058,9 +1065,15 @@ namespace ts {
 
     // Helpers
 
-    export function createExtendsHelper(name: Identifier) {
+    export function createHelperName(tslib: Identifier, name: string) {
+        return tslib
+            ? createPropertyAccess(tslib, name)
+            : createIdentifier(name);
+    }
+
+    export function createExtendsHelper(tslib: Identifier, name: Identifier) {
         return createCall(
-            createIdentifier("__extends"),
+            createHelperName(tslib, "__extends"),
             /*typeArguments*/ undefined,
             [
                 name,
@@ -1069,17 +1082,17 @@ namespace ts {
         );
     }
 
-    export function createAssignHelper(attributesSegments: Expression[]) {
+    export function createAssignHelper(tslib: Identifier, attributesSegments: Expression[]) {
         return createCall(
-            createIdentifier("__assign"),
+            createHelperName(tslib, "__assign"),
             /*typeArguments*/ undefined,
             attributesSegments
         );
     }
 
-    export function createParamHelper(expression: Expression, parameterOffset: number, location?: TextRange) {
+    export function createParamHelper(tslib: Identifier, expression: Expression, parameterOffset: number, location?: TextRange) {
         return createCall(
-            createIdentifier("__param"),
+            createHelperName(tslib, "__param"),
             /*typeArguments*/ undefined,
             [
                 createLiteral(parameterOffset),
@@ -1089,9 +1102,9 @@ namespace ts {
         );
     }
 
-    export function createMetadataHelper(metadataKey: string, metadataValue: Expression) {
+    export function createMetadataHelper(tslib: Identifier, metadataKey: string, metadataValue: Expression) {
         return createCall(
-            createIdentifier("__metadata"),
+            createHelperName(tslib, "__metadata"),
             /*typeArguments*/ undefined,
             [
                 createLiteral(metadataKey),
@@ -1100,7 +1113,7 @@ namespace ts {
         );
     }
 
-    export function createDecorateHelper(decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) {
+    export function createDecorateHelper(tslib: Identifier, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) {
         const argumentsArray: Expression[] = [];
         argumentsArray.push(createArrayLiteral(decoratorExpressions, /*location*/ undefined, /*multiLine*/ true));
         argumentsArray.push(target);
@@ -1111,12 +1124,12 @@ namespace ts {
             }
         }
 
-        return createCall(createIdentifier("__decorate"), /*typeArguments*/ undefined, argumentsArray, location);
+        return createCall(createHelperName(tslib, "__decorate"), /*typeArguments*/ undefined, argumentsArray, location);
     }
 
-    export function createAwaiterHelper(hasLexicalArguments: boolean, promiseConstructor: EntityName | Expression, body: Block) {
+    export function createAwaiterHelper(tslib: Identifier, hasLexicalArguments: boolean, promiseConstructor: EntityName | Expression, body: Block) {
         return createCall(
-            createIdentifier("__awaiter"),
+            createHelperName(tslib, "__awaiter"),
             /*typeArguments*/ undefined,
             [
                 createThis(),
@@ -1920,7 +1933,8 @@ namespace ts {
     export function getLocalNameForExternalImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration, sourceFile: SourceFile): Identifier {
         const namespaceDeclaration = getNamespaceDeclarationNode(node);
         if (namespaceDeclaration && !isDefaultImport(node)) {
-            return createIdentifier(getSourceTextOfNodeFromSourceFile(sourceFile, namespaceDeclaration.name));
+            const name = namespaceDeclaration.name;
+            return isGeneratedIdentifier(name) ? name : createIdentifier(getSourceTextOfNodeFromSourceFile(sourceFile, namespaceDeclaration.name));
         }
         if (node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).importClause) {
             return getGeneratedNameForNode(node);

src/compiler/transformers/es6.ts

@@ -702,7 +702,7 @@ namespace ts {
             if (extendsClauseElement) {
                 statements.push(
                     createStatement(
-                        createExtendsHelper(getDeclarationName(node)),
+                        createExtendsHelper(currentSourceFile.tslib, getDeclarationName(node)),
                         /*location*/ extendsClauseElement
                     )
                 );

src/compiler/transformers/jsx.ts

@@ -7,6 +7,7 @@ namespace ts {
 
     export function transformJsx(context: TransformationContext) {
         const compilerOptions = context.getCompilerOptions();
+        let currentSourceFile: SourceFile;
         return transformSourceFile;
 
         /**
@@ -15,7 +16,10 @@ namespace ts {
          * @param node A SourceFile node.
          */
         function transformSourceFile(node: SourceFile) {
-            return visitEachChild(node, visitor, context);
+            currentSourceFile = node;
+            node = visitEachChild(node, visitor, context);
+            currentSourceFile = undefined;
+            return node;
         }
 
         function visitor(node: Node): VisitResult<Node> {
@@ -102,7 +106,7 @@ namespace ts {
                 // Either emit one big object literal (no spread attribs), or
                 // a call to the __assign helper.
                 objectProperties = singleOrUndefined(segments)
-                    || createAssignHelper(segments);
+                    || createAssignHelper(currentSourceFile.tslib, segments);
             }
 
             const element = createReactCreateElement(