@angular/language-service 11.2.9 → 11.2.13

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v11.2.9
+ * @license Angular v11.2.13
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -11099,6 +11099,34 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
                     content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
                 }
+                else if (rule.selector.startsWith('@font-face')) {
+                    content = this._stripScopingSelectors(rule.content, scopeSelector, hostSelector);
+                }
+                return new CssRule(selector, content);
+            });
+        }
+        /**
+         * Handle a css text that is within a rule that should not contain scope selectors by simply
+         * removing them! An example of such a rule is `@font-face`.
+         *
+         * `@font-face` rules cannot contain nested selectors. Nor can they be nested under a selector.
+         * Normally this would be a syntax error by the author of the styles. But in some rare cases, such
+         * as importing styles from a library, and applying `:host ::ng-deep` to the imported styles, we
+         * can end up with broken css if the imported styles happen to contain @font-face rules.
+         *
+         * For example:
+         *
+         * ```
+         * :host ::ng-deep {
+         *   import 'some/lib/containing/font-face';
+         * }
+         * ```
+         */
+        _stripScopingSelectors(cssText, scopeSelector, hostSelector) {
+            return processRules(cssText, rule => {
+                const selector = rule.selector.replace(_shadowDeepSelectors, ' ')
+                    .replace(_polyfillHostNoCombinatorRe, ' ');
+                const content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
                 return new CssRule(selector, content);
             });
         }
@@ -20399,7 +20427,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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 VERSION$1 = new Version('11.2.9');
+    const VERSION$1 = new Version('11.2.13');
 
     /**
      * @license
@@ -21056,7 +21084,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.2.9'));
+        definitionMap.set('version', literal('11.2.13'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -21277,7 +21305,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.2.9'));
+        definitionMap.set('version', literal('11.2.13'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21309,7 +21337,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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 VERSION$2 = new Version('11.2.9');
+    const VERSION$2 = new Version('11.2.13');
 
     /**
      * @license
@@ -21459,6 +21487,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * Raised when a directive/pipe is part of the declarations of two or more NgModules.
          */
         ErrorCode[ErrorCode["NGMODULE_DECLARATION_NOT_UNIQUE"] = 6007] = "NGMODULE_DECLARATION_NOT_UNIQUE";
+        /**
+         * Not actually raised by the compiler, but reserved for documentation of a View Engine error when
+         * a View Engine build depends on an Ivy-compiled NgModule.
+         */
+        ErrorCode[ErrorCode["NGMODULE_VE_DEPENDENCY_ON_IVY_LIB"] = 6999] = "NGMODULE_VE_DEPENDENCY_ON_IVY_LIB";
         /**
          * An element name failed validation against the DOM schema.
          */
@@ -21704,6 +21737,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function isAssignment(node) {
         return ts$1.isBinaryExpression(node) && node.operatorToken.kind === ts$1.SyntaxKind.EqualsToken;
     }
+    /**
+     * Obtains the non-redirected source file for `sf`.
+     */
+    function toUnredirectedSourceFile(sf) {
+        const redirectInfo = sf.redirectInfo;
+        if (redirectInfo === undefined) {
+            return sf;
+        }
+        return redirectInfo.unredirected;
+    }
 
     /**
      * @license
@@ -22212,6 +22255,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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 DefaultImportDeclaration = Symbol('DefaultImportDeclaration');
+    /**
+     * Attaches a default import declaration to `expr` to indicate the dependency of `expr` on the
+     * default import.
+     */
+    function attachDefaultImportDeclaration(expr, importDecl) {
+        expr[DefaultImportDeclaration] = importDecl;
+    }
+    /**
+     * Obtains the default import declaration that `expr` depends on, or `null` if there is no such
+     * dependency.
+     */
+    function getDefaultImportDeclaration(expr) {
+        var _a;
+        return (_a = expr[DefaultImportDeclaration]) !== null && _a !== void 0 ? _a : null;
+    }
     /**
      * TypeScript has trouble with generating default imports inside of transformers for some module
      * formats. The issue is that for the statement:
@@ -22244,47 +22303,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     class DefaultImportTracker {
         constructor() {
-            /**
-             * A `Map` which tracks the `Map` of default import `ts.Identifier`s to their
-             * `ts.ImportDeclaration`s. These declarations are not guaranteed to be used.
-             */
-            this.sourceFileToImportMap = new Map();
             /**
              * A `Map` which tracks the `Set` of `ts.ImportDeclaration`s for default imports that were used in
              * a given `ts.SourceFile` and need to be preserved.
              */
             this.sourceFileToUsedImports = new Map();
         }
-        recordImportedIdentifier(id, decl) {
-            const sf = getSourceFile(id);
-            if (!this.sourceFileToImportMap.has(sf)) {
-                this.sourceFileToImportMap.set(sf, new Map());
-            }
-            this.sourceFileToImportMap.get(sf).set(id, decl);
-        }
-        recordUsedIdentifier(id) {
-            const sf = getSourceFile(id);
-            if (!this.sourceFileToImportMap.has(sf)) {
-                // The identifier's source file has no registered default imports at all.
-                return;
-            }
-            const identiferToDeclaration = this.sourceFileToImportMap.get(sf);
-            if (!identiferToDeclaration.has(id)) {
-                // The identifier isn't from a registered default import.
-                return;
-            }
-            const decl = identiferToDeclaration.get(id);
+        recordUsedImport(importDecl) {
+            const sf = getSourceFile(importDecl);
             // Add the default import declaration to the set of used import declarations for the file.
             if (!this.sourceFileToUsedImports.has(sf)) {
                 this.sourceFileToUsedImports.set(sf, new Set());
             }
-            this.sourceFileToUsedImports.get(sf).add(decl);
+            this.sourceFileToUsedImports.get(sf).add(importDecl);
         }
         /**
          * Get a `ts.TransformerFactory` which will preserve default imports that were previously marked
          * as used.
          *
-         * This transformer must run after any other transformers which call `recordUsedIdentifier`.
+         * This transformer must run after any other transformers which call `recordUsedImport`.
          */
         importPreservingTransformer() {
             return (context) => {
@@ -22339,7 +22376,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             });
             // Save memory - there's no need to keep these around once the transform has run for the given
             // file.
-            this.sourceFileToImportMap.delete(originalSf);
             this.sourceFileToUsedImports.delete(originalSf);
             return ts$1.updateSourceFileNode(sf, statements);
         }
@@ -26719,7 +26755,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.imports = imports;
             this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
             this.downlevelVariableDeclarations = options.downlevelVariableDeclarations === true;
-            this.recordWrappedNodeExpr = options.recordWrappedNodeExpr || (() => { });
+            this.recordWrappedNode = options.recordWrappedNode || (() => { });
         }
         visitDeclareVarStmt(stmt, context) {
             var _a;
@@ -26947,7 +26983,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('Method not implemented.');
         }
         visitWrappedNodeExpr(ast, _context) {
-            this.recordWrappedNodeExpr(ast.node);
+            this.recordWrappedNode(ast);
             return ast.node;
         }
         visitTypeofExpr(ast, context) {
@@ -27806,11 +27842,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     const NO_DECORATORS = new Set();
     const CLOSURE_FILE_OVERVIEW_REGEXP = /\s+@fileoverview\s+/i;
-    function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportRecorder, perf, isCore, isClosureCompilerEnabled) {
-        const recordWrappedNodeExpr = createRecorderFn(defaultImportRecorder);
+    function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportTracker, perf, isCore, isClosureCompilerEnabled) {
+        const recordWrappedNode = createRecorderFn(defaultImportTracker);
         return (context) => {
             return (file) => {
-                return perf.inPhase(PerfPhase.Compile, () => transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNodeExpr));
+                return perf.inPhase(PerfPhase.Compile, () => transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode));
             };
         };
     }
@@ -27841,13 +27877,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * compilation results (provided as an argument).
      */
     class IvyTransformationVisitor extends Visitor {
-        constructor(compilation, classCompilationMap, reflector, importManager, recordWrappedNodeExpr, isClosureCompilerEnabled, isCore) {
+        constructor(compilation, classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore) {
             super();
             this.compilation = compilation;
             this.classCompilationMap = classCompilationMap;
             this.reflector = reflector;
             this.importManager = importManager;
-            this.recordWrappedNodeExpr = recordWrappedNodeExpr;
+            this.recordWrappedNode = recordWrappedNode;
             this.isClosureCompilerEnabled = isClosureCompilerEnabled;
             this.isCore = isCore;
         }
@@ -27862,7 +27898,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const members = [...node.members];
             for (const field of this.classCompilationMap.get(node)) {
                 // Translate the initializer for the field into TS nodes.
-                const exprNode = translateExpression(field.initializer, this.importManager, { recordWrappedNodeExpr: this.recordWrappedNodeExpr });
+                const exprNode = translateExpression(field.initializer, this.importManager, { recordWrappedNode: this.recordWrappedNode });
                 // Create a static property declaration for the new field.
                 const property = ts$1.createProperty(undefined, [ts$1.createToken(ts$1.SyntaxKind.StaticKeyword)], field.name, undefined, undefined, exprNode);
                 if (this.isClosureCompilerEnabled) {
@@ -27874,7 +27910,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     /* hasTrailingNewLine */ false);
                 }
                 field.statements
-                    .map(stmt => translateStatement(stmt, this.importManager, { recordWrappedNodeExpr: this.recordWrappedNodeExpr }))
+                    .map(stmt => translateStatement(stmt, this.importManager, { recordWrappedNode: this.recordWrappedNode }))
                     .forEach(stmt => statements.push(stmt));
                 members.push(property);
             }
@@ -27978,7 +28014,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     /**
      * A transformer which operates on ts.SourceFiles and applies changes from an `IvyCompilation`.
      */
-    function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNodeExpr) {
+    function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode) {
         const constantPool = new ConstantPool(isClosureCompilerEnabled);
         const importManager = new ImportManager(importRewriter);
         // The transformation process consists of 2 steps:
@@ -27995,13 +28031,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visit(file, compilationVisitor, context);
         // Step 2. Scan through the AST again and perform transformations based on Ivy compilation
         // results obtained at Step 1.
-        const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNodeExpr, isClosureCompilerEnabled, isCore);
+        const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore);
         let sf = visit(file, transformationVisitor, context);
         // Generate the constant statements first, as they may involve adding additional imports
         // to the ImportManager.
         const downlevelTranslatedCode = getLocalizeCompileTarget(context) < ts$1.ScriptTarget.ES2015;
         const constants = constantPool.statements.map(stmt => translateStatement(stmt, importManager, {
-            recordWrappedNodeExpr,
+            recordWrappedNode,
             downlevelTaggedTemplates: downlevelTranslatedCode,
             downlevelVariableDeclarations: downlevelTranslatedCode,
         }));
@@ -28075,10 +28111,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function isFromAngularCore(decorator) {
         return decorator.import !== null && decorator.import.from === '@angular/core';
     }
-    function createRecorderFn(defaultImportRecorder) {
-        return expr => {
-            if (ts$1.isIdentifier(expr)) {
-                defaultImportRecorder.recordUsedIdentifier(expr);
+    function createRecorderFn(defaultImportTracker) {
+        return node => {
+            const importDecl = getDefaultImportDeclaration(node);
+            if (importDecl !== null) {
+                defaultImportTracker.recordUsedImport(importDecl);
             }
         };
     }
@@ -28173,7 +28210,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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 getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore) {
+    function getConstructorDependencies(clazz, reflector, isCore) {
         const deps = [];
         const errors = [];
         let ctorParams = reflector.getConstructorParameters(clazz);
@@ -28186,7 +28223,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
         }
         ctorParams.forEach((param, idx) => {
-            let token = valueReferenceToExpression(param.typeValueReference, defaultImportRecorder);
+            let token = valueReferenceToExpression(param.typeValueReference);
             let attribute = null;
             let optional = false, self = false, skipSelf = false, host = false;
             let resolved = R3ResolvedDependencyType.Token;
@@ -28253,16 +28290,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return { deps: null, errors };
         }
     }
-    function valueReferenceToExpression(valueRef, defaultImportRecorder) {
+    function valueReferenceToExpression(valueRef) {
         if (valueRef.kind === 2 /* UNAVAILABLE */) {
             return null;
         }
         else if (valueRef.kind === 0 /* LOCAL */) {
-            if (defaultImportRecorder !== null && valueRef.defaultImportStatement !== null &&
-                ts$1.isIdentifier(valueRef.expression)) {
-                defaultImportRecorder.recordImportedIdentifier(valueRef.expression, valueRef.defaultImportStatement);
+            const expr = new WrappedNodeExpr(valueRef.expression);
+            if (valueRef.defaultImportStatement !== null) {
+                attachDefaultImportDeclaration(expr, valueRef.defaultImportStatement);
             }
-            return new WrappedNodeExpr(valueRef.expression);
+            return expr;
         }
         else {
             let importExpr = new ExternalExpr({ moduleName: valueRef.moduleName, name: valueRef.importedName });
@@ -28293,8 +28330,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return 'invalid';
         }
     }
-    function getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore) {
-        return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore));
+    function getValidConstructorDependencies(clazz, reflector, isCore) {
+        return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, isCore));
     }
     /**
      * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
@@ -28802,7 +28839,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * If no such metadata is present, this function returns `null`. Otherwise, the call is returned
      * as a `Statement` for inclusion along with the class.
      */
-    function generateSetClassMetadataCall(clazz, reflection, defaultImportRecorder, isCore, annotateForClosureCompiler) {
+    function generateSetClassMetadataCall(clazz, reflection, isCore, annotateForClosureCompiler) {
         if (!reflection.isClass(clazz)) {
             return null;
         }
@@ -28829,7 +28866,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         let metaCtorParameters = new LiteralExpr(null);
         const classCtorParameters = reflection.getConstructorParameters(clazz);
         if (classCtorParameters !== null) {
-            const ctorParameters = classCtorParameters.map(param => ctorParameterToMetadata(param, defaultImportRecorder, isCore));
+            const ctorParameters = classCtorParameters.map(param => ctorParameterToMetadata(param, isCore));
             metaCtorParameters = new FunctionExpr([], [
                 new ReturnStatement(new LiteralArrayExpr(ctorParameters)),
             ]);
@@ -28866,11 +28903,11 @@ Either add the @Injectable() decorator to '${provider.node.name
     /**
      * Convert a reflected constructor parameter to metadata.
      */
-    function ctorParameterToMetadata(param, defaultImportRecorder, isCore) {
+    function ctorParameterToMetadata(param, isCore) {
         // Parameters sometimes have a type that can be referenced. If so, then use it, otherwise
         // its type is undefined.
         const type = param.typeValueReference.kind !== 2 /* UNAVAILABLE */ ?
-            valueReferenceToExpression(param.typeValueReference, defaultImportRecorder) :
+            valueReferenceToExpression(param.typeValueReference) :
             new LiteralExpr(undefined);
         const mapEntries = [
             { key: 'type', value: type, quoted: false },
@@ -29057,13 +29094,12 @@ Either add the @Injectable() decorator to '${provider.node.name
         return isSymbolEqual(current, previous);
     }
     class DirectiveDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, defaultImportRecorder, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
+        constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
             this.scopeRegistry = scopeRegistry;
             this.metaReader = metaReader;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.injectableRegistry = injectableRegistry;
             this.isCore = isCore;
             this.semanticDepGraphUpdater = semanticDepGraphUpdater;
@@ -29097,7 +29133,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return { diagnostics: [getUndecoratedClassWithAngularFeaturesDiagnostic(node)] };
             }
             this.perf.eventCount(PerfEvent.AnalyzeDirective);
-            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore, flags, this.annotateForClosureCompiler);
+            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler);
             if (directiveResult === undefined) {
                 return {};
             }
@@ -29111,7 +29147,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     inputs: directiveResult.inputs,
                     outputs: directiveResult.outputs,
                     meta: analysis,
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     baseClass: readBaseClass$1(node, this.reflector, this.evaluator),
                     typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
                     providersRequiringFactory,
@@ -29194,7 +29230,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * appear in the declarations of an `NgModule` and additional verification is done when processing
      * the module.
      */
-    function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, defaultImportRecorder, isCore, flags, annotateForClosureCompiler, defaultSelector = null) {
+    function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore, flags, annotateForClosureCompiler, defaultSelector = null) {
         let directive;
         if (decorator === null || decorator.args === null || decorator.args.length === 0) {
             directive = new Map();
@@ -29272,7 +29308,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             exportAs = resolved.split(',').map(part => part.trim());
         }
-        const rawCtorDeps = getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+        const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
         let ctorDeps;
         // Non-abstract directives (those with a selector) require valid constructor dependencies, whereas
         // abstract directives are allowed to have invalid dependencies, given that a subclass may call
@@ -29694,7 +29730,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Compiles @NgModule annotations to ngModuleDef fields.
      */
     class NgModuleDecoratorHandler {
-        constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, factoryTracker, defaultImportRecorder, annotateForClosureCompiler, injectableRegistry, perf, localeId) {
+        constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, factoryTracker, annotateForClosureCompiler, injectableRegistry, perf, localeId) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaReader = metaReader;
@@ -29705,7 +29741,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.routeAnalyzer = routeAnalyzer;
             this.refEmitter = refEmitter;
             this.factoryTracker = factoryTracker;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.annotateForClosureCompiler = annotateForClosureCompiler;
             this.injectableRegistry = injectableRegistry;
             this.perf = perf;
@@ -29883,7 +29918,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     schemas: schemas,
                     mod: ngModuleDef,
                     inj: ngInjectorDef,
-                    deps: getValidConstructorDependencies(node, this.reflector, this.defaultImportRecorder, this.isCore),
+                    deps: getValidConstructorDependencies(node, this.reflector, this.isCore),
                     declarations: declarationRefs,
                     rawDeclarations,
                     imports: importRefs,
@@ -29892,7 +29927,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     providersRequiringFactory: rawProviders ?
                         resolveProvidersRequiringFactory(rawProviders, this.reflector, this.evaluator) :
                         null,
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     factorySymbolName: node.name.text,
                 },
             };
@@ -30223,7 +30258,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * `DecoratorHandler` which handles the `@Component` annotation.
      */
     class ComponentDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, defaultImportRecorder, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf) {
+        constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
@@ -30244,7 +30279,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.cycleAnalyzer = cycleAnalyzer;
             this.cycleHandlingStrategy = cycleHandlingStrategy;
             this.refEmitter = refEmitter;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.depTracker = depTracker;
             this.injectableRegistry = injectableRegistry;
             this.semanticDepGraphUpdater = semanticDepGraphUpdater;
@@ -30341,7 +30375,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             let isPoisoned = false;
             // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
             // on it.
-            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore, flags, this.annotateForClosureCompiler, this.elementSchemaRegistry.getDefaultComponentElementName());
+            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler, this.elementSchemaRegistry.getDefaultComponentElementName());
             if (directiveResult === undefined) {
                 // `extractDirectiveMetadata` returns undefined when the @Directive has `jit: true`. In this
                 // case, compilation of the decorator is skipped. Returning an empty object signifies
@@ -30455,7 +30489,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                         // analyzed and the full compilation scope for the component can be realized.
                         animations, viewProviders: wrappedViewProviders, i18nUseExternalIds: this.i18nUseExternalIds, relativeContextFilePath }),
                     typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     template,
                     providersRequiringFactory,
                     viewProvidersRequiringFactory,
@@ -31151,7 +31185,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Adapts the `compileIvyInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
      */
     class InjectableDecoratorHandler {
-        constructor(reflector, defaultImportRecorder, isCore, strictCtorDeps, injectableRegistry, perf, 
+        constructor(reflector, isCore, strictCtorDeps, injectableRegistry, perf, 
         /**
          * What to do if the injectable already contains a ɵprov property.
          *
@@ -31160,7 +31194,6 @@ Either add the @Injectable() decorator to '${provider.node.name
          */
         errorOnDuplicateProv = true) {
             this.reflector = reflector;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.isCore = isCore;
             this.strictCtorDeps = strictCtorDeps;
             this.injectableRegistry = injectableRegistry;
@@ -31192,8 +31225,8 @@ Either add the @Injectable() decorator to '${provider.node.name
             return {
                 analysis: {
                     meta,
-                    ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.defaultImportRecorder, this.isCore, this.strictCtorDeps),
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore),
+                    ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.isCore, this.strictCtorDeps),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
                     // Avoid generating multiple factories if a class has
                     // more Angular decorators, apart from Injectable.
                     needsFactory: !decorators ||
@@ -31335,7 +31368,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], 'Too many arguments to @Injectable');
         }
     }
-    function extractInjectableCtorDeps(clazz, meta, decorator, reflector, defaultImportRecorder, isCore, strictCtorDeps) {
+    function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
         if (decorator.args === null) {
             throw new FatalDiagnosticError(ErrorCode.DECORATOR_NOT_CALLED, Decorator.nodeForError(decorator), '@Injectable must be called');
         }
@@ -31350,15 +31383,16 @@ Either add the @Injectable() decorator to '${provider.node.name
             // constructor signature does not work for DI then a factory definition (ɵfac) that throws is
             // generated.
             if (strictCtorDeps) {
-                ctorDeps = getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+                ctorDeps = getValidConstructorDependencies(clazz, reflector, isCore);
             }
             else {
-                ctorDeps = unwrapConstructorDependencies(getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore));
+                ctorDeps =
+                    unwrapConstructorDependencies(getConstructorDependencies(clazz, reflector, isCore));
             }
             return ctorDeps;
         }
         else if (decorator.args.length === 1) {
-            const rawCtorDeps = getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+            const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
             if (strictCtorDeps && meta.useValue === undefined && meta.useExisting === undefined &&
                 meta.useClass === undefined && meta.useFactory === undefined) {
                 // Since use* was not provided, validate the deps according to strictCtorDeps.
@@ -31442,12 +31476,11 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     class PipeDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, scopeRegistry, defaultImportRecorder, injectableRegistry, isCore, perf) {
+        constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
             this.scopeRegistry = scopeRegistry;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.injectableRegistry = injectableRegistry;
             this.isCore = isCore;
             this.perf = perf;
@@ -31511,10 +31544,10 @@ Either add the @Injectable() decorator to '${provider.node.name
                         internalType,
                         typeArgumentCount: this.reflector.getGenericArityOfClass(clazz) || 0,
                         pipeName,
-                        deps: getValidConstructorDependencies(clazz, this.reflector, this.defaultImportRecorder, this.isCore),
+                        deps: getValidConstructorDependencies(clazz, this.reflector, this.isCore),
                         pure,
                     },
-                    metadataStmt: generateSetClassMetadataCall(clazz, this.reflector, this.defaultImportRecorder, this.isCore),
+                    metadataStmt: generateSetClassMetadataCall(clazz, this.reflector, this.isCore),
                 },
             };
         }
@@ -32148,10 +32181,11 @@ Either add the @Injectable() decorator to '${provider.node.name
                 //    since the previous compilation). These need to be removed from the state tracking to
                 //    avoid leaking memory.
                 // All files in the old program, for easy detection of changes.
-                const oldFiles = new Set(oldProgram.getSourceFiles());
+                const oldFiles = new Set(oldProgram.getSourceFiles().map(toUnredirectedSourceFile));
                 // Assume all the old files were deleted to begin with. Only TS files are tracked.
                 const deletedTsPaths = new Set(tsOnlyFiles(oldProgram).map(sf => sf.fileName));
-                for (const newFile of newProgram.getSourceFiles()) {
+                for (const possiblyRedirectedNewFile of newProgram.getSourceFiles()) {
+                    const newFile = toUnredirectedSourceFile(possiblyRedirectedNewFile);
                     if (!newFile.isDeclarationFile) {
                         // This file exists in the new program, so remove it from `deletedTsPaths`.
                         deletedTsPaths.delete(newFile.fileName);
@@ -32932,7 +32966,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         resolve(url, fromFile) {
             let resolvedUrl = null;
             if (this.adapter.resourceNameToFileName) {
-                resolvedUrl = this.adapter.resourceNameToFileName(url, fromFile);
+                resolvedUrl = this.adapter.resourceNameToFileName(url, fromFile, (url, fromFile) => this.fallbackResolve(url, fromFile));
             }
             else {
                 resolvedUrl = this.fallbackResolve(url, fromFile);
@@ -34720,56 +34754,63 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.data = data;
             this.shimPath = shimPath;
             /**
-             * Cache of `GlobalCompletion`s for various levels of the template, including the root template
-             * (`null`).
+             * Cache of completions for various levels of the template, including the root template (`null`).
+             * Memoizes `getTemplateContextCompletions`.
              */
-            this.globalCompletionCache = new Map();
+            this.templateContextCache = new Map();
             this.expressionCompletionCache = new Map();
-        }
-        /**
-         * Get global completions within the given template context - either a `TmplAstTemplate` embedded
-         * view, or `null` for the root template context.
-         */
-        getGlobalCompletions(context) {
-            if (this.globalCompletionCache.has(context)) {
-                return this.globalCompletionCache.get(context);
-            }
             // Find the component completion expression within the TCB. This looks like: `ctx. /* ... */;`
             const globalRead = findFirstMatchingNode(this.tcb, {
                 filter: ts$1.isPropertyAccessExpression,
                 withExpressionIdentifier: ExpressionIdentifier.COMPONENT_COMPLETION
             });
-            if (globalRead === null) {
-                return null;
-            }
-            const completion = {
-                componentContext: {
+            if (globalRead !== null) {
+                this.componentContext = {
                     shimPath: this.shimPath,
                     // `globalRead.name` is an empty `ts.Identifier`, so its start position immediately follows
                     // the `.` in `ctx.`. TS autocompletion APIs can then be used to access completion results
                     // for the component context.
                     positionInShimFile: globalRead.name.getStart(),
-                },
-                templateContext: new Map(),
-            };
-            // The bound template already has details about the references and variables in scope in the
-            // `context` template - they just need to be converted to `Completion`s.
-            for (const node of this.data.boundTarget.getEntitiesInTemplateScope(context)) {
-                if (node instanceof Reference) {
-                    completion.templateContext.set(node.name, {
-                        kind: CompletionKind.Reference,
-                        node,
-                    });
-                }
-                else {
-                    completion.templateContext.set(node.name, {
-                        kind: CompletionKind.Variable,
-                        node,
-                    });
+                };
+            }
+            else {
+                this.componentContext = null;
+            }
+        }
+        /**
+         * Get global completions within the given template context and AST node.
+         *
+         * @param context the given template context - either a `TmplAstTemplate` embedded view, or `null`
+         *     for the root
+         * template context.
+         * @param node the given AST node
+         */
+        getGlobalCompletions(context, node) {
+            if (this.componentContext === null) {
+                return null;
+            }
+            const templateContext = this.getTemplateContextCompletions(context);
+            if (templateContext === null) {
+                return null;
+            }
+            let nodeContext = null;
+            if (node instanceof EmptyExpr) {
+                const nodeLocation = findFirstMatchingNode(this.tcb, {
+                    filter: ts$1.isIdentifier,
+                    withSpan: node.sourceSpan,
+                });
+                if (nodeLocation !== null) {
+                    nodeContext = {
+                        shimPath: this.shimPath,
+                        positionInShimFile: nodeLocation.getStart(),
+                    };
                 }
             }
-            this.globalCompletionCache.set(context, completion);
-            return completion;
+            return {
+                componentContext: this.componentContext,
+                templateContext,
+                nodeContext,
+            };
         }
         getExpressionCompletionLocation(expr) {
             if (this.expressionCompletionCache.has(expr)) {
@@ -34814,6 +34855,34 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.expressionCompletionCache.set(expr, res);
             return res;
         }
+        /**
+         * Get global completions within the given template context - either a `TmplAstTemplate` embedded
+         * view, or `null` for the root context.
+         */
+        getTemplateContextCompletions(context) {
+            if (this.templateContextCache.has(context)) {
+                return this.templateContextCache.get(context);
+            }
+            const templateContext = new Map();
+            // The bound template already has details about the references and variables in scope in the
+            // `context` template - they just need to be converted to `Completion`s.
+            for (const node of this.data.boundTarget.getEntitiesInTemplateScope(context)) {
+                if (node instanceof Reference) {
+                    templateContext.set(node.name, {
+                        kind: CompletionKind.Reference,
+                        node,
+                    });
+                }
+                else {
+                    templateContext.set(node.name, {
+                        kind: CompletionKind.Variable,
+                        node,
+                    });
+                }
+            }
+            this.templateContextCache.set(context, templateContext);
+            return templateContext;
+        }
     }
 
     /**
@@ -35143,12 +35212,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
         return false;
     }
-    function checkIfGenericTypesAreUnbound(node) {
-        if (node.typeParameters === undefined) {
-            return true;
-        }
-        return node.typeParameters.every(param => param.constraint === undefined);
-    }
     function isAccessExpression(node) {
         return ts$1.isPropertyAccessExpression(node) || ts$1.isElementAccessExpression(node);
     }
@@ -35368,6 +35431,136 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
 
+    /**
+     * @license
+     * Copyright Google LLC 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
+     */
+    /**
+     * Indicates whether a particular component requires an inline type check block.
+     *
+     * This is not a boolean state as inlining might only be required to get the best possible
+     * type-checking, but the component could theoretically still be checked without it.
+     */
+    var TcbInliningRequirement;
+    (function (TcbInliningRequirement) {
+        /**
+         * There is no way to type check this component without inlining.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["MustInline"] = 0] = "MustInline";
+        /**
+         * Inlining should be used due to the component's generic bounds, but a non-inlining fallback
+         * method can be used if that's not possible.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["ShouldInlineForGenericBounds"] = 1] = "ShouldInlineForGenericBounds";
+        /**
+         * There is no requirement for this component's TCB to be inlined.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["None"] = 2] = "None";
+    })(TcbInliningRequirement || (TcbInliningRequirement = {}));
+    function requiresInlineTypeCheckBlock(node, usedPipes, reflector) {
+        // In order to qualify for a declared TCB (not inline) two conditions must be met:
+        // 1) the class must be exported
+        // 2) it must not have contextual generic type bounds
+        if (!checkIfClassIsExported(node)) {
+            // Condition 1 is false, the class is not exported.
+            return TcbInliningRequirement.MustInline;
+        }
+        else if (!checkIfGenericTypeBoundsAreContextFree(node, reflector)) {
+            // Condition 2 is false, the class has constrained generic types. It should be checked with an
+            // inline TCB if possible, but can potentially use fallbacks to avoid inlining if not.
+            return TcbInliningRequirement.ShouldInlineForGenericBounds;
+        }
+        else if (Array.from(usedPipes.values())
+            .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {
+            // If one of the pipes used by the component is not exported, a non-inline TCB will not be able
+            // to import it, so this requires an inline TCB.
+            return TcbInliningRequirement.MustInline;
+        }
+        else {
+            return TcbInliningRequirement.None;
+        }
+    }
+    /** Maps a shim position back to a template location. */
+    function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
+        const node = getTokenAtPosition(shimSf, position);
+        const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);
+        if (sourceLocation === null) {
+            return null;
+        }
+        const mapping = resolver.getSourceMapping(sourceLocation.id);
+        const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);
+        if (span === null) {
+            return null;
+        }
+        // TODO(atscott): Consider adding a context span by walking up from `node` until we get a
+        // different span.
+        return { sourceLocation, templateSourceMapping: mapping, span };
+    }
+    function findTypeCheckBlock(file, id, isDiagnosticRequest) {
+        for (const stmt of file.statements) {
+            if (ts$1.isFunctionDeclaration(stmt) && getTemplateId$1(stmt, file, isDiagnosticRequest) === id) {
+                return stmt;
+            }
+        }
+        return null;
+    }
+    /**
+     * Traverses up the AST starting from the given node to extract the source location from comments
+     * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore
+     * marker comment is found up the tree (and this is part of a diagnostic request), this function
+     * returns null.
+     */
+    function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
+        // Search for comments until the TCB's function declaration is encountered.
+        while (node !== undefined && !ts$1.isFunctionDeclaration(node)) {
+            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
+                // There's an ignore marker on this node, so the diagnostic should not be reported.
+                return null;
+            }
+            const span = readSpanComment(node, sourceFile);
+            if (span !== null) {
+                // Once the positional information has been extracted, search further up the TCB to extract
+                // the unique id that is attached with the TCB's function declaration.
+                const id = getTemplateId$1(node, sourceFile, isDiagnosticsRequest);
+                if (id === null) {
+                    return null;
+                }
+                return { id, span };
+            }
+            node = node.parent;
+        }
+        return null;
+    }
+    function getTemplateId$1(node, sourceFile, isDiagnosticRequest) {
+        // Walk up to the function declaration of the TCB, the file information is attached there.
+        while (!ts$1.isFunctionDeclaration(node)) {
+            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
+                // There's an ignore marker on this node, so the diagnostic should not be reported.
+                return null;
+            }
+            node = node.parent;
+            // Bail once we have reached the root.
+            if (node === undefined) {
+                return null;
+            }
+        }
+        const start = node.getFullStart();
+        return ts$1.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
+            if (kind !== ts$1.SyntaxKind.MultiLineCommentTrivia) {
+                return null;
+            }
+            const commentText = sourceFile.text.substring(pos + 2, end - 2);
+            return commentText;
+        }) || null;
+    }
+    function checkIfGenericTypeBoundsAreContextFree(node, reflector) {
+        // Generic type parameters are considered context free if they can be emitted into any context.
+        return new TypeParameterEmitter(node.typeParameters, reflector).canEmit();
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -35532,10 +35725,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         // emitted into a different context.
         return !checkIfGenericTypeBoundsAreContextFree(node, host);
     }
-    function checkIfGenericTypeBoundsAreContextFree(node, reflector) {
-        // Generic type parameters are considered context free if they can be emitted into any context.
-        return new TypeParameterEmitter(node.typeParameters, reflector).canEmit();
-    }
     /**
      * Add a default `= any` to type parameters that don't have a default value already.
      *
@@ -35844,109 +36033,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         return Object.assign(Object.assign({}, makeDiagnostic(code, node, messageText, relatedInformation)), { componentFile: node.getSourceFile(), templateId });
     }
 
-    /**
-     * @license
-     * Copyright Google LLC 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 requiresInlineTypeCheckBlock(node, usedPipes) {
-        // In order to qualify for a declared TCB (not inline) two conditions must be met:
-        // 1) the class must be exported
-        // 2) it must not have constrained generic types
-        if (!checkIfClassIsExported(node)) {
-            // Condition 1 is false, the class is not exported.
-            return true;
-        }
-        else if (!checkIfGenericTypesAreUnbound(node)) {
-            // Condition 2 is false, the class has constrained generic types
-            return true;
-        }
-        else if (Array.from(usedPipes.values())
-            .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {
-            // If one of the pipes used by the component is not exported, a non-inline TCB will not be able
-            // to import it, so this requires an inline TCB.
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    /** Maps a shim position back to a template location. */
-    function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
-        const node = getTokenAtPosition(shimSf, position);
-        const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);
-        if (sourceLocation === null) {
-            return null;
-        }
-        const mapping = resolver.getSourceMapping(sourceLocation.id);
-        const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);
-        if (span === null) {
-            return null;
-        }
-        // TODO(atscott): Consider adding a context span by walking up from `node` until we get a
-        // different span.
-        return { sourceLocation, templateSourceMapping: mapping, span };
-    }
-    function findTypeCheckBlock(file, id, isDiagnosticRequest) {
-        for (const stmt of file.statements) {
-            if (ts$1.isFunctionDeclaration(stmt) && getTemplateId$1(stmt, file, isDiagnosticRequest) === id) {
-                return stmt;
-            }
-        }
-        return null;
-    }
-    /**
-     * Traverses up the AST starting from the given node to extract the source location from comments
-     * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore
-     * marker comment is found up the tree (and this is part of a diagnostic request), this function
-     * returns null.
-     */
-    function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
-        // Search for comments until the TCB's function declaration is encountered.
-        while (node !== undefined && !ts$1.isFunctionDeclaration(node)) {
-            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
-                // There's an ignore marker on this node, so the diagnostic should not be reported.
-                return null;
-            }
-            const span = readSpanComment(node, sourceFile);
-            if (span !== null) {
-                // Once the positional information has been extracted, search further up the TCB to extract
-                // the unique id that is attached with the TCB's function declaration.
-                const id = getTemplateId$1(node, sourceFile, isDiagnosticsRequest);
-                if (id === null) {
-                    return null;
-                }
-                return { id, span };
-            }
-            node = node.parent;
-        }
-        return null;
-    }
-    function getTemplateId$1(node, sourceFile, isDiagnosticRequest) {
-        // Walk up to the function declaration of the TCB, the file information is attached there.
-        while (!ts$1.isFunctionDeclaration(node)) {
-            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
-                // There's an ignore marker on this node, so the diagnostic should not be reported.
-                return null;
-            }
-            node = node.parent;
-            // Bail once we have reached the root.
-            if (node === undefined) {
-                return null;
-            }
-        }
-        const start = node.getFullStart();
-        return ts$1.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
-            if (kind !== ts$1.SyntaxKind.MultiLineCommentTrivia) {
-                return null;
-            }
-            const commentText = sourceFile.text.substring(pos + 2, end - 2);
-            return commentText;
-        }) || null;
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -36091,7 +36177,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             // The `EmptyExpr` doesn't have a dedicated method on `AstVisitor`, so it's special cased here.
             if (ast instanceof EmptyExpr) {
-                return UNDEFINED;
+                const res = ts$1.factory.createIdentifier('undefined');
+                addParseSpanInfo(res, ast.sourceSpan);
+                return res;
             }
             // First attempt to let any custom resolution logic provide a translation for the given node.
             const resolved = this.maybeResolve(ast);
@@ -36455,6 +36543,32 @@ Either add the @Injectable() decorator to '${provider.node.name
      * 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
      */
+    /**
+     * Controls how generics for the component context class will be handled during TCB generation.
+     */
+    var TcbGenericContextBehavior;
+    (function (TcbGenericContextBehavior) {
+        /**
+         * References to generic parameter bounds will be emitted via the `TypeParameterEmitter`.
+         *
+         * The caller must verify that all parameter bounds are emittable in order to use this mode.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["UseEmitter"] = 0] = "UseEmitter";
+        /**
+         * Generic parameter declarations will be copied directly from the `ts.ClassDeclaration` of the
+         * component class.
+         *
+         * The caller must only use the generated TCB code in a context where such copies will still be
+         * valid, such as an inline type check block.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["CopyClassNodes"] = 1] = "CopyClassNodes";
+        /**
+         * Any generic parameters for the component context class will be set to `any`.
+         *
+         * Produces a less useful type, but is always safe to use.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["FallbackToAny"] = 2] = "FallbackToAny";
+    })(TcbGenericContextBehavior || (TcbGenericContextBehavior = {}));
     /**
      * Given a `ts.ClassDeclaration` for a component, and metadata regarding that component, compose a
      * "type check block" function.
@@ -36476,15 +36590,39 @@ Either add the @Injectable() decorator to '${provider.node.name
      * and bindings.
      * @param oobRecorder used to record errors regarding template elements which could not be correctly
      * translated into types during TCB generation.
+     * @param genericContextBehavior controls how generic parameters (especially parameters with generic
+     * bounds) will be referenced from the generated TCB code.
      */
-    function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecorder) {
+    function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
         const tcb = new Context$1(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas);
         const scope = Scope$1.forNodes(tcb, null, tcb.boundTarget.target.template, /* guard */ null);
         const ctxRawType = env.referenceType(ref);
         if (!ts$1.isTypeReferenceNode(ctxRawType)) {
             throw new Error(`Expected TypeReferenceNode when referencing the ctx param for ${ref.debugName}`);
         }
-        const paramList = [tcbCtxParam(ref.node, ctxRawType.typeName, env.config.useContextGenericType)];
+        let typeParameters = undefined;
+        let typeArguments = undefined;
+        if (ref.node.typeParameters !== undefined) {
+            if (!env.config.useContextGenericType) {
+                genericContextBehavior = TcbGenericContextBehavior.FallbackToAny;
+            }
+            switch (genericContextBehavior) {
+                case TcbGenericContextBehavior.UseEmitter:
+                    // Guaranteed to emit type parameters since we checked that the class has them above.
+                    typeParameters = new TypeParameterEmitter(ref.node.typeParameters, env.reflector)
+                        .emit(typeRef => env.referenceType(typeRef));
+                    typeArguments = typeParameters.map(param => ts$1.factory.createTypeReferenceNode(param.name));
+                    break;
+                case TcbGenericContextBehavior.CopyClassNodes:
+                    typeParameters = [...ref.node.typeParameters];
+                    typeArguments = typeParameters.map(param => ts$1.factory.createTypeReferenceNode(param.name));
+                    break;
+                case TcbGenericContextBehavior.FallbackToAny:
+                    typeArguments = ref.node.typeParameters.map(() => ts$1.factory.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword));
+                    break;
+            }
+        }
+        const paramList = [tcbCtxParam(ref.node, ctxRawType.typeName, typeArguments)];
         const scopeStatements = scope.render();
         const innerBody = ts$1.createBlock([
             ...env.getPreludeStatements(),
@@ -36498,7 +36636,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         /* modifiers */ undefined, 
         /* asteriskToken */ undefined, 
         /* name */ name, 
-        /* typeParameters */ env.config.useContextGenericType ? ref.node.typeParameters : undefined, 
+        /* typeParameters */ env.config.useContextGenericType ? typeParameters : undefined, 
         /* parameters */ paramList, 
         /* type */ undefined, 
         /* body */ body);
@@ -37867,26 +38005,11 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     /**
-     * Create the `ctx` parameter to the top-level TCB function.
-     *
-     * This is a parameter with a type equivalent to the component type, with all generic type
-     * parameters listed (without their generic bounds).
+     * Create the `ctx` parameter to the top-level TCB function, with the given generic type arguments.
      */
-    function tcbCtxParam(node, name, useGenericType) {
-        let typeArguments = undefined;
-        // Check if the component is generic, and pass generic type parameters if so.
-        if (node.typeParameters !== undefined) {
-            if (useGenericType) {
-                typeArguments =
-                    node.typeParameters.map(param => ts$1.createTypeReferenceNode(param.name, undefined));
-            }
-            else {
-                typeArguments =
-                    node.typeParameters.map(() => ts$1.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword));
-            }
-        }
-        const type = ts$1.createTypeReferenceNode(name, typeArguments);
-        return ts$1.createParameter(
+    function tcbCtxParam(node, name, typeArguments) {
+        const type = ts$1.factory.createTypeReferenceNode(name, typeArguments);
+        return ts$1.factory.createParameterDeclaration(
         /* decorators */ undefined, 
         /* modifiers */ undefined, 
         /* dotDotDotToken */ undefined, 
@@ -38197,9 +38320,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.nextTcbId = 1;
             this.tcbStatements = [];
         }
-        addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder) {
+        addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
             const fnId = ts$1.createIdentifier(`_tcb${this.nextTcbId++}`);
-            const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder);
+            const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
             this.tcbStatements.push(fn);
         }
         render(removeComments) {
@@ -38331,10 +38454,11 @@ Either add the @Injectable() decorator to '${provider.node.name
                 boundTarget,
                 templateDiagnostics,
             });
-            const tcbRequiresInline = requiresInlineTypeCheckBlock(ref.node, pipes);
+            const inliningRequirement = requiresInlineTypeCheckBlock(ref.node, pipes, this.reflector);
             // If inlining is not supported, but is required for either the TCB or one of its directive
             // dependencies, then exit here with an error.
-            if (this.inlining === InliningMode.Error && tcbRequiresInline) {
+            if (this.inlining === InliningMode.Error &&
+                inliningRequirement === TcbInliningRequirement.MustInline) {
                 // This template cannot be supported because the underlying strategy does not support inlining
                 // and inlining would be required.
                 // Record diagnostics to indicate the issues with this template.
@@ -38350,14 +38474,23 @@ Either add the @Injectable() decorator to '${provider.node.name
                 schemas,
             };
             this.perf.eventCount(PerfEvent.GenerateTcb);
-            if (tcbRequiresInline) {
+            if (inliningRequirement !== TcbInliningRequirement.None &&
+                this.inlining === InliningMode.InlineOps) {
                 // This class didn't meet the requirements for external type checking, so generate an inline
                 // TCB for the class.
                 this.addInlineTypeCheckBlock(fileData, shimData, ref, meta);
             }
+            else if (inliningRequirement === TcbInliningRequirement.ShouldInlineForGenericBounds &&
+                this.inlining === InliningMode.Error) {
+                // It's suggested that this TCB should be generated inline due to the component's generic
+                // bounds, but inlining is not supported by the current environment. Use a non-inline type
+                // check block, but fall back to `any` generic parameters since the generic bounds can't be
+                // referenced in that context. This will infer a less useful type for the component, but allow
+                // for type-checking it in an environment where that would not be possible otherwise.
+                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder, TcbGenericContextBehavior.FallbackToAny);
+            }
             else {
-                // The class can be type-checked externally as normal.
-                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder);
+                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder, TcbGenericContextBehavior.UseEmitter);
             }
         }
         /**
@@ -38447,7 +38580,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 this.opMap.set(sf, []);
             }
             const ops = this.opMap.get(sf);
-            ops.push(new TcbOp$1(ref, tcbMeta, this.config, this.reflector, shimData.domSchemaChecker, shimData.oobRecorder));
+            ops.push(new InlineTcbOp(ref, tcbMeta, this.config, this.reflector, shimData.domSchemaChecker, shimData.oobRecorder));
             fileData.hasInlines = true;
         }
         pendingShimForComponent(node) {
@@ -38490,9 +38623,9 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     /**
-     * A type check block operation which produces type check code for a particular component.
+     * A type check block operation which produces inline type check code for a particular component.
      */
-    class TcbOp$1 {
+    class InlineTcbOp {
         constructor(ref, meta, config, reflector, domSchemaChecker, oobRecorder) {
             this.ref = ref;
             this.meta = meta;
@@ -38510,7 +38643,9 @@ Either add the @Injectable() decorator to '${provider.node.name
         execute(im, sf, refEmitter, printer) {
             const env = new Environment(this.config, im, refEmitter, this.reflector, sf);
             const fnName = ts$1.createIdentifier(`_tcb_${this.ref.node.pos}`);
-            const fn = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder);
+            // Inline TCBs should copy any generic type parameter nodes directly, as the TCB code is inlined
+            // into the class in a context where that will always be legal.
+            const fn = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder, TcbGenericContextBehavior.CopyClassNodes);
             return printer.printNode(ts$1.EmitHint.Unspecified, fn, sf);
         }
     }
@@ -39339,12 +39474,12 @@ Either add the @Injectable() decorator to '${provider.node.name
         getTypeCheckBlock(component) {
             return this.getLatestComponentState(component).tcb;
         }
-        getGlobalCompletions(context, component) {
+        getGlobalCompletions(context, component, node) {
             const engine = this.getOrCreateCompletionEngine(component);
             if (engine === null) {
                 return null;
             }
-            return this.perf.inPhase(PerfPhase.TtcAutocompletion, () => engine.getGlobalCompletions(context));
+            return this.perf.inPhase(PerfPhase.TtcAutocompletion, () => engine.getGlobalCompletions(context, node));
         }
         getExpressionCompletionLocation(ast, component) {
             const engine = this.getOrCreateCompletionEngine(component);
@@ -40120,10 +40255,11 @@ Either add the @Injectable() decorator to '${provider.node.name
             else {
                 importRewriter = new NoopImportRewriter();
             }
+            const defaultImportTracker = new DefaultImportTracker();
             const before = [
-                ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, compilation.defaultImportTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),
+                ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),
                 aliasTransformFactory(compilation.traitCompiler.exportStatements),
-                compilation.defaultImportTracker.importPreservingTransformer(),
+                defaultImportTracker.importPreservingTransformer(),
             ];
             const afterDeclarations = [];
             if (compilation.dtsTransforms !== null) {
@@ -40428,7 +40564,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             const dtsTransforms = new DtsTransformRegistry();
             const mwpScanner = new ModuleWithProvidersScanner(reflector, evaluator, refEmitter);
             const isCore = isAngularCorePackage(this.tsProgram);
-            const defaultImportTracker = new DefaultImportTracker();
             const resourceRegistry = new ResourceRegistry();
             const compilationMode = this.options.compilationMode === 'partial' ? CompilationMode.PARTIAL : CompilationMode.FULL;
             // Cycles are handled in full compilation mode by "remote scoping".
@@ -40439,17 +40574,17 @@ Either add the @Injectable() decorator to '${provider.node.name
                 1 /* Error */;
             // Set up the IvyCompilation, which manages state for the Ivy transformer.
             const handlers = [
-                new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, defaultImportTracker, this.incrementalDriver.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder),
+                new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, this.incrementalDriver.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder),
                 // TODO(alxhub): understand why the cast here is necessary (something to do with `null`
                 // not being assignable to `unknown` when wrapped in `Readonly`).
                 // clang-format off
-                new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, defaultImportTracker, injectableRegistry, isCore, semanticDepGraphUpdater, this.closureCompilerEnabled, compileUndecoratedClassesWithAngularFeatures, this.delegatingPerfRecorder),
+                new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, this.closureCompilerEnabled, compileUndecoratedClassesWithAngularFeatures, this.delegatingPerfRecorder),
                 // clang-format on
                 // Pipe handler must be before injectable handler in list so pipe factories are printed
                 // before injectable factories (so injectable factories can delegate to them)
-                new PipeDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, defaultImportTracker, injectableRegistry, isCore, this.delegatingPerfRecorder),
-                new InjectableDecoratorHandler(reflector, defaultImportTracker, isCore, this.options.strictInjectionParameters || false, injectableRegistry, this.delegatingPerfRecorder),
-                new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, this.adapter.factoryTracker, defaultImportTracker, this.closureCompilerEnabled, injectableRegistry, this.delegatingPerfRecorder, this.options.i18nInLocale),
+                new PipeDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, this.delegatingPerfRecorder),
+                new InjectableDecoratorHandler(reflector, isCore, this.options.strictInjectionParameters || false, injectableRegistry, this.delegatingPerfRecorder),
+                new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, this.adapter.factoryTracker, this.closureCompilerEnabled, injectableRegistry, this.delegatingPerfRecorder, this.options.i18nInLocale),
             ];
             const traitCompiler = new TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalDriver, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater);
             const templateTypeChecker = new TemplateTypeCheckerImpl(this.tsProgram, this.typeCheckingProgramStrategy, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalDriver, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
@@ -40464,7 +40599,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                 mwpScanner,
                 metaReader,
                 typeCheckScopeRegistry,
-                defaultImportTracker,
                 aliasingHost,
                 refEmitter,
                 templateTypeChecker,
@@ -41039,7 +41173,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      */
     function toAttributeString(attribute) {
         var _a, _b;
-        if (attribute instanceof BoundEvent) {
+        if (attribute instanceof BoundEvent || attribute instanceof BoundAttribute) {
             return `[${attribute.name}]`;
         }
         else {
@@ -41217,6 +41351,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      * 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 PRE_COMPILED_STYLE_EXTENSIONS = ['.scss', '.sass', '.less', '.styl'];
     class LanguageServiceAdapter {
         constructor(project) {
             this.project = project;
@@ -41233,6 +41368,22 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.lastReadResourceVersion = new Map();
             this.rootDirs = getRootDirs(this, project.getCompilationSettings());
         }
+        resourceNameToFileName(url, fromFile, fallbackResolve) {
+            var _a;
+            // If we are trying to resolve a `.css` file, see if we can find a pre-compiled file with the
+            // same name instead. That way, we can provide go-to-definition for the pre-compiled files which
+            // would generally be the desired behavior.
+            if (url.endsWith('.css')) {
+                const styleUrl = path.resolve(fromFile, '..', url);
+                for (const ext of PRE_COMPILED_STYLE_EXTENSIONS) {
+                    const precompiledFileUrl = styleUrl.replace(/\.css$/, ext);
+                    if (this.fileExists(precompiledFileUrl)) {
+                        return precompiledFileUrl;
+                    }
+                }
+            }
+            return (_a = fallbackResolve === null || fallbackResolve === void 0 ? void 0 : fallbackResolve(url, fromFile)) !== null && _a !== void 0 ? _a : null;
+        }
         isShim(sf) {
             return isShim(sf);
         }
@@ -42292,17 +42443,17 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * Get completions for a property expression in a global context (e.g. `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletion(options) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
-            const { componentContext, templateContext } = completions;
+            const { componentContext, templateContext, nodeContext: astContext } = completions;
             const replacementSpan = makeReplacementSpanFromAst(this.node);
             // Merge TS completion results with results from the template scope.
             let entries = [];
-            const tsLsCompletions = this.tsLS.getCompletionsAtPosition(componentContext.shimPath, componentContext.positionInShimFile, options);
-            if (tsLsCompletions !== undefined) {
-                for (const tsCompletion of tsLsCompletions.entries) {
+            const componentCompletions = this.tsLS.getCompletionsAtPosition(componentContext.shimPath, componentContext.positionInShimFile, options);
+            if (componentCompletions !== undefined) {
+                for (const tsCompletion of componentCompletions.entries) {
                     // Skip completions that are shadowed by a template entity definition.
                     if (templateContext.has(tsCompletion.name)) {
                         continue;
@@ -42313,6 +42464,20 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                         replacementSpan }));
                 }
             }
+            // Merge TS completion results with results from the ast context.
+            if (astContext !== null) {
+                const nodeCompletions = this.tsLS.getCompletionsAtPosition(astContext.shimPath, astContext.positionInShimFile, options);
+                if (nodeCompletions !== undefined) {
+                    for (const tsCompletion of nodeCompletions.entries) {
+                        if (this.isValidNodeContextCompletion(tsCompletion)) {
+                            entries.push(Object.assign(Object.assign({}, tsCompletion), { 
+                                // Substitute the TS completion's `replacementSpan` (which uses offsets within the
+                                // TCB) with the `replacementSpan` within the template source.
+                                replacementSpan }));
+                        }
+                    }
+                }
+            }
             for (const [name, entity] of templateContext) {
                 entries.push({
                     name,
@@ -42338,7 +42503,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
@@ -42371,7 +42536,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletionSymbol(entryName) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
@@ -42643,6 +42808,24 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 isNewIdentifierLocation: false,
             };
         }
+        /**
+         * From the AST node of the cursor position, include completion of string literals, number
+         * literals, `true`, `false`, `null`, and `undefined`.
+         */
+        isValidNodeContextCompletion(completion) {
+            if (completion.kind === ts$1.ScriptElementKind.string) {
+                // 'string' kind includes both string literals and number literals
+                return true;
+            }
+            if (completion.kind === ts$1.ScriptElementKind.keyword) {
+                return completion.name === 'true' || completion.name === 'false' ||
+                    completion.name === 'null';
+            }
+            if (completion.kind === ts$1.ScriptElementKind.variableElement) {
+                return completion.name === 'undefined';
+            }
+            return false;
+        }
     }
     function makeReplacementSpanFromParseSourceSpan(span) {
         return {
@@ -43460,6 +43643,9 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                         entries.set(createLocationKey(entry), entry);
                     }
                 }
+                else {
+                    entries.set(createLocationKey(ref), ref);
+                }
             }
             return Array.from(entries.values());
         }