Add sumtype:decl to Declaration type

We also need to fix up one location `convertNamespace` which handles
nested namespaces. Nested namespaces are not valid (and don't even
parse), but here I'm handling them with an error rather than a panic.

This leads to some changes in functions that transitively call
converNamespace.

Signed-off-by: Greg NISBET <gregory.nisbet@gmail.com>

Author: gregory-nisbet

internal/schema/ast/ast.go

@@ -97,6 +97,7 @@ func (s *Schema) End() token.Position {
 	return token.Position{}
 }
 
+//sumtype:decl
 type Declaration interface {
 	Node
 	isDecl()

internal/schema/ast/convert_human.go

@@ -9,26 +9,32 @@ import (
 // Any information related to ordering, formatting, comments, etc... are lost completely.
 //
 // TODO: Add errors if the schema is invalid (references names that don't exist)
-func ConvertHuman2JSON(n *Schema) JSONSchema {
+func ConvertHuman2JSON(n *Schema) (JSONSchema, error) {
 	out := make(JSONSchema)
 	// In Cedar, all anonymous types (not under a namespace) are put into the "root" namespace,
 	// which just has a name of "".
 	anonymousNamespace := &Namespace{}
 	for _, decl := range n.Decls {
 		switch decl := decl.(type) {
 		case *Namespace:
-			out[decl.Name.String()] = convertNamespace(decl)
+			namespace, err := convertNamespace(decl)
+			if err != nil {
+				return nil, err
+			}
+			out[decl.Name.String()] = namespace
 		default:
 			anonymousNamespace.Decls = append(anonymousNamespace.Decls, decl)
 		}
 	}
 	if len(anonymousNamespace.Decls) > 0 {
-		out[""] = convertNamespace(anonymousNamespace)
+		// Any error converting the anonymous namespace here would have been caught above.
+		namespace, _ := convertNamespace(anonymousNamespace)
+		out[""] = namespace
 	}
-	return out
+	return out, nil
 }
 
-func convertNamespace(n *Namespace) *JSONNamespace {
+func convertNamespace(n *Namespace) (*JSONNamespace, error) {
 	jsNamespace := new(JSONNamespace)
 	jsNamespace.Actions = make(map[string]*JSONAction)
 	jsNamespace.EntityTypes = make(map[string]*JSONEntity)
@@ -104,9 +110,13 @@ func convertNamespace(n *Namespace) *JSONNamespace {
 				commonType.Annotations[a.Key.String()] = a.Value.String()
 			}
 			jsNamespace.CommonTypes[astDecl.Name.String()] = commonType
+		case *CommentBlock:
+			// do nothing
+		case *Namespace:
+			return nil, fmt.Errorf("namespace %q contains subnamespace %q", n.Name.String(), astDecl.Name.String())
 		}
 	}
-	return jsNamespace
+	return jsNamespace, nil
 }
 
 func convertType(t Type) *JSONType {

internal/schema/ast/convert_human_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"io/fs"
+	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -28,7 +29,10 @@ func TestConvertHumanToJson(t *testing.T) {
 		t.Fatalf("Error parsing example schema: %v", err)
 	}
 
-	jsonSchema := ast.ConvertHuman2JSON(schema)
+	jsonSchema, err := ast.ConvertHuman2JSON(schema)
+	if err != nil {
+		t.Fatalf("Error in schema: %v", err)
+	}
 	var got bytes.Buffer
 	enc := json.NewEncoder(&got)
 	enc.SetIndent("", "    ")
@@ -47,3 +51,25 @@ func TestConvertHumanToJson(t *testing.T) {
 	diff := cmp.Diff(gotJ, wantJ)
 	testutil.FatalIf(t, diff != "", "mismatch -want +got:\n%v", diff)
 }
+
+func TestConvertHumanToJson_NestedNamespace(t *testing.T) {
+	namespace := &ast.Schema{
+		Decls: []ast.Declaration{
+			&ast.Namespace{
+				Name: &ast.Path{Parts: []*ast.Ident{{Value: "hi"}}},
+				Decls: []ast.Declaration{
+					&ast.Namespace{
+						Name: &ast.Path{Parts: []*ast.Ident{{Value: "hi"}}},
+					},
+				},
+			},
+		},
+	}
+	_, err := ast.ConvertHuman2JSON(namespace)
+	if err == nil {
+		t.Error("error should not be nil")
+	}
+	if !strings.Contains(err.Error(), "namespace") {
+		t.Errorf("bad error %v", err)
+	}
+}

internal/schema/ast/convert_json_test.go

@@ -29,7 +29,10 @@ func TestConvertJsonToHumanRoundtrip(t *testing.T) {
 
 	// Convert to human-readable format and back to JSON
 	humanSchema := ast.ConvertJSON2Human(jsonSchema)
-	jsonSchema2 := ast.ConvertHuman2JSON(humanSchema)
+	jsonSchema2, err := ast.ConvertHuman2JSON(humanSchema)
+	if err != nil {
+		t.Fatalf("Error dumping schema: %v", err)
+	}
 
 	// Compare the JSON schemas
 	json1, err := json.MarshalIndent(jsonSchema, "", "    ")
@@ -92,3 +95,26 @@ func TestConvertJsonToHumanInvalidType(t *testing.T) {
 		t.Errorf("expected panic message to contain %q, got %q", expected, panicMsg)
 	}
 }
+
+func TestConvertHuman2JSON_NestedNamespace(t *testing.T) {
+	namePath := &ast.Path{Parts: []*ast.Ident{{Value: "hi"}}}
+	innerNamespace := &ast.Namespace{
+		Name: namePath,
+	}
+	outerNamespace := &ast.Namespace{
+		Name: namePath,
+		Decls: []ast.Declaration{
+			innerNamespace,
+		},
+	}
+	schema := &ast.Schema{
+		Decls: []ast.Declaration{
+			outerNamespace,
+		},
+	}
+
+	_, err := ast.ConvertHuman2JSON(schema)
+	if err == nil {
+		t.Errorf("should have failed")
+	}
+}

x/exp/schema/schema.go

@@ -69,7 +69,11 @@ func (s *Schema) MarshalJSON() (out []byte, err error) {
 	if s.humanSchema != nil {
 		// Error should not be possible since s.humanSchema comes from our parser.
 		// If it happens, we return empty JSON.
-		s.jsonSchema = ast.ConvertHuman2JSON(s.humanSchema)
+		schema, err := ast.ConvertHuman2JSON(s.humanSchema)
+		if err != nil {
+			return nil, err
+		}
+		s.jsonSchema = schema
 	}
 	if s.jsonSchema == nil {
 		return nil, nil

x/exp/schema/schema_test.go

@@ -3,7 +3,10 @@ package schema
 import (
 	"encoding/json"
 	"reflect"
+	"strings"
 	"testing"
+
+	"github.com/cedar-policy/cedar-go/internal/schema/ast"
 )
 
 func TestSchemaCedarMarshalUnmarshal(t *testing.T) {
@@ -106,6 +109,29 @@ func TestSchemaJSONMarshalEmpty(t *testing.T) {
 	}
 }
 
+func TestSchemaJSONMarshalNestedNamespace(t *testing.T) {
+	var s Schema
+	s.humanSchema = &ast.Schema{
+		Decls: []ast.Declaration{
+			&ast.Namespace{
+				Name: &ast.Path{Parts: []*ast.Ident{{Value: "hi"}}},
+				Decls: []ast.Declaration{
+					&ast.Namespace{
+						Name: &ast.Path{Parts: []*ast.Ident{{Value: "hi"}}},
+					},
+				},
+			},
+		},
+	}
+	_, err := s.MarshalJSON()
+	if err == nil {
+		t.Error("error should not be nil")
+	}
+	if !strings.Contains(err.Error(), "namespace") {
+		t.Errorf("bad non-namespace-related error: %v", err)
+	}
+}
+
 func TestSchemaJSONMarshalUnmarshal(t *testing.T) {
 	tests := []struct {
 		name    string