goscript 0.0.17 → 0.0.19

package/compiler/compiler.go

@@ -303,20 +303,7 @@ 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")
@@ -641,6 +628,18 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 		default:
 			c.tsw.WriteLiterally("0")
 		}
+	case *types.Named:
+		// Handle named types, especially struct types
+		if _, isStruct := t.Underlying().(*types.Struct); isStruct {
+			// Initialize struct types with a new instance
+			c.tsw.WriteLiterallyf("new %s()", t.Obj().Name())
+			return
+		}
+		// For other named types, use the zero value of the underlying type
+		c.WriteZeroValueForType(t.Underlying())
+	case *types.Struct:
+		// For anonymous struct types, initialize with {}
+		c.tsw.WriteLiterally("{}")
 	default:
 		c.tsw.WriteLiterally("null")
 	}
@@ -752,6 +751,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("(")
@@ -810,9 +823,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 +831,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.WriteLiterallyf("'%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 +1112,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 +1202,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 +1313,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 +1493,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 +1542,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 +1568,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 {
@@ -2744,6 +2859,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 +3147,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 +3187,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 +3242,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)
@@ -3198,6 +3344,10 @@ 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.WriteCommentLinef("unhandled spec in DeclStmt: %T", spec)
 				}
@@ -4462,8 +4612,61 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 			}
 		}
 
-		// Write the left-hand side as a destructuring pattern
-		// For token.DEFINE, we've already declared any new variables above
+		
+		// First, collect all the selector expressions to identify variables that need to be initialized
+		hasSelectors := false
+		for _, lhsExpr := range lhs {
+			if _, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				hasSelectors = true
+				break
+			}
+		}
+		
+		// If we have selector expressions, we need to ensure variables are initialized
+		// before the destructuring assignment
+		if hasSelectors {
+			c.tsw.WriteLiterally("{")
+			c.tsw.WriteLine("")
+			
+			// Write a temporary variable to hold the function call result
+			c.tsw.WriteLiterally("  const _tmp = ")
+			if err := c.WriteValueExpr(callExpr); err != nil {
+				return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
+			}
+			c.tsw.WriteLine("")
+			
+			for i, lhsExpr := range lhs {
+				// Skip underscore variables
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name == "_" {
+					continue
+				}
+				
+				// Write the LHS with indentation
+				c.tsw.WriteLiterally("  ")
+				if ident, ok := lhsExpr.(*ast.Ident); ok {
+					c.WriteIdent(ident, false)
+				} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+					if err := c.WriteValueExpr(selectorExpr); err != nil {
+						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+					}
+				} else {
+					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
+				}
+				
+				// Write the assignment
+				c.tsw.WriteLiterallyf(" = _tmp[%d]", i)
+				// Always add a newline after each assignment
+				c.tsw.WriteLine("")
+			}
+			
+			// Close the block scope
+			c.tsw.WriteLiterally("}")
+			c.tsw.WriteLine("")
+			
+			return nil
+		}
+		
+		// For simple cases without selector expressions, use array destructuring
 		c.tsw.WriteLiterally("[")
 
 		for i, lhsExpr := range lhs {
@@ -4472,11 +4675,15 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 			}
 
 			if ident, ok := lhsExpr.(*ast.Ident); ok {
-				if ident.Name == "_" {
-					// For underscore variables, use empty slots in destructuring pattern
-				} else {
+				// For underscore variables, use empty slots in destructuring pattern
+				if ident.Name != "_" {
 					c.WriteIdent(ident, false)
 				}
+			} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				// Handle selector expressions (e.g., a.b) by using WriteValueExpr
+				if err := c.WriteValueExpr(selectorExpr); err != nil {
+					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+				}
 			} else {
 				// Should not happen for valid Go code in this context, but handle defensively
 				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)
@@ -5254,6 +5461,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))
@@ -5264,32 +5480,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("(")
 	}
 
@@ -5383,17 +5660,26 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 		}
 
 		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
@@ -5430,8 +5716,11 @@ 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 {
+		// 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)
 		}
 
@@ -5452,11 +5741,56 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 			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) {
@@ -5472,7 +5806,78 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 
 			c.tsw.WriteLiterally("}")
 		} else {
-			c.tsw.WriteLiterallyf("'%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
@@ -5489,7 +5894,7 @@ func (c *GoToTSCompiler) writeTypeAssertion(lhs []ast.Expr, typeAssertExpr *ast.
 
 	c.tsw.WriteLiterally(")")
 
-	if tok != token.DEFINE {
+	if tok != token.DEFINE || writeEndParen {
 		c.tsw.WriteLiterally(")")
 	}
 
@@ -5545,20 +5950,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 {
@@ -5576,7 +5968,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()")
@@ -5596,6 +5988,75 @@ 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