111

Author: lvan100

gen/generator/golang/server.go

@@ -379,47 +379,9 @@ func convertTypes(ctx Context, doc tidl.Document) (_ []Type, err error) {
 		ret = append(ret, r)
 	}
 
-	// Handle RPC response types with generics
-	for _, c := range doc.RPCs {
-		if c.Response.Stream || c.Response.UserType == nil {
-			continue
-		}
-		r, err := convertResponseType(ctx, c.Name, c.Response)
-		if err != nil {
-			return nil, err
-		}
-		ret = append(ret, r)
-	}
 	return ret, nil
 }
 
-// convertResponseType instantiates a generic response type for RPC
-func convertResponseType(ctx Context, rpcName string, respType tidl.RespType) (Type, error) {
-	t, ok := tidl.GetType(ctx.files, respType.TypeName)
-	if !ok {
-		return Type{}, fmt.Errorf("type %s not found", respType.TypeName)
-	}
-
-	typeName := rpcName + t.Name + respType.UserType.Name
-
-	r := tidl.Type{
-		Name:     typeName,
-		Position: t.Position,
-		Comments: t.Comments,
-	}
-
-	// Replace generic type fields
-	for _, f := range t.Fields {
-		u, ok := f.FieldType.(tidl.UserType)
-		if ok && u.Name == *t.GenericName {
-			f.FieldType = *respType.UserType
-		}
-		r.Fields = append(r.Fields, f)
-	}
-
-	return convertType(ctx, r)
-}
-
 // convertRedefinedType instantiates a redefined generic struct type
 func convertRedefinedType(ctx Context, r tidl.Type) (Type, error) {
 	t, ok := tidl.GetType(ctx.files, r.Redefined.Name)

gen/generator/golang/type.go

@@ -123,12 +123,12 @@ rpc_def
 
 // RPC request type: always an identifier
 rpc_req
-    : IDENTIFIER
+    : user_type
     ;
 
-// RPC response type: identifier, generic form (Type<T>), or stream<T>
+// RPC response type: identifier, stream<T>
 rpc_resp
-    : IDENTIFIER
+    : user_type
     | TYPE_STREAM LESS_THAN user_type GREATER_THAN
     ;
 

lib/tidl/TParser.g4

@@ -312,7 +312,7 @@ func dumpRPC(r RPC) string {
 	sb.WriteString("rpc ")
 	sb.WriteString(r.Name)
 	sb.WriteString("(")
-	sb.WriteString(r.Request)
+	sb.WriteString(r.Request.Text())
 	sb.WriteString(") ")
 	sb.WriteString(r.Response.Text())
 	sb.WriteString(" {")

lib/tidl/format.go

@@ -482,8 +482,7 @@ func (l *ParseTreeListener) parseValueType(ctx interface {
 // types and annotations.
 func (l *ParseTreeListener) ExitRpc_def(ctx *Rpc_defContext) {
 	r := RPC{
-		Name:    ctx.IDENTIFIER().GetText(),
-		Request: ctx.Rpc_req().GetText(),
+		Name: ctx.IDENTIFIER().GetText(),
 		Position: Position{
 			Start: ctx.GetStart().GetLine(),
 			Stop:  ctx.GetStop().GetLine(),
@@ -495,35 +494,31 @@ func (l *ParseTreeListener) ExitRpc_def(ctx *Rpc_defContext) {
 	if !IsPascal(r.Name) {
 		panic(fmt.Errorf("RPC name %s is not PascalCase in line %d", r.Name, r.Position.Start))
 	}
-	if !IsPascal(r.Request) {
-		panic(fmt.Errorf("RPC request type %s is not PascalCase in line %d", r.Request, r.Position.Start))
+
+	// Request
+	reqType := ctx.Rpc_req().User_type()
+	r.Request = UserType{
+		Name:     reqType.IDENTIFIER().GetText(),
+		Optional: reqType.QUESTION() != nil,
+	}
+	if !IsPascal(r.Request.Name) {
+		panic(fmt.Errorf("RPC request type %s is not PascalCase in line %d", r.Request.Name, r.Position.Start))
 	}
-	l.Document.UsedTypes[r.Request] = struct{}{}
+	l.Document.UsedTypes[r.Request.Name] = struct{}{}
 
 	// Response
-	if resp := ctx.Rpc_resp(); resp.TYPE_STREAM() != nil {
-		u := resp.User_type()
-		r.Response = RespType{
-			Stream: true,
-			UserType: &UserType{
-				Name:     u.IDENTIFIER().GetText(),
-				Optional: u.QUESTION() != nil,
-			},
-		}
-		if !IsPascal(r.Response.UserType.Name) {
-			panic(fmt.Errorf("RPC response type %s is not PascalCase in line %d", r.Response.UserType.Name, r.Position.Start))
-		}
-		l.Document.UsedTypes[r.Response.UserType.Name] = struct{}{}
-	} else {
-		r.Response = RespType{
-			Stream:   false,
-			TypeName: resp.IDENTIFIER().GetText(),
-		}
-		if !IsPascal(r.Response.TypeName) {
-			panic(fmt.Errorf("RPC response type %s is not PascalCase in line %d", r.Response.TypeName, r.Position.Start))
-		}
-		l.Document.UsedTypes[r.Response.TypeName] = struct{}{}
+	respType := ctx.Rpc_resp().User_type()
+	if ctx.Rpc_resp().TYPE_STREAM() != nil {
+		r.Response.Stream = true
+	}
+	r.Response.UserType = UserType{
+		Name:     respType.IDENTIFIER().GetText(),
+		Optional: respType.QUESTION() != nil,
+	}
+	if !IsPascal(r.Response.UserType.Name) {
+		panic(fmt.Errorf("RPC response type %s is not PascalCase in line %d", r.Response.UserType.Name, r.Position.Start))
 	}
+	l.Document.UsedTypes[r.Response.UserType.Name] = struct{}{}
 
 	// Annotations
 	for _, aCtx := range ctx.Rpc_annotations().AllAnnotation() {

lib/tidl/parser.go

@@ -611,11 +611,16 @@
   "RPCs": [
     {
       "Name": "GetUser",
-      "Request": "UserReq",
+      "Request": {
+        "Name": "UserReq",
+        "Optional": false
+      },
       "Response": {
         "Stream": false,
-        "TypeName": "UserResponse",
-        "UserType": null
+        "UserType": {
+          "Name": "UserResponse",
+          "Optional": false
+        }
       },
       "Annotations": [
         {

lib/tidl/t_parser.go

@@ -216,28 +216,23 @@ type Annotation struct {
 // RPC represents a remote procedure call definition.
 type RPC struct {
 	Name        string       // Name of the RPC
-	Request     string       // Request type
+	Request     UserType     // Request type
 	Response    RespType     // Response type
 	Annotations []Annotation // Metadata attached to the RPC
 	Position    Position     // Location in source code
 	Comments    Comments     // Associated comments
 }
 
 // RespType represents the response type of an RPC.
-// It supports both streaming and generic forms.
 type RespType struct {
-	Stream   bool      // Whether the response is a stream
-	TypeName string    // Base type name for non-stream responses
-	UserType *UserType // User-defined type for the response
+	Stream   bool     // Whether the response is a stream
+	UserType UserType // User-defined type for the response
 }
 
 // Text returns a human-readable representation of the response type.
 func (t RespType) Text() string {
 	if t.Stream {
 		return "stream<" + t.UserType.Text() + ">"
 	}
-	if t.UserType != nil {
-		return t.TypeName + "<" + t.UserType.Text() + ">"
-	}
-	return t.TypeName
+	return t.UserType.Text()
 }