Fix clang-tidy-19 errors (#8509)

steven-johnson · web-flow · commit 90af42384af0 · 2024-12-16T11:40:39.000-08:00
diff --git a/src/Buffer.h b/src/Buffer.h
@@ -222,7 +222,7 @@ class Buffer {
 
     template<typename... Args,
              typename = typename std::enable_if<Internal::all_ints_and_optional_name<Args...>::value>::type>
-    explicit Buffer(int first, Args... rest)
+    explicit Buffer(int first, const Args &...rest)
         : Buffer(Runtime::Buffer<T, Dims>(Internal::get_shape_from_start_of_parameter_pack(first, rest...)),
                  Internal::get_name_from_end_of_parameter_pack(rest...)) {
     }
diff --git a/src/CodeGen_Vulkan_Dev.cpp b/src/CodeGen_Vulkan_Dev.cpp
@@ -153,7 +153,7 @@ class CodeGen_Vulkan_Dev : public CodeGen_GPU_Dev {
 
         // Returns Phi node inputs.
         template<typename StmtOrExpr>
-        SpvFactory::BlockVariables emit_if_then_else(const Expr &condition, StmtOrExpr then_case, StmtOrExpr else_case);
+        SpvFactory::BlockVariables emit_if_then_else(const Expr &condition, const StmtOrExpr &then_case, const StmtOrExpr &else_case);
 
         template<typename T>
         SpvId declare_constant_int(Type value_type, int64_t value);
@@ -1936,7 +1936,7 @@ void CodeGen_Vulkan_Dev::SPIRV_Emitter::visit(const Realize *) {
 template<typename StmtOrExpr>
 SpvFactory::BlockVariables
 CodeGen_Vulkan_Dev::SPIRV_Emitter::emit_if_then_else(const Expr &condition,
-                                                     StmtOrExpr then_case, StmtOrExpr else_case) {
+                                                     const StmtOrExpr &then_case, const StmtOrExpr &else_case) {
 
     SpvId merge_block_id = builder.reserve_id(SpvBlockId);
     SpvId if_block_id = builder.reserve_id(SpvBlockId);
diff --git a/src/Deserialization.cpp b/src/Deserialization.cpp
@@ -51,7 +51,7 @@ class Deserializer {
     // does not apply to union types like Stmt and Expr or enum types like MemoryType
     template<typename src, typename dst>
     std::vector<dst> deserialize_vector(const flatbuffers::Vector<::flatbuffers::Offset<src>> *flatbuffer_vec,
-                                        std::function<dst(Deserializer &, const src *)> deserialize_func) {
+                                        const std::function<dst(Deserializer &, const src *)> &deserialize_func) {
         user_assert(flatbuffer_vec != nullptr) << "deserializing a null vector\n";
         std::vector<dst> result;
         result.reserve(flatbuffer_vec->size());
diff --git a/src/ExternFuncArgument.h b/src/ExternFuncArgument.h
@@ -31,7 +31,7 @@ struct ExternFuncArgument {
     }
 
     template<typename T, int Dims>
-    ExternFuncArgument(Buffer<T, Dims> b)
+    ExternFuncArgument(const Buffer<T, Dims> &b)
         : arg_type(BufferArg), buffer(b) {
     }
     ExternFuncArgument(Expr e)
diff --git a/src/Func.cpp b/src/Func.cpp
@@ -3313,7 +3313,7 @@ Stage FuncRef::func_ref_update(const Tuple &e, int init_val) {
 }
 
 template<typename BinaryOp>
-Stage FuncRef::func_ref_update(Expr e, int init_val) {
+Stage FuncRef::func_ref_update(const Expr &e, int init_val) {
     // Don't do this: we want to allow the RHS to be implicitly cast to the type of LHS.
     // func.check_types(e);
 
@@ -3323,8 +3323,8 @@ Stage FuncRef::func_ref_update(Expr e, int init_val) {
     return self_ref = BinaryOp()(Expr(self_ref), e);
 }
 
-Stage FuncRef::operator+=(Expr e) {
-    return func_ref_update<std::plus<Expr>>(std::move(e), 0);
+Stage FuncRef::operator+=(const Expr &e) {
+    return func_ref_update<std::plus<Expr>>(e, 0);
 }
 
 Stage FuncRef::operator+=(const Tuple &e) {
@@ -3343,8 +3343,8 @@ Stage FuncRef::operator+=(const FuncRef &e) {
     }
 }
 
-Stage FuncRef::operator*=(Expr e) {
-    return func_ref_update<std::multiplies<Expr>>(std::move(e), 1);
+Stage FuncRef::operator*=(const Expr &e) {
+    return func_ref_update<std::multiplies<Expr>>(e, 1);
 }
 
 Stage FuncRef::operator*=(const Tuple &e) {
@@ -3363,8 +3363,8 @@ Stage FuncRef::operator*=(const FuncRef &e) {
     }
 }
 
-Stage FuncRef::operator-=(Expr e) {
-    return func_ref_update<std::minus<Expr>>(std::move(e), 0);
+Stage FuncRef::operator-=(const Expr &e) {
+    return func_ref_update<std::minus<Expr>>(e, 0);
 }
 
 Stage FuncRef::operator-=(const Tuple &e) {
@@ -3383,8 +3383,8 @@ Stage FuncRef::operator-=(const FuncRef &e) {
     }
 }
 
-Stage FuncRef::operator/=(Expr e) {
-    return func_ref_update<std::divides<Expr>>(std::move(e), 1);
+Stage FuncRef::operator/=(const Expr &e) {
+    return func_ref_update<std::divides<Expr>>(e, 1);
 }
 
 Stage FuncRef::operator/=(const Tuple &e) {
diff --git a/src/Func.h b/src/Func.h
@@ -505,7 +505,7 @@ class FuncRef {
      * already have a pure definition, init_val will be used as RHS in
      * the initial function definition. */
     template<typename BinaryOp>
-    Stage func_ref_update(Expr e, int init_val);
+    Stage func_ref_update(const Expr &e, int init_val);
 
 public:
     FuncRef(const Internal::Function &, const std::vector<Expr> &,
@@ -528,7 +528,7 @@ class FuncRef {
      * pure definition, this sets it to zero.
      */
     // @{
-    Stage operator+=(Expr);
+    Stage operator+=(const Expr &);
     Stage operator+=(const Tuple &);
     Stage operator+=(const FuncRef &);
     // @}
@@ -539,7 +539,7 @@ class FuncRef {
      * not already have a pure definition, this sets it to zero.
      */
     // @{
-    Stage operator-=(Expr);
+    Stage operator-=(const Expr &);
     Stage operator-=(const Tuple &);
     Stage operator-=(const FuncRef &);
     // @}
@@ -550,7 +550,7 @@ class FuncRef {
      * definition, this sets it to 1.
      */
     // @{
-    Stage operator*=(Expr);
+    Stage operator*=(const Expr &);
     Stage operator*=(const Tuple &);
     Stage operator*=(const FuncRef &);
     // @}
@@ -561,7 +561,7 @@ class FuncRef {
      * function does not already have a pure definition, this sets it to 1.
      */
     // @{
-    Stage operator/=(Expr);
+    Stage operator/=(const Expr &);
     Stage operator/=(const Tuple &);
     Stage operator/=(const FuncRef &);
     // @}
diff --git a/src/LLVM_Output.cpp b/src/LLVM_Output.cpp
@@ -42,7 +42,7 @@ namespace {
 // If data too large, assert.
 // Return the offset at which 'data' was written.
 template<typename T>
-size_t emit_padded(std::ostream &out, T data, size_t size) {
+size_t emit_padded(std::ostream &out, const T &data, size_t size) {
     size_t pos = out.tellp();
     out << data;
     size_t written = (size_t)out.tellp() - pos;
diff --git a/src/RDom.h b/src/RDom.h
@@ -217,7 +217,7 @@ class RDom {
     }
 
     template<typename... Args>
-    HALIDE_NO_USER_CODE_INLINE RDom(Expr min, Expr extent, Args &&...args) {
+    HALIDE_NO_USER_CODE_INLINE RDom(const Expr &min, const Expr &extent, Args &&...args) {
         // This should really just be a delegating constructor, but I couldn't make
         // that work with variadic template unpacking in visual studio 2013
         Region region;
diff --git a/src/Simplify_Let.cpp b/src/Simplify_Let.cpp
@@ -53,7 +53,7 @@ class FindVarUses : public IRVisitor {
 };
 
 template<typename StmtOrExpr>
-void find_var_uses(StmtOrExpr x, std::unordered_set<std::string> &unused_vars) {
+void find_var_uses(const StmtOrExpr &x, std::unordered_set<std::string> &unused_vars) {
     FindVarUses counter(unused_vars);
     x.accept(&counter);
 }
diff --git a/src/StmtToHTML.cpp b/src/StmtToHTML.cpp
@@ -1197,7 +1197,7 @@ class HTMLCodePrinter : public IRVisitor {
     }
 
     /* Helper functions for printing IR nodes */
-    void print_constant(std::string cls, Expr c) {
+    void print_constant(const std::string &cls, const Expr &c) {
         print_opening_tag("span", cls, type_to_string(c.type()));
         stream << c;
         print_closing_tag("span");
@@ -1209,7 +1209,7 @@ class HTMLCodePrinter : public IRVisitor {
         print_closing_tag("span");
     }
 
-    void print_binary_op(const Expr &a, const Expr &b, std::string op, Type result_type) {
+    void print_binary_op(const Expr &a, const Expr &b, const std::string &op, Type result_type) {
         std::string result_type_str = type_to_string(result_type);
         print_opening_tag("span", "BinaryOp");
         print_html_element("span", "matched", "(", result_type_str);
@@ -1222,7 +1222,7 @@ class HTMLCodePrinter : public IRVisitor {
         print_closing_tag("span");
     }
 
-    void print_function_call(std::string fn_name, const std::vector<Expr> &args, const std::string &tooltip) {
+    void print_function_call(const std::string &fn_name, const std::vector<Expr> &args, const std::string &tooltip) {
         print_opening_tag("span", "matched");
         print_html_element("span", "Symbol matched", fn_name, tooltip);
         print_text("(");
@@ -1329,7 +1329,7 @@ class HTMLCodePrinter : public IRVisitor {
     }
 
     // Prints a cost button/indicator
-    void print_cost_btn(int line_cost, int block_cost, int max_line_cost, int max_block_cost, std::string id, std::string prefix) {
+    void print_cost_btn(int line_cost, int block_cost, int max_line_cost, int max_block_cost, const std::string &id, const std::string &prefix) {
         const int num_cost_buckets = 20;
         const auto compand = [](int v) -> int { return (int)std::sqrt(v * 10); };
 
diff --git a/src/Util.h b/src/Util.h
@@ -388,7 +388,7 @@ struct ScopedValue {
         : var(var), old_value(var) {
     }
     /** Preserve the old value, then set the var to a new value. */
-    ScopedValue(T &var, T new_value)
+    ScopedValue(T &var, const T &new_value)
         : var(var), old_value(var) {
         var = new_value;
     }
diff --git a/src/autoschedulers/common/cmdline.h b/src/autoschedulers/common/cmdline.h
@@ -161,7 +161,7 @@ std::string readable_typename() {
 }
 
 template<class T>
-std::string default_value(T def) {
+std::string default_value(const T &def) {
     return detail::lexical_cast<std::string>(def);
 }
 
@@ -397,7 +397,7 @@ class parser {
              char short_name = 0,
              const std::string &desc = "",
              bool need = true,
-             const T def = T()) {
+             const T &def = T()) {
         add(name, short_name, desc, need, def, default_reader<T>());
     }
 
@@ -406,7 +406,7 @@ class parser {
              char short_name = 0,
              const std::string &desc = "",
              bool need = true,
-             const T def = T(),
+             const T &def = T(),
              F reader = F()) {
         if (options.count(name)) {
             throw_cmdline_error("multiple definition: " + name);
@@ -879,7 +879,7 @@ class parser {
         option_with_value_with_reader(const std::string &name,
                                       char short_name,
                                       bool need,
-                                      const T def,
+                                      const T &def,
                                       const std::string &desc,
                                       F reader)
             : option_with_value<T>(name, short_name, need, def, desc), reader(reader) {
diff --git a/src/autoschedulers/li2018/GradientAutoscheduler.cpp b/src/autoschedulers/li2018/GradientAutoscheduler.cpp
@@ -535,7 +535,7 @@ void parallelize_vars_and_rvars_cpu(
 template<typename FuncOrStage>
 void parallelize_vars_and_rvars(
     const GradientAutoschedulerParams &params,
-    FuncOrStage func_or_stage,
+    const FuncOrStage &func_or_stage,
     int natural_vector_size,
     bool is_pure_def,
     const std::vector<Var> &vars,
diff --git a/src/runtime/HalideBuffer.h b/src/runtime/HalideBuffer.h
@@ -1991,7 +1991,7 @@ class Buffer {
     /** Make a buffer with the same shape and memory nesting order as
      * another buffer. It may have a different type. */
     template<typename T2, int D2, int S2>
-    static Buffer<T, Dims, InClassDimStorage> make_with_shape_of(Buffer<T2, D2, S2> src,
+    static Buffer<T, Dims, InClassDimStorage> make_with_shape_of(const Buffer<T2, D2, S2> &src,
                                                                  void *(*allocate_fn)(size_t) = nullptr,
                                                                  void (*deallocate_fn)(void *) = nullptr) {
         static_assert(Dims == D2 || Dims == AnyDims);

Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ class Buffer {`
`222`	`222`
`223`	`223`	`template<typename... Args,`
`224`	`224`	`typename = typename std::enable_if<Internal::all_ints_and_optional_name<Args...>::value>::type>`
`225`		`- explicit Buffer(int first, Args... rest)`
	`225`	`+ explicit Buffer(int first, const Args &...rest)`
`226`	`226`	`: Buffer(Runtime::Buffer<T, Dims>(Internal::get_shape_from_start_of_parameter_pack(first, rest...)),`
`227`	`227`	`Internal::get_name_from_end_of_parameter_pack(rest...)) {`
`228`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ struct ExternFuncArgument {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`template<typename T, int Dims>`
`34`		`- ExternFuncArgument(Buffer<T, Dims> b)`
	`34`	`+ ExternFuncArgument(const Buffer<T, Dims> &b)`
`35`	`35`	`: arg_type(BufferArg), buffer(b) {`
`36`	`36`	`}`
`37`	`37`	`ExternFuncArgument(Expr e)`
Original file line number	Diff line number	Diff line change
`@@ -3313,7 +3313,7 @@ Stage FuncRef::func_ref_update(const Tuple &e, int init_val) {`
`3313`	`3313`	`}`
`3314`	`3314`
`3315`	`3315`	`template<typename BinaryOp>`
`3316`		`-Stage FuncRef::func_ref_update(Expr e, int init_val) {`
	`3316`	`+Stage FuncRef::func_ref_update(const Expr &e, int init_val) {`
`3317`	`3317`	`// Don't do this: we want to allow the RHS to be implicitly cast to the type of LHS.`
`3318`	`3318`	`// func.check_types(e);`
`3319`	`3319`
`@@ -3323,8 +3323,8 @@ Stage FuncRef::func_ref_update(Expr e, int init_val) {`
`3323`	`3323`	`return self_ref = BinaryOp()(Expr(self_ref), e);`
`3324`	`3324`	`}`
`3325`	`3325`
`3326`		`-Stage FuncRef::operator+=(Expr e) {`
`3327`		`- return func_ref_update<std::plus<Expr>>(std::move(e), 0);`
	`3326`	`+Stage FuncRef::operator+=(const Expr &e) {`
	`3327`	`+ return func_ref_update<std::plus<Expr>>(e, 0);`
`3328`	`3328`	`}`
`3329`	`3329`
`3330`	`3330`	`Stage FuncRef::operator+=(const Tuple &e) {`
`@@ -3343,8 +3343,8 @@ Stage FuncRef::operator+=(const FuncRef &e) {`
`3343`	`3343`	`}`
`3344`	`3344`	`}`
`3345`	`3345`
`3346`		`-Stage FuncRef::operator*=(Expr e) {`
`3347`		`- return func_ref_update<std::multiplies<Expr>>(std::move(e), 1);`
	`3346`	`+Stage FuncRef::operator*=(const Expr &e) {`
	`3347`	`+ return func_ref_update<std::multiplies<Expr>>(e, 1);`
`3348`	`3348`	`}`
`3349`	`3349`
`3350`	`3350`	`Stage FuncRef::operator*=(const Tuple &e) {`
`@@ -3363,8 +3363,8 @@ Stage FuncRef::operator*=(const FuncRef &e) {`
`3363`	`3363`	`}`
`3364`	`3364`	`}`
`3365`	`3365`
`3366`		`-Stage FuncRef::operator-=(Expr e) {`
`3367`		`- return func_ref_update<std::minus<Expr>>(std::move(e), 0);`
	`3366`	`+Stage FuncRef::operator-=(const Expr &e) {`
	`3367`	`+ return func_ref_update<std::minus<Expr>>(e, 0);`
`3368`	`3368`	`}`
`3369`	`3369`
`3370`	`3370`	`Stage FuncRef::operator-=(const Tuple &e) {`
`@@ -3383,8 +3383,8 @@ Stage FuncRef::operator-=(const FuncRef &e) {`
`3383`	`3383`	`}`
`3384`	`3384`	`}`
`3385`	`3385`
`3386`		`-Stage FuncRef::operator/=(Expr e) {`
`3387`		`- return func_ref_update<std::divides<Expr>>(std::move(e), 1);`
	`3386`	`+Stage FuncRef::operator/=(const Expr &e) {`
	`3387`	`+ return func_ref_update<std::divides<Expr>>(e, 1);`
`3388`	`3388`	`}`
`3389`	`3389`
`3390`	`3390`	`Stage FuncRef::operator/=(const Tuple &e) {`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ class RDom {`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`template<typename... Args>`
`220`		`- HALIDE_NO_USER_CODE_INLINE RDom(Expr min, Expr extent, Args &&...args) {`
	`220`	`+ HALIDE_NO_USER_CODE_INLINE RDom(const Expr &min, const Expr &extent, Args &&...args) {`
`221`	`221`	`// This should really just be a delegating constructor, but I couldn't make`
`222`	`222`	`// that work with variadic template unpacking in visual studio 2013`
`223`	`223`	`Region region;`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ class FindVarUses : public IRVisitor {`
`53`	`53`	`};`
`54`	`54`
`55`	`55`	`template<typename StmtOrExpr>`
`56`		`-void find_var_uses(StmtOrExpr x, std::unordered_set<std::string> &unused_vars) {`
	`56`	`+void find_var_uses(const StmtOrExpr &x, std::unordered_set<std::string> &unused_vars) {`
`57`	`57`	`FindVarUses counter(unused_vars);`
`58`	`58`	`x.accept(&counter);`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -388,7 +388,7 @@ struct ScopedValue {`
`388`	`388`	`: var(var), old_value(var) {`
`389`	`389`	`}`
`390`	`390`	`/** Preserve the old value, then set the var to a new value. */`
`391`		`- ScopedValue(T &var, T new_value)`
	`391`	`+ ScopedValue(T &var, const T &new_value)`
`392`	`392`	`: var(var), old_value(var) {`
`393`	`393`	`var = new_value;`
`394`	`394`	`}`