@effect/language-service 0.73.1 → 0.74.0

package/package.json

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

package/transform.js

@@ -3404,6 +3404,28 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectParseResultModuleApi(${memberName})`,
     (node) => node
   );
+  const isEffectSchemaParserSourceFile = cachedBy(
+    fn("TypeParser.isEffectSchemaParserSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const parseIssueSymbol = typeChecker.tryGetMemberInModuleExports("Parser", moduleSymbol);
+      if (!parseIssueSymbol) return yield* typeParserIssue("ParseIssue type not found", void 0, sourceFile);
+      const decodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("decodeEffect", moduleSymbol);
+      if (!decodeSyncSymbol) return yield* typeParserIssue("decodeSync not found", void 0, sourceFile);
+      const encodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("encodeEffect", moduleSymbol);
+      if (!encodeSyncSymbol) return yield* typeParserIssue("encodeSync not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaParserSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaParserModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSchemaParserModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaParserSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaParserModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
@@ -3411,6 +3433,31 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     ),
     ([Identifier, Service]) => ({ Identifier, Service })
   );
+  const serviceVarianceStruct = (type, atLocation) => map4(
+    all(
+      varianceStructInvariantType(type, atLocation, "_Identifier"),
+      varianceStructInvariantType(type, atLocation, "_Service")
+    ),
+    ([Identifier, Service]) => ({ Identifier, Service })
+  );
+  const serviceType = cachedBy(
+    fn("TypeParser.serviceType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+      );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+      }
+      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        return serviceVarianceStruct(propertyType, atLocation);
+      }));
+    }),
+    "TypeParser.serviceType",
+    (type) => type
+  );
   const contextTag = cachedBy(
     fn("TypeParser.contextTag")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
@@ -3492,14 +3539,22 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   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
-      );
-      if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
-        return type;
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/Scope");
+        if (typeIdSymbol) {
+          return type;
+        }
+        return yield* typeParserIssue("Type is not an effect", type, atLocation);
+      } else {
+        yield* pipeableType(type, atLocation);
+        const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+          (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+        );
+        if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
+          return type;
+        }
+        return yield* typeParserIssue("Type has no scope type id", type, atLocation);
       }
-      return yield* typeParserIssue("Type has no scope type id", type, atLocation);
     }),
     "TypeParser.scopeType",
     (type) => type
@@ -3981,6 +4036,55 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectService",
     (atLocation) => atLocation
   );
+  const extendsServiceMapService = cachedBy(
+    fn("TypeParser.extendsServiceMapService")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const serviceMapServiceCall = wholeCall.expression;
+              if (ts.isCallExpression(serviceMapServiceCall) && serviceMapServiceCall.typeArguments && serviceMapServiceCall.typeArguments.length > 0) {
+                const serviceMapServiceIdentifier = serviceMapServiceCall.expression;
+                const selfTypeNode = serviceMapServiceCall.typeArguments[0];
+                const isServiceMapService = yield* pipe(
+                  isNodeReferenceToServiceMapModuleApi("Service")(serviceMapServiceIdentifier),
+                  orUndefined
+                );
+                if (isServiceMapService) {
+                  const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                  if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                  const type = typeChecker.getTypeOfSymbol(classSym);
+                  const parsedServiceType = yield* pipe(
+                    serviceType(type, atLocation),
+                    orUndefined
+                  );
+                  if (parsedServiceType) {
+                    return {
+                      ...parsedServiceType,
+                      className: atLocation.name,
+                      selfTypeNode,
+                      keyStringLiteral: wholeCall.arguments.length > 0 && ts.isStringLiteral(wholeCall.arguments[0]) ? wholeCall.arguments[0] : void 0
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend ServiceMap.Service", void 0, atLocation);
+    }),
+    "TypeParser.extendsServiceMapService",
+    (atLocation) => atLocation
+  );
   const isEffectSqlModelTypeSourceFile = cachedBy(
     fn("TypeParser.isEffectSqlModelTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -4073,6 +4177,24 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectLayerModuleApi(${memberName})`,
     (node) => node
   );
+  const isServiceMapTypeSourceFile = cachedBy(
+    fn("TypeParser.isServiceMapTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const serviceMapSymbol = typeChecker.tryGetMemberInModuleExports("ServiceMap", moduleSymbol);
+      if (!serviceMapSymbol) return yield* typeParserIssue("ServiceMap not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isServiceMapTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToServiceMapModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToServiceMapModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isServiceMapTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToServiceMapModuleApi(${memberName})`,
+    (node) => node
+  );
   const lazyExpression = cachedBy(
     function(node) {
       if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) {
@@ -4403,6 +4525,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
+    isNodeReferenceToEffectSchemaParserModuleApi,
+    isServiceMapTypeSourceFile,
+    isNodeReferenceToServiceMapModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -4418,6 +4543,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
+    serviceType,
     pipeableType,
     pipeCall,
     singleArgCall,
@@ -4425,6 +4551,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     promiseLike,
     extendsEffectTag,
     extendsEffectService,
+    extendsServiceMapService,
     extendsContextTag,
     extendsSchemaClass,
     extendsSchemaTaggedClass,
@@ -4902,6 +5029,7 @@ var deterministicKeys = createDiagnostic({
             typeParser.extendsEffectService(node),
             orElse2(() => typeParser.extendsContextTag(node)),
             orElse2(() => typeParser.extendsEffectTag(node)),
+            orElse2(() => typeParser.extendsServiceMapService(node)),
             map4(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
           ),
           orElse2(
@@ -6297,6 +6425,9 @@ More info and examples at https://effect.website/docs/requirements-management/la
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "GenericTag") {
         const nodeType = typeCheckerUtils.getTypeAtLocation(node);
         if (nodeType) typesToCheck.push([nodeType, node]);
+      } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "Service") {
+        const nodeType = typeCheckerUtils.getTypeAtLocation(node);
+        if (nodeType) typesToCheck.push([nodeType, node]);
       } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
@@ -6310,6 +6441,7 @@ More info and examples at https://effect.website/docs/requirements-management/la
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
+          orElse2(() => typeParser.serviceType(type, node)),
           flatMap2(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
@@ -7084,6 +7216,7 @@ var nonObjectEffectServiceType = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     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)
@@ -7368,6 +7501,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const typeChecker = yield* service(TypeCheckerApi);
   const typeParser = yield* service(TypeParser);
   const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  if (typeParser.supportedEffect() === "v4") return yield* fail("not applicable to Effect v4");
   if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
   const { Service, accessors: accessors2, className, kind } = yield* pipe(
     map4(typeParser.extendsEffectService(node), (_) => ({ kind: "effectService", ..._ })),
@@ -7610,16 +7744,16 @@ var pushHoistedVariableStatement = fn("StructuralSchemaGen.pushHoistedVariableSt
     );
   }
 );
-var createProcessingContext = (maxDepth = 200) => ({
+var createProcessingContext = (supportedEffect, maxDepth = 200) => ({
   depth: 0,
   maxDepth,
-  hoistName: void 0
+  hoistName: void 0,
+  supportedEffect
 });
 var processType = fn(
   "StructuralSchemaGen.processType"
 )(
-  function* (type, context) {
-    const processingContext = context || createProcessingContext();
+  function* (type, processingContext) {
     const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service(
       StructuralSchemaGenContext
     );
@@ -7754,7 +7888,7 @@ var processUnionType = fn(
     const allLiterals = types.every(
       (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
     );
-    if (allLiterals) {
+    if (allLiterals && context.supportedEffect !== "v4") {
       const literals = yield* all(
         ...types.map((t) => processType(t, context))
       );
@@ -7764,7 +7898,13 @@ var processUnionType = fn(
         }
         return expr;
       }).filter((arg) => arg !== void 0);
-      return [createApiCall("Literal", literalValues), false];
+      return [
+        createApiCall(
+          "Literal",
+          literalValues
+        ),
+        false
+      ];
     }
     const members = yield* all(
       ...types.map((t) => processType(t, context))
@@ -7772,7 +7912,13 @@ var processUnionType = fn(
     if (members.length === 1) {
       return [members[0], false];
     }
-    return [createApiCall("Union", members), false];
+    return [
+      createApiCall(
+        "Union",
+        context.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(members)] : members
+      ),
+      false
+    ];
   }
 );
 var processIntersectionType = fn(
@@ -7818,12 +7964,18 @@ var processTupleType = fn(
   "StructuralSchemaGen.processTupleType"
 )(
   function* (type, context) {
-    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const { createApiCall, ts, typeChecker } = yield* service(StructuralSchemaGenContext);
     const typeArgs = typeChecker.getTypeArguments(type);
     const elementSchemas = yield* all(
       ...typeArgs.map((t) => processType(t, context))
     );
-    return [createApiCall("Tuple", elementSchemas), false];
+    return [
+      createApiCall(
+        "Tuple",
+        context.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(elementSchemas)] : elementSchemas
+      ),
+      false
+    ];
   }
 );
 var processObjectType = fn(
@@ -7840,7 +7992,6 @@ var processObjectType = fn(
     } = yield* service(
       StructuralSchemaGenContext
     );
-    let hasRecords = false;
     const properties = typeChecker.getPropertiesOfType(type);
     const propertyAssignments = [];
     for (const property of properties) {
@@ -7880,20 +8031,28 @@ var processObjectType = fn(
     const args2 = [
       ts.factory.createObjectLiteralExpression(propertyAssignments, propertyAssignments.length > 0)
     ];
+    const records = [];
     for (const indexInfo of indexInfos) {
-      hasRecords = true;
       const keyType = indexInfo.keyType;
       const valueType = indexInfo.type;
       const keySchema = yield* processType(keyType, context);
       const valueSchema = yield* processType(valueType, context);
-      args2.push(
-        ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("key", keySchema),
-          ts.factory.createPropertyAssignment("value", valueSchema)
-        ])
-      );
+      records.push({ key: keySchema, value: valueSchema });
+    }
+    if (context.supportedEffect === "v4") {
+      if (records.length > 0) {
+        return [
+          createApiCall("StructWithRest", [
+            createApiCall("Struct", args2),
+            ts.factory.createArrayLiteralExpression(
+              records.map(({ key, value }) => createApiCall("Record", [key, value]))
+            )
+          ]),
+          propertyAssignments.length === 0
+        ];
+      }
     }
-    if (!hasRecords && context.hoistName) {
+    if (records.length === 0 && context.hoistName) {
       const ctx = yield* service(StructuralSchemaGenContext);
       yield* pushHoistedStatement(
         ctx,
@@ -7928,6 +8087,14 @@ var processObjectType = fn(
       );
       return [ctx.hoistedSchemas.get(type)(), true];
     }
+    for (const { key, value } of records) {
+      args2.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", key),
+          ts.factory.createPropertyAssignment("value", value)
+        ])
+      );
+    }
     return [createApiCall("Struct", args2), propertyAssignments.length === 0];
   }
 );
@@ -8013,7 +8180,7 @@ var process = fn("StructuralSchemaGen.process")(
       all(
         ...fromIterable(ctx.nameToType.entries()).map(
           ([name, type]) => pipe(
-            processType(type),
+            processType(type, createProcessingContext(typeParser.supportedEffect())),
             orElse2(
               (error) => succeed(ts.addSyntheticLeadingComment(
                 ts.factory.createIdentifier(""),
@@ -8595,6 +8762,7 @@ var runEffectInsideEffect = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
+    if (typeParser.supportedEffect() === "v4") return;
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map4(() => ({ node, methodName }))
@@ -8789,12 +8957,18 @@ var schemaStructWithTag = createDiagnostic({
 });
 
 // src/diagnostics/schemaSyncInEffect.ts
-var syncToEffectMethod = {
+var syncToEffectMethodV3 = {
   decodeSync: "decode",
   decodeUnknownSync: "decodeUnknown",
   encodeSync: "encode",
   encodeUnknownSync: "encodeUnknown"
 };
+var syncToEffectMethodV4 = {
+  decodeSync: "decodeEffect",
+  decodeUnknownSync: "decodeUnknownEffect",
+  encodeSync: "encodeEffect",
+  encodeUnknownSync: "encodeUnknownEffect"
+};
 var schemaSyncInEffect = createDiagnostic({
   name: "schemaSyncInEffect",
   code: 43,
@@ -8803,8 +8977,10 @@ var schemaSyncInEffect = createDiagnostic({
   apply: fn("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const syncToEffectMethod = typeParser.supportedEffect() === "v3" ? syncToEffectMethodV3 : syncToEffectMethodV4;
     const parseSchemaSyncMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectParseResultModuleApi(methodName)(node),
+      orElse2(() => typeParser.isNodeReferenceToEffectSchemaParserModuleApi(methodName)(node)),
       map4(() => ({ node, methodName }))
     );
     const nodeToVisit = [];
@@ -8834,7 +9010,7 @@ var schemaSyncInEffect = createDiagnostic({
       const effectMethodName = syncToEffectMethod[isSchemaSyncCall.value.methodName];
       report({
         location: node.expression,
-        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed ParseError in the error channel.`,
+        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed error channel.`,
         fixes: []
       });
     }
@@ -8850,6 +9026,7 @@ var schemaUnionOfLiterals = createDiagnostic({
   apply: fn("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);