@effect/language-service 0.23.5 → 0.24.0

package/README.md

@@ -5,7 +5,7 @@ This package implements a TypeScript language service plugin that allows additio
 ## Installation
 
 1. `npm install @effect/language-service --save-dev` in your project
-2. inside your tsconfig.json, you should add the plugin configuration as follows:
+2. Inside your tsconfig.json, you should add the plugin configuration as follows:
 ```jsonc
 {
   "compilerOptions": {
@@ -22,10 +22,10 @@ This package implements a TypeScript language service plugin that allows additio
 3. Ensure that you have installed TypeScript locally in your project and set your editor to use your workspace TypeScript version.
 
    - In VSCode you can do this by pressing "F1" and typing "TypeScript: Select TypeScript version". Then select "Use workspace version". If that option does not appear, TypeScript is not installed locally in your node_modules.
-   - In JetBrains you may have to disable the Vue language service, and chose the workspace version of TypeScript in the settings from the dropdown.
-   - In NVim with nvim-vtsls you should refer to [how to enable TypeScript plugins in vstls](https://github.com/yioneko/vtsls?tab=readme-ov-file#typescript-plugin-not-activated)
+   - In JetBrains you may have to disable the Vue language service, and choose the workspace version of TypeScript in the settings from the dropdown.
+   - In NVim with nvim-vtsls you should refer to [how to enable TypeScript plugins in vtsls](https://github.com/yioneko/vtsls?tab=readme-ov-file#typescript-plugin-not-activated)
 
-And you're done! You'll now be able to use a set of refactor and diagnostics that targets Effect!
+And you're done! You'll now be able to use a set of refactors and diagnostics that target Effect!
 
 ## Provided functionalities
 
@@ -33,7 +33,7 @@ And you're done! You'll now be able to use a set of refactor and diagnostics tha
 
 - Show the extended type of the current Effect
 - Hovering `yield\*` of `Effect.gen` will show the Effect type parameters
-- Hovering a variable assignment of a type Layer, will show info on how each service got involve
+- Hovering a variable assignment of a type Layer, will show info on how each service got involved
 - Hovering a layer, will attempt to produce a graph
 
 ### Diagnostics
@@ -85,7 +85,7 @@ Few options can be provided alongside the initialization of the Language Service
         "quickinfo": true, // controls quickinfo over Effect (default: true)
         "completions": true, // controls Effect completions (default: true)
         "goto": true, // controls Effect goto references (default: true)
-        "allowedDuplicatedPackages": [], // list of package names that has effect in peer dependencies and are allowed to be duplicated (default: [])
+        "allowedDuplicatedPackages": [], // list of package names that have effect in peer dependencies and are allowed to be duplicated (default: [])
         "barrelImportPackages": [], // package names that should be preferred as imported from the top level barrel file (default: [])
         "namespaceImportPackages": [] // package names that should be preferred as imported with namespace imports e.g. ["effect", "@effect/*"] (default: [])
       }
@@ -94,9 +94,9 @@ Few options can be provided alongside the initialization of the Language Service
 }
 ```
 
-## Why diagnostics does not appear at compile time?
+## Why do diagnostics not appear at compile time?
 
-TypeScript LSP are loaded only while editing your files. That means that if you run `tsc` in your project, the plugin won't be loaded and you'll miss out on the Effect diagnostics.
+TypeScript LSPs are loaded only while editing your files. That means that if you run `tsc` in your project, the plugin won't be loaded and you'll miss out on the Effect diagnostics.
 
 HOWEVER, if you use `ts-patch` you can enable the transform as well to get the diagnostics also at compile time.
 Your `tsconfig.json` should look like this:
@@ -117,7 +117,7 @@ Your `tsconfig.json` should look like this:
 To get diagnostics you need to install `ts-patch` which will make it possible to run `tspc`.
 
 Running `tspc` in your project will now also run the plugin and give you the diagnostics at compile time.
-Effect diagnostics will be shown only after standard TypeScript diagnostics has been satisfied.
+Effect diagnostics will be shown only after standard TypeScript diagnostics have been satisfied.
 
 ```ts
 $ npx tspc
@@ -165,9 +165,9 @@ or you can set the severity for the entire project in the global plugin configur
 
 The Svelte LSP does not properly compose with other LSPs when using SvelteKit. So the Effect LSP should be loaded as last entry to ensure proper composition.
 
-If you did not installed the Svelte LSP into your local project but instead through the Svelte VSCode extension, we recommend instead to install locally and add it as first entry. That way it won't be applied by the VSCode extension.
+If you did not install the Svelte LSP into your local project but instead through the Svelte VSCode extension, we recommend instead to install it locally and add it as the first entry. That way it won't be applied by the VSCode extension.
 
-Your tsconfig should look like this:
+Your tsconfig.json should look like this:
 
 ```jsonc
 {

package/index.js

@@ -2162,22 +2162,16 @@ function make4(ts, typeChecker) {
   );
   const effectType = cachedBy(
     fn("TypeParser.effectType")(function* (type, atLocation) {
-      yield* pipeableType(type, atLocation);
+      let result = typeParserIssue("Type has no effect variance struct", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
       for (const propertySymbol of propertiesSymbols) {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        const varianceArgs = yield* option(effectVarianceStruct(
-          propertyType,
-          atLocation
-        ));
-        if (isSome2(varianceArgs)) {
-          return varianceArgs.value;
-        }
+        result = pipe(result, orElse2(() => effectVarianceStruct(propertyType, atLocation)));
       }
-      return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+      return yield* result;
     }),
     "TypeParser.effectType",
     (type) => type
@@ -2196,7 +2190,7 @@ function make4(ts, typeChecker) {
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2480,7 +2474,7 @@ function make4(ts, typeChecker) {
       const ast = typeChecker.getPropertyOfType(type, "ast");
       if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2509,7 +2503,7 @@ function make4(ts, typeChecker) {
     fn("TypeParser.contextTag")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2541,6 +2535,25 @@ function make4(ts, typeChecker) {
     "TypeParser.pipeCall",
     (node) => node
   );
+  const scopeType = cachedBy(
+    fn("TypeParser.scopeType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+      );
+      propertiesSymbols.sort((a, b) => b.name.indexOf("ScopeTypeId") - a.name.indexOf("ScopeTypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const computedPropertyExpression = propertySymbol.valueDeclaration.name;
+        const symbol3 = typeChecker.getSymbolAtLocation(computedPropertyExpression.expression);
+        if (symbol3 && symbol3.name === "ScopeTypeId") {
+          return type;
+        }
+      }
+      return yield* typeParserIssue("Type has no scope type id", type, atLocation);
+    }),
+    "TypeParser.scopeType",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2554,7 +2567,8 @@ function make4(ts, typeChecker) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
-    pipeCall
+    pipeCall,
+    scopeType
   };
 }
 
@@ -2947,18 +2961,39 @@ var missingEffectError = createDiagnostic({
   code: 1,
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Effect"))
+    );
+    const createDieMessage = (message) => ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleIdentifier),
+        "dieMessage"
+      ),
+      void 0,
+      [ts.factory.createStringLiteral(message)]
+    );
     const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
       all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
       flatMap2(
-        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
-          realEffect.E,
-          expectedEffect.E
+        ([expectedEffect, realEffect]) => pipe(
+          getMissingTypeEntriesInTargetType(
+            realEffect.E,
+            expectedEffect.E
+          ),
+          map4((missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E }))
         )
       )
     );
@@ -2973,15 +3008,79 @@ var missingEffectError = createDiagnostic({
             valueNode,
             realType
           ),
-          map4(
-            (missingTypes) => missingTypes.length > 0 ? report(
+          map4((result) => {
+            if (result.missingErrorTypes.length === 0) return;
+            const fixes = [];
+            if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
+              fixes.push({
+                fixName: "missingEffectError_catchAll",
+                description: "Catch all errors with Effect.catchAll",
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchAll(");
+                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ", () => ");
+                  changeTracker.insertNodeAt(
+                    sourceFile,
+                    valueNode.getEnd(),
+                    createDieMessage("TODO: catchAll not implemented")
+                  );
+                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                })
+              });
+            }
+            if (ts.isExpression(valueNode)) {
+              const propertyAssignments = pipe(
+                result.missingErrorTypes,
+                map3((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                filter((_) => !!_),
+                map3((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
+                map3((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                filter((_) => !!_ && ts.isLiteralTypeNode(_)),
+                map3((_) => _.literal),
+                filter((_) => ts.isLiteralExpression(_)),
+                map3((_) => _.text),
+                sort(string2),
+                map3(
+                  (_) => ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier(_),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [],
+                      void 0,
+                      void 0,
+                      createDieMessage(`TODO: catchTags() not implemented for ${_}`)
+                    )
+                  )
+                )
+              );
+              if (propertyAssignments.length === result.missingErrorTypes.length) {
+                fixes.push({
+                  fixName: "missingEffectError_tagged",
+                  description: "Catch unexpected errors with Effect.catchTag",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchTags(");
+                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ", ");
+                    changeTracker.insertNodeAt(
+                      sourceFile,
+                      valueNode.getEnd(),
+                      ts.factory.createObjectLiteralExpression(propertyAssignments)
+                    );
+                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                  })
+                });
+              }
+            }
+            report(
               {
                 node,
-                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
-                fixes: []
+                messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+                fixes
               }
-            ) : void 0
-          ),
+            );
+          }),
           ignore
         );
       }
@@ -3193,6 +3292,108 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
   })
 });
 
+// src/diagnostics/scopeInLayerEffect.ts
+var scopeInLayerEffect = createDiagnostic({
+  name: "scopeInLayerEffect",
+  code: 13,
+  severity: "warning",
+  apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Layer"))
+    );
+    function parseLayerEffectApiCall(node) {
+      if (!ts.isCallExpression(node)) return;
+      const expression = node.expression;
+      if (!ts.isPropertyAccessExpression(expression)) return;
+      const calledModule = expression.expression;
+      if (!(ts.isIdentifier(calledModule) && calledModule.text === layerModuleIdentifier)) return;
+      const methodIdentifier = expression.name;
+      if (!(ts.isIdentifier(methodIdentifier) && methodIdentifier.text.toLowerCase().startsWith("effect"))) return;
+      return { methodIdentifier };
+    }
+    const reportIfLayerRequireScope = (type, node, methodIdentifier) => {
+      let toCheck = [type];
+      const entries = [];
+      while (toCheck.length > 0) {
+        const type2 = toCheck.pop();
+        if (type2.isUnion()) {
+          toCheck = toCheck.concat(type2.types);
+        } else {
+          entries.push(type2);
+        }
+      }
+      return pipe(
+        firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
+        map4(
+          () => report({
+            node,
+            messageText: `Seems like you are constructing a layer with a scope in the requirements.
+Consider using "scoped" instead to get ride of the scope in the requirements.`,
+            fixes: methodIdentifier ? [{
+              fixName: "scopeInLayerEffect_scoped",
+              description: "Use scoped for Layer creation",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                changeTracker.replaceNode(
+                  sourceFile,
+                  methodIdentifier,
+                  ts.factory.createIdentifier("scoped")
+                );
+              })
+            }] : []
+          })
+        ),
+        ignore
+      );
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const layerEffectApiCall = parseLayerEffectApiCall(node);
+      if (layerEffectApiCall) {
+        const type = typeChecker.getTypeAtLocation(node);
+        yield* pipe(
+          typeParser.layerType(type, node),
+          flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+          ignore
+        );
+        continue;
+      }
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const classType = typeChecker.getTypeOfSymbol(classSym);
+          const defaultLayer = typeChecker.getPropertyOfType(classType, "Default");
+          if (defaultLayer) {
+            const type = typeChecker.getTypeOfSymbolAtLocation(defaultLayer, node);
+            yield* pipe(
+              typeParser.layerType(type, node),
+              flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
+              ignore
+            );
+            continue;
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -3294,7 +3495,8 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   returnEffectInGen,
-  importFromBarrel
+  importFromBarrel,
+  scopeInLayerEffect
 ];
 
 // src/completions/effectDiagnosticsComment.ts