@angular/language-service 10.1.4 → 10.2.1

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v10.1.4
+ * @license Angular v10.2.1
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -10780,11 +10780,12 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
     function extractCommentsWithHash(input) {
         return input.match(_commentWithHashRe) || [];
     }
-    const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
-    const _curlyRe = /([{}])/g;
-    const OPEN_CURLY = '{';
-    const CLOSE_CURLY = '}';
     const BLOCK_PLACEHOLDER = '%BLOCK%';
+    const QUOTE_PLACEHOLDER = '%QUOTED%';
+    const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+    const _quotedRe = /%QUOTED%/g;
+    const CONTENT_PAIRS = new Map([['{', '}']]);
+    const QUOTE_PAIRS = new Map([[`"`, `"`], [`'`, `'`]]);
     class CssRule {
         constructor(selector, content) {
             this.selector = selector;
@@ -10792,9 +10793,12 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
         }
     }
     function processRules(input, ruleCallback) {
-        const inputWithEscapedBlocks = escapeBlocks(input);
+        const inputWithEscapedQuotes = escapeBlocks(input, QUOTE_PAIRS, QUOTE_PLACEHOLDER);
+        const inputWithEscapedBlocks = escapeBlocks(inputWithEscapedQuotes.escapedString, CONTENT_PAIRS, BLOCK_PLACEHOLDER);
         let nextBlockIndex = 0;
-        return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function (...m) {
+        let nextQuoteIndex = 0;
+        return inputWithEscapedBlocks.escapedString
+            .replace(_ruleRe, (...m) => {
             const selector = m[2];
             let content = '';
             let suffix = m[4];
@@ -10806,7 +10810,8 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             }
             const rule = ruleCallback(new CssRule(selector, content));
             return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
-        });
+        })
+            .replace(_quotedRe, () => inputWithEscapedQuotes.blocks[nextQuoteIndex++]);
     }
     class StringWithEscapedBlocks {
         constructor(escapedString, blocks) {
@@ -10814,35 +10819,46 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             this.blocks = blocks;
         }
     }
-    function escapeBlocks(input) {
-        const inputParts = input.split(_curlyRe);
+    function escapeBlocks(input, charPairs, placeholder) {
         const resultParts = [];
         const escapedBlocks = [];
-        let bracketCount = 0;
-        let currentBlockParts = [];
-        for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
-            const part = inputParts[partIndex];
-            if (part == CLOSE_CURLY) {
-                bracketCount--;
-            }
-            if (bracketCount > 0) {
-                currentBlockParts.push(part);
-            }
-            else {
-                if (currentBlockParts.length > 0) {
-                    escapedBlocks.push(currentBlockParts.join(''));
-                    resultParts.push(BLOCK_PLACEHOLDER);
-                    currentBlockParts = [];
-                }
-                resultParts.push(part);
-            }
-            if (part == OPEN_CURLY) {
-                bracketCount++;
-            }
+        let openCharCount = 0;
+        let nonBlockStartIndex = 0;
+        let blockStartIndex = -1;
+        let openChar;
+        let closeChar;
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if (char === '\\') {
+                i++;
+            }
+            else if (char === closeChar) {
+                openCharCount--;
+                if (openCharCount === 0) {
+                    escapedBlocks.push(input.substring(blockStartIndex, i));
+                    resultParts.push(placeholder);
+                    nonBlockStartIndex = i;
+                    blockStartIndex = -1;
+                    openChar = closeChar = undefined;
+                }
+            }
+            else if (char === openChar) {
+                openCharCount++;
+            }
+            else if (openCharCount === 0 && charPairs.has(char)) {
+                openChar = char;
+                closeChar = charPairs.get(char);
+                openCharCount = 1;
+                blockStartIndex = i + 1;
+                resultParts.push(input.substring(nonBlockStartIndex, blockStartIndex));
+            }
+        }
+        if (blockStartIndex !== -1) {
+            escapedBlocks.push(input.substring(blockStartIndex));
+            resultParts.push(placeholder);
         }
-        if (currentBlockParts.length > 0) {
-            escapedBlocks.push(currentBlockParts.join(''));
-            resultParts.push(BLOCK_PLACEHOLDER);
+        else {
+            resultParts.push(input.substring(nonBlockStartIndex));
         }
         return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
     }
@@ -13958,43 +13974,77 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             const span = new ParseSpan(0, input == null ? 0 : input.length);
             return new ASTWithSource(new Interpolation(span, span.toAbsolute(absoluteOffset), split.strings, expressions), input, location, absoluteOffset, this.errors);
         }
+        /**
+         * Splits a string of text into "raw" text segments and expressions present in interpolations in
+         * the string.
+         * Returns `null` if there are no interpolations, otherwise a
+         * `SplitInterpolation` with splits that look like
+         *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
+         */
         splitInterpolation(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-            const regexp = _getInterpolateRegExp(interpolationConfig);
-            const parts = input.split(regexp);
-            if (parts.length <= 1) {
-                return null;
-            }
             const strings = [];
             const expressions = [];
             const offsets = [];
             const stringSpans = [];
             const expressionSpans = [];
-            let offset = 0;
-            for (let i = 0; i < parts.length; i++) {
-                const part = parts[i];
-                if (i % 2 === 0) {
-                    // fixed string
+            let i = 0;
+            let atInterpolation = false;
+            let extendLastString = false;
+            let { start: interpStart, end: interpEnd } = interpolationConfig;
+            while (i < input.length) {
+                if (!atInterpolation) {
+                    // parse until starting {{
+                    const start = i;
+                    i = input.indexOf(interpStart, i);
+                    if (i === -1) {
+                        i = input.length;
+                    }
+                    const part = input.substring(start, i);
                     strings.push(part);
-                    const start = offset;
-                    offset += part.length;
-                    stringSpans.push({ start, end: offset });
-                }
-                else if (part.trim().length > 0) {
-                    const start = offset;
-                    offset += interpolationConfig.start.length;
-                    expressions.push(part);
-                    offsets.push(offset);
-                    offset += part.length + interpolationConfig.end.length;
-                    expressionSpans.push({ start, end: offset });
+                    stringSpans.push({ start, end: i });
+                    atInterpolation = true;
                 }
                 else {
-                    this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${this._findInterpolationErrorColumn(parts, i, interpolationConfig)} in`, location);
-                    expressions.push('$implicit');
-                    offsets.push(offset);
-                    expressionSpans.push({ start: offset, end: offset });
+                    // parse from starting {{ to ending }}
+                    const fullStart = i;
+                    const exprStart = fullStart + interpStart.length;
+                    const exprEnd = input.indexOf(interpEnd, exprStart);
+                    if (exprEnd === -1) {
+                        // Could not find the end of the interpolation; do not parse an expression.
+                        // Instead we should extend the content on the last raw string.
+                        atInterpolation = false;
+                        extendLastString = true;
+                        break;
+                    }
+                    const fullEnd = exprEnd + interpEnd.length;
+                    const part = input.substring(exprStart, exprEnd);
+                    if (part.trim().length > 0) {
+                        expressions.push(part);
+                    }
+                    else {
+                        this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location);
+                        expressions.push('$implicit');
+                    }
+                    offsets.push(exprStart);
+                    expressionSpans.push({ start: fullStart, end: fullEnd });
+                    i = fullEnd;
+                    atInterpolation = false;
+                }
+            }
+            if (!atInterpolation) {
+                // If we are now at a text section, add the remaining content as a raw string.
+                if (extendLastString) {
+                    strings[strings.length - 1] += input.substring(i);
+                    stringSpans[stringSpans.length - 1].end = input.length;
+                }
+                else {
+                    strings.push(input.substring(i));
+                    stringSpans.push({ start: i, end: input.length });
                 }
             }
-            return new SplitInterpolation(strings, stringSpans, expressions, expressionSpans, offsets);
+            return expressions.length === 0 ?
+                null :
+                new SplitInterpolation(strings, stringSpans, expressions, expressionSpans, offsets);
         }
         wrapLiteralPrimitive(input, location, absoluteOffset) {
             const span = new ParseSpan(0, input == null ? 0 : input.length);
@@ -14043,6 +14093,19 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             this.simpleExpressionChecker = IvySimpleExpressionChecker; //
         }
     }
+    /** Describes a stateful context an expression parser is in. */
+    var ParseContextFlags;
+    (function (ParseContextFlags) {
+        ParseContextFlags[ParseContextFlags["None"] = 0] = "None";
+        /**
+         * A Writable context is one in which a value may be written to an lvalue.
+         * For example, after we see a property access, we may expect a write to the
+         * property via the "=" operator.
+         *   prop
+         *        ^ possible "=" after
+         */
+        ParseContextFlags[ParseContextFlags["Writable"] = 1] = "Writable";
+    })(ParseContextFlags || (ParseContextFlags = {}));
     class _ParseAST {
         constructor(input, location, absoluteOffset, tokens, inputLength, parseAction, errors, offset) {
             this.input = input;
@@ -14056,6 +14119,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             this.rparensExpected = 0;
             this.rbracketsExpected = 0;
             this.rbracesExpected = 0;
+            this.context = ParseContextFlags.None;
             // Cache of expression start and input indeces to the absolute source span they map to, used to
             // prevent creating superfluous source spans in `sourceSpan`.
             // A serial of the expression start and input index is used for mapping because both are stateful
@@ -14116,6 +14180,15 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
         advance() {
             this.index++;
         }
+        /**
+         * Executes a callback in the provided context.
+         */
+        withContext(context, cb) {
+            this.context |= context;
+            const ret = cb();
+            this.context ^= context;
+            return ret;
+        }
         consumeOptionalCharacter(code) {
             if (this.next.isCharacter(code)) {
                 this.advance();
@@ -14131,6 +14204,12 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
         peekKeywordAs() {
             return this.next.isKeywordAs();
         }
+        /**
+         * Consumes an expected character, otherwise emits an error about the missing expected character
+         * and skips over the token stream until reaching a recoverable point.
+         *
+         * See `this.error` and `this.skip` for more details.
+         */
         expectCharacter(code) {
             if (this.consumeOptionalCharacter(code))
                 return;
@@ -14150,10 +14229,13 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                 return;
             this.error(`Missing expected operator ${operator}`);
         }
+        prettyPrintToken(tok) {
+            return tok === EOF ? 'end of input' : `token ${tok}`;
+        }
         expectIdentifierOrKeyword() {
             const n = this.next;
             if (!n.isIdentifier() && !n.isKeyword()) {
-                this.error(`Unexpected token ${n}, expected identifier or keyword`);
+                this.error(`Unexpected ${this.prettyPrintToken(n)}, expected identifier or keyword`);
                 return '';
             }
             this.advance();
@@ -14162,7 +14244,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
         expectIdentifierOrKeywordOrString() {
             const n = this.next;
             if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
-                this.error(`Unexpected token ${n}, expected identifier, keyword, or string`);
+                this.error(`Unexpected ${this.prettyPrintToken(n)}, expected identifier, keyword, or string`);
                 return '';
             }
             this.advance();
@@ -14366,17 +14448,23 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                     result = this.parseAccessMemberOrMethodCall(result, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
-                    this.rbracketsExpected++;
-                    const key = this.parsePipe();
-                    this.rbracketsExpected--;
-                    this.expectCharacter($RBRACKET);
-                    if (this.consumeOptionalOperator('=')) {
-                        const value = this.parseConditional();
-                        result = new KeyedWrite(this.span(resultStart), this.sourceSpan(resultStart), result, key, value);
-                    }
-                    else {
-                        result = new KeyedRead(this.span(resultStart), this.sourceSpan(resultStart), result, key);
-                    }
+                    this.withContext(ParseContextFlags.Writable, () => {
+                        this.rbracketsExpected++;
+                        const key = this.parsePipe();
+                        if (key instanceof EmptyExpr) {
+                            this.error(`Key access cannot be empty`);
+                        }
+                        this.rbracketsExpected--;
+                        this.expectCharacter($RBRACKET);
+                        if (this.consumeOptionalOperator('=')) {
+                            const value = this.parseConditional();
+                            result = new KeyedWrite(this.span(resultStart), this.sourceSpan(resultStart), result, key, value);
+                        }
+                        else {
+                            result =
+                                new KeyedRead(this.span(resultStart), this.sourceSpan(resultStart), result, key);
+                        }
+                    });
                 }
                 else if (this.consumeOptionalCharacter($LPAREN)) {
                     this.rparensExpected++;
@@ -14715,6 +14803,10 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
         consumeStatementTerminator() {
             this.consumeOptionalCharacter($SEMICOLON) || this.consumeOptionalCharacter($COMMA);
         }
+        /**
+         * Records an error and skips over the token stream until reaching a recoverable point. See
+         * `this.skip` for more details on token skipping.
+         */
         error(message, index = null) {
             this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));
             this.skip();
@@ -14725,24 +14817,32 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             return (index < this.tokens.length) ? `at column ${this.tokens[index].index + 1} in` :
                 `at the end of the expression`;
         }
-        // Error recovery should skip tokens until it encounters a recovery point. skip() treats
-        // the end of input and a ';' as unconditionally a recovery point. It also treats ')',
-        // '}' and ']' as conditional recovery points if one of calling productions is expecting
-        // one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing
-        // more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because
-        // of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols
-        // must be conditional as they must be skipped if none of the calling productions are not
-        // expecting the closing token else we will never make progress in the case of an
-        // extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because
-        // parseChain() is always the root production and it expects a ';'.
-        // If a production expects one of these token it increments the corresponding nesting count,
-        // and then decrements it just prior to checking if the token is in the input.
+        /**
+         * Error recovery should skip tokens until it encounters a recovery point. skip() treats
+         * the end of input and a ';' as unconditionally a recovery point. It also treats ')',
+         * '}' and ']' as conditional recovery points if one of calling productions is expecting
+         * one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing
+         * more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because
+         * of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols
+         * must be conditional as they must be skipped if none of the calling productions are not
+         * expecting the closing token else we will never make progress in the case of an
+         * extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because
+         * parseChain() is always the root production and it expects a ';'.
+         *
+         * Furthermore, the presence of a stateful context can add more recovery points.
+         *   - in a `Writable` context, we are able to recover after seeing the `=` operator, which
+         *     signals the presence of an independent rvalue expression following the `=` operator.
+         *
+         * If a production expects one of these token it increments the corresponding nesting count,
+         * and then decrements it just prior to checking if the token is in the input.
+         */
         skip() {
             let n = this.next;
             while (this.index < this.tokens.length && !n.isCharacter($SEMICOLON) &&
                 (this.rparensExpected <= 0 || !n.isCharacter($RPAREN)) &&
                 (this.rbracesExpected <= 0 || !n.isCharacter($RBRACE)) &&
-                (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET))) {
+                (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET)) &&
+                (!(this.context & ParseContextFlags.Writable) || !n.isOperator('='))) {
                 if (this.next.isError()) {
                     this.errors.push(new ParserError(this.next.toString(), this.input, this.locationText(), this.location));
                 }
@@ -19066,7 +19166,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
      * 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('10.1.4');
+    const VERSION$1 = new Version('10.2.1');
 
     /**
      * @license
@@ -19659,7 +19759,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
      * 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('10.1.4');
+    const VERSION$2 = new Version('10.2.1');
 
     /**
      * @license
@@ -20078,12 +20178,20 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
      */
     class LocalIdentifierStrategy {
         emit(ref, context, importFlags) {
+            const refSf = getSourceFile(ref.node);
             // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a
             // local identifier at all, *except* in the source file where the node is actually declared.
-            if (importFlags & ImportFlags.ForceNewImport &&
-                getSourceFile(ref.node) !== getSourceFile(context)) {
+            if (importFlags & ImportFlags.ForceNewImport && refSf !== context) {
                 return null;
             }
+            // If referenced node is not an actual TS declaration (e.g. `class Foo` or `function foo() {}`,
+            // etc) and it is in the current file then just use it directly.
+            // This is important because the reference could be a property access (e.g. `exports.foo`). In
+            // such a case, the reference's `identities` property would be `[foo]`, which would result in an
+            // invalid emission of a free-standing `foo` identifier, rather than `exports.foo`.
+            if (!isDeclaration(ref.node) && refSf === context) {
+                return new WrappedNodeExpr(ref.node);
+            }
             // A Reference can have multiple identities in different files, so it may already have an
             // Identifier in the requested context file.
             const identifier = ref.getIdentityIn(context);
@@ -20166,11 +20274,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             }
             const exportMap = new Map();
             exports.forEach((declaration, name) => {
-                // It's okay to skip inline declarations, since by definition they're not target-able with a
-                // ts.Declaration anyway.
-                if (declaration.node !== null) {
-                    exportMap.set(declaration.node, name);
-                }
+                exportMap.set(declaration.node, name);
             });
             return exportMap;
         }
@@ -20842,6 +20946,13 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
          */
         KnownDeclaration[KnownDeclaration["TsHelperSpreadArrays"] = 3] = "TsHelperSpreadArrays";
     })(KnownDeclaration || (KnownDeclaration = {}));
+    /**
+     * Returns true if the `decl` is a `ConcreteDeclaration` (ie. that its `node` property is a
+     * `ts.Declaration`).
+     */
+    function isConcreteDeclaration(decl) {
+        return decl.kind === 0 /* Concrete */;
+    }
 
     /**
      * @license
@@ -21093,7 +21204,10 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
      * found in the LICENSE file at https://angular.io/license
      */
     function isNamedClassDeclaration(node) {
-        return ts.isClassDeclaration(node) && (node.name !== undefined);
+        return ts.isClassDeclaration(node) && isIdentifier$1(node.name);
+    }
+    function isIdentifier$1(node) {
+        return node !== undefined && ts.isIdentifier(node);
     }
 
     /**
@@ -21184,13 +21298,13 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             if (!ts.isSourceFile(node)) {
                 throw new Error(`getExportsOfModule() called on non-SourceFile in TS code`);
             }
-            const map = new Map();
             // Reflect the module to a Symbol, and use getExportsOfModule() to get a list of exported
             // Symbols.
             const symbol = this.checker.getSymbolAtLocation(node);
             if (symbol === undefined) {
                 return null;
             }
+            const map = new Map();
             this.checker.getExportsOfModule(symbol).forEach(exportSymbol => {
                 // Map each exported Symbol to a Declaration and add it to the map.
                 const decl = this.getDeclarationOfSymbol(exportSymbol, null);
@@ -21369,6 +21483,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                     known: null,
                     viaModule,
                     identity: null,
+                    kind: 0 /* Concrete */,
                 };
             }
             else if (symbol.declarations !== undefined && symbol.declarations.length > 0) {
@@ -21377,6 +21492,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                     known: null,
                     viaModule,
                     identity: null,
+                    kind: 0 /* Concrete */,
                 };
             }
             else {
@@ -22851,12 +22967,7 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                 return this.getResolvedEnum(decl.node, decl.identity.enumMembers, context);
             }
             const declContext = Object.assign(Object.assign({}, context), joinModuleContext(context, node, decl));
-            // The identifier's declaration is either concrete (a ts.Declaration exists for it) or inline
-            // (a direct reference to a ts.Expression).
-            // TODO(alxhub): remove cast once TS is upgraded in g3.
-            const result = decl.node !== null ?
-                this.visitDeclaration(decl.node, declContext) :
-                this.visitExpression(decl.expression, declContext);
+            const result = this.visitAmbiguousDeclaration(decl, declContext);
             if (result instanceof Reference$1) {
                 // Only record identifiers to non-synthetic references. Synthetic references may not have the
                 // same value at runtime as they do at compile time, so it's not legal to refer to them by the
@@ -22957,12 +23068,18 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
                 }
                 const declContext = Object.assign(Object.assign({}, context), joinModuleContext(context, node, decl));
                 // Visit both concrete and inline declarations.
-                // TODO(alxhub): remove cast once TS is upgraded in g3.
-                return decl.node !== null ?
-                    this.visitDeclaration(decl.node, declContext) :
-                    this.visitExpression(decl.expression, declContext);
+                return this.visitAmbiguousDeclaration(decl, declContext);
             });
         }
+        visitAmbiguousDeclaration(decl, declContext) {
+            return decl.kind === 1 /* Inline */ && decl.implementation !== undefined &&
+                !isDeclaration(decl.implementation) ?
+                // Inline declarations whose `implementation` is a `ts.Expression` should be visited as
+                // an expression.
+                this.visitExpression(decl.implementation, declContext) :
+                // Otherwise just visit the `node` as a declaration.
+                this.visitDeclaration(decl.node, declContext);
+        }
         accessHelper(node, lhs, rhs, context) {
             const strIndex = `${rhs}`;
             if (lhs instanceof Map) {
@@ -23310,13 +23427,6 @@ define(['exports', 'os', 'typescript', 'fs', 'constants', 'stream', 'util', 'ass
             return null;
         }
     }
-    /**
-     * Helper type guard to workaround a narrowing limitation in g3, where testing for
-     * `decl.node !== null` would not narrow `decl` to be of type `ConcreteDeclaration`.
-     */
-    function isConcreteDeclaration(decl) {
-        return decl.node !== null;
-    }
 
     /**
      * @license
@@ -26571,10 +26681,16 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
         reflectObjectLiteral(queryData).forEach((queryExpr, propertyName) => {
             queryExpr = unwrapExpression(queryExpr);
-            if (!ts.isNewExpression(queryExpr) || !ts.isIdentifier(queryExpr.expression)) {
+            if (!ts.isNewExpression(queryExpr)) {
                 throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, 'Decorator query metadata must be an instance of a query type');
             }
-            const type = reflector.getImportOfIdentifier(queryExpr.expression);
+            const queryType = ts.isPropertyAccessExpression(queryExpr.expression) ?
+                queryExpr.expression.name :
+                queryExpr.expression;
+            if (!ts.isIdentifier(queryType)) {
+                throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, 'Decorator query metadata must be an instance of a query type');
+            }
+            const type = reflector.getImportOfIdentifier(queryType);
             if (type === null || (!isCore && type.from !== '@angular/core') ||
                 !QUERY_TYPES.has(type.name)) {
                 throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, 'Decorator query metadata must be an instance of a query type');
@@ -28100,7 +28216,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             else {
                 let typeRef = valueRef;
                 let typeNode = this.reflector.getDtsDeclaration(typeRef.node);
-                if (typeNode !== null && ts.isClassDeclaration(typeNode)) {
+                if (typeNode !== null && isNamedClassDeclaration(typeNode)) {
                     typeRef = new Reference$1(typeNode);
                 }
                 return toR3Reference(valueRef, typeRef, valueContext, typeContext, this.refEmitter);
@@ -28180,7 +28296,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return null;
         }
-        // Verify that a `ts.Declaration` reference is a `ClassDeclaration` reference.
+        // Verify that a "Declaration" reference is a `ClassDeclaration` reference.
         isClassDeclarationReference(ref) {
             return this.reflector.isClass(ref.node);
         }
@@ -28202,7 +28318,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     // Recurse into nested arrays.
                     refList.push(...this.resolveTypeList(expr, entry, className, arrayName));
                 }
-                else if (isDeclarationReference(entry)) {
+                else if (entry instanceof Reference$1) {
                     if (!this.isClassDeclarationReference(entry)) {
                         throw createValueHasWrongTypeError(entry.node, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a class`);
                     }
@@ -28220,11 +28336,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         return !compilation.directives.some(directive => directive.ref.node === node) &&
             !compilation.pipes.some(pipe => pipe.ref.node === node);
     }
-    function isDeclarationReference(ref) {
-        return ref instanceof Reference$1 &&
-            (ts.isClassDeclaration(ref.node) || ts.isFunctionDeclaration(ref.node) ||
-                ts.isVariableDeclaration(ref.node));
-    }
 
     /**
      * @license
@@ -29567,13 +29678,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             node.modifiers.some(mod => mod.kind === ts.SyntaxKind.StaticKeyword);
     }
 
-    /**
-     * @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
-     */
     const NOOP_PERF_RECORDER = {
         enabled: false,
         mark: (name, node, category, detail) => { },