Add Model.Class support for completions and diagnostics in Effect v4 (#659)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mattiamanzati

.changeset/model-class-support.md

@@ -0,0 +1,16 @@
+---
+"@effect/language-service": patch
+---
+
+Add support for `Model.Class` from `effect/unstable/schema` in completions and diagnostics.
+
+The `classSelfMismatch` diagnostic now detects mismatched Self type parameters in `Model.Class` declarations, and the autocomplete for Self type in classes now suggests `Model.Class` when typing after `Model.`.
+
+```ts
+import { Model } from "effect/unstable/schema"
+
+// autocomplete triggers after `Model.`
+export class MyDataModel extends Model.Class<MyDataModel>("MyDataModel")({
+  id: Schema.String
+}) {}
+```

packages/harness-effect-v4/__snapshots__/completions.test.ts.snap

@@ -248,6 +248,22 @@ exports[`Completion effectSchemaSelfInClasses > effectSchemaSelfInClasses_dotTok
 ]
 `;
 
+exports[`Completion effectSchemaSelfInClasses > effectSchemaSelfInClasses_model.ts at 4:40 1`] = `
+[
+  {
+    "insertText": "Model.Class<MyDataModel>("MyDataModel")({\${0}}){}",
+    "isSnippet": true,
+    "kind": "const",
+    "name": "Class<MyDataModel>",
+    "replacementSpan": {
+      "length": 6,
+      "start": 156,
+    },
+    "sortText": "11",
+  },
+]
+`;
+
 exports[`Completion effectSchemaSelfInClasses > effectSchemaSelfInClasses_tagg.ts at 4:25 1`] = `
 [
   {

packages/harness-effect-v4/__snapshots__/diagnostics/classSelfMismatch_sqlClass.ts.classSelfMismatch_fix.from412to427.output

@@ -0,0 +1,13 @@
+// code fix classSelfMismatch_fix  output for range 412 - 427
+import { Model } from "effect/unstable/schema"
+import {Schema} from "effect"
+
+// valid usage
+export class ValidModelClass extends Model.Class<ValidModelClass>("ValidModelClass")({
+  id: Schema.String
+}) {}
+
+// invalid usage: Model.Class<ValidModelClass> should be Model.Class<InvalidModelClass> because the Self type parameter is not the same as the class name
+export class InvalidModelClass extends Model.Class<InvalidModelClass>("InvalidModelClass")({
+  id2: Schema.String
+}) {}

packages/harness-effect-v4/__snapshots__/diagnostics/classSelfMismatch_sqlClass.ts.codefixes

@@ -1 +1,3 @@
-no codefixes
+classSelfMismatch_fix from 412 to 427
+classSelfMismatch_skipNextLine from 412 to 427
+classSelfMismatch_skipFile from 412 to 427

packages/harness-effect-v4/__snapshots__/diagnostics/classSelfMismatch_sqlClass.ts.output

@@ -1 +1,2 @@
-// no diagnostics
+ValidModelClass
+10:51 - 10:66 | 1 | Self type parameter should be 'InvalidModelClass'    effect(classSelfMismatch)

packages/harness-effect-v4/examples/completions/effectSchemaSelfInClasses_model.ts

@@ -0,0 +1,4 @@
+// 4:40
+import { Model } from "effect/unstable/schema"
+
+export class MyDataModel extends Model.

packages/language-service/src/completions/effectSchemaSelfInClasses.ts

@@ -155,6 +155,39 @@ export const effectSchemaSelfInClasses = LSP.createCompletion({
       }
     }
 
+    // Check for Model.Class (v4 only - Model moved to effect/unstable/schema)
+    if (typeParser.supportedEffect() === "v4") {
+      const modelIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable/schema",
+        "Model"
+      ) || tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable",
+        "Model"
+      ) || "Model"
+
+      const isModelFullyQualified = modelIdentifier === ts.idText(accessedObject)
+
+      const hasModelClassCompletion = isModelFullyQualified || Option.isSome(
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectSchemaModelModuleApi("Class")(accessedObject),
+          Nano.option
+        )
+      )
+      if (hasModelClassCompletion) {
+        completions.push({
+          name: `Class<${name}>`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: isModelFullyQualified
+            ? `${modelIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}`
+            : `Class<${name}>("${name}")({${"${0}"}}){}`,
+          replacementSpan,
+          isSnippet: true
+        })
+      }
+    }
+
     return completions
   })
 })

packages/language-service/src/core/TypeParser.ts

@@ -100,6 +100,9 @@ export interface TypeParser {
   isNodeReferenceToEffectSqlModelModuleApi: (
     memberName: string
   ) => (node: ts.Node) => Nano.Nano<ts.SourceFile, TypeParserIssue, never>
+  isNodeReferenceToEffectSchemaModelModuleApi: (
+    memberName: string
+  ) => (node: ts.Node) => Nano.Nano<ts.SourceFile, TypeParserIssue, never>
   isNodeReferenceToEffectLayerModuleApi: (
     memberName: string
   ) => (node: ts.Node) => Nano.Nano<ts.SourceFile, TypeParserIssue, never>
@@ -334,6 +337,14 @@ export interface TypeParser {
     TypeParserIssue,
     never
   >
+  extendsEffectSchemaModelClass: (atLocation: ts.ClassDeclaration) => Nano.Nano<
+    {
+      className: ts.Identifier
+      selfTypeNode: ts.TypeNode
+    },
+    TypeParserIssue,
+    never
+  >
   lazyExpression: (node: ts.Node) => Nano.Nano<
     ParsedLazyExpression,
     TypeParserIssue,
@@ -2451,6 +2462,87 @@ export function make(
     (atLocation) => atLocation
   )
 
+  const isEffectSchemaModelTypeSourceFile = Nano.cachedBy(
+    Nano.fn("TypeParser.isEffectSchemaModelTypeSourceFile")(function*(
+      sourceFile: ts.SourceFile
+    ) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile)
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", undefined, sourceFile)
+      // check for Class
+      const classSymbol = typeChecker.tryGetMemberInModuleExports("Class", moduleSymbol)
+      if (!classSymbol) return yield* typeParserIssue("Model's Class type not found", undefined, sourceFile)
+      // check for Generated (unique to Model, not present in Schema)
+      const generatedSymbol = typeChecker.tryGetMemberInModuleExports("Generated", moduleSymbol)
+      if (!generatedSymbol) {
+        return yield* typeParserIssue("Model's Generated type not found", undefined, sourceFile)
+      }
+      // check for FieldOption (unique to v4 Model)
+      const fieldOptionSymbol = typeChecker.tryGetMemberInModuleExports("FieldOption", moduleSymbol)
+      if (!fieldOptionSymbol) {
+        return yield* typeParserIssue("Model's FieldOption type not found", undefined, sourceFile)
+      }
+      return sourceFile
+    }),
+    "TypeParser.isEffectSchemaModelTypeSourceFile",
+    (sourceFile) => sourceFile
+  )
+
+  const isNodeReferenceToEffectSchemaModelModuleApi = (memberName: string) =>
+    Nano.cachedBy(
+      Nano.fn("TypeParser.isNodeReferenceToEffectSchemaModelModuleApi")(function*(
+        node: ts.Node
+      ) {
+        return yield* isNodeReferenceToExportOfPackageModule(
+          node,
+          "effect",
+          isEffectSchemaModelTypeSourceFile,
+          memberName
+        )
+      }),
+      `TypeParser.isNodeReferenceToEffectSchemaModelModuleApi(${memberName})`,
+      (node) => node
+    )
+
+  const extendsEffectSchemaModelClass = Nano.cachedBy(
+    Nano.fn("TypeParser.extendsEffectSchemaModelClass")(function*(
+      atLocation: ts.ClassDeclaration
+    ) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", undefined, atLocation)
+      }
+      const heritageClauses = atLocation.heritageClauses
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", undefined, atLocation)
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression
+            if (ts.isCallExpression(expression)) {
+              // Model.Class<T>("name")({})
+              const schemaCall = expression.expression
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const isEffectSchemaModelModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModelModuleApi("Class")(schemaCall.expression),
+                  Nano.orUndefined
+                )
+                if (isEffectSchemaModelModuleApi) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]!
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend effect's Model.Class", undefined, atLocation)
+    }),
+    "TypeParser.extendsEffectSchemaModelClass",
+    (atLocation) => atLocation
+  )
+
   const isEffectLayerTypeSourceFile = Nano.cachedBy(
     Nano.fn("TypeParser.isEffectLayerTypeSourceFile")(function*(
       sourceFile: ts.SourceFile
@@ -2967,6 +3059,7 @@ export function make(
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
+    isNodeReferenceToEffectSchemaModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
     isNodeReferenceToEffectSchemaParserModuleApi,
     isServiceMapTypeSourceFile,
@@ -3004,6 +3097,7 @@ export function make(
     extendsSchemaTaggedRequest,
     extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
+    extendsEffectSchemaModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,

packages/language-service/src/diagnostics/classSelfMismatch.ts

@@ -41,6 +41,7 @@ export const classSelfMismatch = LSP.createDiagnostic({
             )
           ),
           Nano.orElse(() => typeParser.extendsEffectSqlModelClass(node)),
+          Nano.orElse(() => typeParser.extendsEffectSchemaModelClass(node)),
           Nano.orElse(() => Nano.void_)
         )