[functorch] Minor fix2 (pytorch/functorch#797)

* use range-based for

* mordenize code

* reduce variable scope

Author: cyyever

functorch/functorch/csrc/BatchRulesLoss.cpp

@@ -263,7 +263,6 @@ at::Tensor nll_loss_backward_decomposition(
   if (self.dim() < 2) {
     channel_dim = 0;
   }
-  auto self_ = self;
   auto target_ = target.unsqueeze(channel_dim);
 
   auto grad_output_ = grad_output;
@@ -280,6 +279,7 @@ at::Tensor nll_loss_backward_decomposition(
 
   Tensor weight_;
   if (weight && weight->defined()) {
+    auto self_ = self;
     auto shape = weight->sizes();
     VmapDimVector new_shape(self_.dim(), 1);
     new_shape[channel_dim] = shape[0];

functorch/functorch/csrc/BatchRulesViews.cpp

@@ -217,10 +217,10 @@ std::tuple<Tensor, optional<int64_t>> squeeze_batch_rule(const Tensor& self, opt
   int64_t new_batch_idx = 0;
   int64_t original_idx = 0;
 
-  for (auto it = shape.begin(); it != shape.end(); ++it) {
+  for (auto it : shape) {
     // Keep only dimensions != 1 and the batch dimension (irrespective of size).
-    if (*it != 1 || original_idx == bdim) {
-      squeezed_sizes.push_back(*it);
+    if (it != 1 || original_idx == bdim) {
+      squeezed_sizes.push_back(it);
       if (original_idx == bdim) {
         before_batch_idx = false;
       }

functorch/functorch/csrc/CustomFunction.cpp

@@ -22,7 +22,7 @@ class PythonKernelHolder : public c10::OperatorKernel {
   // py::object destructor.  This is because this object may outlive
   // libtorch_python, so we want to disarm the deallocation if that happens.
   // PyInterpreter does this correctly, pybind11 does not.
-  ~PythonKernelHolder() {
+  ~PythonKernelHolder() override {
     getPyInterpreter()->decref(func_, /*is_tensor*/false);
   }
 
@@ -201,7 +201,7 @@ variable_list GenericPythonBackward::apply(variable_list&& grads) {
   return grad_inputs;
 }
 
-typedef TensorList (*custom_python_function_t)(TensorList);
+using custom_python_function_t = TensorList (*)(TensorList);
 
 using torch::autograd::compute_requires_grad;
 using torch::autograd::collect_next_edges;
@@ -216,14 +216,12 @@ void customFunctionBoxed(const c10::OperatorHandle& op, torch::jit::Stack* stack
 
   std::string schema_name = op.schema().name();
   std::string vjp_fn_name = schema_name + "_vjp";
-  auto vjp_fn = c10::Dispatcher::singleton()
-    .findSchemaOrThrow(vjp_fn_name.c_str(), "");
 
   std::shared_ptr<GenericPythonBackward> grad_fn;
   if (_any_requires_grad) {
     grad_fn = std::shared_ptr<GenericPythonBackward>(new GenericPythonBackward(), deleteNode);
     grad_fn->set_next_edges(collect_next_edges(tensors));
-    grad_fn->backward_fn_ = std::move(vjp_fn);
+    grad_fn->backward_fn_ = c10::Dispatcher::singleton().findSchemaOrThrow(vjp_fn_name.c_str(), "");
     grad_fn->num_inputs_ = tensors_.size();
   }
 
@@ -246,7 +244,7 @@ void customFunctionBoxed(const c10::OperatorHandle& op, torch::jit::Stack* stack
       if (!is_input) {
         set_history(tensor, grad_fn);
       }
-      grad_fn->saved_tensors_.push_back(torch::autograd::SavedVariable(tensor, !is_input));
+      grad_fn->saved_tensors_.emplace_back(tensor, !is_input);
     }
   }
   torch::jit::push(stack, result);

functorch/functorch/csrc/PlumbingHelper.cpp

@@ -21,8 +21,8 @@ Tensor makeBatched(const Tensor& tensor, optional<int64_t> bdim, int64_t level)
 
 std::vector<Tensor> makeBatchedVector(const std::vector<Tensor>& tensors, optional<int64_t> bdim, int64_t level) {
   std::vector<Tensor> res;
-  for (size_t idx = 0; idx < tensors.size(); idx++) {
-    res.emplace_back(makeBatched(tensors[idx], bdim, level));
+  for (const auto & tensor : tensors) {
+    res.emplace_back(makeBatched(tensor, bdim, level));
   }
   return res;
 }