@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

package/src/ngtsc/annotations/src/diagnostics.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/diagnostics" />
+import * as ts from 'typescript';
+import { Reference } from '../../imports';
+import { InjectableClassRegistry, MetadataReader } from '../../metadata';
+import { PartialEvaluator } from '../../partial_evaluator';
+import { ClassDeclaration, ReflectionHost } from '../../reflection';
+import { LocalModuleScopeRegistry } from '../../scope';
+/**
+ * Gets the diagnostics for a set of provider classes.
+ * @param providerClasses Classes that should be checked.
+ * @param providersDeclaration Node that declares the providers array.
+ * @param registry Registry that keeps track of the registered injectable classes.
+ */
+export declare function getProviderDiagnostics(providerClasses: Set<Reference<ClassDeclaration>>, providersDeclaration: ts.Expression, registry: InjectableClassRegistry): ts.Diagnostic[];
+export declare function getDirectiveDiagnostics(node: ClassDeclaration, reader: MetadataReader, evaluator: PartialEvaluator, reflector: ReflectionHost, scopeRegistry: LocalModuleScopeRegistry, kind: string): ts.Diagnostic[] | null;
+export declare function checkInheritanceOfDirective(node: ClassDeclaration, reader: MetadataReader, reflector: ReflectionHost, evaluator: PartialEvaluator): ts.Diagnostic | null;

package/src/ngtsc/annotations/src/diagnostics.js

@@ -0,0 +1,123 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngtsc/annotations/src/diagnostics", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/src/ngtsc/annotations/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics");
+    var imports_1 = require("@angular/compiler-cli/src/ngtsc/imports");
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/annotations/src/util");
+    /**
+     * Gets the diagnostics for a set of provider classes.
+     * @param providerClasses Classes that should be checked.
+     * @param providersDeclaration Node that declares the providers array.
+     * @param registry Registry that keeps track of the registered injectable classes.
+     */
+    function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
+        var e_1, _a;
+        var diagnostics = [];
+        try {
+            for (var providerClasses_1 = tslib_1.__values(providerClasses), providerClasses_1_1 = providerClasses_1.next(); !providerClasses_1_1.done; providerClasses_1_1 = providerClasses_1.next()) {
+                var provider = providerClasses_1_1.value;
+                if (registry.isInjectable(provider.node)) {
+                    continue;
+                }
+                var contextNode = provider.getOriginForDiagnostics(providersDeclaration);
+                diagnostics.push(diagnostics_1.makeDiagnostic(diagnostics_1.ErrorCode.UNDECORATED_PROVIDER, contextNode, "The class '" + provider.node.name.text + "' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.\n\nEither add the @Injectable() decorator to '" + provider.node.name.text + "', or configure a different provider (such as a provider with 'useFactory').\n", [{ node: provider.node, messageText: "'" + provider.node.name.text + "' is declared here." }]));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (providerClasses_1_1 && !providerClasses_1_1.done && (_a = providerClasses_1.return)) _a.call(providerClasses_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return diagnostics;
+    }
+    exports.getProviderDiagnostics = getProviderDiagnostics;
+    function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegistry, kind) {
+        var diagnostics = [];
+        var addDiagnostics = function (more) {
+            if (more === null) {
+                return;
+            }
+            else if (diagnostics === null) {
+                diagnostics = Array.isArray(more) ? more : [more];
+            }
+            else if (Array.isArray(more)) {
+                diagnostics.push.apply(diagnostics, tslib_1.__spread(more));
+            }
+            else {
+                diagnostics.push(more);
+            }
+        };
+        var duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);
+        if (duplicateDeclarations !== null) {
+            addDiagnostics(util_1.makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
+        }
+        addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));
+        return diagnostics;
+    }
+    exports.getDirectiveDiagnostics = getDirectiveDiagnostics;
+    function checkInheritanceOfDirective(node, reader, reflector, evaluator) {
+        if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
+            // We should skip nodes that aren't classes. If a constructor exists, then no base class
+            // definition is required on the runtime side - it's legal to inherit from any class.
+            return null;
+        }
+        // The extends clause is an expression which can be as dynamic as the user wants. Try to
+        // evaluate it, but fall back on ignoring the clause if it can't be understood. This is a View
+        // Engine compatibility hack: View Engine ignores 'extends' expressions that it cannot understand.
+        var baseClass = util_1.readBaseClass(node, reflector, evaluator);
+        while (baseClass !== null) {
+            if (baseClass === 'dynamic') {
+                return null;
+            }
+            // We can skip the base class if it has metadata.
+            var baseClassMeta = reader.getDirectiveMetadata(baseClass);
+            if (baseClassMeta !== null) {
+                return null;
+            }
+            // If the base class has a blank constructor we can skip it since it can't be using DI.
+            var baseClassConstructorParams = reflector.getConstructorParameters(baseClass.node);
+            var newParentClass = util_1.readBaseClass(baseClass.node, reflector, evaluator);
+            if (baseClassConstructorParams !== null && baseClassConstructorParams.length > 0) {
+                // This class has a non-trivial constructor, that's an error!
+                return getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader);
+            }
+            else if (baseClassConstructorParams !== null || newParentClass === null) {
+                // This class has a trivial constructor, or no constructor + is the
+                // top of the inheritance chain, so it's okay.
+                return null;
+            }
+            // Go up the chain and continue
+            baseClass = newParentClass;
+        }
+        return null;
+    }
+    exports.checkInheritanceOfDirective = checkInheritanceOfDirective;
+    function getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader) {
+        var subclassMeta = reader.getDirectiveMetadata(new imports_1.Reference(node));
+        var dirOrComp = subclassMeta.isComponent ? 'Component' : 'Directive';
+        var baseClassName = baseClass.debugName;
+        return diagnostics_1.makeDiagnostic(diagnostics_1.ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name, "The " + dirOrComp.toLowerCase() + " " + node.name.text + " inherits its constructor from " + baseClassName + ", " +
+            "but the latter does not have an Angular decorator of its own. Dependency injection will not be able to " +
+            ("resolve the parameters of " + baseClassName + "'s constructor. Either add a @Directive decorator ") +
+            ("to " + baseClassName + ", or add an explicit constructor to " + node.name.text + "."));
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/annotations/src/diagnostics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {ErrorCode, makeDiagnostic} from '../../diagnostics';\nimport {Reference} from '../../imports';\nimport {InjectableClassRegistry, MetadataReader} from '../../metadata';\nimport {PartialEvaluator} from '../../partial_evaluator';\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {LocalModuleScopeRegistry} from '../../scope';\n\nimport {makeDuplicateDeclarationError, readBaseClass} from './util';\n\n/**\n * Gets the diagnostics for a set of provider classes.\n * @param providerClasses Classes that should be checked.\n * @param providersDeclaration Node that declares the providers array.\n * @param registry Registry that keeps track of the registered injectable classes.\n */\nexport function getProviderDiagnostics(\n    providerClasses: Set<Reference<ClassDeclaration>>, providersDeclaration: ts.Expression,\n    registry: InjectableClassRegistry): ts.Diagnostic[] {\n  const diagnostics: ts.Diagnostic[] = [];\n\n  for (const provider of providerClasses) {\n    if (registry.isInjectable(provider.node)) {\n      continue;\n    }\n\n    const contextNode = provider.getOriginForDiagnostics(providersDeclaration);\n    diagnostics.push(makeDiagnostic(\n        ErrorCode.UNDECORATED_PROVIDER, contextNode,\n        `The class '${provider.node.name.text}' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.\n\nEither add the @Injectable() decorator to '${provider.node.name.text}', or configure a different provider (such as a provider with 'useFactory').\n`,\n        [{node: provider.node, messageText: `'${provider.node.name.text}' is declared here.`}]));\n  }\n\n  return diagnostics;\n}\n\nexport function getDirectiveDiagnostics(\n    node: ClassDeclaration, reader: MetadataReader, evaluator: PartialEvaluator,\n    reflector: ReflectionHost, scopeRegistry: LocalModuleScopeRegistry,\n    kind: string): ts.Diagnostic[]|null {\n  let diagnostics: ts.Diagnostic[]|null = [];\n\n  const addDiagnostics = (more: ts.Diagnostic | ts.Diagnostic[] | null) => {\n    if (more === null) {\n      return;\n    } else if (diagnostics === null) {\n      diagnostics = Array.isArray(more) ? more : [more];\n    } else if (Array.isArray(more)) {\n      diagnostics.push(...more);\n    } else {\n      diagnostics.push(more);\n    }\n  };\n\n  const duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);\n\n  if (duplicateDeclarations !== null) {\n    addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));\n  }\n\n  addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));\n  return diagnostics;\n}\n\nexport function checkInheritanceOfDirective(\n    node: ClassDeclaration, reader: MetadataReader, reflector: ReflectionHost,\n    evaluator: PartialEvaluator): ts.Diagnostic|null {\n  if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {\n    // We should skip nodes that aren't classes. If a constructor exists, then no base class\n    // definition is required on the runtime side - it's legal to inherit from any class.\n    return null;\n  }\n\n  // The extends clause is an expression which can be as dynamic as the user wants. Try to\n  // evaluate it, but fall back on ignoring the clause if it can't be understood. This is a View\n  // Engine compatibility hack: View Engine ignores 'extends' expressions that it cannot understand.\n  let baseClass = readBaseClass(node, reflector, evaluator);\n\n  while (baseClass !== null) {\n    if (baseClass === 'dynamic') {\n      return null;\n    }\n\n    // We can skip the base class if it has metadata.\n    const baseClassMeta = reader.getDirectiveMetadata(baseClass);\n    if (baseClassMeta !== null) {\n      return null;\n    }\n\n    // If the base class has a blank constructor we can skip it since it can't be using DI.\n    const baseClassConstructorParams = reflector.getConstructorParameters(baseClass.node);\n    const newParentClass = readBaseClass(baseClass.node, reflector, evaluator);\n\n    if (baseClassConstructorParams !== null && baseClassConstructorParams.length > 0) {\n      // This class has a non-trivial constructor, that's an error!\n      return getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader);\n    } else if (baseClassConstructorParams !== null || newParentClass === null) {\n      // This class has a trivial constructor, or no constructor + is the\n      // top of the inheritance chain, so it's okay.\n      return null;\n    }\n\n    // Go up the chain and continue\n    baseClass = newParentClass;\n  }\n\n  return null;\n}\n\nfunction getInheritedUndecoratedCtorDiagnostic(\n    node: ClassDeclaration, baseClass: Reference, reader: MetadataReader) {\n  const subclassMeta = reader.getDirectiveMetadata(new Reference(node)) !;\n  const dirOrComp = subclassMeta.isComponent ? 'Component' : 'Directive';\n  const baseClassName = baseClass.debugName;\n\n  return makeDiagnostic(\n      ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name,\n      `The ${dirOrComp.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, ` +\n          `but the latter does not have an Angular decorator of its own. Dependency injection will not be able to ` +\n          `resolve the parameters of ${baseClassName}'s constructor. Either add a @Directive decorator ` +\n          `to ${baseClassName}, or add an explicit constructor to ${node.name.text}.`);\n}\n"]}

package/src/ngtsc/annotations/src/directive.d.ts

@@ -8,27 +8,38 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/annotations/src/directive" />
 import { ConstantPool, ParsedHostBindings, R3DirectiveMetadata, R3QueryMetadata, Statement } from '@angular/compiler';
 import * as ts from 'typescript';
-import { DefaultImportRecorder } from '../../imports';
-import { MetadataRegistry } from '../../metadata';
+import { DefaultImportRecorder, Reference } from '../../imports';
+import { InjectableClassRegistry, MetadataReader, MetadataRegistry } from '../../metadata';
+import { extractDirectiveGuards } from '../../metadata/src/util';
 import { PartialEvaluator } from '../../partial_evaluator';
 import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../reflection';
-import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence } from '../../transform';
+import { LocalModuleScopeRegistry } from '../../scope';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFlags, HandlerPrecedence, ResolveResult } from '../../transform';
 export interface DirectiveHandlerData {
+    baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
+    guards: ReturnType<typeof extractDirectiveGuards>;
     meta: R3DirectiveMetadata;
     metadataStmt: Statement | null;
+    providersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
 }
-export declare class DirectiveDecoratorHandler implements DecoratorHandler<DirectiveHandlerData, Decorator | null> {
+export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decorator | null, DirectiveHandlerData, unknown> {
     private reflector;
     private evaluator;
     private metaRegistry;
+    private scopeRegistry;
+    private metaReader;
     private defaultImportRecorder;
+    private injectableRegistry;
     private isCore;
     private annotateForClosureCompiler;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, defaultImportRecorder: DefaultImportRecorder, isCore: boolean, annotateForClosureCompiler: boolean);
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, defaultImportRecorder: DefaultImportRecorder, injectableRegistry: InjectableClassRegistry, isCore: boolean, annotateForClosureCompiler: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
+    readonly name: string;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
-    analyze(node: ClassDeclaration, decorator: Decorator | null, flags?: HandlerFlags): AnalysisOutput<DirectiveHandlerData>;
-    compile(node: ClassDeclaration, analysis: DirectiveHandlerData, pool: ConstantPool): CompileResult[];
+    analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>, flags?: HandlerFlags): AnalysisOutput<DirectiveHandlerData>;
+    register(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): void;
+    resolve(node: ClassDeclaration, analysis: DirectiveHandlerData): ResolveResult<unknown>;
+    compile(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[];
 }
 /**
  * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a
@@ -36,7 +47,7 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Direc
  * appear in the declarations of an `NgModule` and additional verification is done when processing
  * the module.
  */
-export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Decorator | null, reflector: ReflectionHost, evaluator: PartialEvaluator, defaultImportRecorder: DefaultImportRecorder, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
+export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decorator: Readonly<Decorator | null>, reflector: ReflectionHost, evaluator: PartialEvaluator, defaultImportRecorder: DefaultImportRecorder, isCore: boolean, flags: HandlerFlags, annotateForClosureCompiler: boolean, defaultSelector?: string | null): {
     decorator: Map<string, ts.Expression>;
     metadata: R3DirectiveMetadata;
 } | undefined;