goscript 0.1.0 → 0.1.1

package/compiler/typescript-emitter.go

@@ -51,8 +51,11 @@ func (o *TypeScriptEmitOwner) Emit(
 		}}
 	}
 
+	files, diagnostics := o.EmitToMemory(ctx, program)
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, diagnostics
+	}
 	var compiled []string
-	var diagnostics []Diagnostic
 	for _, pkg := range program.packages {
 		if err := ctx.Err(); err != nil {
 			diagnostics = append(diagnostics, Diagnostic{
@@ -68,12 +71,14 @@ func (o *TypeScriptEmitOwner) Emit(
 			continue
 		}
 		for _, file := range pkg.files {
-			path := filepath.Join(pkgDir, file.outputName)
-			if err := os.WriteFile(path, []byte(o.renderLoweredFile(pkg, file)), 0o644); err != nil {
+			filePath := "@goscript/" + pkg.pkgPath + "/" + file.outputName
+			path := filepath.Join(req.OutputPath, filepath.FromSlash(filePath))
+			if err := os.WriteFile(path, []byte(files[filePath]), 0o644); err != nil {
 				diagnostics = append(diagnostics, emitError("write TypeScript file", path, err))
 			}
 		}
-		if err := os.WriteFile(filepath.Join(pkgDir, "index.ts"), []byte(renderIndex(pkg)), 0o644); err != nil {
+		indexPath := "@goscript/" + pkg.pkgPath + "/index.ts"
+		if err := os.WriteFile(filepath.Join(pkgDir, "index.ts"), []byte(files[indexPath]), 0o644); err != nil {
 			diagnostics = append(diagnostics, emitError("write package index", pkg.pkgPath, err))
 			continue
 		}
@@ -82,6 +87,34 @@ func (o *TypeScriptEmitOwner) Emit(
 	return compiled, diagnostics
 }
 
+// EmitToMemory renders a lowered program into deterministic slash-path files.
+func (o *TypeScriptEmitOwner) EmitToMemory(
+	ctx context.Context,
+	program *LoweredProgram,
+) (map[string]string, []Diagnostic) {
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+	}
+	if program == nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/emitter:no-program",
+			Message:  "TypeScript emission requires a lowered program",
+		}}
+	}
+	files := make(map[string]string)
+	for _, pkg := range program.packages {
+		if err := ctx.Err(); err != nil {
+			return files, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		for _, file := range pkg.files {
+			files["@goscript/"+pkg.pkgPath+"/"+file.outputName] = o.renderLoweredFile(pkg, file)
+		}
+		files["@goscript/"+pkg.pkgPath+"/index.ts"] = renderIndex(pkg)
+	}
+	return files, nil
+}
+
 func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *loweredFile) string {
 	var b strings.Builder
 	if file.sourcePath != "" {
@@ -102,31 +135,119 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 	if len(file.imports) != 0 {
 		b.WriteString("\n")
 	}
-	for idx, decl := range file.decls {
-		if idx != 0 {
+	hasMain := false
+	wroteDecl := false
+	writeSeparator := func() {
+		if wroteDecl {
 			b.WriteString("\n")
 		}
+		wroteDecl = true
+	}
+	writeDecl := func(decl loweredDecl) {
 		if decl.structType != nil {
+			writeSeparator()
 			renderStruct(&b, decl.structType, o.runtimeOwner)
-			continue
+			return
 		}
 		if decl.function != nil {
+			writeSeparator()
 			renderFunction(&b, decl.function)
-			if pkg.name == "main" && decl.function.name == "main" {
-				b.WriteString("\n\nif (")
-				b.WriteString(o.runtimeOwner.QualifiedHelper(RuntimeHelperIsMainScript))
-				b.WriteString("(import.meta)) {\n")
-				b.WriteString("\tawait main()\n")
-				b.WriteString("}\n")
+			if decl.function.name == "main" {
+				hasMain = true
 			}
-			continue
+			return
 		}
+		writeSeparator()
 		b.WriteString(decl.code)
 		b.WriteString("\n")
 	}
+	for _, decl := range file.decls {
+		if decl.typeIndexExport != "" && decl.code != "" {
+			writeDecl(decl)
+		}
+	}
+	for _, decl := range sortedStructDecls(file.decls) {
+		if decl.structType != nil {
+			writeDecl(decl)
+		}
+	}
+	for _, decl := range file.decls {
+		if decl.structType != nil || (decl.typeIndexExport != "" && decl.code != "") {
+			continue
+		}
+		writeDecl(decl)
+	}
+	if pkg.name == "main" && hasMain {
+		writeSeparator()
+		b.WriteString("if (")
+		b.WriteString(o.runtimeOwner.QualifiedHelper(RuntimeHelperIsMainScript))
+		b.WriteString("(import.meta)) {\n")
+		b.WriteString("\tawait main()\n")
+		b.WriteString("}\n")
+	}
 	return b.String()
 }
 
+func sortedStructDecls(decls []loweredDecl) []loweredDecl {
+	structs := make([]loweredDecl, 0)
+	names := make(map[string]bool)
+	for _, decl := range decls {
+		if decl.structType == nil {
+			continue
+		}
+		structs = append(structs, decl)
+		names[decl.structType.name] = true
+	}
+	if len(structs) < 2 {
+		return structs
+	}
+	byName := make(map[string]loweredDecl, len(structs))
+	for _, decl := range structs {
+		byName[decl.structType.name] = decl
+	}
+	visiting := make(map[string]bool, len(structs))
+	visited := make(map[string]bool, len(structs))
+	sorted := make([]loweredDecl, 0, len(structs))
+	var visit func(loweredDecl)
+	visit = func(decl loweredDecl) {
+		name := decl.structType.name
+		if visited[name] || visiting[name] {
+			return
+		}
+		visiting[name] = true
+		for _, dep := range structZeroValueDeps(decl.structType, names) {
+			if depDecl, ok := byName[dep]; ok {
+				visit(depDecl)
+			}
+		}
+		visiting[name] = false
+		visited[name] = true
+		sorted = append(sorted, decl)
+	}
+	for _, decl := range structs {
+		visit(decl)
+	}
+	return sorted
+}
+
+func structZeroValueDeps(structType *loweredStruct, names map[string]bool) []string {
+	var deps []string
+	for _, field := range structType.fields {
+		if !field.structValue {
+			continue
+		}
+		for name := range names {
+			if name == structType.name {
+				continue
+			}
+			if strings.Contains(field.zero, "new "+name+"(") {
+				deps = append(deps, name)
+			}
+		}
+	}
+	return deps
+}
+
 func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *RuntimeContractOwner) {
 	varRef := runtimeOwner.QualifiedHelper(RuntimeHelperVarRef)
 	markStructValue := runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue)
@@ -201,7 +322,9 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		b.WriteString("\n")
 	}
 	b.WriteString("\t\t}\n\t}\n\n")
-	b.WriteString("\tpublic clone(): ")
+	b.WriteString("\tpublic ")
+	b.WriteString(structType.cloneMethod)
+	b.WriteString("(): ")
 	b.WriteString(structType.name)
 	b.WriteString(" {\n\t\tconst cloned = new ")
 	b.WriteString(structType.name)
@@ -240,15 +363,19 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 	b.WriteString("(\n")
 	b.WriteString("\t\t")
 	b.WriteString(strconvQuote(structType.typeName))
-	b.WriteString(",\n\t\tnew ")
+	b.WriteString(",\n\t\t() => new ")
 	b.WriteString(structType.name)
 	b.WriteString("(),\n\t\t[")
 	for idx, method := range structType.methods {
 		if idx != 0 {
 			b.WriteString(", ")
 		}
+		methodName := method.name
+		if method.runtimeName != "" {
+			methodName = method.runtimeName
+		}
 		b.WriteString("{ name: ")
-		b.WriteString(strconvQuote(method.name))
+		b.WriteString(strconvQuote(methodName))
 		b.WriteString(", args: [], returns: [] }")
 	}
 	b.WriteString("],\n\t\t")
@@ -260,7 +387,7 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		}
 		b.WriteString(strconvQuote(field.name))
 		b.WriteString(": ")
-		b.WriteString(runtimeStructFieldInfoExpr(field.runtimeType, field.tag))
+		b.WriteString(runtimeStructFieldInfoExpr(field.runtimeType, field.runtimeName, field.tag))
 	}
 	b.WriteString("}\n\t)\n")
 	b.WriteString("}\n")
@@ -308,10 +435,22 @@ func renderFunction(b *strings.Builder, fn *loweredFunction) {
 	b.WriteString(" {\n")
 	if fn.receiverAlias != "" && fn.receiverAlias != "_" {
 		writeIndent(b, 1)
-		b.WriteString("const ")
+		if fn.receiverMutable {
+			b.WriteString("let ")
+		} else {
+			b.WriteString("const ")
+		}
 		b.WriteString(fn.receiverAlias)
-		b.WriteString(" = this\n")
+		if fn.receiverType != "" {
+			b.WriteString(": ")
+			b.WriteString(fn.receiverType)
+		}
+		b.WriteString(" = ")
+		b.WriteString(receiverValue(fn))
+		b.WriteString("\n")
 	}
+	renderStmts(b, fn.paramBindings, 1)
+	renderNamedResults(b, fn.namedResults, 1)
 	renderDeferStack(b, fn.deferState, 1)
 	renderStmts(b, fn.body, 1)
 	b.WriteString("}\n")
@@ -338,16 +477,48 @@ func renderMethod(b *strings.Builder, fn *loweredFunction) {
 	b.WriteString(" {\n")
 	if fn.receiverAlias != "" && fn.receiverAlias != "_" {
 		writeIndent(b, 2)
-		b.WriteString("const ")
+		if fn.receiverMutable {
+			b.WriteString("let ")
+		} else {
+			b.WriteString("const ")
+		}
 		b.WriteString(fn.receiverAlias)
-		b.WriteString(" = this\n")
+		if fn.receiverType != "" {
+			b.WriteString(": ")
+			b.WriteString(fn.receiverType)
+		}
+		b.WriteString(" = ")
+		b.WriteString(receiverValue(fn))
+		b.WriteString("\n")
 	}
+	renderStmts(b, fn.paramBindings, 2)
+	renderNamedResults(b, fn.namedResults, 2)
 	renderDeferStack(b, fn.deferState, 2)
 	renderStmts(b, fn.body, 2)
 	writeIndent(b, 1)
 	b.WriteString("}\n")
 }
 
+func receiverValue(fn *loweredFunction) string {
+	if fn.receiverValue != "" {
+		return fn.receiverValue
+	}
+	return "this"
+}
+
+func renderNamedResults(b *strings.Builder, results []loweredNamedResult, indent int) {
+	for _, result := range results {
+		writeIndent(b, indent)
+		b.WriteString("let ")
+		b.WriteString(result.name)
+		b.WriteString(": ")
+		b.WriteString(result.typ)
+		b.WriteString(" = ")
+		b.WriteString(result.zero)
+		b.WriteString("\n")
+	}
+}
+
 func renderDeferStack(b *strings.Builder, state *loweredDeferState, indent int) {
 	if state == nil || !state.used {
 		return
@@ -361,7 +532,7 @@ func renderDeferStack(b *strings.Builder, state *loweredDeferState, indent int)
 }
 
 func renderStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
-	for _, stmt := range stmts {
+	for idx, stmt := range stmts {
 		renderLeadingLines(b, stmt.leading, indent)
 		if stmt.rangeFunc != nil {
 			renderRangeFunc(b, stmt.rangeFunc, indent)
@@ -380,7 +551,7 @@ func renderStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
 			continue
 		}
 		writeIndent(b, indent)
-		if stmt.text == "" && len(stmt.children) != 0 {
+		if stmt.text == "" && (stmt.hasBlock || len(stmt.children) != 0) {
 			b.WriteString("{\n")
 			renderStmts(b, stmt.children, indent+1)
 			writeIndent(b, indent)
@@ -388,7 +559,10 @@ func renderStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
 			continue
 		}
 		writeIndentedText(b, stmt.text, indent)
-		if len(stmt.children) == 0 {
+		if !stmt.hasBlock && len(stmt.children) == 0 {
+			if idx+1 < len(stmts) && needsASIBarrier(stmt, stmts[idx+1]) {
+				b.WriteString(";")
+			}
 			b.WriteString("\n")
 			continue
 		}
@@ -407,6 +581,23 @@ func renderStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
 	}
 }
 
+func needsASIBarrier(current loweredStmt, next loweredStmt) bool {
+	if current.text == "" ||
+		current.hasBlock ||
+		len(current.children) != 0 ||
+		current.rangeFunc != nil ||
+		current.switchStmt != nil ||
+		current.selectStmt != nil ||
+		current.typeSwitch != nil {
+		return false
+	}
+	if strings.HasSuffix(strings.TrimSpace(current.text), ";") {
+		return false
+	}
+	nextText := strings.TrimLeft(next.text, " \t")
+	return strings.HasPrefix(nextText, "(") || strings.HasPrefix(nextText, "[")
+}
+
 func renderLeadingLines(b *strings.Builder, lines []string, indent int) {
 	for _, line := range lines {
 		if strings.TrimSpace(line) == "" {
@@ -438,39 +629,66 @@ func renderSwitch(b *strings.Builder, stmt *loweredSwitch, indent int) {
 	b.WriteString(stmt.value)
 	b.WriteString(") {\n")
 	for _, switchCase := range stmt.cases {
-		for _, value := range switchCase.values {
+		if switchCase.defaultCase {
 			writeIndent(b, indent+1)
-			b.WriteString("case ")
-			b.WriteString(value)
-			b.WriteString(":\n")
+			b.WriteString("default:\n")
+		} else {
+			for _, value := range switchCase.values {
+				writeIndent(b, indent+1)
+				b.WriteString("case ")
+				b.WriteString(value)
+				b.WriteString(":\n")
+			}
 		}
-		renderSwitchBody(b, switchCase.body, indent+1)
-	}
-	if len(stmt.defaultBody) != 0 {
-		writeIndent(b, indent+1)
-		b.WriteString("default:\n")
-		renderSwitchBody(b, stmt.defaultBody, indent+1)
+		renderSwitchBody(b, switchCase.body, switchCase.fallsThrough, indent+1)
 	}
 	writeIndent(b, indent)
 	b.WriteString("}\n")
 }
 
-func renderSwitchBody(b *strings.Builder, body []loweredStmt, indent int) {
+func renderSwitchBody(b *strings.Builder, body []loweredStmt, fallsThrough bool, indent int) {
 	writeIndent(b, indent)
 	b.WriteString("{\n")
 	renderStmts(b, body, indent+1)
-	writeIndent(b, indent+1)
-	b.WriteString("break\n")
+	if !fallsThrough {
+		writeIndent(b, indent+1)
+		b.WriteString("break\n")
+	}
 	writeIndent(b, indent)
 	b.WriteString("}\n")
 }
 
 func renderRangeFunc(b *strings.Builder, stmt *loweredRangeFunc, indent int) {
+	if stmt.returnBranch != nil {
+		writeIndent(b, indent)
+		b.WriteString("let ")
+		b.WriteString(stmt.returnBranch.hasReturn)
+		b.WriteString(" = false\n")
+		if stmt.returnBranch.value != "" {
+			writeIndent(b, indent)
+			b.WriteString("let ")
+			b.WriteString(stmt.returnBranch.value)
+			b.WriteString(": ")
+			b.WriteString(stmt.returnBranch.resultType)
+			b.WriteString(" | undefined\n")
+		}
+	}
 	writeIndent(b, indent)
-	b.WriteString(";(() => {\n")
+	if stmt.async {
+		b.WriteString(";await (async () => {\n")
+	} else {
+		b.WriteString(";(() => {\n")
+	}
 	writeIndent(b, indent+1)
+	if stmt.async {
+		b.WriteString("await ")
+	}
 	b.WriteString(stmt.value)
-	b.WriteString("!((")
+	b.WriteString("!(")
+	if stmt.async {
+		b.WriteString("async ")
+	}
+	b.WriteString("(")
 	b.WriteString(strings.Join(stmt.params, ", "))
 	b.WriteString(") => {\n")
 	renderStmts(b, stmt.body, indent+2)
@@ -480,6 +698,66 @@ func renderRangeFunc(b *strings.Builder, stmt *loweredRangeFunc, indent int) {
 	b.WriteString("})\n")
 	writeIndent(b, indent)
 	b.WriteString("})()\n")
+	if stmt.returnBranch == nil {
+		return
+	}
+	writeIndent(b, indent)
+	b.WriteString("if (")
+	b.WriteString(stmt.returnBranch.hasReturn)
+	b.WriteString(")")
+	if stmt.parentBranch != nil {
+		b.WriteString(" {\n")
+		writeIndent(b, indent+1)
+		b.WriteString(stmt.parentBranch.hasReturn)
+		b.WriteString(" = true\n")
+		if stmt.parentBranch.value != "" && stmt.returnBranch.value != "" {
+			writeIndent(b, indent+1)
+			b.WriteString(stmt.parentBranch.value)
+			b.WriteString(" = ")
+			b.WriteString(stmt.returnBranch.value)
+			b.WriteString("!\n")
+		}
+		writeIndent(b, indent+1)
+		b.WriteString("return false\n")
+		writeIndent(b, indent)
+		b.WriteString("}\n")
+		return
+	}
+	if stmt.returnBranch.value == "" {
+		b.WriteString(" {\n")
+		writeIndent(b, indent+1)
+		b.WriteString("return\n")
+		writeIndent(b, indent)
+		b.WriteString("}\n")
+		return
+	}
+	b.WriteString(" {\n")
+	writeIndent(b, indent+1)
+	b.WriteString("return ")
+	b.WriteString(stmt.returnBranch.value)
+	b.WriteString("!")
+	b.WriteString("\n")
+	writeIndent(b, indent)
+	b.WriteString("}\n")
+}
+
+func renderNamedStructConversion(expr *loweredNamedStructConversionExpr) string {
+	if expr == nil {
+		return "undefined"
+	}
+	if expr.castOnly {
+		return "(" + expr.value.text + " as unknown as " + expr.castTarget + ")"
+	}
+	fields := make([]string, 0, len(expr.fields))
+	for _, field := range expr.fields {
+		fields = append(fields, field.name+": "+expr.temp+"."+field.name)
+	}
+	body := "const " + expr.temp + " = " + expr.value.text + "; return " +
+		expr.helper + "(new " + expr.target + "({" + strings.Join(fields, ", ") + "}))"
+	if expr.value.async {
+		return "(await (async () => { " + body + " })())"
+	}
+	return "(() => { " + body + " })()"
 }
 
 func renderSelect(b *strings.Builder, stmt *loweredSelect, indent int) {
@@ -489,10 +767,14 @@ func renderSelect(b *strings.Builder, stmt *loweredSelect, indent int) {
 	b.WriteString(", ")
 	b.WriteString(stmt.value)
 	b.WriteString("] = await $.selectStatement<any, ")
-	b.WriteString(stmt.resultType)
+	if stmt.external {
+		b.WriteString("any")
+	} else {
+		b.WriteString(stmt.resultType)
+	}
 	b.WriteString(">([\n")
 	for idx, switchCase := range stmt.cases {
-		renderSelectCase(b, switchCase, indent+1)
+		renderSelectCase(b, switchCase, stmt.external, indent+1)
 		if idx != len(stmt.cases)-1 {
 			b.WriteString(",")
 		}
@@ -506,6 +788,10 @@ func renderSelect(b *strings.Builder, stmt *loweredSelect, indent int) {
 	}
 	b.WriteString(hasDefault)
 	b.WriteString(")\n")
+	if stmt.external {
+		renderSelectExternalBodies(b, stmt, indent)
+		return
+	}
 	writeIndent(b, indent)
 	b.WriteString("if (")
 	b.WriteString(stmt.hasReturn)
@@ -516,9 +802,44 @@ func renderSelect(b *strings.Builder, stmt *loweredSelect, indent int) {
 	b.WriteString("\n")
 	writeIndent(b, indent)
 	b.WriteString("}\n")
+	if stmt.returns {
+		writeIndent(b, indent)
+		b.WriteString("throw new Error(\"unreachable select\")\n")
+	}
 }
 
-func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, indent int) {
+func renderSelectExternalBodies(b *strings.Builder, stmt *loweredSelect, indent int) {
+	writeIndent(b, indent)
+	b.WriteString("switch (")
+	b.WriteString(stmt.value)
+	b.WriteString("?.id) {\n")
+	for _, switchCase := range stmt.cases {
+		writeIndent(b, indent+1)
+		b.WriteString("case ")
+		b.WriteString(strconv.Itoa(switchCase.id))
+		b.WriteString(":\n")
+		writeIndent(b, indent+2)
+		b.WriteString("{\n")
+		writeIndent(b, indent+3)
+		b.WriteString("const result = ")
+		b.WriteString(stmt.value)
+		b.WriteString("\n")
+		renderStmts(b, switchCase.prelude, indent+3)
+		renderStmts(b, switchCase.body, indent+3)
+		writeIndent(b, indent+3)
+		b.WriteString("break\n")
+		writeIndent(b, indent+2)
+		b.WriteString("}\n")
+	}
+	writeIndent(b, indent)
+	b.WriteString("}\n")
+	if stmt.returns {
+		writeIndent(b, indent)
+		b.WriteString("throw new Error(\"unreachable select\")\n")
+	}
+}
+
+func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, external bool, indent int) {
 	writeIndent(b, indent)
 	b.WriteString("{\n")
 	writeIndent(b, indent+1)
@@ -545,6 +866,15 @@ func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, indent i
 	}
 	writeIndent(b, indent+1)
 	b.WriteString("onSelected: async (result) => {\n")
+	if external {
+		writeIndent(b, indent+2)
+		b.WriteString("return result\n")
+		writeIndent(b, indent+1)
+		b.WriteString("}\n")
+		writeIndent(b, indent)
+		b.WriteString("}")
+		return
+	}
 	renderStmts(b, switchCase.prelude, indent+2)
 	renderStmts(b, switchCase.body, indent+2)
 	writeIndent(b, indent+1)
@@ -555,68 +885,115 @@ func renderSelectCase(b *strings.Builder, switchCase loweredSelectCase, indent i
 
 func renderTypeSwitch(b *strings.Builder, stmt *loweredTypeSwitch, indent int) {
 	writeIndent(b, indent)
-	b.WriteString("$.typeSwitch(\n")
+	b.WriteString("{\n")
 	writeIndent(b, indent+1)
+	b.WriteString("const __goscriptTypeSwitchValue = ")
 	b.WriteString(stmt.value)
-	b.WriteString(",\n")
+	b.WriteString("\n")
 	writeIndent(b, indent+1)
-	b.WriteString("[\n")
-	for caseIdx, switchCase := range stmt.cases {
+	b.WriteString("switch (true) {\n")
+	for _, switchCase := range stmt.cases {
+		renderTypeSwitchCase(b, stmt.varName, stmt.varRef, switchCase, indent+2)
+	}
+	if len(stmt.defaultBody) != 0 {
 		writeIndent(b, indent+2)
-		b.WriteString("{\n")
+		b.WriteString("default:\n")
+		renderTypeSwitchInlineBody(b, stmt.varName, stmt.varRef || stmt.defaultRef, "any", "__goscriptTypeSwitchValue", stmt.defaultBody, indent+3)
 		writeIndent(b, indent+3)
-		b.WriteString("types: [")
+		b.WriteString("break\n")
+	}
+	writeIndent(b, indent+1)
+	b.WriteString("}\n")
+	writeIndent(b, indent)
+	b.WriteString("}\n")
+}
+
+func renderTypeSwitchCase(b *strings.Builder, varName string, varRef bool, switchCase loweredTypeSwitchCase, indent int) {
+	if len(switchCase.types) == 0 {
+		return
+	}
+	writeIndent(b, indent)
+	b.WriteString("case ")
+	if len(switchCase.types) == 1 {
+		b.WriteString("$.typeAssert<")
+		b.WriteString(typeSwitchAssertType(switchCase, 0))
+		b.WriteString(">(__goscriptTypeSwitchValue, ")
+		b.WriteString(switchCase.types[0])
+		b.WriteString(").ok")
+	} else {
 		for idx, typ := range switchCase.types {
 			if idx != 0 {
-				b.WriteString(", ")
+				b.WriteString(" || ")
 			}
+			b.WriteString("$.is(__goscriptTypeSwitchValue, ")
 			b.WriteString(typ)
+			b.WriteString(")")
 		}
-		b.WriteString("],\n")
-		writeIndent(b, indent+3)
-		b.WriteString("body: ")
-		renderTypeSwitchBody(b, stmt.varName, "", switchCase.body, indent+3)
-		writeIndent(b, indent+2)
-		b.WriteString("}")
-		if caseIdx != len(stmt.cases)-1 {
-			b.WriteString(",")
-		}
-		b.WriteString("\n")
 	}
+	b.WriteString(":\n")
+	value := "__goscriptTypeSwitchValue"
+	if len(switchCase.types) == 1 {
+		value = "$.typeAssert<" + typeSwitchAssertType(switchCase, 0) +
+			">(__goscriptTypeSwitchValue, " + switchCase.types[0] + ").value"
+	}
+	renderTypeSwitchInlineBody(b, varName, varRef || switchCase.varRef, typeSwitchCaseVariableType(switchCase), value, switchCase.body, indent+1)
 	writeIndent(b, indent+1)
-	b.WriteString("]")
-	if len(stmt.defaultBody) != 0 {
-		b.WriteString(",\n")
-		writeIndent(b, indent+1)
-		renderTypeSwitchBody(b, stmt.varName, stmt.value, stmt.defaultBody, indent+1)
+	b.WriteString("break\n")
+}
+
+func typeSwitchAssertType(switchCase loweredTypeSwitchCase, idx int) string {
+	if idx < len(switchCase.tsTypes) && switchCase.tsTypes[idx] != "" {
+		return switchCase.tsTypes[idx]
 	}
-	if len(stmt.defaultBody) == 0 {
-		b.WriteString("\n")
+	return "any"
+}
+
+func typeSwitchCaseVariableType(switchCase loweredTypeSwitchCase) string {
+	if len(switchCase.types) == 1 {
+		return typeSwitchAssertType(switchCase, 0)
 	}
-	writeIndent(b, indent)
-	b.WriteString(")\n")
+	return ""
 }
 
-func renderTypeSwitchBody(
+func renderTypeSwitchInlineBody(
 	b *strings.Builder,
 	varName string,
-	defaultValue string,
+	varRef bool,
+	varType string,
+	value string,
 	body []loweredStmt,
 	indent int,
 ) {
-	header := "() => {\n"
-	if varName != "" && defaultValue == "" {
-		header = "(" + varName + ") => {\n"
+	if varName == "" {
+		renderStmts(b, body, indent)
+		return
 	}
-	b.WriteString(header)
-	if varName != "" && defaultValue != "" {
-		writeIndent(b, indent+1)
-		b.WriteString("let ")
-		b.WriteString(varName)
-		b.WriteString(" = ")
-		b.WriteString(defaultValue)
-		b.WriteString("\n")
+	writeIndent(b, indent)
+	b.WriteString("{\n")
+	writeIndent(b, indent+1)
+	b.WriteString("let ")
+	b.WriteString(varName)
+	if varRef {
+		if varType == "" {
+			varType = "any"
+		}
+		b.WriteString(": $.VarRef<")
+		b.WriteString(varType)
+		b.WriteString("> = $.varRef(")
+		b.WriteString(value)
+		b.WriteString(")\n")
+		renderStmts(b, body, indent+1)
+		writeIndent(b, indent)
+		b.WriteString("}\n")
+		return
 	}
+	if varType != "" {
+		b.WriteString(": ")
+		b.WriteString(varType)
+	}
+	b.WriteString(" = ")
+	b.WriteString(value)
+	b.WriteString("\n")
 	renderStmts(b, body, indent+1)
 	writeIndent(b, indent)
 	b.WriteString("}\n")