@effect/language-service 0.26.0 → 0.27.0

package/index.js

@@ -3608,6 +3608,73 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/strictBooleanExpressions.ts
+var strictBooleanExpressions = createDiagnostic({
+  name: "strictBooleanExpressions",
+  code: 17,
+  severity: "off",
+  apply: fn("strictBooleanExpressions.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const conditionChecks = /* @__PURE__ */ new WeakMap();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const nodes = [];
+      if (ts.isIfStatement(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.expression);
+      } else if (ts.isWhileStatement(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.expression);
+      } else if (ts.isConditionalExpression(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.condition);
+      } else if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+        conditionChecks.set(node, true);
+        nodes.push(node.operand);
+      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+        if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
+        nodes.push(node.left);
+        nodes.push(node.right);
+      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
+        nodes.push(node.left);
+        nodes.push(node.right);
+      }
+      for (const nodeToCheck of nodes) {
+        if (!nodeToCheck) continue;
+        if (!conditionChecks.has(nodeToCheck.parent)) continue;
+        const nodeType = typeChecker.getTypeAtLocation(nodeToCheck);
+        const constrainedType = typeChecker.getBaseConstraintOfType(nodeType);
+        let typesToCheck = [constrainedType || nodeType];
+        while (typesToCheck.length > 0) {
+          const type = typesToCheck.pop();
+          if (type.isUnion()) {
+            typesToCheck = typesToCheck.concat(type.types);
+            continue;
+          }
+          if (type.flags & ts.TypeFlags.Boolean) continue;
+          if (type.flags & ts.TypeFlags.Never) continue;
+          if (type.flags & ts.TypeFlags.BooleanLiteral) continue;
+          const typeName = typeChecker.typeToString(type);
+          report({
+            node: nodeToCheck,
+            messageText: `Unexpected \`${typeName}\` type in condition, expected strictly a boolean instead.`,
+            fixes: []
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/tryCatchInEffectGen.ts
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
@@ -3832,7 +3899,8 @@ var diagnostics = [
   importFromBarrel,
   scopeInLayerEffect,
   effectInVoidSuccess,
-  unnecessaryPipeChain
+  unnecessaryPipeChain,
+  strictBooleanExpressions
 ];
 
 // src/completions/effectDiagnosticsComment.ts