Support if statement init

goose.go

@@ -1180,14 +1180,14 @@ func (ctx Ctx) ifStmt(s *ast.IfStmt, cont glang.Expr) glang.Expr {
 	if s.Else != nil {
 		elseExpr = ctx.stmt(s.Else, glang.Tt)
 	}
-	ife := glang.IfExpr{
+	var ife glang.Expr = glang.IfExpr{
 		Cond: ctx.expr(s.Cond),
 		Then: ctx.blockStmt(s.Body),
 		Else: elseExpr,
 	}
 
 	if s.Init != nil {
-		ctx.unsupported(s.Init, "if statement initializations")
+		ife = glang.ParenExpr{Inner: ctx.stmt(s.Init, ife)}
 	}
 	return glang.LetExpr{ValExpr: ife, Cont: cont}
 }

testdata/examples/unittest/control_flow.go

@@ -55,3 +55,21 @@ func elseIf(x, y bool) uint64 {
 		return 2
 	}
 }
+
+func ifStmtInitialization(x uint64) uint64 {
+	f := func() uint64 {
+		return x
+	}
+
+	if f(); x == 2 {
+	} else if z := x; z == 1 {
+	} else if y := 94; y == 30 {
+	} else if z = 10; x == 30 {
+	}
+
+	if y := uint64(10); x == 0 {
+		return y
+	} else {
+		return y - 1
+	}
+}

testdata/examples/unittest/unittest.gold.v

@@ -169,6 +169,52 @@ Definition elseIf : val :=
       #());;;
     do:  #()).
 
+(* go: control_flow.go:59:6 *)
+Definition ifStmtInitialization : val :=
+  rec: "ifStmtInitialization" "x" :=
+    exception_do (let: "x" := ref_ty uint64T "x" in
+    let: "f" := ref_ty funcT (zero_val funcT) in
+    let: "$r0" := (λ: <>,
+      return: (![uint64T] "x");;;
+      do:  #()
+      ) in
+    do:  ("f" <-[funcT] "$r0");;;
+    (do:  ((![funcT] "f") #());;;
+    (if: (![uint64T] "x") = #2
+    then do:  #()
+    else
+      (let: "z" := ref_ty uint64T (zero_val uint64T) in
+      let: "$r0" := ![uint64T] "x" in
+      do:  ("z" <-[uint64T] "$r0");;;
+      (if: (![uint64T] "z") = #1
+      then do:  #()
+      else
+        (let: "y" := ref_ty intT (zero_val intT) in
+        let: "$r0" := #94 in
+        do:  ("y" <-[intT] "$r0");;;
+        (if: (![intT] "y") = #30
+        then do:  #()
+        else
+          (let: "$r0" := #10 in
+          do:  ("z" <-[uint64T] "$r0");;;
+          (if: (![uint64T] "x") = #30
+          then do:  #()
+          else do:  #()));;;
+          #()));;;
+        #()));;;
+      #()));;;
+    (let: "y" := ref_ty uint64T (zero_val uint64T) in
+    let: "$r0" := #10 in
+    do:  ("y" <-[uint64T] "$r0");;;
+    (if: (![uint64T] "x") = #0
+    then
+      return: (![uint64T] "y");;;
+      do:  #()
+    else
+      return: ((![uint64T] "y") - #1);;;
+      do:  #()));;;
+    do:  #()).
+
 Definition stringWrapper : go_type := stringT.
 
 Definition stringWrapper__mset : list (string * val) := [