eslint-plugin-absolute 0.11.0-beta.0 → 0.11.0-beta.2

package/dist/index.js

@@ -3653,6 +3653,39 @@ var noRedundantTypeAnnotation = createRule({
       return {};
     }
     const stringify = (type) => tsChecker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation | ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    const referencesTypeParam = (typeNode, name) => {
+      let found = false;
+      const visit = (node) => {
+        if (found)
+          return;
+        if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName) && node.typeName.text === name) {
+          found = true;
+          return;
+        }
+        ts2.forEachChild(node, visit);
+      };
+      visit(typeNode);
+      return found;
+    };
+    const leansOnContextualInference = (initNode) => {
+      const callLike = ts2.isCallExpression(initNode) || ts2.isNewExpression(initNode) ? initNode : null;
+      if (!callLike)
+        return false;
+      if (callLike.typeArguments && callLike.typeArguments.length > 0) {
+        return false;
+      }
+      const resolved = tsChecker.getResolvedSignature(callLike);
+      const declaration = resolved?.declaration;
+      if (declaration && !ts2.isJSDocSignature(declaration)) {
+        const typeParams = declaration.typeParameters;
+        if (!typeParams || typeParams.length === 0)
+          return false;
+        return typeParams.some((typeParam) => !declaration.parameters.some((parameter) => parameter.type !== undefined && referencesTypeParam(parameter.type, typeParam.name.text)));
+      }
+      const calleeType = tsChecker.getTypeAtLocation(callLike.expression);
+      const signatures = ts2.isNewExpression(callLike) ? calleeType.getConstructSignatures() : calleeType.getCallSignatures();
+      return signatures.some((signature) => (signature.getTypeParameters()?.length ?? 0) > 0);
+    };
     return {
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier")
@@ -3670,6 +3703,8 @@ var noRedundantTypeAnnotation = createRule({
           return;
         if (!ts2.isTypeNode(annotationTSNode))
           return;
+        if (leansOnContextualInference(initTSNode))
+          return;
         const annotationType = tsChecker.getTypeFromTypeNode(annotationTSNode);
         const initType = tsChecker.getTypeAtLocation(initTSNode);
         const aliasSymbol = ts2.isTypeReferenceNode(annotationTSNode) ? tsChecker.getSymbolAtLocation(annotationTSNode.typeName) : undefined;

package/package.json

@@ -40,5 +40,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.11.0-beta.0"
+	"version": "0.11.0-beta.2"
 }