@effect/language-service 0.40.0 → 0.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -3381,7 +3381,7 @@ var classSelfMismatch = createDiagnostic({
         );
         if (result) {
           const { className, selfTypeNode } = result;
-          let actualName = "";
+          let actualName = sourceFile.text.substring(selfTypeNode.pos, selfTypeNode.end);
           if (ts.isTypeReferenceNode(selfTypeNode)) {
             if (ts.isIdentifier(selfTypeNode.typeName)) {
               actualName = ts.idText(selfTypeNode.typeName);
@@ -4098,7 +4098,7 @@ var missingEffectError = createDiagnostic({
 // src/diagnostics/missingEffectServiceDependency.ts
 var missingEffectServiceDependency = createDiagnostic({
   name: "missingEffectServiceDependency",
-  code: 21,
+  code: 22,
   severity: "off",
   apply: fn("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4420,6 +4420,96 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/diagnostics/nonObjectEffectServiceType.ts
+var nonObjectEffectServiceType = createDiagnostic({
+  name: "nonObjectEffectServiceType",
+  code: 24,
+  severity: "error",
+  apply: fn("nonObjectEffectServiceType.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    function isPrimitiveType(type) {
+      return typeCheckerUtils.unrollUnionMembers(type).some(
+        (type2) => !!(type2.flags & ts.TypeFlags.String || type2.flags & ts.TypeFlags.Number || type2.flags & ts.TypeFlags.Boolean || type2.flags & ts.TypeFlags.StringLiteral || type2.flags & ts.TypeFlags.NumberLiteral || type2.flags & ts.TypeFlags.BooleanLiteral || type2.flags & ts.TypeFlags.Undefined || type2.flags & ts.TypeFlags.Null)
+      );
+    }
+    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.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const serviceResult = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse2(() => void_)
+        );
+        if (serviceResult && serviceResult.options && ts.isObjectLiteralExpression(serviceResult.options)) {
+          const options = serviceResult.options;
+          for (const property of options.properties) {
+            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+              continue;
+            }
+            const propertyName = ts.idText(property.name);
+            const propertyValue = property.initializer;
+            const errorToReport = {
+              location: property.name,
+              messageText: "Effect.Service requires the service type to be an object {} and not a primitive type. \nConsider wrapping the value in an object, or manually using Context.Tag or Effect.Tag if you want to use a primitive instead.",
+              fixes: []
+            };
+            if (propertyName === "succeed") {
+              const valueType = typeChecker.getTypeAtLocation(propertyValue);
+              if (isPrimitiveType(valueType)) {
+                report(errorToReport);
+              }
+            } else if (propertyName === "sync") {
+              const valueType = typeChecker.getTypeAtLocation(propertyValue);
+              const signatures = typeChecker.getSignaturesOfType(valueType, ts.SignatureKind.Call);
+              for (const signature of signatures) {
+                const returnType = typeChecker.getReturnTypeOfSignature(signature);
+                if (isPrimitiveType(returnType)) {
+                  report(errorToReport);
+                  break;
+                }
+              }
+            } else if (propertyName === "effect" || propertyName === "scoped") {
+              const valueType = typeChecker.getTypeAtLocation(propertyValue);
+              const effectResult = yield* pipe(
+                typeParser.effectType(valueType, propertyValue),
+                orElse2(() => void_)
+              );
+              if (effectResult) {
+                if (isPrimitiveType(effectResult.A)) {
+                  report(errorToReport);
+                  continue;
+                }
+              } else {
+                const signatures = typeChecker.getSignaturesOfType(valueType, ts.SignatureKind.Call);
+                for (const signature of signatures) {
+                  const returnType = typeChecker.getReturnTypeOfSignature(signature);
+                  const effectReturnResult = yield* pipe(
+                    typeParser.effectType(returnType, propertyValue),
+                    orElse2(() => void_)
+                  );
+                  if (effectReturnResult && isPrimitiveType(effectReturnResult.A)) {
+                    report(errorToReport);
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/refactors/writeTagClassAccessors.ts
 var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, service2, className, atLocation, involvedMembers) {
   const ts = yield* service(TypeScriptApi);
@@ -4468,7 +4558,10 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       ]
     );
     return ts.factory.createPropertyDeclaration(
-      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+      [
+        ts.factory.createModifier(ts.SyntaxKind.StaticKeyword),
+        ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)
+      ],
       propertyName,
       void 0,
       type,
@@ -5331,7 +5424,8 @@ var diagnostics = [
   multipleEffectProvide,
   outdatedEffectCodegen,
   overriddenSchemaConstructor,
-  unsupportedServiceAccessors
+  unsupportedServiceAccessors,
+  nonObjectEffectServiceType
 ];
 
 // src/transform.ts