@ngtools/webpack 8.0.2 → 8.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngtools/webpack",
-  "version": "8.0.2",
+  "version": "8.0.6",
   "description": "Webpack plugin that AoT compiles your Angular components and modules.",
   "main": "./src/index.js",
   "typings": "src/index.d.ts",
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/core": "8.0.2",
+    "@angular-devkit/core": "8.0.6",
     "enhanced-resolve": "4.1.0",
     "rxjs": "6.4.0",
     "tree-kill": "1.2.1",

package/src/angular_compiler_plugin.d.ts

@@ -21,6 +21,7 @@ export declare class AngularCompilerPlugin {
     private _platform;
     private _JitMode;
     private _emitSkipped;
+    private _hadFullJitEmit;
     private _changedFileExtensions;
     private _firstRun;
     private _donePromise;

package/src/angular_compiler_plugin.js

@@ -25,6 +25,7 @@ const paths_plugin_1 = require("./paths-plugin");
 const resource_loader_1 = require("./resource_loader");
 const transformers_1 = require("./transformers");
 const ast_helpers_1 = require("./transformers/ast_helpers");
+const ctor_parameters_1 = require("./transformers/ctor-parameters");
 const type_checker_1 = require("./type_checker");
 const type_checker_messages_1 = require("./type_checker_messages");
 const utils_1 = require("./utils");
@@ -626,7 +627,6 @@ class AngularCompilerPlugin {
     }
     async _make(compilation) {
         benchmark_1.time('AngularCompilerPlugin._make');
-        this._emitSkipped = true;
         // tslint:disable-next-line:no-any
         if (compilation._ngToolsWebpackPluginInstance) {
             throw new Error('An @ngtools/webpack plugin already exist for this compilation.');
@@ -681,6 +681,9 @@ class AngularCompilerPlugin {
         if (this._JitMode) {
             // Replace resources in JIT.
             this._transformers.push(transformers_1.replaceResources(isAppPath, getTypeChecker, this._options.directTemplateLoading));
+            // Downlevel constructor parameters for DI support
+            // This is required to support forwardRef in ES2015 due to TDZ issues
+            this._transformers.push(ctor_parameters_1.downlevelConstructorParameters(getTypeChecker));
         }
         else {
             // Remove unneeded angular decorators.
@@ -919,8 +922,9 @@ class AngularCompilerPlugin {
                 }
                 allDiagnostics.push(...gather_diagnostics_1.gatherDiagnostics(tsProgram, this._JitMode, 'AngularCompilerPlugin._emit.ts', diagMode));
                 if (!gather_diagnostics_1.hasErrors(allDiagnostics)) {
-                    if (this._firstRun || changedTsFiles.size > 20 || this._emitSkipped) {
+                    if (this._firstRun || changedTsFiles.size > 20 || !this._hadFullJitEmit) {
                         emitResult = tsProgram.emit(undefined, undefined, undefined, undefined, { before: this._transformers });
+                        this._hadFullJitEmit = !emitResult.emitSkipped;
                         allDiagnostics.push(...emitResult.diagnostics);
                     }
                     else {

package/src/interfaces.d.ts

@@ -7,6 +7,7 @@
  */
 /// <reference types="node" />
 import { logging, virtualFs } from '@angular-devkit/core';
+import { CompilerOptions } from '@angular/compiler-cli';
 import * as fs from 'fs';
 import * as ts from 'typescript';
 export declare enum PLATFORM {
@@ -48,7 +49,7 @@ export interface AngularCompilerPluginOptions {
     };
     additionalLazyModuleResources?: string[];
     contextElementDependencyConstructor?: ContextElementDependencyConstructor;
-    compilerOptions?: ts.CompilerOptions;
+    compilerOptions?: CompilerOptions;
     host?: virtualFs.Host<fs.Stats>;
     platformTransformers?: ts.TransformerFactory<ts.SourceFile>[];
 }

package/src/transformers/ctor-parameters.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+export declare function downlevelConstructorParameters(getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory<ts.SourceFile>;
+/**
+ * Transformer factory for the decorator downlevel transformer. See fileoverview for details.
+ */
+export declare function decoratorDownlevelTransformer(typeChecker: ts.TypeChecker, diagnostics: ts.Diagnostic[]): (context: ts.TransformationContext) => ts.Transformer<ts.SourceFile>;

package/src/transformers/ctor-parameters.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const ts = require("typescript");
+function downlevelConstructorParameters(getTypeChecker) {
+    return (context) => {
+        const transformer = decoratorDownlevelTransformer(getTypeChecker(), []);
+        return transformer(context);
+    };
+}
+exports.downlevelConstructorParameters = downlevelConstructorParameters;
+// The following is sourced from tsickle with local modifications
+// Only the creation of `ctorParameters` is retained
+// tslint:disable-next-line:max-line-length
+// https://github.com/angular/tsickle/blob/0ceb7d6bc47f6945a6c4c09689f1388eb48f5c07/src/decorator_downlevel_transformer.ts
+//
+/**
+ * Extracts the type of the decorator (the function or expression invoked), as well as all the
+ * arguments passed to the decorator. Returns an AST with the form:
+ *
+ *     // For @decorator(arg1, arg2)
+ *     { type: decorator, args: [arg1, arg2] }
+ */
+function extractMetadataFromSingleDecorator(decorator, diagnostics) {
+    const metadataProperties = [];
+    const expr = decorator.expression;
+    switch (expr.kind) {
+        case ts.SyntaxKind.Identifier:
+            // The decorator was a plain @Foo.
+            metadataProperties.push(ts.createPropertyAssignment('type', expr));
+            break;
+        case ts.SyntaxKind.CallExpression:
+            // The decorator was a call, like @Foo(bar).
+            const call = expr;
+            metadataProperties.push(ts.createPropertyAssignment('type', call.expression));
+            if (call.arguments.length) {
+                const args = [];
+                for (const arg of call.arguments) {
+                    args.push(arg);
+                }
+                const argsArrayLiteral = ts.createArrayLiteral(args);
+                argsArrayLiteral.elements.hasTrailingComma = true;
+                metadataProperties.push(ts.createPropertyAssignment('args', argsArrayLiteral));
+            }
+            break;
+        default:
+            diagnostics.push({
+                file: decorator.getSourceFile(),
+                start: decorator.getStart(),
+                length: decorator.getEnd() - decorator.getStart(),
+                messageText: `${ts.SyntaxKind[decorator.kind]} not implemented in gathering decorator metadata`,
+                category: ts.DiagnosticCategory.Error,
+                code: 0,
+            });
+            break;
+    }
+    return ts.createObjectLiteral(metadataProperties);
+}
+/**
+ * createCtorParametersClassProperty creates a static 'ctorParameters' property containing
+ * downleveled decorator information.
+ *
+ * The property contains an arrow function that returns an array of object literals of the shape:
+ *     static ctorParameters = () => [{
+ *       type: SomeClass|undefined,  // the type of the param that's decorated, if it's a value.
+ *       decorators: [{
+ *         type: DecoratorFn,  // the type of the decorator that's invoked.
+ *         args: [ARGS],       // the arguments passed to the decorator.
+ *       }]
+ *     }];
+ */
+function createCtorParametersClassProperty(diagnostics, entityNameToExpression, ctorParameters, typeChecker) {
+    const params = [];
+    for (const ctorParam of ctorParameters) {
+        if (!ctorParam.type && ctorParam.decorators.length === 0) {
+            params.push(ts.createNull());
+            continue;
+        }
+        const paramType = ctorParam.type
+            ? typeReferenceToExpression(entityNameToExpression, ctorParam.type, typeChecker)
+            : undefined;
+        const members = [
+            ts.createPropertyAssignment('type', paramType || ts.createIdentifier('undefined')),
+        ];
+        const decorators = [];
+        for (const deco of ctorParam.decorators) {
+            decorators.push(extractMetadataFromSingleDecorator(deco, diagnostics));
+        }
+        if (decorators.length) {
+            members.push(ts.createPropertyAssignment('decorators', ts.createArrayLiteral(decorators)));
+        }
+        params.push(ts.createObjectLiteral(members));
+    }
+    const initializer = ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.createArrayLiteral(params, true));
+    const ctorProp = ts.createProperty(undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'ctorParameters', undefined, undefined, initializer);
+    return ctorProp;
+}
+/**
+ * Returns an expression representing the (potentially) value part for the given node.
+ *
+ * This is a partial re-implementation of TypeScript's serializeTypeReferenceNode. This is a
+ * workaround for https://github.com/Microsoft/TypeScript/issues/17516 (serializeTypeReferenceNode
+ * not being exposed). In practice this implementation is sufficient for Angular's use of type
+ * metadata.
+ */
+function typeReferenceToExpression(entityNameToExpression, node, typeChecker) {
+    let kind = node.kind;
+    if (ts.isLiteralTypeNode(node)) {
+        // Treat literal types like their base type (boolean, string, number).
+        kind = node.literal.kind;
+    }
+    switch (kind) {
+        case ts.SyntaxKind.FunctionType:
+        case ts.SyntaxKind.ConstructorType:
+            return ts.createIdentifier('Function');
+        case ts.SyntaxKind.ArrayType:
+        case ts.SyntaxKind.TupleType:
+            return ts.createIdentifier('Array');
+        case ts.SyntaxKind.TypePredicate:
+        case ts.SyntaxKind.TrueKeyword:
+        case ts.SyntaxKind.FalseKeyword:
+        case ts.SyntaxKind.BooleanKeyword:
+            return ts.createIdentifier('Boolean');
+        case ts.SyntaxKind.StringLiteral:
+        case ts.SyntaxKind.StringKeyword:
+            return ts.createIdentifier('String');
+        case ts.SyntaxKind.ObjectKeyword:
+            return ts.createIdentifier('Object');
+        case ts.SyntaxKind.NumberKeyword:
+        case ts.SyntaxKind.NumericLiteral:
+            return ts.createIdentifier('Number');
+        case ts.SyntaxKind.TypeReference:
+            const typeRef = node;
+            let typeSymbol = typeChecker.getSymbolAtLocation(typeRef.typeName);
+            if (typeSymbol && typeSymbol.flags & ts.SymbolFlags.Alias) {
+                typeSymbol = typeChecker.getAliasedSymbol(typeSymbol);
+            }
+            if (!typeSymbol || !(typeSymbol.flags & ts.SymbolFlags.Value)) {
+                return undefined;
+            }
+            const type = typeChecker.getTypeOfSymbolAtLocation(typeSymbol, typeRef);
+            if (!type || typeChecker.getSignaturesOfType(type, ts.SignatureKind.Construct).length === 0) {
+                return undefined;
+            }
+            // Ignore any generic types, just return the base type.
+            return entityNameToExpression(typeRef.typeName);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Transformer factory for the decorator downlevel transformer. See fileoverview for details.
+ */
+function decoratorDownlevelTransformer(typeChecker, diagnostics) {
+    return (context) => {
+        const parameterTypeSymbols = new Set();
+        /**
+         * Converts an EntityName (from a type annotation) to an expression (accessing a value).
+         *
+         * For a given ts.EntityName, this walks depth first to find the leftmost ts.Identifier, then
+         * converts the path into property accesses.
+         *
+         */
+        function entityNameToExpression(name) {
+            if (ts.isIdentifier(name)) {
+                const typeSymbol = typeChecker.getSymbolAtLocation(name);
+                if (typeSymbol) {
+                    parameterTypeSymbols.add(typeSymbol);
+                }
+                // Based on TS's strategy to allow the checker to reach this identifier
+                // tslint:disable-next-line:max-line-length
+                // https://github.com/microsoft/TypeScript/blob/7f47a08a5e9874f0f97a667bd81eebddec61247c/src/compiler/transformers/ts.ts#L2093
+                const exp = ts.getMutableClone(name);
+                exp.flags &= ~ts.NodeFlags.Synthesized;
+                exp.original = undefined;
+                exp.parent = ts.getParseTreeNode(name.getSourceFile());
+                return exp;
+            }
+            const ref = entityNameToExpression(name.left);
+            if (!ref) {
+                return undefined;
+            }
+            return ts.createPropertyAccess(ref, name.right);
+        }
+        function classMemberVisitor(node) {
+            if (!ts.isConstructorDeclaration(node) || !node.body) {
+                return visitor(node);
+            }
+            const parametersInfo = [];
+            for (const param of node.parameters) {
+                const paramInfo = { decorators: [], type: null };
+                for (const decorator of param.decorators || []) {
+                    paramInfo.decorators.push(decorator);
+                }
+                if (param.type) {
+                    // param has a type provided, e.g. "foo: Bar".
+                    // The type will be emitted as a value expression in entityNameToExpression, which takes
+                    // care not to emit anything for types that cannot be expressed as a value (e.g.
+                    // interfaces).
+                    paramInfo.type = param.type;
+                }
+                parametersInfo.push(paramInfo);
+            }
+            if (parametersInfo.length > 0) {
+                const ctorProperty = createCtorParametersClassProperty(diagnostics, entityNameToExpression, parametersInfo, typeChecker);
+                return [node, ctorProperty];
+            }
+            else {
+                return node;
+            }
+        }
+        function visitor(node) {
+            if (ts.isClassDeclaration(node)) {
+                return ts.updateClassDeclaration(node, node.decorators, node.modifiers, node.name, node.typeParameters, node.heritageClauses, ts.visitNodes(node.members, classMemberVisitor));
+            }
+            else {
+                return ts.visitEachChild(node, visitor, context);
+            }
+        }
+        return (sf) => {
+            parameterTypeSymbols.clear();
+            return ts.visitEachChild(visitor(sf), function visitImports(node) {
+                if ((ts.isImportSpecifier(node) || ts.isNamespaceImport(node) || ts.isImportClause(node)) &&
+                    node.name) {
+                    const importSymbol = typeChecker.getSymbolAtLocation(node.name);
+                    if (importSymbol && parameterTypeSymbols.has(importSymbol)) {
+                        // Using a clone prevents TS from removing the import specifier
+                        return ts.getMutableClone(node);
+                    }
+                }
+                return ts.visitEachChild(node, visitImports, context);
+            }, context);
+        };
+    };
+}
+exports.decoratorDownlevelTransformer = decoratorDownlevelTransformer;

package/src/transformers/make_transform.js

@@ -10,50 +10,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ts = require("typescript");
 const elide_imports_1 = require("./elide_imports");
 const interfaces_1 = require("./interfaces");
-// Typescript below 2.7.0 needs a workaround.
-const tsVersionParts = ts.version.split('.').map(p => Number(p));
-const visitEachChild = tsVersionParts[0] <= 2 && tsVersionParts[1] < 7
-    ? visitEachChildWorkaround
-    : ts.visitEachChild;
 function makeTransform(standardTransform, getTypeChecker) {
     return (context) => {
         const transformer = (sf) => {
             const ops = standardTransform(sf);
-            const removeOps = ops
-                .filter((op) => op.kind === interfaces_1.OPERATION_KIND.Remove);
-            const addOps = ops.filter((op) => op.kind === interfaces_1.OPERATION_KIND.Add);
-            const replaceOps = ops
-                .filter((op) => op.kind === interfaces_1.OPERATION_KIND.Replace);
+            const removeOps = ops.filter(op => op.kind === interfaces_1.OPERATION_KIND.Remove);
+            const addOps = ops.filter(op => op.kind === interfaces_1.OPERATION_KIND.Add);
+            const replaceOps = ops.filter(op => op.kind === interfaces_1.OPERATION_KIND.Replace);
             // If nodes are removed, elide the imports as well.
             // Mainly a workaround for https://github.com/Microsoft/TypeScript/issues/17552.
             // WARNING: this assumes that replaceOps DO NOT reuse any of the nodes they are replacing.
             // This is currently true for transforms that use replaceOps (replace_bootstrap and
             // replace_resources), but may not be true for new transforms.
             if (getTypeChecker && removeOps.length + replaceOps.length > 0) {
-                const removedNodes = removeOps.concat(replaceOps).map((op) => op.target);
+                const removedNodes = removeOps.concat(replaceOps).map(op => op.target);
                 removeOps.push(...elide_imports_1.elideImports(sf, removedNodes, getTypeChecker));
             }
-            const visitor = (node) => {
+            const visitor = node => {
                 let modified = false;
                 let modifiedNodes = [node];
                 // Check if node should be dropped.
-                if (removeOps.find((op) => op.target === node)) {
+                if (removeOps.find(op => op.target === node)) {
                     modifiedNodes = [];
                     modified = true;
                 }
                 // Check if node should be replaced (only replaces with first op found).
-                const replace = replaceOps.find((op) => op.target === node);
+                const replace = replaceOps.find(op => op.target === node);
                 if (replace) {
                     modifiedNodes = [replace.replacement];
                     modified = true;
                 }
                 // Check if node should be added to.
-                const add = addOps.filter((op) => op.target === node);
+                const add = addOps.filter(op => op.target === node);
                 if (add.length > 0) {
                     modifiedNodes = [
-                        ...add.filter((op) => op.before).map(((op) => op.before)),
+                        ...add.filter(op => op.before).map(op => op.before),
                         ...modifiedNodes,
-                        ...add.filter((op) => op.after).map(((op) => op.after)),
+                        ...add.filter(op => op.after).map(op => op.after),
                     ];
                     modified = true;
                 }
@@ -63,7 +56,7 @@ function makeTransform(standardTransform, getTypeChecker) {
                 }
                 else {
                     // Otherwise return node as is and visit children.
-                    return visitEachChild(node, visitor, context);
+                    return ts.visitEachChild(node, visitor, context);
                 }
             };
             // Don't visit the sourcefile at all if we don't have ops for it.
@@ -72,7 +65,7 @@ function makeTransform(standardTransform, getTypeChecker) {
             }
             const result = ts.visitNode(sf, visitor);
             // If we removed any decorators, we need to clean up the decorator arrays.
-            if (removeOps.some((op) => op.target.kind === ts.SyntaxKind.Decorator)) {
+            if (removeOps.some(op => op.target.kind === ts.SyntaxKind.Decorator)) {
                 cleanupDecorators(result);
             }
             return result;
@@ -81,43 +74,11 @@ function makeTransform(standardTransform, getTypeChecker) {
     };
 }
 exports.makeTransform = makeTransform;
-/**
- * This is a version of `ts.visitEachChild` that works that calls our version
- * of `updateSourceFileNode`, so that typescript doesn't lose type information
- * for property decorators.
- * See https://github.com/Microsoft/TypeScript/issues/17384 (fixed by
- * https://github.com/Microsoft/TypeScript/pull/20314 and released in TS 2.7.0) and
- * https://github.com/Microsoft/TypeScript/issues/17551 (fixed by
- * https://github.com/Microsoft/TypeScript/pull/18051 and released on TS 2.5.0).
- */
-function visitEachChildWorkaround(node, visitor, context) {
-    if (node.kind === ts.SyntaxKind.SourceFile) {
-        const sf = node;
-        const statements = ts.visitLexicalEnvironment(sf.statements, visitor, context);
-        if (statements === sf.statements) {
-            return sf;
-        }
-        // Note: Need to clone the original file (and not use `ts.updateSourceFileNode`)
-        // as otherwise TS fails when resolving types for decorators.
-        const sfClone = ts.getMutableClone(sf);
-        sfClone.statements = statements;
-        return sfClone;
-    }
-    return ts.visitEachChild(node, visitor, context);
-}
-// 1) If TS sees an empty decorator array, it will still emit a `__decorate` call.
+// If TS sees an empty decorator array, it will still emit a `__decorate` call.
 //    This seems to be a TS bug.
-// 2) Also ensure nodes with modified decorators have parents
-//    built in TS transformers assume certain nodes have parents (fixed in TS 2.7+)
 function cleanupDecorators(node) {
-    if (node.decorators) {
-        if (node.decorators.length == 0) {
-            node.decorators = undefined;
-        }
-        else if (node.parent == undefined) {
-            const originalNode = ts.getParseTreeNode(node);
-            node.parent = originalNode.parent;
-        }
+    if (node.decorators && node.decorators.length === 0) {
+        node.decorators = undefined;
     }
     ts.forEachChild(node, node => cleanupDecorators(node));
 }