goscript 0.0.33 → 0.0.35

package/compiler/expr-call.go

@@ -206,17 +206,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 					// Check if it's make([]byte, ...)
 					if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-						c.tsw.WriteLiterally("new Uint8Array(")
-						if len(exp.Args) >= 2 {
+						// Check if capacity is different from length
+						if len(exp.Args) == 3 {
+							// make([]byte, len, cap) - need to handle capacity
+							c.tsw.WriteLiterally("$.makeSlice<number>(")
 							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)
+							c.tsw.WriteLiterally(", ")
+							if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+								return err
+							}
+							c.tsw.WriteLiterally(", 'byte')")
 						} else {
-							// If no length is provided, default to 0
-							c.tsw.WriteLiterally("0")
+							// make([]byte, len) - capacity equals length, use Uint8Array
+							c.tsw.WriteLiterally("new Uint8Array(")
+							if len(exp.Args) >= 2 {
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+							} else {
+								// If no length is provided, default to 0
+								c.tsw.WriteLiterally("0")
+							}
+							c.tsw.WriteLiterally(")")
 						}
-						c.tsw.WriteLiterally(")")
 						return nil // Handled make for []byte
 					}
 
@@ -251,11 +265,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 					c.tsw.WriteLiterally(">(")
 
+					hasCapacity := len(exp.Args) == 3
+
 					if len(exp.Args) >= 2 {
 						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 							return err
 						}
-						if len(exp.Args) == 3 {
+						if hasCapacity {
 							c.tsw.WriteLiterally(", ")
 							if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 								return err
@@ -267,6 +283,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						// If no length is provided, default to 0
 						c.tsw.WriteLiterally("0")
 					}
+
+					// Add type hint for proper zero value initialization
+					typeHint := c.getTypeHintForSliceElement(goElemType)
+					if typeHint != "" {
+						if !hasCapacity {
+							// If no capacity was provided, add undefined for capacity parameter
+							c.tsw.WriteLiterally(", undefined")
+						}
+						c.tsw.WriteLiterally(", '")
+						c.tsw.WriteLiterally(typeHint)
+						c.tsw.WriteLiterally("'")
+					}
+
 					c.tsw.WriteLiterally(")")
 					return nil // Handled make for slice
 				}
@@ -291,17 +320,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 											if elemType != nil {
 												// Check if it's make(S, ...) where S constrains to []byte
 												if basicElem, isBasic := elemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
-													c.tsw.WriteLiterally("new Uint8Array(")
-													if len(exp.Args) >= 2 {
+													// Check if capacity is different from length
+													if len(exp.Args) == 3 {
+														// make([]byte, len, cap) - need to handle capacity
+														c.tsw.WriteLiterally("$.makeSlice<number>(")
 														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)
+														c.tsw.WriteLiterally(", ")
+														if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+															return err
+														}
+														c.tsw.WriteLiterally(", 'byte')")
 													} else {
-														// If no length is provided, default to 0
-														c.tsw.WriteLiterally("0")
+														// make([]byte, len) - capacity equals length, use Uint8Array
+														c.tsw.WriteLiterally("new Uint8Array(")
+														if len(exp.Args) >= 2 {
+															if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+																return err
+															}
+														} else {
+															// If no length is provided, default to 0
+															c.tsw.WriteLiterally("0")
+														}
+														c.tsw.WriteLiterally(")")
 													}
-													c.tsw.WriteLiterally(")")
 													return nil // Handled make for generic []byte
 												}
 
@@ -309,11 +352,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 												c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type
 												c.tsw.WriteLiterally(">(")
 
+												hasCapacity := len(exp.Args) == 3
+
 												if len(exp.Args) >= 2 {
 													if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 														return err
 													}
-													if len(exp.Args) == 3 {
+													if hasCapacity {
 														c.tsw.WriteLiterally(", ")
 														if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 															return err
@@ -325,6 +370,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 													// If no length is provided, default to 0
 													c.tsw.WriteLiterally("0")
 												}
+
+												// Add type hint for proper zero value initialization
+												typeHint := c.getTypeHintForSliceElement(elemType)
+												if typeHint != "" {
+													if !hasCapacity {
+														// If no capacity was provided, add undefined for capacity parameter
+														c.tsw.WriteLiterally(", undefined")
+													}
+													c.tsw.WriteLiterally(", '")
+													c.tsw.WriteLiterally(typeHint)
+													c.tsw.WriteLiterally("'")
+												}
+
 												c.tsw.WriteLiterally(")")
 												return nil // Handled make for generic slice
 											}
@@ -340,17 +398,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 									// Check if it's a named 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 {
+										// Check if capacity is different from length
+										if len(exp.Args) == 3 {
+											// make([]byte, len, cap) - need to handle capacity
+											c.tsw.WriteLiterally("$.makeSlice<number>(")
 											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)
+											c.tsw.WriteLiterally(", ")
+											if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+												return err
+											}
+											c.tsw.WriteLiterally(", 'byte')")
 										} else {
-											// If no length is provided, default to 0
-											c.tsw.WriteLiterally("0")
+											// make([]byte, len) - capacity equals length, use Uint8Array
+											c.tsw.WriteLiterally("new Uint8Array(")
+											if len(exp.Args) >= 2 {
+												if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+													return err
+												}
+											} else {
+												// If no length is provided, default to 0
+												c.tsw.WriteLiterally("0")
+											}
+											c.tsw.WriteLiterally(")")
 										}
-										c.tsw.WriteLiterally(")")
 										return nil // Handled make for named []byte type
 									}
 
@@ -359,11 +431,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 									c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 									c.tsw.WriteLiterally(">(")
 
+									hasCapacity := len(exp.Args) == 3
+
 									if len(exp.Args) >= 2 {
 										if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 											return err
 										}
-										if len(exp.Args) == 3 {
+										if hasCapacity {
 											c.tsw.WriteLiterally(", ")
 											if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 												return err
@@ -375,6 +449,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 										// If no length is provided, default to 0
 										c.tsw.WriteLiterally("0")
 									}
+
+									// Add type hint for proper zero value initialization
+									typeHint := c.getTypeHintForSliceElement(goElemType)
+									if typeHint != "" {
+										if !hasCapacity {
+											// If no capacity was provided, add undefined for capacity parameter
+											c.tsw.WriteLiterally(", undefined")
+										}
+										c.tsw.WriteLiterally(", '")
+										c.tsw.WriteLiterally(typeHint)
+										c.tsw.WriteLiterally("'")
+									}
+
 									c.tsw.WriteLiterally(")")
 									return nil // Handled make for named slice type
 								}
@@ -461,17 +548,31 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 						// 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 {
+							// Check if capacity is different from length
+							if len(exp.Args) == 3 {
+								// make([]byte, len, cap) - need to handle capacity
+								c.tsw.WriteLiterally("$.makeSlice<number>(")
 								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)
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+								c.tsw.WriteLiterally(", 'byte')")
 							} else {
-								// If no length is provided, default to 0
-								c.tsw.WriteLiterally("0")
+								// make([]byte, len) - capacity equals length, use Uint8Array
+								c.tsw.WriteLiterally("new Uint8Array(")
+								if len(exp.Args) >= 2 {
+									if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+										return err
+									}
+								} else {
+									// If no length is provided, default to 0
+									c.tsw.WriteLiterally("0")
+								}
+								c.tsw.WriteLiterally(")")
 							}
-							c.tsw.WriteLiterally(")")
 							return nil // Handled make for instantiated generic []byte type
 						}
 
@@ -480,11 +581,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 						c.tsw.WriteLiterally(">(")
 
+						hasCapacity := len(exp.Args) == 3
+
 						if len(exp.Args) >= 2 {
 							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
 								return err
 							}
-							if len(exp.Args) == 3 {
+							if hasCapacity {
 								c.tsw.WriteLiterally(", ")
 								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
 									return err
@@ -496,6 +599,19 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 							// If no length is provided, default to 0
 							c.tsw.WriteLiterally("0")
 						}
+
+						// Add type hint for proper zero value initialization
+						typeHint := c.getTypeHintForSliceElement(goElemType)
+						if typeHint != "" {
+							if !hasCapacity {
+								// If no capacity was provided, add undefined for capacity parameter
+								c.tsw.WriteLiterally(", undefined")
+							}
+							c.tsw.WriteLiterally(", '")
+							c.tsw.WriteLiterally(typeHint)
+							c.tsw.WriteLiterally("'")
+						}
+
 						c.tsw.WriteLiterally(")")
 						return nil // Handled make for instantiated generic slice type
 					}
@@ -545,6 +661,143 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					}
 				}
 			}
+			// Handle selector expressions: make(pkg.TypeName, ...)
+			// This handles cases like: make(fstest.MapFS) where fstest.MapFS is map[string]*MapFile
+			if selectorExpr, ok := exp.Args[0].(*ast.SelectorExpr); ok {
+				// Get the type information for the selector expression
+				if typ := c.pkg.TypesInfo.TypeOf(selectorExpr); typ != nil {
+					// Check the underlying type of the selector expression
+					underlying := typ.Underlying()
+
+					// Handle selector expression map types: make(pkg.MapType)
+					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 selector expression map type
+					}
+
+					// Handle selector expression slice types: make(pkg.SliceType, len, cap)
+					if sliceType, isSlice := underlying.(*types.Slice); isSlice {
+						goElemType := sliceType.Elem()
+
+						// Check if it's a selector expression with []byte underlying type
+						if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+							// Check if capacity is different from length
+							if len(exp.Args) == 3 {
+								// make([]byte, len, cap) - need to handle capacity
+								c.tsw.WriteLiterally("$.makeSlice<number>(")
+								if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+									return err
+								}
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+									return err
+								}
+								c.tsw.WriteLiterally(", 'byte')")
+							} else {
+								// make([]byte, len) - capacity equals length, use Uint8Array
+								c.tsw.WriteLiterally("new Uint8Array(")
+								if len(exp.Args) >= 2 {
+									if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+										return err
+									}
+								} else {
+									// If no length is provided, default to 0
+									c.tsw.WriteLiterally("0")
+								}
+								c.tsw.WriteLiterally(")")
+							}
+							return nil // Handled make for selector expression []byte type
+						}
+
+						// Handle other selector expression slice types
+						c.tsw.WriteLiterally("$.makeSlice<")
+						c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+						c.tsw.WriteLiterally(">(")
+
+						hasCapacity := len(exp.Args) == 3
+
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							if hasCapacity {
+								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")
+						}
+
+						// Add type hint for proper zero value initialization
+						typeHint := c.getTypeHintForSliceElement(goElemType)
+						if typeHint != "" {
+							if !hasCapacity {
+								// If no capacity was provided, add undefined for capacity parameter
+								c.tsw.WriteLiterally(", undefined")
+							}
+							c.tsw.WriteLiterally(", '")
+							c.tsw.WriteLiterally(typeHint)
+							c.tsw.WriteLiterally("'")
+						}
+
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for selector expression slice type
+					}
+
+					// Handle selector expression channel types: make(pkg.ChannelType, 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 selector expression channel type
+					}
+				}
+			}
 			// Fallthrough for unhandled make calls (e.g., channels)
 			return errors.New("unhandled make call")
 		case "string":
@@ -666,6 +919,40 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					if i > 0 || len(exp.Args) > 1 { // Add comma before elements if there are any
 						c.tsw.WriteLiterally(", ")
 					}
+
+					// Special case: append([]byte, string...) should convert string to bytes
+					if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+						// Check if the slice is []byte and the argument is a string
+						sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+						argType := c.pkg.TypesInfo.TypeOf(arg)
+
+						if sliceType != nil && argType != nil {
+							// Check if slice is []byte (Uint8Array)
+							isSliceOfBytes := false
+							if sliceUnder, ok := sliceType.Underlying().(*types.Slice); ok {
+								if basicElem, ok := sliceUnder.Elem().(*types.Basic); ok && basicElem.Kind() == types.Uint8 {
+									isSliceOfBytes = true
+								}
+							}
+
+							// Check if argument is string (including untyped string)
+							isArgString := false
+							if basicArg, ok := argType.Underlying().(*types.Basic); ok && (basicArg.Kind() == types.String || basicArg.Kind() == types.UntypedString) {
+								isArgString = true
+							}
+
+							if isSliceOfBytes && isArgString {
+								// Convert string to bytes: append([]byte, string...) -> $.append(slice, ...$.stringToBytes(string))
+								c.tsw.WriteLiterally("...$.stringToBytes(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write string argument in append call: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								continue
+							}
+						}
+					}
+
 					if err := c.WriteValueExpr(arg); err != nil {
 						return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
 					}
@@ -879,12 +1166,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Not an identifier (e.g., method call on a value)
+			// Not an identifier (e.g., method call on a value, function call result)
 			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 {
+			// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+			// Add non-null assertion since the returned function could be null
+			if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+				c.tsw.WriteLiterally("!")
+			} else if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
 				if _, ok := funType.Underlying().(*types.Signature); ok {
 					// Check if this is a function parameter identifier that needs not-null assertion
 					if ident, isIdent := expFun.(*ast.Ident); isIdent {
@@ -899,6 +1190,13 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					} else if _, isNamed := funType.(*types.Named); isNamed {
 						c.tsw.WriteLiterally("!")
 					}
+				} else {
+					// Check if the function type is nullable (e.g., func(...) | null)
+					// This handles cases where a function call returns a nullable function
+					funTypeStr := funType.String()
+					if strings.Contains(funTypeStr, "| null") || strings.Contains(funTypeStr, "null |") {
+						c.tsw.WriteLiterally("!")
+					}
 				}
 			}
 		}
@@ -1004,3 +1302,22 @@ func hasMixedStringByteConstraint(iface *types.Interface) bool {
 	// Return true only if we have both string and []byte in the constraint
 	return hasString && hasByteSlice
 }
+
+// getTypeHintForSliceElement returns the appropriate type hint for makeSlice based on the Go element type
+func (c *GoToTSCompiler) getTypeHintForSliceElement(elemType types.Type) string {
+	if basicType, isBasic := elemType.(*types.Basic); isBasic {
+		switch basicType.Kind() {
+		case types.Int, types.Int8, types.Int16, types.Int32, types.Int64,
+			types.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64,
+			types.Float32, types.Float64, types.Complex64, types.Complex128:
+			return "number"
+		case types.Bool:
+			return "boolean"
+		case types.String:
+			return "string"
+		}
+	}
+	// For other types (structs, interfaces, pointers, etc.), don't provide a hint
+	// This will use the default null initialization which is appropriate for object types
+	return ""
+}

package/compiler/expr-selector.go

@@ -129,7 +129,33 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	// Add null assertion for selector expressions when accessing fields/methods on nullable types
 	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
 	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
-	if baseType != nil {
+
+	// Special case: Check if this is a method receiver alias (e.g., `b` in `const b = this`)
+	// In this case, we should use regular field access instead of pointer access
+	isMethodReceiverAlias := false
+	if baseIdent, ok := exp.X.(*ast.Ident); ok {
+		// Check if this identifier refers to a method receiver
+		// Method receivers are typically named variables that alias `this`
+		if obj := c.pkg.TypesInfo.ObjectOf(baseIdent); obj != nil {
+			if varObj, ok := obj.(*types.Var); ok {
+				// Check if this is a local variable in a method context
+				// Method receiver aliases are local variables with pointer types that represent `this`
+				if _, isPtr := varObj.Type().(*types.Pointer); isPtr {
+					// Additional check: only consider it a method receiver alias if the variable name
+					// suggests it's an alias (single letter names are common for aliases like `b`, `r`, etc.)
+					// and it's not a common variable name like `f` which is often used for regular variables
+					varName := baseIdent.Name
+					if len(varName) == 1 && varName != "f" {
+						// This is likely a method receiver alias like `const b = this`
+						// We should treat it as a regular object access, not a pointer access
+						isMethodReceiverAlias = true
+					}
+				}
+			}
+		}
+	}
+
+	if baseType != nil && !isMethodReceiverAlias {
 		// Check if the base is a pointer type
 		if _, isPtr := baseType.(*types.Pointer); isPtr {
 			c.tsw.WriteLiterally("!.")
@@ -145,7 +171,7 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 			c.tsw.WriteLiterally(".")
 		}
 	} else {
-		// Add .
+		// Add . (either baseType is nil or this is a method receiver alias)
 		c.tsw.WriteLiterally(".")
 	}