x/exp/schema: remove unused arguments

Signed-off-by: philhassey <phil@strongdm.com>

Author: philhassey

x/exp/schema/internal/json/json.go

@@ -54,7 +54,7 @@ func (s *Schema) UnmarshalJSON(b []byte) error {
 		if err := json.Unmarshal(data, &jns); err != nil {
 			return fmt.Errorf("namespace %q: %w", name, err)
 		}
-		ns, err := unmarshalNamespace(types.Path(name), jns)
+		ns, err := unmarshalNamespace(jns)
 		if err != nil {
 			return fmt.Errorf("namespace %q: %w", name, err)
 		}
@@ -291,7 +291,7 @@ func marshalAnnotations(annotations ast.Annotations) map[string]string {
 	return m
 }
 
-func unmarshalNamespace(name types.Path, jns jsonNamespace) (ast.Namespace, error) {
+func unmarshalNamespace(jns jsonNamespace) (ast.Namespace, error) {
 	ns := ast.Namespace{}
 
 	if len(jns.Annotations) > 0 {

x/exp/schema/internal/json/json_internal_test.go

@@ -117,7 +117,7 @@ func TestMarshalNamespacedError(t *testing.T) {
 }
 
 func TestUnmarshalCommonTypeError(t *testing.T) {
-	_, err := unmarshalNamespace("", jsonNamespace{
+	_, err := unmarshalNamespace(jsonNamespace{
 		EntityTypes: map[string]jsonEntityType{},
 		Actions:     map[string]jsonAction{},
 		CommonTypes: map[string]jsonCommonType{
@@ -128,7 +128,7 @@ func TestUnmarshalCommonTypeError(t *testing.T) {
 }
 
 func TestUnmarshalEntityShapeError(t *testing.T) {
-	_, err := unmarshalNamespace("", jsonNamespace{
+	_, err := unmarshalNamespace(jsonNamespace{
 		EntityTypes: map[string]jsonEntityType{
 			"Foo": {Shape: &jsonType{
 				Type: "Record",
@@ -143,7 +143,7 @@ func TestUnmarshalEntityShapeError(t *testing.T) {
 }
 
 func TestUnmarshalActionAnnotations(t *testing.T) {
-	ns, err := unmarshalNamespace("", jsonNamespace{
+	ns, err := unmarshalNamespace(jsonNamespace{
 		EntityTypes: map[string]jsonEntityType{},
 		Actions: map[string]jsonAction{
 			"view": {Annotations: map[string]string{"doc": "test"}},
@@ -154,7 +154,7 @@ func TestUnmarshalActionAnnotations(t *testing.T) {
 }
 
 func TestUnmarshalContextTypeError(t *testing.T) {
-	_, err := unmarshalNamespace("", jsonNamespace{
+	_, err := unmarshalNamespace(jsonNamespace{
 		EntityTypes: map[string]jsonEntityType{},
 		Actions: map[string]jsonAction{
 			"view": {AppliesTo: &jsonAppliesTo{

x/exp/schema/internal/parser/parser.go

@@ -124,7 +124,7 @@ func (p *parser) parseSchema() (*ast.Schema, error) {
 			}
 			schema.Namespaces[ns.name] = ns.ns
 		} else {
-			if err := p.parseDecl(annotations, nil, schema); err != nil {
+			if err := p.parseDecl(annotations, schema); err != nil {
 				return nil, err
 			}
 		}
@@ -155,8 +155,7 @@ func (p *parser) parseNamespace(annotations ast.Annotations) (parsedNamespace, e
 		if err != nil {
 			return parsedNamespace{}, err
 		}
-		pathPtr := path
-		if err := p.parseDecl(innerAnnotations, &pathPtr, &innerSchema); err != nil {
+		if err := p.parseDecl(innerAnnotations, &innerSchema); err != nil {
 			return parsedNamespace{}, err
 		}
 	}
@@ -170,7 +169,7 @@ func (p *parser) parseNamespace(annotations ast.Annotations) (parsedNamespace, e
 	return parsedNamespace{name: path, ns: ns}, nil
 }
 
-func (p *parser) parseDecl(annotations ast.Annotations, namespace *types.Path, schema *ast.Schema) error {
+func (p *parser) parseDecl(annotations ast.Annotations, schema *ast.Schema) error {
 	if p.tok.Type != tokenIdent {
 		return p.errorf("expected declaration (entity, action, or type), got %s", tokenDesc(p.tok))
 	}
@@ -179,12 +178,12 @@ func (p *parser) parseDecl(annotations ast.Annotations, namespace *types.Path, s
 		if err := p.readToken(); err != nil {
 			return err
 		}
-		return p.parseEntity(annotations, namespace, schema)
+		return p.parseEntity(annotations, schema)
 	case "action":
 		if err := p.readToken(); err != nil {
 			return err
 		}
-		return p.parseAction(annotations, namespace, schema)
+		return p.parseAction(annotations, schema)
 	case "type":
 		if err := p.readToken(); err != nil {
 			return err
@@ -195,7 +194,7 @@ func (p *parser) parseDecl(annotations ast.Annotations, namespace *types.Path, s
 	}
 }
 
-func (p *parser) parseEntity(annotations ast.Annotations, namespace *types.Path, schema *ast.Schema) error {
+func (p *parser) parseEntity(annotations ast.Annotations, schema *ast.Schema) error {
 	names, err := p.parseIdents()
 	if err != nil {
 		return err
@@ -206,7 +205,7 @@ func (p *parser) parseEntity(annotations ast.Annotations, namespace *types.Path,
 		if err := p.readToken(); err != nil {
 			return err
 		}
-		return p.parseEnumEntity(annotations, namespace, names, schema)
+		return p.parseEnumEntity(annotations, names, schema)
 	}
 
 	// Parse optional 'in' clause
@@ -271,7 +270,7 @@ func (p *parser) parseEntity(annotations ast.Annotations, namespace *types.Path,
 	return nil
 }
 
-func (p *parser) parseEnumEntity(annotations ast.Annotations, namespace *types.Path, names []types.Ident, schema *ast.Schema) error {
+func (p *parser) parseEnumEntity(annotations ast.Annotations, names []types.Ident, schema *ast.Schema) error {
 	if err := p.expect(tokenLBracket); err != nil {
 		return err
 	}
@@ -311,7 +310,7 @@ func (p *parser) parseEnumEntity(annotations ast.Annotations, namespace *types.P
 	return nil
 }
 
-func (p *parser) parseAction(annotations ast.Annotations, namespace *types.Path, schema *ast.Schema) error {
+func (p *parser) parseAction(annotations ast.Annotations, schema *ast.Schema) error {
 	names, err := p.parseNames()
 	if err != nil {
 		return err
@@ -323,7 +322,7 @@ func (p *parser) parseAction(annotations ast.Annotations, namespace *types.Path,
 		if err := p.readToken(); err != nil {
 			return err
 		}
-		memberOf, err = p.parseActionParents(namespace)
+		memberOf, err = p.parseActionParents()
 		if err != nil {
 			return err
 		}
@@ -598,14 +597,14 @@ func (p *parser) parseEntityTypes() ([]ast.EntityTypeRef, error) {
 }
 
 // parseActionParents parses QualName | '[' QualName { ',' QualName } ']'
-func (p *parser) parseActionParents(namespace *types.Path) ([]ast.ParentRef, error) {
+func (p *parser) parseActionParents() ([]ast.ParentRef, error) {
 	if p.tok.Type == tokenLBracket {
 		if err := p.readToken(); err != nil {
 			return nil, err
 		}
 		var result []ast.ParentRef
 		for p.tok.Type != tokenRBracket {
-			ref, err := p.parseQualName(namespace)
+			ref, err := p.parseQualName()
 			if err != nil {
 				return nil, err
 			}
@@ -620,15 +619,15 @@ func (p *parser) parseActionParents(namespace *types.Path) ([]ast.ParentRef, err
 		}
 		return result, p.readToken() // consume ']'
 	}
-	ref, err := p.parseQualName(namespace)
+	ref, err := p.parseQualName()
 	if err != nil {
 		return nil, err
 	}
 	return []ast.ParentRef{ref}, nil
 }
 
 // parseQualName parses QualName = Name | Path '::' STR
-func (p *parser) parseQualName(namespace *types.Path) (ast.ParentRef, error) {
+func (p *parser) parseQualName() (ast.ParentRef, error) {
 	if p.tok.Type == tokenString {
 		name := types.String(p.tok.Text)
 		if err := p.readToken(); err != nil {