@effect/language-service 0.26.0 → 0.27.1

package/index.js

@@ -1710,7 +1710,11 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
+      const defaultLevel = pluginOptions.diagnosticSeverity[ruleNameLowered] || rule.severity;
       if (skippedRules.indexOf(ruleNameLowered) > -1) return { diagnostics: diagnostics2, codeFixes };
+      if (defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || []).length === 0) {
+        return { diagnostics: diagnostics2, codeFixes };
+      }
       const fixByDisableNextLine = (_) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
@@ -1751,7 +1755,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
         });
       });
       for (const emitted of applicableDiagnostics.slice(0)) {
-        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered] || rule.severity;
+        let newLevel = defaultLevel;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
           (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
         );
@@ -3608,6 +3612,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 +3903,8 @@ var diagnostics = [
   importFromBarrel,
   scopeInLayerEffect,
   effectInVoidSuccess,
-  unnecessaryPipeChain
+  unnecessaryPipeChain,
+  strictBooleanExpressions
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -4065,6 +4137,55 @@ var rpcMakeClasses = createCompletion({
   })
 });
 
+// src/completions/schemaBrand.ts
+var schemaBrand = createCompletion({
+  name: "schemaBrand",
+  apply: fn("schemaBrand")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    if (!ts.isIdentifier(accessedObject)) return [];
+    const schemaName = match(
+      yield* option(
+        findImportedModuleIdentifierByPackageAndNameOrBarrel(
+          sourceFile,
+          "effect",
+          "Schema"
+        )
+      ),
+      {
+        onNone: () => "Schema",
+        onSome: (_) => _.text
+      }
+    );
+    if (schemaName !== accessedObject.text) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    return pipe(
+      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
+      filter(ts.isVariableDeclaration),
+      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      filter((_) => _.length > 0),
+      head,
+      map2((name) => [
+        {
+          name: `brand("${name}")`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: `brand("${name}")`,
+          replacementSpan: span,
+          isSnippet: true
+        }
+      ]),
+      getOrElse2(() => [])
+    );
+  })
+});
+
 // src/completions.ts
 var completions = [
   effectSchemaSelfInClasses,
@@ -4075,7 +4196,8 @@ var completions = [
   fnFunctionStar,
   effectDataClasses,
   effectDiagnosticsComment,
-  durationInput
+  durationInput,
+  schemaBrand
 ];
 
 // src/completions/middlewareAutoImports.ts
@@ -9630,7 +9752,7 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
       ts.factory.createIdentifier(inferFromName)
     )]
   );
-  const opaqueType = typeA.isUnion() ? ts.factory.createTypeAliasDeclaration(
+  const opaqueType = !(typeA.flags & ts.TypeFlags.Object) ? ts.factory.createTypeAliasDeclaration(
     [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
     opaqueTypeName,
     [],
@@ -9657,7 +9779,7 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
       ts.factory.createIdentifier(inferFromName)
     )]
   );
-  const encodedType = typeE.isUnion() ? ts.factory.createTypeAliasDeclaration(
+  const encodedType = !(typeE.flags & ts.TypeFlags.Object) ? ts.factory.createTypeAliasDeclaration(
     [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
     opaqueEncodedName,
     [],