feat: suppress export statements in functions

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

compiler/analysis.go

@@ -56,6 +56,7 @@ type NodeInfo struct {
 	IsBareReturn      bool
 	EnclosingFuncDecl *ast.FuncDecl
 	EnclosingFuncLit  *ast.FuncLit
+	IsInsideFunction  bool // true if this declaration is inside a function body
 }
 
 // Analysis holds information gathered during the analysis phase of the Go code compilation.
@@ -689,6 +690,25 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 		return v // Continue traversal
+
+	case *ast.DeclStmt:
+		// Handle declarations inside functions (const, var, type declarations within function bodies)
+		// These should not have export modifiers in TypeScript
+		if genDecl, ok := n.Decl.(*ast.GenDecl); ok {
+			// Check if we're inside a function (either FuncDecl or FuncLit)
+			isInsideFunction := v.currentFuncDecl != nil || v.currentFuncLit != nil
+
+			if isInsideFunction {
+				// Mark all specs in this declaration as being inside a function
+				for _, spec := range genDecl.Specs {
+					if v.analysis.NodeData[spec] == nil {
+						v.analysis.NodeData[spec] = &NodeInfo{}
+					}
+					v.analysis.NodeData[spec].IsInsideFunction = true
+				}
+			}
+		}
+		return v // Continue traversal
 	}
 
 	// For all other nodes, continue traversal

compiler/spec-value.go

@@ -81,8 +81,13 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			}
 		}
 
-		// Start declaration - add export for Go-exported symbols
-		if name.IsExported() {
+		// Start declaration - add export for Go-exported symbols (but not if inside a function)
+		isInsideFunction := false
+		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+			isInsideFunction = nodeInfo.IsInsideFunction
+		}
+
+		if name.IsExported() && !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("let ")

compiler/spec.go

@@ -165,8 +165,13 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 	case *ast.InterfaceType:
 		return c.WriteInterfaceTypeSpec(a, t)
 	default:
-		// type alias - add export for Go-exported types
-		if a.Name.IsExported() {
+		// type alias - add export for Go-exported types (but not if inside a function)
+		isInsideFunction := false
+		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+			isInsideFunction = nodeInfo.IsInsideFunction
+		}
+
+		if a.Name.IsExported() && !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("type ")
@@ -182,8 +187,13 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 
 // WriteInterfaceTypeSpec writes the TypeScript type for a Go interface type.
 func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.InterfaceType) error {
-	// Add export for Go-exported interfaces
-	if a.Name.IsExported() {
+	// Add export for Go-exported interfaces (but not if inside a function)
+	isInsideFunction := false
+	if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
+		isInsideFunction = nodeInfo.IsInsideFunction
+	}
+
+	if a.Name.IsExported() && !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 	c.tsw.WriteLiterally("type ")

compliance/WIP.md

@@ -4,10 +4,10 @@
 import * as $ from "@goscript/builtin/builtin.js";
 
 export async function main(): Promise<void> {
-	export let O_WRONLY: number = 0x1
-	export let O_CREATE: number = 0x40
-	export let O_APPEND: number = 0x400
-	export let O_TRUNC: number = 0x200
+	let O_WRONLY: number = 0x1
+	let O_CREATE: number = 0x40
+	let O_APPEND: number = 0x400
+	let O_TRUNC: number = 0x200
 	let flag = ((1 | 64) | 1024)
 	if ((flag & 1024) != 0) {
 		console.log("O_APPEND is set: Expected: O_APPEND is set, Actual: O_APPEND is set")

compliance/tests/flag_bitwise_op/actual.log

@@ -19,7 +19,7 @@ export async function main(): Promise<void> {
 	console.log(castedGreeter!("Inline World"))
 
 	// Test with a different signature
-	export type Adder = ((a: number, b: number) => number) | null;
+	type Adder = ((a: number, b: number) => number) | null;
 	let theInlineAdder = (a: number, b: number): number => {
 		return a + b
 	}