fix(no-unnecessary-type-arguments): handle Partial aliases in default-type checks (#862)

fixes #861

Author: camc314

internal/rule_tester/__snapshots__/no-unnecessary-type-arguments.snap

@@ -390,3 +390,30 @@ Message: This is the default value for this type parameter, so it can be omitted
      |                                                       ~~~
    3 |       
 ---
+
+[TestNoUnnecessaryTypeArguments/invalid-43 - 1]
+Diagnostic 1: isDefaultParameterValue (10:3 - 10:5)
+Message: This is the default value for this type parameter, so it can be omitted.
+   9 | function f<T = Foo>() {}
+  10 | f<Bar>();
+     |   ~~~
+  11 |       
+---
+
+[TestNoUnnecessaryTypeArguments/invalid-44 - 1]
+Diagnostic 1: canBeInferred (3:52 - 3:62)
+Message: This value can be trivially inferred for this type parameter, so it can be omitted.
+   2 | declare function useState<T>(initialState: T | (() => T)): [T, (value: T) => void];
+   3 | const [bookmarkedIds, setBookmarkedIds] = useState<Set<string>>(new Set());
+     |                                                    ~~~~~~~~~~~
+   4 |       
+---
+
+[TestNoUnnecessaryTypeArguments/invalid-45 - 1]
+Diagnostic 1: canBeInferred (3:33 - 3:43)
+Message: This value can be trivially inferred for this type parameter, so it can be omitted.
+   2 | declare function useRef<T>(initialValue: T): { current: T };
+   3 | const activeIndexesRef = useRef<Set<number>>(new Set());
+     |                                 ~~~~~~~~~~~
+   4 |       
+---

internal/rules/no_unnecessary_type_arguments/no_unnecessary_type_arguments.go

@@ -55,18 +55,6 @@ func areTypesEquivalent(typeChecker *checker.Checker, a *checker.Type, b *checke
 	return checker.Checker_isTypeAssignableTo(typeChecker, a, b) && checker.Checker_isTypeAssignableTo(typeChecker, b, a)
 }
 
-func areDefaultValueTypesEquivalent(typeChecker *checker.Checker, a *checker.Type, b *checker.Type) bool {
-	if a == b {
-		return true
-	}
-
-	if utils.IsTypeAnyType(a) || utils.IsTypeAnyType(b) || a.Flags() != b.Flags() {
-		return false
-	}
-
-	return checker.Checker_isTypeIdenticalTo(typeChecker, a, b)
-}
-
 var NoUnnecessaryTypeArgumentsRule = rule.Rule{
 	Name: "no-unnecessary-type-arguments",
 	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
@@ -159,9 +147,6 @@ var NoUnnecessaryTypeArgumentsRule = rule.Rule{
 			typeParameter := parameters[lastParamIndex]
 
 			typeArgumentType := ctx.TypeChecker.GetTypeAtLocation(typeArgument)
-			if utils.IsIntrinsicErrorType(typeArgumentType) {
-				return
-			}
 
 			if callOrNewExpr != nil {
 				signature := checker.Checker_getResolvedSignature(ctx.TypeChecker, callOrNewExpr, nil, checker.CheckModeNormal)
@@ -212,7 +197,7 @@ var NoUnnecessaryTypeArgumentsRule = rule.Rule{
 			}
 
 			defaultTypeValue := ctx.TypeChecker.GetTypeAtLocation(defaultType)
-			if utils.IsIntrinsicErrorType(defaultTypeValue) || !areDefaultValueTypesEquivalent(ctx.TypeChecker, defaultTypeValue, typeArgumentType) {
+			if !areTypesEquivalent(ctx.TypeChecker, defaultTypeValue, typeArgumentType) {
 				return
 			}
 

internal/rules/no_unnecessary_type_arguments/no_unnecessary_type_arguments_test.go

@@ -311,17 +311,6 @@ f<any>();
 		{Code: `
 function f<T = any>() {}
 f<string>();
-    `},
-		{Code: `
-interface Foo {
-	foo?: string
-}
-interface Bar extends Foo {
-	bar?: string
-}
-
-function f<T = Foo>() {}
-f<Bar>();
     `},
 		// https://github.com/oxc-project/oxc/issues/13164
 		{Code: `
@@ -334,6 +323,31 @@ interface TestInterface {
 type OneParam<T = any, U = any, V = any> = T;
 interface TestInterface {
   prop?: OneParam<string, number>;  // TypeScript error, but shouldn't panic
+}
+    `},
+		// https://github.com/oxc-project/tsgolint/issues/861
+		{Code: `
+type Data = Record<never, never>
+
+type LocaleData<T extends Data = Data> = Record<string, T>
+
+interface Data1 { a: string }
+
+type Data2 = Partial<Data1>
+
+type LocaleData2 = LocaleData<Data2>
+    `},
+		{Code: `
+type Data = Record<never, never>
+
+type LocaleData<T extends Data = Data> = Record<string, T>
+
+interface Data1 { a: string }
+
+type Data2 = Partial<Data1>
+
+interface Wrapper {
+  value: LocaleData<Data2>
 }
     `},
 	}, []rule_tester.InvalidTestCase{
@@ -1151,5 +1165,70 @@ declare type MessageEventHandler = ((ev: MessageEvent) => any) | null;
 				},
 			},
 		},
+		{
+			Code: `
+interface Foo {
+	foo?: string
+}
+interface Bar extends Foo {
+	bar?: string
+}
+
+function f<T = Foo>() {}
+f<Bar>();
+      `,
+			Output: []string{`
+interface Foo {
+	foo?: string
+}
+interface Bar extends Foo {
+	bar?: string
+}
+
+function f<T = Foo>() {}
+f();
+      `,
+			},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{
+					Line:      10,
+					MessageId: "isDefaultParameterValue",
+				},
+			},
+		},
+		{
+			Code: `
+declare function useState<T>(initialState: T | (() => T)): [T, (value: T) => void];
+const [bookmarkedIds, setBookmarkedIds] = useState<Set<string>>(new Set());
+      `,
+			Output: []string{`
+declare function useState<T>(initialState: T | (() => T)): [T, (value: T) => void];
+const [bookmarkedIds, setBookmarkedIds] = useState(new Set());
+      `,
+			},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{
+					Line:      3,
+					MessageId: "canBeInferred",
+				},
+			},
+		},
+		{
+			Code: `
+declare function useRef<T>(initialValue: T): { current: T };
+const activeIndexesRef = useRef<Set<number>>(new Set());
+      `,
+			Output: []string{`
+declare function useRef<T>(initialValue: T): { current: T };
+const activeIndexesRef = useRef(new Set());
+      `,
+			},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{
+					Line:      3,
+					MessageId: "canBeInferred",
+				},
+			},
+		},
 	})
 }