Add eval.TooFewArgError() (#3557)

* Add eval.TooFewArgError()

* Fix a condition in dsl.ErrorName

* Fix a test case in expr.TestExample

* Remove an unnecessary block

---------

Co-authored-by: Raphael Simon <[email protected]>

Author: tchssk

dsl/attribute.go

@@ -112,29 +112,27 @@ import (
 //	})
 func Attribute(name string, args ...any) {
 	var parent *expr.AttributeExpr
-	{
-		switch def := eval.Current().(type) {
-		case *expr.AttributeExpr:
-			parent = def
-		case expr.CompositeExpr:
-			parent = def.Attribute()
-		default:
-			eval.IncompatibleDSL()
-			return
-		}
-		if parent == nil {
-			eval.ReportError("invalid syntax, attribute %#v has no parent", name)
+	switch def := eval.Current().(type) {
+	case *expr.AttributeExpr:
+		parent = def
+	case expr.CompositeExpr:
+		parent = def.Attribute()
+	default:
+		eval.IncompatibleDSL()
+		return
+	}
+	if parent == nil {
+		eval.ReportError("invalid syntax, attribute %#v has no parent", name)
+		return
+	}
+	if parent.Type == nil {
+		parent.Type = &expr.Object{}
+	}
+	if _, ok := parent.Type.(*expr.Object); !ok {
+		if _, ok := parent.Type.(*expr.Union); !ok {
+			eval.ReportError("can't define child attribute %#v on attribute of type %s %T", name, parent.Type.Name(), parent.Type)
 			return
 		}
-		if parent.Type == nil {
-			parent.Type = &expr.Object{}
-		}
-		if _, ok := parent.Type.(*expr.Object); !ok {
-			if _, ok := parent.Type.(*expr.Union); !ok {
-				eval.ReportError("can't define child attribute %#v on attribute of type %s %T", name, parent.Type.Name(), parent.Type)
-				return
-			}
-		}
 	}
 
 	var attr *expr.AttributeExpr
@@ -298,7 +296,7 @@ func Default(def any) {
 //	})
 func Example(args ...any) {
 	if len(args) == 0 {
-		eval.ReportError("not enough arguments")
+		eval.TooFewArgError()
 		return
 	}
 	if len(args) > 2 {

dsl/error.go

@@ -173,7 +173,7 @@ func Error(name string, args ...any) {
 //	}
 func ErrorName(args ...any) {
 	if len(args) == 0 {
-		eval.IncompatibleDSL()
+		eval.TooFewArgError()
 		return
 	}
 	dsl, ok := args[len(args)-1].(func())
@@ -191,8 +191,8 @@ func ErrorName(args ...any) {
 	case string:
 		Attribute(actual, args[1:]...)
 	case int:
-		if len(args) == 1 {
-			eval.IncompatibleDSL()
+		if len(args) == 2 {
+			eval.TooFewArgError()
 			return
 		}
 		name, ok := args[1].(string)

dsl/http.go

@@ -895,7 +895,7 @@ func SkipResponseBodyEncodeDecode() {
 //	})
 func Body(args ...any) {
 	if len(args) == 0 {
-		eval.ReportError("not enough arguments, use Body(name), Body(type), Body(func()) or Body(type, func())")
+		eval.TooFewArgError()
 		return
 	}
 

dsl/response.go

@@ -202,7 +202,7 @@ func Code(code int) {
 
 func grpcError(n string, p eval.Expression, args ...any) *expr.GRPCErrorExpr {
 	if len(args) == 0 {
-		eval.ReportError("not enough arguments, use Response(name, status), Response(name, status, func()) or Response(name, func())")
+		eval.TooFewArgError()
 		return nil
 	}
 	var (
@@ -260,7 +260,7 @@ func parseResponseArgs(val any, args ...any) (code int, fn func()) {
 
 func httpError(n string, p eval.Expression, args ...any) *expr.HTTPErrorExpr {
 	if len(args) == 0 {
-		eval.ReportError("not enough arguments, use Response(name, status), Response(name, status, func()) or Response(name, func())")
+		eval.TooFewArgError()
 		return nil
 	}
 	var (

eval/eval.go

@@ -126,6 +126,12 @@ func InvalidArgError(expected string, actual any) {
 	ReportError("cannot use %#v (type %s) as type %s", actual, reflect.TypeOf(actual), expected)
 }
 
+// TooFewArgError records a too few arguments error. It is used by DSL
+// functions that take dynamic arguments.
+func TooFewArgError() {
+	ReportError("too few arguments given to %s", caller())
+}
+
 // TooManyArgError records a too many arguments error. It is used by DSL
 // functions that take dynamic arguments.
 func TooManyArgError() {

eval/eval_test.go

@@ -35,6 +35,24 @@ func TestInvalidArgError(t *testing.T) {
 	}
 }
 
+func TestTooFewArgError(t *testing.T) {
+	dsls := map[string]func(){
+		"Body":            func() { Body() },
+		"ErrorName":       func() { ErrorName() },
+		"ErrorName (int)": func() { Type("name", func() { ErrorName(1) }) },
+		"Example":         func() { Example() },
+		"Response (grpc)": func() { Service("s", func() { GRPC(func() { Response("name") }) }) },
+		"Response (http)": func() { Service("s", func() { HTTP(func() { Response("name") }) }) },
+	}
+	for name, dsl := range dsls {
+		t.Run(name, func(t *testing.T) {
+			err := expr.RunInvalidDSL(t, dsl)
+			assert.Len(t, strings.Split(err.Error(), "\n"), 1)
+			assert.Contains(t, err.Error(), "too few arguments given to "+strings.Split(name, " ")[0])
+		})
+	}
+}
+
 func TestTooManyArgError(t *testing.T) {
 	dsls := map[string]func(){
 		"APIKey":           func() { Type("name", func() { APIKey("scheme", "name", 1, 2, 3) }) },

expr/example_test.go

@@ -63,7 +63,7 @@ func TestExample(t *testing.T) {
 		{"overriding-example", testdata.OverridingExampleDSL, map[string]any{"name": "overridden"}, ""},
 		{"with-extend", testdata.WithExtendExampleDSL, map[string]any{"name": "example"}, ""},
 		{"invalid-example-type", testdata.InvalidExampleTypeDSL, nil, "example value map[int]int{1:1} is incompatible with attribute of type map in attribute"},
-		{"empty-example", testdata.EmptyExampleDSL, nil, "not enough arguments in attribute"},
+		{"empty-example", testdata.EmptyExampleDSL, nil, "too few arguments given to Example in attribute"},
 		{"hiding-example", testdata.HidingExampleDSL, nil, ""},
 		{"overriding-hidden-examples", testdata.OverridingHiddenExamplesDSL, "example", ""},
 	}