goscript 0.1.3 → 0.1.4

package/compiler/lowering.go

@@ -1124,7 +1124,7 @@ func isConstGenDecl(decl ast.Decl) bool {
 }
 
 func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([]loweredDecl, []Diagnostic) {
-	var decls []loweredDecl
+	decls := make([]loweredDecl, 0, len(decl.Specs))
 	var diagnostics []Diagnostic
 	for _, spec := range decl.Specs {
 		switch typed := spec.(type) {
@@ -1190,7 +1190,7 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				code := keyword + " " + declName + ": " + variableType + " = " + value
 				if lazy {
 					keyword = "var"
-					code = "var " + declName + ": " + variableType + " = undefined as unknown as " + variableType
+					code = "var " + declName + ": " + variableType
 				}
 				indexExport := ""
 				if ctx.topLevel && name.Name != "_" {
@@ -1402,7 +1402,7 @@ func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
 	}
-	declFiles := make(map[types.Object]string)
+	declFiles := make(map[types.Object]string, len(semPkg.declarations))
 	for _, decl := range semPkg.declarations {
 		if decl.object != nil && decl.position.file != "" {
 			declFiles[decl.object] = decl.position.file
@@ -1962,6 +1962,13 @@ func lowerLargeIntegerConstantValue(value constant.Value) (string, bool) {
 	return value.ExactString(), true
 }
 
+func lowerWideIntegerConstantValue(value constant.Value) (string, bool) {
+	if value == nil || value.Kind() != constant.Int || constant.BitLen(value) <= 53 {
+		return "", false
+	}
+	return value.ExactString(), true
+}
+
 func lowerConstantStringByteSlice(ctx lowerFileContext, expr ast.Expr) (string, bool) {
 	value := ctx.semPkg.source.TypesInfo.Types[unwrapParenExpr(expr)].Value
 	if value == nil || value.Kind() != constant.String {
@@ -2006,35 +2013,218 @@ func (o *LoweringOwner) lowerGoEmbedValue(
 	typ types.Type,
 	patterns []string,
 ) (string, []Diagnostic) {
+	if isEmbedFSType(typ) {
+		return o.lowerGoEmbedFSValue(ctx, patterns)
+	}
 	if len(patterns) != 1 {
 		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
 	}
-	pattern := strings.Trim(patterns[0], "`\"")
+	cleanPattern, diagnostics := cleanGoEmbedFilePattern(ctx, patterns[0])
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	data, diagnostics := readGoEmbedFile(ctx, cleanPattern)
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	if isStringType(typ) {
+		return strconv.Quote(string(data)), nil
+	}
+	if slice, ok := types.Unalias(typ).Underlying().(*types.Slice); ok && isByteType(slice.Elem()) {
+		return byteSliceLiteral(data), nil
+	}
+	diag := loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed target type")
+	diag.Detail = "target type: " + types.TypeString(typ, func(pkg *types.Package) string {
+		if pkg == nil {
+			return ""
+		}
+		return pkg.Path()
+	})
+	return "", []Diagnostic{diag}
+}
+
+func (o *LoweringOwner) lowerGoEmbedFSValue(ctx lowerFileContext, patterns []string) (string, []Diagnostic) {
+	embedAlias := ctx.importPaths["embed"]
+	if embedAlias == "" {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed FS import")}
+	}
+	if len(patterns) == 0 {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern list")}
+	}
+
+	filesByPath := make(map[string][]byte)
+	for _, pattern := range patterns {
+		files, diagnostics := expandGoEmbedPattern(ctx, pattern)
+		if len(diagnostics) != 0 {
+			return "", diagnostics
+		}
+		for _, file := range files {
+			filesByPath[file.path] = file.data
+		}
+	}
+	paths := make([]string, 0, len(filesByPath))
+	for path := range filesByPath {
+		paths = append(paths, path)
+	}
+	slices.Sort(paths)
+	entries := make([]string, 0, len(paths))
+	for _, path := range paths {
+		entries = append(entries, "["+strconv.Quote(path)+", "+byteSliceLiteral(filesByPath[path])+"]")
+	}
+	builtinAlias := o.runtimeOwner.BuiltinImport().Alias
+	return builtinAlias + ".markAsStructValue(new " + embedAlias + ".FS(new Map<string, Uint8Array>([" + strings.Join(entries, ", ") + "])))", nil
+}
+
+type goEmbedFile struct {
+	path string
+	data []byte
+}
+
+func cleanGoEmbedFilePattern(ctx lowerFileContext, pattern string) (string, []Diagnostic) {
+	cleanPattern, _, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+	if len(diagnostics) != 0 {
+		return "", diagnostics
+	}
+	if strings.Contains(cleanPattern, "*") {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+	}
+	info, err := os.Stat(filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	if err != nil {
+		return "", []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	if info.IsDir() {
+		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed directory target")}
+	}
+	return cleanPattern, nil
+}
+
+func cleanGoEmbedPattern(ctx lowerFileContext, pattern string) (string, bool, []Diagnostic) {
+	pattern = strings.Trim(pattern, "`\"")
+	all := false
+	if strings.HasPrefix(pattern, "all:") {
+		all = true
+		pattern = strings.TrimPrefix(pattern, "all:")
+	}
 	cleanPattern := path.Clean(pattern)
 	if pattern == "" ||
-		strings.Contains(pattern, "*") ||
 		path.IsAbs(pattern) ||
 		cleanPattern == "." ||
 		cleanPattern == ".." ||
 		strings.HasPrefix(cleanPattern, "../") {
-		return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		return "", false, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
 	}
-	data, err := os.ReadFile(filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	return cleanPattern, all, nil
+}
+
+func expandGoEmbedPattern(ctx lowerFileContext, pattern string) ([]goEmbedFile, []Diagnostic) {
+	cleanPattern, all, diagnostics := cleanGoEmbedPattern(ctx, pattern)
+	if len(diagnostics) != 0 {
+		return nil, diagnostics
+	}
+	pkgDir := filepath.Dir(ctx.sourcePath)
+	paths := []string{filepath.Join(pkgDir, filepath.FromSlash(cleanPattern))}
+	if strings.Contains(cleanPattern, "*") {
+		matches, err := filepath.Glob(filepath.Join(pkgDir, filepath.FromSlash(cleanPattern)))
+		if err != nil {
+			return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed pattern")}
+		}
+		if len(matches) == 0 {
+			return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "go:embed pattern matched no files")}
+		}
+		paths = matches
+	}
+
+	var files []goEmbedFile
+	for _, path := range paths {
+		collected, diagnostics := collectGoEmbedPath(ctx, pkgDir, path, all)
+		if len(diagnostics) != 0 {
+			return nil, diagnostics
+		}
+		files = append(files, collected...)
+	}
+	slices.SortFunc(files, func(a, b goEmbedFile) int {
+		return cmp.Compare(a.path, b.path)
+	})
+	return files, nil
+}
+
+func collectGoEmbedPath(ctx lowerFileContext, pkgDir, absPath string, all bool) ([]goEmbedFile, []Diagnostic) {
+	info, err := os.Stat(absPath)
 	if err != nil {
-		return "", []Diagnostic{{
-			Severity: DiagnosticSeverityError,
-			Code:     "goscript/lowering:embed",
-			Message:  "failed to read go:embed file",
-			Detail:   ctx.semPkg.pkgPath + ": " + err.Error(),
-		}}
+		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
 	}
-	if isStringType(typ) {
-		return strconv.Quote(string(data)), nil
+	if !info.IsDir() {
+		file, diagnostics := readGoEmbedAbsFile(ctx, pkgDir, absPath)
+		if len(diagnostics) != 0 {
+			return nil, diagnostics
+		}
+		return []goEmbedFile{file}, nil
 	}
-	if slice, ok := types.Unalias(typ).Underlying().(*types.Slice); ok && isByteType(slice.Elem()) {
-		return byteSliceLiteral(data), nil
+
+	var files []goEmbedFile
+	if err := filepath.WalkDir(absPath, func(path string, entry os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if path != absPath && !all && (strings.HasPrefix(entry.Name(), ".") || strings.HasPrefix(entry.Name(), "_")) {
+			if entry.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if entry.IsDir() {
+			return nil
+		}
+		file, diagnostics := readGoEmbedAbsFile(ctx, pkgDir, path)
+		if len(diagnostics) != 0 {
+			return fmt.Errorf("%s", diagnostics[0].Detail)
+		}
+		files = append(files, file)
+		return nil
+	}); err != nil {
+		return nil, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	if len(files) == 0 {
+		return nil, []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "go:embed directory matched no files")}
 	}
-	return "", []Diagnostic{loweringUnsupported("declaration", ctx.semPkg.pkgPath, "unsupported go:embed target type")}
+	return files, nil
+}
+
+func readGoEmbedFile(ctx lowerFileContext, cleanPattern string) ([]byte, []Diagnostic) {
+	file, diagnostics := readGoEmbedAbsFile(ctx, filepath.Dir(ctx.sourcePath), filepath.Join(filepath.Dir(ctx.sourcePath), filepath.FromSlash(cleanPattern)))
+	if len(diagnostics) != 0 {
+		return nil, diagnostics
+	}
+	return file.data, nil
+}
+
+func readGoEmbedAbsFile(ctx lowerFileContext, pkgDir, absPath string) (goEmbedFile, []Diagnostic) {
+	relPath, err := filepath.Rel(pkgDir, absPath)
+	if err != nil {
+		return goEmbedFile{}, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	data, err := os.ReadFile(absPath)
+	if err != nil {
+		return goEmbedFile{}, []Diagnostic{goEmbedReadDiagnostic(ctx, err)}
+	}
+	return goEmbedFile{path: filepath.ToSlash(relPath), data: data}, nil
+}
+
+func goEmbedReadDiagnostic(ctx lowerFileContext, err error) Diagnostic {
+	return Diagnostic{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/lowering:embed",
+		Message:  "failed to read go:embed file",
+		Detail:   ctx.semPkg.pkgPath + ": " + err.Error(),
+	}
+}
+
+func isEmbedFSType(typ types.Type) bool {
+	named, _ := types.Unalias(typ).(*types.Named)
+	if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+		return false
+	}
+	return named.Obj().Pkg().Path() == "embed" && named.Obj().Name() == "FS"
 }
 
 func byteSliceLiteral(data []byte) string {
@@ -2202,6 +2392,7 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 		name:          safeIdentifier(semType.name),
 		typeName:      runtimeNamedTypeName(semType.named),
 		cloneMethod:   "clone",
+		fields:        make([]loweredStructField, 0, len(semType.fields)),
 	}
 	for idx, field := range semType.fields {
 		structValue := isStructValueType(field.typ)
@@ -2228,9 +2419,12 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 
 	methodDecls := o.methodDeclsForType(ctx, semType.named)
 	explicitMethods := make(map[string]bool, len(methodDecls))
-	for _, methodDecl := range methodDecls {
-		if methodDecl != nil {
-			explicitMethods[methodDecl.Name.Name] = true
+	if len(methodDecls) != 0 {
+		lowered.methods = make([]loweredFunction, 0, len(methodDecls))
+		for _, methodDecl := range methodDecls {
+			if methodDecl != nil {
+				explicitMethods[methodDecl.Name.Name] = true
+			}
 		}
 	}
 	var diagnostics []Diagnostic
@@ -3034,105 +3228,113 @@ func (o *LoweringOwner) lowerStmtListAfter(
 ) ([]loweredStmt, []Diagnostic) {
 	lowered := make([]loweredStmt, 0, len(stmts))
 	var diagnostics []Diagnostic
-	gotoSpans := backwardGotoLabelSpans(stmts)
-	gotoLabels := make(map[string]bool, len(gotoSpans))
-	for label := range gotoSpans {
-		gotoLabels[label] = true
-	}
-	forwardSpans := forwardGotoLabelSpans(stmts, gotoSpans)
-	forwardStarts := make(map[int]forwardGotoLabelSpan, len(forwardSpans))
-	for label, span := range forwardSpans {
-		span.label = label
-		group := forwardStarts[span.start]
-		if group.forwardLabels == nil {
-			group.forwardLabels = make(map[string]bool)
-		}
-		group.forwardLabels[label] = true
-		if group.label == "" || span.labelIdx > group.labelIdx {
-			group.label = span.label
-			group.start = span.start
-			group.labelIdx = span.labelIdx
-		}
-		forwardStarts[span.start] = group
+	hasGoto := stmtListHasGoto(stmts)
+	var gotoSpans map[string]int
+	var gotoLabels map[string]bool
+	var forwardStarts map[int]forwardGotoLabelSpan
+	if hasGoto {
+		gotoSpans = backwardGotoLabelSpans(stmts)
+		gotoLabels = make(map[string]bool, len(gotoSpans))
+		for label := range gotoSpans {
+			gotoLabels[label] = true
+		}
+		forwardSpans := forwardGotoLabelSpans(stmts, gotoSpans)
+		forwardStarts = make(map[int]forwardGotoLabelSpan, len(forwardSpans))
+		for label, span := range forwardSpans {
+			span.label = label
+			group := forwardStarts[span.start]
+			if group.forwardLabels == nil {
+				group.forwardLabels = make(map[string]bool)
+			}
+			group.forwardLabels[label] = true
+			if group.label == "" || span.labelIdx > group.labelIdx {
+				group.label = span.label
+				group.start = span.start
+				group.labelIdx = span.labelIdx
+			}
+			forwardStarts[span.start] = group
+		}
 	}
 	for idx := 0; idx < len(stmts); idx++ {
 		stmt := stmts[idx]
 		startLine := sourceLine(ctx, stmt.Pos())
 		leading := leadingStmtLines(ctx, prevEndLine, startLine)
-		if cluster, ok := gotoStateClusterAt(stmts, idx); ok {
-			clusterLowered, clusterDiagnostics := o.lowerGotoStateCluster(ctx, stmts, cluster, leading)
-			diagnostics = append(diagnostics, clusterDiagnostics...)
-			lowered = append(lowered, clusterLowered...)
-			if endLine := sourceLine(ctx, stmts[cluster.endIdx].End()); endLine != 0 {
-				prevEndLine = endLine
-			}
-			idx = cluster.endIdx
-			continue
-		}
-		if span, ok := leadingGotoBackwardLoopSpan(stmts, idx, gotoSpans); ok {
-			loop, loopDiagnostics := o.lowerBackwardGotoLoop(
-				ctx,
-				gotoLabels,
-				span.label,
-				span.labelIdx,
-				span.endIdx,
-				span.forwardLabel,
-				stmts,
-				leading,
-			)
-			diagnostics = append(diagnostics, loopDiagnostics...)
-			lowered = append(lowered, loop...)
-			if endLine := sourceLine(ctx, stmts[span.endIdx].End()); endLine != 0 {
-				prevEndLine = endLine
-			}
-			idx = span.endIdx
-			continue
-		}
-		if span, ok := forwardStarts[idx]; ok {
-			bodyStmts := stmts[idx:span.labelIdx]
-			body, bodyDiagnostics := o.lowerStmtListAfter(
-				ctx.withForwardGotos(span.forwardLabels),
-				bodyStmts,
-				prevEndLine,
-			)
-			diagnostics = append(diagnostics, bodyDiagnostics...)
-			block := loweredStmt{hasBlock: true, text: span.label + ":", children: body}
-			if len(leading) != 0 {
-				block.leading = append(leading, block.leading...)
-			}
-			lowered = append(lowered, block)
-			if labeled, ok := stmts[span.labelIdx].(*ast.LabeledStmt); ok {
-				labelLowered, labelDiagnostics := o.lowerStmt(ctx, labeled.Stmt)
-				diagnostics = append(diagnostics, labelDiagnostics...)
-				lowered = append(lowered, labelLowered...)
-				if endLine := sourceLine(ctx, labeled.End()); endLine != 0 {
+		if hasGoto {
+			if cluster, ok := gotoStateClusterAt(stmts, idx); ok {
+				clusterLowered, clusterDiagnostics := o.lowerGotoStateCluster(ctx, stmts, cluster, leading)
+				diagnostics = append(diagnostics, clusterDiagnostics...)
+				lowered = append(lowered, clusterLowered...)
+				if endLine := sourceLine(ctx, stmts[cluster.endIdx].End()); endLine != 0 {
 					prevEndLine = endLine
 				}
+				idx = cluster.endIdx
+				continue
 			}
-			idx = span.labelIdx
-			continue
-		}
-		if labeled, ok := stmt.(*ast.LabeledStmt); ok {
-			label := safeIdentifier(labeled.Label.Name)
-			if endIdx, ok := gotoSpans[label]; ok {
+			if span, ok := leadingGotoBackwardLoopSpan(stmts, idx, gotoSpans); ok {
 				loop, loopDiagnostics := o.lowerBackwardGotoLoop(
 					ctx,
 					gotoLabels,
-					label,
-					idx,
-					endIdx,
-					"",
+					span.label,
+					span.labelIdx,
+					span.endIdx,
+					span.forwardLabel,
 					stmts,
 					leading,
 				)
 				diagnostics = append(diagnostics, loopDiagnostics...)
 				lowered = append(lowered, loop...)
-				if endLine := sourceLine(ctx, stmts[endIdx].End()); endLine != 0 {
+				if endLine := sourceLine(ctx, stmts[span.endIdx].End()); endLine != 0 {
 					prevEndLine = endLine
 				}
-				idx = endIdx
+				idx = span.endIdx
 				continue
 			}
+			if span, ok := forwardStarts[idx]; ok {
+				bodyStmts := stmts[idx:span.labelIdx]
+				body, bodyDiagnostics := o.lowerStmtListAfter(
+					ctx.withForwardGotos(span.forwardLabels),
+					bodyStmts,
+					prevEndLine,
+				)
+				diagnostics = append(diagnostics, bodyDiagnostics...)
+				block := loweredStmt{hasBlock: true, text: span.label + ":", children: body}
+				if len(leading) != 0 {
+					block.leading = append(leading, block.leading...)
+				}
+				lowered = append(lowered, block)
+				if labeled, ok := stmts[span.labelIdx].(*ast.LabeledStmt); ok {
+					labelLowered, labelDiagnostics := o.lowerStmt(ctx, labeled.Stmt)
+					diagnostics = append(diagnostics, labelDiagnostics...)
+					lowered = append(lowered, labelLowered...)
+					if endLine := sourceLine(ctx, labeled.End()); endLine != 0 {
+						prevEndLine = endLine
+					}
+				}
+				idx = span.labelIdx
+				continue
+			}
+			if labeled, ok := stmt.(*ast.LabeledStmt); ok {
+				label := safeIdentifier(labeled.Label.Name)
+				if endIdx, ok := gotoSpans[label]; ok {
+					loop, loopDiagnostics := o.lowerBackwardGotoLoop(
+						ctx,
+						gotoLabels,
+						label,
+						idx,
+						endIdx,
+						"",
+						stmts,
+						leading,
+					)
+					diagnostics = append(diagnostics, loopDiagnostics...)
+					lowered = append(lowered, loop...)
+					if endLine := sourceLine(ctx, stmts[endIdx].End()); endLine != 0 {
+						prevEndLine = endLine
+					}
+					idx = endIdx
+					continue
+				}
+			}
 		}
 		if stmtCtx, nextCtx, ok := o.lowerDeclStatementContext(ctx, stmt); ok {
 			stmtLowered, stmtDiagnostics := o.lowerStmt(stmtCtx, stmt)
@@ -3204,7 +3406,7 @@ func (o *LoweringOwner) lowerDeclStatementContext(
 			if def == nil || aliases[def] != "" {
 				continue
 			}
-			if shortDeclDefShadowsOuterName(name.Name, def) {
+			if shortDeclDefShadowsOuterName(ctx, name.Name, def) || valueSpecUsesOuterName(ctx, valueSpec, name.Name, def) {
 				aliases[def] = ctx.tempName("Shadow")
 			}
 		}
@@ -3452,9 +3654,30 @@ type leadingGotoBackwardLoop struct {
 }
 
 func stmtListNeedsLoopBranchLabel(stmts []ast.Stmt) bool {
+	if !stmtListHasGoto(stmts) {
+		return false
+	}
 	return len(backwardGotoLabelSpans(stmts)) != 0
 }
 
+func stmtListHasGoto(stmts []ast.Stmt) bool {
+	for _, stmt := range stmts {
+		hasGoto := false
+		ast.Inspect(stmt, func(node ast.Node) bool {
+			branch, ok := node.(*ast.BranchStmt)
+			if ok && branch.Tok == token.GOTO && branch.Label != nil {
+				hasGoto = true
+				return false
+			}
+			return !hasGoto
+		})
+		if hasGoto {
+			return true
+		}
+	}
+	return false
+}
+
 func backwardGotoLabelSpans(stmts []ast.Stmt) map[string]int {
 	seenLabels := make(map[string]bool)
 	spans := make(map[string]int)
@@ -3734,15 +3957,11 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		if starTarget && stmt.Tok != token.DEFINE {
 			pointer, pointerDiagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			diagnostics = append(diagnostics, pointerDiagnostics...)
-			if stmt.Tok == token.AND_NOT_ASSIGN {
-				stmts = append(stmts, loweredStmt{text: pointer + " = " + pointer + " & ~(" + right + ")"})
-				continue
-			}
 			if value, ok := integerQuotientAssignExpr(targetType, pointer, right, stmt.Tok); ok {
 				stmts = append(stmts, loweredStmt{text: value})
 				continue
 			}
-			stmts = append(stmts, loweredStmt{text: pointer + " " + stmt.Tok.String() + " " + right})
+			stmts = append(stmts, loweredStmt{text: pointer + " = " + lowerCompoundAssignValue(o.runtimeOwner, targetType, pointer, right, stmt.Tok)})
 			continue
 		}
 		if isShortDecl {
@@ -3752,10 +3971,6 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 			stmts = append(stmts, loweredStmt{text: "let " + left + o.shortDeclTypeAnnotation(ctx, lhs, stmt.Rhs[idx]) + " = " + right})
 			continue
 		}
-		if stmt.Tok == token.AND_NOT_ASSIGN {
-			stmts = append(stmts, loweredStmt{text: left + " = " + left + " & ~(" + right + ")"})
-			continue
-		}
 		if helper, ok := wideIntegerAssignHelper(targetType, stmt.Tok); ok {
 			stmts = append(stmts, loweredStmt{text: left + " = " + o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"})
 			continue
@@ -3768,6 +3983,10 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		if stmt.Tok == token.DEFINE {
 			op = "="
 		}
+		if stmt.Tok != token.ASSIGN && stmt.Tok != token.DEFINE {
+			stmts = append(stmts, loweredStmt{text: left + " = " + lowerCompoundAssignValue(o.runtimeOwner, targetType, left, right, stmt.Tok)})
+			continue
+		}
 		stmts = append(stmts, loweredStmt{text: left + " " + op + " " + right})
 	}
 	return stmts, diagnostics
@@ -3810,6 +4029,7 @@ func lowerCompoundAssignValue(
 	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
 		return value
 	}
+	right = "(" + right + ")"
 	switch tok {
 	case token.ADD_ASSIGN:
 		return left + " + " + right
@@ -3830,6 +4050,9 @@ func lowerCompoundAssignValue(
 	case token.SHL_ASSIGN:
 		return left + " << " + right
 	case token.SHR_ASSIGN:
+		if bits, ok := unsignedIntegerBits(targetType); ok && bits <= 32 {
+			return "(" + left + " >>> " + right + ") >>> 0"
+		}
 		return left + " >> " + right
 	case token.AND_NOT_ASSIGN:
 		return left + " & ~(" + right + ")"
@@ -3866,30 +4089,31 @@ func integerQuotientAssignValueExpr(targetType types.Type, left string, right st
 }
 
 func wideIntegerAssignHelper(targetType types.Type, tok token.Token) (RuntimeHelper, bool) {
-	if !isFixedWideIntegerType(targetType) {
+	if !isRuntimeWideIntegerType(targetType) {
 		return "", false
 	}
+	signed := isFixedSignedWideIntegerType(targetType)
 	switch tok {
 	case token.SHL_ASSIGN:
-		return RuntimeHelperUint64Shl, true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Shl, RuntimeHelperInt64Shl), true
 	case token.SHR_ASSIGN:
-		return RuntimeHelperUint64Shr, true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Shr, RuntimeHelperInt64Shr), true
 	case token.MUL_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mul, RuntimeHelperInt64Mul), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Mul, RuntimeHelperInt64Mul), true
 	case token.QUO_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Div, RuntimeHelperInt64Div), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Div, RuntimeHelperInt64Div), true
 	case token.REM_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mod, RuntimeHelperInt64Mod), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Mod, RuntimeHelperInt64Mod), true
 	case token.ADD_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Add, RuntimeHelperInt64Add), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Add, RuntimeHelperInt64Add), true
 	case token.SUB_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Sub, RuntimeHelperInt64Sub), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Sub, RuntimeHelperInt64Sub), true
 	case token.AND_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64And, RuntimeHelperInt64And), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And), true
 	case token.OR_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Or, RuntimeHelperInt64Or), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Or, RuntimeHelperInt64Or), true
 	case token.XOR_ASSIGN:
-		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Xor, RuntimeHelperInt64Xor), true
+		return wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor), true
 	default:
 		return "", false
 	}
@@ -4172,7 +4396,7 @@ func (o *LoweringOwner) lowerShortDeclNewShadowAliases(
 		if entry.def == nil || aliases[entry.def] != "" {
 			continue
 		}
-		if shortDeclDefShadowsOuterName(entry.name, entry.def) {
+		if shortDeclDefShadowsOuterName(ctx, entry.name, entry.def) {
 			aliases[entry.def] = ctx.tempName("Shadow")
 		}
 	}
@@ -4201,12 +4425,24 @@ func shortDeclShadowNonValueIdents(ctx lowerFileContext, expr ast.Expr) map[*ast
 	return idents
 }
 
-func shortDeclDefShadowsOuterName(name string, def types.Object) bool {
+func shortDeclDefShadowsOuterName(ctx lowerFileContext, name string, def types.Object) bool {
 	for scope := def.Parent(); scope != nil; scope = scope.Parent() {
 		if scope == def.Parent() {
 			continue
 		}
 		obj := scope.Lookup(name)
+		if scope.Parent() == types.Universe {
+			if obj == nil {
+				return false
+			}
+			if _, isTypeName := obj.(*types.TypeName); isTypeName {
+				return true
+			}
+			if _, isFunc := obj.(*types.Func); isFunc {
+				return sameSourceFile(ctx, obj.Pos(), def.Pos()) && obj.Pos() < def.Pos()
+			}
+			return false
+		}
 		if obj != nil && obj.Pos().IsValid() && obj.Pos() < def.Pos() {
 			return true
 		}
@@ -4214,6 +4450,40 @@ func shortDeclDefShadowsOuterName(name string, def types.Object) bool {
 	return false
 }
 
+func sameSourceFile(ctx lowerFileContext, left token.Pos, right token.Pos) bool {
+	if !left.IsValid() || !right.IsValid() || ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return false
+	}
+	leftPos := sourcePos(ctx.semPkg.source, left)
+	rightPos := sourcePos(ctx.semPkg.source, right)
+	return leftPos.file != "" && leftPos.file == rightPos.file
+}
+
+func valueSpecUsesOuterName(ctx lowerFileContext, spec *ast.ValueSpec, name string, def types.Object) bool {
+	if spec == nil || name == "" || def == nil {
+		return false
+	}
+	usesOuter := false
+	for _, value := range spec.Values {
+		ast.Inspect(value, func(node ast.Node) bool {
+			ident, ok := node.(*ast.Ident)
+			if !ok || ident.Name != name {
+				return true
+			}
+			obj := ctx.semPkg.source.TypesInfo.Uses[ident]
+			if obj != nil && obj != def {
+				usesOuter = true
+				return false
+			}
+			return true
+		})
+		if usesOuter {
+			return true
+		}
+	}
+	return false
+}
+
 func (o *LoweringOwner) mapIndexDefaultUsesShortDeclName(
 	ctx lowerFileContext,
 	rhs ast.Expr,
@@ -5273,7 +5543,7 @@ func (o *LoweringOwner) lowerRangeFuncStmt(
 		diagnostics = append(diagnostics, assignmentDiagnostics...)
 		body = append(assignments, body...)
 	}
-	async := ctx.asyncFunction
+	async := ctx.asyncFunction || stmtsContainAwait(body) || o.rangeFunctionValueNeedsAwait(ctx, stmt.X)
 
 	return loweredStmt{rangeFunc: &loweredRangeFunc{
 		value:        rangeValue,
@@ -5902,6 +6172,19 @@ func (o *LoweringOwner) lowerComplexEqualityExpr(ctx lowerFileContext, expr *ast
 	return value, true
 }
 
+func (o *LoweringOwner) lowerStructEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isStructComparableType(leftType) || !isStructComparableType(rightType) {
+		return "", false
+	}
+	value := o.runtimeOwner.QualifiedHelper(RuntimeHelperComparableEqual) + "(" + left + ", " + right + ")"
+	if expr.Op == token.NEQ {
+		value = "!" + value
+	}
+	return value, true
+}
+
 func (o *LoweringOwner) lowerStringEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
 	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
 	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
@@ -6030,6 +6313,9 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 			if value, ok := o.lowerComplexEqualityExpr(ctx, typed, left, right); ok {
 				return value, append(leftDiagnostics, rightDiagnostics...)
 			}
+			if value, ok := o.lowerStructEqualityExpr(ctx, typed, left, right); ok {
+				return value, append(leftDiagnostics, rightDiagnostics...)
+			}
 			if value, ok := o.lowerStringEqualityExpr(ctx, typed, left, right); ok {
 				return value, append(leftDiagnostics, rightDiagnostics...)
 			}
@@ -6073,6 +6359,10 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 			return lowerPrefixUnaryExpr(typed.Op, value), diagnostics
 		}
 		if typed.Op == token.XOR {
+			if bits, ok := unsignedIntegerBits(ctx.semPkg.source.TypesInfo.TypeOf(typed)); ok && bits <= 32 {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
+					"(~" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
+			}
 			return "~" + value, diagnostics
 		}
 		return value, append(diagnostics, loweringUnsupported("expression", ctx.semPkg.pkgPath, "unsupported unary operator"))
@@ -6155,7 +6445,7 @@ func isLegacyOctalLiteral(value string) bool {
 func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (string, bool, []Diagnostic) {
 	signature, _ := ctx.semPkg.source.TypesInfo.TypeOf(lit).(*types.Signature)
 	deferState := &loweredDeferState{}
-	bodyCtx := ctx.withSignature(signature).withDeferState(deferState).withoutRangeBranch()
+	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
 	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
@@ -6276,7 +6566,7 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 		}
 		return alias
 	}
-	if constObj, ok := obj.(*types.Const); ok && ctx.localAliases[obj] != "" {
+	if constObj, ok := obj.(*types.Const); ok && !raw {
 		if constValue, ok := lowerConstantValue(constObj.Val()); ok {
 			return constValue
 		}
@@ -6962,6 +7252,8 @@ func (o *LoweringOwner) lowerConversionExpr(
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperRunesToString) + "(" + value + ")", diagnostics
 		case isByteSliceType(sourceType):
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperBytesToString) + "(" + value + ")", diagnostics
+		case overrideNamedStringType(ctx, o, sourceType):
+			return "String(" + value + ")", diagnostics
 		case isStringType(sourceType):
 			return value, diagnostics
 		case isNumericType(sourceType):
@@ -7020,7 +7312,7 @@ func (o *LoweringOwner) lowerConversionExpr(
 		return renderNamedStructConversion(conversion), diagnostics
 	}
 	if isNumericType(targetType) {
-		if constantValue, ok := lowerRealNumericConstantExpr(ctx, expr.Args[0]); ok {
+		if constantValue, ok := o.lowerNumericConstantExprForTarget(ctx, expr.Args[0], targetType); ok {
 			return constantValue, diagnostics
 		}
 	}
@@ -7052,8 +7344,8 @@ func (o *LoweringOwner) lowerConversionExpr(
 }
 
 func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
-	resultWide := isFixedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr))
-	leftWide := isFixedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
+	resultWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr))
+	leftWide := isRuntimeWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
 	if !resultWide && !leftWide {
 		return "", false
 	}
@@ -7329,6 +7621,12 @@ func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 			methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
 		return call, diagnostics, true
 	}
+	if crossPackageUnexportedNamedType(ctx, receiver) {
+		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<any>(" + receiverExpr + ")." + methodMemberName(selector.Sel.Name) +
+			"(" + strings.Join(args, ", ") + ")"
+		return call, diagnostics, true
+	}
 	callArgs := append([]string{receiverExpr}, args...)
 	call := o.namedTypeExpr(ctx, receiver) + ".prototype." + selector.Sel.Name + ".call(" + strings.Join(callArgs, ", ") + ")"
 	return call, diagnostics, true
@@ -8492,12 +8790,40 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 func compositeLiteralFieldNeedsPreEval(ctx lowerFileContext, expr ast.Expr) bool {
 	switch typed := unwrapParenExpr(expr).(type) {
 	case *ast.CallExpr:
+		for _, arg := range typed.Args {
+			if compositeLiteralFieldNeedsPreEval(ctx, arg) {
+				return true
+			}
+		}
 		if ident, ok := typed.Fun.(*ast.Ident); ok && isBuiltinCallTarget(ctx, ident) {
 			return false
 		}
 		return typeFromExpr(ctx, typed.Fun) == nil
 	case *ast.UnaryExpr:
-		return typed.Op == token.ARROW
+		return typed.Op == token.ARROW || compositeLiteralFieldNeedsPreEval(ctx, typed.X)
+	case *ast.BinaryExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Y)
+	case *ast.IndexExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Index)
+	case *ast.IndexListExpr:
+		if compositeLiteralFieldNeedsPreEval(ctx, typed.X) {
+			return true
+		}
+		for _, index := range typed.Indices {
+			if compositeLiteralFieldNeedsPreEval(ctx, index) {
+				return true
+			}
+		}
+		return false
+	case *ast.SliceExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Low) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.High) ||
+			compositeLiteralFieldNeedsPreEval(ctx, typed.Max)
+	case *ast.StarExpr:
+		return compositeLiteralFieldNeedsPreEval(ctx, typed.X)
 	default:
 		return false
 	}
@@ -8562,6 +8888,9 @@ func (o *LoweringOwner) lowerArrayCompositeLit(
 	lit *ast.CompositeLit,
 	array *types.Array,
 ) (string, []Diagnostic) {
+	if len(lit.Elts) == 0 && isByteType(array.Elem()) {
+		return "new Uint8Array(" + strconv.FormatInt(array.Len(), 10) + ")", nil
+	}
 	values := make([]string, int(array.Len()))
 	for idx := range values {
 		values[idx] = o.lowerZeroValueExprFor(ctx, array.Elem())
@@ -8715,7 +9044,7 @@ func (o *LoweringOwner) lowerValueForTarget(
 		}
 	}
 	if isNumericType(targetType) {
-		if constantValue, ok := lowerRealNumericConstantExpr(ctx, expr); ok {
+		if constantValue, ok := o.lowerNumericConstantExprForTarget(ctx, expr, targetType); ok {
 			return constantValue
 		}
 	}
@@ -8744,6 +9073,28 @@ func lowerRealNumericConstantExpr(ctx lowerFileContext, expr ast.Expr) (string,
 	}
 }
 
+func (o *LoweringOwner) lowerNumericConstantExprForTarget(ctx lowerFileContext, expr ast.Expr, targetType types.Type) (string, bool) {
+	if ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return "", false
+	}
+	tv, ok := ctx.semPkg.source.TypesInfo.Types[expr]
+	if ok && tv.Value != nil {
+		if bits, ok := unsignedIntegerBits(targetType); ok && bits >= 64 {
+			if value, ok := lowerWideIntegerConstantValue(tv.Value); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) + "(" +
+					strconv.Quote(value) + ", 64)", true
+			}
+		}
+		if bits, ok := signedIntegerBits(targetType); ok && bits >= 64 {
+			if value, ok := lowerWideIntegerConstantValue(tv.Value); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperInt) + "(" +
+					strconv.Quote(value) + ", 64)", true
+			}
+		}
+	}
+	return lowerRealNumericConstantExpr(ctx, expr)
+}
+
 func isRealNumericConstantExpr(ctx lowerFileContext, expr ast.Expr) bool {
 	if ctx.semPkg != nil && ctx.semPkg.source != nil {
 		if tv, ok := ctx.semPkg.source.TypesInfo.Types[expr]; ok && tv.Value != nil {
@@ -8789,6 +9140,9 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 			return wrapper
 		}
 	}
+	if wrapper := o.lowerNumericInterfaceWrapper(ctx, targetType, sourceType, value); wrapper != "" {
+		return wrapper
+	}
 	if isInterfaceType(targetType) && isStructValueType(sourceType) {
 		if cloneStructValue {
 			value = o.lowerStructClone(value)
@@ -8837,6 +9191,25 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 	return value
 }
 
+func (o *LoweringOwner) lowerNumericInterfaceWrapper(
+	ctx lowerFileContext,
+	targetType types.Type,
+	sourceType types.Type,
+	value string,
+) string {
+	if targetType == nil || sourceType == nil || !isInterfaceType(targetType) || isInterfaceType(sourceType) {
+		return ""
+	}
+	basic, ok := types.Unalias(sourceType).(*types.Basic)
+	if !ok || basic.Info()&types.IsNumeric == 0 || basic.Info()&types.IsUntyped != 0 {
+		return ""
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
+		"<" + o.tsTypeFor(ctx, targetType) + ">(" + value + ", " +
+		strconv.Quote(goRuntimeTypeString(sourceType)) + ", {}, " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
+}
+
 func isBasicFixedWideIntegerType(typ types.Type) bool {
 	basic, ok := types.Unalias(typ).(*types.Basic)
 	if !ok {
@@ -8876,7 +9249,8 @@ func (o *LoweringOwner) lowerNamedValueInterfaceWrapper(
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
 		"<" + o.tsTypeFor(ctx, targetType) + ">(" + value + ", " +
-		strconv.Quote(goRuntimeTypeString(sourceType)) + ", " + methods + ")"
+		strconv.Quote(goRuntimeTypeString(sourceType)) + ", " + methods + ", " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
 }
 
 func (o *LoweringOwner) lowerPrimitiveErrorWrapper(ctx lowerFileContext, sourceType types.Type, value string) string {
@@ -8898,7 +9272,8 @@ func (o *LoweringOwner) lowerPrimitiveErrorWrapper(ctx lowerFileContext, sourceT
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
 		"<$.GoError>(" + value + ", " + strconv.Quote(goRuntimeTypeString(sourceType)) +
-		", {\"Error\": " + o.methodFunctionExpr(ctx, named, fn, "Error") + "})"
+		", {\"Error\": " + o.methodFunctionExpr(ctx, named, fn, "Error") + "}, " +
+		o.runtimeTypeInfoExpr(sourceType) + ")"
 }
 
 func (o *LoweringOwner) lowerStructClone(value string) string {
@@ -8955,7 +9330,7 @@ func (o *LoweringOwner) lowerZeroValueExprFor(ctx lowerFileContext, typ types.Ty
 
 func (o *LoweringOwner) lowerDeclarationZeroValueExpr(ctx lowerFileContext, typ types.Type) string {
 	if isFunctionType(typ) {
-		return "null as " + o.tsTypeFor(ctx, typ)
+		return "null as unknown as " + o.tsFunctionZeroValueTypeFor(ctx, typ)
 	}
 	typeParam, ok := types.Unalias(typ).(*types.TypeParam)
 	if !ok {
@@ -8972,6 +9347,13 @@ func (o *LoweringOwner) lowerDeclarationZeroValueExpr(ctx lowerFileContext, typ
 		"(__typeArgs, " + strconv.Quote(typeParam.Obj().Name()) + ", " + zeroValueExpr(typ) + ")"
 }
 
+func (o *LoweringOwner) tsFunctionZeroValueTypeFor(ctx lowerFileContext, typ types.Type) string {
+	if signature := unnamedSignatureForType(typ); signature != nil {
+		return o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
+	}
+	return o.tsTypeFor(ctx, typ)
+}
+
 func (o *LoweringOwner) runtimeTypeInfoExpr(typ types.Type) string {
 	return o.runtimeTypeInfoExprWithSeen(typ, make(map[types.Type]bool))
 }
@@ -9588,6 +9970,11 @@ func namedFunctionType(typ types.Type) *types.Named {
 	return named
 }
 
+func overrideNamedStringType(ctx lowerFileContext, owner *LoweringOwner, typ types.Type) bool {
+	named, _ := types.Unalias(typ).(*types.Named)
+	return named != nil && isStringType(named) && owner.typeUsesOverride(named)
+}
+
 func isBuiltinErrorType(typ types.Type) bool {
 	if typ == nil {
 		return false
@@ -9738,6 +10125,16 @@ func isStructValueType(typ types.Type) bool {
 	return namedStructType(typ) != nil
 }
 
+func isStructComparableType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	if _, ok := types.Unalias(typ).Underlying().(*types.Struct); !ok {
+		return false
+	}
+	return types.Comparable(typ)
+}
+
 func isPointerToStructType(typ types.Type) bool {
 	pointer, ok := types.Unalias(typ).Underlying().(*types.Pointer)
 	if !ok {
@@ -9917,6 +10314,14 @@ func isFixedSignedWideIntegerType(typ types.Type) bool {
 	return ok && basic.Kind() == types.Int64
 }
 
+func isRuntimeWideIntegerType(typ types.Type) bool {
+	if isFixedWideIntegerType(typ) {
+		return true
+	}
+	bits, ok := unsignedIntegerBits(typ)
+	return ok && bits > 32
+}
+
 func isRuneSliceType(typ types.Type) bool {
 	slice, ok := types.Unalias(typ).Underlying().(*types.Slice)
 	return ok && isRuneType(slice.Elem())
@@ -10002,8 +10407,7 @@ func (o *LoweringOwner) functionAsync(ctx lowerFileContext, fn *types.Func) bool
 	if fn == nil || ctx.model == nil {
 		return false
 	}
-	semFn := semanticFunctionFor(ctx.model, fn)
-	return semFn != nil && semFn.async
+	return ctx.model.functionAsync(fn)
 }
 
 func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool {
@@ -10152,6 +10556,18 @@ func (o *LoweringOwner) inferGenericTypeArg(
 		}
 		return
 	}
+	if paramNamed, ok := types.Unalias(paramType).(*types.Named); ok {
+		if argNamed, ok := types.Unalias(argType).(*types.Named); ok &&
+			namedOriginsEqual(paramNamed, argNamed) {
+			paramArgs := paramNamed.TypeArgs()
+			argArgs := argNamed.TypeArgs()
+			if paramArgs != nil && argArgs != nil {
+				for idx := range min(paramArgs.Len(), argArgs.Len()) {
+					o.inferGenericTypeArg(inferred, paramArgs.At(idx), argArgs.At(idx))
+				}
+			}
+		}
+	}
 	switch param := types.Unalias(paramType).Underlying().(type) {
 	case *types.Slice:
 		if arg, ok := types.Unalias(argType).Underlying().(*types.Slice); ok {
@@ -10164,6 +10580,24 @@ func (o *LoweringOwner) inferGenericTypeArg(
 	}
 }
 
+func namedOriginsEqual(a, b *types.Named) bool {
+	if a == nil || b == nil {
+		return false
+	}
+	aOrigin := a.Origin()
+	if aOrigin == nil {
+		aOrigin = a
+	}
+	bOrigin := b.Origin()
+	if bOrigin == nil {
+		bOrigin = b
+	}
+	if aOrigin.Obj() == nil || bOrigin.Obj() == nil {
+		return aOrigin == bOrigin
+	}
+	return aOrigin.Obj() == bOrigin.Obj()
+}
+
 func (o *LoweringOwner) genericTypeDescriptorExpr(ctx lowerFileContext, typ types.Type) string {
 	if typeParam, ok := types.Unalias(typ).(*types.TypeParam); ok && typeParamInScope(ctx, typeParam) {
 		return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "] ?? { type: " +
@@ -10377,6 +10811,32 @@ func basicRuntimeName(basic *types.Basic) string {
 		return "bool"
 	case types.String:
 		return "string"
+	case types.Int:
+		return "int"
+	case types.Int8:
+		return "int8"
+	case types.Int16:
+		return "int16"
+	case types.Int32:
+		return "int32"
+	case types.Int64:
+		return "int64"
+	case types.Uint:
+		return "uint"
+	case types.Uint8:
+		return "uint8"
+	case types.Uint16:
+		return "uint16"
+	case types.Uint32:
+		return "uint32"
+	case types.Uint64:
+		return "uint64"
+	case types.Uintptr:
+		return "uintptr"
+	case types.Float32:
+		return "float32"
+	case types.Float64:
+		return "float64"
 	case types.Complex64:
 		return "complex64"
 	case types.Complex128: