@effect/language-service 0.73.1 → 0.75.0

package/README.md

@@ -88,7 +88,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 
 ### Completions
 
-- Autocomplete 'Self' in `Effect.Service`, `Context.Tag`, `Schema.TaggedClass`, `Schema.TaggedRequest`, `Model.Class` and family
+- Autocomplete 'Self' in `Effect.Service`, `Context.Tag`, `Schema.TaggedClass`, `Schema.TaggedRequest`, `ServiceMap.Service`, `Model.Class` and family
 - Autocomplete `Effect.gen` with `function*(){}`
 - Autocomplete `Effect.fn` with the span name given by the exported member
 - Completions for DurationInput string millis/seconds/etc...

package/cli.js

@@ -30214,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.73.1",
+  version: "0.75.0",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -33603,6 +33603,28 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectParseResultModuleApi(${memberName})`,
     (node) => node
   );
+  const isEffectSchemaParserSourceFile = cachedBy(
+    fn2("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(
+    fn2("TypeParser.isNodeReferenceToEffectSchemaParserModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaParserSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaParserModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type2, atLocation) => map34(
     all9(
       varianceStructInvariantType(type2, atLocation, "_Identifier"),
@@ -33610,6 +33632,31 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     ),
     ([Identifier, Service]) => ({ Identifier, Service })
   );
+  const serviceVarianceStruct = (type2, atLocation) => map34(
+    all9(
+      varianceStructInvariantType(type2, atLocation, "_Identifier"),
+      varianceStructInvariantType(type2, atLocation, "_Service")
+    ),
+    ([Identifier, Service]) => ({ Identifier, Service })
+  );
+  const serviceType = cachedBy(
+    fn2("TypeParser.serviceType")(function* (type2, atLocation) {
+      yield* pipeableType(type2, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+      );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no tag variance struct", type2, atLocation);
+      }
+      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
+      return yield* firstSuccessOf2(propertiesSymbols.map((propertySymbol) => {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        return serviceVarianceStruct(propertyType, atLocation);
+      }));
+    }),
+    "TypeParser.serviceType",
+    (type2) => type2
+  );
   const contextTag = cachedBy(
     fn2("TypeParser.contextTag")(function* (type2, atLocation) {
       yield* pipeableType(type2, atLocation);
@@ -33691,14 +33738,22 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const scopeType = cachedBy(
     fn2("TypeParser.scopeType")(function* (type2, atLocation) {
-      yield* pipeableType(type2, atLocation);
-      const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
-      );
-      if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
-        return type2;
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type2, "~effect/Scope");
+        if (typeIdSymbol) {
+          return type2;
+        }
+        return yield* typeParserIssue("Type is not an effect", type2, atLocation);
+      } else {
+        yield* pipeableType(type2, atLocation);
+        const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
+          (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+        );
+        if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
+          return type2;
+        }
+        return yield* typeParserIssue("Type has no scope type id", type2, atLocation);
       }
-      return yield* typeParserIssue("Type has no scope type id", type2, atLocation);
     }),
     "TypeParser.scopeType",
     (type2) => type2
@@ -34180,6 +34235,55 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectService",
     (atLocation) => atLocation
   );
+  const extendsServiceMapService = cachedBy(
+    fn2("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),
+                  orUndefined2
+                );
+                if (isServiceMapService) {
+                  const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                  if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                  const type2 = typeChecker.getTypeOfSymbol(classSym);
+                  const parsedServiceType = yield* pipe(
+                    serviceType(type2, atLocation),
+                    orUndefined2
+                  );
+                  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(
     fn2("TypeParser.isEffectSqlModelTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -34272,6 +34376,24 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectLayerModuleApi(${memberName})`,
     (node) => node
   );
+  const isServiceMapTypeSourceFile = cachedBy(
+    fn2("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(
+    fn2("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)) {
@@ -34602,6 +34724,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
+    isNodeReferenceToEffectSchemaParserModuleApi,
+    isServiceMapTypeSourceFile,
+    isNodeReferenceToServiceMapModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -34617,6 +34742,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
+    serviceType,
     pipeableType,
     pipeCall,
     singleArgCall,
@@ -34624,6 +34750,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     promiseLike,
     extendsEffectTag,
     extendsEffectService,
+    extendsServiceMapService,
     extendsContextTag,
     extendsSchemaClass,
     extendsSchemaTaggedClass,
@@ -34844,6 +34971,7 @@ var parse5 = fn2("writeTagClassAccessors.parse")(function* (node) {
   const typeChecker = yield* service2(TypeCheckerApi);
   const typeParser = yield* service2(TypeParser);
   const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  if (typeParser.supportedEffect() === "v4") return yield* fail18("not applicable to Effect v4");
   if (!ts.isClassDeclaration(node)) return yield* fail18("not a class declaration");
   const { Service, accessors: accessors2, className, kind } = yield* pipe(
     map34(typeParser.extendsEffectService(node), (_) => ({ kind: "effectService", ..._ })),
@@ -35086,16 +35214,16 @@ var pushHoistedVariableStatement = fn2("StructuralSchemaGen.pushHoistedVariableS
     );
   }
 );
-var createProcessingContext = (maxDepth = 200) => ({
+var createProcessingContext = (supportedEffect, maxDepth = 200) => ({
   depth: 0,
   maxDepth,
-  hoistName: void 0
+  hoistName: void 0,
+  supportedEffect
 });
 var processType = fn2(
   "StructuralSchemaGen.processType"
 )(
-  function* (type2, context7) {
-    const processingContext = context7 || createProcessingContext();
+  function* (type2, processingContext) {
     const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service2(
       StructuralSchemaGenContext
     );
@@ -35230,7 +35358,7 @@ var processUnionType = fn2(
     const allLiterals = types.every(
       (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
     );
-    if (allLiterals) {
+    if (allLiterals && context7.supportedEffect !== "v4") {
       const literals = yield* all9(
         ...types.map((t) => processType(t, context7))
       );
@@ -35240,7 +35368,13 @@ var processUnionType = fn2(
         }
         return expr;
       }).filter((arg) => arg !== void 0);
-      return [createApiCall("Literal", literalValues), false];
+      return [
+        createApiCall(
+          "Literal",
+          literalValues
+        ),
+        false
+      ];
     }
     const members = yield* all9(
       ...types.map((t) => processType(t, context7))
@@ -35248,7 +35382,13 @@ var processUnionType = fn2(
     if (members.length === 1) {
       return [members[0], false];
     }
-    return [createApiCall("Union", members), false];
+    return [
+      createApiCall(
+        "Union",
+        context7.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(members)] : members
+      ),
+      false
+    ];
   }
 );
 var processIntersectionType = fn2(
@@ -35294,12 +35434,18 @@ var processTupleType = fn2(
   "StructuralSchemaGen.processTupleType"
 )(
   function* (type2, context7) {
-    const { createApiCall, typeChecker } = yield* service2(StructuralSchemaGenContext);
+    const { createApiCall, ts, typeChecker } = yield* service2(StructuralSchemaGenContext);
     const typeArgs = typeChecker.getTypeArguments(type2);
     const elementSchemas = yield* all9(
       ...typeArgs.map((t) => processType(t, context7))
     );
-    return [createApiCall("Tuple", elementSchemas), false];
+    return [
+      createApiCall(
+        "Tuple",
+        context7.supportedEffect === "v4" ? [ts.factory.createArrayLiteralExpression(elementSchemas)] : elementSchemas
+      ),
+      false
+    ];
   }
 );
 var processObjectType = fn2(
@@ -35316,7 +35462,6 @@ var processObjectType = fn2(
     } = yield* service2(
       StructuralSchemaGenContext
     );
-    let hasRecords = false;
     const properties = typeChecker.getPropertiesOfType(type2);
     const propertyAssignments = [];
     for (const property of properties) {
@@ -35356,20 +35501,28 @@ var processObjectType = fn2(
     const args3 = [
       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, context7);
       const valueSchema = yield* processType(valueType, context7);
-      args3.push(
-        ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("key", keySchema),
-          ts.factory.createPropertyAssignment("value", valueSchema)
-        ])
-      );
+      records.push({ key: keySchema, value: valueSchema });
+    }
+    if (context7.supportedEffect === "v4") {
+      if (records.length > 0) {
+        return [
+          createApiCall("StructWithRest", [
+            createApiCall("Struct", args3),
+            ts.factory.createArrayLiteralExpression(
+              records.map(({ key, value: value5 }) => createApiCall("Record", [key, value5]))
+            )
+          ]),
+          propertyAssignments.length === 0
+        ];
+      }
     }
-    if (!hasRecords && context7.hoistName) {
+    if (records.length === 0 && context7.hoistName) {
       const ctx = yield* service2(StructuralSchemaGenContext);
       yield* pushHoistedStatement(
         ctx,
@@ -35404,6 +35557,14 @@ var processObjectType = fn2(
       );
       return [ctx.hoistedSchemas.get(type2)(), true];
     }
+    for (const { key, value: value5 } of records) {
+      args3.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", key),
+          ts.factory.createPropertyAssignment("value", value5)
+        ])
+      );
+    }
     return [createApiCall("Struct", args3), propertyAssignments.length === 0];
   }
 );
@@ -35489,7 +35650,7 @@ var process2 = fn2("StructuralSchemaGen.process")(
       all9(
         ...fromIterable(ctx.nameToType.entries()).map(
           ([name, type2]) => pipe(
-            processType(type2),
+            processType(type2, createProcessingContext(typeParser.supportedEffect())),
             orElse15(
               (error4) => succeed17(ts.addSyntheticLeadingComment(
                 ts.factory.createIdentifier(""),
@@ -36289,6 +36450,7 @@ var deterministicKeys = createDiagnostic({
             typeParser.extendsEffectService(node),
             orElse15(() => typeParser.extendsContextTag(node)),
             orElse15(() => typeParser.extendsEffectTag(node)),
+            orElse15(() => typeParser.extendsServiceMapService(node)),
             map34(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
           ),
           orElse15(
@@ -37684,6 +37846,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) {
@@ -37697,6 +37862,7 @@ More info and examples at https://effect.website/docs/requirements-management/la
       for (const [type2, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type2, node),
+          orElse15(() => typeParser.serviceType(type2, node)),
           flatMap18(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
@@ -38471,6 +38637,7 @@ var nonObjectEffectServiceType = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     function isPrimitiveType(type2) {
       return typeCheckerUtils.unrollUnionMembers(type2).some(
         (type3) => !!(type3.flags & ts.TypeFlags.String || type3.flags & ts.TypeFlags.Number || type3.flags & ts.TypeFlags.Boolean || type3.flags & ts.TypeFlags.StringLiteral || type3.flags & ts.TypeFlags.NumberLiteral || type3.flags & ts.TypeFlags.BooleanLiteral || type3.flags & ts.TypeFlags.Undefined || type3.flags & ts.TypeFlags.Null)
@@ -38949,6 +39116,7 @@ var runEffectInsideEffect = createDiagnostic({
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(TypeScriptUtils);
+    if (typeParser.supportedEffect() === "v4") return;
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map34(() => ({ node, methodName }))
@@ -39143,12 +39311,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,
@@ -39157,8 +39331,10 @@ var schemaSyncInEffect = createDiagnostic({
   apply: fn2("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
+    const syncToEffectMethod = typeParser.supportedEffect() === "v3" ? syncToEffectMethodV3 : syncToEffectMethodV4;
     const parseSchemaSyncMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectParseResultModuleApi(methodName)(node),
+      orElse15(() => typeParser.isNodeReferenceToEffectSchemaParserModuleApi(methodName)(node)),
       map34(() => ({ node, methodName }))
     );
     const nodeToVisit = [];
@@ -39188,7 +39364,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: []
       });
     }
@@ -39204,6 +39380,7 @@ var schemaUnionOfLiterals = createDiagnostic({
   apply: fn2("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
+    if (typeParser.supportedEffect() === "v4") return;
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);