Revert "Fixed an issue with contextual type for intersection properties (#48668)" (#50279)

This reverts commit 9236e39374.

src/compiler/checker.ts

@@ -27130,27 +27130,7 @@ namespace ts {
         }
 
         function getTypeOfPropertyOfContextualType(type: Type, name: __String, nameType?: Type) {
-            return mapType(type, (t): Type | undefined => {
-                if (t.flags & TypeFlags.Intersection) {
-                    const intersection = t as IntersectionType;
-                    let newTypes = mapDefined(intersection.types, getTypeOfConcretePropertyOfContextualType);
-                    if (newTypes.length > 0) {
-                        return getIntersectionType(newTypes);
-                    }
-                    newTypes = mapDefined(intersection.types, getTypeOfApplicableIndexInfoOfContextualType);
-                    if (newTypes.length > 0) {
-                        return getIntersectionType(newTypes);
-                    }
-                    return undefined;
-                }
-                const concretePropertyType = getTypeOfConcretePropertyOfContextualType(t);
-                if (concretePropertyType) {
-                    return concretePropertyType;
-                }
-                return getTypeOfApplicableIndexInfoOfContextualType(t);
-            }, /*noReductions*/ true);
-
-            function getTypeOfConcretePropertyOfContextualType(t: Type) {
+            return mapType(type, t => {
                 if (isGenericMappedType(t) && !t.declaration.nameType) {
                     const constraint = getConstraintTypeFromMappedType(t);
                     const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
@@ -27158,9 +27138,8 @@ namespace ts {
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
-                    return undefined;
                 }
-                if (t.flags & TypeFlags.StructuredType) {
+                else if (t.flags & TypeFlags.StructuredType) {
                     const prop = getPropertyOfType(t, name);
                     if (prop) {
                         return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop);
@@ -27171,15 +27150,10 @@ namespace ts {
                             return restType;
                         }
                     }
+                    return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
                 }
                 return undefined;
-            }
-            function getTypeOfApplicableIndexInfoOfContextualType(t: Type) {
-                if (!(t.flags & TypeFlags.StructuredType)) {
-                    return undefined;
-                }
-                return findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))?.type;
-            }
+            }, /*noReductions*/ true);
         }
 
         // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of

tests/baselines/reference/contextualTypeFunctionObjectPropertyIntersection.js

@@ -1,42 +0,0 @@
-//// [contextualTypeFunctionObjectPropertyIntersection.ts]
-type Action<TEvent extends { type: string }> = (ev: TEvent) => void;
-
-interface MachineConfig<TEvent extends { type: string }> {
-  schema: {
-    events: TEvent;
-  };
-  on?: {
-    [K in TEvent["type"]]?: Action<TEvent extends { type: K } ? TEvent : never>;
-  } & {
-    "*"?: Action<TEvent>;
-  };
-}
-
-declare function createMachine<TEvent extends { type: string }>(
-  config: MachineConfig<TEvent>
-): void;
-
-createMachine({
-  schema: {
-    events: {} as { type: "FOO" } | { type: "BAR" },
-  },
-  on: {
-    FOO: (ev) => {
-      ev.type; // should be 'FOO'
-    },
-  },
-});
-
-
-//// [contextualTypeFunctionObjectPropertyIntersection.js]
-"use strict";
-createMachine({
-    schema: {
-        events: {}
-    },
-    on: {
-        FOO: function (ev) {
-            ev.type; // should be 'FOO'
-        }
-    }
-});

tests/baselines/reference/contextualTypeFunctionObjectPropertyIntersection.symbols

@@ -1,82 +0,0 @@
-=== tests/cases/compiler/contextualTypeFunctionObjectPropertyIntersection.ts ===
-type Action<TEvent extends { type: string }> = (ev: TEvent) => void;
->Action : Symbol(Action, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 0))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 12))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 28))
->ev : Symbol(ev, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 48))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 12))
-
-interface MachineConfig<TEvent extends { type: string }> {
->MachineConfig : Symbol(MachineConfig, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 68))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 40))
-
-  schema: {
->schema : Symbol(MachineConfig.schema, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 58))
-
-    events: TEvent;
->events : Symbol(events, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 3, 11))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
-
-  };
-  on?: {
->on : Symbol(MachineConfig.on, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 5, 4))
-
-    [K in TEvent["type"]]?: Action<TEvent extends { type: K } ? TEvent : never>;
->K : Symbol(K, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 7, 5))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
->Action : Symbol(Action, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 0))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 7, 51))
->K : Symbol(K, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 7, 5))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
-
-  } & {
-    "*"?: Action<TEvent>;
->"*" : Symbol("*", Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 8, 7))
->Action : Symbol(Action, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 0))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 2, 24))
-
-  };
-}
-
-declare function createMachine<TEvent extends { type: string }>(
->createMachine : Symbol(createMachine, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 11, 1))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 13, 31))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 13, 47))
-
-  config: MachineConfig<TEvent>
->config : Symbol(config, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 13, 64))
->MachineConfig : Symbol(MachineConfig, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 0, 68))
->TEvent : Symbol(TEvent, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 13, 31))
-
-): void;
-
-createMachine({
->createMachine : Symbol(createMachine, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 11, 1))
-
-  schema: {
->schema : Symbol(schema, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 17, 15))
-
-    events: {} as { type: "FOO" } | { type: "BAR" },
->events : Symbol(events, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 18, 11))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 19, 19))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 19, 37))
-
-  },
-  on: {
->on : Symbol(on, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 20, 4))
-
-    FOO: (ev) => {
->FOO : Symbol(FOO, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 21, 7))
->ev : Symbol(ev, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 22, 10))
-
-      ev.type; // should be 'FOO'
->ev.type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 19, 19))
->ev : Symbol(ev, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 22, 10))
->type : Symbol(type, Decl(contextualTypeFunctionObjectPropertyIntersection.ts, 19, 19))
-
-    },
-  },
-});
-

tests/baselines/reference/contextualTypeFunctionObjectPropertyIntersection.types

@@ -1,73 +0,0 @@
-=== tests/cases/compiler/contextualTypeFunctionObjectPropertyIntersection.ts ===
-type Action<TEvent extends { type: string }> = (ev: TEvent) => void;
->Action : Action<TEvent>
->type : string
->ev : TEvent
-
-interface MachineConfig<TEvent extends { type: string }> {
->type : string
-
-  schema: {
->schema : { events: TEvent; }
-
-    events: TEvent;
->events : TEvent
-
-  };
-  on?: {
->on : ({ [K in TEvent["type"]]?: Action<TEvent extends { type: K; } ? TEvent : never> | undefined; } & { "*"?: Action<TEvent> | undefined; }) | undefined
-
-    [K in TEvent["type"]]?: Action<TEvent extends { type: K } ? TEvent : never>;
->type : K
-
-  } & {
-    "*"?: Action<TEvent>;
->"*" : Action<TEvent> | undefined
-
-  };
-}
-
-declare function createMachine<TEvent extends { type: string }>(
->createMachine : <TEvent extends { type: string; }>(config: MachineConfig<TEvent>) => void
->type : string
-
-  config: MachineConfig<TEvent>
->config : MachineConfig<TEvent>
-
-): void;
-
-createMachine({
->createMachine({  schema: {    events: {} as { type: "FOO" } | { type: "BAR" },  },  on: {    FOO: (ev) => {      ev.type; // should be 'FOO'    },  },}) : void
->createMachine : <TEvent extends { type: string; }>(config: MachineConfig<TEvent>) => void
->{  schema: {    events: {} as { type: "FOO" } | { type: "BAR" },  },  on: {    FOO: (ev) => {      ev.type; // should be 'FOO'    },  },} : { schema: { events: { type: "FOO"; } | { type: "BAR"; }; }; on: { FOO: (ev: { type: "FOO"; }) => void; }; }
-
-  schema: {
->schema : { events: { type: "FOO"; } | { type: "BAR"; }; }
->{    events: {} as { type: "FOO" } | { type: "BAR" },  } : { events: { type: "FOO"; } | { type: "BAR"; }; }
-
-    events: {} as { type: "FOO" } | { type: "BAR" },
->events : { type: "FOO"; } | { type: "BAR"; }
->{} as { type: "FOO" } | { type: "BAR" } : { type: "FOO"; } | { type: "BAR"; }
->{} : {}
->type : "FOO"
->type : "BAR"
-
-  },
-  on: {
->on : { FOO: (ev: { type: "FOO"; }) => void; }
->{    FOO: (ev) => {      ev.type; // should be 'FOO'    },  } : { FOO: (ev: { type: "FOO"; }) => void; }
-
-    FOO: (ev) => {
->FOO : (ev: { type: "FOO"; }) => void
->(ev) => {      ev.type; // should be 'FOO'    } : (ev: { type: "FOO"; }) => void
->ev : { type: "FOO"; }
-
-      ev.type; // should be 'FOO'
->ev.type : "FOO"
->ev : { type: "FOO"; }
->type : "FOO"
-
-    },
-  },
-});
-

tests/cases/compiler/contextualTypeFunctionObjectPropertyIntersection.ts

@@ -1,29 +0,0 @@
-// @strict: true
-
-type Action<TEvent extends { type: string }> = (ev: TEvent) => void;
-
-interface MachineConfig<TEvent extends { type: string }> {
-  schema: {
-    events: TEvent;
-  };
-  on?: {
-    [K in TEvent["type"]]?: Action<TEvent extends { type: K } ? TEvent : never>;
-  } & {
-    "*"?: Action<TEvent>;
-  };
-}
-
-declare function createMachine<TEvent extends { type: string }>(
-  config: MachineConfig<TEvent>
-): void;
-
-createMachine({
-  schema: {
-    events: {} as { type: "FOO" } | { type: "BAR" },
-  },
-  on: {
-    FOO: (ev) => {
-      ev.type; // should be 'FOO'
-    },
-  },
-});