prog: return concrete arg types from Make functions

This removes a bunch of type assertions and makes code type safer.

4 files changed, 16 insertions, 16 deletions

diff --git a/prog/hints_test.go b/prog/hints_test.go
index a3fd94c62..6648693d3 100644
--- a/prog/hints_test.go
+++ b/prog/hints_test.go
@@ -162,7 +162,7 @@ func TestHintsCheckDataArg(t *testing.T) {
 			// Whatever type here. It's just needed to pass the
 			// dataArg.Type().Dir() == DirIn check.
 			typ := &ArrayType{TypeCommon{"", "", 0, DirIn, false, true}, nil, 0, 0, 0}
-			dataArg := MakeDataArg(typ, []byte(test.in)).(*DataArg)
+			dataArg := MakeDataArg(typ, []byte(test.in))
 			checkDataArg(dataArg, test.comps, func() {
 				res[string(dataArg.Data())] = true
 			})
diff --git a/prog/prog.go b/prog/prog.go
index dc6121662..3c01ae65a 100644
--- a/prog/prog.go
+++ b/prog/prog.go
@@ -55,7 +55,7 @@ type ConstArg struct {
 	Val uint64
 }
 
-func MakeConstArg(t Type, v uint64) Arg {
+func MakeConstArg(t Type, v uint64) *ConstArg {
 	return &ConstArg{ArgCommon: ArgCommon{typ: t}, Val: v}
 }
 
@@ -141,14 +141,14 @@ type DataArg struct {
 	size uint64 // for out Args
 }
 
-func MakeDataArg(t Type, data []byte) Arg {
+func MakeDataArg(t Type, data []byte) *DataArg {
 	if t.Dir() == DirOut {
 		panic("non-empty output data arg")
 	}
 	return &DataArg{ArgCommon: ArgCommon{typ: t}, data: append([]byte{}, data...)}
 }
 
-func MakeOutDataArg(t Type, size uint64) Arg {
+func MakeOutDataArg(t Type, size uint64) *DataArg {
 	if t.Dir() != DirOut {
 		panic("empty input data arg")
 	}
@@ -176,7 +176,7 @@ type GroupArg struct {
 	Inner []Arg
 }
 
-func MakeGroupArg(t Type, inner []Arg) Arg {
+func MakeGroupArg(t Type, inner []Arg) *GroupArg {
 	return &GroupArg{ArgCommon: ArgCommon{typ: t}, Inner: inner}
 }
 
@@ -225,7 +225,7 @@ type UnionArg struct {
 	Option Arg
 }
 
-func MakeUnionArg(t Type, opt Arg) Arg {
+func MakeUnionArg(t Type, opt Arg) *UnionArg {
 	return &UnionArg{ArgCommon: ArgCommon{typ: t}, Option: opt}
 }
 
@@ -248,7 +248,7 @@ type ResultArg struct {
 	uses  map[Arg]bool // ArgResult args that use this arg
 }
 
-func MakeResultArg(t Type, r Arg, v uint64) Arg {
+func MakeResultArg(t Type, r Arg, v uint64) *ResultArg {
 	arg := &ResultArg{ArgCommon: ArgCommon{typ: t}, Res: r, Val: v}
 	if r == nil {
 		return arg
@@ -280,7 +280,7 @@ type ReturnArg struct {
 	uses map[Arg]bool // ArgResult args that use this arg
 }
 
-func MakeReturnArg(t Type) Arg {
+func MakeReturnArg(t Type) *ReturnArg {
 	return &ReturnArg{ArgCommon: ArgCommon{typ: t}}
 }
 
@@ -534,7 +534,7 @@ func removeArg(arg0 Arg) {
 					panic("use references not ArgResult")
 				}
 				arg2 := MakeResultArg(arg1.Type(), nil, arg1.Type().Default())
-				replaceResultArg(a1, arg2.(*ResultArg))
+				replaceResultArg(a1, arg2)
 			}
 		}
 	})
diff --git a/sys/linux/init.go b/sys/linux/init.go
index d127efbfb..4e04f237b 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -259,17 +259,17 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, old prog.Arg) (a
 			Ret: prog.MakeReturnArg(meta.Ret),
 		}
 		calls = append(calls, gettime)
-		sec := prog.MakeResultArg(typ.Fields[0], tp.(*prog.GroupArg).Inner[0], 0)
-		nsec := prog.MakeResultArg(typ.Fields[1], tp.(*prog.GroupArg).Inner[1], 0)
+		sec := prog.MakeResultArg(typ.Fields[0], tp.Inner[0], 0)
+		nsec := prog.MakeResultArg(typ.Fields[1], tp.Inner[1], 0)
 		msec := uint64(10)
 		if g.NOutOf(1, 2) {
 			msec = 30
 		}
 		if usec {
-			nsec.(*prog.ResultArg).OpDiv = 1e3
-			nsec.(*prog.ResultArg).OpAdd = msec * 1e3
+			nsec.OpDiv = 1e3
+			nsec.OpAdd = msec * 1e3
 		} else {
-			nsec.(*prog.ResultArg).OpAdd = msec * 1e6
+			nsec.OpAdd = msec * 1e6
 		}
 		arg = prog.MakeGroupArg(typ, []prog.Arg{sec, nsec})
 	}
diff --git a/sys/linux/init_alg.go b/sys/linux/init_alg.go
index 8b7791f00..4094bb2cd 100644
--- a/sys/linux/init_alg.go
+++ b/sys/linux/init_alg.go
@@ -18,8 +18,8 @@ func (arch *arch) generateSockaddrAlg(g *prog.Gen, typ0 prog.Type, old prog.Arg)
 	feat := prog.MakeConstArg(typ.Fields[2], 0)
 	mask := prog.MakeConstArg(typ.Fields[3], 0)
 	if g.NOutOf(1, 1000) {
-		feat = g.GenerateArg(typ.Fields[2], &calls)
-		mask = g.GenerateArg(typ.Fields[3], &calls)
+		feat = g.GenerateArg(typ.Fields[2], &calls).(*prog.ConstArg)
+		mask = g.GenerateArg(typ.Fields[3], &calls).(*prog.ConstArg)
 	}
 	algType, algName := generateAlgName(g.Rand())
 	// Extend/truncate type/name to their fixed sizes.