Fix false positive regarding Schema.Class (#385)

Author: mattiamanzati

.changeset/salty-turkeys-vanish.md

@@ -0,0 +1,5 @@
+---
+"@effect/language-service": patch
+---
+
+Fix false positive regarding Schema.Class

examples/diagnostics/classSelfMismatch_schemaFalsePositive.ts

@@ -0,0 +1,7 @@
+import * as Persistable from "./utils"
+
+export class TTLRequest extends Persistable.Class<{
+  payload: { id: number }
+}>()("TTLRequest", {
+  primaryKey: (req) => `TTLRequest:${req.id}`
+}) {}

examples/diagnostics/utils.ts

@@ -0,0 +1,34 @@
+import type * as Types from "effect/Types"
+
+export const Class = <
+  Config extends {
+    payload: Record<string, unknown>
+    requires?: any
+    requestError?: any
+  } = { payload: {} }
+>() =>
+<const Tag extends string>(tag: Tag, _options: {
+  readonly primaryKey: (payload: Config["payload"]) => string
+}): new(
+  args: Types.EqualsWith<
+    Config["payload"],
+    {},
+    void,
+    {
+      readonly [
+        P in keyof Config["payload"] as P extends "_tag" ? never : P
+      ]: Config["payload"][P]
+    }
+  >
+) =>
+  & { readonly _tag: Tag }
+  & { readonly [K in keyof Config["payload"]]: Config["payload"][K] } =>
+{
+  function Persistable(this: any, props: any) {
+    this._tag = tag
+    if (props) {
+      Object.assign(this, props)
+    }
+  }
+  return Persistable as any
+}

src/core/TypeParser.ts

@@ -484,15 +484,30 @@ export function make(
     Nano.fn("TypeParser.importedSchemaModule")(function*(
       node: ts.Node
     ) {
+      // should be an expression
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an expression", undefined, node)
+      }
       const type = typeChecker.getTypeAtLocation(node)
       // if the type has a property "Class" that is a function
       const propertySymbol = typeChecker.getPropertyOfType(type, "Class")
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'Class' property", type, node)
       }
-      // should be an expression
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", type, node)
+      const sourceFile = tsUtils.getSourceFileOfNode(node)
+      if (!sourceFile) {
+        return yield* typeParserIssue("Node is not in a source file", undefined, node)
+      }
+      const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Schema"
+      )
+      if (!schemaIdentifier) {
+        return yield* typeParserIssue("Schema module not found", undefined, node)
+      }
+      if (ts.idText(node) !== schemaIdentifier) {
+        return yield* typeParserIssue("Node is not a schema module reference", undefined, node)
       }
       // return the node itself
       return node
@@ -512,8 +527,23 @@ export function make(
         return yield* typeParserIssue("Type has no 'Tag' property", type, node)
       }
       // should be an expression
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", type, node)
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an identifier", type, node)
+      }
+      const sourceFile = tsUtils.getSourceFileOfNode(node)
+      if (!sourceFile) {
+        return yield* typeParserIssue("Node is not in a source file", undefined, node)
+      }
+      const contextIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Context"
+      )
+      if (!contextIdentifier) {
+        return yield* typeParserIssue("Context module not found", undefined, node)
+      }
+      if (ts.idText(node) !== contextIdentifier) {
+        return yield* typeParserIssue("Node is not a context module reference", undefined, node)
       }
       // return the node itself
       return node
@@ -557,9 +587,24 @@ export function make(
         return yield* typeParserIssue("Type has no 'TaggedError' property", type, node)
       }
       // should be an expression
-      if (!ts.isExpression(node)) {
+      if (!ts.isIdentifier(node)) {
         return yield* typeParserIssue("Node is not an expression", type, node)
       }
+      const sourceFile = tsUtils.getSourceFileOfNode(node)
+      if (!sourceFile) {
+        return yield* typeParserIssue("Node is not in a source file", undefined, node)
+      }
+      const dataIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Data"
+      )
+      if (!dataIdentifier) {
+        return yield* typeParserIssue("Data module not found", undefined, node)
+      }
+      if (ts.idText(node) !== dataIdentifier) {
+        return yield* typeParserIssue("Node is not a data module reference", undefined, node)
+      }
       // return the node itself
       return node
     }),
@@ -1029,8 +1074,10 @@ export function make(
                   ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) &&
                   ts.idText(schemaIdentifier.name) === "Class"
                 ) {
+                  const expressionType = typeChecker.getTypeAtLocation(expression)
                   const parsedSchemaModule = yield* pipe(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    Nano.flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     Nano.option
                   )
                   if (Option.isSome(parsedSchemaModule)) {
@@ -1081,8 +1128,10 @@ export function make(
                   ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) &&
                   ts.idText(schemaIdentifier.name) === "TaggedClass"
                 ) {
+                  const expressionType = typeChecker.getTypeAtLocation(expression)
                   const parsedSchemaModule = yield* pipe(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    Nano.flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     Nano.option
                   )
                   if (Option.isSome(parsedSchemaModule)) {
@@ -1141,8 +1190,10 @@ export function make(
                   ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) &&
                   ts.idText(schemaIdentifier.name) === "TaggedError"
                 ) {
+                  const expressionType = typeChecker.getTypeAtLocation(expression)
                   const parsedSchemaModule = yield* pipe(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    Nano.flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     Nano.option
                   )
                   if (Option.isSome(parsedSchemaModule)) {
@@ -1306,8 +1357,10 @@ export function make(
                   ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) &&
                   ts.idText(schemaIdentifier.name) === "TaggedRequest"
                 ) {
+                  const expressionType = typeChecker.getTypeAtLocation(expression)
                   const parsedSchemaModule = yield* pipe(
-                    importedSchemaModule(schemaIdentifier.expression),
+                    effectSchemaType(expressionType, expression),
+                    Nano.flatMap(() => importedSchemaModule(schemaIdentifier.expression)),
                     Nano.option
                   )
                   if (Option.isSome(parsedSchemaModule)) {

src/diagnostics/classSelfMismatch.ts

@@ -29,6 +29,7 @@ export const classSelfMismatch = LSP.createDiagnostic({
         const result = yield* pipe(
           typeParser.extendsEffectService(node),
           Nano.orElse(() => typeParser.extendsContextTag(node)),
+          Nano.orElse(() => typeParser.extendsEffectTag(node)),
           Nano.orElse(() => typeParser.extendsSchemaClass(node)),
           Nano.orElse(() => typeParser.extendsSchemaTaggedClass(node)),
           Nano.orElse(() => typeParser.extendsSchemaTaggedError(node)),

test/__snapshots__/diagnostics/classSelfMismatch_schemaFalsePositive.ts.codefixes

@@ -0,0 +1 @@
+no codefixes

test/__snapshots__/diagnostics/classSelfMismatch_schemaFalsePositive.ts.output

@@ -0,0 +1 @@
+// no diagnostics