diff --git a/tests/baselines/reference/enforceReadonly1.errors.txt b/tests/baselines/reference/enforceReadonly1.errors.txt
index b526236c3ef..39764796401 100644
--- a/tests/baselines/reference/enforceReadonly1.errors.txt
+++ b/tests/baselines/reference/enforceReadonly1.errors.txt
@@ -14,8 +14,8 @@ enforceReadonly1.ts(53,11): error TS2430: Interface 'D2' incorrectly extends int
   Property 'x' is 'readonly' in the source but not in the target.
 enforceReadonly1.ts(61,7): error TS2415: Class 'D3' incorrectly extends base class 'B3'.
   Property 'x' is 'readonly' in the source but not in the target.
-enforceReadonly1.ts(108,3): error TS2540: Cannot assign to 'value' because it is a read-only property.
-enforceReadonly1.ts(110,5): error TS2322: Type 'ImmutableValue<string>' is not assignable to type 'MutableValue<string>'.
+enforceReadonly1.ts(100,3): error TS2540: Cannot assign to 'value' because it is a read-only property.
+enforceReadonly1.ts(102,5): error TS2322: Type 'ImmutableValue<string>' is not assignable to type 'MutableValue<string>'.
   Property 'value' is 'readonly' in the source but not in the target.
 
 
@@ -110,14 +110,6 @@ enforceReadonly1.ts(110,5): error TS2322: Type 'ImmutableValue<string>' is not a
         readonly x = 1;
     }
     
-    class B4 {
-        foo() {}
-    }
-    
-    class D4 extends B4 {  // Error
-        readonly foo = () => {}
-    }
-    
     // A const assertion means "as const as possible" without violating constraints
     
     const x1 = { a: "hello", b: 42 };
diff --git a/tests/baselines/reference/enforceReadonly1.symbols b/tests/baselines/reference/enforceReadonly1.symbols
index 3a860fb8ee0..9d99e846bdf 100644
--- a/tests/baselines/reference/enforceReadonly1.symbols
+++ b/tests/baselines/reference/enforceReadonly1.symbols
@@ -180,179 +180,164 @@ class D3 extends B3 {  // Error
 >x : Symbol(D3.x, Decl(enforceReadonly1.ts, 60, 21))
 }
 
-class B4 {
->B4 : Symbol(B4, Decl(enforceReadonly1.ts, 62, 1))
-
-    foo() {}
->foo : Symbol(B4.foo, Decl(enforceReadonly1.ts, 64, 10))
-}
-
-class D4 extends B4 {  // Error
->D4 : Symbol(D4, Decl(enforceReadonly1.ts, 66, 1))
->B4 : Symbol(B4, Decl(enforceReadonly1.ts, 62, 1))
-
-    readonly foo = () => {}
->foo : Symbol(D4.foo, Decl(enforceReadonly1.ts, 68, 21))
-}
-
 // A const assertion means "as const as possible" without violating constraints
 
 const x1 = { a: "hello", b: 42 };
->x1 : Symbol(x1, Decl(enforceReadonly1.ts, 74, 5))
->a : Symbol(a, Decl(enforceReadonly1.ts, 74, 12))
->b : Symbol(b, Decl(enforceReadonly1.ts, 74, 24))
+>x1 : Symbol(x1, Decl(enforceReadonly1.ts, 66, 5))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 66, 12))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 66, 24))
 
 const x2 = { a: "hello", b: 42 } as const;
->x2 : Symbol(x2, Decl(enforceReadonly1.ts, 75, 5))
->a : Symbol(a, Decl(enforceReadonly1.ts, 75, 12))
->b : Symbol(b, Decl(enforceReadonly1.ts, 75, 24))
+>x2 : Symbol(x2, Decl(enforceReadonly1.ts, 67, 5))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 67, 12))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 67, 24))
 >const : Symbol(const)
 
 const y1: { a: string, b: number } = { a: "hello", b: 42 };
->y1 : Symbol(y1, Decl(enforceReadonly1.ts, 77, 5))
->a : Symbol(a, Decl(enforceReadonly1.ts, 77, 11))
->b : Symbol(b, Decl(enforceReadonly1.ts, 77, 22))
->a : Symbol(a, Decl(enforceReadonly1.ts, 77, 38))
->b : Symbol(b, Decl(enforceReadonly1.ts, 77, 50))
+>y1 : Symbol(y1, Decl(enforceReadonly1.ts, 69, 5))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 69, 11))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 69, 22))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 69, 38))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 69, 50))
 
 const y2: { a: string, b: number } = { a: "hello", b: 42 } as const;
->y2 : Symbol(y2, Decl(enforceReadonly1.ts, 78, 5))
->a : Symbol(a, Decl(enforceReadonly1.ts, 78, 11))
->b : Symbol(b, Decl(enforceReadonly1.ts, 78, 22))
->a : Symbol(a, Decl(enforceReadonly1.ts, 78, 38))
->b : Symbol(b, Decl(enforceReadonly1.ts, 78, 50))
+>y2 : Symbol(y2, Decl(enforceReadonly1.ts, 70, 5))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 70, 11))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 70, 22))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 70, 38))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 70, 50))
 >const : Symbol(const)
 
 const y3: { a: string, readonly b: number } = { a: "hello", b: 42 };
->y3 : Symbol(y3, Decl(enforceReadonly1.ts, 79, 5))
->a : Symbol(a, Decl(enforceReadonly1.ts, 79, 11))
->b : Symbol(b, Decl(enforceReadonly1.ts, 79, 22))
->a : Symbol(a, Decl(enforceReadonly1.ts, 79, 47))
->b : Symbol(b, Decl(enforceReadonly1.ts, 79, 59))
+>y3 : Symbol(y3, Decl(enforceReadonly1.ts, 71, 5))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 71, 11))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 71, 22))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 71, 47))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 71, 59))
 
 const y4: Record<string, unknown> = { a: 1, b: 2 } as const;
->y4 : Symbol(y4, Decl(enforceReadonly1.ts, 80, 5))
+>y4 : Symbol(y4, Decl(enforceReadonly1.ts, 72, 5))
 >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
->a : Symbol(a, Decl(enforceReadonly1.ts, 80, 37))
->b : Symbol(b, Decl(enforceReadonly1.ts, 80, 43))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 72, 37))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 72, 43))
 >const : Symbol(const)
 
 declare function f10<T>(obj: T): T;
->f10 : Symbol(f10, Decl(enforceReadonly1.ts, 80, 60))
->T : Symbol(T, Decl(enforceReadonly1.ts, 82, 21))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 82, 24))
->T : Symbol(T, Decl(enforceReadonly1.ts, 82, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 82, 21))
+>f10 : Symbol(f10, Decl(enforceReadonly1.ts, 72, 60))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 74, 21))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 74, 24))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 74, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 74, 21))
 
 declare function f11<const T>(obj: T): T;
->f11 : Symbol(f11, Decl(enforceReadonly1.ts, 82, 35))
->T : Symbol(T, Decl(enforceReadonly1.ts, 83, 21))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 83, 30))
->T : Symbol(T, Decl(enforceReadonly1.ts, 83, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 83, 21))
+>f11 : Symbol(f11, Decl(enforceReadonly1.ts, 74, 35))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 75, 21))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 75, 30))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 75, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 75, 21))
 
 declare function f12<const T extends { a: string, b: number }>(obj: T): T;
->f12 : Symbol(f12, Decl(enforceReadonly1.ts, 83, 41))
->T : Symbol(T, Decl(enforceReadonly1.ts, 84, 21))
->a : Symbol(a, Decl(enforceReadonly1.ts, 84, 38))
->b : Symbol(b, Decl(enforceReadonly1.ts, 84, 49))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 84, 63))
->T : Symbol(T, Decl(enforceReadonly1.ts, 84, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 84, 21))
+>f12 : Symbol(f12, Decl(enforceReadonly1.ts, 75, 41))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 76, 21))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 76, 38))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 76, 49))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 76, 63))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 76, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 76, 21))
 
 declare function f13<const T extends { a: string, readonly b: number }>(obj: T): T;
->f13 : Symbol(f13, Decl(enforceReadonly1.ts, 84, 74))
->T : Symbol(T, Decl(enforceReadonly1.ts, 85, 21))
->a : Symbol(a, Decl(enforceReadonly1.ts, 85, 38))
->b : Symbol(b, Decl(enforceReadonly1.ts, 85, 49))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 85, 72))
->T : Symbol(T, Decl(enforceReadonly1.ts, 85, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 85, 21))
+>f13 : Symbol(f13, Decl(enforceReadonly1.ts, 76, 74))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 77, 21))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 77, 38))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 77, 49))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 77, 72))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 77, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 77, 21))
 
 declare function f14<const T extends Record<string, unknown>>(obj: T): T;
->f14 : Symbol(f14, Decl(enforceReadonly1.ts, 85, 83))
->T : Symbol(T, Decl(enforceReadonly1.ts, 86, 21))
+>f14 : Symbol(f14, Decl(enforceReadonly1.ts, 77, 83))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 78, 21))
 >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 86, 62))
->T : Symbol(T, Decl(enforceReadonly1.ts, 86, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 86, 21))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 78, 62))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 78, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 78, 21))
 
 declare function f15<const T extends Readonly<Record<string, unknown>>>(obj: T): T;
->f15 : Symbol(f15, Decl(enforceReadonly1.ts, 86, 73))
->T : Symbol(T, Decl(enforceReadonly1.ts, 87, 21))
+>f15 : Symbol(f15, Decl(enforceReadonly1.ts, 78, 73))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 79, 21))
 >Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
 >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
->obj : Symbol(obj, Decl(enforceReadonly1.ts, 87, 72))
->T : Symbol(T, Decl(enforceReadonly1.ts, 87, 21))
->T : Symbol(T, Decl(enforceReadonly1.ts, 87, 21))
+>obj : Symbol(obj, Decl(enforceReadonly1.ts, 79, 72))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 79, 21))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 79, 21))
 
 f10({ a: "hello", b: 42 });  // { a: string; b: number; }
->f10 : Symbol(f10, Decl(enforceReadonly1.ts, 80, 60))
->a : Symbol(a, Decl(enforceReadonly1.ts, 89, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 89, 17))
+>f10 : Symbol(f10, Decl(enforceReadonly1.ts, 72, 60))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 81, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 81, 17))
 
 f11({ a: "hello", b: 42 });  // { readonly a: "hello"; readonly b: 42; }
->f11 : Symbol(f11, Decl(enforceReadonly1.ts, 82, 35))
->a : Symbol(a, Decl(enforceReadonly1.ts, 90, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 90, 17))
+>f11 : Symbol(f11, Decl(enforceReadonly1.ts, 74, 35))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 82, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 82, 17))
 
 f12({ a: "hello", b: 42 });  // { a: "hello"; b: 42; }
->f12 : Symbol(f12, Decl(enforceReadonly1.ts, 83, 41))
->a : Symbol(a, Decl(enforceReadonly1.ts, 91, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 91, 17))
+>f12 : Symbol(f12, Decl(enforceReadonly1.ts, 75, 41))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 83, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 83, 17))
 
 f13({ a: "hello", b: 42 });  // { a: "hello"; readonly b: 42; }
->f13 : Symbol(f13, Decl(enforceReadonly1.ts, 84, 74))
->a : Symbol(a, Decl(enforceReadonly1.ts, 92, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 92, 17))
+>f13 : Symbol(f13, Decl(enforceReadonly1.ts, 76, 74))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 84, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 84, 17))
 
 f14({ a: "hello", b: 42 });  // { a: "hello"; b: 42; }
->f14 : Symbol(f14, Decl(enforceReadonly1.ts, 85, 83))
->a : Symbol(a, Decl(enforceReadonly1.ts, 93, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 93, 17))
+>f14 : Symbol(f14, Decl(enforceReadonly1.ts, 77, 83))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 85, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 85, 17))
 
 f15({ a: "hello", b: 42 });  // { readonly a: "hello"; readonly b: 42; }
->f15 : Symbol(f15, Decl(enforceReadonly1.ts, 86, 73))
->a : Symbol(a, Decl(enforceReadonly1.ts, 94, 5))
->b : Symbol(b, Decl(enforceReadonly1.ts, 94, 17))
+>f15 : Symbol(f15, Decl(enforceReadonly1.ts, 78, 73))
+>a : Symbol(a, Decl(enforceReadonly1.ts, 86, 5))
+>b : Symbol(b, Decl(enforceReadonly1.ts, 86, 17))
 
 // https://github.com/microsoft/TypeScript/issues/13347
 
 interface MutableValue<T> {
->MutableValue : Symbol(MutableValue, Decl(enforceReadonly1.ts, 94, 27))
->T : Symbol(T, Decl(enforceReadonly1.ts, 98, 23))
+>MutableValue : Symbol(MutableValue, Decl(enforceReadonly1.ts, 86, 27))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 90, 23))
 
     value: T;
->value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 98, 27))
->T : Symbol(T, Decl(enforceReadonly1.ts, 98, 23))
+>value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 90, 27))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 90, 23))
 }
 
 interface ImmutableValue<T> {
->ImmutableValue : Symbol(ImmutableValue, Decl(enforceReadonly1.ts, 100, 1))
->T : Symbol(T, Decl(enforceReadonly1.ts, 102, 25))
+>ImmutableValue : Symbol(ImmutableValue, Decl(enforceReadonly1.ts, 92, 1))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 94, 25))
 
     readonly value: T;
->value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 102, 29))
->T : Symbol(T, Decl(enforceReadonly1.ts, 102, 25))
+>value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 94, 29))
+>T : Symbol(T, Decl(enforceReadonly1.ts, 94, 25))
 }
 
 let i: ImmutableValue<string> = { value: "hi" };
->i : Symbol(i, Decl(enforceReadonly1.ts, 106, 3))
->ImmutableValue : Symbol(ImmutableValue, Decl(enforceReadonly1.ts, 100, 1))
->value : Symbol(value, Decl(enforceReadonly1.ts, 106, 33))
+>i : Symbol(i, Decl(enforceReadonly1.ts, 98, 3))
+>ImmutableValue : Symbol(ImmutableValue, Decl(enforceReadonly1.ts, 92, 1))
+>value : Symbol(value, Decl(enforceReadonly1.ts, 98, 33))
 
 i.value = "Excellent, I can't change it";  // Error
->i.value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 102, 29))
->i : Symbol(i, Decl(enforceReadonly1.ts, 106, 3))
->value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 102, 29))
+>i.value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 94, 29))
+>i : Symbol(i, Decl(enforceReadonly1.ts, 98, 3))
+>value : Symbol(ImmutableValue.value, Decl(enforceReadonly1.ts, 94, 29))
 
 let m: MutableValue<string> = i;  // Error
->m : Symbol(m, Decl(enforceReadonly1.ts, 109, 3))
->MutableValue : Symbol(MutableValue, Decl(enforceReadonly1.ts, 94, 27))
->i : Symbol(i, Decl(enforceReadonly1.ts, 106, 3))
+>m : Symbol(m, Decl(enforceReadonly1.ts, 101, 3))
+>MutableValue : Symbol(MutableValue, Decl(enforceReadonly1.ts, 86, 27))
+>i : Symbol(i, Decl(enforceReadonly1.ts, 98, 3))
 
 m.value = "Oh dear, I can change it";
->m.value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 98, 27))
->m : Symbol(m, Decl(enforceReadonly1.ts, 109, 3))
->value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 98, 27))
+>m.value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 90, 27))
+>m : Symbol(m, Decl(enforceReadonly1.ts, 101, 3))
+>value : Symbol(MutableValue.value, Decl(enforceReadonly1.ts, 90, 27))
 
diff --git a/tests/baselines/reference/enforceReadonly1.types b/tests/baselines/reference/enforceReadonly1.types
index 9a1392791b1..03446339854 100644
--- a/tests/baselines/reference/enforceReadonly1.types
+++ b/tests/baselines/reference/enforceReadonly1.types
@@ -265,28 +265,6 @@ class D3 extends B3 {  // Error
 >  : ^
 }
 
-class B4 {
->B4 : B4
->   : ^^
-
-    foo() {}
->foo : () => void
->    : ^^^^^^^^^^
-}
-
-class D4 extends B4 {  // Error
->D4 : D4
->   : ^^
->B4 : B4
->   : ^^
-
-    readonly foo = () => {}
->foo : () => void
->    : ^^^^^^^^^^
->() => {} : () => void
->         : ^^^^^^^^^^
-}
-
 // A const assertion means "as const as possible" without violating constraints
 
 const x1 = { a: "hello", b: 42 };