Revert "Avoid some dangling reference warnings (pytorch#132535)"

This reverts commit f3d7a02.

Reverted pytorch#132535 on behalf of https://github.com/clee2000 due to broke some internal builds D64479234 ([comment](pytorch#132535 (comment)))

Author: pytorchmergebot

aten/src/ATen/ZeroTensorFallback.cpp

@@ -66,8 +66,7 @@ namespace at {
       } else if (ivalue.isTensorList()) {
         auto tensors = std::move(ivalue).toTensorList();
         for(const auto j : c10::irange(tensors.size())) {
-          const auto& tensor_ref = tensors[j];
-          const Tensor& tensor = tensor_ref;
+          const Tensor& tensor = tensors[j];
           if (tensor._is_zerotensor()) {
             // TODO: assert requires_grad=False
             //_like should not propagate zerotensor dispatch key

aten/src/ATen/core/IListRef_inl.h

@@ -168,8 +168,7 @@ class IListRefTagImpl<IListRefTag::Boxed, at::OptionalTensorRef>
    */
   static IListRefConstRef<at::OptionalTensorRef> iterator_get(
       const typename list_type::const_iterator& it) {
-    const auto& elem = *it;
-    const auto& ivalue = elem.get();
+    const auto& ivalue = (*it).get();
     if (!ivalue.isNone()) {
         const auto& tensor = ivalue.toTensor();
         return (tensor.defined()) ? tensor : at::OptionalTensorRef{};

aten/src/ATen/core/dispatch/DispatchKeyExtractor.h

@@ -151,9 +151,7 @@ struct TORCH_API DispatchKeyExtractor final {
         // no safe toTensorRef method, alas)
         ks = ks | ivalue.unsafeToTensorImpl()->key_set();
       } else if (C10_UNLIKELY(ivalue.isTensorList())) {
-        const c10::List<at::Tensor> tensorlist = ivalue.toTensorList();
-        for (const auto& tensor_ref : tensorlist) {
-          const at::Tensor& tensor = tensor_ref;
+        for (const at::Tensor& tensor : ivalue.toTensorList()) {
           ks = ks | tensor.key_set();
         }
       }

torch/csrc/inductor/aoti_torch/oss_proxy_executor.cpp

@@ -21,9 +21,8 @@ void OSSProxyExecutor::prefill_stack_with_static_arguments(
   auto& dynamic_args = op_kernel.dynamic_args_;
 
   TORCH_CHECK(serialized_arg.size() == 1);
-  auto serialized_arg_elem = serialized_arg.begin();
-  std::string serialized_arg_type = serialized_arg_elem.key();
-  auto& serialized_arg_val = serialized_arg_elem.value();
+  std::string serialized_arg_type = serialized_arg.begin().key();
+  auto& serialized_arg_val = serialized_arg.begin().value();
 
   switch (schema_arg_type->kind()) {
     case c10::TypeKind::TensorType: {
@@ -256,9 +255,8 @@ void OSSProxyExecutor::get_output_info_from_serialized(
   size_t output_index = 0;
   for (const auto& serialized_output : serialized_node["outputs"]) {
     TORCH_CHECK(serialized_output.size() == 1);
-    auto serialized_output_elem = serialized_output.begin();
-    std::string serialized_output_type = serialized_output_elem.key();
-    auto& serialized_output_val = serialized_output_elem.value();
+    std::string serialized_output_type = serialized_output.begin().key();
+    auto& serialized_output_val = serialized_output.begin().value();
 
     auto& schema_return = schema_returns[output_index];
     const at::TypePtr& schema_return_type = schema_return.real_type();

torch/csrc/jit/frontend/ir_emitter.cpp

@@ -854,8 +854,7 @@ struct to_ir {
 
     if (self) {
       AT_ASSERT(it != end);
-      auto ident = (*it).ident();
-      const auto& name = ident.name();
+      const auto& name = (*it).ident().name();
       Value* new_input = block->addInput()->setDebugName(name);
       environment_stack->setSugaredVar(
           (*it).ident().range(),
@@ -873,8 +872,7 @@ struct to_ir {
     bool shouldDeriveType = shouldDeriveSetStateType(def, schema);
     size_t arg_annotation_idx = 0;
     for (; it != end; ++it) {
-      auto ident = (*it).ident();
-      auto& name = ident.name();
+      auto& name = (*it).ident().name();
       // Add the input to the graph
       Value* new_input = block->addInput();
       if (meaningfulName(name)) {
@@ -1019,8 +1017,7 @@ struct to_ir {
                  " (see https://github.com/pytorch/pytorch/issues/31430)");
         }
         const SugaredValuePtr sv = emitSugaredExpr(subscript.value(), 1);
-        auto subscript_value = subscript.value();
-        const SourceRange& val_range = subscript_value.range();
+        const SourceRange& val_range = subscript.value().range();
         Value* idx = emitExpr(subscript_exprs[0]);
         Value* val = sv->asValue(val_range, method);
 
@@ -1193,8 +1190,7 @@ struct to_ir {
       return {};
     }
     // statement must be var {is, is not} None
-    auto var_lhs_name = Var(lhs).name();
-    const std::string& name = var_lhs_name.name();
+    const std::string& name = Var(lhs).name().name();
     // While it should in theory be possible to specialize
     // the `x is None` to know x has type NoneType, we have previously
     // not done this. Unfortunately, doing this will make the type None
@@ -2173,8 +2169,7 @@ struct to_ir {
           ErrorReport(attrExpr)
           << "hasattr's second argument must be a string literal");
     }
-    auto literal = StringLiteral(attrExpr);
-    const std::string& name = literal.text();
+    const std::string& name = StringLiteral(attrExpr).text();
     const bool hasAttr = obj->hasAttr(objExpr.range(), method, name);
     return CondValue(*graph, objExpr.range(), hasAttr, {});
   }
@@ -3507,8 +3502,7 @@ struct to_ir {
               ErrorReport(apply)
               << "getattr's second argument must be a string literal");
         }
-        auto literal = StringLiteral(selector);
-        const std::string& name = literal.text();
+        const std::string& name = StringLiteral(selector).text();
 
         if (apply.inputs().size() == 2) {
           return obj->attr(apply.range(), method, name);
@@ -5293,8 +5287,7 @@ struct to_ir {
     const SugaredValuePtr sv = emitSugaredExpr(subscript.value(), 1);
     const List<Expr>& subscript_exprs = subscript.subscript_exprs();
     const SourceRange& range = subscript.range();
-    const auto& val = subscript.value();
-    const SourceRange& val_range = val.range();
+    const SourceRange& val_range = subscript.value().range();
     if (subscript_exprs.size() != 1) {
       return std::make_shared<SimpleValue>(emitMultidimSlicing(
           range, sv->asValue(val_range, method), subscript_exprs));

torch/csrc/jit/frontend/script_type_parser.cpp

@@ -124,8 +124,7 @@ std::optional<std::pair<TypePtr, int32_t>> ScriptTypeParser::parseBroadcastList(
   // Alias torch.nn._common_types._size_?_t to BroadcastingList?[int]
   if (expr.kind() == TK_VAR) {
     auto var = Var(expr);
-    auto var_name = var.name();
-    auto& name = var_name.name();
+    auto& name = var.name().name();
     constexpr auto _size_prefix = "_size_";
     constexpr auto _size_suffix = "_t";
     constexpr auto _size_n_len = 9; // strlen("_size_X_t")
@@ -207,8 +206,7 @@ std::optional<std::string> ScriptTypeParser::parseBaseTypeName(
     }
     case '.': {
       auto select = Select(expr);
-      auto selector = select.selector();
-      const std::string& name = selector.name();
+      const std::string& name = select.selector().name();
       // Special case for torch.Tensor and its' subclasses
       const std::unordered_set<std::string> tensor_subtypes = {
           "Tensor",
@@ -264,8 +262,7 @@ TypePtr ScriptTypeParser::parseTypeFromExprImpl(const Expr& expr) const {
     return subscriptToType(*value_name, subscript);
 
   } else if (expr.kind() == TK_STRINGLITERAL) {
-    auto literal = StringLiteral(expr);
-    const auto& type_name = literal.text();
+    const auto& type_name = StringLiteral(expr).text();
 
     // Check if the type is a custom class. This is done by checking
     // if type_name starts with "torch.classes."

torch/csrc/jit/ir/alias_analysis.cpp

@@ -828,8 +828,7 @@ void AliasDb::analyzeImpl(Node* node) {
   std::unordered_map<Symbol, Value*> formalToActual;
   for (const auto i : c10::irange(schema.arguments().size())) {
     const at::AliasInfo* formal = schema.arguments()[i].alias_info();
-    auto node_inputs = node->inputs();
-    const auto& actualValue = node_inputs.at(i);
+    const auto& actualValue = node->inputs().at(i);
 
     // Skip if there's no alias annotation
     if (!formal) {

torch/csrc/jit/mobile/nnc/context.cpp

@@ -132,24 +132,24 @@ Function::Function(const c10::IValue& value) {
   nnc_kernel_id_ = dict.at("nnc_kernel_id").toStringRef();
   parameters_ = dict.at("parameters").toList();
 
-  auto input_tuple_ref = dict.at("input_specs").toTupleRef();
   // input_specs_
-  for (const auto& input_value : input_tuple_ref.elements()) {
+  for (const auto& input_value :
+       dict.at("input_specs").toTupleRef().elements()) {
     input_specs_.emplace_back(input_value);
   }
 
-  auto output_tuple_ref = dict.at("output_specs").toTupleRef();
   // output_specs_
-  for (const auto& output_value : output_tuple_ref.elements()) {
+  for (const auto& output_value :
+       dict.at("output_specs").toTupleRef().elements()) {
     output_specs_.emplace_back(output_value);
   }
 
   // memory_plan_
   memory_plan_ = MemoryPlan(dict.at("memory_plan"));
 
-  auto pos_tuple_ref = dict.at("sym_shape_pos").toTupleRef();
   // symbolic shape positions
-  for (const auto& sym_shape_pos : pos_tuple_ref.elements()) {
+  for (const auto& sym_shape_pos :
+       dict.at("sym_shape_pos").toTupleRef().elements()) {
     auto sym_shape_elements = sym_shape_pos.toTupleRef().elements();
     sym_shape_positions_.emplace_back(
         sym_shape_elements[0].toInt(), sym_shape_elements[1].toInt());

torch/csrc/jit/mobile/quantization.cpp

@@ -49,8 +49,8 @@ void PTQQuanizationHelper::quantize_dynamic(
 
   m.compareMethodSchemas(method_name, quantized_method_name);
   m.unsafeRemoveMethod(method_name);
-  const auto& quantized_method = m.find_method(quantized_method_name);
-  const Function& to_be_copied = quantized_method.value().function();
+  const Function& to_be_copied =
+      m.find_method(quantized_method_name).value().function();
   m.unsafeCopyMethod(method_name, to_be_copied);
   m.unsafeRemoveMethod(quantized_method_name);
   m.unsafeRemoveMethod(quantize_method_name);

torch/csrc/jit/passes/quantization/helper.cpp

@@ -332,8 +332,7 @@ void cloneMethod(
     Module& module,
     const std::string& orig_method_name,
     const std::string& new_method_name) {
-  const auto& orig_method = module.get_method(orig_method_name);
-  const Function& method = orig_method.function();
+  const Function& method = module.get_method(orig_method_name).function();
   auto graph = toGraphFunction(method).graph()->copy();
   const auto& schema = method.getSchema();
   const auto this_method_name =

torch/csrc/jit/passes/quantization/insert_quant_dequant.cpp

@@ -1444,8 +1444,7 @@ void InsertQuantDeQuantHelper::run(
   // observing a potentially mutated value due to some in-place operation
   std::vector<Value*> input_values;
   for (const auto idx : c10::irange(1, method.num_inputs())) {
-    auto inputs = graph->inputs();
-    const auto v = inputs[idx];
+    auto& v = graph->inputs()[idx];
     if (v->type()->isSubtypeOf(*TensorType::get())) {
       input_values.push_back(v);
     }
@@ -1652,8 +1651,7 @@ void InsertQuantDeQuantHelper::runForOnDevicePTQ(
   // observing a potentially mutated value due to some in-place operation
   std::vector<Value*> input_values;
   for (const auto idx : c10::irange(1, method.num_inputs())) {
-    auto inputs = graph->inputs();
-    auto& v = inputs[idx];
+    auto& v = graph->inputs()[idx];
     if (v->type()->isSubtypeOf(*TensorType::get())) {
       input_values.push_back(v);
     }

torch/csrc/jit/passes/utils/check_alias_annotation.cpp

@@ -26,8 +26,7 @@ IValue deepCopy(const IValue& self) {
     auto source = self.toList();
     auto newList = c10::impl::GenericList(source.elementType());
     newList.reserve(source.size());
-    for (const auto& value_ref : source) {
-      const IValue& value = value_ref;
+    for (const IValue& value : source) {
       newList.push_back(deepCopy(value));
     }
     return newList;

torch/csrc/jit/runtime/graph_executor.cpp

@@ -330,8 +330,7 @@ struct DifferentiableGraphBackward : public autograd::Node {
   void addOutputForIValue(const IValue& value) {
     if (value.isTensorList()) {
       input_tensor_lists_.insert({index_, value.toTensorList().size()});
-      for (const auto& tensor_ref : value.toTensorList()) {
-        const at::Tensor& tensor = tensor_ref;
+      for (const at::Tensor& tensor : value.toTensorList()) {
         addOutputForTensor(tensor);
         index_++;
       }
@@ -362,8 +361,7 @@ struct DifferentiableGraphBackward : public autograd::Node {
     if (v.isTensorList()) {
       auto tensors = v.toTensorList();
       input_instructions_.pushTensorList(tensors.size());
-      for (const auto& tensor_ref : tensors) {
-        const at::Tensor& tensor = tensor_ref;
+      for (const at::Tensor& tensor : tensors) {
         addInputVariable(tensor);
       }
     } else if (v.isTensor()) {

torch/csrc/jit/runtime/register_ops_utils.h

@@ -329,8 +329,7 @@ void listContains(Stack& stack) {
   auto key = pop(stack).to<T>();
   auto list = pop(stack).to<c10::List<T>>();
   // NOLINTNEXTLINE(performance-implicit-conversion-in-loop)
-  for (const auto& item_ref : list) {
-    const T& item = item_ref;
+  for (const T& item : list) {
     if (item == key) {
       push(stack, true);
       return;

torch/csrc/jit/runtime/static/native_ops.cpp

@@ -1175,8 +1175,7 @@ REGISTER_NATIVE_OPERATOR_FUNCTOR(
           p_node->Output(0) = future->value();
           return;
         }
-        auto tuple_ref = future->value().toTupleRef();
-        auto& elems = tuple_ref.elements();
+        auto& elems = future->value().toTupleRef().elements();
         TORCH_DCHECK_EQ(elems.size(), p_node->num_outputs());
         for (const auto i : c10::irange(elems.size())) {
           p_node->Output(i) = elems[i];

torch/csrc/jit/serialization/export_module.cpp

@@ -204,9 +204,8 @@ std::pair<IValue, IValue> getFunctionTuple(
       // For DictType, there are two items in t->containedTypes(), the first one
       // is key and the second one is value. Both of them could be NamedTuple
       // type.
-      const auto& contained_types = t->containedTypes();
-      const TypePtr& key_type = contained_types[0];
-      const TypePtr& value_type = contained_types[1];
+      const TypePtr& key_type = t->containedTypes()[0];
+      const TypePtr& value_type = t->containedTypes()[1];
       std::string key_type_str = get_named_tuple_str_or_default(
           compilation_unit, key_type, key_type->annotation_str());
       std::string value_type_str = get_named_tuple_str_or_default(

torch/csrc/jit/serialization/import_source.cpp

@@ -283,8 +283,7 @@ void SourceImporterImpl::importNamedType(
   if (!class_def.superclass().present()) {
     return importClass(qualified_name, class_def, /*is_module=*/false);
   }
-  auto superclass_name_var = Var(class_def.superclass().get()).name();
-  const auto& superclass_name = superclass_name_var.name();
+  const auto& superclass_name = Var(class_def.superclass().get()).name().name();
   if (superclass_name == "Module") {
     importClass(qualified_name, class_def, /*is_module=*/true);
   } else if (superclass_name == "NamedTuple") {

torch/csrc/jit/serialization/python_print.cpp

@@ -1139,8 +1139,7 @@ struct PythonPrintImpl {
         stmt << ")";
       } break;
       case prim::CallMethod: {
-        auto node_inputs = node->inputs();
-        const auto& self = node_inputs.at(0);
+        const auto& self = node->inputs().at(0);
         const auto& methodName = node->s(attr::name);
         stmt << "(" << useOf(self) << ")"
              << "." << methodName << "(";

torch/csrc/jit/serialization/unpickler.cpp

@@ -142,8 +142,7 @@ void restoreAccurateTypeTags(const IValue& root, const TypePtr& type_tag) {
         auto elem_type = w.type->containedType(0);
         auto lst = w.value.toList();
         lst.unsafeSetElementType(elem_type);
-        for (const auto& item_ref : lst) {
-          const IValue& item = item_ref;
+        for (const IValue& item : lst) {
           Work elem = {elem_type, item};
           to_process.emplace_back(std::move(elem));
         }

torch/csrc/jit/tensorexpr/kernel.cpp

@@ -1763,8 +1763,7 @@ void TensorExprKernel::compile() {
 
   // Move output operands from `bufs_` to `bufOutputs_`
   for (auto i : c10::irange(graph_->outputs().size())) {
-    auto outputs = graph_->outputs();
-    auto& output = outputs.at(i);
+    auto& output = graph_->outputs().at(i);
     if (!bufs_.count(output)) {
       throw malformed_input("cannot find output Tensor");
     }

torch/csrc/profiler/standalone/nvtx_observer.cpp

@@ -68,8 +68,7 @@ static std::list<std::pair<at::RecordFunctionHandle, int>> flattenOpIdList(
   std::list<std::pair<at::RecordFunctionHandle, int>> input_op_id_list;
   auto state_ptr = NVTXThreadLocalState::getTLS();
   TORCH_INTERNAL_ASSERT(state_ptr, "Expected profiler state set");
-  for (const auto& input_ref : list) {
-    const c10::IValue& input = input_ref;
+  for (const c10::IValue& input : list) {
     if (input.isTensor()) {
       const at::Tensor& tensor = input.toTensor();
       auto producer_op_pair = state_ptr->getOpIdFromInput(tensor);

torch/csrc/profiler/util.cpp

@@ -163,8 +163,7 @@ std::string stacksToStr(
 static std::vector<std::vector<int64_t>> flattenList(
     const c10::List<c10::IValue>& list) {
   std::vector<std::vector<int64_t>> tensor_dims;
-  for (const auto& input_ref : list) {
-    const c10::IValue& input = input_ref;
+  for (const c10::IValue& input : list) {
     if (input.isTensor()) {
       const at::Tensor& tensor = input.toTensor();
       if (tensor.defined()) {