@effect/language-service 0.47.1 → 0.47.3

package/index.js

@@ -1861,6 +1861,10 @@ var makeKeyBuilder = fn("KeyBuilder")(
 );
 var keyBuilderCache = /* @__PURE__ */ new Map();
 var getOrMakeKeyBuilder = fn("getOrMakeKeyBuilder")(function* (sourceFile) {
+  while (keyBuilderCache.size > 5) {
+    const oldest = keyBuilderCache.keys().next().value;
+    if (oldest) keyBuilderCache.delete(oldest);
+  }
   const keyBuilder = keyBuilderCache.get(sourceFile.fileName) || (yield* makeKeyBuilder(sourceFile));
   keyBuilderCache.set(sourceFile.fileName, keyBuilder);
   return keyBuilder;
@@ -2247,10 +2251,10 @@ var TypeCheckerUtils = Tag("TypeCheckerUtils");
 var nanoLayer2 = (fa) => pipe(
   service(TypeScriptApi),
   flatMap2(
-    (ts) => flatMap2(service(TypeCheckerApi), (typeChecker) => pipe(fa, provideService(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker))))
+    (ts) => flatMap2(service(TypeCheckerApi), (typeChecker) => flatMap2(service(TypeScriptUtils), (typeScriptUtils) => pipe(fa, provideService(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker, typeScriptUtils)))))
   )
 );
-function makeTypeCheckerUtils(ts, typeChecker) {
+function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function isUnion(type) {
     return !!(type.flags & ts.TypeFlags.Union);
   }
@@ -2490,6 +2494,74 @@ function makeTypeCheckerUtils(ts, typeChecker) {
     expectedAndRealTypeCache.set(sourceFile, result);
     return result;
   };
+  function typeToSimplifiedTypeNode(type, enclosingNode, flags) {
+    const fallbackStandard = () => {
+      const typeNode = typeChecker.typeToTypeNode(type, enclosingNode, flags);
+      if (!typeNode) return void 0;
+      return tsUtils.simplifyTypeNode(typeNode);
+    };
+    const members = unrollUnionMembers(type);
+    if (members.length > 1) {
+      const typeNodes = [];
+      members.sort(deterministicTypeOrder);
+      for (const member of members) {
+        const memberNode = typeToSimplifiedTypeNode(member, enclosingNode, flags);
+        if (!memberNode) return fallbackStandard();
+        typeNodes.push(memberNode);
+      }
+      return tsUtils.simplifyTypeNode(ts.factory.createUnionTypeNode(typeNodes));
+    }
+    if (type.flags & ts.TypeFlags.Intersection) {
+      const intersectionType = type;
+      const typeNodes = [];
+      for (const member of intersectionType.types) {
+        const memberNode = typeToSimplifiedTypeNode(member, enclosingNode, flags);
+        if (!memberNode) return fallbackStandard();
+        typeNodes.push(memberNode);
+      }
+      return tsUtils.simplifyTypeNode(ts.factory.createIntersectionTypeNode(typeNodes));
+    }
+    if (type.flags & ts.TypeFlags.Object && type.objectFlags & ts.ObjectFlags.Reference) {
+      const typeReference = type;
+      const standard2 = fallbackStandard();
+      if (!standard2) return void 0;
+      if (!ts.isTypeReferenceNode(standard2)) return standard2;
+      if (typeReference.target.typeParameters?.length !== typeReference.typeArguments?.length) return standard2;
+      if (standard2.typeArguments?.length !== typeReference.typeArguments?.length) return standard2;
+      const typeParametersCount = (typeReference.target.typeParameters || []).length;
+      for (let i = typeParametersCount - 1; i >= 0; i--) {
+        const typeParameter = typeReference.target.typeParameters[i];
+        const typeArgument = typeReference.typeArguments[i];
+        const defaultType = typeChecker.getDefaultFromTypeParameter(typeParameter);
+        if (defaultType !== typeArgument || i === 0) {
+          return tsUtils.simplifyTypeNode(ts.factory.updateTypeReferenceNode(
+            standard2,
+            standard2.typeName,
+            ts.factory.createNodeArray((standard2.typeArguments || []).slice(0, Math.min(typeParametersCount, i + 1)))
+          ));
+        }
+      }
+      return standard2;
+    }
+    if (type.flags & ts.TypeFlags.Object) {
+      const standard2 = fallbackStandard();
+      if (!standard2) return void 0;
+      if (!ts.isFunctionTypeNode(standard2)) return standard2;
+      const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
+      if (signatures.length !== 1) return standard2;
+      const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
+      if (!returnType) return standard2;
+      const returnTypeNode = typeToSimplifiedTypeNode(returnType, enclosingNode, flags);
+      if (!returnTypeNode) return standard2;
+      return tsUtils.simplifyTypeNode(ts.factory.updateFunctionTypeNode(
+        standard2,
+        standard2.typeParameters,
+        standard2.parameters,
+        returnTypeNode
+      ));
+    }
+    return fallbackStandard();
+  }
   return {
     isUnion,
     getTypeParameterAtPosition,
@@ -2498,7 +2570,8 @@ function makeTypeCheckerUtils(ts, typeChecker) {
     appendToUniqueTypesMap,
     deterministicTypeOrder,
     getInferredReturnType,
-    expectedAndRealType
+    expectedAndRealType,
+    typeToSimplifiedTypeNode
   };
 }
 
@@ -6538,6 +6611,10 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
 });
 var importProvidersCache = /* @__PURE__ */ new Map();
 var getOrMakeAutoImportProvider = fn("getOrMakeAutoImportProvider")(function* (sourceFile) {
+  while (importProvidersCache.size > 5) {
+    const oldest = importProvidersCache.keys().next().value;
+    if (oldest) importProvidersCache.delete(oldest);
+  }
   const autoImportProvider = importProvidersCache.get(sourceFile.fileName) || (yield* makeAutoImportProvider(sourceFile));
   importProvidersCache.set(sourceFile.fileName, autoImportProvider);
   return autoImportProvider;
@@ -13041,7 +13118,6 @@ var toggleReturnTypeAnnotation = createRefactor({
   apply: fn("toggleReturnTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
-    const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     function addReturnTypeAnnotation(sourceFile2, changeTracker, declaration, typeNode) {
       const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile2);
@@ -13092,7 +13168,7 @@ var toggleReturnTypeAnnotation = createRefactor({
     }
     const returnType = typeCheckerUtils.getInferredReturnType(node);
     if (!returnType) return yield* fail(new RefactorNotApplicableError());
-    const returnTypeNode = typeChecker.typeToTypeNode(
+    const returnTypeNode = typeCheckerUtils.typeToSimplifiedTypeNode(
       returnType,
       node,
       ts.NodeBuilderFlags.NoTruncation
@@ -13103,9 +13179,7 @@ var toggleReturnTypeAnnotation = createRefactor({
       description: "Toggle return type annotation",
       apply: pipe(
         service(ChangeTracker),
-        map5(
-          (changeTracker) => addReturnTypeAnnotation(sourceFile, changeTracker, node, tsUtils.simplifyTypeNode(returnTypeNode))
-        )
+        map5((changeTracker) => addReturnTypeAnnotation(sourceFile, changeTracker, node, returnTypeNode))
       )
     };
   })
@@ -13119,6 +13193,7 @@ var toggleTypeAnnotation = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const maybeNode = pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter((node2) => ts.isVariableDeclaration(node2) || ts.isPropertyDeclaration(node2)),
@@ -13140,13 +13215,13 @@ var toggleTypeAnnotation = createRefactor({
           }
           const initializer = node.initializer;
           const initializerType = typeChecker.getTypeAtLocation(initializer);
-          const initializerTypeNode = fromNullable(typeChecker.typeToTypeNode(
+          const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
             initializerType,
             node,
             ts.NodeBuilderFlags.NoTruncation
           )).pipe(
             orElse(
-              () => fromNullable(typeChecker.typeToTypeNode(
+              () => fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
                 initializerType,
                 void 0,
                 ts.NodeBuilderFlags.NoTruncation
@@ -13158,7 +13233,7 @@ var toggleTypeAnnotation = createRefactor({
             changeTracker.insertNodeAt(
               sourceFile,
               node.name.end,
-              tsUtils.simplifyTypeNode(initializerTypeNode),
+              initializerTypeNode,
               {
                 prefix: ": "
               }
@@ -13878,6 +13953,10 @@ var init = (modules) => {
     const effectCodeFixesForFile = /* @__PURE__ */ new Map();
     const runDiagnosticsAndCacheCodeFixes = (fileName) => {
       const program = languageService.getProgram();
+      while (effectCodeFixesForFile.size > 5) {
+        const oldest = effectCodeFixesForFile.keys().next().value;
+        if (oldest) effectCodeFixesForFile.delete(oldest);
+      }
       if (languageServicePluginOptions.diagnostics && program) {
         effectCodeFixesForFile.delete(fileName);
         const sourceFile = program.getSourceFile(fileName);