@effect/language-service 0.83.1 → 0.84.0

package/index.js

@@ -3775,6 +3775,25 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
       return typeChecker.getTypeAtLocation(node);
     }
   }
+  function resolveToGlobalSymbol(symbol3) {
+    if (symbol3.flags & ts.SymbolFlags.Alias) {
+      symbol3 = typeChecker.getAliasedSymbol(symbol3);
+    }
+    let depth = 0;
+    while (depth < 2 && symbol3.valueDeclaration && ts.isVariableDeclaration(symbol3.valueDeclaration)) {
+      const initializer = symbol3.valueDeclaration.initializer;
+      if (!initializer) break;
+      let nextSymbol = typeChecker.getSymbolAtLocation(initializer);
+      if (!nextSymbol) break;
+      if (nextSymbol.flags & ts.SymbolFlags.Alias) {
+        nextSymbol = typeChecker.getAliasedSymbol(nextSymbol);
+      }
+      if (nextSymbol === symbol3) break;
+      symbol3 = nextSymbol;
+      depth++;
+    }
+    return symbol3;
+  }
   return {
     isUnion,
     isReadonlyArrayType,
@@ -3788,7 +3807,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     expectedAndRealType,
     typeToSimplifiedTypeNode,
     isGlobalErrorType,
-    getTypeAtLocation
+    getTypeAtLocation,
+    resolveToGlobalSymbol
   };
 }
 
@@ -4476,7 +4496,11 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       }
       currentParent = nodeToCheck.parent;
     }
-    return { scopeNode, effectGen: effectGenResult };
+    return {
+      inEffect: effectGenResult !== void 0 && effectGenResult.body.statements.length > 0 && scopeNode === effectGenResult.generatorFunction,
+      scopeNode,
+      effectGen: effectGenResult
+    };
   });
   const effectFn = cachedBy(
     function(node) {
@@ -8836,6 +8860,128 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalConsoleInEffect.ts
+var consoleMethodAlternatives = {
+  "log": "Effect.log or Logger",
+  "warn": "Effect.logWarning or Logger",
+  "error": "Effect.logError or Logger",
+  "info": "Effect.logInfo or Logger",
+  "debug": "Effect.logDebug or Logger",
+  "trace": "Effect.logTrace or Logger"
+};
+var makeGlobalConsoleApply = (checkInEffect) => fn(`globalConsole${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const consoleSymbol = typeChecker.resolveName("console", void 0, ts.SymbolFlags.Value, false);
+  if (!consoleSymbol) return;
+  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);
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) continue;
+    const method = ts.idText(node.expression.name);
+    const alternative = consoleMethodAlternatives[method];
+    if (!alternative) continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(node.expression.expression);
+    if (!symbol3) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol3) !== consoleSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({
+      location: node,
+      messageText: checkInEffect ? `Prefer using ${alternative} instead of console.${method} inside Effect generators.` : `Prefer using ${alternative} instead of console.${method}.`,
+      fixes: []
+    });
+  }
+});
+var globalConsoleInEffect = createDiagnostic({
+  name: "globalConsoleInEffect",
+  code: 56,
+  description: "Warns when using console methods inside Effect generators instead of Effect.log/Logger",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalConsoleApply(true)
+});
+
+// src/diagnostics/globalConsole.ts
+var globalConsole = createDiagnostic({
+  name: "globalConsole",
+  code: 60,
+  description: "Warns when using console methods outside Effect generators instead of Effect.log/Logger",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalConsoleApply(false)
+});
+
+// src/diagnostics/globalDateInEffect.ts
+var makeGlobalDateApply = (checkInEffect) => fn(`globalDate${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const dateSymbol = typeChecker.resolveName("Date", void 0, ts.SymbolFlags.Value, false);
+  if (!dateSymbol) return;
+  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);
+    let messageText;
+    let objectNode;
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.idText(node.expression.name) === "now") {
+      objectNode = node.expression.expression;
+      messageText = checkInEffect ? "Prefer using Clock or DateTime from Effect instead of Date.now() inside Effect generators." : "Prefer using Clock or DateTime from Effect instead of Date.now().";
+    } else if (ts.isNewExpression(node)) {
+      objectNode = node.expression;
+      messageText = checkInEffect ? "Prefer using DateTime from Effect instead of new Date() inside Effect generators." : "Prefer using DateTime from Effect instead of new Date().";
+    }
+    if (!messageText || !objectNode) continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(objectNode);
+    if (!symbol3) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol3) !== dateSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({ location: node, messageText, fixes: [] });
+  }
+});
+var globalDateInEffect = createDiagnostic({
+  name: "globalDateInEffect",
+  code: 55,
+  description: "Warns when using Date.now() or new Date() inside Effect generators instead of Clock/DateTime",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalDateApply(true)
+});
+
+// src/diagnostics/globalDate.ts
+var globalDate = createDiagnostic({
+  name: "globalDate",
+  code: 59,
+  description: "Warns when using Date.now() or new Date() outside Effect generators instead of Clock/DateTime",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalDateApply(false)
+});
+
 // src/diagnostics/globalErrorInEffectCatch.ts
 var globalErrorInEffectCatch = createDiagnostic({
   name: "globalErrorInEffectCatch",
@@ -8955,46 +9101,186 @@ var globalErrorInEffectFailure = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalFetchInEffect.ts
+var makeGlobalFetchApply = (checkInEffect) => fn(`globalFetch${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const fetchSymbol = typeChecker.resolveName("fetch", void 0, ts.SymbolFlags.Value, false);
+  if (!fetchSymbol) return;
+  const effectVersion = typeParser.supportedEffect();
+  const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
+  const messageText = checkInEffect ? `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function inside Effect generators.` : `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function.`;
+  const nodeToVisit = [];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  ts.forEachChild(sourceFile, appendNodeToVisit);
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    if (ts.isCallExpression(node)) {
+      const symbol3 = typeChecker.getSymbolAtLocation(node.expression);
+      if (symbol3 && typeCheckerUtils.resolveToGlobalSymbol(symbol3) === fetchSymbol) {
+        const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+        if (inEffect === checkInEffect) {
+          report({
+            location: node.expression,
+            messageText,
+            fixes: []
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, appendNodeToVisit);
+  }
+});
+var globalFetchInEffect = createDiagnostic({
+  name: "globalFetchInEffect",
+  code: 63,
+  description: "Warns when using the global fetch function inside Effect generators instead of the Effect HTTP client",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalFetchApply(true)
+});
+
 // src/diagnostics/globalFetch.ts
 var globalFetch = createDiagnostic({
   name: "globalFetch",
   code: 53,
-  description: "Warns when using the global fetch function instead of the Effect HTTP client",
+  description: "Warns when using the global fetch function outside Effect generators instead of the Effect HTTP client",
   group: "effectNative",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
-  apply: fn("globalFetch.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const fetchSymbol = typeChecker.resolveName("fetch", void 0, ts.SymbolFlags.Value, false);
-    if (!fetchSymbol) return;
-    const effectVersion = typeParser.supportedEffect();
-    const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
-    const messageText = `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function.`;
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      if (ts.isCallExpression(node)) {
-        const symbol3 = typeChecker.getSymbolAtLocation(node.expression);
-        const resolvedSymbol = symbol3 && symbol3.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol3) : symbol3;
-        if (resolvedSymbol === fetchSymbol) {
-          report({
-            location: node.expression,
-            messageText,
-            fixes: []
-          });
-        }
+  apply: makeGlobalFetchApply(false)
+});
+
+// src/diagnostics/globalRandomInEffect.ts
+var makeGlobalRandomApply = (checkInEffect) => fn(`globalRandom${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const mathSymbol = typeChecker.resolveName("Math", void 0, ts.SymbolFlags.Value, false);
+  if (!mathSymbol) return;
+  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);
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || ts.idText(node.expression.name) !== "random") continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(node.expression.expression);
+    if (!symbol3) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol3) !== mathSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({
+      location: node,
+      messageText: checkInEffect ? "Prefer using the Random service from Effect instead of Math.random() inside Effect generators." : "Prefer using the Random service from Effect instead of Math.random().",
+      fixes: []
+    });
+  }
+});
+var globalRandomInEffect = createDiagnostic({
+  name: "globalRandomInEffect",
+  code: 57,
+  description: "Warns when using Math.random() inside Effect generators instead of the Random service",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalRandomApply(true)
+});
+
+// src/diagnostics/globalRandom.ts
+var globalRandom = createDiagnostic({
+  name: "globalRandom",
+  code: 61,
+  description: "Warns when using Math.random() outside Effect generators instead of the Random service",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalRandomApply(false)
+});
+
+// src/diagnostics/globalTimersInEffect.ts
+var timerAlternatives = {
+  "setTimeout": {
+    inEffect: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout inside Effect generators.",
+    outsideEffect: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout."
+  },
+  "setInterval": {
+    inEffect: "Prefer using Schedule or Effect.repeat from Effect instead of setInterval inside Effect generators.",
+    outsideEffect: "Prefer using Schedule or Effect.repeat from Effect instead of setInterval."
+  }
+};
+var makeGlobalTimersApply = (checkInEffect) => fn(`globalTimers${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const globalSymbols = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(timerAlternatives)) {
+    const symbol3 = typeChecker.resolveName(name, void 0, ts.SymbolFlags.Value, false);
+    if (symbol3) globalSymbols.set(name, symbol3);
+  }
+  if (globalSymbols.size === 0) return;
+  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);
+    if (!ts.isCallExpression(node)) continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(node.expression);
+    if (!symbol3) continue;
+    const resolvedSymbol = typeCheckerUtils.resolveToGlobalSymbol(symbol3);
+    let messageText;
+    for (const [name, symbol4] of globalSymbols) {
+      if (resolvedSymbol === symbol4) {
+        messageText = checkInEffect ? timerAlternatives[name].inEffect : timerAlternatives[name].outsideEffect;
+        break;
       }
-      ts.forEachChild(node, appendNodeToVisit);
     }
-  })
+    if (!messageText) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({ location: node, messageText, fixes: [] });
+  }
+});
+var globalTimersInEffect = createDiagnostic({
+  name: "globalTimersInEffect",
+  code: 58,
+  description: "Warns when using setTimeout/setInterval inside Effect generators instead of Effect.sleep/Schedule",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalTimersApply(true)
+});
+
+// src/diagnostics/globalTimers.ts
+var globalTimers = createDiagnostic({
+  name: "globalTimers",
+  code: 62,
+  description: "Warns when using setTimeout/setInterval outside Effect generators instead of Effect.sleep/Schedule",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalTimersApply(false)
 });
 
 // src/diagnostics/importFromBarrel.ts
@@ -10059,8 +10345,8 @@ var missingReturnYieldStar = createDiagnostic({
       if (!type) continue;
       const maybeEffect = yield* option(typeParser.effectYieldableType(type, unwrapped.expression));
       if (!(isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never)) continue;
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+      if (!inEffect) continue;
       const fix = [{
         fixName: "missingReturnYieldStar_fix",
         description: "Add return statement",
@@ -11454,11 +11740,8 @@ var preferSchemaOverJson = createDiagnostic({
     });
     const jsonMethodInEffectGen = fn("preferSchemaOverJson.jsonMethodInEffectGen")(
       function* (jsonCall) {
-        const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(jsonCall);
-        if (!effectGen || effectGen.body.statements.length === 0) {
-          return yield* TypeParserIssue.issue;
-        }
-        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+        const { inEffect } = yield* typeParser.findEnclosingScopes(jsonCall);
+        if (!inEffect) {
           return yield* TypeParserIssue.issue;
         }
         return jsonCall;
@@ -11874,9 +12157,8 @@ var schemaSyncInEffect = createDiagnostic({
         option
       );
       if (isNone2(isSchemaSyncCall)) continue;
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || effectGen.body.statements.length === 0) continue;
-      if (scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+      if (!inEffect) continue;
       const nodeText = sourceFile.text.substring(
         ts.getTokenPosOfNode(node.expression, sourceFile),
         node.expression.end
@@ -12718,6 +13000,7 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   globalFetch,
+  globalFetchInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -12749,7 +13032,15 @@ var diagnostics = [
   preferSchemaOverJson,
   extendsNativeError,
   serviceNotAsClass,
-  nodeBuiltinImport
+  nodeBuiltinImport,
+  globalDate,
+  globalDateInEffect,
+  globalConsole,
+  globalConsoleInEffect,
+  globalRandom,
+  globalRandomInEffect,
+  globalTimers,
+  globalTimersInEffect
 ];
 
 // src/completions/effectDiagnosticsComment.ts