tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-contextual.js

@@ -1,6 +1,6 @@
 // Contextual typing: the type an expression's position implies, and contextual signatures.
 import { resolvedReturnTypeOf } from './side-state.js';
-import { getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
+import { getArguments, getInitializer, getName, getParameters, getType, getText, getSymbol, getTypeParameters, JsxAttribute, JsxElement, } from './ast.js';
 import { getImmediatelyInvokedFunctionExpression, isFunctionExpressionOrArrowFunction, isObjectLiteralMethod, isStatic, } from './binder-utilities.js';
 import { filterType, getIntersectionType, getNumberLiteralType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, getEndElementCount, getStringLiteralType, getTypeArguments, getTypeReferenceArity, mapType, mapTypeEx, isTupleType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { combineUnionOrIntersectionMemberSignatures, compareTypeParametersIdentical, findApplicableIndexInfo, getApparentType, getBaseConstraintOrType, getIndexInfosOfStructuredType, getPropertiesOfType, getPropertyOfType, getReducedType, getSignaturesOfType, } from './checker-members.js';
@@ -68,6 +68,116 @@ export function findContextualNode(c, node, includeCaches) {
             return i;
     return -1;
 }
+/**
+ * The id of the contextual type in force for `node`, or -1 if the node's contextual type is not on
+ * the stack. A key built from -1 can't tell a check under a contextual type that was not pushed from
+ * a check with no contextual type, so callers record nothing under -1.
+ */
+export function getContextualTypeId(c, node) {
+    const index = findContextualNode(c, node, true);
+    if (index < 0)
+        return -1;
+    const t = c.inferenceCaches.contextualTypes[index];
+    return t === undefined ? -1 : t.id;
+}
+/**
+ * Whether a check of `node` has no contextual type and no inference context, so its type is a
+ * function of the node and the check mode alone: the node is not on the contextual stack, no
+ * inference context contains it, and its parent gives it no contextual type. The parents answered
+ * here are the ones `getContextualTypeEx` returns `undefined` for without computing anything; a
+ * parent it computes a type for is not answered, so the result is never "yes" for a check that
+ * could have a contextual type.
+ *
+ * Types computed inside a flow loop are provisional (the checker does not cache them either), so a
+ * check in a loop is not context-free. The same holds while a reduce label is in force, as when
+ * flow analysis revisits a `finally` block with the antecedents of one outgoing path: the flow
+ * state differs from the one the earlier check of the block saw.
+ */
+export function isCheckedWithoutContextualType(c, node) {
+    if (c.flowLoopStack.length !== 0)
+        return false;
+    if (c.flowReduceLabels.length !== 0)
+        return false;
+    if (findContextualNode(c, node, true) >= 0)
+        return false;
+    if (getInferenceContext(c, node) !== undefined)
+        return false;
+    const parent = node.parent;
+    if (parent === undefined)
+        return true;
+    switch (parent.kind) {
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 210 /* SyntaxKind.BindingElement */:
+            // Only the initializer is contextually typed by the declaration.
+            return getInitializer(parent) !== node;
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */: {
+            // Only the arguments are contextually typed by the parameters; the callee is not.
+            const args = getArguments(parent);
+            if (args !== undefined) {
+                for (const arg of args.nodes)
+                    if (arg === node)
+                        return false;
+            }
+            return true;
+        }
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            // Only a method takes the property's contextual type.
+            return node.kind !== 176 /* SyntaxKind.MethodDeclaration */;
+        case 228 /* SyntaxKind.BinaryExpression */: {
+            const binary = parent;
+            if (binary.type !== undefined)
+                return false;
+            switch (binary.operatorToken.kind) {
+                case 63 /* SyntaxKind.EqualsToken */:
+                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                case 75 /* SyntaxKind.BarBarEqualsToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                    return node !== binary.right;
+                case 56 /* SyntaxKind.BarBarToken */:
+                case 60 /* SyntaxKind.QuestionQuestionToken */:
+                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+                case 27 /* SyntaxKind.CommaToken */:
+                    return false;
+            }
+            return true;
+        }
+        case 229 /* SyntaxKind.ConditionalExpression */: {
+            const conditional = parent;
+            return node !== conditional.whenTrue && node !== conditional.whenFalse;
+        }
+        case 241 /* SyntaxKind.TemplateSpan */: {
+            // Only a tagged template types its spans.
+            const template = parent.parent;
+            return template.parent === undefined || template.parent.kind !== 217 /* SyntaxKind.TaggedTemplateExpression */;
+        }
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 231 /* SyntaxKind.YieldExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+            return false;
+    }
+    return true;
+}
 export function pushInferenceContext(c, node, context) {
     const caches = c.inferenceCaches;
     const depth = caches.inferenceDepth;
@@ -98,7 +208,7 @@ export function getInferenceContext(c, node) {
 }
 /** The node a contextual type for `node` is pushed onto: an element for its attributes, which spans its children. */
 function getContextNode(node) {
-    if (node.kind === 293 /* SyntaxKind.JsxAttributes */ && node.parent.kind !== 286 /* SyntaxKind.JsxSelfClosingElement */)
+    if (node.kind === 294 /* SyntaxKind.JsxAttributes */ && node.parent.kind !== 287 /* SyntaxKind.JsxSelfClosingElement */)
         return node.parent.parent;
     return node;
 }
@@ -175,56 +285,56 @@ export function getContextualTypeEx(c, node, contextFlags) {
     if (parent === undefined)
         return undefined;
     switch (parent.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 209 /* SyntaxKind.BindingElement */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 210 /* SyntaxKind.BindingElement */:
             if (getInitializer(parent) !== node)
                 return undefined;
             return getContextualTypeForInitializerExpression(c, parent, contextFlags);
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 254 /* SyntaxKind.ReturnStatement */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 255 /* SyntaxKind.ReturnStatement */:
             return getContextualTypeForReturnExpression(c, node);
-        case 230 /* SyntaxKind.YieldExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
             return getContextualTypeForYieldOperand(c, parent, contextFlags);
-        case 224 /* SyntaxKind.AwaitExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
             return getContextualTypeForAwaitOperand(c, parent, contextFlags);
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return getContextualTypeForArgument(c, parent, node);
-        case 171 /* SyntaxKind.Decorator */: {
+        case 172 /* SyntaxKind.Decorator */: {
             // A decorator expression is contextually typed by the call the runtime makes.
             const signature = getDecoratorCallSignature(c, parent);
             return signature !== undefined ? getOrCreateTypeFromSignature(c, signature) : undefined;
         }
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */: {
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */: {
             const typeNode = getType(parent);
             return isConstTypeReference(typeNode)
                 ? getContextualTypeEx(c, parent, contextFlags)
                 : getTypeFromTypeNode(c, typeNode);
         }
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return getTypeFromTypeNode(c, getType(parent));
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             // A JSDoc `@type` on `export default`.
             const typeNode = getType(parent);
             return typeNode !== undefined ? getTypeFromTypeNode(c, typeNode) : undefined;
         }
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return getContextualTypeForBinaryOperand(c, parent, node, contextFlags);
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             // The property's name gets the property's contextual type too.
             return getContextualTypeForObjectLiteralElement(c, parent, contextFlags);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            return node.kind === 175 /* SyntaxKind.MethodDeclaration */
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            return node.kind === 176 /* SyntaxKind.MethodDeclaration */
                 ? getContextualTypeForObjectLiteralElement(c, node, contextFlags)
                 : undefined;
-        case 305 /* SyntaxKind.SpreadAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
             return getContextualTypeEx(c, parent.parent, contextFlags);
-        case 210 /* SyntaxKind.ArrayLiteralExpression */: {
+        case 211 /* SyntaxKind.ArrayLiteralExpression */: {
             const elements = parent.elements.nodes;
             const index = indexOfNode(elements, node);
             if (index < 0)
@@ -232,28 +342,28 @@ export function getContextualTypeEx(c, node, contextFlags) {
             const spreads = getSpreadIndices(c, parent, elements);
             return getContextualTypeForElementExpression(c, getApparentTypeOfContextualTypeEx(c, parent, contextFlags), index, elements.length, spreads.first, spreads.last);
         }
-        case 228 /* SyntaxKind.ConditionalExpression */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = parent;
             return node === cond.whenTrue || node === cond.whenFalse
                 ? getContextualTypeEx(c, parent, contextFlags)
                 : undefined;
         }
-        case 240 /* SyntaxKind.TemplateSpan */: {
+        case 241 /* SyntaxKind.TemplateSpan */: {
             const template = parent.parent;
-            return template.parent !== undefined && template.parent.kind === 216 /* SyntaxKind.TaggedTemplateExpression */
+            return template.parent !== undefined && template.parent.kind === 217 /* SyntaxKind.TaggedTemplateExpression */
                 ? getContextualTypeForArgument(c, template.parent, node)
                 : undefined;
         }
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return getContextualTypeEx(c, parent, contextFlags);
-        case 295 /* SyntaxKind.JsxExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
             return getContextualTypeForJsxExpression(c, parent, contextFlags);
-        case 292 /* SyntaxKind.JsxAttribute */:
-        case 294 /* SyntaxKind.JsxSpreadAttribute */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
             return getContextualTypeForJsxAttribute(c, parent, contextFlags);
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             return getContextualJsxElementAttributesType(c, parent, contextFlags);
     }
     return undefined;
@@ -266,7 +376,7 @@ function getContextualTypeForInitializerExpression(c, declaration, contextFlags)
     const name = getName(declaration);
     if ((contextFlags & 8 /* ContextFlags.SkipBindingPatterns */) === 0 &&
         name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) &&
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */) &&
         getElements(name).nodes.length > 0)
         return getTypeFromBindingPattern(c, name, true, false);
     return undefined;
@@ -275,17 +385,20 @@ function getContextualTypeForInitializer(c, declaration, contextFlags) {
     const typeNode = getType(declaration);
     if (typeNode !== undefined)
         return getTypeFromTypeNode(c, typeNode);
-    if (declaration.kind === 170 /* SyntaxKind.Parameter */)
+    if (declaration.kind === 171 /* SyntaxKind.Parameter */)
         return getContextuallyTypedParameterTypeOrUndefined(c, declaration);
-    if (declaration.kind === 209 /* SyntaxKind.BindingElement */)
+    if (declaration.kind === 210 /* SyntaxKind.BindingElement */)
         return getContextualTypeForBindingElement(c, declaration);
     // A static property of a class expression takes the type of the same property of the class's contextual type.
-    if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+    if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         isStatic(declaration) &&
-        declaration.parent.kind === 232 /* SyntaxKind.ClassExpression */) {
+        declaration.parent.kind === 233 /* SyntaxKind.ClassExpression */) {
         const parentType = getContextualTypeEx(c, declaration.parent, contextFlags);
         const symbol = getSymbolOfDeclaration(c, declaration);
-        if (parentType !== undefined && symbol !== undefined)
+        // The class's own type might still be in progress, so contextually typing by it would report a spurious circularity.
+        if (parentType !== undefined &&
+            symbol !== undefined &&
+            parentType.symbol !== getSymbolOfDeclaration(c, declaration.parent))
             return getTypeOfPropertyOfContextualType(c, parentType, symbol.name);
     }
     return undefined;
@@ -295,18 +408,18 @@ function getContextualTypeForBindingElement(c, declaration) {
     const element = declaration;
     const name = element.propertyName ?? element.name;
     if (name === undefined ||
-        name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
-        name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ ||
-        (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputedName(name)))
+        name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ ||
+        name.kind === 209 /* SyntaxKind.ArrayBindingPattern */ ||
+        (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputedName(name)))
         return undefined;
     const parent = declaration.parent.parent;
     let parentType = getContextualTypeForInitializer(c, parent, 0 /* ContextFlags.None */);
-    if (parentType === undefined && parent.kind !== 209 /* SyntaxKind.BindingElement */ && getInitializer(parent) !== undefined)
+    if (parentType === undefined && parent.kind !== 210 /* SyntaxKind.BindingElement */ && getInitializer(parent) !== undefined)
         parentType = checkDeclarationInitializer(c, parent, element.dotDotDotToken !== undefined ? 32 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */);
     if (parentType === undefined)
         return undefined;
     const parentName = getName(parent);
-    if (parentName.kind === 208 /* SyntaxKind.ArrayBindingPattern */) {
+    if (parentName.kind === 209 /* SyntaxKind.ArrayBindingPattern */) {
         const index = getElements(parentName).nodes.indexOf(declaration);
         if (index < 0)
             return undefined;
@@ -498,7 +611,7 @@ function getSpreadIndices(c, node, elements) {
     let first = -1;
     let last = -1;
     for (let i = 0; i < elements.length; i++)
-        if (elements[i].kind === 231 /* SyntaxKind.SpreadElement */) {
+        if (elements[i].kind === 232 /* SyntaxKind.SpreadElement */) {
             if (first < 0)
                 first = i;
             last = i;
@@ -524,7 +637,7 @@ function getContextualTypeForObjectLiteralElement(c, element, contextFlags) {
             let nameType = symbol !== undefined ? c.symbolNameTypes.get(getSymbolId(symbol)) : undefined;
             // Late-bound members are named by the type of their computed name, like a unique symbol.
             const nameNode = getName(element);
-            if (nameType === undefined && nameNode.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (nameType === undefined && nameNode.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 nameType = checkComputedPropertyName(c, nameNode);
             return getTypeOfPropertyOfContextualTypeEx(c, t, name, nameType);
         }
@@ -629,7 +742,7 @@ function getTypeOfConcretePropertyOfContextualType(c, t, name) {
 }
 /** Whether the type of a mapped type property is being resolved. */
 function isCircularMappedProperty(c, symbol) {
-    return ((symbol.checkFlags & 262144 /* CheckFlags.Mapped */) !== 0 &&
+    return ((symbol.checkFlags & 2097152 /* CheckFlags.Mapped */) !== 0 &&
         c.symbolTypes.get(getSymbolId(symbol)) === undefined &&
         findResolutionCycleStartIndex(c, symbol, 0 /* TypeSystemPropertyName.Type */) >= 0);
 }
@@ -697,9 +810,9 @@ export function getApparentTypeOfContextualTypeEx(c, node, contextFlags) {
         : mapTypeEx(c, t, (u) => ((u.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 ? u : getApparentType(c, u)), true);
     if (apparentType === undefined)
         return undefined;
-    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
         return discriminateContextualTypeByObjectMembers(c, node, apparentType);
-    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 293 /* SyntaxKind.JsxAttributes */)
+    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 294 /* SyntaxKind.JsxAttributes */)
         return discriminateContextualTypeByJSXAttributes(c, node, apparentType);
     return apparentType;
 }
@@ -732,10 +845,10 @@ function discriminateContextualTypeByObjectMembers(c, node, contextualType) {
             const symbol = getSymbol(p);
             if (symbol === undefined)
                 continue;
-            if ((p.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+            if ((p.kind === 304 /* SyntaxKind.PropertyAssignment */ &&
                 isPossiblyDiscriminantValue(p.initializer) &&
                 isDiscriminantProperty(c, contextualType, symbol.name)) ||
-                (p.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ && isDiscriminantProperty(c, contextualType, symbol.name)))
+                (p.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */ && isDiscriminantProperty(c, contextualType, symbol.name)))
                 props.push(p);
         }
         const nodeSymbol = getSymbol(node);
@@ -789,7 +902,7 @@ function getMatchingUnionConstituentForObjectLiteral(c, unionType, node) {
     for (const p of getProperties(node).nodes) {
         const symbol = getSymbol(p);
         if (symbol !== undefined &&
-            p.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+            p.kind === 304 /* SyntaxKind.PropertyAssignment */ &&
             symbol.name === keyPropertyName &&
             isPossiblyDiscriminantValue(p.initializer)) {
             propNode = p;
@@ -807,17 +920,17 @@ function isPossiblyDiscriminantValue(node) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
         case 111 /* SyntaxKind.TrueKeyword */:
         case 96 /* SyntaxKind.FalseKeyword */:
         case 105 /* SyntaxKind.NullKeyword */:
         case 79 /* SyntaxKind.Identifier */:
         case 157 /* SyntaxKind.UndefinedKeyword */:
             return true;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return isPossiblyDiscriminantValue(getExpression(node));
-        case 295 /* SyntaxKind.JsxExpression */: {
+        case 296 /* SyntaxKind.JsxExpression */: {
             const expression = getExpression(node);
             return expression === undefined || isPossiblyDiscriminantValue(expression);
         }
@@ -912,7 +1025,7 @@ function discriminantMatches(c, props, index, t) {
     let propType;
     if (index < props.length) {
         const prop = props[index];
-        if (prop.kind === 303 /* SyntaxKind.PropertyAssignment */)
+        if (prop.kind === 304 /* SyntaxKind.PropertyAssignment */)
             propType = getContextFreeTypeOfExpression(c, prop.initializer);
         else if (prop instanceof JsxAttribute)
             // An attribute without an initializer is `true`.
@@ -957,7 +1070,7 @@ export function hasContextSensitiveParameters(func) {
     for (const p of params)
         if (getType(p) === undefined)
             return true;
-    if (func.kind !== 220 /* SyntaxKind.ArrowFunction */) {
+    if (func.kind !== 221 /* SyntaxKind.ArrowFunction */) {
         // Without an explicit `this` parameter, the implicit one is contextually typed.
         if (params.length === 0 || !isThisParameter(params[0]))
             return (func.flags & 128 /* NodeFlags.ContainsThis */) !== 0;
@@ -1084,7 +1197,7 @@ export function getContextuallyTypedParameterType(c, parameter) {
 }
 /** The contextual type of an intra-expression inference site. */
 export function getContextualTypeForInference(c, node) {
-    return node.kind === 175 /* SyntaxKind.MethodDeclaration */
+    return node.kind === 176 /* SyntaxKind.MethodDeclaration */
         ? getContextualTypeForObjectLiteralElement(c, node, 2 /* ContextFlags.NoConstraints */)
         : getContextualTypeEx(c, node, 2 /* ContextFlags.NoConstraints */);
 }
@@ -1109,7 +1222,7 @@ function getThisTypeOfObjectLiteralFromContextualType(c, containingLiteral, cont
         const thisType = getThisTypeFromContextualType(c, t);
         if (thisType !== undefined)
             return thisType;
-        if (literal.parent.kind !== 303 /* SyntaxKind.PropertyAssignment */)
+        if (literal.parent.kind !== 304 /* SyntaxKind.PropertyAssignment */)
             break;
         literal = literal.parent.parent;
         t = getApparentTypeOfContextualTypeEx(c, literal, 0 /* ContextFlags.None */);