goscript 0.0.16 → 0.0.18

package/compiler/compiler.go

@@ -303,24 +303,11 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	case *types.Signature:
 		c.WriteSignatureType(t)
 	case *types.Struct:
-		// Generate an interface with the struct's fields
-		c.tsw.WriteLiterally("{ ")
-		// Add field properties to the interface
-		if t.NumFields() > 0 {
-			for i := 0; i < t.NumFields(); i++ {
-				field := t.Field(i)
-				if i > 0 {
-					c.tsw.WriteLiterally("; ")
-				}
-				c.tsw.WriteLiterally(field.Name() + "?: ")
-				c.WriteGoType(field.Type())
-			}
-		}
-		c.tsw.WriteLiterally(" }")
+		c.WriteStructType(t)
 	default:
 		// For other types, just write "any" and add a comment
 		c.tsw.WriteLiterally("any")
-		c.tsw.WriteCommentInline(fmt.Sprintf("unhandled type: %T", typ))
+		c.tsw.WriteCommentInlinef("unhandled type: %T", typ)
 	}
 }
 
@@ -452,7 +439,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 		if param.Name() != "" {
 			c.tsw.WriteLiterally(param.Name())
 		} else {
-			c.tsw.WriteLiterally(fmt.Sprintf("p%d", i))
+			c.tsw.WriteLiterallyf("p%d", i)
 		}
 		c.tsw.WriteLiterally(": ")
 
@@ -752,6 +739,20 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 		c.tsw.WriteLiterally(")")
 		return nil
 	case *ast.ParenExpr:
+		// Check if this is a nil pointer to struct type cast: (*struct{})(nil)
+		if starExpr, isStarExpr := exp.X.(*ast.StarExpr); isStarExpr {
+			if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+				c.tsw.WriteLiterally("null")
+				return nil
+			}
+		}
+
+		// Check if this is a type cast with nil: (SomeType)(nil)
+		if ident, isIdent := exp.X.(*ast.Ident); isIdent && ident.Name == "nil" {
+			c.tsw.WriteLiterally("null")
+			return nil
+		}
+
 		// Translate (X) to (X)
 		// If we haven't written anything in this statement yet, prepend ;
 		c.tsw.WriteLiterally("(")
@@ -763,7 +764,7 @@ func (c *GoToTSCompiler) WriteValueExpr(a ast.Expr) error {
 	case *ast.FuncLit:
 		return c.WriteFuncLitValue(exp)
 	default:
-		c.tsw.WriteCommentLine(fmt.Sprintf("unhandled value expr: %T", exp))
+		c.tsw.WriteCommentLinef("unhandled value expr: %T", exp)
 		return nil
 	}
 }
@@ -774,19 +775,19 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
 		// Check if it's a map type
 		if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+			c.tsw.WriteLiterally("$.mapGet(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return err
 			}
-			c.tsw.WriteLiterally(".get(")
+			c.tsw.WriteLiterally(", ")
 			if err := c.WriteValueExpr(exp.Index); err != nil {
 				return err
 			}
-			// Map.get() returns undefined when key not found, but Go returns zero value
-			// Add nullish coalescing with the appropriate zero value for the map's value type
-			c.tsw.WriteLiterally(") ?? ")
+			c.tsw.WriteLiterally(", ")
 
-			// Generate the zero value based on the map's value type
+			// Generate the zero value as the default value for mapGet
 			c.WriteZeroValueForType(mapType.Elem())
+			c.tsw.WriteLiterally(")")
 			return nil
 		}
 	}
@@ -810,9 +811,6 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 // context, we expect the asserted value directly. The `TypeName` string is used
 // by the runtime for error messages.
 func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
-	// Get the type name string for the asserted type
-	typeName := c.getTypeNameString(exp.Type)
-
 	// Generate a call to $.typeAssert
 	c.tsw.WriteLiterally("$.typeAssert<")
 	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
@@ -821,8 +819,23 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 		return fmt.Errorf("failed to write interface expression in type assertion expression: %w", err)
 	}
 	c.tsw.WriteLiterally(", ")
-	c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeName))
-	c.tsw.WriteLiterally(").value") // Access the value field directly in expression context
+
+	// Write the type description instead of just the type name
+	// This ensures we generate proper type info objects for all types
+
+	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
+	typeExpr := exp.Type
+	for {
+		if parenExpr, ok := typeExpr.(*ast.ParenExpr); ok {
+			typeExpr = parenExpr.X
+		} else {
+			break
+		}
+	}
+
+	c.writeTypeDescription(typeExpr)
+
+	c.tsw.WriteLiterally(")") // Just close the parenthesis, don't access .value directly
 	return nil
 }
 
@@ -1087,17 +1100,19 @@ func (c *GoToTSCompiler) WriteStarExpr(exp *ast.StarExpr) error {
 // `WriteFieldList` to generate the list of field definitions.
 // Note: This is for anonymous struct type literals. Named struct types are usually
 // handled as classes via `WriteTypeSpec`.
-func (c *GoToTSCompiler) WriteStructType(exp *ast.StructType) {
-	if typ := c.pkg.TypesInfo.TypeOf(exp); typ != nil {
-		c.WriteGoType(typ)
-		return
-	}
-
-	if exp.Fields == nil || exp.Fields.NumFields() == 0 {
-		c.tsw.WriteLiterally("{}")
-		return
+func (c *GoToTSCompiler) WriteStructType(t *types.Struct) {
+	// Generate an interface with the struct's fields
+	c.tsw.WriteLiterally("{ ")
+	// Add field properties to the interface
+	for i := range t.NumFields() {
+		field := t.Field(i)
+		if i > 0 {
+			c.tsw.WriteLiterally("; ")
+		}
+		c.tsw.WriteLiterally(field.Name() + "?: ")
+		c.WriteGoType(field.Type())
 	}
-	c.WriteFieldList(exp.Fields, false) // false = not arguments
+	c.tsw.WriteLiterally(" }")
 }
 
 // WriteFuncType translates a Go function type (`ast.FuncType`) into a TypeScript
@@ -1175,6 +1190,22 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 	expFun := exp.Fun
 
+	// Handle any type conversion with nil argument
+	if len(exp.Args) == 1 {
+		if nilIdent, isIdent := exp.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
+			// Handle nil pointer to struct type conversions: (*struct{})(nil)
+			if starExpr, isStarExpr := expFun.(*ast.StarExpr); isStarExpr {
+				if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+					c.tsw.WriteLiterally("null")
+					return nil
+				}
+			}
+
+			c.tsw.WriteLiterally("null")
+			return nil
+		}
+	}
+
 	// Handle array type conversions like []rune(string)
 	if arrayType, isArrayType := expFun.(*ast.ArrayType); isArrayType {
 		// Check if it's a []rune type
@@ -1270,7 +1301,26 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					c.tsw.WriteLiterally(", ") // Add comma for zero value argument
 
 					// Write the zero value for the channel's element type
-					c.WriteZeroValueForType(chanType.Elem())
+					if chanType.Elem().String() == "struct{}" {
+						c.tsw.WriteLiterally("{}")
+					} else {
+						c.WriteZeroValueForType(chanType.Elem())
+					}
+
+					// Add direction parameter
+					c.tsw.WriteLiterally(", ")
+
+					// Determine channel direction
+					switch chanType.Dir() {
+					case types.SendRecv:
+						c.tsw.WriteLiterally("'both'")
+					case types.SendOnly:
+						c.tsw.WriteLiterally("'send'")
+					case types.RecvOnly:
+						c.tsw.WriteLiterally("'receive'")
+					default:
+						c.tsw.WriteLiterally("'both'") // Default to bidirectional
+					}
 
 					c.tsw.WriteLiterally(")")
 					return nil // Handled make for channel
@@ -1431,6 +1481,42 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			}
 			return errors.New("unhandled byte call with incorrect number of arguments")
 		default:
+			// Check if this is a type conversion to a function type
+			if funIdent != nil {
+				if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil {
+					// Check if the object is a type name
+					if typeName, isType := obj.(*types.TypeName); isType {
+						// Make sure we have exactly one argument
+						if len(exp.Args) == 1 {
+							// Check if this is a function type
+							if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
+								// For function types, we need to add a __goTypeName property
+								c.tsw.WriteLiterally("Object.assign(")
+								
+								// Write the argument first
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for function type cast: %w", err)
+								}
+								
+								// Add the __goTypeName property with the function type name
+								c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
+								return nil // Handled function type cast
+							} else {
+								// For non-function types, use the TypeScript "as" operator
+								c.tsw.WriteLiterally("(")
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for type cast: %w", err)
+								}
+								
+								// Then use the TypeScript "as" operator with the type name
+								c.tsw.WriteLiterallyf(" as %s)", funIdent.String())
+								return nil // Handled non-function type cast
+							}
+						}
+					}
+				}
+			}
+
 			// Check if this is an async function call
 			if funIdent != nil {
 				// Get the object for this function identifier
@@ -1444,6 +1530,15 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			if err := c.WriteValueExpr(expFun); err != nil {
 				return fmt.Errorf("failed to write function expression in call: %w", err)
 			}
+
+			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+				if _, ok := funType.Underlying().(*types.Signature); ok {
+					if _, isNamed := funType.(*types.Named); isNamed {
+						c.tsw.WriteLiterally("!")
+					}
+				}
+			}
+
 			c.tsw.WriteLiterally("(")
 			for i, arg := range exp.Args {
 				if i != 0 {
@@ -1461,6 +1556,14 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		if err := c.WriteValueExpr(expFun); err != nil {
 			return fmt.Errorf("failed to write method expression in call: %w", err)
 		}
+
+		if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+			if _, ok := funType.Underlying().(*types.Signature); ok {
+				if _, isNamed := funType.(*types.Named); isNamed {
+					c.tsw.WriteLiterally("!")
+				}
+			}
+		}
 	}
 	c.tsw.WriteLiterally("(")
 	for i, arg := range exp.Args {
@@ -1709,10 +1812,10 @@ func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
 		// Use strconv.UnquoteChar to handle escape sequences correctly.
 		val, _, _, err := strconv.UnquoteChar(exp.Value[1:len(exp.Value)-1], '\'')
 		if err != nil {
-			c.tsw.WriteCommentInline(fmt.Sprintf("error parsing char literal %s: %v", exp.Value, err))
+			c.tsw.WriteCommentInlinef("error parsing char literal %s: %v", exp.Value, err)
 			c.tsw.WriteLiterally("0") // Default to 0 on error
 		} else {
-			c.tsw.WriteLiterally(fmt.Sprintf("%d", val))
+			c.tsw.WriteLiterallyf("%d", val)
 		}
 	} else {
 		// Other literals (INT, FLOAT, STRING, IMAG)
@@ -2362,7 +2465,7 @@ func (c *GoToTSCompiler) collectMethodNames(structName string) string {
 			// Check if the receiver identifier name matches the struct name
 			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == structName {
 				// Found a method for this struct
-				methodNames = append(methodNames, fmt.Sprintf("'%s'", funcDecl.Name.Name))
+				methodNames = append(methodNames, strconv.Quote(funcDecl.Name.Name))
 			}
 		}
 	}
@@ -2744,6 +2847,21 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		var initializerExpr ast.Expr
 		if hasInitializer {
 			initializerExpr = a.Values[0]
+
+			// Special case for nil pointer to struct type: (*struct{})(nil)
+			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
+				if starExpr, isStarExpr := callExpr.Fun.(*ast.StarExpr); isStarExpr {
+					if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+						// Check if the argument is nil
+						if len(callExpr.Args) == 1 {
+							if nilIdent, isIdent := callExpr.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
+								c.tsw.WriteLiterally("null")
+								return nil
+							}
+						}
+					}
+				}
+			}
 		}
 
 		if needsBox {
@@ -3017,10 +3135,17 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 			if i > 0 {
 				c.tsw.WriteLiterally(", ")
 			}
-			c.WriteField(field, true)
-			c.tsw.WriteLiterally(": ")
-			typ := c.pkg.TypesInfo.TypeOf(field.Type)
-			c.WriteGoType(typ)
+
+			// Handle multiple parameter names for the same type
+			for j, name := range field.Names {
+				if j > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.tsw.WriteLiterally(name.Name)
+				c.tsw.WriteLiterally(": ")
+				typ := c.pkg.TypesInfo.TypeOf(field.Type)
+				c.WriteGoType(typ)
+			}
 		}
 
 		// Handle the variadic parameter
@@ -3050,11 +3175,16 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 			}
 
 			if isArguments {
-				// For function parameters, write "name: type"
-				c.WriteField(field, true)
-				c.tsw.WriteLiterally(": ")
-				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ) // Use WriteGoType for parameter type
+				// For function parameters with multiple names, write each with its type
+				for j, name := range field.Names {
+					if j > 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					c.tsw.WriteLiterally(name.Name)
+					c.tsw.WriteLiterally(": ")
+					typ := c.pkg.TypesInfo.TypeOf(field.Type)
+					c.WriteGoType(typ) // Use WriteGoType for parameter type
+				}
 			} else {
 				// For struct fields and other non-argument fields
 				c.WriteField(field, false)
@@ -3100,7 +3230,11 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 		return
 	}
 
-	for _, name := range field.Names {
+	for i, name := range field.Names {
+		if i > 0 && isArguments {
+			c.tsw.WriteLiterally(", ")
+		}
+
 		// argument names: keep original casing, no access modifier
 		if isArguments {
 			c.tsw.WriteLiterally(name.Name)
@@ -3120,7 +3254,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 		if !isArguments {
 			// write tag comment if any for struct fields
 			if field.Tag != nil {
-				c.tsw.WriteCommentLine(fmt.Sprintf(" // tag: %s", field.Tag.Value))
+				c.tsw.WriteCommentLinef("tag: %s", field.Tag.Value)
 			} else {
 				c.tsw.WriteLine("") // No semicolon
 			}
@@ -3198,8 +3332,12 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 					if err := c.WriteValueSpec(valueSpec); err != nil {
 						return fmt.Errorf("failed to write value spec in declaration statement: %w", err)
 					}
+				} else if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					if err := c.WriteTypeSpec(typeSpec); err != nil {
+						return fmt.Errorf("failed to write type spec in declaration statement: %w", err)
+					}
 				} else {
-					c.tsw.WriteCommentLine(fmt.Sprintf("unhandled spec in DeclStmt: %T", spec))
+					c.tsw.WriteCommentLinef("unhandled spec in DeclStmt: %T", spec)
 				}
 			}
 		} else {
@@ -3278,7 +3416,7 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		case token.CONTINUE:
 			c.tsw.WriteLine("continue") // No semicolon needed
 		default:
-			c.tsw.WriteCommentLine(fmt.Sprintf("unhandled branch statement token: %s", exp.Tok.String()))
+			c.tsw.WriteCommentLinef("unhandled branch statement token: %s", exp.Tok.String())
 		}
 	default:
 		return errors.Errorf("unknown statement: %s\n", a)
@@ -3316,7 +3454,7 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 
 	// Set stack variable based on whether we are in an async function
 	stackVar := "__defer"
-	c.tsw.WriteLiterally(fmt.Sprintf("%s.defer(%s() => {", stackVar, asyncPrefix))
+	c.tsw.WriteLiterallyf("%s.defer(%s() => {", stackVar, asyncPrefix)
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("")
 
@@ -3418,7 +3556,7 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 			c.tsw.WriteLiterally("{") // Start object literal
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
-			c.tsw.WriteLiterally(fmt.Sprintf("id: %d,", caseID))
+			c.tsw.WriteLiterallyf("id: %d,", caseID)
 			c.tsw.WriteLine("")
 
 			// Handle different types of comm statements
@@ -3437,10 +3575,10 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 						c.tsw.WriteLiterally(",")
 						c.tsw.WriteLine("")
 					} else {
-						c.tsw.WriteCommentLine(fmt.Sprintf("unhandled RHS in select assignment case: %T", comm.Rhs[0]))
+						c.tsw.WriteCommentLinef("unhandled RHS in select assignment case: %T", comm.Rhs[0])
 					}
 				} else {
-					c.tsw.WriteCommentLine(fmt.Sprintf("unhandled RHS count in select assignment case: %d", len(comm.Rhs)))
+					c.tsw.WriteCommentLinef("unhandled RHS count in select assignment case: %d", len(comm.Rhs))
 				}
 			case *ast.ExprStmt:
 				// This is a simple receive: case <-ch:
@@ -3454,7 +3592,7 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 					c.tsw.WriteLiterally(",")
 					c.tsw.WriteLine("")
 				} else {
-					c.tsw.WriteCommentLine(fmt.Sprintf("unhandled expression in select case: %T", comm.X))
+					c.tsw.WriteCommentLinef("unhandled expression in select case: %T", comm.X)
 				}
 			case *ast.SendStmt:
 				// This is a send operation: case ch <- v:
@@ -3473,7 +3611,7 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 				c.tsw.WriteLiterally(",")
 				c.tsw.WriteLine("")
 			default:
-				c.tsw.WriteCommentLine(fmt.Sprintf("unhandled comm statement in select case: %T", comm))
+				c.tsw.WriteCommentLinef("unhandled comm statement in select case: %T", comm)
 			}
 
 			// Add the onSelected handler to execute the case body after the select resolves
@@ -3530,14 +3668,14 @@ func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
 			c.tsw.WriteLine("")
 
 		} else {
-			c.tsw.WriteCommentLine(fmt.Sprintf("unknown statement in select body: %T", stmt))
+			c.tsw.WriteCommentLinef("unknown statement in select body: %T", stmt)
 		}
 	}
 
 	// Close the array literal and the selectStatement call
 	c.tsw.Indent(-1)
 	c.tsw.WriteLiterally("], ")
-	c.tsw.WriteLiterally(fmt.Sprintf("%t", hasDefault))
+	c.tsw.WriteLiterallyf("%t", hasDefault)
 	c.tsw.WriteLiterally(")")
 	c.tsw.WriteLine("")
 
@@ -3591,7 +3729,7 @@ func (c *GoToTSCompiler) WriteStmtSwitch(exp *ast.SwitchStmt) error {
 				return fmt.Errorf("failed to write case clause in switch statement: %w", err)
 			}
 		} else {
-			c.tsw.WriteCommentLine(fmt.Sprintf("unhandled statement in switch body: %T", stmt))
+			c.tsw.WriteCommentLinef("unhandled statement in switch body: %T", stmt)
 		}
 	}
 
@@ -4547,10 +4685,11 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if !existsIsBlank {
 			c.tsw.WriteLiterally(existsName)
 			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally("$.mapHas(")
 			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
 				return err
 			}
-			c.tsw.WriteLiterally(".has(")
+			c.tsw.WriteLiterally(", ")
 			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
 				return err
 			}
@@ -4562,14 +4701,15 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if !valueIsBlank {
 			c.tsw.WriteLiterally(valueName)
 			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally("$.mapGet(")
 			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
 				return err
 			}
-			c.tsw.WriteLiterally(".get(")
+			c.tsw.WriteLiterally(", ")
 			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
 				return err
 			}
-			c.tsw.WriteLiterally(") ?? ")
+			c.tsw.WriteLiterally(", ")
 			// Write the zero value for the map's value type
 			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
 				if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
@@ -4581,27 +4721,30 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 			} else {
 				c.tsw.WriteLiterally("null")
 			}
+			c.tsw.WriteLiterally(")")
 			c.tsw.WriteLine("")
 		} else if existsIsBlank {
 			// If both are blank, still evaluate for side effects (though .has/.get are usually pure)
 			// We add a ; otherwise TypeScript thinks we are invoking a function.
-			c.tsw.WriteLiterally(";(")                            // Wrap in parens to make it an expression statement
+			c.tsw.WriteLiterally(";(") // Wrap in parens to make it an expression statement
+			c.tsw.WriteLiterally("$.mapHas(")
 			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
 				return err
 			}
-			c.tsw.WriteLiterally(".has(")
+			c.tsw.WriteLiterally(", ")
 			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
 				return err
 			}
-			c.tsw.WriteLiterally("), ")                           // Evaluate .has
+			c.tsw.WriteLiterally("), ") // Evaluate .has
+			c.tsw.WriteLiterally("$.mapGet(")
 			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
 				return err
 			}
-			c.tsw.WriteLiterally(".get(")
+			c.tsw.WriteLiterally(", ")
 			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
 				return err
 			}
-			c.tsw.WriteLiterally("))") // Evaluate .get
+			c.tsw.WriteLiterally(", null))") // Evaluate .get with null as default
 			c.tsw.WriteLine("")
 		}
 
@@ -5072,7 +5215,7 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 					indexVarName = keyIdent.Name
 				}
 			}
-			c.tsw.WriteLiterally(fmt.Sprintf("for (let %s = 0; %s < _runes.length; %s++) {", indexVarName, indexVarName, indexVarName))
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < _runes.length; %s++) {", indexVarName, indexVarName, indexVarName)
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
 			// Declare value if provided and not blank
@@ -5104,11 +5247,11 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 				}
 			}
 
-			c.tsw.WriteLiterally(fmt.Sprintf("for (let %s = 0; %s < ", indexVarName, indexVarName))
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < ", indexVarName, indexVarName)
 			if err := c.WriteValueExpr(exp.X); err != nil { // This is N
 				return fmt.Errorf("failed to write range loop integer expression: %w", err)
 			}
-			c.tsw.WriteLiterally(fmt.Sprintf("; %s++) {", indexVarName))
+			c.tsw.WriteLiterallyf("; %s++) {", indexVarName)
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
 
@@ -5139,11 +5282,11 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 		}
 		// If both key and value are provided, use an index loop and assign both
 		if exp.Key != nil && exp.Value != nil {
-			c.tsw.WriteLiterally(fmt.Sprintf("for (let %s = 0; %s < ", indexVarName, indexVarName))
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
 			if err := c.WriteValueExpr(exp.X); err != nil { // Write the expression for the iterable
 				return fmt.Errorf("failed to write range loop array/slice expression (key and value): %w", err)
 			}
-			c.tsw.WriteLiterally(fmt.Sprintf(".length; %s++) {", indexVarName))
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
 			// Declare value if not blank
@@ -5154,7 +5297,7 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 				if err := c.WriteValueExpr(exp.X); err != nil {
 					return fmt.Errorf("failed to write range loop array/slice value expression: %w", err)
 				}
-				c.tsw.WriteLiterally(fmt.Sprintf("[%s]", indexVarName)) // Use indexVarName
+				c.tsw.WriteLiterallyf("![%s]", indexVarName) // Use indexVarName with not-null assert
 				c.tsw.WriteLine("")
 			}
 			if err := c.WriteStmt(exp.Body); err != nil {
@@ -5164,12 +5307,12 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 			c.tsw.WriteLine("}")
 			return nil
 		} else if exp.Key != nil && exp.Value == nil { // Only key provided
-			c.tsw.WriteLiterally(fmt.Sprintf("for (let %s = 0; %s < ", indexVarName, indexVarName))
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
 			// Write the expression for the iterable
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return fmt.Errorf("failed to write expression for the iterable: %w", err)
 			}
-			c.tsw.WriteLiterally(fmt.Sprintf(".length; %s++) {", indexVarName))
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
 			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
@@ -5184,11 +5327,11 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 		} else {
 			// Fallback: simple index loop without declaring range variables, use _i
 			indexVarName := "_i"
-			c.tsw.WriteLiterally(fmt.Sprintf("for (let %s = 0; %s < ", indexVarName, indexVarName))
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return fmt.Errorf("failed to write range loop array/slice length expression (fallback): %w", err)
 			}
-			c.tsw.WriteLiterally(fmt.Sprintf(".length; %s++) {", indexVarName))
+			c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
 			c.tsw.Indent(1)
 			c.tsw.WriteLine("")
 			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
@@ -5249,6 +5392,15 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 	interfaceExpr := typeAssertExpr.X
 	assertedType := typeAssertExpr.Type
 
+	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
+	for {
+		if parenExpr, ok := assertedType.(*ast.ParenExpr); ok {
+			assertedType = parenExpr.X
+		} else {
+			break
+		}
+	}
+
 	// Ensure LHS has exactly two expressions (value and ok)
 	if len(lhs) != 2 {
 		return fmt.Errorf("type assertion assignment requires exactly 2 variables on LHS, got %d", len(lhs))
@@ -5259,32 +5411,93 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 	okIsBlank := false
 	var valueName string
 	var okName string
+	var valueIdent *ast.Ident
+	var okIdent *ast.Ident
 
-	if valIdent, ok := lhs[0].(*ast.Ident); ok {
-		if valIdent.Name == "_" {
+	if valId, ok := lhs[0].(*ast.Ident); ok {
+		valueIdent = valId
+		if valId.Name == "_" {
 			valueIsBlank = true
 		} else {
-			valueName = valIdent.Name
+			valueName = valId.Name
 		}
 	} else {
 		return fmt.Errorf("unhandled LHS expression type for value in type assertion: %T", lhs[0])
 	}
 
-	if okIdent, ok := lhs[1].(*ast.Ident); ok {
-		if okIdent.Name == "_" {
+	if okId, ok := lhs[1].(*ast.Ident); ok {
+		okIdent = okId
+		if okId.Name == "_" {
 			okIsBlank = true
 		} else {
-			okName = okIdent.Name
+			okName = okId.Name
 		}
 	} else {
 		return fmt.Errorf("unhandled LHS expression type for ok in type assertion: %T", lhs[1])
 	}
 
-	// Generate the destructuring assignment
+	// For token.DEFINE (:=), we need to check if any of the variables are already declared
+	// In Go, := can be used for redeclaration if at least one variable is new
+	writeEndParen := false
 	if tok == token.DEFINE {
-		c.tsw.WriteLiterally("let ")
+		// Identify which variables are new vs existing
+		valueIsNew := true
+		okIsNew := true
+		anyNewVars := false
+		allNewVars := true
+
+		// Check if variables are already in scope
+		if !valueIsBlank {
+			if obj := c.pkg.TypesInfo.Uses[valueIdent]; obj != nil {
+				// If it's in Uses, it's referenced elsewhere, so it exists
+				valueIsNew = false
+				allNewVars = false
+			}
+			if valueIsNew {
+				anyNewVars = true
+			}
+		}
+
+		if !okIsBlank {
+			if obj := c.pkg.TypesInfo.Uses[okIdent]; obj != nil {
+				// If it's in Uses, it's referenced elsewhere, so it exists
+				okIsNew = false
+				allNewVars = false
+			}
+			if okIsNew {
+				anyNewVars = true
+			}
+		}
+
+		if allNewVars && anyNewVars {
+			c.tsw.WriteLiterally("let ")
+		} else if anyNewVars {
+			// If only some variables are new, declare them separately
+			if !valueIsBlank && valueIsNew {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(valueName)
+				// Add type annotation if possible
+				if tv, ok := c.pkg.TypesInfo.Types[assertedType]; ok {
+					c.tsw.WriteLiterally(": ")
+					c.WriteGoType(tv.Type)
+				}
+				c.tsw.WriteLine("")
+			}
+			if !okIsBlank && okIsNew {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(okName)
+				c.tsw.WriteLiterally(": boolean") // ok is always boolean
+				c.tsw.WriteLine("")
+			}
+			// Use parenthesized destructuring assignment for existing variables
+			c.tsw.WriteLiterally(";(")
+			writeEndParen = true
+		} else {
+			// All variables exist, use parenthesized destructuring assignment
+			c.tsw.WriteLiterally(";(")
+			writeEndParen = true
+		}
 	} else {
-		// We must wrap in parenthesis.
 		c.tsw.WriteLiterally("(")
 	}
 
@@ -5319,9 +5532,9 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		c.tsw.WriteLiterally("keyType: ")
 		if ident, ok := typeExpr.Key.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
 			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", tsType))
+				c.tsw.WriteLiterallyf("'%s'", tsType)
 			} else {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", ident.Name)) // Fallback
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
 			}
 		} else {
 			c.writeTypeDescription(typeExpr.Key)
@@ -5333,9 +5546,9 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		c.tsw.WriteLiterally("elemType: ")
 		if ident, ok := typeExpr.Value.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
 			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", tsType))
+				c.tsw.WriteLiterallyf("'%s'", tsType)
 			} else {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", ident.Name)) // Fallback
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
 			}
 		} else {
 			c.writeTypeDescription(typeExpr.Value)
@@ -5351,15 +5564,15 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 
 		// Create a type descriptor object
 		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally(fmt.Sprintf("kind: %s, ", typeKind))
+		c.tsw.WriteLiterallyf("kind: %s, ", typeKind)
 
 		// Add element type
 		c.tsw.WriteLiterally("elemType: ")
 		if ident, ok := typeExpr.Elt.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
 			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", tsType))
+				c.tsw.WriteLiterallyf("'%s'", tsType)
 			} else {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", ident.Name)) // Fallback
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
 			}
 		} else {
 			c.writeTypeDescription(typeExpr.Elt)
@@ -5374,21 +5587,30 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		// Get the type name if available
 		typeName := c.getTypeNameString(assertedType)
 		if typeName != "unknown" {
-			c.tsw.WriteLiterally(fmt.Sprintf(", name: '%s'", typeName))
+			c.tsw.WriteLiterallyf(", name: '%s'", typeName)
 		}
 
 		if typeExpr.Fields != nil && typeExpr.Fields.List != nil {
-			c.tsw.WriteLiterally(", fields: new Set([")
+			// Add fields property to provide type information
+			c.tsw.WriteLiterally(", fields: {")
 
-			fields := []string{}
+			hasFields := false
 			for _, field := range typeExpr.Fields.List {
-				for _, name := range field.Names {
-					fields = append(fields, fmt.Sprintf("'%s'", name.Name))
+				if len(field.Names) > 0 {
+					for _, name := range field.Names {
+						if hasFields {
+							c.tsw.WriteLiterally(", ")
+						}
+						c.tsw.WriteLiterally(fmt.Sprintf("'%s': ", name.Name))
+						c.writeTypeDescription(field.Type)
+						hasFields = true
+					}
 				}
 			}
 
-			c.tsw.WriteLiterally(strings.Join(fields, ", "))
-			c.tsw.WriteLiterally("])")
+			c.tsw.WriteLiterally("}")
+		} else {
+			c.tsw.WriteLiterally(", fields: {}")
 		}
 
 		// Add empty methods set to satisfy StructTypeInfo interface
@@ -5402,7 +5624,7 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		// Get the type name if available
 		typeName := c.getTypeNameString(assertedType)
 		if typeName != "unknown" {
-			c.tsw.WriteLiterally(fmt.Sprintf(", name: '%s'", typeName))
+			c.tsw.WriteLiterallyf(", name: '%s'", typeName)
 		}
 
 		// Add methods if available
@@ -5425,9 +5647,12 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		c.tsw.WriteLiterally("{")
 		c.tsw.WriteLiterally("kind: $.TypeKind.Pointer")
 
-		// Add element type if it's a named type
-		if ident, ok := typeExpr.X.(*ast.Ident); ok {
-			c.tsw.WriteLiterally(fmt.Sprintf(", elemType: '%s'", ident.Name))
+		// Add element type if it's a struct type or named type
+		if structType, ok := typeExpr.X.(*ast.StructType); ok {
+			c.tsw.WriteLiterally(", elemType: ")
+			c.writeTypeDescription(structType)
+		} else if ident, ok := typeExpr.X.(*ast.Ident); ok {
+			c.tsw.WriteLiterallyf(", elemType: '%s'", ident.Name)
 		}
 
 		c.tsw.WriteLiterally("}")
@@ -5439,19 +5664,64 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		c.tsw.WriteLiterally(", elemType: ")
 		if ident, ok := typeExpr.Value.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
 			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", tsType))
+				c.tsw.WriteLiterallyf("'%s'", tsType)
 			} else {
-				c.tsw.WriteLiterally(fmt.Sprintf("'%s'", ident.Name)) // Fallback
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
 			}
 		} else {
 			c.writeTypeDescription(typeExpr.Value)
 		}
 
+		c.tsw.WriteLiterally(", direction: ")
+		switch typeExpr.Dir {
+		case ast.SEND:
+			c.tsw.WriteLiterally("'send'")
+		case ast.RECV:
+			c.tsw.WriteLiterally("'receive'")
+		case ast.SEND | ast.RECV: // bidirectional
+			c.tsw.WriteLiterally("'both'")
+		default:
+			// This should not happen, but just in case
+			c.tsw.WriteLiterally("'both'")
+		}
+
 		c.tsw.WriteLiterally("}")
 	case *ast.FuncType:
-		// For function types, create a type descriptor object
+		// For function types, create a type descriptor object with params and results
 		c.tsw.WriteLiterally("{")
 		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
+		
+		// Add name if this is a named function type
+		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
+			if named, ok := namedType.(*types.Named); ok {
+				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+			}
+		}
+		
+		// Add params if present
+		if typeExpr.Params != nil && len(typeExpr.Params.List) > 0 {
+			c.tsw.WriteLiterally(", params: [")
+			for i, param := range typeExpr.Params.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(param.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		
+		// Add results if present
+		if typeExpr.Results != nil && len(typeExpr.Results.List) > 0 {
+			c.tsw.WriteLiterally(", results: [")
+			for i, result := range typeExpr.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(result.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		
 		c.tsw.WriteLiterally("}")
 	case *ast.Ident:
 		if isPrimitiveType(typeExpr.Name) {
@@ -5460,31 +5730,102 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 
 			// Use TypeScript equivalent if available
 			if tsType, ok := GoBuiltinToTypescript(typeExpr.Name); ok {
-				c.tsw.WriteLiterally(fmt.Sprintf("name: '%s'", tsType))
+				c.tsw.WriteLiterallyf("name: '%s'", tsType) // TODO: use %q?
 			} else {
-				c.tsw.WriteLiterally(fmt.Sprintf("name: '%s'", typeExpr.Name))
+				c.tsw.WriteLiterallyf("name: '%s'", typeExpr.Name)
 			}
 
 			c.tsw.WriteLiterally("}")
 		} else {
-			c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeExpr.Name))
+			// Check if this is a named function type
+			isFunctionType := false
+			if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
+				if named, ok := namedType.(*types.Named); ok {
+					if _, ok := named.Underlying().(*types.Signature); ok {
+						// This is a named function type, generate a FunctionTypeInfo
+						isFunctionType = true
+						c.tsw.WriteLiterally("{")
+						c.tsw.WriteLiterally("kind: $.TypeKind.Function")
+						c.tsw.WriteLiterallyf(", name: '%s'", typeExpr.Name)
+						
+						// Get the underlying signature
+						signature := named.Underlying().(*types.Signature)
+						
+						// Add params if present
+						params := signature.Params()
+						if params != nil && params.Len() > 0 {
+							c.tsw.WriteLiterally(", params: [")
+							for i := 0; i < params.Len(); i++ {
+								if i > 0 {
+									c.tsw.WriteLiterally(", ")
+								}
+								// Use basic type info for parameters
+								param := params.At(i)
+								c.tsw.WriteLiterally("{")
+								c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
+								
+								typeName := param.Type().String()
+								if tsType, ok := GoBuiltinToTypescript(typeName); ok {
+									c.tsw.WriteLiterallyf("name: '%s'", tsType)
+								} else {
+									c.tsw.WriteLiterallyf("name: '%s'", typeName)
+								}
+								
+								c.tsw.WriteLiterally("}")
+							}
+							c.tsw.WriteLiterally("]")
+						}
+						
+						// Add results if present
+						results := signature.Results()
+						if results != nil && results.Len() > 0 {
+							c.tsw.WriteLiterally(", results: [")
+							for i := 0; i < results.Len(); i++ {
+								if i > 0 {
+									c.tsw.WriteLiterally(", ")
+								}
+								result := results.At(i)
+								c.tsw.WriteLiterally("{")
+								c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
+								
+								typeName := result.Type().String()
+								if tsType, ok := GoBuiltinToTypescript(typeName); ok {
+									c.tsw.WriteLiterallyf("name: '%s'", tsType)
+								} else {
+									c.tsw.WriteLiterallyf("name: '%s'", typeName)
+								}
+								
+								c.tsw.WriteLiterally("}")
+							}
+							c.tsw.WriteLiterally("]")
+						}
+						
+						c.tsw.WriteLiterally("}")
+					}
+				}
+			}
+			
+			// Default case for non-function named types
+			if !isFunctionType {
+				c.tsw.WriteLiterallyf("'%s'", typeExpr.Name)
+			}
 		}
 	case *ast.SelectorExpr:
 		// For imported types like pkg.Type
 		if ident, ok := typeExpr.X.(*ast.Ident); ok {
-			c.tsw.WriteLiterally(fmt.Sprintf("'%s.%s'", ident.Name, typeExpr.Sel.Name))
+			c.tsw.WriteLiterallyf("'%s.%s'", ident.Name, typeExpr.Sel.Name)
 		} else {
-			c.tsw.WriteLiterally(fmt.Sprintf("'%s'", c.getTypeNameString(assertedType)))
+			c.tsw.WriteLiterallyf("'%s'", c.getTypeNameString(assertedType))
 		}
 	default:
 		// For other types, use the string name as before
 		typeName := c.getTypeNameString(assertedType)
-		c.tsw.WriteLiterally(fmt.Sprintf("'%s'", typeName))
+		c.tsw.WriteLiterallyf("'%s'", typeName)
 	}
 
 	c.tsw.WriteLiterally(")")
 
-	if tok != token.DEFINE {
+	if tok != token.DEFINE || writeEndParen {
 		c.tsw.WriteLiterally(")")
 	}
 
@@ -5506,22 +5847,22 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 			if tsType, ok := GoBuiltinToTypescript(t.Name); ok {
 				c.tsw.WriteLiterally("{")
 				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-				c.tsw.WriteLiterally(fmt.Sprintf("name: '%s'", tsType))
+				c.tsw.WriteLiterallyf("name: '%s'", tsType)
 				c.tsw.WriteLiterally("}")
 			} else {
 				// Fallback for other primitive types
 				c.tsw.WriteLiterally("{")
 				c.tsw.WriteLiterally("kind: $.TypeKind.Basic, ")
-				c.tsw.WriteLiterally(fmt.Sprintf("name: '%s'", t.Name))
+				c.tsw.WriteLiterallyf("name: '%s'", t.Name)
 				c.tsw.WriteLiterally("}")
 			}
 		} else {
 			// For named types, just use the name string
-			c.tsw.WriteLiterally(fmt.Sprintf("'%s'", t.Name))
+			c.tsw.WriteLiterallyf("'%s'", t.Name)
 		}
 	case *ast.SelectorExpr:
 		if ident, ok := t.X.(*ast.Ident); ok {
-			c.tsw.WriteLiterally(fmt.Sprintf("'%s.%s'", ident.Name, t.Sel.Name))
+			c.tsw.WriteLiterallyf("'%s.%s'", ident.Name, t.Sel.Name)
 		}
 	case *ast.ArrayType:
 		typeKind := "$.TypeKind.Slice"
@@ -5530,7 +5871,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 		}
 
 		c.tsw.WriteLiterally("{")
-		c.tsw.WriteLiterally(fmt.Sprintf("kind: %s, ", typeKind))
+		c.tsw.WriteLiterallyf("kind: %s, ", typeKind)
 		c.tsw.WriteLiterally("elemType: ")
 		c.writeTypeDescription(t.Elt)
 		c.tsw.WriteLiterally("}")
@@ -5540,20 +5881,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 
 		// Add field names and types to the struct type info
 		if t.Fields != nil && t.Fields.List != nil {
-			c.tsw.WriteLiterally("fields: new Set([")
-
-			fields := []string{}
-			for _, field := range t.Fields.List {
-				for _, name := range field.Names {
-					fields = append(fields, fmt.Sprintf("'%s'", name.Name))
-				}
-			}
-
-			c.tsw.WriteLiterally(strings.Join(fields, ", "))
-			c.tsw.WriteLiterally("]), ")
-
-			// Add fieldTypes property to provide type information
-			c.tsw.WriteLiterally("fieldTypes: {")
+			c.tsw.WriteLiterally("fields: {")
 
 			hasFields := false
 			for _, field := range t.Fields.List {
@@ -5562,7 +5890,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 						if hasFields {
 							c.tsw.WriteLiterally(", ")
 						}
-						c.tsw.WriteLiterally(fmt.Sprintf("'%s': ", name.Name))
+						c.tsw.WriteLiterallyf("'%s': ", name.Name)
 						c.writeTypeDescription(field.Type)
 						hasFields = true
 					}
@@ -5571,7 +5899,7 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 
 			c.tsw.WriteLiterally("}, ")
 		} else {
-			c.tsw.WriteLiterally("fields: new Set(), ")
+			c.tsw.WriteLiterally("fields: {}, ")
 		}
 
 		c.tsw.WriteLiterally("methods: new Set()")
@@ -5591,10 +5919,79 @@ func (c *GoToTSCompiler) writeTypeDescription(typeExpr ast.Expr) {
 		c.tsw.WriteLiterally("kind: $.TypeKind.Pointer, ")
 		c.tsw.WriteLiterally("elemType: ")
 		c.writeTypeDescription(t.X)
+		c.tsw.WriteLiterally("}")
+	case *ast.FuncType:
+		// For function types, create a type descriptor object with params and results
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Function")
+		
+		// Add name if this is a named function type
+		if namedType := c.pkg.TypesInfo.TypeOf(typeExpr); namedType != nil {
+			if named, ok := namedType.(*types.Named); ok {
+				c.tsw.WriteLiterallyf(", name: '%s'", named.Obj().Name())
+			}
+		}
+		
+		// Add params if present
+		if t.Params != nil && len(t.Params.List) > 0 {
+			c.tsw.WriteLiterally(", params: [")
+			for i, param := range t.Params.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(param.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		
+		// Add results if present
+		if t.Results != nil && len(t.Results.List) > 0 {
+			c.tsw.WriteLiterally(", results: [")
+			for i, result := range t.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.writeTypeDescription(result.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		
+		c.tsw.WriteLiterally("}")
+		return
+	case *ast.ChanType:
+		c.tsw.WriteLiterally("{")
+		c.tsw.WriteLiterally("kind: $.TypeKind.Channel, ")
+		c.tsw.WriteLiterally("elemType: ")
+
+		// Add element type
+		if ident, ok := t.Value.(*ast.Ident); ok && isPrimitiveType(ident.Name) {
+			if tsType, ok := GoBuiltinToTypescript(ident.Name); ok {
+				c.tsw.WriteLiterallyf("'%s'", tsType)
+			} else {
+				c.tsw.WriteLiterallyf("'%s'", ident.Name) // Fallback
+			}
+		} else {
+			c.writeTypeDescription(t.Value)
+		}
+
+		// Add direction
+		c.tsw.WriteLiterally(", direction: ")
+		switch t.Dir {
+		case ast.SEND:
+			c.tsw.WriteLiterally("'send'")
+		case ast.RECV:
+			c.tsw.WriteLiterally("'receive'")
+		case ast.SEND | ast.RECV: // bidirectional
+			c.tsw.WriteLiterally("'both'")
+		default:
+			// This should not happen, but just in case
+			c.tsw.WriteLiterally("'both'")
+		}
+
 		c.tsw.WriteLiterally("}")
 	default:
 		// For other types, use the string representation
-		c.tsw.WriteLiterally(fmt.Sprintf("'%s'", c.getTypeNameString(typeExpr)))
+		c.tsw.WriteLiterallyf("'%s'", c.getTypeNameString(typeExpr))
 	}
 }