Merge pull request #512 from nevalang/fix_array_inport_iteration_order

fix(irgen): sort port addrs

.vscode/launch.json

@@ -205,6 +205,15 @@
       "cwd": "${workspaceFolder}/examples",
       "args": ["run", "11_99_bottles"]
     },
+    {
+      "name": "Neva CLI 113",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "program": "${workspaceFolder}/cmd/neva",
+      "cwd": "${workspaceFolder}/examples",
+      "args": ["run", "13_subtract"]
+    },
     // run (e2e tests)
     {
       "name": "E2E struct_selector_on_port_addr",

internal/compiler/irgen/network.go

@@ -2,6 +2,7 @@ package irgen
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/nevalang/neva/internal/runtime/ir"
@@ -153,7 +154,6 @@ func (g Generator) processSenderSide(
 
 	return irSenderSide, nil
 }
-
 func (Generator) insertAndReturnInports(
 	nodeCtx nodeContext,
 	result *ir.Program,
@@ -175,14 +175,30 @@ func (Generator) insertAndReturnInports(
 		inports = append(inports, *addr)
 	}
 
+	sortPortAddrs(inports)
+
 	return inports
 }
 
+// sortPortAddrs sorts port addresses by path, port and idx,
+// this is very important because runtime function calls depends on this order.
+func sortPortAddrs(addrs []ir.PortAddr) {
+	sort.Slice(addrs, func(i, j int) bool {
+		if addrs[i].Path != addrs[j].Path {
+			return addrs[i].Path < addrs[j].Path
+		}
+		if addrs[i].Port != addrs[j].Port {
+			return addrs[i].Port < addrs[j].Port
+		}
+		return addrs[i].Idx < addrs[j].Idx
+	})
+}
+
 func (Generator) insertAndReturnOutports(
 	nodeCtx nodeContext,
 	result *ir.Program,
 ) []ir.PortAddr {
-	runtimeFuncOutportAddrs := make([]ir.PortAddr, 0, len(nodeCtx.portsUsage.out))
+	outports := make([]ir.PortAddr, 0, len(nodeCtx.portsUsage.out))
 
 	// In a valid (desugared) program all outports are used so it's safe to depend on nodeCtx and not use component's IO.
 	// Actually we can't use IO because we need to know how many slots are used.
@@ -196,10 +212,12 @@ func (Generator) insertAndReturnOutports(
 			PortAddr: *irAddr,
 			BufSize:  0,
 		})
-		runtimeFuncOutportAddrs = append(runtimeFuncOutportAddrs, *irAddr)
+		outports = append(outports, *irAddr)
 	}
 
-	return runtimeFuncOutportAddrs
+	sortPortAddrs(outports)
+
+	return outports
 }
 
 // mapReceiverSide maps compiler connection side to ir connection side 1-1 just making the port addr's path absolute

internal/compiler/irgen/network_test.go

@@ -1,6 +1,11 @@
 package irgen
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/nevalang/neva/internal/runtime/ir"
+	"github.com/stretchr/testify/require"
+)
 
 func Test_joinNodePath(t *testing.T) {
 	type args struct {
@@ -29,3 +34,39 @@ func Test_joinNodePath(t *testing.T) {
 		})
 	}
 }
+
+func Test_sortPortAddrs(t *testing.T) {
+	tests := []struct {
+		name  string
+		addrs []ir.PortAddr
+		want  []ir.PortAddr
+	}{
+		{
+			name: "messed up order",
+			addrs: []ir.PortAddr{
+				{Path: "b", Port: "A", Idx: 1},
+				{Path: "b", Port: "A", Idx: 0},
+				{Path: "a", Port: "B", Idx: 0},
+				{Path: "a", Port: "B", Idx: 1},
+				{Path: "a", Port: "A", Idx: 2},
+				{Path: "a", Port: "A", Idx: 1},
+				{Path: "a", Port: "A", Idx: 0},
+			},
+			want: []ir.PortAddr{
+				{Path: "a", Port: "A", Idx: 0},
+				{Path: "a", Port: "A", Idx: 1},
+				{Path: "a", Port: "A", Idx: 2},
+				{Path: "a", Port: "B", Idx: 0},
+				{Path: "a", Port: "B", Idx: 1},
+				{Path: "b", Port: "A", Idx: 0},
+				{Path: "b", Port: "A", Idx: 1},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sortPortAddrs(tt.addrs)
+			require.Equal(t, tt.want, tt.addrs)
+		})
+	}
+}

internal/runtime/ir/ir.go

@@ -40,8 +40,8 @@ type FuncCall struct {
 
 // FuncIO represents the input/output ports of a function.
 type FuncIO struct {
-	In  []PortAddr
-	Out []PortAddr
+	In  []PortAddr // Must be ordered by path -> port -> idx
+	Out []PortAddr // Must be ordered by path -> port -> idx
 }
 
 // Msg represents a message.