Fixed an issue with contextual type for intersection properties

Author: Andarist

src/compiler/checker.ts

@@ -26811,16 +26811,25 @@ namespace ts {
         }
 
         function getTypeOfPropertyOfContextualType(type: Type, name: __String, nameType?: Type) {
-            return mapType(type, t => {
+            return mapType(type, function propertyOfContextualTypeMapper(t): Type | undefined {
                 if (isGenericMappedType(t) && !t.declaration.nameType) {
                     const constraint = getConstraintTypeFromMappedType(t);
                     const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
                     const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
+                    return undefined;
+                }
+                if (t.flags & TypeFlags.Intersection) {
+                    const intersection = t as IntersectionType;
+                    const newTypes = intersection.types.map(propertyOfContextualTypeMapper).filter((t): t is Type => !!t);
+                    if (newTypes.length === 0) {
+                        return undefined;
+                    }
+                    return getIntersectionType(newTypes);
                 }
-                else if (t.flags & TypeFlags.StructuredType) {
+                if (t.flags & TypeFlags.StructuredType) {
                     const prop = getPropertyOfType(t, name);
                     if (prop) {
                         return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop);

tests/baselines/reference/contextualTypeFunctionObjectPropertyIntersection.errors.txt

@@ -72,7 +72,9 @@ createMachine({
 >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.symbols

@@ -39,7 +39,7 @@ declare function createMachine<TEvent extends { type: string }>(
 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: any) => 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"; }; }
@@ -54,18 +54,18 @@ createMachine({
 
   },
   on: {
->on : { FOO: (ev: any) => void; }
->{    FOO: (ev) => {      ev.type; // should be 'FOO'    },  } : { FOO: (ev: any) => void; }
+>on : { FOO: (ev: { type: "FOO"; }) => void; }
+>{    FOO: (ev) => {      ev.type; // should be 'FOO'    },  } : { FOO: (ev: { type: "FOO"; }) => void; }
 
     FOO: (ev) => {
->FOO : (ev: any) => void
->(ev) => {      ev.type; // should be 'FOO'    } : (ev: any) => void
->ev : any
+>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 : any
->ev : any
->type : any
+>ev.type : "FOO"
+>ev : { type: "FOO"; }
+>type : "FOO"
 
     },
   },