diff --git a/tests/baselines/reference/controlFlowGenericTypes.types b/tests/baselines/reference/controlFlowGenericTypes.types
index b76216b121e..aa8b768d588 100644
--- a/tests/baselines/reference/controlFlowGenericTypes.types
+++ b/tests/baselines/reference/controlFlowGenericTypes.types
@@ -586,13 +586,13 @@ type Column<T> = (keyof T extends never ? { id?: number | string } : { id: T })
 >title : string | undefined
 
 function getColumnProperty<T>(column: Column<T>, key: keyof Column<T>) {
->getColumnProperty : <T>(column: Column<T>, key: keyof Column<T>) => Column<T>["title" | keyof (keyof T extends never ? { id?: string | number | undefined; } : { id: T; })]
+>getColumnProperty : <T>(column: Column<T>, key: keyof Column<T>) => Column<T>[keyof Column<T>]
 >column : Column<T>
->key : "title" | keyof (keyof T extends never ? { id?: string | number | undefined; } : { id: T; })
+>key : keyof Column<T>
 
   return column[key];
->column[key] : Column<T>["title" | keyof (keyof T extends never ? { id?: string | number | undefined; } : { id: T; })]
+>column[key] : Column<T>[keyof Column<T>]
 >column : Column<T>
->key : "title" | keyof (keyof T extends never ? { id?: string | number | undefined; } : { id: T; })
+>key : keyof Column<T>
 }
 
diff --git a/tests/baselines/reference/indexedAccessRelation.types b/tests/baselines/reference/indexedAccessRelation.types
index bc69d43328e..bfdc520d985 100644
--- a/tests/baselines/reference/indexedAccessRelation.types
+++ b/tests/baselines/reference/indexedAccessRelation.types
@@ -29,9 +29,9 @@ class Comp<T extends Foo, S> extends Component<S & State<T>>
 
         this.setState({ a: a });
 >this.setState({ a: a }) : void
->this.setState : <K extends keyof S | "a">(state: Pick<S & State<T>, K>) => void
+>this.setState : <K extends keyof (S & State<T>)>(state: Pick<S & State<T>, K>) => void
 >this : this
->setState : <K extends keyof S | "a">(state: Pick<S & State<T>, K>) => void
+>setState : <K extends keyof (S & State<T>)>(state: Pick<S & State<T>, K>) => void
 >{ a: a } : { a: T; }
 >a : T
 >a : T
diff --git a/tests/baselines/reference/keyRemappingKeyofResult.types b/tests/baselines/reference/keyRemappingKeyofResult.types
index 01569ae0dde..17929b1c769 100644
--- a/tests/baselines/reference/keyRemappingKeyofResult.types
+++ b/tests/baselines/reference/keyRemappingKeyofResult.types
@@ -58,24 +58,24 @@ function f<T>() {
 >sym : unique symbol
     
     type Okay = keyof Orig;
->Okay : string | number | unique symbol | keyof T
+>Okay : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 
     let a: Okay;
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 
     a = "str";
 >a = "str" : "str"
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >"str" : "str"
 
     a = sym;
 >a = sym : unique symbol
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >sym : unique symbol
 
     a = "whatever";
 >a = "whatever" : "whatever"
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >"whatever" : "whatever"
 
     // type Okay = string | number | typeof sym
@@ -118,24 +118,24 @@ function g<T>() {
 >sym : unique symbol
     
     type Okay = keyof Orig;
->Okay : string | number | unique symbol | keyof T
+>Okay : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 
     let a: Okay;
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 
     a = "str";
 >a = "str" : "str"
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >"str" : "str"
 
     a = sym;
 >a = sym : unique symbol
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >sym : unique symbol
 
     a = "whatever";
 >a = "whatever" : "whatever"
->a : string | number | unique symbol | keyof T
+>a : keyof ({ [k: string]: any; str: any; [sym]: any; } & T)
 >"whatever" : "whatever"
 
     // type Okay = string | number | typeof sym
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index d1aca031816..bc813debb66 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -768,11 +768,11 @@ function f70(func: <T, U>(k1: keyof (T | U), k2: keyof (T & U)) => void) {
 >f70 : (func: <T, U>(k1: keyof (T | U), k2: keyof (T & U)) => void) => void
 >func : <T, U>(k1: keyof (T | U), k2: keyof (T & U)) => void
 >k1 : keyof T & keyof U
->k2 : keyof T | keyof U
+>k2 : keyof (T & U)
 
     func<{ a: any, b: any }, { a: any, c: any }>('a', 'a');
 >func<{ a: any, b: any }, { a: any, c: any }>('a', 'a') : void
->func : <T, U>(k1: keyof T & keyof U, k2: keyof T | keyof U) => void
+>func : <T, U>(k1: keyof T & keyof U, k2: keyof (T & U)) => void
 >a : any
 >b : any
 >a : any
@@ -782,7 +782,7 @@ function f70(func: <T, U>(k1: keyof (T | U), k2: keyof (T & U)) => void) {
 
     func<{ a: any, b: any }, { a: any, c: any }>('a', 'b');
 >func<{ a: any, b: any }, { a: any, c: any }>('a', 'b') : void
->func : <T, U>(k1: keyof T & keyof U, k2: keyof T | keyof U) => void
+>func : <T, U>(k1: keyof T & keyof U, k2: keyof (T & U)) => void
 >a : any
 >b : any
 >a : any
@@ -792,7 +792,7 @@ function f70(func: <T, U>(k1: keyof (T | U), k2: keyof (T & U)) => void) {
 
     func<{ a: any, b: any }, { a: any, c: any }>('a', 'c');
 >func<{ a: any, b: any }, { a: any, c: any }>('a', 'c') : void
->func : <T, U>(k1: keyof T & keyof U, k2: keyof T | keyof U) => void
+>func : <T, U>(k1: keyof T & keyof U, k2: keyof (T & U)) => void
 >a : any
 >b : any
 >a : any
@@ -887,8 +887,8 @@ function f72(func: <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T &
 }
 
 function f73(func: <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]) {
->f73 : (func: <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T & U)[K]) => void
->func : <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T & U)[K]
+>f73 : (func: <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]) => void
+>func : <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]
 >x : T
 >y : U
 >k : K
@@ -896,7 +896,7 @@ function f73(func: <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[
     let a = func({ a: 1, b: "hello" }, { c: true }, 'a');  // number
 >a : number
 >func({ a: 1, b: "hello" }, { c: true }, 'a') : number
->func : <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T & U)[K]
+>func : <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]
 >{ a: 1, b: "hello" } : { a: number; b: string; }
 >a : number
 >1 : 1
@@ -910,7 +910,7 @@ function f73(func: <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[
     let b = func({ a: 1, b: "hello" }, { c: true }, 'b');  // string
 >b : string
 >func({ a: 1, b: "hello" }, { c: true }, 'b') : string
->func : <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T & U)[K]
+>func : <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]
 >{ a: 1, b: "hello" } : { a: number; b: string; }
 >a : number
 >1 : 1
@@ -924,7 +924,7 @@ function f73(func: <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[
     let c = func({ a: 1, b: "hello" }, { c: true }, 'c');  // boolean
 >c : boolean
 >func({ a: 1, b: "hello" }, { c: true }, 'c') : boolean
->func : <T, U, K extends keyof T | keyof U>(x: T, y: U, k: K) => (T & U)[K]
+>func : <T, U, K extends keyof (T & U)>(x: T, y: U, k: K) => (T & U)[K]
 >{ a: 1, b: "hello" } : { a: number; b: string; }
 >a : number
 >1 : 1
@@ -1573,7 +1573,7 @@ declare class Component1<Data, Computed> {
 >options : Options1<Data, Computed>
 
     get<K extends keyof (Data & Computed)>(key: K): (Data & Computed)[K];
->get : <K extends keyof Data | keyof Computed>(key: K) => (Data & Computed)[K]
+>get : <K extends keyof (Data & Computed)>(key: K) => (Data & Computed)[K]
 >key : K
 }
 
@@ -1725,9 +1725,9 @@ function onChangeGenericFunction<T>(handler: Handler<T & {preset: number}>) {
 
     handler.onChange('preset')
 >handler.onChange('preset') : void
->handler.onChange : (name: keyof T | "preset") => void
+>handler.onChange : (name: keyof (T & { preset: number; })) => void
 >handler : Handler<T & { preset: number; }>
->onChange : (name: keyof T | "preset") => void
+>onChange : (name: keyof (T & { preset: number; })) => void
 >'preset' : "preset"
 }
 
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
index e19b848ab74..3699457e1d6 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.errors.txt
@@ -22,7 +22,7 @@ keyofAndIndexedAccessErrors.ts(64,33): error TS2345: Argument of type '"name" |
   Type '"size"' is not assignable to type 'keyof Shape'.
 keyofAndIndexedAccessErrors.ts(66,24): error TS2345: Argument of type '"size"' is not assignable to parameter of type 'keyof Shape'.
 keyofAndIndexedAccessErrors.ts(67,24): error TS2345: Argument of type '"name" | "size"' is not assignable to parameter of type 'keyof Shape'.
-keyofAndIndexedAccessErrors.ts(73,5): error TS2536: Type 'keyof T | keyof U' cannot be used to index type 'T | U'.
+keyofAndIndexedAccessErrors.ts(73,5): error TS2536: Type 'keyof (T & U)' cannot be used to index type 'T | U'.
 keyofAndIndexedAccessErrors.ts(74,5): error TS2536: Type 'keyof T | keyof U' cannot be used to index type 'T | U'.
 keyofAndIndexedAccessErrors.ts(82,5): error TS2322: Type 'keyof T | keyof U' is not assignable to type 'keyof T & keyof U'.
   Type 'keyof T' is not assignable to type 'keyof T & keyof U'.
@@ -191,7 +191,7 @@ keyofAndIndexedAccessErrors.ts(165,5): error TS2322: Type 'number' is not assign
         x[k2];
         x[k3];  // Error
         ~~~~~
-!!! error TS2536: Type 'keyof T | keyof U' cannot be used to index type 'T | U'.
+!!! error TS2536: Type 'keyof (T & U)' cannot be used to index type 'T | U'.
         x[k4];  // Error
         ~~~~~
 !!! error TS2536: Type 'keyof T | keyof U' cannot be used to index type 'T | U'.
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.types b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
index 204e3582114..f380b85f237 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.types
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
@@ -211,7 +211,7 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 >y : T & U
 >k1 : keyof T & keyof U
 >k2 : keyof T & keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 >k4 : keyof T | keyof U
 
     x[k1];
@@ -227,7 +227,7 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
     x[k3];  // Error
 >x[k3] : any
 >x : T | U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 
     x[k4];  // Error
 >x[k4] : any
@@ -245,9 +245,9 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 >k2 : keyof T & keyof U
 
     y[k3];
->y[k3] : (T & U)[keyof T | keyof U]
+>y[k3] : (T & U)[keyof (T & U)]
 >y : T & U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 
     y[k4];
 >y[k4] : (T & U)[keyof T | keyof U]
@@ -260,9 +260,9 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 >k2 : keyof T & keyof U
 
     k1 = k3;  // Error
->k1 = k3 : keyof T | keyof U
+>k1 = k3 : keyof (T & U)
 >k1 : keyof T & keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 
     k1 = k4;  // Error
 >k1 = k4 : keyof T | keyof U
@@ -275,9 +275,9 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 >k1 : keyof T & keyof U
 
     k2 = k3;  // Error
->k2 = k3 : keyof T | keyof U
+>k2 = k3 : keyof (T & U)
 >k2 : keyof T & keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 
     k2 = k4;  // Error
 >k2 = k4 : keyof T | keyof U
@@ -286,17 +286,17 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 
     k3 = k1;
 >k3 = k1 : keyof T & keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 >k1 : keyof T & keyof U
 
     k3 = k2;
 >k3 = k2 : keyof T & keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 >k2 : keyof T & keyof U
 
     k3 = k4;
 >k3 = k4 : keyof T | keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 >k4 : keyof T | keyof U
 
     k4 = k1;
@@ -310,9 +310,9 @@ function f20<T, U>(x: T | U, y: T & U, k1: keyof (T | U), k2: keyof T & keyof U,
 >k2 : keyof T & keyof U
 
     k4 = k3;
->k4 = k3 : keyof T | keyof U
+>k4 = k3 : keyof (T & U)
 >k4 : keyof T | keyof U
->k3 : keyof T | keyof U
+>k3 : keyof (T & U)
 }
 
 // Repro from #17166
diff --git a/tests/baselines/reference/keyofIntersection.types b/tests/baselines/reference/keyofIntersection.types
index bc5aaea8fc6..1f54b1eab2d 100644
--- a/tests/baselines/reference/keyofIntersection.types
+++ b/tests/baselines/reference/keyofIntersection.types
@@ -10,25 +10,25 @@ type B = { b: string };
 >b : string
 
 type T01 = keyof (A & B);  // "a" | "b"
->T01 : "b" | "a"
+>T01 : "a" | "b"
 
 type T02<T> = keyof (T & B);  // "b" | keyof T
->T02 : keyof T | "b"
+>T02 : keyof (T & B)
 
 type T03<U> = keyof (A & U);  // "a" | keyof U
->T03 : "a" | keyof U
+>T03 : keyof (A & U)
 
 type T04<T, U> = keyof (T & U);  // keyof T | keyof U
->T04 : keyof T | keyof U
+>T04 : keyof (T & U)
 
 type T05 = T02<A>;  // "a" | "b"
->T05 : "b" | "a"
+>T05 : "a" | "b"
 
 type T06 = T03<B>;  // "a" | "b"
->T06 : "b" | "a"
+>T06 : "a" | "b"
 
 type T07 = T04<A, B>;  // "a" | "b"
->T07 : "b" | "a"
+>T07 : "a" | "b"
 
 // Repros from #22291
 
@@ -54,7 +54,7 @@ type Result4 = keyof Example4<'x', 'y'>;  // "x" | "y"
 >Result4 : "x" | "y"
 
 type Example5<T, U> = keyof (T & U);
->Example5 : keyof T | keyof U
+>Example5 : keyof (T & U)
 
 type Result5 = Example5<Record<'x', any>, Record<'y', any>>;  // "x" | "y"
 >Result5 : "x" | "y"
diff --git a/tests/baselines/reference/mappedTypeConstraints.types b/tests/baselines/reference/mappedTypeConstraints.types
index e835e07b142..a59ca49c05f 100644
--- a/tests/baselines/reference/mappedTypeConstraints.types
+++ b/tests/baselines/reference/mappedTypeConstraints.types
@@ -45,21 +45,21 @@ function f3<T extends { a: string, b: string }, U extends { b: string, c: string
 >b : string
 >b : string
 >c : string
->obj : Pick<T & U, keyof T | keyof U>
+>obj : Pick<T & U, keyof (T & U)>
 
     obj.a;
 >obj.a : (T & U)["a"]
->obj : Pick<T & U, keyof T | keyof U>
+>obj : Pick<T & U, keyof (T & U)>
 >a : (T & U)["a"]
 
     obj.b;
 >obj.b : (T & U)["b"]
->obj : Pick<T & U, keyof T | keyof U>
+>obj : Pick<T & U, keyof (T & U)>
 >b : (T & U)["b"]
 
     obj.c;
 >obj.c : (T & U)["c"]
->obj : Pick<T & U, keyof T | keyof U>
+>obj : Pick<T & U, keyof (T & U)>
 >c : (T & U)["c"]
 }
 
diff --git a/tests/baselines/reference/mappedTypes4.types b/tests/baselines/reference/mappedTypes4.types
index d897a9ac171..e7bcaa54414 100644
--- a/tests/baselines/reference/mappedTypes4.types
+++ b/tests/baselines/reference/mappedTypes4.types
@@ -28,19 +28,19 @@ function boxify<T>(obj: T): Boxified<T> {
 >{} : {}
 
         for (let k in obj) {
->k : Extract<keyof T, string>
+>k : Extract<keyof (T & object), string>
 >obj : (T & object) | (T & null)
 
             result[k] = { value: obj[k] };
->result[k] = { value: obj[k] } : { value: (T & object)[Extract<keyof T, string>]; }
->result[k] : Boxified<T>[Extract<keyof T, string>]
+>result[k] = { value: obj[k] } : { value: (T & object)[Extract<keyof (T & object), string>]; }
+>result[k] : Boxified<T>[Extract<keyof (T & object), string>]
 >result : Boxified<T>
->k : Extract<keyof T, string>
->{ value: obj[k] } : { value: (T & object)[Extract<keyof T, string>]; }
->value : (T & object)[Extract<keyof T, string>]
->obj[k] : (T & object)[Extract<keyof T, string>]
+>k : Extract<keyof (T & object), string>
+>{ value: obj[k] } : { value: (T & object)[Extract<keyof (T & object), string>]; }
+>value : (T & object)[Extract<keyof (T & object), string>]
+>obj[k] : (T & object)[Extract<keyof (T & object), string>]
 >obj : T & object
->k : Extract<keyof T, string>
+>k : Extract<keyof (T & object), string>
         }
         return result;
 >result : Boxified<T>