fix: don't mark type aliases as violations

re #153

Author: RebeccaStevens

src/rules/prefer-readonly-type.ts

@@ -16,7 +16,7 @@ import {
 } from "~/common/ignore-options";
 import type { RuleContext, RuleMetaData, RuleResult } from "~/util/rule";
 import { createRule, getTypeOfNode } from "~/util/rule";
-import { isInReturnType } from "~/util/tree";
+import { isInReturnType, isInTSTypeAliasDeclaration } from "~/util/tree";
 import {
   isArrayType,
   isAssignmentPattern,
@@ -184,33 +184,35 @@ function checkTypeReference(
   context: RuleContext<keyof typeof errorMessages, Options>,
   options: Options
 ): RuleResult<keyof typeof errorMessages, Options> {
-  if (isIdentifier(node.typeName)) {
-    if (
-      options.ignoreCollections &&
-      mutableTypeRegex.test(node.typeName.name)
-    ) {
-      return {
-        context,
-        descriptors: [],
-      };
-    }
-    const immutableType = mutableToImmutableTypes.get(node.typeName.name);
+  if (
+    !isIdentifier(node.typeName) ||
+    (options.ignoreCollections && mutableTypeRegex.test(node.typeName.name)) ||
+    isInTSTypeAliasDeclaration(node)
+  ) {
     return {
       context,
-      descriptors:
-        immutableType !== undefined &&
-        immutableType.length > 0 &&
-        (!options.allowMutableReturnType || !isInReturnType(node))
-          ? [
-              {
-                node,
-                messageId: "type",
-                fix: (fixer) => fixer.replaceText(node.typeName, immutableType),
-              },
-            ]
-          : [],
+      descriptors: [],
+    };
+  }
+
+  const immutableType = mutableToImmutableTypes.get(node.typeName.name);
+  if (
+    immutableType !== undefined &&
+    immutableType.length > 0 &&
+    (!options.allowMutableReturnType || !isInReturnType(node))
+  ) {
+    return {
+      context,
+      descriptors: [
+        {
+          node,
+          messageId: "type",
+          fix: (fixer) => fixer.replaceText(node.typeName, immutableType),
+        },
+      ],
     };
   }
+
   return {
     context,
     descriptors: [],

src/util/tree.ts

@@ -10,6 +10,7 @@ import {
   isMethodDefinition,
   isProperty,
   isTSInterfaceBody,
+  isTSTypeAliasDeclaration,
 } from "./typeguard";
 
 /**
@@ -81,6 +82,13 @@ export function isInReturnType(node: TSESTree.Node): boolean {
   );
 }
 
+/**
+ * Is the given node in a TS Type Alias Declaration.
+ */
+export function isInTSTypeAliasDeclaration(node: TSESTree.Node): boolean {
+  return getAncestorOfType(isTSTypeAliasDeclaration, node) !== null;
+}
+
 /**
  * Is the given identifier a property of an object?
  */

src/util/typeguard.ts

@@ -222,6 +222,12 @@ export function isTSTupleType(
   return node.type === AST_NODE_TYPES.TSTupleType;
 }
 
+export function isTSTypeAliasDeclaration(
+  node: TSESTree.Node
+): node is TSESTree.TSTypeAliasDeclaration {
+  return node.type === AST_NODE_TYPES.TSTypeAliasDeclaration;
+}
+
 export function isTSTypeAnnotation(
   node: TSESTree.Node
 ): node is TSESTree.TSTypeAnnotation {