Function methodDSL

dsl/payload.go:164–222

(m *expr.MethodExpr, suffix string, p any, args ...any)

}

func methodDSL(m *expr.MethodExpr, suffix string, p any, args ...any) *expr.AttributeExpr {
	var (
		att *expr.AttributeExpr
		fn  func()
	)
	switch actual := p.(type) {
	case func():
		fn = actual
		att = &expr.AttributeExpr{Type: &expr.Object{}}
	case expr.UserType:
		if len(args) == 0 {
			// Do not duplicate type if it is not customized
			return &expr.AttributeExpr{Type: actual}
		}
		dupped := expr.Dup(actual)
		att = &expr.AttributeExpr{Type: dupped}
		if f, ok := args[len(args)-1].(func()); ok {
			numreqs := 0
			if att.Validation != nil {
				numreqs = len(att.Validation.Required)
			}
			eval.Execute(f, att)
			if att.Validation != nil && len(att.Validation.Required) != numreqs {
				// If the DSL modifies the type attributes "requiredness"
				// then rename the type to avoid collisions.
				if renamer, ok := dupped.(interface {
					Rename(string)
				}); ok {
					renamer.Rename(actual.Name() + "_" + m.Name + "_" + suffix)
				}
			}
		}
	case expr.DataType:
		att = &expr.AttributeExpr{Type: actual}
	default:
		eval.InvalidArgError("type or function", p)
		return nil
	}
	if len(args) >= 1 {
		if f, ok := args[len(args)-1].(func()); ok {
			if fn != nil {
				eval.InvalidArgError("(type), (func), (type, func), (type, desc) or (type, desc, func)", f)
			}
			fn = f
		}
		if d, ok := args[0].(string); ok {
			att.Description = d
		}
	}
	if fn != nil {
		eval.Execute(fn, att)
		if obj, ok := att.Type.(*expr.Object); ok {
			if len(*obj) == 0 {
				att.Type = expr.Empty
			}
		}
	}
	return att