Constructors

[vito]

This PR adds support for explicit constructor definitions in Dang using the new(...) { ... } syntax. This enables constructor arguments that are not automatically exposed as fields, which is essential for Dagger module serialization where some constructor inputs shouldn't be persisted.

Motivation

Previously, Dang derived constructors from public fields - constructor parameter names matched field names exactly. This caused issues with Dagger's serialization model:

1. Constructor inputs that shouldn't be serialized (e.g., transient configuration) became fields
2. No way to transform constructor inputs before storing them
3. Constructor arg names were tightly coupled to field names

New Syntax

type Greeter {
  pub greeting: String!

  new(name: String!) {
    self.greeting = "Hello, " + name + "!"
  }
}

let g = Greeter("World")  # g.greeting == "Hello, World!"

Key features:

• Constructor args are only available within the new() body
• Args are NOT exposed as instance fields
• new() implicitly returns self
• Runtime error if non-null fields aren't assigned
• new() is only valid inside class bodies (parse error elsewhere)

Changes

Grammar (pkg/dang/dang.peg)

• Added NewConstructor rule: new(args) { block }
• Added ClassExpr and ClassBlock to restrict new() to class bodies
• Class rule now uses ClassBlock instead of generic Block

AST (pkg/dang/slots.go)

• Added NewConstructorDecl struct with Args, BodyBlock, DocString, Loc
• ClassDecl methods updated to find and handle NewConstructorDecl
• findNewConstructor() and bodyFormsWithoutNew() helpers

Type Inference (pkg/dang/slots.go)

• ClassDecl.Hoist: Uses new() args if present, otherwise derives from fields
• ClassDecl.Infer: Separately infers new() body with args in scope
• inferNewConstructor(): Adds constructor args to env before inferring body

Evaluation (pkg/dang/eval.go)

• ConstructorFunction now has NewBody *Block field
• ConstructorFunction.Call:
  • Evaluates field declarations (skipping required fields without defaults)
  • Binds constructor args in forked closure
  • Executes new() body with access to self and args
  • Validates all non-null fields were assigned
• checkRequiredFields(): Runtime validation of field assignment

Dagger SDK (dagger-sdk/entrypoint/main.go)

• Fixed object reconstruction from serialized state
• Key fix: Bypass constructor when deserializing - directly set fields from JSON
• Evaluates class body forms after setting fields (for computed properties)
• SlotDecl.Eval's GetLocal check prevents defaults from clobbering loaded state

Backwards Compatibility

• Types without new() continue to derive constructors from fields (existing behavior)
• No breaking changes to existing Dang code

Tests

• tests/test_explicit_constructor.dang: Comprehensive test cases
• tests/errors/constructor_arg_in_method_body.dang: Verifies args scoped to new()
• tests/errors/new_outside_class.dang: Verifies new() only valid in class bodies
• mod/test-mismatch/: Tests constructor arg names differing from field names
• mod/test-private-arg/: Updated to use new syntax

Example: Dagger Module

type Dang {
  pub source: Directory!

  new(
    source2: Directory! @defaultPath(path: "/")
  ) {
    self.source = source2
  }

  pub test: Test! {
    Test(self)
  }
}

Here source2 is the constructor arg (with Dagger directives), but source is the serialized field. The arg name doesn't need to match the field name.