diff --git a/tests/rules/prefer-readonly-type/ts/invalid.ts b/tests/rules/prefer-readonly-type/ts/invalid.ts
index dedae2fd0..e770fa6bd 100644
--- a/tests/rules/prefer-readonly-type/ts/invalid.ts
+++ b/tests/rules/prefer-readonly-type/ts/invalid.ts
@@ -314,88 +314,6 @@ const tests: ReadonlyArray<InvalidTestCase> = [
       },
     ],
   },
-  // Should fail on Array type alias.
-  {
-    code: `type Foo = Array<string>;`,
-    optionsSet: [[]],
-    output: `type Foo = ReadonlyArray<string>;`,
-    errors: [
-      {
-        messageId: "type",
-        type: "TSTypeReference",
-        line: 1,
-        column: 12,
-      },
-    ],
-  },
-  // Should fail on Array as type member.
-  {
-    code: dedent`
-      function foo() {
-        type Foo = {
-          readonly bar: Array<string>
-        }
-      }`,
-    optionsSet: [[]],
-    output: dedent`
-      function foo() {
-        type Foo = {
-          readonly bar: ReadonlyArray<string>
-        }
-      }`,
-    errors: [
-      {
-        messageId: "type",
-        type: "TSTypeReference",
-        line: 3,
-        column: 19,
-      },
-    ],
-  },
-  // Should fail on Array type alias in local type.
-  {
-    code: dedent`
-      function foo() {
-        type Foo = Array<string>;
-      }`,
-    optionsSet: [[]],
-    output: dedent`
-      function foo() {
-        type Foo = ReadonlyArray<string>;
-      }`,
-    errors: [
-      {
-        messageId: "type",
-        type: "TSTypeReference",
-        line: 2,
-        column: 14,
-      },
-    ],
-  },
-  // Should fail on Array as type member in local type.
-  {
-    code: dedent`
-      function foo() {
-        type Foo = {
-          readonly bar: Array<string>
-        }
-      }`,
-    optionsSet: [[]],
-    output: dedent`
-      function foo() {
-        type Foo = {
-          readonly bar: ReadonlyArray<string>
-        }
-      }`,
-    errors: [
-      {
-        messageId: "type",
-        type: "TSTypeReference",
-        line: 3,
-        column: 19,
-      },
-    ],
-  },
   // Should fail on Array type in variable declaration.
   {
     code: `const foo: Array<string> = [];`,
@@ -632,34 +550,6 @@ const tests: ReadonlyArray<InvalidTestCase> = [
       },
     ],
   },
-  // Type literal in property template parameter without readonly should produce failures.
-  {
-    code: dedent`
-      type foo = ReadonlyArray<{
-        type: string,
-        code: string,
-      }>;`,
-    optionsSet: [[]],
-    output: dedent`
-      type foo = ReadonlyArray<{
-        readonly type: string,
-        readonly code: string,
-      }>;`,
-    errors: [
-      {
-        messageId: "property",
-        type: "TSPropertySignature",
-        line: 2,
-        column: 3,
-      },
-      {
-        messageId: "property",
-        type: "TSPropertySignature",
-        line: 3,
-        column: 3,
-      },
-    ],
-  },
   // Type literal without readonly on members should produce failures.
   // Also verify that nested members are checked.
   {
@@ -1088,6 +978,84 @@ const tests: ReadonlyArray<InvalidTestCase> = [
       },
     ],
   },
+  // Should fail when using an mutable type alias in variable declaration.
+  {
+    code: dedent`
+      type Foo = Array<string>;
+      let foo: Foo;`,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "type",
+        type: "TSTypeReference",
+        line: 2,
+        column: 20,
+      },
+    ],
+  },
+  // Should fail when using an mutable type alias in function param.
+  {
+    code: dedent`
+      type Foo = Array<string>;
+      function foo(param: Foo) {}`,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "type",
+        type: "TSTypeReference",
+        line: 2,
+        column: 20,
+      },
+    ],
+  },
+  // Should fail when using an mutable type alias of type literal without readonly modifer in variable declaration.
+  {
+    code: dedent`
+      type Foo = ReadonlyArray<{
+        type: string,
+        code: string,
+      }>;
+      let foo: Foo;`,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "property",
+        type: "TSPropertySignature",
+        line: 2,
+        column: 3,
+      },
+      {
+        messageId: "property",
+        type: "TSPropertySignature",
+        line: 3,
+        column: 3,
+      },
+    ],
+  },
+  // Should fail when using an mutable type alias of type literal without readonly modifer in function param.
+  {
+    code: dedent`
+      type Foo = ReadonlyArray<{
+        type: string,
+        code: string,
+      }>;
+      function foo(param: Foo) {}`,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "property",
+        type: "TSPropertySignature",
+        line: 2,
+        column: 3,
+      },
+      {
+        messageId: "property",
+        type: "TSPropertySignature",
+        line: 3,
+        column: 3,
+      },
+    ],
+  },
 ];
 
 export default tests;
diff --git a/tests/rules/prefer-readonly-type/ts/valid.ts b/tests/rules/prefer-readonly-type/ts/valid.ts
index a6613133a..f6c8723fe 100644
--- a/tests/rules/prefer-readonly-type/ts/valid.ts
+++ b/tests/rules/prefer-readonly-type/ts/valid.ts
@@ -38,16 +38,16 @@ const tests: ReadonlyArray<ValidTestCase> = [
     }`,
     optionsSet: [[]],
   },
-  // Should not fail on ReadonlyArray type alias.
+  // Should not fail on type alias.
   {
-    code: `type Foo = ReadonlyArray<string>;`,
+    code: `type Foo = Array<string>;`,
     optionsSet: [[]],
   },
-  // Should not fail on ReadonlyArray type alias in local type.
+  // Should not fail on type alias in local type.
   {
     code: dedent`
     function foo() {
-      type Foo = ReadonlyArray<string>;
+      type Foo = Array<string>;
     }`,
     optionsSet: [[]],
   },
@@ -214,7 +214,7 @@ const tests: ReadonlyArray<ValidTestCase> = [
   },
   // Type literal in array template parameter with readonly should not produce failures.
   {
-    code: `type foo = ReadonlyArray<{ readonly type: string, readonly code: string }>;`,
+    code: `let foo: ReadonlyArray<{ readonly type: string, readonly code: string }>;`,
     optionsSet: [[]],
   },
   // Type literal with readonly on members should not produce failures.
@@ -348,7 +348,7 @@ const tests: ReadonlyArray<ValidTestCase> = [
   },
   // Ignore Mutable Collections (Array, Tuple, Set, Map)
   {
-    code: dedent`type Foo = Array<string>;`,
+    code: dedent`let Foo: Array<string>;`,
     optionsSet: [[{ ignoreCollections: true }]],
   },
   {
@@ -360,7 +360,7 @@ const tests: ReadonlyArray<ValidTestCase> = [
     optionsSet: [[{ ignoreCollections: true, checkImplicit: true }]],
   },
   {
-    code: dedent`type Foo = [string, string];`,
+    code: dedent`let Foo: [string, string];`,
     optionsSet: [[{ ignoreCollections: true }]],
   },
   {
@@ -372,7 +372,7 @@ const tests: ReadonlyArray<ValidTestCase> = [
     optionsSet: [[{ ignoreCollections: true, checkImplicit: true }]],
   },
   {
-    code: dedent`type Foo = Set<string, string>;`,
+    code: dedent`let Foo: Set<string, string>;`,
     optionsSet: [[{ ignoreCollections: true }]],
   },
   {
@@ -380,7 +380,7 @@ const tests: ReadonlyArray<ValidTestCase> = [
     optionsSet: [[{ ignoreCollections: true }]],
   },
   {
-    code: dedent`type Foo = Map<string, string>;`,
+    code: dedent`let Foo: Map<string, string>;`,
     optionsSet: [[{ ignoreCollections: true }]],
   },
   {