Updated codegen to remove TensorOptions from generated code

Author: izdeby

aten/src/ATen/ScalarOps.h

@@ -13,14 +13,14 @@ inline at::Tensor scalar_to_tensor(Scalar s, const Device device = at::kCPU) {
   // This is the fast track we have for CPU scalar tensors.
   if (device == at::kCPU) {
     if (s.isFloatingPoint()) {
-      return at::native::scalar_tensor(s, at::device(at::kCPU).dtype(at::kDouble));
+      return at::native::scalar_tensor(s, at::kDouble, c10::nullopt, at::kCPU);
     } else if (s.isBoolean()) {
-      return at::native::scalar_tensor(s, at::device(at::kCPU).dtype(at::kBool));
+      return at::native::scalar_tensor(s, at::kBool, c10::nullopt, at::kCPU);
     } else if (s.isComplex()) {
-      return at::native::scalar_tensor(s, at::device(at::kCPU).dtype(at::kComplexDouble));
+      return at::native::scalar_tensor(s, at::kComplexDouble, c10::nullopt, at::kCPU);
     } else {
       AT_ASSERT(s.isIntegral(false));
-      return at::native::scalar_tensor(s, at::device(at::kCPU).dtype(at::kLong));
+      return at::native::scalar_tensor(s,  at::kLong, c10::nullopt, at::kCPU);
     }
   }
   if (s.isFloatingPoint()) {

aten/src/ATen/function_wrapper.py

@@ -236,7 +236,9 @@ std::tuple<Tensor, Tensor, double, int64_t> fbgemm_linear_quantize_weight(
   q_params.precision = kPrecision;
 
   Tensor quantized = at::native::empty_like(
-      weight_contig, weight_contig.options().dtype(at::kChar), LEGACY_CONTIGUOUS_MEMORY_FORMAT);
+      weight_contig, at::kChar, weight_contig.options().layout(), 
+      weight_contig.options().device(), weight_contig.options().pinned_memory(), 
+      LEGACY_CONTIGUOUS_MEMORY_FORMAT);
   // Tensor quantized = at::native::empty_cpu(
   //     weight_contig.sizes(), weight_contig.options().dtype(at::kChar));
   fbgemm::Quantize<int8_t>(

aten/src/ATen/native/QuantizedLinear.cpp

@@ -150,7 +150,12 @@ Tensor& _sobol_engine_initialize_state_(Tensor& sobolstate, int64_t dimension) {
     }
   }
 
-  Tensor pow2s = at::pow(2, at::native::arange((MAXBIT - 1), -1, -1, sobolstate.options()));
+  Tensor pow2s = at::pow(2, at::native::arange(
+    (MAXBIT - 1), -1, -1, 
+    typeMetaToScalarType(sobolstate.options().dtype()), 
+                         sobolstate.options().layout(), 
+                         sobolstate.options().device(), 
+                         sobolstate.options().pinned_memory()));
   sobolstate.mul_(pow2s);
   return sobolstate;
 }

aten/src/ATen/native/SobolEngineOps.cpp

@@ -36,7 +36,11 @@ Tensor _bincount_cpu_template(
 
   const input_t* self_p = self.data_ptr<input_t>();
   if (has_weights) {
-    output = native::zeros({nbins}, weights.options());
+    output = native::zeros({nbins},
+                            typeMetaToScalarType(weights.options().dtype()),
+                                                 weights.options().layout(),
+                                                 weights.options().device(),
+                                                 weights.options().pinned_memory());
     weights_t* output_p = output.data_ptr<weights_t>();
     const weights_t* weights_p = weights.data_ptr<weights_t>();
     for (int64_t i = 0; i < self.size(0); i++) {

aten/src/ATen/native/SummaryOps.cpp

@@ -45,29 +45,23 @@ static inline Tensor to_impl(const Tensor& self, const TensorOptions& options, b
   return r;
 }
 
-Tensor to(const Tensor& self, const TensorOptions& options, bool non_blocking, bool copy, c10::optional<c10::MemoryFormat> optional_memory_format) {
-  TORCH_CHECK(options.requires_grad_opt() == c10::nullopt,
-           "to(options) expects unset requires_grad flag, but got "
-           "options.requires_grad set as ", options.requires_grad());
-
-  const auto & layout_opt = options.layout_opt();
-  TORCH_CHECK(!layout_opt || self.layout() == layout_opt.value(),
+Tensor to(const Tensor& self, c10::optional<ScalarType> dtype, c10::optional<Layout> layout, c10::optional<Device> device, c10::optional<bool> pin_memory, bool non_blocking, bool copy, c10::optional<c10::MemoryFormat> optional_memory_format) {
+  TORCH_CHECK(!layout.has_value() || self.layout() == layout.value(),
            "to(options) doesn't support converting to a different layout, "
            "but got self.layout being ", self.layout(),
-           " and options.layout set as ", options.layout());
-
-  auto device_opt = options.device_opt();
-  if (device_opt) {
-    device_opt = ensure_has_index(device_opt.value());
+           " and options.layout set as ", layout.value());
+  
+  if (device.has_value()) {
+    device = ensure_has_index(device.value());
   }
-  const auto & dtype_opt = options.dtype_opt();
   auto specified_options = self.options();
-  if (device_opt) {
-    specified_options = specified_options.device(device_opt.value());
+  if (device.has_value()) {
+    specified_options = specified_options.device(device.value());
   }
-  if (dtype_opt) {
-    specified_options = specified_options.dtype(dtype_opt.value());
+  if (dtype.has_value()) {
+    specified_options = specified_options.dtype(dtype.value());
   }
+  
   return to_impl(self, specified_options, non_blocking, copy, optional_memory_format);
 }