Resolve global prompts

Author: FollowTheProcess

internal/syntax/resolver/resolver.go

@@ -48,15 +48,16 @@ func (r *Resolver) Resolve(in ast.File) (spec.File, error) {
 		Requests: []spec.Request{},
 	}
 
-	var err error
-
 	for _, statement := range in.Statements {
-		file, err = r.resolveStatement(file, statement)
+		newFile, err := r.resolveFileStatement(file, statement)
 		if err != nil {
 			// If we can't resolve this one, try carrying on. This ensures we provide
 			// multiple diagnostics for the user rather than one at a time
 			continue
 		}
+
+		// Update the file
+		file = newFile
 	}
 
 	// We've had diagnostics reported somewhere during resolving so correctly
@@ -93,7 +94,7 @@ func (r *Resolver) errorf(node ast.Node, format string, a ...any) {
 
 // resolveStatement resolves a generic [ast.Statement], modifying the file and returning
 // the new version.
-func (r *Resolver) resolveStatement(file spec.File, statement ast.Statement) (spec.File, error) {
+func (r *Resolver) resolveFileStatement(file spec.File, statement ast.Statement) (spec.File, error) {
 	var err error
 
 	switch stmt := statement.(type) {
@@ -102,9 +103,14 @@ func (r *Resolver) resolveStatement(file spec.File, statement ast.Statement) (sp
 		if err != nil {
 			return spec.File{}, ErrResolve
 		}
+	case ast.PromptStatement:
+		file, err = r.resolveGlobalPromptStatement(file, stmt)
+		if err != nil {
+			return spec.File{}, ErrResolve
+		}
 
 	default:
-		return spec.File{}, fmt.Errorf("unhandled ast statement: %T", stmt)
+		return file, fmt.Errorf("unhandled ast statement: %T", stmt)
 	}
 
 	return file, nil
@@ -161,6 +167,32 @@ func (r *Resolver) resolveGlobalVarStatement(file spec.File, statement ast.VarSt
 	return file, nil
 }
 
+// resolveGlobalPromptStatement resolves a top level file @prompt statement and
+// adds it to the file, returning the new file containing the prompt.
+func (r *Resolver) resolveGlobalPromptStatement(file spec.File, statement ast.PromptStatement) (spec.File, error) {
+	name := statement.Ident.Name
+
+	prompt := spec.Prompt{
+		Name:        name,
+		Description: statement.Description.Value,
+	}
+
+	if _, exists := file.Prompts[name]; exists {
+		r.errorf(statement, "prompt %s already declared", name)
+		return spec.File{}, ErrResolve
+	}
+
+	// Shouldn't need this because file is declared top level with all this
+	// initialised but let's not panic if we can help it
+	if file.Prompts == nil {
+		file.Prompts = make(map[string]spec.Prompt)
+	}
+
+	file.Prompts[statement.Ident.Name] = prompt
+
+	return file, nil
+}
+
 // resolveExpression resolves an [ast.Expression].
 func (r *Resolver) resolveExpression(expression ast.Expression) (string, error) {
 	switch expr := expression.(type) {

internal/syntax/resolver/resolver_test.go

@@ -5,11 +5,14 @@ import (
 	"flag"
 	"os"
 	"path/filepath"
+	"reflect"
+	"slices"
 	"strings"
 	"testing"
 
 	"go.followtheprocess.codes/test"
 	"go.followtheprocess.codes/txtar"
+	"go.followtheprocess.codes/zap/internal/spec"
 	"go.followtheprocess.codes/zap/internal/syntax"
 	"go.followtheprocess.codes/zap/internal/syntax/parser/v2"
 	"go.followtheprocess.codes/zap/internal/syntax/resolver"
@@ -143,3 +146,60 @@ func testFailHandler(tb testing.TB) syntax.ErrorHandler {
 		tb.Fatalf("%s: %s", pos, msg)
 	}
 }
+
+// TODO(@FollowTheProcess): Benchmark the resolver once it's complete, use the same full.http file
+// as the parser benchmark.
+
+func FuzzResolver(f *testing.F) {
+	// Get all valid .http source from testdata for the corpus
+	validPattern := filepath.Join("testdata", "valid", "*.txtar")
+	validFiles, err := filepath.Glob(validPattern)
+	test.Ok(f, err)
+
+	// Invalid ones too!
+	invalidPattern := filepath.Join("testdata", "invalid", "*.txtar")
+	invalidFiles, err := filepath.Glob(invalidPattern)
+	test.Ok(f, err)
+
+	files := slices.Concat(validFiles, invalidFiles)
+
+	defer goleak.VerifyNone(f)
+
+	for _, file := range files {
+		archive, err := txtar.ParseFile(file)
+		test.Ok(f, err)
+
+		src, ok := archive.Read("src.http")
+		test.True(f, ok, test.Context("%s missing src.http", file))
+
+		// Add the src to the fuzz corpus
+		f.Add(src)
+	}
+
+	// This also fuzzes the parser (again) but realistically there's no way around that. It's also
+	// not a bad thing as the parser produces partial trees in error cases to aid error reporting
+	// so we need to be able to handle these.
+
+	// Property: The resolver never panics or loops indefinitely, fuzz by default will
+	// catch both of these
+	f.Fuzz(func(t *testing.T, src string) {
+		parser, err := parser.New("fuzz", strings.NewReader(src), nil)
+		test.Ok(t, err)
+
+		parsed, _ := parser.Parse() //nolint:errcheck // Just checking for panics and infinite loops
+
+		res := resolver.New(parsed.Name)
+
+		resolved, err := res.Resolve(parsed)
+		// Property: If there is an error, the file should be the zero spec.File{}
+		if err != nil {
+			if !reflect.DeepEqual(resolved, spec.File{}) {
+				// Marshal it as JSON for readability
+				resolvedJSON, err := json.MarshalIndent(resolved, "", "  ")
+				test.Ok(t, err)
+
+				t.Fatalf("got a non-zero spec.File{} in err != nil case:\n\n%s\n\n", resolvedJSON)
+			}
+		}
+	})
+}

internal/syntax/resolver/testdata/invalid/redeclared-prompts.txtar

@@ -0,0 +1,27 @@
+# Declaring prompts multiple times with the same id is an error.
+
+-- src.http --
+@prompt id User id
+@prompt id A different id
+@prompt other Something else
+@prompt no-description
+@prompt other Something else again
+-- diagnostics.json --
+[
+  {
+    "file": "redeclared-prompts.txtar",
+    "msg": "prompt id already declared",
+    "highlight": {
+      "start": 19,
+      "end": 44
+    }
+  },
+  {
+    "file": "redeclared-prompts.txtar",
+    "msg": "prompt other already declared",
+    "highlight": {
+      "start": 97,
+      "end": 131
+    }
+  }
+]

internal/syntax/resolver/testdata/valid/global-prompts.txtar

@@ -0,0 +1,23 @@
+# Top level prompts
+
+-- src.http --
+@prompt id User id
+@prompt other Something else
+@prompt no-description
+-- want.json --
+{
+  "name": "global-prompts.txtar",
+  "prompts": {
+    "id": {
+      "name": "id",
+      "description": "User id"
+    },
+    "no-description": {
+      "name": "no-description"
+    },
+    "other": {
+      "name": "other",
+      "description": "Something else"
+    }
+  }
+}