Function TestMatchParser_NestedPatterns

pkg/matchparser/match_parser_test.go:103–165

(t *testing.T)

}

func TestMatchParser_NestedPatterns(t *testing.T) {
	tests := []struct {
		name        string
		input       string
		wantPattern string
		wantNested  bool
	}{
		{
			name:        "Ok(Some(x))",
			input:       "match wrapped { Ok(Some(x)) => x }",
			wantPattern: "Ok(Some(x))",
			wantNested:  true,
		},
		{
			name:        "Err(Error(code, msg))",
			input:       "match result { Err(Error(code, msg)) => code }",
			wantPattern: "Err(Error(code, msg))",
			wantNested:  true,
		},
		{
			name:        "Ok(Some(Ok(value)))",
			input:       "match deep { Ok(Some(Ok(value))) => value }",
			wantPattern: "Ok(Some(Ok(value)))",
			wantNested:  true,
		},
		{
			name:        "tuple with nested",
			input:       "match pair { (Ok(x), Err(e)) => x }",
			wantPattern: "(Ok(x), Err(e))",
			wantNested:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tok := tokenizer.New([]byte(tt.input))
			_, err := tok.Tokenize()
			if err != nil {
				t.Fatalf("tokenize error: %v", err)
			}

			parser := NewMatchParser(tok)
			expr, err := parser.ParseMatchExpr()
			if err != nil {
				t.Fatalf("parse error: %v", err)
			}

			if len(expr.Arms) == 0 {
				t.Fatal("no arms parsed")
			}

			gotPattern := expr.Arms[0].Pattern.String()
			if gotPattern != tt.wantPattern {
				t.Errorf("got pattern %q, want %q", gotPattern, tt.wantPattern)
			}

			// Verify nesting by checking pattern structure
			if tt.wantNested {