@typespec/compiler 1.10.0-dev.1 → 1.10.0-dev.10

package/dist/src/core/parser.js

@@ -2,7 +2,8 @@ import { isArray, mutate } from "../utils/misc.js";
 import { codePointBefore, isIdentifierContinue, trim } from "./charcode.js";
 import { compilerAssert } from "./diagnostics.js";
 import { createDiagnostic } from "./messages.js";
-import { createScanner, isComment, isKeyword, isPunctuation, isReservedKeyword, isStatementKeyword, isTrivia, skipContinuousIdentifier, skipTrivia, skipTriviaBackward, Token, TokenDisplay, TokenFlags, } from "./scanner.js";
+import { modifiersToFlags } from "./modifiers.js";
+import { createScanner, isComment, isKeyword, isModifier, isPunctuation, isReservedKeyword, isStatementKeyword, isTrivia, skipContinuousIdentifier, skipTrivia, skipTriviaBackward, Token, TokenDisplay, TokenFlags, } from "./scanner.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
 /**
  * The fixed set of options for each of the kinds of delimited lists in TypeSpec.
@@ -221,35 +222,6 @@ function createParser(code, options = {}) {
                     reportInvalidDecorators(decorators, "import statement");
                     item = parseImportStatement();
                     break;
-                case Token.ModelKeyword:
-                    item = parseModelStatement(pos, decorators);
-                    break;
-                case Token.ScalarKeyword:
-                    item = parseScalarStatement(pos, decorators);
-                    break;
-                case Token.NamespaceKeyword:
-                    item = parseNamespaceStatement(pos, decorators, docs, directives);
-                    break;
-                case Token.InterfaceKeyword:
-                    item = parseInterfaceStatement(pos, decorators);
-                    break;
-                case Token.UnionKeyword:
-                    item = parseUnionStatement(pos, decorators);
-                    break;
-                case Token.OpKeyword:
-                    item = parseOperationStatement(pos, decorators);
-                    break;
-                case Token.EnumKeyword:
-                    item = parseEnumStatement(pos, decorators);
-                    break;
-                case Token.AliasKeyword:
-                    reportInvalidDecorators(decorators, "alias statement");
-                    item = parseAliasStatement(pos);
-                    break;
-                case Token.ConstKeyword:
-                    reportInvalidDecorators(decorators, "const statement");
-                    item = parseConstStatement(pos);
-                    break;
                 case Token.UsingKeyword:
                     reportInvalidDecorators(decorators, "using statement");
                     item = parseUsingStatement(pos);
@@ -259,10 +231,20 @@ function createParser(code, options = {}) {
                     item = parseEmptyStatement(pos);
                     break;
                 // Start of declaration with modifiers
+                case Token.NamespaceKeyword:
+                case Token.ModelKeyword:
+                case Token.ScalarKeyword:
+                case Token.InterfaceKeyword:
+                case Token.UnionKeyword:
+                case Token.OpKeyword:
+                case Token.EnumKeyword:
+                case Token.AliasKeyword:
+                case Token.ConstKeyword:
                 case Token.ExternKeyword:
+                case Token.InternalKeyword:
                 case Token.FnKeyword:
                 case Token.DecKeyword:
-                    item = parseDeclaration(pos);
+                    item = parseDeclaration(pos, decorators, docs, directives);
                     break;
                 default:
                     item = parseInvalidStatement(pos, decorators);
@@ -312,47 +294,24 @@ function createParser(code, options = {}) {
                     item = parseImportStatement();
                     error({ code: "import-first", messageId: "topLevel", target: item });
                     break;
-                case Token.ModelKeyword:
-                    item = parseModelStatement(pos, decorators);
+                case Token.UsingKeyword:
+                    reportInvalidDecorators(decorators, "using statement");
+                    item = parseUsingStatement(pos);
                     break;
+                case Token.ModelKeyword:
                 case Token.ScalarKeyword:
-                    item = parseScalarStatement(pos, decorators);
-                    break;
                 case Token.NamespaceKeyword:
-                    const ns = parseNamespaceStatement(pos, decorators, docs, directives);
-                    if (isBlocklessNamespace(ns)) {
-                        error({ code: "blockless-namespace-first", messageId: "topLevel", target: ns });
-                    }
-                    item = ns;
-                    break;
                 case Token.InterfaceKeyword:
-                    item = parseInterfaceStatement(pos, decorators);
-                    break;
                 case Token.UnionKeyword:
-                    item = parseUnionStatement(pos, decorators);
-                    break;
                 case Token.OpKeyword:
-                    item = parseOperationStatement(pos, decorators);
-                    break;
                 case Token.EnumKeyword:
-                    item = parseEnumStatement(pos, decorators);
-                    break;
                 case Token.AliasKeyword:
-                    reportInvalidDecorators(decorators, "alias statement");
-                    item = parseAliasStatement(pos);
-                    break;
                 case Token.ConstKeyword:
-                    reportInvalidDecorators(decorators, "const statement");
-                    item = parseConstStatement(pos);
-                    break;
-                case Token.UsingKeyword:
-                    reportInvalidDecorators(decorators, "using statement");
-                    item = parseUsingStatement(pos);
-                    break;
                 case Token.ExternKeyword:
+                case Token.InternalKeyword:
                 case Token.FnKeyword:
                 case Token.DecKeyword:
-                    item = parseDeclaration(pos);
+                    item = parseDeclaration(pos, decorators, docs, directives);
                     break;
                 case Token.EndOfFile:
                     parseExpected(Token.CloseBrace);
@@ -365,6 +324,9 @@ function createParser(code, options = {}) {
                     item = parseInvalidStatement(pos, decorators);
                     break;
             }
+            if (isBlocklessNamespace(item)) {
+                error({ code: "blockless-namespace-first", messageId: "topLevel", target: item });
+            }
             mutate(item).directives = directives;
             if (tok !== Token.NamespaceKeyword) {
                 mutate(item).docs = docs;
@@ -387,7 +349,7 @@ function createParser(code, options = {}) {
         }
         return directives;
     }
-    function parseNamespaceStatement(pos, decorators, docs, directives) {
+    function parseNamespaceStatement(pos, decorators, modifiers, docs, directives) {
         parseExpected(Token.NamespaceKeyword);
         let currentName = parseIdentifierOrMemberExpression();
         const nsSegments = [];
@@ -410,6 +372,8 @@ function createParser(code, options = {}) {
             locals: undefined,
             statements,
             directives: directives,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
         for (let i = 1; i < nsSegments.length; i++) {
@@ -420,12 +384,14 @@ function createParser(code, options = {}) {
                 id: nsSegments[i],
                 statements: outerNs,
                 locals: undefined,
+                modifiers: [],
+                modifierFlags: 0 /* ModifierFlags.None */,
                 ...finishNode(pos),
             };
         }
         return outerNs;
     }
-    function parseInterfaceStatement(pos, decorators) {
+    function parseInterfaceStatement(pos, decorators, modifiers) {
         parseExpected(Token.InterfaceKeyword);
         const id = parseIdentifier();
         const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -438,7 +404,7 @@ function createParser(code, options = {}) {
             error({ code: "token-expected", format: { token: "'extends' or '{'" } });
             nextToken();
         }
-        const { items: operations, range: bodyRange } = parseList(ListKind.InterfaceMembers, (pos, decorators) => parseOperationStatement(pos, decorators, true));
+        const { items: operations, range: bodyRange } = parseList(ListKind.InterfaceMembers, (pos, decorators) => parseOperationStatement(pos, decorators, /* modifiers */ undefined, true));
         return {
             kind: SyntaxKind.InterfaceStatement,
             id,
@@ -448,6 +414,8 @@ function createParser(code, options = {}) {
             bodyRange,
             extends: extendList.items,
             decorators,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
@@ -465,7 +433,7 @@ function createParser(code, options = {}) {
         }
         return detail;
     }
-    function parseUnionStatement(pos, decorators) {
+    function parseUnionStatement(pos, decorators, modifiers) {
         parseExpected(Token.UnionKeyword);
         const id = parseIdentifier();
         const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -476,6 +444,8 @@ function createParser(code, options = {}) {
             templateParameters,
             templateParametersRange,
             decorators,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             options,
             ...finishNode(pos),
         };
@@ -483,11 +453,16 @@ function createParser(code, options = {}) {
     function parseIdOrValueForVariant() {
         const nextToken = token();
         let id;
-        if (isReservedKeyword(nextToken)) {
+        if (isReservedKeyword(nextToken) || isModifier(nextToken)) {
             id = parseIdentifier({ allowReservedIdentifier: true });
             // If the next token is not a colon this means we tried to use the reserved keyword as a type reference
             if (token() !== Token.Colon) {
-                error({ code: "reserved-identifier", messageId: "future", format: { name: id.sv } });
+                if (isReservedKeyword(nextToken)) {
+                    error({ code: "reserved-identifier", messageId: "future", format: { name: id.sv } });
+                }
+                else {
+                    error({ code: "reserved-identifier" });
+                }
             }
             return {
                 kind: SyntaxKind.TypeReference,
@@ -552,11 +527,14 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function parseOperationStatement(pos, decorators, inInterface) {
+    function parseOperationStatement(pos, decorators, _modifiers, inInterface) {
+        let modifiers;
         if (inInterface) {
+            modifiers = parseModifiers();
             parseOptional(Token.OpKeyword);
         }
         else {
+            modifiers = _modifiers;
             parseExpected(Token.OpKeyword);
         }
         const id = parseIdentifier();
@@ -597,6 +575,8 @@ function createParser(code, options = {}) {
             templateParametersRange,
             signature,
             decorators,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
@@ -611,7 +591,7 @@ function createParser(code, options = {}) {
         };
         return parameters;
     }
-    function parseModelStatement(pos, decorators) {
+    function parseModelStatement(pos, decorators, modifiers) {
         parseExpected(Token.ModelKeyword);
         const id = parseIdentifier();
         const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -641,6 +621,8 @@ function createParser(code, options = {}) {
             decorators,
             properties: propDetail.items,
             bodyRange: propDetail.range,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
@@ -661,7 +643,7 @@ function createParser(code, options = {}) {
         const id = parseIdentifier();
         let constraint;
         if (parseOptional(Token.ExtendsKeyword)) {
-            constraint = parseMixedParameterConstraint();
+            constraint = parseMixedConstraint();
         }
         let def;
         if (parseOptional(Token.Equals)) {
@@ -680,13 +662,13 @@ function createParser(code, options = {}) {
             return parseValueOfExpression();
         }
         else if (parseOptional(Token.OpenParen)) {
-            const expr = parseMixedParameterConstraint();
+            const expr = parseMixedConstraint();
             parseExpected(Token.CloseParen);
             return expr;
         }
         return parseIntersectionExpressionOrHigher();
     }
-    function parseMixedParameterConstraint() {
+    function parseMixedConstraint() {
         const pos = tokenPos();
         parseOptional(Token.Bar);
         const node = parseValueOfExpressionOrIntersectionOrHigher();
@@ -771,7 +753,7 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function parseScalarStatement(pos, decorators) {
+    function parseScalarStatement(pos, decorators, modifiers) {
         parseExpected(Token.ScalarKeyword);
         const id = parseIdentifier();
         const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -786,6 +768,8 @@ function createParser(code, options = {}) {
             members,
             bodyRange,
             decorators,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
@@ -816,7 +800,7 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function parseEnumStatement(pos, decorators) {
+    function parseEnumStatement(pos, decorators, modifiers) {
         parseExpected(Token.EnumKeyword);
         const id = parseIdentifier();
         const { items: members } = parseList(ListKind.EnumMembers, parseEnumMemberOrSpread);
@@ -824,6 +808,8 @@ function createParser(code, options = {}) {
             kind: SyntaxKind.EnumStatement,
             id,
             decorators,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             members,
             ...finishNode(pos),
         };
@@ -871,7 +857,7 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function parseAliasStatement(pos) {
+    function parseAliasStatement(pos, modifiers) {
         parseExpected(Token.AliasKeyword);
         const id = parseIdentifier();
         const { items: templateParameters, range: templateParametersRange } = parseTemplateParameterList();
@@ -884,10 +870,12 @@ function createParser(code, options = {}) {
             templateParameters,
             templateParametersRange,
             value,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
-    function parseConstStatement(pos) {
+    function parseConstStatement(pos, modifiers) {
         parseExpected(Token.ConstKeyword);
         const id = parseIdentifier();
         const type = parseOptionalTypeAnnotation();
@@ -899,6 +887,8 @@ function createParser(code, options = {}) {
             id,
             value,
             type,
+            modifiers,
+            modifierFlags: modifiersToFlags(modifiers),
             ...finishNode(pos),
         };
     }
@@ -923,6 +913,14 @@ function createParser(code, options = {}) {
             const expr = parseIntersectionExpressionOrHigher();
             options.push(expr);
         }
+        for (const fnVariant of options.filter((n) => n.kind === SyntaxKind.FunctionTypeExpression)) {
+            if (!fnVariant.parenthesized) {
+                error({
+                    code: "fn-in-union-expression",
+                    target: fnVariant,
+                });
+            }
+        }
         return {
             kind: SyntaxKind.UnionExpression,
             options,
@@ -1013,6 +1011,19 @@ function createParser(code, options = {}) {
             }
         }
     }
+    function parseFunctionTypeExpression() {
+        const pos = tokenPos();
+        parseExpected(Token.FnKeyword);
+        const { items: parameters } = parseFunctionParameters();
+        const optionalReturnType = parseOptional(Token.EqualsGreaterThan);
+        const returnType = optionalReturnType ? parseMixedConstraint() : undefined;
+        return {
+            kind: SyntaxKind.FunctionTypeExpression,
+            parameters,
+            returnType,
+            ...finishNode(pos),
+        };
+    }
     function parseReferenceExpression(message) {
         const pos = tokenPos();
         const target = parseIdentifierOrMemberExpression({
@@ -1255,6 +1266,8 @@ function createParser(code, options = {}) {
             switch (token()) {
                 case Token.TypeOfKeyword:
                     return parseTypeOfExpression();
+                case Token.FnKeyword:
+                    return parseFunctionTypeExpression();
                 case Token.Identifier:
                     return parseCallOrReferenceExpression();
                 case Token.StringLiteral:
@@ -1303,6 +1316,14 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
+    function parseInternalKeyword() {
+        const pos = tokenPos();
+        parseExpected(Token.InternalKeyword);
+        return {
+            kind: SyntaxKind.InternalKeyword,
+            ...finishNode(pos),
+        };
+    }
     function parseVoidKeyword() {
         const pos = tokenPos();
         parseExpected(Token.VoidKeyword);
@@ -1332,7 +1353,7 @@ function createParser(code, options = {}) {
         parseExpected(Token.OpenParen);
         const expr = parseExpression();
         parseExpected(Token.CloseParen);
-        return { ...expr, ...finishNode(pos) };
+        return { parenthesized: true, ...expr, ...finishNode(pos) };
     }
     function parseTupleExpression() {
         const pos = tokenPos();
@@ -1490,8 +1511,10 @@ function createParser(code, options = {}) {
     }
     function parseIdentifier(options) {
         if (isKeyword(token())) {
-            error({ code: "reserved-identifier" });
-            return createMissingIdentifier();
+            if (!(isModifier(token()) && options?.allowReservedIdentifier)) {
+                error({ code: "reserved-identifier" });
+                return createMissingIdentifier();
+            }
         }
         else if (isReservedKeyword(token())) {
             if (!options?.allowReservedIdentifier) {
@@ -1514,9 +1537,29 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function parseDeclaration(pos) {
+    function parseDeclaration(pos, decorators, docs, directives) {
         const modifiers = parseModifiers();
         switch (token()) {
+            case Token.ModelKeyword:
+                return parseModelStatement(pos, decorators, modifiers);
+            case Token.ScalarKeyword:
+                return parseScalarStatement(pos, decorators, modifiers);
+            case Token.NamespaceKeyword:
+                return parseNamespaceStatement(pos, decorators, modifiers, docs, directives);
+            case Token.InterfaceKeyword:
+                return parseInterfaceStatement(pos, decorators, modifiers);
+            case Token.UnionKeyword:
+                return parseUnionStatement(pos, decorators, modifiers);
+            case Token.OpKeyword:
+                return parseOperationStatement(pos, decorators, modifiers);
+            case Token.EnumKeyword:
+                return parseEnumStatement(pos, decorators, modifiers);
+            case Token.AliasKeyword:
+                reportInvalidDecorators(decorators, "alias statement");
+                return parseAliasStatement(pos, modifiers);
+            case Token.ConstKeyword:
+                reportInvalidDecorators(decorators, "const statement");
+                return parseConstStatement(pos, modifiers);
             case Token.DecKeyword:
                 return parseDecoratorDeclarationStatement(pos, modifiers);
             case Token.FnKeyword:
@@ -1536,6 +1579,8 @@ function createParser(code, options = {}) {
         switch (token()) {
             case Token.ExternKeyword:
                 return parseExternKeyword();
+            case Token.InternalKeyword:
+                return parseInternalKeyword();
             default:
                 return undefined;
         }
@@ -1578,7 +1623,7 @@ function createParser(code, options = {}) {
         const { items: parameters } = parseFunctionParameters();
         let returnType;
         if (parseOptional(Token.Colon)) {
-            returnType = parseExpression();
+            returnType = parseMixedConstraint();
         }
         parseExpected(Token.Semicolon);
         return {
@@ -1618,7 +1663,7 @@ function createParser(code, options = {}) {
         const optional = parseOptional(Token.Question);
         let type;
         if (parseOptional(Token.Colon)) {
-            type = parseMixedParameterConstraint();
+            type = parseMixedConstraint();
         }
         return {
             kind: SyntaxKind.FunctionParameter,
@@ -1629,17 +1674,6 @@ function createParser(code, options = {}) {
             ...finishNode(pos),
         };
     }
-    function modifiersToFlags(modifiers) {
-        let flags = 0 /* ModifierFlags.None */;
-        for (const modifier of modifiers) {
-            switch (modifier.kind) {
-                case SyntaxKind.ExternKeyword:
-                    flags |= 2 /* ModifierFlags.Extern */;
-                    break;
-            }
-        }
-        return flags;
-    }
     function parseRange(mode, range, callback) {
         const savedMode = currentMode;
         const result = scanner.scanRange(range, () => {
@@ -2298,7 +2332,8 @@ export function visitChildren(node, cb) {
         case SyntaxKind.ImportStatement:
             return visitNode(cb, node.path);
         case SyntaxKind.OperationStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitNode(cb, node.signature));
@@ -2307,11 +2342,13 @@ export function visitChildren(node, cb) {
         case SyntaxKind.OperationSignatureReference:
             return visitNode(cb, node.baseOperation);
         case SyntaxKind.NamespaceStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 (isArray(node.statements) ? visitEach(cb, node.statements) : visitNode(cb, node.statements)));
         case SyntaxKind.InterfaceStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitEach(cb, node.extends) ||
@@ -2332,14 +2369,16 @@ export function visitChildren(node, cb) {
         case SyntaxKind.ModelSpreadProperty:
             return visitNode(cb, node.target);
         case SyntaxKind.ModelStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitNode(cb, node.extends) ||
                 visitNode(cb, node.is) ||
                 visitEach(cb, node.properties));
         case SyntaxKind.ScalarStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitEach(cb, node.members) ||
@@ -2347,24 +2386,32 @@ export function visitChildren(node, cb) {
         case SyntaxKind.ScalarConstructor:
             return visitNode(cb, node.id) || visitEach(cb, node.parameters);
         case SyntaxKind.UnionStatement:
-            return (visitEach(cb, node.decorators) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitEach(cb, node.options));
         case SyntaxKind.UnionVariant:
             return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
         case SyntaxKind.EnumStatement:
-            return (visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitEach(cb, node.members));
+            return (visitEach(cb, node.modifiers) ||
+                visitEach(cb, node.decorators) ||
+                visitNode(cb, node.id) ||
+                visitEach(cb, node.members));
         case SyntaxKind.EnumMember:
             return visitEach(cb, node.decorators) || visitNode(cb, node.id) || visitNode(cb, node.value);
         case SyntaxKind.EnumSpreadMember:
             return visitNode(cb, node.target);
         case SyntaxKind.AliasStatement:
-            return (visitNode(cb, node.id) ||
+            return (visitEach(cb, node.modifiers) ||
+                visitNode(cb, node.id) ||
                 visitEach(cb, node.templateParameters) ||
                 visitNode(cb, node.value));
         case SyntaxKind.ConstStatement:
-            return visitNode(cb, node.id) || visitNode(cb, node.value) || visitNode(cb, node.type);
+            return (visitEach(cb, node.modifiers) ||
+                visitNode(cb, node.id) ||
+                visitNode(cb, node.value) ||
+                visitNode(cb, node.type));
         case SyntaxKind.DecoratorDeclarationStatement:
             return (visitEach(cb, node.modifiers) ||
                 visitNode(cb, node.id) ||
@@ -2375,6 +2422,8 @@ export function visitChildren(node, cb) {
                 visitNode(cb, node.id) ||
                 visitEach(cb, node.parameters) ||
                 visitNode(cb, node.returnType));
+        case SyntaxKind.FunctionTypeExpression:
+            return visitEach(cb, node.parameters) || visitNode(cb, node.returnType);
         case SyntaxKind.FunctionParameter:
             return visitNode(cb, node.id) || visitNode(cb, node.type);
         case SyntaxKind.TypeReference:
@@ -2428,6 +2477,7 @@ export function visitChildren(node, cb) {
         case SyntaxKind.VoidKeyword:
         case SyntaxKind.NeverKeyword:
         case SyntaxKind.ExternKeyword:
+        case SyntaxKind.InternalKeyword:
         case SyntaxKind.UnknownKeyword:
         case SyntaxKind.JsSourceFile:
         case SyntaxKind.JsNamespaceDeclaration:
@@ -2600,6 +2650,9 @@ export function getIdentifierContext(id) {
         case SyntaxKind.DecoratorExpression:
             kind = IdentifierKind.Decorator;
             break;
+        case SyntaxKind.CallExpression:
+            kind = IdentifierKind.Function;
+            break;
         case SyntaxKind.UsingStatement:
             kind = IdentifierKind.Using;
             break;