@effect/language-service 0.40.1 → 0.41.1

package/index.js

@@ -1064,6 +1064,68 @@ var all = fn("all")(
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
+function getPackageJsonInfoCache(program) {
+  try {
+    if (hasProperty(program, "getModuleResolutionCache") && isFunction2(program.getModuleResolutionCache)) {
+      const moduleResolutionCache = program.getModuleResolutionCache();
+      if (hasProperty(moduleResolutionCache, "getPackageJsonInfoCache") && isFunction2(moduleResolutionCache.getPackageJsonInfoCache)) {
+        return moduleResolutionCache.getPackageJsonInfoCache();
+      }
+    }
+  } catch (_) {
+    return void 0;
+  }
+  return void 0;
+}
+function getDirectoryPath(ts, path) {
+  try {
+    if (hasProperty(ts, "getDirectoryPath") && isFunction2(ts.getDirectoryPath)) {
+      return ts.getDirectoryPath(path);
+    }
+    return path;
+  } catch (_) {
+    return path;
+  }
+}
+function makeGetModuleSpecifier(ts) {
+  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+  const _internal = ts.moduleSpecifiers.getModuleSpecifier;
+  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
+    return _internal(
+      compilerOptions,
+      importingSourceFile,
+      importingSourceFileName,
+      toFileName,
+      host,
+      options
+    );
+  };
+}
+function makeGetTemporaryModuleResolutionState(ts) {
+  if (hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState)) {
+    const _internal = ts.getTemporaryModuleResolutionState;
+    return (cache, program, compilerOptions) => _internal(cache, program, compilerOptions);
+  }
+  return void 0;
+}
+function makeGetPackageScopeForPath(ts) {
+  if (hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
+    const _internal = ts.getPackageScopeForPath;
+    return (path, state) => _internal(path, state);
+  }
+}
+function makeResolvePackageNameToPackageJson(ts) {
+  if (hasProperty(ts, "resolvePackageNameToPackageJson") && isFunction2(ts.resolvePackageNameToPackageJson)) {
+    const _internal = ts.resolvePackageNameToPackageJson;
+    return (packageName, fromFileName, compilerOptions, host) => _internal(packageName, fromFileName, compilerOptions, host);
+  }
+}
+function makeGetEntrypointsFromPackageJsonInfo(ts) {
+  if (hasProperty(ts, "getEntrypointsFromPackageJsonInfo") && isFunction2(ts.getEntrypointsFromPackageJsonInfo)) {
+    const _internal = ts.getEntrypointsFromPackageJsonInfo;
+    return (packageJsonInfo, compilerOptions, host) => _internal(packageJsonInfo, compilerOptions, host);
+  }
+}
 
 // node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
@@ -1185,6 +1247,8 @@ var nanoLayer = (fa) => pipe(
   flatMap((ts) => pipe(fa, provideService(TypeScriptUtils, makeTypeScriptUtils(ts))))
 );
 function makeTypeScriptUtils(ts) {
+  const getTemporaryModuleResolutionState = makeGetTemporaryModuleResolutionState(ts);
+  const getPackageScopeForPath = makeGetPackageScopeForPath(ts);
   function parsePackageContentNameAndVersionFromScope(v) {
     if (!isObject(v)) return;
     if (!hasProperty(v, "packageJsonScope")) return;
@@ -1219,20 +1283,26 @@ function makeTypeScriptUtils(ts) {
       exportsKeys
     };
   }
-  function resolveModulePattern(program, sourceFile, pattern) {
-    if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
+  function resolveModuleWithPackageInfoFromSourceFile(program, sourceFile) {
     let packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
-    if (!packageJsonScope && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath) && hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState) && hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
-      const temporaryModuleResolutionState = ts.getTemporaryModuleResolutionState(
-        void 0,
+    if (!packageJsonScope && getPackageScopeForPath && getTemporaryModuleResolutionState) {
+      const packageJsonInfoCache = getPackageJsonInfoCache(program);
+      const temporaryModuleResolutionState = getTemporaryModuleResolutionState(
+        packageJsonInfoCache,
         program,
         program.getCompilerOptions()
       );
+      const directoryPath = getDirectoryPath(ts, sourceFile.fileName);
       packageJsonScope = parsePackageContentNameAndVersionFromScope({
         ...sourceFile,
-        packageJsonScope: ts.getPackageScopeForPath(sourceFile.fileName, temporaryModuleResolutionState)
+        packageJsonScope: getPackageScopeForPath(directoryPath, temporaryModuleResolutionState)
       });
     }
+    return packageJsonScope;
+  }
+  function resolveModulePattern(program, sourceFile, pattern) {
+    if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
+    const packageJsonScope = resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
       if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -1250,20 +1320,6 @@ function makeTypeScriptUtils(ts) {
       )
     );
   }
-  function makeGetModuleSpecifier() {
-    if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
-    const _internal = ts.moduleSpecifiers.getModuleSpecifier;
-    return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
-      return _internal(
-        compilerOptions,
-        importingSourceFile,
-        importingSourceFileName,
-        toFileName,
-        host,
-        options
-      );
-    };
-  }
   function findNodeWithLeadingCommentAtPosition(sourceFile, position) {
     const sourceText = sourceFile.text;
     let result;
@@ -1652,6 +1708,7 @@ function makeTypeScriptUtils(ts) {
     findNodeAtPositionIncludingTrivia,
     parsePackageContentNameAndVersionFromScope,
     resolveModulePattern,
+    resolveModuleWithPackageInfoFromSourceFile,
     findNodeWithLeadingCommentAtPosition,
     getCommentAtPosition,
     getAncestorNodesInRange,
@@ -1666,7 +1723,6 @@ function makeTypeScriptUtils(ts) {
     parseDataForExtendsClassCompletion,
     createEffectGenCallExpressionWithBlock,
     createReturnYieldStarStatement,
-    makeGetModuleSpecifier,
     parseAccessedExpressionForCompletion,
     getSourceFileOfNode
   };
@@ -4143,14 +4199,14 @@ var importFromBarrel = createDiagnostic({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
+    const getModuleSpecifier = makeGetModuleSpecifier(ts);
+    const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
     const packageNamesToCheck = flatten(
       languageServicePluginOptions.namespaceImportPackages.map(
         (packageName) => tsUtils.resolveModulePattern(program, sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
-      const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
-      const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
       if (!(getModuleSpecifier && resolveExternalModuleName)) return;
       const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
       if (!importDeclaration) return;
@@ -4585,7 +4641,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);
@@ -4907,6 +4963,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/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
@@ -5527,7 +5673,8 @@ var diagnostics = [
   multipleEffectProvide,
   outdatedEffectCodegen,
   overriddenSchemaConstructor,
-  unsupportedServiceAccessors
+  unsupportedServiceAccessors,
+  nonObjectEffectServiceType
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -5629,6 +5776,12 @@ var effectSelfInClasses = createCompletion({
       insertText: `${effectIdentifier}.Service<${name}>()("${name}", {${"${0}"}}){}`,
       replacementSpan,
       isSnippet: true
+    }, {
+      name: `Tag("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectIdentifier}.Tag("${name}")<${name}, {${"${0}"}}>(){}`,
+      replacementSpan,
+      isSnippet: true
     }];
   })
 });
@@ -5799,7 +5952,9 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const program = yield* service(TypeScriptProgram);
   const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
   const host = program;
-  const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
+  const getModuleSpecifier = makeGetModuleSpecifier(ts);
+  const resolvePackageNameToPackageJson = makeResolvePackageNameToPackageJson(ts);
+  const getEntrypointsFromPackageJsonInfo = makeGetEntrypointsFromPackageJsonInfo(ts);
   function collectSourceFileReexports(sourceFile) {
     const namespaceExports = [];
     const namedExports = [];
@@ -5837,14 +5992,15 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   }
   function getPackageInfo(fromFileName, packageName) {
     try {
-      const packageJsonInfo = ts.resolvePackageNameToPackageJson(
+      if (!resolvePackageNameToPackageJson || !getEntrypointsFromPackageJsonInfo) return;
+      const packageJsonInfo = resolvePackageNameToPackageJson(
         packageName,
         fromFileName,
         program.getCompilerOptions(),
         host
       );
       if (!packageJsonInfo) return;
-      const _entrypoints = ts.getEntrypointsFromPackageJsonInfo(
+      const _entrypoints = getEntrypointsFromPackageJsonInfo(
         packageJsonInfo,
         program.getCompilerOptions(),
         host