Merge branch 'main' of https://github.com/synnaxlabs/synnax

Author: emilbon99

arc/go/analyzer/function/function_test.go

@@ -334,7 +334,7 @@ var _ = Describe("Function Analyzer", func() {
 						last_error $= error
 						derivative := (error - last_error) / f32(dt)
 						d := kd * derivative
-						return p + i + d
+						return f64(p + i + d)
 					}
 				`, resolver)
 			})
@@ -379,8 +379,70 @@ var _ = Describe("Function Analyzer", func() {
 					}
 				}`,
 				Equal("function 'dog' must return a value of type f64 on all paths")),
+			Entry("concrete f64 expression returned from f32 function",
+				`func dog(x f64) f32 { return x * 2.0 }`,
+				ContainSubstring("cannot return f64 from 'dog': expected f32")),
+			Entry("concrete f32 expression returned from f64 function",
+				`func dog(x f32) f64 { return x * 2.0 }`,
+				ContainSubstring("cannot return f32 from 'dog': expected f64")),
+			Entry("concrete i64 expression returned from f32 function",
+				`func dog(x i64) f32 { return x * 2 }`,
+				ContainSubstring("cannot return i64 from 'dog': expected f32")),
+			Entry("concrete f64 expression returned from i32 function",
+				`func dog(x f64) i32 { return x * 2.0 }`,
+				ContainSubstring("cannot return f64 from 'dog': expected i32")),
+			Entry("concrete i32 expression returned from f32 function",
+				`func dog(x i32) f32 { return x * 2 }`,
+				ContainSubstring("cannot return i32 from 'dog': expected f32")),
 		)
 
+		It("Should reject f64 channel multiplied by f32 channel", func() {
+			resolver := symbol.MapResolver{
+				"ch_f64": {Name: "ch_f64", Kind: symbol.KindChannel, Type: types.Chan(types.F64()), ID: 1},
+				"ch_f32": {Name: "ch_f32", Kind: symbol.KindChannel, Type: types.Chan(types.F32()), ID: 2},
+			}
+			analyzeExpectError(
+				`func calc() f64 { return ch_f64 * ch_f32 }`,
+				resolver,
+				ContainSubstring("cannot use f64 and f32 in * operation"),
+			)
+		})
+
+		It("Should reject f32 channel multiplied by f64 channel", func() {
+			resolver := symbol.MapResolver{
+				"ch_f32": {Name: "ch_f32", Kind: symbol.KindChannel, Type: types.Chan(types.F32()), ID: 1},
+				"ch_f64": {Name: "ch_f64", Kind: symbol.KindChannel, Type: types.Chan(types.F64()), ID: 2},
+			}
+			ctx := analyzeProgram(`func calc() f64 { return ch_f32 * ch_f64 }`, resolver)
+			Expect(*ctx.Diagnostics).ToNot(BeEmpty())
+			Expect(ctx.Diagnostics.String()).To(ContainSubstring("cannot use f32 and f64 in * operation"))
+		})
+
+		It("Should reject f32 return when literals mask f64 channel in denominator", func() {
+			resolver := symbol.MapResolver{
+				"input_power":    {Name: "input_power", Kind: symbol.KindChannel, Type: types.Chan(types.I64()), ID: 1},
+				"drive_speed_fb": {Name: "drive_speed_fb", Kind: symbol.KindChannel, Type: types.Chan(types.F64()), ID: 2},
+			}
+			ctx := analyzeProgram(
+				`func calc() f32 { return f32(input_power*60)/(2*(3.14159)*(drive_speed_fb)) }`,
+				resolver,
+			)
+			Expect(*ctx.Diagnostics).ToNot(BeEmpty())
+			Expect(ctx.Diagnostics.String()).To(ContainSubstring("cannot use f32 and f64 in / operation"))
+		})
+
+		It("Should reject f32 expression returned from f64 function with channel inputs", func() {
+			resolver := symbol.MapResolver{
+				"input_power":    {Name: "input_power", Kind: symbol.KindChannel, Type: types.Chan(types.I64()), ID: 1},
+				"drive_speed_fb": {Name: "drive_speed_fb", Kind: symbol.KindChannel, Type: types.Chan(types.F32()), ID: 2},
+			}
+			analyzeExpectError(
+				`func calc() f64 { return f32(input_power*60)/(2*(3.14159)*(drive_speed_fb)) }`,
+				resolver,
+				ContainSubstring("cannot return f32 from 'calc': expected f64"),
+			)
+		})
+
 		Context("complete return coverage", func() {
 			It("should accept if-else with returns on all paths", func() {
 				analyzeExpectSuccess(`

arc/go/analyzer/statement/statement.go

@@ -337,8 +337,7 @@ func analyzeReturnStatement(ctx context.Context[parser.IReturnStatementContext])
 				}
 			} else {
 				isLiteral := isLiteralExpression(context.Child(ctx, returnExpr))
-				useLiteralRules := isLiteral || (actualReturnType.IsNumeric() && expectedReturnType.IsNumeric())
-				if useLiteralRules {
+				if isLiteral {
 					if !atypes.LiteralAssignmentCompatible(expectedReturnType, actualReturnType) {
 						ctx.Diagnostics.Add(diagnostics.Errorf(ctx.AST,
 							"cannot return %s from '%s': expected %s",

arc/go/analyzer/types/infer_expression.go

@@ -75,40 +75,49 @@ func InferRelational(ctx context.Context[parser.IRelationalExpressionContext]) t
 	return types.Type{}
 }
 
+func inferBinaryType(elemType, nextElem types.Type) (types.Type, bool) {
+	if elemType.Kind == types.KindVariable && nextElem.Kind != types.KindVariable {
+		elemType = nextElem
+	}
+	// Only early-return on incompatibility when both types are concrete.
+	// When either is a type variable (literal), we must keep iterating
+	// to discover later concrete types that determine the actual type.
+	bothConcrete := elemType.Kind != types.KindVariable && nextElem.Kind != types.KindVariable
+	if bothConcrete && !Compatible(elemType, nextElem) {
+		return elemType, true
+	}
+	return elemType, false
+}
+
 func InferAdditive(ctx context.Context[parser.IAdditiveExpressionContext]) types.Type {
 	multiplicatives := ctx.AST.AllMultiplicativeExpression()
 	if len(multiplicatives) == 0 {
 		return types.Type{}
 	}
 	if len(multiplicatives) > 1 {
 		firstType := InferMultiplicative(context.Child(ctx, multiplicatives[0]))
-		// Track if any operand is a series - if so, result is a series
 		isSeries := firstType.Kind == types.KindSeries
-		// Use series element type when available, as it's more concrete than scalar type variables
 		elemType := firstType.Unwrap()
 
 		for i := 1; i < len(multiplicatives); i++ {
 			nextType := InferMultiplicative(context.Child(ctx, multiplicatives[i]))
 			if nextType.Kind == types.KindSeries {
 				isSeries = true
-				// Prefer series element type over scalar type variable
 				nextElem := nextType.Unwrap()
 				if nextElem.Kind != types.KindVariable {
 					elemType = nextElem
 				}
-				if !Compatible(elemType, nextElem) {
+				bothConcrete := elemType.Kind != types.KindVariable && nextElem.Kind != types.KindVariable
+				if bothConcrete && !Compatible(elemType, nextElem) {
 					if isSeries {
 						return types.Series(elemType)
 					}
 					return elemType
 				}
 			} else {
-				nextElem := nextType.Unwrap()
-				// Prefer concrete type over type variable (literal)
-				if elemType.Kind == types.KindVariable && nextElem.Kind != types.KindVariable {
-					elemType = nextElem
-				}
-				if !Compatible(elemType, nextElem) {
+				var earlyReturn bool
+				elemType, earlyReturn = inferBinaryType(elemType, nextType.Unwrap())
+				if earlyReturn {
 					if isSeries {
 						return types.Series(elemType)
 					}
@@ -131,32 +140,27 @@ func InferMultiplicative(ctx context.Context[parser.IMultiplicativeExpressionCon
 	}
 	if len(powers) > 1 {
 		firstType := InferPower(context.Child(ctx, powers[0]))
-		// Track if any operand is a series - if so, result is a series
 		isSeries := firstType.Kind == types.KindSeries
-		// Use series element type when available, as it's more concrete than scalar type variables
 		elemType := firstType.Unwrap()
 
 		for i := 1; i < len(powers); i++ {
 			nextType := InferPower(context.Child(ctx, powers[i]))
 			if nextType.Kind == types.KindSeries {
 				isSeries = true
-				// Prefer series element type over scalar type variable
 				nextElem := nextType.Unwrap()
 				if nextElem.Kind != types.KindVariable {
 					elemType = nextElem
 				}
-				if !Compatible(elemType, nextElem) {
+				bothConcrete := elemType.Kind != types.KindVariable && nextElem.Kind != types.KindVariable
+				if bothConcrete && !Compatible(elemType, nextElem) {
 					resultType := lo.Ternary(isSeries, types.Series(elemType), elemType)
 					ctx.TypeMap[ctx.AST] = resultType
 					return resultType
 				}
 			} else {
-				nextElem := nextType.Unwrap()
-				// Prefer concrete type over type variable (literal)
-				if elemType.Kind == types.KindVariable && nextElem.Kind != types.KindVariable {
-					elemType = nextElem
-				}
-				if !Compatible(elemType, nextElem) {
+				var earlyReturn bool
+				elemType, earlyReturn = inferBinaryType(elemType, nextType.Unwrap())
+				if earlyReturn {
 					resultType := lo.Ternary(isSeries, types.Series(elemType), elemType)
 					ctx.TypeMap[ctx.AST] = resultType
 					return resultType

arc/go/analyzer/types/infer_test.go

@@ -248,6 +248,26 @@ var _ = Describe("Type Inference", func() {
 			})
 		})
 
+		Context("literals between concrete channel types", func() {
+			It("should infer f64 when concrete f64 channel follows two literals", func() {
+				// 2 * 3.14159 * pressure where pressure is f64
+				// InferMultiplicative should NOT early-return on the two literals
+				// and should discover the f64 from pressure
+				t := inferExprType(bCtx, testResolver, "2*(3.14159)*(pressure)")
+				Expect(t.Kind).To(Equal(types.KindF64))
+			})
+
+			It("should infer f32 when concrete f32 channel follows two literals", func() {
+				t := inferExprType(bCtx, testResolver, "2*(3.14159)*(temp_sensor)")
+				Expect(t.Kind).To(Equal(types.KindF32))
+			})
+
+			It("should infer i64 when concrete i64 channel follows two literals", func() {
+				t := inferExprType(bCtx, testResolver, "2*3*(i64_ch)")
+				Expect(t.Kind).To(Equal(types.KindI64))
+			})
+		})
+
 		Context("literal-left across mixed additive and multiplicative", func() {
 			It("should infer f32 for literal / f32 channel (multiplicative within additive)", func() {
 				t := inferExprType(bCtx, testResolver, "1000.0 / temp_sensor + 1")

arc/go/compiler/compiler_test.go

@@ -3609,4 +3609,88 @@ var _ = Describe("Compiler", func() {
 			}`, int32(6)),
 		)
 	})
+
+	Describe("Mixed numeric type channel arithmetic", func() {
+		It("Should compile torque-like expression with i64 and f32 channels", func() {
+			bindMockChannelModule(r, map[string]any{
+				"read_i64": func(_ context.Context, channelID uint32) int64 { return 500 },
+				"read_f32": func(_ context.Context, channelID uint32) float32 { return float32(1000.0) },
+			})
+			resolver := symbol.MapResolver(map[string]symbol.Symbol{
+				"input_power":    {Name: "input_power", Kind: symbol.KindChannel, Type: types.Chan(types.I64()), ID: 1},
+				"drive_speed_fb": {Name: "drive_speed_fb", Kind: symbol.KindChannel, Type: types.Chan(types.F32()), ID: 2},
+			})
+			output := MustSucceed(compileWithHostImports(`
+			func calculation() f32 {
+				return f32(input_power*60)/(2*(3.14159)*(drive_speed_fb))
+			}
+			`, resolver))
+			_, err := r.Instantiate(ctx, output.WASM)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("Should compile torque-like expression with f64 cast and f64 return", func() {
+			bindMockChannelModule(r, map[string]any{
+				"read_i64": func(_ context.Context, channelID uint32) int64 { return 500 },
+				"read_f64": func(_ context.Context, channelID uint32) float64 { return 1000.0 },
+			})
+			resolver := symbol.MapResolver(map[string]symbol.Symbol{
+				"input_power":    {Name: "input_power", Kind: symbol.KindChannel, Type: types.Chan(types.I64()), ID: 1},
+				"drive_speed_fb": {Name: "drive_speed_fb", Kind: symbol.KindChannel, Type: types.Chan(types.F64()), ID: 2},
+			})
+			output := MustSucceed(compileWithHostImports(`
+			func calculation() f64 {
+				return f64(input_power*60)/(2*(3.14159)*(drive_speed_fb))
+			}
+			`, resolver))
+			mod := MustSucceed(r.Instantiate(ctx, output.WASM))
+			calculation := mod.ExportedFunction("calculation")
+			Expect(calculation).ToNot(BeNil())
+			results := MustSucceed(calculation.Call(ctx))
+			Expect(results).To(HaveLen(1))
+			result := math.Float64frombits(results[0])
+			Expect(result).To(BeNumerically("~", 4.7746, 0.001))
+		})
+
+	})
+
+	Describe("Exact user reproduction from data dump", func() {
+		for _, inputType := range []struct {
+			name string
+			t    types.Type
+		}{
+			{"i64", types.I64()},
+			{"f32", types.F32()},
+			{"f64", types.F64()},
+		} {
+			It(fmt.Sprintf("Torque with input_power_calc_test=%s drive_speed_fb=f32", inputType.name), func() {
+				bindMockChannelModule(r, map[string]any{
+					"read_f32": func(_ context.Context, id uint32) float32 { return float32(1000.0) },
+					"read_f64": func(_ context.Context, id uint32) float64 { return 500.0 },
+					"read_i64": func(_ context.Context, id uint32) int64 { return 500 },
+				})
+				resolver := symbol.MapResolver(map[string]symbol.Symbol{
+					"input_power_calc_test": {
+						Name: "input_power_calc_test",
+						Kind: symbol.KindChannel,
+						Type: types.Chan(inputType.t),
+						ID:   1,
+					},
+					"drive_speed_fb": {
+						Name: "drive_speed_fb",
+						Kind: symbol.KindChannel,
+						Type: types.Chan(types.F32()),
+						ID:   2,
+					},
+				})
+				output := MustSucceed(compileWithHostImports(`
+				func calculation() f64 {
+					return f64(input_power_calc_test*60)/(2*(3.14159)*f64(drive_speed_fb))
+				}
+				`, resolver))
+				_, err := r.Instantiate(ctx, output.WASM)
+				Expect(err).ToNot(HaveOccurred())
+			})
+		}
+	})
 })

arc/go/runtime/scheduler/scheduler_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/synnaxlabs/arc/ir/testutil"
 	"github.com/synnaxlabs/arc/runtime/node"
 	"github.com/synnaxlabs/arc/runtime/scheduler"
+	"github.com/synnaxlabs/x/errors"
 	"github.com/synnaxlabs/x/telem"
 )
 
@@ -1267,7 +1268,7 @@ var _ = Describe("Scheduler", func() {
 	Describe("Error Handling", func() {
 		It("Should pass errors to error handler", func() {
 			nodeA := mock("A")
-			testErr := fmt.Errorf("test error")
+			testErr := errors.New("test error")
 			nodeA.ErrorOnNext(testErr)
 
 			prog := testutil.NewIRBuilder().
@@ -1290,7 +1291,7 @@ var _ = Describe("Scheduler", func() {
 			nodeB := mock("B")
 
 			nodeA.OnNext = func(ctx node.Context) {
-				ctx.ReportError(fmt.Errorf("error from A"))
+				ctx.ReportError(errors.New("error from A"))
 				ctx.MarkChanged("output")
 			}
 
@@ -1308,7 +1309,7 @@ var _ = Describe("Scheduler", func() {
 
 		It("Should return normally after error", func() {
 			nodeA := mock("A")
-			nodeA.ErrorOnNext(fmt.Errorf("node error"))
+			nodeA.ErrorOnNext(errors.New("node error"))
 
 			prog := testutil.NewIRBuilder().
 				Node("A").

arc/go/stl/wasm/wasm_test.go

@@ -688,7 +688,7 @@ var _ = Describe("WASM", func() {
 	Describe("Series Literal Edge Cases", func() {
 		DescribeTable("empty series",
 			func(elemType string, outType types.Type) {
-				expectOutput("empty_series", types.I32(), `{
+				expectOutput("empty_series", types.I64(), `{
 				s series `+elemType+` := []
 				return len(s)
 			}`, stl.SymbolResolver, int32(0))
@@ -894,19 +894,19 @@ var _ = Describe("WASM", func() {
 	Describe("Series Length Operations", func() {
 		DescribeTable("len() function",
 			expectOutput[int32],
-			Entry("empty series", "len_empty", types.I32(), `{
+			Entry("empty series", "len_empty", types.I64(), `{
 				s series f64 := []
 				return len(s)
 			}`, stl.SymbolResolver, int32(0)),
-			Entry("single element", "len_one", types.I32(), `{
+			Entry("single element", "len_one", types.I64(), `{
 				s series f64 := [1.0]
 				return len(s)
 			}`, stl.SymbolResolver, int32(1)),
-			Entry("five elements", "len_five", types.I32(), `{
+			Entry("five elements", "len_five", types.I64(), `{
 				s series f64 := [1.0, 2.0, 3.0, 4.0, 5.0]
 				return len(s)
 			}`, stl.SymbolResolver, int32(5)),
-			Entry("after operation", "len_after_op", types.I32(), `{
+			Entry("after operation", "len_after_op", types.I64(), `{
 				a series f64 := [1.0, 2.0, 3.0]
 				b series f64 := [4.0, 5.0, 6.0]
 				c series f64 := a + b
@@ -918,19 +918,19 @@ var _ = Describe("WASM", func() {
 	Describe("String Operations Extended", func() {
 		DescribeTable("string len() function",
 			expectOutput[int32],
-			Entry("empty string", "len_empty_str", types.I32(), `{
+			Entry("empty string", "len_empty_str", types.I64(), `{
 				return len("")
 			}`, stl.SymbolResolver, int32(0)),
-			Entry("simple string", "len_str", types.I32(), `{
+			Entry("simple string", "len_str", types.I64(), `{
 				return len("hello")
 			}`, stl.SymbolResolver, int32(5)),
-			Entry("concatenated strings", "len_concat", types.I32(), `{
+			Entry("concatenated strings", "len_concat", types.I64(), `{
 				return len("ab" + "cd")
 			}`, stl.SymbolResolver, int32(4)),
-			Entry("triple concatenation", "len_triple", types.I32(), `{
+			Entry("triple concatenation", "len_triple", types.I64(), `{
 				return len("a" + "b" + "c")
 			}`, stl.SymbolResolver, int32(3)),
-			Entry("variable concatenation", "len_var_concat", types.I32(), `{
+			Entry("variable concatenation", "len_var_concat", types.I64(), `{
 				a str := "hello"
 				b str := " world"
 				return len(a + b)