Removed some unnessecary parentheses from tuples and did some general cleanup

phases/context.ml

@@ -10,8 +10,8 @@ let mapfind name tbl =
   if Hashtbl.mem tbl name then Some (Hashtbl.find tbl name) else None
 
 let check_in_scope name errnode scope err =
-  let (vars, funs) = scope in
-  let (name, tbl, other_map, desired_type) = match name with
+  let vars, funs = scope in
+  let name, tbl, other_map, desired_type = match name with
   | Varname  name -> (name, vars, funs, "variable")
   | Funcname name -> (name, funs, vars, "function")
   in
@@ -27,9 +27,9 @@ let check_in_scope name errnode scope err =
     (DummyNode, -1)
 
 let add_to_scope name dec depth (vars, funs) =
-  let (name, tbl, name_type) = match name with
-  | Varname name  -> (name, vars, "variable")
-  | Funcname name -> (name, funs, "function")
+  let name, tbl, name_type = match name with
+  | Varname name  -> name, vars, "variable"
+  | Funcname name -> name, funs, "function"
   in
   match mapfind name tbl with
   (* Identifiers of lower depth may be overwritten, but idenetifiers at
@@ -79,21 +79,21 @@ let rec analyse scope depth node err =
     (* For a variable or function call, look for its declaration in the
      * current scope and save a its type/depth information  *)
     | Var (name, dims, ann) ->
-      let (dec, dec_depth) = check_in_scope (Varname name) node scope err in
+      let dec, dec_depth = check_in_scope (Varname name) node scope err in
       VarUse (dec, optmap collect dims, Depth depth :: ann)
 
     | FunCall (name, args, ann) ->
-      let (dec, dec_depth) = check_in_scope (Funcname name) node scope err in
+      let dec, dec_depth = check_in_scope (Funcname name) node scope err in
       FunUse (dec, List.map collect args, Depth depth :: ann)
 
     (* Assign statements are replaced with VarLet nodes, which stores the
      * declaration of the assigned variable *)
     | Assign (name, dims, value, ann) ->
-      let (dec, dec_depth) = check_in_scope (Varname name) node scope err in
+      let dec, dec_depth = check_in_scope (Varname name) node scope err in
       VarLet (dec, optmap collect dims, collect value, Depth depth :: ann)
 
     | Allocate (dec, dims, ann) ->
-      let (dec, dec_depth) = check_in_scope (Varname (nameof dec)) node scope err in
+      let dec, dec_depth = check_in_scope (Varname (nameof dec)) node scope err in
       Allocate (dec, List.map collect dims, Depth depth :: ann)
 
     | _ -> traverse_unit collect node
@@ -103,7 +103,7 @@ let rec analyse scope depth node err =
     match node with
     (* Increase nesting level when entering function *)
     | FunDef (export, ret_type, name, params, body, ann) ->
-      let (vars, funs) = scope in
+      let vars, funs = scope in
       let local_scope = (Hashtbl.copy vars, Hashtbl.copy funs) in
       let params = List.map (traverse local_scope (depth + 1)) params in
       let body = analyse local_scope (depth + 1) body err in

phases/desug.ml

@@ -83,14 +83,14 @@ let array_dims node =
   let rec trav = function
     | VarDec (ArrayDims (ctype, values), name, init, ann) ->
       let make_decs value name = [VarDec (Int, name, Some value, [])] in
-      let (decs, dims) = patch_dims name values make_decs in
+      let decs, dims = patch_dims name values make_decs in
       Block (decs @ [VarDec (ArrayDims (ctype, dims), name, init, ann)])
 
     | GlobalDef (export, ArrayDims (ctype, values), name, init, ann) ->
       (* Move array dimensions into new variables to avoid double evaluation of
       * expressions with side effects (i.e. function calls) *)
       let make_decs value name = [GlobalDef (export, Int, name, Some value, [])] in
-      let (decs, dims) = patch_dims name values make_decs in
+      let decs, dims = patch_dims name values make_decs in
       Block (decs @ [GlobalDef (export, ArrayDims (ctype, dims), name, init, ann)])
 
     | GlobalDec (ArrayDims (ctype, dims), name, ann) ->
@@ -112,7 +112,7 @@ let array_dims node =
           [GlobalDec (Int, impname, [])]
         | _ -> raise InvalidNode
       in
-      let (decs, dims) = patch_dims name dims make_decs in
+      let decs, dims = patch_dims name dims make_decs in
       Block (decs @ [GlobalDec (ArrayDims (ctype, dims), name, ann)])
 
       (*
@@ -126,7 +126,7 @@ let array_dims node =
           (decs, Dim (impname, dimann))
         | _ -> raise InvalidNode
       in
-      let (decs, dims) = List.split (mapi make_decs dims) in
+      let decs, dims = List.split (mapi make_decs dims) in
       Block (List.concat decs @ [GlobalDec (ArrayDims (ctype, dims), name, ann)])
       *)
 
@@ -186,7 +186,7 @@ let extract_inits lst =
     | (Allocate _ as hd) :: tl ->
       trav (hd :: inits) tl
     | hd :: tl ->
-      let (inits, tl) = trav inits tl in
+      let inits, tl = trav inits tl in
       (inits, (hd :: tl))
   in trav [] lst
 
@@ -206,7 +206,7 @@ let rec move_inits = function
   | FunDef (export, ret_type, name, params, Block body, ann) ->
     let rec place_inits inits = function
       | VarDecs lst :: tl ->
-        let (inits, decs) = extract_inits lst in
+        let inits, decs = extract_inits lst in
         VarDecs decs :: (place_inits inits tl)
       | LocalFuns _ as hd :: tl ->
         hd :: inits @ tl

phases/load.ml

@@ -44,7 +44,7 @@ let phase = function
           Unix.open_process_in (cpp_cmd ^ " " ^ filename)
         | None ->
           let content = input_buffered stdin bufsize in
-          let (cpp_out, cpp_in) = Unix.open_process cpp_cmd in
+          let cpp_out, cpp_in = Unix.open_process cpp_cmd in
           output_string cpp_in content;
           close_out cpp_in;
           cpp_out

phases/typecheck.ml

@@ -87,18 +87,18 @@ let check_dims_match dims dec_type errnode =
   | _ -> []
 
 let err_map f nodes =
-  let (n, e) = List.split (List.map f nodes) in
+  let n, e = List.split (List.map f nodes) in
   (n, List.concat e)
 
 let default_unknown ctype = function [] -> ctype | _ -> Unknown
 
 let rec typecheck node =
   let add_error node msg =
-    let (node, err) = traverse_list typecheck node in
+    let node, err = traverse_list typecheck node in
     (annotate (Type Unknown) node, NodeMsg (node, msg) :: err)
   in
   let check_trav ctype node =
-    let (node, err) = typecheck node in
+    let node, err = typecheck node in
     (node, err @ check_type ctype node)
   in
   match node with
@@ -111,7 +111,7 @@ let rec typecheck node =
           "function \"%s\" expects %d arguments, got %d"
           name nparams nargs)
       | _ ->
-        let (args, aerr) = err_map typecheck args in
+        let args, aerr = err_map typecheck args in
         let check_arg_type arg param = check_type (typeof param) arg in
         let err = List.concat (List.map2 check_arg_type args params) in
         (FunUse (dec, args, Type ret_type :: ann), aerr @ err)
@@ -119,7 +119,7 @@ let rec typecheck node =
 
   (* Operators match operand types and get a new type based on the operator *)
   | Monop (op, opnd, ann) ->
-    let (opnd, oerr) = typecheck opnd in
+    let opnd, oerr = typecheck opnd in
     let desc = sprintf "unary operator \"%s\"" (op2str op) in
     let err = check_type_op (op_types op) desc opnd in
     let res_type = default_unknown (typeof opnd) err in
@@ -127,8 +127,8 @@ let rec typecheck node =
      oerr @ err)
 
   | Binop (op, left, right, ann) ->
-    let (left, lerr) = typecheck left in
-    let (right, rerr) = typecheck right in
+    let left, lerr = typecheck left in
+    let right, rerr = typecheck right in
     let desc = sprintf "binary operator \"%s\"" (op2str op) in
     let err =
       (* Only compare operand types if left operand has a valid type *)
@@ -151,20 +151,20 @@ let rec typecheck node =
 
   (* Conditions must be bool, and right-hand type must match left-hand type *)
   | Cond (cond, texpr, fexpr, ann) ->
-    let (cond, cerr) = check_trav Bool cond in
-    let (texpr, terr) = typecheck texpr in
-    let (fexpr, ferr) = check_trav (typeof texpr) fexpr in
+    let cond, cerr = check_trav Bool cond in
+    let texpr, terr = typecheck texpr in
+    let fexpr, ferr = check_trav (typeof texpr) fexpr in
     (Cond (cond, texpr, fexpr, Type (typeof texpr) :: ann), cerr @ terr @ ferr)
 
   (* Only basic types can be typecasted *)
   | TypeCast (ctype, value, ann) ->
-    let (value, err) = typecheck value in
+    let value, err = typecheck value in
     let err = err @ check_type_op [Bool; Int; Float] "typecast" value in
     (TypeCast (ctype, value, Type ctype :: ann), err)
 
   (* Array allocation dimensions must have type int *)
   | Allocate (dec, dims, ann) ->
-    let (dims, err) = err_map typecheck dims in
+    let dims, err = err_map typecheck dims in
     let err = err @ List.concat (List.map (check_type Int) dims) in
     (Allocate (dec, dims, ann), err)
 
@@ -175,8 +175,8 @@ let rec typecheck node =
   (* Void functions may have no return statement, other functions must have a
    * return statement of valid type *)
   | FunDef (export, ret_type, name, params, body, ann) ->
-    let (params, perr) = err_map typecheck params in
-    let (body, berr) = typecheck body in
+    let params, perr = err_map typecheck params in
+    let body, berr = typecheck body in
     let rec find_return = function
       | []                         -> None
       | [Return (value, _) as ret] -> Some (ret, typeof value)
@@ -203,21 +203,21 @@ let rec typecheck node =
 
   (* Conditions in must have type bool *)
   | If (cond, body, ann) ->
-    let (cond, cerr) = check_trav Bool cond in
-    let (body, berr) = typecheck body in
+    let cond, cerr = check_trav Bool cond in
+    let body, berr = typecheck body in
     (If (cond, body, ann), cerr @ berr)
   | IfElse (cond, tbody, fbody, ann) ->
-    let (cond, cerr) = check_trav Bool cond in
-    let (tbody, terr) = typecheck tbody in
-    let (fbody, ferr) = typecheck fbody in
+    let cond, cerr = check_trav Bool cond in
+    let tbody, terr = typecheck tbody in
+    let fbody, ferr = typecheck fbody in
     (IfElse (cond, tbody, fbody, ann), cerr @ terr @ ferr)
   | While (cond, body, ann) ->
-    let (cond, cerr) = check_trav Bool cond in
-    let (body, berr) = typecheck body in
+    let cond, cerr = check_trav Bool cond in
+    let body, berr = typecheck body in
     (While (cond, body, ann), cerr @ berr)
   | DoWhile (cond, body, ann) ->
-    let (body, berr) = typecheck body in
-    let (cond, cerr) = check_trav Bool cond in
+    let body, berr = typecheck body in
+    let cond, cerr = check_trav Bool cond in
     (DoWhile (cond, body, ann), berr @ cerr)
 
   (* Constants *)
@@ -234,7 +234,7 @@ let rec typecheck node =
 
   | VarUse (dec, Some dims, ann) ->
     (* Dimensions must have int type *)
-    let (dims, err) = err_map typecheck dims in
+    let dims, err = err_map typecheck dims in
     let err = err @ List.concat (List.map (check_type Int) dims) in
 
     (* Number of indices must match number of array dimensions *)
@@ -248,7 +248,7 @@ let rec typecheck node =
 
   (* Assigned values must match variable declaration *)
   | VarLet (dec, None, value, ann) ->
-    let (value, err) = typecheck value in
+    let value, err = typecheck value in
     let err = err @ check_type (typeof dec) value in
     (VarLet (dec, None, value, ann), err)
 
@@ -257,11 +257,11 @@ let rec typecheck node =
     let err1 = check_dims_match dims (typeof dec) node in
 
     (* Array indices must be ints *)
-    let (dims, err2) = err_map typecheck dims in
+    let dims, err2 = err_map typecheck dims in
     let err2 = err2 @ List.concat (List.map (check_type Int) dims) in
 
     (* Assigned value must match array base type *)
-    let (value, err3) = typecheck value in
+    let value, err3 = typecheck value in
     let err3 = err3 @ check_type (basetypeof dec) value in
 
     (VarLet (dec, Some dims, value, ann), err1 @ err2 @ err3)
@@ -275,6 +275,6 @@ let rec typecheck node =
 
 let phase = function
   | Ast node ->
-    let (node, err) = typecheck node in
+    let node, err = typecheck node in
     Ast (quit_on_error node err)
   | _ -> raise InvalidInput

stringify.ml

@@ -1,8 +1,6 @@
 open Types
 
 let tab = "    "
-
-(* string -> string *)
 let indent = Str.global_replace (Str.regexp "^\\(.\\)") (tab ^ "\\1")
 
 (* const -> string *)
@@ -11,11 +9,9 @@ let const2str = function
   | IntVal   i -> Int32.to_string i
   | FloatVal f ->
     (* Add a trailing zero to a float stringification *)
-    begin
-      match string_of_float f with
-      | s when s.[String.length s - 1] = '.' -> s ^ "0"
-      | s -> s
-    end
+    match string_of_float f with
+    | s when s.[String.length s - 1] = '.' -> s ^ "0"
+    | s -> s
 
 (* Copied from util.ml to avoid circular dependency *)
 let nameof = function
@@ -52,8 +48,8 @@ let rec type2str = function
   | Bool  -> "bool"
   | Int   -> "int"
   | Float -> "float"
-  | ArrayDims (t, dims) -> (type2str t) ^ "[" ^ (concat ", " dims) ^ "]"
-  | Array t             -> (type2str t) ^ "[]"
+  | ArrayDims (t, dims) -> type2str t ^ "[" ^ concat ", " dims ^ "]"
+  | Array t             -> type2str t ^ "[]"
   | Unknown -> "unknown"
 
 and concat sep nodes = String.concat sep (List.map node2str nodes)
@@ -67,33 +63,33 @@ and node2str node =
   | Program (decls, _) ->
     concat "\n\n" decls
   | Param (param_type, name, _) ->
-    (type2str param_type) ^ " " ^ name
+    type2str param_type ^ " " ^ name
   | FunDec (ret_type, name, params, _) ->
     let params = concat ", " params in
     "extern " ^ type2str ret_type ^ " " ^ name ^ "(" ^ params ^ ");"
   | FunDef (export, ret_type, name, params, body, _) ->
     let export = if export then "export " else "" in
-    let params = "(" ^ (concat ", " params) ^ ")" in
+    let params = "(" ^ concat ", " params ^ ")" in
     export ^ type2str ret_type ^ " " ^ name ^ params ^ " " ^ str body
   | GlobalDec (var_type, name, _) ->
     "extern " ^ type2str var_type ^ " " ^ name ^ ";"
   | GlobalDef (export, ret_type, name, init, _) ->
     let export = if export then "export " else "" in
     let init = match init with
-      | Some value -> " = " ^ str value
-      | None -> ""
+    | Some value -> " = " ^ str value
+    | None -> ""
     in
     export ^ (type2str ret_type) ^ " " ^ name ^ init ^ ";"
 
   (* Statements *)
   | VarDec (var_type, name, None, _) ->
-    (type2str var_type) ^ " " ^ name ^ ";"
+    type2str var_type ^ " " ^ name ^ ";"
   | VarDec (var_type, name, Some init, _) ->
-    (type2str var_type) ^ " " ^ name ^ " = " ^ str init ^ ";"
+    type2str var_type ^ " " ^ name ^ " = " ^ str init ^ ";"
   | Assign (name, None, value, _) ->
-    name ^ " = " ^ (str value) ^ ";"
+    name ^ " = " ^ str value ^ ";"
   | Assign (name, Some dims, value, _) ->
-    name ^ "[" ^ (concat ", " dims) ^ "] = " ^ (str value) ^ ";"
+    name ^ "[" ^ concat ", " dims ^ "] = " ^ str value ^ ";"
   | Expr expr ->
     str expr ^ ";"
   | Return (value, _) ->
@@ -116,25 +112,31 @@ and node2str node =
   | Allocate (dec, dims, _) ->
     nameof dec ^ " = __allocate(" ^ concat ", " dims ^ ");"
   | Block body ->
-    let rec append = function
-      | [] -> ""
-      | [last] -> last
-      | "" :: tl -> append tl
-      | hd :: tl -> hd ^ "\n" ^ append tl
+    let rec append pre = function
+      | []       -> pre
+      | [last]   -> pre ^ last
+      | "" :: tl -> append pre tl
+      | hd :: tl -> append (pre ^ hd ^ "\n") tl
     in
-    "{\n" ^ indent (append (List.map str body)) ^ "\n}"
+    "{\n" ^ indent (append "" (List.map str body)) ^ "\n}"
 
   (* Expressions *)
-  | Const (c, _) -> const2str c
-  | ArrayConst (dims, _) -> "[" ^ concat ", " dims ^ "]"
-  | Var (v, None, _) -> v
-  | Var (name, Some dims, _) -> name ^ (str (ArrayConst (dims, [])))
-  | Monop (op, opnd, _) -> op2str op ^ str opnd
+  | Const (value, _) ->
+    const2str value
+  | ArrayConst (dims, _) ->
+    "[" ^ concat ", " dims ^ "]"
+  | Var (name, None, _) -> name
+  | Var (name, Some dims, _) ->
+    name ^ "[" ^ concat ", " dims ^ "]"
+  | Monop (op, opnd, _) ->
+    op2str op ^ str opnd
   | Binop (op, left, right, _) ->
     "(" ^ str left ^ " " ^ op2str op ^ " " ^ str right ^ ")"
-  | TypeCast (ctype, value, _) -> "(" ^ type2str ctype ^ ")" ^ str value
-  | FunCall (name, args, _) -> name ^ "(" ^ (concat ", " args) ^ ")"
-  | Cond (cond, t, f, _) -> "(" ^ (str cond) ^ " ? " ^ str t ^ " : " ^ str f ^ ")"
+  | TypeCast (ctype, value, _) ->
+    "(" ^ type2str ctype ^ ")" ^ str value
+  | FunCall (name, args, _) ->
+    name ^ "(" ^ concat ", " args ^ ")"
+  | Cond (cond, t, f, _) -> "(" ^ str cond ^ " ? " ^ str t ^ " : " ^ str f ^ ")"
 
   (* Annotation nodes print more information at higher verbosity, for
    * debugging purposes *)

util.ml

@@ -55,13 +55,13 @@ let is_const_id id =
   && id.[String.length id - 1] = '_'
 
 let loc_from_lexpos pstart pend =
-  let (fname, ystart, yend, xstart, xend) = begin
+  let fname, ystart, yend, xstart, xend =
     pstart.pos_fname,
     pstart.pos_lnum,
     pend.pos_lnum,
-    (pstart.pos_cnum - pstart.pos_bol + 1),
-    (pend.pos_cnum - pend.pos_bol)
-  end in
+    pstart.pos_cnum - pstart.pos_bol + 1,
+    pend.pos_cnum - pend.pos_bol
+  in
   if ystart = yend && xend < xstart then
     (fname, ystart, yend, xstart, xstart)
   else
@@ -100,120 +100,120 @@ let rec flatten_blocks lst =
  * (node -> node) -> node -> node *)
 let rec traverse u ( *: ) trav node =
   let trav_all nodes =
-    let (nodes, res) = List.split (List.map trav nodes) in
+    let nodes, res = List.split (List.map trav nodes) in
     (nodes, List.fold_left ( *: ) u res)
   in
   match node with
   | Program (decls, ann) ->
-    let (decls, res_decls) = trav_all decls in
+    let decls, res_decls = trav_all decls in
     (Program (flatten_blocks decls, ann), res_decls)
   | FunDec (ret_type, name, params, ann) ->
-    let (params, res_params) = trav_all params in
+    let params, res_params = trav_all params in
     (FunDec (ret_type, name, params, ann), res_params)
   | FunDef (export, ret_type, name, params, body, ann) ->
-    let (params, resp) = trav_all params in
-    let (body, resb) = trav body in
+    let params, resp = trav_all params in
+    let body, resb = trav body in
     (FunDef (export, ret_type, name, params, body, ann), resp *: resb)
   | GlobalDec (ctype, name, ann) ->
     (GlobalDec (ctype, name, ann), u)
   | GlobalDef (export, ctype, name, Some init, ann) ->
-    let (init, res_init) = trav init in
+    let init, res_init = trav init in
     (GlobalDef (export, ctype, name, Some init, ann), res_init)
 
   | VarDecs decs ->
-    let (decs, res_decs) = trav_all decs in
+    let decs, res_decs = trav_all decs in
     (VarDecs decs, res_decs)
   | LocalFuns funs ->
-    let (funs, res_funs) = trav_all funs in
+    let funs, res_funs = trav_all funs in
     (LocalFuns funs, res_funs)
 
   | VarDec (ctype, name, Some init, ann) ->
-    let (init, res_init) = trav init in
+    let init, res_init = trav init in
     (VarDec (ctype, name, Some init, ann), res_init)
   | Assign (name, None, value, ann) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (Assign (name, None, value, ann), res_value)
   | Assign (name, Some dims, value, ann) ->
-    let (dims, res_dims) = trav_all dims in
-    let (value, res_value) = trav value in
+    let dims, res_dims = trav_all dims in
+    let value, res_value = trav value in
     (Assign (name, Some dims, value, ann), res_dims *: res_value)
   | VarLet (dec, None, value, ann) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (VarLet (dec, None, value, ann), res_value)
   | VarLet (dec, Some dims, value, ann) ->
-    let (dims, res_dims) = trav_all dims in
-    let (value, res_value) = trav value in
+    let dims, res_dims = trav_all dims in
+    let value, res_value = trav value in
     (VarLet (dec, Some dims, value, ann), res_dims *: res_value)
   | Return (value, ann) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (Return (value, ann), res_value)
   | If (cond, body, ann) ->
-    let (cond, res_cond) = trav cond in
-    let (body, res_body) = trav body in
+    let cond, res_cond = trav cond in
+    let body, res_body = trav body in
     (If (cond, body, ann), res_cond *: res_body)
   | IfElse (cond, tbody, fbody, ann) ->
-    let (cond, resa) = trav cond in
-    let (tbody, resb) = trav tbody in
-    let (fbody, resc) = trav fbody in
+    let cond, resa = trav cond in
+    let tbody, resb = trav tbody in
+    let fbody, resc = trav fbody in
     (IfElse (cond, tbody, fbody, ann), resa *: resb *: resc)
   | While (cond, body, ann) ->
-    let (cond, resc) = trav cond in
-    let (body, resb) = trav body in
+    let cond, resc = trav cond in
+    let body, resb = trav body in
     (While (cond, body, ann), resc *: resb)
   | DoWhile (cond, body, ann) ->
-    let (cond, resc) = trav cond in
-    let (body, resb) = trav body in
+    let cond, resc = trav cond in
+    let body, resb = trav body in
     (DoWhile (cond, body, ann), resc *: resb)
   | For (counter, start, stop, step, body, ann) ->
-    let (start, resa) = trav start in
-    let (stop, resb) = trav stop in
-    let (step, resc) = trav step in
-    let (body, resd) = trav body in
+    let start, resa = trav start in
+    let stop, resb = trav stop in
+    let step, resc = trav step in
+    let body, resd = trav body in
     let res = resa *: resb *: resc *: resd in
     (For (counter, start, stop, step, body, ann), res)
   | Allocate (dec, dims, ann) ->
-    let (dims, res_dims) = trav_all dims in
+    let dims, res_dims = trav_all dims in
     (Allocate (dec, dims, ann), res_dims)
   | Expr value ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (Expr value, res_value)
   | Block (body) ->
-    let (body, res_body) = trav_all body in
+    let body, res_body = trav_all body in
     (Block body, res_body)
 
   | Monop (op, value, ann) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (Monop (op, value, ann), res_value)
   | Binop (op, left, right, ann) ->
-    let (left, res_left) = trav left in
-    let (right, res_right) = trav right in
+    let left, res_left = trav left in
+    let right, res_right = trav right in
     (Binop (op, left, right, ann), res_left *: res_right)
   | Cond (cond, texpr, fexpr, ann) ->
-    let (cond, resa) = trav cond in
-    let (texpr, resb) = trav texpr in
-    let (fexpr, resc) = trav fexpr in
+    let cond, resa = trav cond in
+    let texpr, resb = trav texpr in
+    let fexpr, resc = trav fexpr in
     (Cond (cond, texpr, fexpr, ann), resa *: resb *: resc)
   | TypeCast (ctype, value, ann) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (TypeCast (ctype, value, ann), res_value)
   | FunCall (name, args, ann) ->
-    let (args, res_args) = trav_all args in
+    let args, res_args = trav_all args in
     (FunCall (name, args, ann), res_args)
   | Arg value ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (Arg value, res_value)
 
   | ArrayInit (value, dims) ->
-    let (value, res_value) = trav value in
+    let value, res_value = trav value in
     (ArrayInit (value, dims), res_value)
   | Var (dec, Some dims, ann) ->
-    let (dims, res_dims) = trav_all dims in
+    let dims, res_dims = trav_all dims in
     (Var (dec, Some dims, ann), res_dims)
   | VarUse (dec, Some dims, ann) ->
-    let (dims, res_dims) = trav_all dims in
+    let dims, res_dims = trav_all dims in
     (VarUse (dec, Some dims, ann), res_dims)
   | FunUse (dec, params, ann) ->
-    let (params, res_params) = trav_all params in
+    let params, res_params = trav_all params in
     (FunUse (dec, params, ann), res_params)
 
   | _ -> (node, u)
@@ -444,7 +444,7 @@ let prerr_loc (fname, ystart, yend, xstart, xend) =
 
 let prerr_loc_msg loc msg =
   if Globals.args.verbose >= 1 then begin
-    let (fname, ystart, yend, xstart, xend) = loc in
+    let fname, ystart, yend, xstart, xend = loc in
     if loc != noloc then begin
       let line_s = if yend != ystart
         then sprintf "lines %d-%d" ystart yend