Fix deadlock in errors-must e2e test

.github/workflows/lint.yml

@@ -17,10 +17,10 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: false
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.60
+          version: v1.64
           only-new-issues: true

.gitignore

@@ -28,6 +28,7 @@ cmd/tmp
 /neva-lsp-windows-arm64.exe
 dist
 trace.log
+ir.yml
 output
 node_modules
 __debug*

.vscode/launch.json

@@ -7,7 +7,7 @@
       "request": "launch",
       "mode": "auto",
       "program": "${workspaceFolder}/cmd/neva",
-      "cwd": "${workspaceFolder}/e2e/for_with_range_and_if",
+      "cwd": "${workspaceFolder}/e2e/errors_must",
       "args": ["run", "--trace", "main"]
     },
     {

benchmarks/message_passing/bench_test.go

@@ -30,7 +30,7 @@ func BenchmarkMessagePassing(b *testing.B) {
 	// Reset timer after setup
 	b.ResetTimer()
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		cmd := exec.Command("neva", "run", "message_passing")
 		out, err := cmd.CombinedOutput()
 		require.NoError(b, err, string(out))

e2e/cli/run_with_ir/e2e_test.go

@@ -0,0 +1,39 @@
+package test
+
+import (
+	"os"
+	"os/exec"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+)
+
+func Test(t *testing.T) {
+	defer func() {
+		require.NoError(t, os.RemoveAll("src"))
+		require.NoError(t, os.Remove("ir.yml"))
+	}()
+
+	// Create new project
+	cmd := exec.Command("neva", "new")
+	require.NoError(t, cmd.Run())
+
+	// Run with IR emission
+	cmd = exec.Command("neva", "run", "--emit-ir", "src")
+	out, err := cmd.CombinedOutput()
+	require.NoError(t, err)
+	require.Equal(t, "Hello, World!\n", string(out))
+	require.Equal(t, 0, cmd.ProcessState.ExitCode())
+
+	// Verify IR file exists and is valid YAML
+	irBytes, err := os.ReadFile("ir.yml")
+	require.NoError(t, err)
+
+	var ir struct {
+		Connections map[string]string `yaml:"connections"`
+		Funcs       []any             `yaml:"funcs"`
+	}
+	require.NoError(t, yaml.Unmarshal(irBytes, &ir))
+	require.NotEmpty(t, ir.Funcs)
+}

e2e/cli/run_with_ir/neva.yml

@@ -0,0 +1 @@
+neva: 0.31.0

e2e/errors_must/e2e_test.go

@@ -8,15 +8,18 @@ import (
 )
 
 func Test(t *testing.T) {
-	cmd := exec.Command("neva", "run", "main")
+	// we run N times to make sure https://github.com/nevalang/neva/issues/872 is fixed
+	for range 10 {
+		cmd := exec.Command("neva", "run", "main")
 
-	out, err := cmd.CombinedOutput()
-	require.NoError(t, err)
-	require.Equal(
-		t,
-		"success!\n",
-		string(out),
-	)
+		out, err := cmd.CombinedOutput()
+		require.NoError(t, err)
+		require.Equal(
+			t,
+			"success!\n",
+			string(out),
+		)
 
-	require.Equal(t, 0, cmd.ProcessState.ExitCode())
+		require.Equal(t, 0, cmd.ProcessState.ExitCode())
+	}
 }

examples/delayed_echo/e2e_test.go

@@ -11,6 +11,7 @@ import (
 )
 
 func Test(t *testing.T) {
+	// for i := 0; i < 10; i++ {
 	err := os.Chdir("..")
 	require.NoError(t, err)
 
@@ -23,18 +24,18 @@ func Test(t *testing.T) {
 	start := time.Now()
 	out, err := cmd.CombinedOutput()
 	elapsed := time.Since(start)
-	require.NoError(t, err)
+	require.NoError(t, err, string(out))
 
 	// Check execution time is between 1-5 seconds
 	require.GreaterOrEqual(t, elapsed.Seconds(), 1.0)
 	require.LessOrEqual(t, elapsed.Seconds(), 5.0)
 
 	// Split output into lines and verify contents
 	lines := strings.Split(strings.TrimSpace(string(out)), "\n")
-	require.Equal(t, 7, len(lines)) // Hello + World + 5 numbers
+	require.Equal(t, 7, len(lines), string(out)) // Hello + World + 5 numbers
 
 	// First line must be Hello
-	require.Equal(t, "Hello", lines[0])
+	require.Equal(t, "Hello", lines[0], string(out))
 
 	// Create set of expected remaining values
 	expected := map[string]bool{
@@ -59,4 +60,5 @@ func Test(t *testing.T) {
 	}
 
 	require.Equal(t, 0, cmd.ProcessState.ExitCode())
+	// }
 }

go.mod

@@ -1,6 +1,6 @@
 module github.com/nevalang/neva
 
-go 1.23
+go 1.24
 
 require (
 	github.com/Masterminds/semver/v3 v3.2.1

internal/cli/run.go

@@ -22,6 +22,10 @@ func newRunCmd(workdir string, nativec compiler.Compiler) *cli.Command {
 				Name:  "trace",
 				Usage: "Write trace information to file",
 			},
+			&cli.BoolFlag{
+				Name:  "emit-ir",
+				Usage: "Emit intermediate representation to ir.yml file",
+			},
 		},
 		ArgsUsage: "Provide path to main package",
 		Action: func(cliCtx *cli.Context) error {
@@ -30,10 +34,8 @@ func newRunCmd(workdir string, nativec compiler.Compiler) *cli.Command {
 				return err
 			}
 
-			var trace bool
-			if cliCtx.IsSet("trace") {
-				trace = true
-			}
+			trace := cliCtx.IsSet("trace")
+			emitIR := cliCtx.IsSet("emit-ir")
 
 			// we need to always set GOOS for compiler backend
 			prevGOOS := os.Getenv("GOOS")
@@ -55,6 +57,7 @@ func newRunCmd(workdir string, nativec compiler.Compiler) *cli.Command {
 				Main:   mainPkg,
 				Output: workdir,
 				Trace:  trace,
+				EmitIR: emitIR,
 			}
 
 			if err := nativec.Compile(cliCtx.Context, input); err != nil {

internal/compiler/compiler.go

@@ -3,8 +3,13 @@ package compiler
 import (
 	"context"
 	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 
+	"gopkg.in/yaml.v3"
+
 	"github.com/nevalang/neva/internal/compiler/ir"
 	"github.com/nevalang/neva/internal/compiler/sourcecode"
 	"github.com/nevalang/neva/internal/compiler/sourcecode/core"
@@ -20,6 +25,7 @@ type CompilerInput struct {
 	Main   string
 	Output string
 	Trace  bool
+	EmitIR bool
 }
 
 func (c Compiler) Compile(ctx context.Context, input CompilerInput) error {
@@ -33,9 +39,26 @@ func (c Compiler) Compile(ctx context.Context, input CompilerInput) error {
 		return err
 	}
 
+	if input.EmitIR {
+		if err := c.emitIR(input.Output, meResult.IR); err != nil {
+			return fmt.Errorf("emit IR: %w", err)
+		}
+	}
+
 	return c.be.Emit(input.Output, meResult.IR, input.Trace)
 }
 
+func (c Compiler) emitIR(dst string, prog *ir.Program) error {
+	path := filepath.Join(dst, "ir.yml")
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// fmt.Println(dst, path, prog)
+	return yaml.NewEncoder(f).Encode(prog)
+}
+
 type Frontend struct {
 	builder Builder
 	parser  Parser

internal/compiler/desugarer/desugarer.go

@@ -120,8 +120,7 @@ type Scope interface {
 	Entity(ref core.EntityRef) (src.Entity, core.Location, error)
 	Relocate(location core.Location) src.Scope
 	Location() *core.Location
-	GetFirstInportName(nodes map[string]src.Node, portAddr src.PortAddr) (string, error)
-	GetFirstOutportName(nodes map[string]src.Node, portAddr src.PortAddr) (string, error)
+	GetNodeIOByPortAddr(nodes map[string]src.Node, portAddr src.PortAddr) (src.IO, error)
 }
 
 func (d *Desugarer) desugarPkg(pkg src.Package, scope Scope) (src.Package, error) {

internal/compiler/desugarer/network.go

@@ -1,6 +1,7 @@
 package desugarer
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/nevalang/neva/internal/compiler"
@@ -238,7 +239,7 @@ func (d *Desugarer) desugarSingleReceiver(
 			}, nil
 		}
 
-		firstInportName, err := scope.GetFirstInportName(nodes, *receiver.PortAddr)
+		firstInportName, err := d.getFirstInportName(scope, nodes, *receiver.PortAddr)
 		if err != nil {
 			return desugarReceiverResult{}, fmt.Errorf("get first inport name: %w", err)
 		}
@@ -441,7 +442,7 @@ func (d *Desugarer) desugarChainedConnection(
 		chainHeadPort = chainHead.PortAddr.Port
 		if chainHeadPort == "" {
 			var err error
-			chainHeadPort, err = scope.GetFirstInportName(nodes, *chainHead.PortAddr)
+			chainHeadPort, err = d.getFirstInportName(scope, nodes, *chainHead.PortAddr)
 			if err != nil {
 				return desugarConnectionResult{}, fmt.Errorf("get first inport name: %w", err)
 			}
@@ -688,7 +689,7 @@ func (d *Desugarer) desugarSingleSender(
 	if sender.PortAddr != nil {
 		portName := sender.PortAddr.Port
 		if sender.PortAddr.Port == "" {
-			firstOutportName, err := scope.GetFirstOutportName(nodes, *sender.PortAddr)
+			firstOutportName, err := d.getFirstOutportName(scope, nodes, *sender.PortAddr)
 			if err != nil {
 				return desugarSenderResult{}, fmt.Errorf("get first outport name: %w", err)
 			}
@@ -842,6 +843,42 @@ func (d *Desugarer) desugarSingleSender(
 	}, nil
 }
 
+func (d *Desugarer) getFirstInportName(
+	scope Scope,
+	nodes map[string]src.Node,
+	portAddr src.PortAddr,
+) (string, error) {
+	io, err := scope.GetNodeIOByPortAddr(nodes, portAddr)
+	if err != nil {
+		return "", err
+	}
+	for inport := range io.In {
+		return inport, nil
+	}
+	return "", errors.New("first inport not found")
+}
+
+func (d *Desugarer) getFirstOutportName(
+	scope Scope,
+	nodes map[string]src.Node,
+	portAddr src.PortAddr,
+) (string, error) {
+	io, err := scope.GetNodeIOByPortAddr(nodes, portAddr)
+	if err != nil {
+		return "", err
+	}
+
+	// important: skip `err` outport if node has err guard
+	for outport := range io.Out {
+		if outport == "err" && nodes[portAddr.Node].ErrGuard {
+			continue
+		}
+		return outport, nil
+	}
+
+	return "", errors.New("first outport not found")
+}
+
 var newComponentRef = core.EntityRef{
 	Pkg:  "builtin",
 	Name: "New",