Merge pull request #1011 from stan-dev/shadowing

Fix issue with function shadowing

Author: rok-cesnovar

src/stan_math_backend/Expression_gen.ml

@@ -6,17 +6,9 @@ open Fmt
 let ends_with suffix s = String.is_suffix ~suffix s
 let starts_with prefix s = String.is_prefix ~prefix s
 
-let functions_requiring_namespace =
-  String.Set.of_list
-    [ "e"; "pi"; "log2"; "log10"; "sqrt2"; "not_a_number"; "positive_infinity"
-    ; "negative_infinity"; "machine_precision"; "abs"; "acos"; "acosh"; "asin"
-    ; "asinh"; "atan"; "atanh"; "cbrt"; "ceil"; "cos"; "cosh"; "erf"; "erfc"
-    ; "exp"; "exp2"; "expm1"; "fabs"; "floor"; "lgamma"; "log"; "log1p"; "log2"
-    ; "log10"; "round"; "sin"; "sinh"; "sqrt"; "tan"; "tanh"; "tgamma"; "trunc"
-    ; "fdim"; "fmax"; "fmin"; "hypot"; "fma"; "complex" ]
-
 let stan_namespace_qualify f =
-  if Set.mem functions_requiring_namespace f then "stan::math::" ^ f else f
+  if String.is_suffix ~suffix:"functor__" f || String.contains f ':' then f
+  else "stan::math::" ^ f
 
 (* return true if the types of the two expression are the same *)
 let types_match e1 e2 =
@@ -141,7 +133,7 @@ let fn_renames =
     ~f:(fun (k, v) -> (Internal_fun.to_string k, v))
     [ (Internal_fun.FnLength, "stan::math::size")
     ; (FnNegInf, "stan::math::negative_infinity")
-    ; (FnResizeToMatch, "resize_to_match")
+    ; (FnResizeToMatch, "stan::math::resize_to_match")
     ; (FnNaN, "std::numeric_limits<double>::quiet_NaN") ]
   |> String.Map.of_alist_exn
 
@@ -191,107 +183,84 @@ let transform_args = function
   | transform -> Transformation.fold (fun args arg -> args @ [arg]) [] transform
 
 let rec pp_index ppf = function
-  | Index.All -> pf ppf "index_omni()"
-  | Single e -> pf ppf "index_uni(%a)" pp_expr e
-  | Upfrom e -> pf ppf "index_min(%a)" pp_expr e
+  | Index.All -> pf ppf "stan::model::index_omni()"
+  | Single e -> pf ppf "stan::model::index_uni(%a)" pp_expr e
+  | Upfrom e -> pf ppf "stan::model::index_min(%a)" pp_expr e
   | Between (e_low, e_high) ->
-      pf ppf "index_min_max(%a, %a)" pp_expr e_low pp_expr e_high
-  | MultiIndex e -> pf ppf "index_multi(%a)" pp_expr e
+      pf ppf "stan::model::index_min_max(%a, %a)" pp_expr e_low pp_expr e_high
+  | MultiIndex e -> pf ppf "stan::model::index_multi(%a)" pp_expr e
 
 and pp_indexes ppf = function
   | [] -> pf ppf ""
   | idxs -> pf ppf "@[<hov 2>%a@]" (list ~sep:comma pp_index) idxs
 
 and pp_logical_op ppf op lhs rhs =
-  pf ppf "(primitive_value(@,%a)@ %s@ primitive_value(@,%a))" pp_expr lhs op
-    pp_expr rhs
+  pf ppf
+    "(stan::math::primitive_value(@,%a)@ %s@ stan::math::primitive_value(@,%a))"
+    pp_expr lhs op pp_expr rhs
 
 and pp_unary ppf fm es = pf ppf fm pp_expr (List.hd_exn es)
-and pp_binary ppf fm es = pf ppf fm pp_expr (first es) pp_expr (second es)
+
+and pp_binary_op ppf op es =
+  pf ppf "(%a@ %s@ %a)" pp_expr (first es) op pp_expr (second es)
 
 and pp_binary_f ppf f es =
   pf ppf "%s(@,%a,@ %a)" f pp_expr (first es) pp_expr (second es)
 
 and first es = List.nth_exn es 0
 and second es = List.nth_exn es 1
 
-and pp_scalar_binary ppf scalar_fmt generic_fmt es =
-  pp_binary ppf
-    ( if is_scalar (first es) && is_scalar (second es) then scalar_fmt
-    else generic_fmt )
-    es
+and pp_scalar_binary ppf op fn es =
+  if is_scalar (first es) && is_scalar (second es) then pp_binary_op ppf op es
+  else pp_binary_f ppf fn es
 
-and gen_operator_app = function
-  | Operator.Plus ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ +@ %a)" "add(@,%a,@ %a)" es
+and gen_operator_app op ppf es =
+  match op with
+  | Operator.Plus -> pp_scalar_binary ppf "+" "stan::math::add" es
   | PMinus ->
-      fun ppf es ->
-        pp_unary ppf
-          (if is_scalar (List.hd_exn es) then "-%a" else "minus(@,%a)")
-          es
-  | PPlus -> fun ppf es -> pp_unary ppf "%a" es
+      pp_unary ppf
+        (if is_scalar (List.hd_exn es) then "-%a" else "stan::math::minus(@,%a)")
+        es
+  | PPlus -> pp_unary ppf "%a" es
   | Transpose ->
-      fun ppf es ->
-        pp_unary ppf
-          (if is_scalar (List.hd_exn es) then "%a" else "transpose(@,%a)")
-          es
-  | PNot -> fun ppf es -> pp_unary ppf "logical_negation(@,%a)" es
-  | Minus ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ -@ %a)" "subtract(@,%a,@ %a)" es
-  | Times ->
-      fun ppf es -> pp_scalar_binary ppf "(%a@ *@ %a)" "multiply(@,%a,@ %a)" es
+      pp_unary ppf
+        ( if is_scalar (List.hd_exn es) then "%a"
+        else "stan::math::transpose(@,%a)" )
+        es
+  | PNot -> pp_unary ppf "stan::math::logical_negation(@,%a)" es
+  | Minus -> pp_scalar_binary ppf "-" "stan::math::subtract" es
+  | Times -> pp_scalar_binary ppf "*" "stan::math::multiply" es
   | Divide | IntDivide ->
-      fun ppf es ->
-        if
-          is_matrix (second es)
-          && (is_matrix (first es) || is_row_vector (first es))
-        then pp_binary_f ppf "mdivide_right" es
-        else pp_scalar_binary ppf "(%a@ /@ %a)" "divide(@,%a,@ %a)" es
-  | Modulo -> fun ppf es -> pp_binary_f ppf "modulus" es
-  | LDivide -> fun ppf es -> pp_binary_f ppf "mdivide_left" es
+      if
+        is_matrix (second es)
+        && (is_matrix (first es) || is_row_vector (first es))
+      then pp_binary_f ppf "stan::math::mdivide_right" es
+      else pp_scalar_binary ppf "/" "stan::math::divide" es
+  | Modulo -> pp_binary_f ppf "stan::math::modulus" es
+  | LDivide -> pp_binary_f ppf "stan::math::mdivide_left" es
   | And | Or ->
       Common.FatalError.fatal_error_msg
         [%message "And/Or should have been converted to an expression"]
-  | EltTimes ->
-      fun ppf es ->
-        pp_scalar_binary ppf "(%a@ *@ %a)" "elt_multiply(@,%a,@ %a)" es
-  | EltDivide ->
-      fun ppf es ->
-        pp_scalar_binary ppf "(%a@ /@ %a)" "elt_divide(@,%a,@ %a)" es
-  | Pow -> fun ppf es -> pp_binary_f ppf "pow" es
-  | EltPow -> fun ppf es -> pp_binary_f ppf "pow" es
-  | Equals -> fun ppf es -> pp_binary_f ppf "logical_eq" es
-  | NEquals -> fun ppf es -> pp_binary_f ppf "logical_neq" es
-  | Less -> fun ppf es -> pp_binary_f ppf "logical_lt" es
-  | Leq -> fun ppf es -> pp_binary_f ppf "logical_lte" es
-  | Greater -> fun ppf es -> pp_binary_f ppf "logical_gt" es
-  | Geq -> fun ppf es -> pp_binary_f ppf "logical_gte" es
+  | EltTimes -> pp_scalar_binary ppf "*" "stan::math::elt_multiply" es
+  | EltDivide -> pp_scalar_binary ppf "/" "stan::math::elt_divide" es
+  | Pow -> pp_binary_f ppf "stan::math::pow" es
+  | EltPow -> pp_binary_f ppf "stan::math::pow" es
+  | Equals -> pp_binary_f ppf "stan::math::logical_eq" es
+  | NEquals -> pp_binary_f ppf "stan::math::logical_neq" es
+  | Less -> pp_binary_f ppf "stan::math::logical_lt" es
+  | Leq -> pp_binary_f ppf "stan::math::logical_lte" es
+  | Greater -> pp_binary_f ppf "stan::math::logical_gt" es
+  | Geq -> pp_binary_f ppf "stan::math::logical_gte" es
 
 and gen_misc_special_math_app f =
   match f with
   | "lmultiply" ->
-      Some (fun ppf es -> pp_binary ppf "multiply_log(@,%a,@ %a)" es)
+      Some (fun ppf es -> pp_binary_f ppf "stan::math::multiply_log" es)
   | "lchoose" ->
-      Some (fun ppf es -> pp_binary ppf "binomial_coefficient_log(@,%a,@ %a)" es)
-  | "target" -> Some (fun ppf _ -> pf ppf "get_lp(lp__, lp_accum__)")
-  | "get_lp" -> Some (fun ppf _ -> pf ppf "get_lp(lp__, lp_accum__)")
-  | "max" | "min" ->
-      Some
-        (fun ppf es ->
-          let f = match es with [_; _] -> "std::" ^ f | _ -> f in
-          pp_call ppf (f, pp_expr, es) )
-  | "ceil" ->
-      let std_prefix_data_scalar f = function
-        | [ Expr.
-              { Fixed.meta=
-                  Typed.Meta.{adlevel= DataOnly; type_= UInt | UReal; _}
-              ; _ } ] ->
-            "std::" ^ f
-        | _ -> f in
       Some
-        (fun ppf es ->
-          let f = std_prefix_data_scalar f es in
-          pp_call ppf (f, pp_expr, es) )
+        (fun ppf es -> pp_binary_f ppf "stan::math::binomial_coefficient_log" es)
+  | "target" -> Some (fun ppf _ -> pf ppf "stan::math::get_lp(lp__, lp_accum__)")
+  | "get_lp" -> Some (fun ppf _ -> pf ppf "stan::math::get_lp(lp__, lp_accum__)")
   | f when Map.mem fn_renames f ->
       Some (fun ppf es -> pp_call ppf (Map.find_exn fn_renames f, pp_expr, es))
   | _ -> None
@@ -498,7 +467,8 @@ and pp_promoted ad ut ppf e =
           (local_scalar ut ad) pp_expr e )
 
 and pp_indexed ppf (vident, indices, pretty) =
-  pf ppf "@[<hov 2>rvalue(@,%s,@ %S,@ %a)@]" vident pretty pp_indexes indices
+  pf ppf "@[<hov 2>stan::model::rvalue(@,%s,@ %S,@ %a)@]" vident pretty
+    pp_indexes indices
 
 and pp_indexed_simple ppf (obj, idcs) =
   let idx_minus_one = function
@@ -525,7 +495,7 @@ and pp_expr ppf Expr.Fixed.({pattern; meta} as e) =
   match pattern with
   | Var s -> pf ppf "%s" s
   | Lit (Str, s) -> pf ppf "\"%s\"" (Cpp_str.escaped s)
-  | Lit (Imaginary, s) -> pf ppf "to_complex(0, %s)" s
+  | Lit (Imaginary, s) -> pf ppf "stan::math::to_complex(0, %s)" s
   | Lit ((Real | Int), s) -> pf ppf "%s" s
   | FunApp
       ( StanLib (op, _, _)
@@ -541,7 +511,6 @@ and pp_expr ppf Expr.Fixed.({pattern; meta} as e) =
       gen_fun_app suffix ppf f es mem_pattern
   | FunApp (CompilerInternal f, es) ->
       pp_compiler_internal_fn meta.adlevel meta.type_ f ppf es
-      (* stan_namespace_qualify?  *)
   | FunApp (UserDefined (f, suffix), es) ->
       pp_user_defined_fun ppf (f, suffix, es)
   | EAnd (e1, e2) -> pp_logical_op ppf "&&" e1 e2
@@ -629,7 +598,7 @@ let%expect_test "pp_expr9" =
 
 let%expect_test "pp_expr10" =
   printf "%s" (pp_unlocated (Indexed (dummy_locate (Var "a"), [All]))) ;
-  [%expect {| rvalue(a, "a", index_omni()) |}]
+  [%expect {| stan::model::rvalue(a, "a", stan::model::index_omni()) |}]
 
 let%expect_test "pp_expr11" =
   printf "%s"

src/stan_math_backend/Stan_math_code_gen.ml

@@ -114,7 +114,8 @@ let pp_returntype ppf arg_types rt =
 
 let pp_eigen_arg_to_ref ppf arg_types =
   let pp_ref ppf name =
-    pf ppf "@[<hv 8>const auto& %s = to_ref(%s);@]" name (name ^ "_arg__") in
+    pf ppf "@[<hv 8>const auto& %s = stan::math::to_ref(%s);@]" name
+      (name ^ "_arg__") in
   pf ppf "@[<v>%a@]@ " (list ~sep:cut pp_ref)
     (List.filter_map
        ~f:(fun (_, name, ut) ->
@@ -188,7 +189,7 @@ let get_templates_and_args exprs fdargs =
 let pp_template_decorator ppf = function
   | [] -> ()
   | templates ->
-      pf ppf "@[<hov>template <%a>@]@ " (list ~sep:comma string) templates
+      pf ppf "template @[<hov><%a>@]@ " (list ~sep:comma string) templates
 
 let mk_extra_args templates args =
   List.map ~f:(fun (t, v) -> t ^ "& " ^ v) (List.zip_exn templates args)
@@ -903,19 +904,9 @@ let pp_model ppf ({Program.prog_name; _} as p) =
     "%%NAME%%3 %%VERSION%%" stanc_args_to_print ;
   pf ppf "@ %a@]@]@ };" pp_model_public p
 
-(** The C++ aliases needed for the model class*)
 let usings =
   {|
-using stan::io::dump;
-using stan::model::assign;
-using stan::model::index_uni;
-using stan::model::index_max;
-using stan::model::index_min;
-using stan::model::index_min_max;
-using stan::model::index_multi;
-using stan::model::index_omni;
 using stan::model::model_base_crtp;
-using stan::model::rvalue;
 using namespace stan::math;
 |}
 

src/stan_math_backend/Statement_gen.ml

@@ -8,12 +8,12 @@ let pp_call_str ppf (name, args) = pp_call ppf (name, string, args)
 let pp_block ppf (pp_body, body) = pf ppf "{@;<1 2>@[<v>%a@]@,}" pp_body body
 
 let pp_profile ppf (pp_body, name, body) =
-  let profile =
-    Fmt.str
-      "profile<local_scalar_t__> profile__(%s, \
-       const_cast<profile_map&>(profiles__));"
+  let profile ppf name =
+    pf ppf
+      "@[<hov 2>stan::math::profile<local_scalar_t__> profile__(%s,@ \
+       const_cast<stan::math::profile_map&>(profiles__));@]"
       name in
-  pf ppf "{@;<1 2>@[<v>%s@;@;%a@]@,}" profile pp_body body
+  pf ppf "{@;<1 2>@[<v>%a@;@;%a@]@,}" profile name pp_body body
 
 let rec contains_eigen (ut : UnsizedType.t) : bool =
   match ut with
@@ -251,9 +251,10 @@ let pp_decl ppf (vident, pst, adtype, initialize) =
 
 let math_fn_translations = function
   | Internal_fun.FnLength -> Some ("length", [])
-  | FnValidateSize -> Some ("validate_non_negative_index", [])
-  | FnValidateSizeSimplex -> Some ("validate_positive_index", [])
-  | FnValidateSizeUnitVector -> Some ("validate_unit_vector_index", [])
+  | FnValidateSize -> Some ("stan::math::validate_non_negative_index", [])
+  | FnValidateSizeSimplex -> Some ("stan::math::validate_positive_index", [])
+  | FnValidateSizeUnitVector ->
+      Some ("stan::math::validate_unit_vector_index", [])
   | FnReadWriteEventsOpenCL x -> Some (x ^ ".wait_for_read_write_events", [])
   | _ -> None
 
@@ -263,7 +264,7 @@ let trans_math_fn f =
 
 let pp_bool_expr ppf expr =
   match Expr.Typed.type_of expr with
-  | UReal -> pp_call ppf ("as_bool", pp_expr, [expr])
+  | UReal -> pp_call ppf ("stan::math::as_bool", pp_expr, [expr])
   | _ -> pp_expr ppf expr
 
 let rec pp_statement (ppf : Format.formatter) Stmt.Fixed.{pattern; meta} =
@@ -305,13 +306,15 @@ let rec pp_statement (ppf : Format.formatter) Stmt.Fixed.{pattern; meta} =
               Expr.Fixed.pattern= FunApp (CompilerInternal FnDeepCopy, [e]) }
         | _ -> recurse e in
       let rhs = maybe_deep_copy rhs in
-      pf ppf "@[<hov 2>assign(@,%s,@ %a,@ %S%s%a@]);" assignee pp_expr rhs
+      pf ppf "@[<hov 2>stan::model::assign(@,%s,@ %a,@ %S%s%a@]);" assignee
+        pp_expr rhs
         (str "assigning variable %s" assignee)
         (if List.length idcs = 0 then "" else ", ")
         pp_indexes idcs
   | TargetPE e -> pf ppf "@[<hov 2>lp_accum__.add(@,%a@]);" pp_expr e
   | NRFunApp (CompilerInternal FnPrint, args) ->
-      let pp_arg ppf a = pf ppf "stan_print(pstream__, %a);" pp_expr a in
+      let pp_arg ppf a =
+        pf ppf "stan::math::stan_print(pstream__, %a);" pp_expr a in
       let args = args @ [Expr.Helpers.str "\n"] in
       pf ppf "if (pstream__) %a" pp_block (list ~sep:cut pp_arg, args)
   | NRFunApp (CompilerInternal FnReject, args) ->
@@ -323,7 +326,8 @@ let rec pp_statement (ppf : Format.formatter) Stmt.Fixed.{pattern; meta} =
   | NRFunApp (CompilerInternal (FnCheck {trans; var_name; var}), args) ->
       Option.iter (check_to_string trans) ~f:(fun check_name ->
           let function_arg = Expr.Helpers.variable "function__" in
-          pf ppf "%s(@[<hov>%a@]);" ("check_" ^ check_name)
+          pf ppf "%s(@[<hov>%a@]);"
+            ("stan::math::check_" ^ check_name)
             (list ~sep:comma pp_expr)
             (function_arg :: Expr.Helpers.str var_name :: var :: args) )
   | NRFunApp (CompilerInternal (FnWriteParam {unconstrain_opt; var}), _) -> (
@@ -344,7 +348,9 @@ let rec pp_statement (ppf : Format.formatter) Stmt.Fixed.{pattern; meta} =
       pf ppf "%s(@[<hov>%a@]);" fname (list ~sep:comma pp_expr)
         (extra_args @ args)
   | NRFunApp (StanLib (fname, _, _), args) ->
-      pf ppf "%s(@[<hov>%a@]);" fname (list ~sep:comma pp_expr) args
+      pf ppf "%s(@[<hov>%a@]);"
+        (stan_namespace_qualify fname)
+        (list ~sep:comma pp_expr) args
   | NRFunApp (UserDefined (fname, suffix), args) ->
       pf ppf "%a;" pp_user_defined_fun (fname, suffix, args)
   | Break -> string ppf "break;"

test/integration/cli-args/filename_good.expected

@@ -4,16 +4,7 @@
 #include <stan/model/model_header.hpp>
 namespace filename_good_model_namespace {
 
-using stan::io::dump;
-using stan::model::assign;
-using stan::model::index_uni;
-using stan::model::index_max;
-using stan::model::index_min;
-using stan::model::index_min_max;
-using stan::model::index_multi;
-using stan::model::index_omni;
 using stan::model::model_base_crtp;
-using stan::model::rvalue;
 using namespace stan::math;
 
 
@@ -125,11 +116,12 @@ class filename_good_model final : public model_base_crtp<filename_good_model> {
     (void) function__;  // suppress unused var warning
 
     try {
-      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
-            primitive_value(emit_generated_quantities__)))) {
+      if (stan::math::logical_negation((stan::math::primitive_value(
+            emit_transformed_parameters__) || stan::math::primitive_value(
+            emit_generated_quantities__)))) {
         return ;
       } 
-      if (logical_negation(emit_generated_quantities__)) {
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
         return ;
       } 
     } catch (const std::exception& e) {