eslint-plugin-absolute 0.11.5 → 0.11.7

package/dist/index.js

@@ -1731,6 +1731,48 @@ var noExplicitReturnTypes = createRule({
         return parent.parent;
       return node;
     };
+    const collectTypeReferenceNames = (root) => {
+      const names = new Set;
+      const visit = (value) => {
+        if (!value || typeof value !== "object") {
+          return;
+        }
+        if (Array.isArray(value)) {
+          value.forEach(visit);
+          return;
+        }
+        const candidate = value;
+        if (typeof candidate.type !== "string") {
+          return;
+        }
+        const astNode = value;
+        if (astNode.type === "TSTypeReference" && astNode.typeName.type === "Identifier") {
+          names.add(astNode.typeName.name);
+        }
+        for (const key of Object.keys(astNode)) {
+          if (key === "parent") {
+            continue;
+          }
+          visit(astNode[key]);
+        }
+      };
+      visit(root);
+      return names;
+    };
+    const hasReturnOnlyTypeParameter = (node) => {
+      const declaredTypeParams = node.typeParameters?.params;
+      if (!declaredTypeParams || declaredTypeParams.length === 0) {
+        return false;
+      }
+      const returnTypeNames = collectTypeReferenceNames(node.returnType);
+      const parameterTypeNames = new Set;
+      for (const parameter of node.params) {
+        for (const name of collectTypeReferenceNames(parameter)) {
+          parameterTypeNames.add(name);
+        }
+      }
+      return declaredTypeParams.some((typeParam) => returnTypeNames.has(typeParam.name.name) && !parameterTypeNames.has(typeParam.name.name));
+    };
     const referencesOwnName = (node) => {
       const ownName = getOwnName(node);
       if (!ownName)
@@ -1759,6 +1801,9 @@ var noExplicitReturnTypes = createRule({
         if (referencesOwnName(node)) {
           return;
         }
+        if (hasReturnOnlyTypeParameter(node)) {
+          return;
+        }
         context.report({
           messageId: "noExplicitReturnType",
           node: returnType
@@ -1769,7 +1814,7 @@ var noExplicitReturnTypes = createRule({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects)."
+      description: "Disallow explicit return type annotations on functions, except when the annotation is load-bearing: type predicates for type guards, inline object literal returns (e.g., style objects), recursive functions, or generics whose type parameter appears only in the return type."
     },
     messages: {
       noExplicitReturnType: "Explicit return types are disallowed; rely on TypeScript's inference instead."
@@ -2026,6 +2071,22 @@ var visitImmediateReferences = (node, onReference) => {
       case "FunctionExpression":
       case "ArrowFunctionExpression":
         return;
+      case "CallExpression":
+      case "NewExpression": {
+        const runAtInit = (invoked) => {
+          if (!invoked) {
+            return;
+          }
+          if (invoked.type === "FunctionDeclaration" || invoked.type === "FunctionExpression" || invoked.type === "ArrowFunctionExpression") {
+            visit(invoked.body);
+            return;
+          }
+          visit(invoked);
+        };
+        runAtInit(current.callee);
+        current.arguments.forEach(runAtInit);
+        return;
+      }
       case "MemberExpression":
         visit(current.object);
         if (current.computed) {

package/package.json

@@ -41,5 +41,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.11.5"
+	"version": "0.11.7"
 }