goscript 0.0.31 → 0.0.33

package/compiler/expr-call.go

@@ -378,8 +378,170 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 									c.tsw.WriteLiterally(")")
 									return nil // Handled make for named slice type
 								}
+
+								// Handle named types with map underlying types: make(NamedMapType)
+								if mapType, isMap := namedType.Underlying().(*types.Map); isMap {
+									c.tsw.WriteLiterally("$.makeMap<")
+									c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
+									c.tsw.WriteLiterally(", ")
+									c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
+									c.tsw.WriteLiterally(">()")
+									return nil // Handled make for named map type
+								}
+
+								// Handle named types with channel underlying types: make(NamedChannelType, bufferSize)
+								if chanType, isChan := namedType.Underlying().(*types.Chan); isChan {
+									c.tsw.WriteLiterally("$.makeChannel<")
+									c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+									c.tsw.WriteLiterally(">(")
+
+									// If buffer size is provided, add it
+									if len(exp.Args) >= 2 {
+										if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+											return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+										}
+									} else {
+										// Default to 0 (unbuffered channel)
+										c.tsw.WriteLiterally("0")
+									}
+
+									c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+									// Write the zero value for the channel's element type
+									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 named channel type
+								}
+							}
+						}
+					}
+				}
+			}
+			// Handle instantiated generic types: make(GenericType[TypeArg], ...)
+			// This handles cases like: make(Ints[int64]) where Ints[T] is a generic type
+			if indexExpr, ok := exp.Args[0].(*ast.IndexExpr); ok {
+				// Get the type information for the instantiated generic type
+				if typ := c.pkg.TypesInfo.TypeOf(indexExpr); typ != nil {
+					// Check the underlying type of the instantiated generic type
+					underlying := typ.Underlying()
+
+					// Handle instantiated generic map types: make(GenericMap[K, V])
+					if mapType, isMap := underlying.(*types.Map); isMap {
+						c.tsw.WriteLiterally("$.makeMap<")
+						c.WriteGoType(mapType.Key(), GoTypeContextGeneral) // Write the key type
+						c.tsw.WriteLiterally(", ")
+						c.WriteGoType(mapType.Elem(), GoTypeContextGeneral) // Write the value type
+						c.tsw.WriteLiterally(">()")
+						return nil // Handled make for instantiated generic map type
+					}
+
+					// Handle instantiated generic slice types: make(GenericSlice[T], len, cap)
+					if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+						goElemType := sliceType.Elem()
+
+						// Check if it's an instantiated generic type with []byte underlying type
+						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+							c.tsw.WriteLiterally("new Uint8Array(")
+							if len(exp.Args) >= 2 {
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+								// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+							} else {
+								// If no length is provided, default to 0
+								c.tsw.WriteLiterally("0")
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled make for instantiated generic []byte type
+						}
+
+						// Handle other instantiated generic slice types
+						c.tsw.WriteLiterally("$.makeSlice<")
+						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+						c.tsw.WriteLiterally(">(")
+
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							if len(exp.Args) == 3 {
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+							} else if len(exp.Args) > 3 {
+								return errors.New("makeSlice expects 2 or 3 arguments")
+							}
+						} else {
+							// If no length is provided, default to 0
+							c.tsw.WriteLiterally("0")
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for instantiated generic slice type
+					}
+
+					// Handle instantiated generic channel types: make(GenericChannel[T], bufferSize)
+					if chanType, isChan := underlying.(*types.Chan); isChan {
+						c.tsw.WriteLiterally("$.makeChannel<")
+						c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">(")
+
+						// If buffer size is provided, add it
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+								return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
 							}
+						} else {
+							// Default to 0 (unbuffered channel)
+							c.tsw.WriteLiterally("0")
+						}
+
+						c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+						// Write the zero value for the channel's element type
+						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 instantiated generic channel type
 					}
 				}
 			}

package/compiler/spec.go

@@ -414,6 +414,12 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 		if err := c.WriteValueExpr(a.Name); err != nil {
 			return err
 		}
+
+		// Write type parameters if present (for generics)
+		if a.TypeParams != nil {
+			c.WriteTypeParameters(a.TypeParams)
+		}
+
 		c.tsw.WriteLiterally(" = ")
 		c.WriteTypeExpr(a.Type) // The aliased type
 		c.tsw.WriteLine(";")

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",