Merge open PRs MadAppGang#59, MadAppGang#60, MadAppGang#61, MadAppGang#62 into fork main

Combines all four currently open pull requests against MadAppGang/dingo into
the local fork's main so downstream work (e.g. the nodes.go cascade fix) can
build on top of all of them without one-by-one branch juggling. The
upstream PRs remain unaffected because their base branch is MadAppGang/dingo:main,
not bbodi/dingo:main.

Included:
  MadAppGang#59 fix(ast/transform): recognise method receiver param lists for type annotations
  MadAppGang#60 test(tokenizer): cover ENUM and GUARD keywords at both surfaces
  MadAppGang#61 fix(ast/enum_parser): allow arbitrary nesting of '*' and '[]' in variant field types
  MadAppGang#62 feat(feature): add Validator plugin extension and character-level pre-transform phase

Author: bbodi

pkg/ast/enum_parser.go

@@ -317,17 +317,19 @@ func (p *EnumParser) parseStructFields() ([]*EnumField, error) {
 func (p *EnumParser) parseTypeExpr() (*TypeExpr, error) {
 	start := p.pos
 
-	// Handle pointer types
-	for p.peek() == '*' {
-		p.advance()
-	}
-
-	// Handle slice types
-	if p.peek() == '[' {
-		p.advance()
-		if p.peek() == ']' {
+	// Accept any number of '*' (pointer) and '[]' (slice) prefixes in any order.
+	// Supports *T, []T, []*T, *[]T, [][]T, **T, etc.
+	for {
+		if p.peek() == '*' {
 			p.advance()
+			continue
+		}
+		if p.peek() == '[' && p.pos+1 < len(p.src) && p.src[p.pos+1] == ']' {
+			p.advance() // '['
+			p.advance() // ']'
+			continue
 		}
+		break
 	}
 
 	// Parse base type name

pkg/ast/enum_parser_test.go

@@ -0,0 +1,200 @@
+package ast
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestEnumParser_TypePrefixes covers parseTypeExpr's handling of pointer (*),
+// slice ([]), and any nesting/order of the two. The original implementation
+// accepted only `**T` or `*[]T`-shaped prefixes (pointers first, then a single
+// slice), which silently rejected `[]*T`, `[][]T`, `[]*[]T`, etc. The
+// transpilation pipeline turned that rejection into a confusing
+// "expected declaration, found enum" error downstream.
+func TestEnumParser_TypePrefixes(t *testing.T) {
+	tests := []struct {
+		name     string
+		src      string
+		wantType string // expected Text of the parsed field type
+	}{
+		{
+			name:     "plain type",
+			src:      `enum E { V { x: int } }`,
+			wantType: "int",
+		},
+		{
+			name:     "pointer",
+			src:      `enum E { V { x: *Foo } }`,
+			wantType: "*Foo",
+		},
+		{
+			name:     "double pointer",
+			src:      `enum E { V { x: **Foo } }`,
+			wantType: "**Foo",
+		},
+		{
+			name:     "slice of value",
+			src:      `enum E { V { x: []Foo } }`,
+			wantType: "[]Foo",
+		},
+		{
+			name:     "slice of pointer",
+			src:      `enum E { V { x: []*Foo } }`,
+			wantType: "[]*Foo",
+		},
+		{
+			name:     "pointer to slice",
+			src:      `enum E { V { x: *[]Foo } }`,
+			wantType: "*[]Foo",
+		},
+		{
+			name:     "slice of slice",
+			src:      `enum E { V { x: [][]int } }`,
+			wantType: "[][]int",
+		},
+		{
+			name:     "slice of slice of pointer",
+			src:      `enum E { V { x: [][]*Foo } }`,
+			wantType: "[][]*Foo",
+		},
+		{
+			name:     "generic with slice arg",
+			src:      `enum E { V { x: Result[[]int, error] } }`,
+			wantType: "Result[[]int, error]",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := NewEnumParser([]byte(tt.src), 0)
+			decl, _, err := p.ParseEnumDecl()
+			if err != nil {
+				t.Fatalf("ParseEnumDecl(%q) returned error: %v", tt.src, err)
+			}
+			if len(decl.Variants) != 1 {
+				t.Fatalf("expected 1 variant, got %d", len(decl.Variants))
+			}
+			v := decl.Variants[0]
+			if v.Kind != StructVariant {
+				t.Fatalf("expected struct variant, got %v", v.Kind)
+			}
+			if len(v.Fields) != 1 {
+				t.Fatalf("expected 1 field, got %d", len(v.Fields))
+			}
+			got := v.Fields[0].Type.Text
+			if got != tt.wantType {
+				t.Errorf("field type = %q, want %q", got, tt.wantType)
+			}
+		})
+	}
+}
+
+// TestEnumParser_TupleTypePrefixes covers the same prefix handling in tuple
+// variant fields. parseTupleFields shares parseTypeExpr with parseStructFields,
+// so a regression in either context surfaces here too.
+func TestEnumParser_TupleTypePrefixes(t *testing.T) {
+	tests := []struct {
+		name      string
+		src       string
+		wantTypes []string
+	}{
+		{
+			name:      "single slice-of-pointer",
+			src:       `enum E { V([]*Foo) }`,
+			wantTypes: []string{"[]*Foo"},
+		},
+		{
+			name:      "mixed prefixes",
+			src:       `enum E { V(*Foo, []*Bar, [][]int) }`,
+			wantTypes: []string{"*Foo", "[]*Bar", "[][]int"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := NewEnumParser([]byte(tt.src), 0)
+			decl, _, err := p.ParseEnumDecl()
+			if err != nil {
+				t.Fatalf("ParseEnumDecl(%q) returned error: %v", tt.src, err)
+			}
+			if len(decl.Variants) != 1 {
+				t.Fatalf("expected 1 variant, got %d", len(decl.Variants))
+			}
+			v := decl.Variants[0]
+			if v.Kind != TupleVariant {
+				t.Fatalf("expected tuple variant, got %v", v.Kind)
+			}
+			if len(v.Fields) != len(tt.wantTypes) {
+				t.Fatalf("expected %d fields, got %d", len(tt.wantTypes), len(v.Fields))
+			}
+			for i, want := range tt.wantTypes {
+				got := v.Fields[i].Type.Text
+				if got != want {
+					t.Errorf("field %d type = %q, want %q", i, got, want)
+				}
+			}
+		})
+	}
+}
+
+// TestTransformSource_SliceOfPointer is an end-to-end regression test:
+// before the fix, a `[]*T` field on an enum variant caused the dingo→go
+// transformation to leave the `enum` keyword in the output, producing a
+// downstream go/parser error of the form
+//
+//	"expected declaration, found enum"
+//
+// After the fix the source is transformed cleanly and the generated Go
+// contains the variant struct with the correct slice-of-pointer field.
+func TestTransformSource_SliceOfPointer(t *testing.T) {
+	src := []byte(`package main
+
+enum D { Foo { xs: []*Name, n: int } }
+
+type Name struct { v string }
+`)
+	got, err := TransformSource(src, "test.dingo")
+	if err != nil {
+		t.Fatalf("TransformSource returned error: %v", err)
+	}
+	out := string(got)
+	if strings.Contains(out, "enum ") {
+		t.Errorf("transformed output still contains 'enum' keyword:\n%s", out)
+	}
+	// The variant struct should carry the field with its original slice-of-pointer type.
+	if !strings.Contains(out, "xs []*Name") {
+		t.Errorf("expected `xs []*Name` field in generated Go, got:\n%s", out)
+	}
+}
+
+// TestTransformSource_MultiLineVariantBody confirms that a struct variant
+// whose fields are newline-separated (no trailing commas) still parses.
+// This was suspected to be broken alongside the slice-of-pointer bug but is
+// actually fine; this test guards against future regressions in
+// parseStructFields, which relies on skipWhitespaceAndCommas treating
+// newlines as separators.
+func TestTransformSource_MultiLineVariantBody(t *testing.T) {
+	src := []byte(`package main
+
+enum D { Foo {
+    a: int
+    b: *Name
+    c: []*Name
+} }
+
+type Name struct { v string }
+`)
+	got, err := TransformSource(src, "test.dingo")
+	if err != nil {
+		t.Fatalf("TransformSource returned error: %v", err)
+	}
+	out := string(got)
+	if strings.Contains(out, "enum ") {
+		t.Errorf("transformed output still contains 'enum' keyword:\n%s", out)
+	}
+	for _, want := range []string{"a int", "b *Name", "c []*Name"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("expected %q in generated Go, got:\n%s", want, out)
+		}
+	}
+}

pkg/ast/transform.go

@@ -104,6 +104,30 @@ func TransformSource(src []byte, filename string) ([]byte, error) {
 								break
 							}
 						}
+					} else if prevPrev.tok == gotoken.RPAREN {
+						// Method declaration: func (recv) name(x: int).
+						// Walk back to find the matching `(` of the receiver
+						// list and verify FUNC sits in front of it.
+						depth := 1
+						for j := i - 3; j >= 0; j-- {
+							switch tokens[j].tok {
+							case gotoken.RPAREN:
+								depth++
+							case gotoken.LPAREN:
+								depth--
+								if depth == 0 {
+									if j > 0 && tokens[j-1].tok == gotoken.FUNC {
+										paramListDepth = parenDepth
+									}
+									j = -1 // break outer
+								}
+							case gotoken.SEMICOLON, gotoken.LBRACE, gotoken.RBRACE:
+								j = -1 // break outer
+							}
+							if j < 0 {
+								break
+							}
+						}
 					}
 				}
 			}

pkg/ast/transform_test.go

@@ -0,0 +1,79 @@
+package ast
+
+import (
+	"go/parser"
+	gotoken "go/token"
+	"strings"
+	"testing"
+)
+
+// TestTransformSource_MethodReceiverTypeAnnotations exercises the fix for
+// type-annotated parameter lists on methods (receiver functions).
+//
+// Without the receiver-aware branch in TransformSource, the param-list detector
+// only recognised `func name(...)` and `func(...)`. As soon as a receiver was
+// present, e.g. `func (r *T) Foo(x: int)`, the `(x: int)` group was treated as
+// an arbitrary parenthesised expression, so the `:` was never converted into a
+// space and the generated Go was syntactically invalid.
+func TestTransformSource_MethodReceiverTypeAnnotations(t *testing.T) {
+	tests := []struct {
+		name       string
+		input      string
+		wantAbsent []string
+	}{
+		{
+			name:  "pointer receiver single param",
+			input: "package p\nfunc (r *T) Foo(x: int) {}\ntype T struct{}\n",
+			wantAbsent: []string{
+				"x: int",
+			},
+		},
+		{
+			name:  "value receiver multiple params",
+			input: "package p\nfunc (r T) Bar(x: int, y: string) {}\ntype T struct{}\n",
+			wantAbsent: []string{
+				"x: int",
+				"y: string",
+			},
+		},
+		{
+			name: "method body struct literal colons are preserved",
+			input: "package p\n" +
+				"type T struct{}\n" +
+				"type rw struct{ X int }\n" +
+				"func (r *T) Foo(x: int) { _ = rw{X: 1} }\n",
+			wantAbsent: []string{
+				"x: int",
+			},
+		},
+		{
+			name:  "named receiver pointer to generic type",
+			input: "package p\nfunc (r *T[U]) Foo(x: U) {}\ntype T[U any] struct{}\n",
+			wantAbsent: []string{
+				"x: U",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out, err := TransformSource([]byte(tt.input), "test.dingo")
+			if err != nil {
+				t.Fatalf("TransformSource() error = %v", err)
+			}
+			got := string(out)
+			// Goal: transformer must produce valid Go for method declarations
+			// with type-annotated params. Without the fix, the `:` survives and
+			// go/parser rejects it.
+			fset := gotoken.NewFileSet()
+			if _, err := parser.ParseFile(fset, "out.go", got, 0); err != nil {
+				t.Errorf("transformed output is not valid Go: %v\n---got---\n%s", err, got)
+			}
+			for _, bad := range tt.wantAbsent {
+				if strings.Contains(got, bad) {
+					t.Errorf("output unexpectedly contains %q\n---got---\n%s", bad, got)
+				}
+			}
+		})
+	}
+}