@effect/language-service 0.33.1 → 0.34.0

package/package.json

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

package/transform.js

@@ -4308,6 +4308,68 @@ var outdatedEffectCodegen = createDiagnostic({
   })
 });
 
+// src/diagnostics/overriddenSchemaConstructor.ts
+var overriddenSchemaConstructor = createDiagnostic({
+  name: "overriddenSchemaConstructor",
+  code: 30,
+  severity: "error",
+  apply: fn("overriddenSchemaConstructor.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    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.heritageClauses) {
+        let extendsSchema = false;
+        for (const heritageClause of node.heritageClauses) {
+          if (heritageClause.token === ts.SyntaxKind.ExtendsKeyword) {
+            for (const type of heritageClause.types) {
+              const typeAtLocation = typeChecker.getTypeAtLocation(type.expression);
+              const isSchema = yield* pipe(
+                typeParser.effectSchemaType(typeAtLocation, type.expression),
+                map3(() => true),
+                orElse2(() => succeed(false))
+              );
+              if (isSchema) {
+                extendsSchema = true;
+                break;
+              }
+            }
+          }
+          if (extendsSchema) break;
+        }
+        if (extendsSchema) {
+          const members = node.members;
+          for (const member of members) {
+            if (ts.isConstructorDeclaration(member)) {
+              report({
+                location: member,
+                messageText: "Classes extending Schema must not override the constructor",
+                fixes: [{
+                  fixName: "overriddenSchemaConstructor_fix",
+                  description: "Remove the constructor override",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.delete(sourceFile, member);
+                  })
+                }]
+              });
+              break;
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -4826,36 +4888,48 @@ var diagnostics = [
   strictBooleanExpressions,
   multipleEffectProvide,
   outdatedEffectCodegen,
+  overriddenSchemaConstructor,
   unsupportedServiceAccessors
 ];
 
 // src/transform.ts
+var programsChecked = /* @__PURE__ */ new WeakMap();
 function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstance }) {
-  return (_) => {
-    return (sourceFile) => {
-      pipe(
-        getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
-        nanoLayer2,
-        nanoLayer,
-        provideService(TypeCheckerApi, program.getTypeChecker()),
-        provideService(TypeScriptProgram, program),
-        provideService(TypeScriptApi, tsInstance),
-        provideService(
-          LanguageServicePluginOptions,
-          parse(pluginConfig)
-        ),
-        run,
-        map((_2) => _2.diagnostics),
-        map(
-          filter(
-            (_2) => _2.category === tsInstance.DiagnosticCategory.Error || _2.category === tsInstance.DiagnosticCategory.Warning
-          )
-        ),
-        getOrElse(() => []),
-        map2(addDiagnostic)
-      );
-      return sourceFile;
-    };
+  function runDiagnostics(program2, sourceFile) {
+    const checkedFiles = programsChecked.get(program2) ?? /* @__PURE__ */ new Set();
+    programsChecked.set(program2, checkedFiles);
+    if (checkedFiles.has(sourceFile.fileName)) return;
+    checkedFiles.add(sourceFile.fileName);
+    pipe(
+      getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
+      nanoLayer2,
+      nanoLayer,
+      provideService(TypeCheckerApi, program2.getTypeChecker()),
+      provideService(TypeScriptProgram, program2),
+      provideService(TypeScriptApi, tsInstance),
+      provideService(
+        LanguageServicePluginOptions,
+        parse(pluginConfig)
+      ),
+      run,
+      map((_) => _.diagnostics),
+      map(
+        filter(
+          (_) => _.category === tsInstance.DiagnosticCategory.Error || _.category === tsInstance.DiagnosticCategory.Warning
+        )
+      ),
+      getOrElse(() => []),
+      map2(addDiagnostic)
+    );
+  }
+  const rootFileNames = program.getRootFileNames();
+  const sourceFiles = program.getSourceFiles().filter((_) => rootFileNames.indexOf(_.fileName) > -1);
+  for (const sourceFile of sourceFiles) {
+    runDiagnostics(program, sourceFile);
+  }
+  return (_) => (sourceFile) => {
+    runDiagnostics(program, sourceFile);
+    return sourceFile;
   };
 }
 //# sourceMappingURL=transform.js.map