@effect/language-service 0.3.1 → 0.4.0

package/{index.cjs → index.js}

@@ -723,19 +723,16 @@ function createDiagnostic(definition) {
 // src/utils/TypeParser.ts
 var covariantTypeArgument = (type) => {
   const signatures = type.getCallSignatures();
-  if (signatures.length !== 1)
-    return none2();
+  if (signatures.length !== 1) return none2();
   return some2(signatures[0].getReturnType());
 };
 function pipeableType(ts, typeChecker) {
   return (type, atLocation) => {
     const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-    if (!pipeSymbol)
-      return none2();
+    if (!pipeSymbol) return none2();
     const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
     const signatures = pipeType.getCallSignatures();
-    if (signatures.length === 0)
-      return none2();
+    if (signatures.length === 0) return none2();
     return some2(type);
   };
 }
@@ -779,8 +776,16 @@ function fiberType(ts, typeChecker) {
     const pollSymbol = yield* fromNullable(
       typeChecker.getPropertyOfType(type, "poll")
     );
-    if (!awaitSymbol || !pollSymbol)
-      return yield* none2();
+    if (!awaitSymbol || !pollSymbol) return yield* none2();
+    return effectType(ts, typeChecker)(type, atLocation);
+  });
+}
+function effectSubtype(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    const tagSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "_tag")
+    );
+    if (!tagSymbol) return yield* none2();
     return effectType(ts, typeChecker)(type, atLocation);
   });
 }
@@ -798,20 +803,51 @@ function importedEffectModule(ts, typeChecker) {
 }
 function effectGen(ts, typeChecker) {
   return (node) => gen(function* () {
-    if (!ts.isCallExpression(node))
-      return yield* none2();
-    if (node.arguments.length === 0)
-      return yield* none2();
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
     const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction))
-      return yield* none2();
-    if (generatorFunction.asteriskToken === void 0)
-      return yield* none2();
-    if (!ts.isPropertyAccessExpression(node.expression))
-      return yield* none2();
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
     const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "gen")
-      return yield* none2();
+    if (propertyAccess.name.text !== "gen") return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
+    );
+  });
+}
+function effectFnUntracedGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "fnUntraced") return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
+    );
+  });
+}
+function effectFnGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+    if (!ts.isPropertyAccessExpression(expressionToTest)) return yield* none2();
+    const propertyAccess = expressionToTest;
+    if (propertyAccess.name.text !== "fn") return yield* none2();
     return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
       map(() => ({
         body: generatorFunction.body,
@@ -861,15 +897,13 @@ function expectedAndRealType(ts, typeChecker) {
     if (ts.isReturnStatement(node) && node.expression) {
       const expectedType = typeChecker.getContextualType(node.expression);
       const realType = typeChecker.getTypeAtLocation(node.expression);
-      if (expectedType)
-        return [[node, expectedType, node, realType]];
+      if (expectedType) return [[node, expectedType, node, realType]];
     }
     if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
       const body = node.body;
       const expectedType = typeChecker.getContextualType(body);
       const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType)
-        return [[body, expectedType, body, realType]];
+      if (expectedType) return [[body, expectedType, body, realType]];
     }
     if (ts.isSatisfiesExpression(node)) {
       const expectedType = typeChecker.getTypeAtLocation(node.type);
@@ -886,13 +920,23 @@ var floatingEffect = createDiagnostic({
   apply: (ts, program) => (sourceFile) => {
     const typeChecker = program.getTypeChecker();
     const effectDiagnostics = [];
+    function isFloatingExpression(node) {
+      if (!ts.isExpressionStatement(node)) return false;
+      if (!(ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) return false;
+      const expression = node.expression;
+      if (ts.isBinaryExpression(expression) && expression.operatorToken && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) return false;
+      return true;
+    }
     const visit = (node) => {
-      if (ts.isExpressionStatement(node) && (ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) {
+      if (isFloatingExpression(node)) {
         const type = typeChecker.getTypeAtLocation(node.expression);
         const effect = effectType(ts, typeChecker)(type, node.expression);
         if (isSome2(effect)) {
-          const fiber = fiberType(ts, typeChecker)(type, node.expression);
-          if (isNone2(fiber)) {
+          const allowedFloatingEffects = pipe(
+            fiberType(ts, typeChecker)(type, node.expression),
+            orElse(() => effectSubtype(ts, typeChecker)(type, node.expression))
+          );
+          if (isNone2(allowedFloatingEffects)) {
             effectDiagnostics.push({
               node,
               category: ts.DiagnosticCategory.Error,
@@ -968,8 +1012,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 function getNodesContainingRange(ts) {
   return (sourceFile, textRange) => {
     const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
-    if (!precedingToken)
-      return empty();
+    if (!precedingToken) return empty();
     let result = empty();
     let parent = precedingToken;
     while (parent) {
@@ -989,19 +1032,14 @@ function isNodeInRange(textRange) {
 }
 function findModuleNamedBindings(ts) {
   return (sourceFile, moduleName) => fromNullable(ts.forEachChild(sourceFile, (node) => {
-    if (!ts.isImportDeclaration(node))
-      return;
+    if (!ts.isImportDeclaration(node)) return;
     const moduleSpecifier = node.moduleSpecifier;
-    if (!ts.isStringLiteral(moduleSpecifier))
-      return;
-    if (moduleSpecifier.text !== moduleName)
-      return;
+    if (!ts.isStringLiteral(moduleSpecifier)) return;
+    if (moduleSpecifier.text !== moduleName) return;
     const importClause = node.importClause;
-    if (!importClause)
-      return;
+    if (!importClause) return;
     const namedBindings = importClause.namedBindings;
-    if (!namedBindings)
-      return;
+    if (!namedBindings) return;
     return namedBindings;
   }));
 }
@@ -1010,8 +1048,7 @@ function findModuleNamespaceImportIdentifierName(ts) {
     findModuleNamedBindings(ts)(sourceFile, moduleName),
     map(
       (namedBindings) => {
-        if (!ts.isNamespaceImport(namedBindings))
-          return;
+        if (!ts.isNamespaceImport(namedBindings)) return;
         return namedBindings.name.text;
       }
     ),
@@ -1022,11 +1059,10 @@ function findModuleNamedImportIdentifierName(ts) {
   return (sourceFile, moduleName, namedImport) => pipe(
     findModuleNamedBindings(ts)(sourceFile, moduleName),
     map((namedBindings) => {
-      if (!ts.isNamedImports(namedBindings))
-        return;
+      if (!ts.isNamedImports(namedBindings)) return;
       for (const importSpecifier of namedBindings.elements) {
-        if (importSpecifier.propertyName?.escapedText === namedImport) {
-          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.escapedText;
+        if (importSpecifier.propertyName?.getText() === namedImport) {
+          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
         }
       }
     }),
@@ -1036,29 +1072,22 @@ function findModuleNamedImportIdentifierName(ts) {
 function findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker) {
   return (sourceFile, importName) => {
     return fromNullable(ts.forEachChild(sourceFile, (node) => {
-      if (!ts.isImportDeclaration(node))
-        return;
-      if (!node.importClause)
-        return;
+      if (!ts.isImportDeclaration(node)) return;
+      if (!node.importClause) return;
       const namedBindings = node.importClause.namedBindings;
-      if (!namedBindings)
-        return;
+      if (!namedBindings) return;
       if (ts.isNamespaceImport(namedBindings)) {
         const symbol3 = typeChecker.getTypeAtLocation(namedBindings).getSymbol();
-        if (!symbol3 || !symbol3.exports)
-          return;
-        if (!symbol3.exports.has(importName))
-          return;
+        if (!symbol3 || !symbol3.exports) return;
+        if (!symbol3.exports.has(importName)) return;
         return namedBindings.name.escapedText;
       }
       if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
           const symbol3 = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
-          if (!symbol3 || !symbol3.exports)
-            return;
-          if (!symbol3.exports.has(importName))
-            return;
-          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.escapedText;
+          if (!symbol3 || !symbol3.exports) return;
+          if (!symbol3.exports.has(importName)) return;
+          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
         }
       }
     }));
@@ -1179,8 +1208,7 @@ function getEffectModuleIdentifier(ts, typeChecker) {
 }
 function simplifyTypeNode(ts) {
   function collectCallable(typeNode) {
-    if (ts.isParenthesizedTypeNode(typeNode))
-      return collectCallable(typeNode.type);
+    if (ts.isParenthesizedTypeNode(typeNode)) return collectCallable(typeNode.type);
     if (ts.isFunctionTypeNode(typeNode)) {
       return some2([
         ts.factory.createCallSignature(typeNode.typeParameters, typeNode.parameters, typeNode.type)
@@ -1210,23 +1238,18 @@ function simplifyTypeNode(ts) {
 }
 function isPipeCall(ts) {
   return (node) => {
-    if (!ts.isCallExpression(node))
-      return false;
+    if (!ts.isCallExpression(node)) return false;
     const expression = node.expression;
-    if (!ts.isIdentifier(expression))
-      return false;
-    if (expression.text !== "pipe")
-      return false;
+    if (!ts.isIdentifier(expression)) return false;
+    if (expression.text !== "pipe") return false;
     return true;
   };
 }
 function asDataFirstExpression(ts, checker) {
   return (node, self) => {
-    if (!ts.isCallExpression(node))
-      return none2();
+    if (!ts.isCallExpression(node)) return none2();
     const signature = checker.getResolvedSignature(node);
-    if (!signature)
-      return none2();
+    if (!signature) return none2();
     const callSignatures = checker.getTypeAtLocation(node.expression).getCallSignatures();
     for (let i = 0; i < callSignatures.length; i++) {
       const callSignature = callSignatures[i];
@@ -1247,10 +1270,8 @@ function deterministicTypeOrder(ts, typeChecker) {
   return make2((a, b) => {
     const aName = typeChecker.typeToString(a);
     const bName = typeChecker.typeToString(b);
-    if (aName < bName)
-      return -1;
-    if (aName > bName)
-      return 1;
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
     return 0;
   });
 }
@@ -1262,8 +1283,7 @@ function getMissingTypeEntriesInTargetType(ts, typeChecker) {
     const toTest = [realType];
     while (toTest.length > 0) {
       const type = toTest.pop();
-      if (!type)
-        return result;
+      if (!type) return result;
       if (type.isUnion()) {
         toTest.push(...type.types);
       } else {
@@ -1291,14 +1311,12 @@ var missingEffectContext = createDiagnostic({
           expectedType,
           node2
         );
-        if (isNone2(expectedEffect))
-          continue;
+        if (isNone2(expectedEffect)) continue;
         const realEffect = effectType(ts, typeChecker)(
           realType,
           valueNode
         );
-        if (isNone2(realEffect))
-          continue;
+        if (isNone2(realEffect)) continue;
         const missingContext = getMissingTypeEntriesInTargetType(
           ts,
           typeChecker
@@ -1337,14 +1355,12 @@ var missingEffectError = createDiagnostic({
           expectedType,
           node2
         );
-        if (isNone2(expectedEffect))
-          continue;
+        if (isNone2(expectedEffect)) continue;
         const realEffect = effectType(ts, typeChecker)(
           realType,
           valueNode
         );
-        if (isNone2(realEffect))
-          continue;
+        if (isNone2(realEffect)) continue;
         const missingErrorTypes = getMissingTypeEntriesInTargetType(
           ts,
           typeChecker
@@ -1386,9 +1402,13 @@ var missingStarInYieldEffectGen = createDiagnostic({
           brokenYields.add(node);
         }
       }
-      const effectGen2 = effectGen(ts, typeChecker)(node);
-      if (isSome2(effectGen2)) {
-        ts.forEachChild(effectGen2.value.body, visit(effectGen2.value.functionStar));
+      const effectGenLike = pipe(
+        effectGen(ts, typeChecker)(node),
+        orElse(() => effectFnUntracedGen(ts, typeChecker)(node)),
+        orElse(() => effectFnGen(ts, typeChecker)(node))
+      );
+      if (isSome2(effectGenLike)) {
+        ts.forEachChild(effectGenLike.value.body, visit(effectGenLike.value.functionStar));
       } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
         ts.forEachChild(node, visit(void 0));
       } else {
@@ -1760,8 +1780,7 @@ var toggleReturnTypeAnnotation = createRefactor({
             const returnTypeNodes = returnTypes.map(
               (type) => typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.NoTruncation)
             ).filter((node2) => !!node2);
-            if (returnTypeNodes.length === 0)
-              return;
+            if (returnTypeNodes.length === 0) return;
             const returnTypeNode = returnTypeNodes.length === 1 ? returnTypeNodes[0] : ts.factory.createUnionTypeNode(returnTypeNodes);
             addReturnTypeAnnotation(ts, changeTracker)(
               sourceFile,
@@ -1823,8 +1842,7 @@ var wrapWithPipe = createRefactor({
   name: "effect/wrapWithPipe",
   description: "Wrap with pipe",
   apply: () => (sourceFile, textRange) => {
-    if (textRange.end - textRange.pos === 0)
-      return none2();
+    if (textRange.end - textRange.pos === 0) return none2();
     return some2({
       kind: "refactor.rewrite.effect.wrapWithPipe",
       description: `Wrap with pipe(...)`,
@@ -1997,4 +2015,4 @@ var init = (modules) => {
   return { create };
 };
 module.exports = init;
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.js.map