@effect/language-service 0.3.0 → 0.3.1

package/index.cjs

@@ -739,7 +739,7 @@ function pipeableType(ts, typeChecker) {
     return some2(type);
   };
 }
-function varianceStructCovariant(ts, typeChecker) {
+function varianceStructCovariantType(ts, typeChecker) {
   return (type, atLocation, propertyName) => gen(function* (_) {
     const propertySymbol = yield* fromNullable(
       typeChecker.getPropertyOfType(type, propertyName)
@@ -750,12 +750,12 @@ function varianceStructCovariant(ts, typeChecker) {
 }
 function effectVarianceStruct(ts, typeChecker) {
   return (type, atLocation) => all({
-    A: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_A"),
-    E: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_E"),
-    R: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_R")
+    A: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_A"),
+    E: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_E"),
+    R: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_R")
   });
 }
-function effectTypeArguments(ts, typeChecker) {
+function effectType(ts, typeChecker) {
   return (type, atLocation) => gen(function* (_) {
     yield* pipeableType(ts, typeChecker)(type, atLocation);
     for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
@@ -771,6 +771,19 @@ function effectTypeArguments(ts, typeChecker) {
     return yield* none2();
   });
 }
+function fiberType(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    const awaitSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "await")
+    );
+    const pollSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "poll")
+    );
+    if (!awaitSymbol || !pollSymbol)
+      return yield* none2();
+    return effectType(ts, typeChecker)(type, atLocation);
+  });
+}
 function importedEffectModule(ts, typeChecker) {
   return (node) => gen(function* () {
     const type = typeChecker.getTypeAtLocation(node);
@@ -778,7 +791,7 @@ function importedEffectModule(ts, typeChecker) {
       typeChecker.getPropertyOfType(type, "never")
     );
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-    return yield* effectTypeArguments(ts, typeChecker)(propertyType, node).pipe(
+    return yield* effectType(ts, typeChecker)(propertyType, node).pipe(
       map(() => node)
     );
   });
@@ -800,7 +813,10 @@ function effectGen(ts, typeChecker) {
     if (propertyAccess.name.text !== "gen")
       return yield* none2();
     return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({ body: generatorFunction.body }))
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
     );
   });
 }
@@ -873,13 +889,16 @@ var floatingEffect = createDiagnostic({
     const visit = (node) => {
       if (ts.isExpressionStatement(node) && (ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) {
         const type = typeChecker.getTypeAtLocation(node.expression);
-        const effect = effectTypeArguments(ts, typeChecker)(type, node.expression);
+        const effect = effectType(ts, typeChecker)(type, node.expression);
         if (isSome2(effect)) {
-          effectDiagnostics.push({
-            node,
-            category: ts.DiagnosticCategory.Error,
-            messageText: `Effect must be yielded or assigned to a variable.`
-          });
+          const fiber = fiberType(ts, typeChecker)(type, node.expression);
+          if (isNone2(fiber)) {
+            effectDiagnostics.push({
+              node,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Effect must be yielded or assigned to a variable.`
+            });
+          }
         }
       }
       ts.forEachChild(node, visit);
@@ -1268,32 +1287,34 @@ var missingEffectContext = createDiagnostic({
     const visit = (node) => {
       const entries = expectedAndRealType(ts, typeChecker)(node);
       for (const [node2, expectedType, valueNode, realType] of entries) {
-        gen(function* () {
-          const expectedEffect = yield* effectTypeArguments(ts, typeChecker)(
-            expectedType,
-            node2
-          );
-          const realEffect = yield* effectTypeArguments(ts, typeChecker)(
-            realType,
-            valueNode
-          );
-          const missingContext = getMissingTypeEntriesInTargetType(
-            ts,
-            typeChecker
-          )(
-            realEffect.R,
-            expectedEffect.R
+        const expectedEffect = effectType(ts, typeChecker)(
+          expectedType,
+          node2
+        );
+        if (isNone2(expectedEffect))
+          continue;
+        const realEffect = effectType(ts, typeChecker)(
+          realType,
+          valueNode
+        );
+        if (isNone2(realEffect))
+          continue;
+        const missingContext = getMissingTypeEntriesInTargetType(
+          ts,
+          typeChecker
+        )(
+          realEffect.value.R,
+          expectedEffect.value.R
+        );
+        if (missingContext.length > 0) {
+          effectDiagnostics.push(
+            {
+              node: node2,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
+            }
           );
-          if (missingContext.length > 0) {
-            effectDiagnostics.push(
-              {
-                node: node2,
-                category: ts.DiagnosticCategory.Error,
-                messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
-              }
-            );
-          }
-        });
+        }
       }
       ts.forEachChild(node, visit);
     };
@@ -1312,32 +1333,34 @@ var missingEffectError = createDiagnostic({
     const visit = (node) => {
       const entries = expectedAndRealType(ts, typeChecker)(node);
       for (const [node2, expectedType, valueNode, realType] of entries) {
-        gen(function* () {
-          const expectedEffect = yield* effectTypeArguments(ts, typeChecker)(
-            expectedType,
-            node2
-          );
-          const realEffect = yield* effectTypeArguments(ts, typeChecker)(
-            realType,
-            valueNode
-          );
-          const missingErrorTypes = getMissingTypeEntriesInTargetType(
-            ts,
-            typeChecker
-          )(
-            realEffect.E,
-            expectedEffect.E
+        const expectedEffect = effectType(ts, typeChecker)(
+          expectedType,
+          node2
+        );
+        if (isNone2(expectedEffect))
+          continue;
+        const realEffect = effectType(ts, typeChecker)(
+          realType,
+          valueNode
+        );
+        if (isNone2(realEffect))
+          continue;
+        const missingErrorTypes = getMissingTypeEntriesInTargetType(
+          ts,
+          typeChecker
+        )(
+          realEffect.value.E,
+          expectedEffect.value.E
+        );
+        if (missingErrorTypes.length > 0) {
+          effectDiagnostics.push(
+            {
+              node: node2,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Missing '${sortTypes(missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
+            }
           );
-          if (missingErrorTypes.length > 0) {
-            effectDiagnostics.push(
-              {
-                node: node2,
-                category: ts.DiagnosticCategory.Error,
-                messageText: `Missing '${sortTypes(missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
-              }
-            );
-          }
-        });
+        }
       }
       ts.forEachChild(node, visit);
     };
@@ -1352,36 +1375,41 @@ var missingStarInYieldEffectGen = createDiagnostic({
   apply: (ts, program) => (sourceFile) => {
     const typeChecker = program.getTypeChecker();
     const effectDiagnostics = [];
-    const visitWhileInGenerator = (node) => {
-      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const brokenYields = /* @__PURE__ */ new Set();
+    const visit = (functionStarNode) => (node) => {
+      if (functionStarNode && ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
         const type = typeChecker.getTypeAtLocation(node.expression);
-        const effect = effectTypeArguments(ts, typeChecker)(type, node.expression);
+        const effect = effectType(ts, typeChecker)(type, node.expression);
         if (isSome2(effect)) {
-          effectDiagnostics.push({
-            node,
-            category: ts.DiagnosticCategory.Error,
-            messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
-          });
+          brokenGenerators.add(functionStarNode);
+          brokenYields.add(node);
         }
       }
       const effectGen2 = effectGen(ts, typeChecker)(node);
       if (isSome2(effectGen2)) {
-        ts.forEachChild(effectGen2.value.body, visitWhileInGenerator);
+        ts.forEachChild(effectGen2.value.body, visit(effectGen2.value.functionStar));
       } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
-        ts.forEachChild(node, visit);
-      } else {
-        ts.forEachChild(node, visitWhileInGenerator);
-      }
-    };
-    const visit = (node) => {
-      const effectGen2 = effectGen(ts, typeChecker)(node);
-      if (isSome2(effectGen2)) {
-        ts.forEachChild(effectGen2.value.body, visitWhileInGenerator);
+        ts.forEachChild(node, visit(void 0));
       } else {
-        ts.forEachChild(node, visit);
+        ts.forEachChild(node, visit(functionStarNode));
       }
     };
-    ts.forEachChild(sourceFile, visit);
+    ts.forEachChild(sourceFile, visit(void 0));
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`
+      })
+    );
+    brokenYields.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
+      })
+    );
     return effectDiagnostics;
   }
 });