@effect/language-service 0.83.1 → 0.84.1

package/transform.js

@@ -3122,6 +3122,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,
@@ -3135,7 +3154,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     expectedAndRealType,
     typeToSimplifiedTypeNode,
     isGlobalErrorType,
-    getTypeAtLocation
+    getTypeAtLocation,
+    resolveToGlobalSymbol
   };
 }
 
@@ -3823,7 +3843,11 @@ function make2(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) {
@@ -5909,12 +5933,14 @@ var getParameterName = (typescript, name) => {
   }
   return "parameter";
 };
-var hasOuterContextualFunctionType = (typescript, typeChecker, node) => {
+var hasOuterContextualFunctionType = (typescript, typeChecker, typeCheckerUtils, node) => {
   const contextualType = typeChecker.getContextualType(node);
   if (!contextualType) {
     return false;
   }
-  return typeChecker.getSignaturesOfType(contextualType, typescript.SignatureKind.Call).length > 0;
+  return typeCheckerUtils.unrollUnionMembers(contextualType).some(
+    (type) => typeChecker.getSignaturesOfType(type, typescript.SignatureKind.Call).length > 0
+  );
 };
 var effectFnImplicitAny = createDiagnostic({
   name: "effectFnImplicitAny",
@@ -5928,6 +5954,7 @@ var effectFnImplicitAny = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
     if (!noImplicitAny) {
@@ -5967,7 +5994,7 @@ var effectFnImplicitAny = createDiagnostic({
         ),
         orUndefined
       );
-      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, parsed.call)) {
+      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, typeCheckerUtils, parsed.call)) {
         continue;
       }
       for (const parameter of parsed.fn.parameters) {
@@ -7018,6 +7045,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",
@@ -7137,46 +7286,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
@@ -8241,8 +8530,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",
@@ -10705,11 +10994,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;
@@ -10872,16 +11158,16 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var runEffectInsideEffect = createDiagnostic({
   name: "runEffectInsideEffect",
   code: 32,
-  description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+  description: "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts",
   group: "antipattern",
   severity: "suggestion",
   fixable: true,
-  supportedEffect: ["v3"],
+  supportedEffect: ["v3", "v4"],
   apply: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
-    if (typeParser.supportedEffect() === "v4") return;
+    const supportedEffect = typeParser.supportedEffect();
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map4(() => ({ node, methodName }))
@@ -10914,9 +11200,10 @@ var runEffectInsideEffect = createDiagnostic({
         if (scopeNode && scopeNode !== effectGen.generatorFunction) {
           const fixAddRuntime = gen(function* () {
             const changeTracker = yield* service(ChangeTracker);
-            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             let runtimeIdentifier = void 0;
+            let servicesIdentifier = void 0;
             for (const statement of effectGen.generatorFunction.body.statements) {
               if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
                 const declaration = statement.declarationList.declarations[0];
@@ -10930,11 +11217,46 @@ var runEffectInsideEffect = createDiagnostic({
                     if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
                       runtimeIdentifier = ts.idText(declaration.name);
                     }
+                    const maybeEffectServices = yield* pipe(
+                      typeParser.isNodeReferenceToEffectModuleApi("services")(yieldedExpression.expression),
+                      option
+                    );
+                    if (isSome2(maybeEffectServices) && ts.isIdentifier(declaration.name)) {
+                      servicesIdentifier = ts.idText(declaration.name);
+                    }
                   }
                 }
               }
             }
-            if (!runtimeIdentifier) {
+            if (supportedEffect === "v4" && !servicesIdentifier) {
+              changeTracker.insertNodeAt(
+                sourceFile,
+                effectGen.body.statements[0].pos,
+                ts.factory.createVariableStatement(
+                  void 0,
+                  ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                    "effectServices",
+                    void 0,
+                    void 0,
+                    ts.factory.createYieldExpression(
+                      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                      ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                          ts.factory.createIdentifier(effectModuleIdentifier),
+                          "services"
+                        ),
+                        [ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)],
+                        []
+                      )
+                    )
+                  )], ts.NodeFlags.Const)
+                ),
+                {
+                  prefix: "\n",
+                  suffix: "\n"
+                }
+              );
+            } else if (supportedEffect === "v3" && !runtimeIdentifier) {
               changeTracker.insertNodeAt(
                 sourceFile,
                 effectGen.body.statements[0].pos,
@@ -10970,16 +11292,19 @@ var runEffectInsideEffect = createDiagnostic({
             changeTracker.insertText(
               sourceFile,
               node.arguments[0].pos,
-              `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              supportedEffect === "v4" ? `${effectModuleIdentifier}.${isEffectRunCall.value.methodName}With(${servicesIdentifier || "effectServices"})(` : `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
             );
           });
+          const v4MethodName = `${isEffectRunCall.value.methodName}With`;
+          const messageText = supportedEffect === "v4" ? `Using ${nodeText} inside an Effect is not recommended. The same services should generally be used instead to run child effects.
+Consider extracting the current services by using for example Effect.services and then use Effect.${v4MethodName} with the extracted services instead.` : `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`;
           report({
             location: node.expression,
-            messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
+            messageText,
             fixes: [{
               fixName: "runEffectInsideEffect_fix",
-              description: "Use a runtime to run the Effect",
+              description: supportedEffect === "v4" ? "Use the current services to run the Effect" : "Use a runtime to run the Effect",
               apply: fixAddRuntime
             }]
           });
@@ -11125,9 +11450,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
@@ -11969,6 +12293,7 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   globalFetch,
+  globalFetchInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -12000,7 +12325,15 @@ var diagnostics = [
   preferSchemaOverJson,
   extendsNativeError,
   serviceNotAsClass,
-  nodeBuiltinImport
+  nodeBuiltinImport,
+  globalDate,
+  globalDateInEffect,
+  globalConsole,
+  globalConsoleInEffect,
+  globalRandom,
+  globalRandomInEffect,
+  globalTimers,
+  globalTimersInEffect
 ];
 
 // src/transform.ts