make THPPointer have explicit constructors (pytorch#1636)

Author: killeent

tools/cwrap/plugins/THPPlugin.py

@@ -127,7 +127,7 @@ class THPPlugin(CWrapPlugin):
     """)
 
     ALLOCATE_TMPL = Template("""\
-THP${type}TensorPtr _${name}_guard = (THP${type}Tensor*) THP${type}Tensor_NewEmpty();
+THP${type}TensorPtr _${name}_guard((THP${type}Tensor*) THP${type}Tensor_NewEmpty());
 if (!_${name}_guard.get()) return NULL;
 THP${type}Tensor* $name = _${name}_guard.get();
 """)

torch/csrc/Generator.cpp

@@ -33,7 +33,7 @@ static PyObject * THPGenerator_pynew(PyTypeObject *type, PyObject *args, PyObjec
     THPUtils_setError("torch.Generator constructor doesn't accept any arguments");
     return NULL;
   }
-  THPGeneratorPtr self = (THPGenerator *)type->tp_alloc(type, 0);
+  THPGeneratorPtr self((THPGenerator *)type->tp_alloc(type, 0));
   self->cdata = THGenerator_new();
 
   return (PyObject*)self.release();
@@ -44,7 +44,7 @@ static PyObject * THPGenerator_getState(THPGenerator *self)
 {
   HANDLE_TH_ERRORS
   THGenerator *generator = self->cdata;
-  THPByteTensorPtr res = (THPByteTensor *)THPByteTensor_NewEmpty();
+  THPByteTensorPtr res((THPByteTensor *)THPByteTensor_NewEmpty());
   if (!res) return NULL;
   THByteTensor_getRNGState(generator, res->cdata);
   return (PyObject *)res.release();

torch/csrc/Module.cpp

@@ -63,7 +63,7 @@ static PyObject * THPModule_initNames(PyObject *self, PyObject *arg)
 {
   static std::vector<std::string> names;
 
-  THPObjectPtr types = PySequence_Fast(arg, "expected a sequence");
+  THPObjectPtr types(PySequence_Fast(arg, "expected a sequence"));
   if (!types) return NULL;
 
   int num_classes = PySequence_Fast_GET_SIZE(types.get());
@@ -73,7 +73,7 @@ static PyObject * THPModule_initNames(PyObject *self, PyObject *arg)
     THPUtils_assert(PyType_Check(obj), "expected a PyTypeObject");
     PyTypeObject* type = (PyTypeObject*)obj;
 
-    THPObjectPtr module_name = PyObject_GetAttrString(obj, "__module__");
+    THPObjectPtr module_name(PyObject_GetAttrString(obj, "__module__"));
     if (!module_name) return NULL;
     THPUtils_assert(THPUtils_checkString(module_name.get()),
         "expected __module__ to be a string");

torch/csrc/Size.cpp

@@ -25,7 +25,7 @@ PyObject * THPSize_New(int dim, long *sizes)
 
 static PyObject * THPSize_pynew(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 {
-  THPObjectPtr self = PyTuple_Type.tp_new(type, args, kwargs);
+  THPObjectPtr self(PyTuple_Type.tp_new(type, args, kwargs));
   if (self) {
     for (Py_ssize_t i = 0; i < PyTuple_Size(self); ++i) {
       PyObject *item = PyTuple_GET_ITEM(self.get(), i);

torch/csrc/autograd/functions/init.cpp

@@ -81,7 +81,7 @@ PyObject* getTupleAttr(PyObject* obj, void* _unused)
   THPCppFunction* self = (THPCppFunction*)obj;
   auto& arr = ((T*)(self->cdata.get()))->*ptr;
   auto num_elems = arr.size();
-  THPObjectPtr py_tuple = PyTuple_New(num_elems);
+  THPObjectPtr py_tuple(PyTuple_New(num_elems));
   if (!py_tuple) return NULL;
   for (size_t i = 0; i < num_elems; ++i) {
     PyTuple_SET_ITEM(py_tuple.get(), i, Convert(arr[i]));
@@ -203,7 +203,7 @@ static struct PyGetSetDef accumulate_grad_properties[] = {
 
 bool THPAutograd_initFunctions(PyObject* _unused)
 {
-  THPObjectPtr module = PyModule_New("torch._C._functions");
+  THPObjectPtr module(PyModule_New("torch._C._functions"));
   if (!module) return false;
 
   static PyTypeObject BatchNormClass, BatchNormBackwardClass;
@@ -233,7 +233,7 @@ bool THPAutograd_initFunctions(PyObject* _unused)
   static PyTypeObject IdentityClass;
   addClass<Identity, NoCtor>(module, IdentityClass, "Identity");
 
-  THPObjectPtr parent = PyImport_ImportModule("torch._C");
+  THPObjectPtr parent(PyImport_ImportModule("torch._C"));
   if (!parent) return false;
   PyModule_AddObject(parent.get(), "_functions", module.release());
   return true;

torch/csrc/autograd/python_cpp_function.cpp

@@ -53,7 +53,7 @@ PyObject* THPCppFunction_call(PyObject* self, PyObject* args, PyObject *kwargs)
     return THPVariable_Wrap(output[0]);
   }
 
-  THPObjectPtr tuple = PyTuple_New(num_outputs);
+  THPObjectPtr tuple(PyTuple_New(num_outputs));
   for (int i = 0; i != num_outputs; ++i) {
     PyTuple_SET_ITEM(tuple.get(), i, THPVariable_Wrap(output[i]));
   }
@@ -94,11 +94,11 @@ PyObject* THPCppFunction_next_functions(THPCppFunction* self, PyObject* hook)
 {
   auto& next_functions = self->cdata->next_functions;
   auto num_next = next_functions.size();
-  THPObjectPtr py_functions = PyTuple_New(num_next);
+  THPObjectPtr py_functions(PyTuple_New(num_next));
   if (!py_functions) return NULL;
   for (size_t i = 0; i < num_next; ++i) {
     auto& c_tuple = next_functions[i];
-    THPObjectPtr tuple = PyTuple_New(2);
+    THPObjectPtr tuple(PyTuple_New(2));
     if (!tuple) return NULL;
     PyObject *py_fn = functionToPyObject(c_tuple.first);
     if (!py_fn) return NULL;
@@ -181,7 +181,7 @@ PyObject* functionToPyObject(std::shared_ptr<Function> cdata)
   }
 
   PyTypeObject* type = (PyTypeObject*)it->second.get();
-  THPObjectPtr obj = type->tp_alloc(type, 0);
+  THPObjectPtr obj(type->tp_alloc(type, 0));
   if (!obj) return NULL;
   THPCppFunction* f = (THPCppFunction*)obj.get();
   new (&f->cdata) std::shared_ptr<Function>(cdata);
@@ -207,9 +207,9 @@ PyObject* registerFunctionHook(Function& fn, PyObject* hook)
     }
   }
 
-  THPObjectPtr register_fn = PyObject_GetAttrString(THPFunctionClass, "_register_hook");
+  THPObjectPtr register_fn(PyObject_GetAttrString(THPFunctionClass, "_register_hook"));
   if (!register_fn) return NULL;
-  THPObjectPtr res = PyObject_CallFunctionObjArgs(register_fn.get(), dict, hook, NULL);
+  THPObjectPtr res(PyObject_CallFunctionObjArgs(register_fn.get(), dict, hook, NULL));
   if (!res) return NULL;
 
   if (dict == Py_None) {

torch/csrc/autograd/python_cpp_function.h

@@ -18,7 +18,7 @@ struct THPCppFunction {
 template<typename Ctor>
 PyObject* CppFunction_pynew(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-  THPObjectPtr obj = type->tp_alloc(type, 0);
+  THPObjectPtr obj(type->tp_alloc(type, 0));
   if (!obj) return NULL;
   THPCppFunction* f = (THPCppFunction*)obj.get();
   HANDLE_TH_ERRORS

torch/csrc/autograd/python_function.cpp

@@ -59,11 +59,11 @@ static PyObject* _allocate_grad_output(output_info_type& info, AutoGPU& gpu_guar
   gpu_guard.setDevice(std::get<1>(info));
   std::vector<long> &sizes = std::get<2>(info);
 
-  THPObjectPtr grad_size = THPSize_New(sizes.size(), sizes.data());
+  THPObjectPtr grad_size(THPSize_New(sizes.size(), sizes.data()));
   if (!grad_size) throw python_error();
-  THPObjectPtr new_grad = PyObject_CallFunctionObjArgs(tensor_cls, grad_size.get(), NULL);
+  THPObjectPtr new_grad(PyObject_CallFunctionObjArgs(tensor_cls, grad_size.get(), NULL));
   if (!new_grad) throw python_error();
-  THPObjectPtr result = PyObject_CallMethod(new_grad.get(), "zero_", "");
+  THPObjectPtr result(PyObject_CallMethod(new_grad.get(), "zero_", ""));
   if (!result) throw python_error();
   return new_grad.release();
 }
@@ -73,7 +73,7 @@ namespace torch { namespace autograd {
 auto PyFunction::legacy_apply(const variable_list& inputs) -> variable_list {
   AutoGIL gil;
 
-  THPObjectPtr pyInputs = PyTuple_New(inputs.size());
+  THPObjectPtr pyInputs(PyTuple_New(inputs.size()));
   if (!pyInputs) throw python_error();
 
   for (size_t i = 0; i != inputs.size(); ++i) {
@@ -88,8 +88,8 @@ auto PyFunction::legacy_apply(const variable_list& inputs) -> variable_list {
     PyTuple_SET_ITEM(pyInputs.get(), i, input);
   }
 
-  THPObjectPtr r = PyObject_CallMethod(
-      obj, "_do_backward", "OO", pyInputs.get(), Py_True);
+  THPObjectPtr r(PyObject_CallMethod(
+      obj, "_do_backward", "OO", pyInputs.get(), Py_True));
   if (!r) throw python_error();
 
   auto num_outputs = PyTuple_GET_SIZE(r.get());
@@ -126,32 +126,32 @@ auto PyFunction::apply(const variable_list& inputs) -> variable_list {
   AutoGPU _gpu_guard(-1);
   THPFunction* py_fn = (THPFunction*)obj;
 
-  THPObjectPtr _legacy = PyObject_GetAttrString(obj, "_is_legacy");
+  THPObjectPtr _legacy(PyObject_GetAttrString(obj, "_is_legacy"));
   if (_legacy == Py_True) {
     return legacy_apply(inputs);
   }
 
   // Massage a C++ variable_list into a Python arguments tuple
   auto num_inputs = inputs.size();
-  THPObjectPtr pyInputs = PyTuple_New(num_inputs);
+  THPObjectPtr pyInputs(PyTuple_New(num_inputs));
   if (!pyInputs) throw python_error();
   auto& output_info = *py_fn->output_info;
   for (size_t i = 0; i < num_inputs; ++i) {
     PyObject* input;
     if (inputs[i]) {
       input = THPVariable_Wrap(inputs[i]);
     } else {
-      THPObjectPtr tensor = _allocate_grad_output(output_info[i], _gpu_guard);
+      THPObjectPtr tensor(_allocate_grad_output(output_info[i], _gpu_guard));
       input = THPVariable_NewLeaf(tensor);
     }
     if (!input) throw python_error();
     PyTuple_SET_ITEM(pyInputs.get(), i, input);
   }
 
   // TODO: theoretically we could take a shortcut here and call apply directly
-  THPObjectPtr apply_fn = PyObject_GetAttrString(obj, "apply");
+  THPObjectPtr apply_fn(PyObject_GetAttrString(obj, "apply"));
   if (!apply_fn) throw python_error();
-  THPObjectPtr r = PyObject_CallObject(apply_fn, pyInputs.get());
+  THPObjectPtr r(PyObject_CallObject(apply_fn, pyInputs.get()));
   if (!r) throw python_error();
   _ensure_tuple(r);
 
@@ -625,12 +625,12 @@ std::pair<UnpackedInput, InputFlags> unpack_input(PyObject *args) {
   return std::make_pair(std::move(unpacked), std::move(flags));
 }
 
-PyObject* process_outputs(THPFunction* grad_fn, const UnpackedInput& unpacked, THPObjectPtr raw_output, bool is_volatile) {
+PyObject* process_outputs(THPFunction* grad_fn, const UnpackedInput& unpacked, THPObjectPtr&& raw_output, bool is_volatile) {
   bool unpack_output = _ensure_tuple(raw_output);
 
   auto num_outputs = PyTuple_GET_SIZE(raw_output.get());
 
-  THPObjectPtr outputs = PyTuple_New(num_outputs);
+  THPObjectPtr outputs(PyTuple_New(num_outputs));
   if (!outputs) throw python_error();
 
   grad_fn->cdata.num_inputs = num_outputs;
@@ -678,9 +678,9 @@ PyObject *THPFunction_do_forward(THPFunction *self, PyObject *_inputs)
   self->needs_input_grad = input_info.needs_input_grad.release();
 
   // Now we're ready to call a forward (implemented in Python)
-  THPObjectPtr forward_fn = PyObject_GetAttrString((PyObject*)self, "forward");
+  THPObjectPtr forward_fn(PyObject_GetAttrString((PyObject*)self, "forward"));
   if (!forward_fn) return NULL;
-  THPObjectPtr raw_output = PyObject_CallObject(forward_fn, unpacked_input.tensor_input);
+  THPObjectPtr raw_output(PyObject_CallObject(forward_fn, unpacked_input.tensor_input));
   if (!raw_output) return NULL;
 
   return process_outputs(self, unpacked_input, std::move(raw_output), is_volatile);
@@ -691,9 +691,9 @@ PyObject *THPFunction_apply(PyObject *cls, PyObject *_inputs)
 {
   HANDLE_TH_ERRORS
 
-  THPObjectPtr backward_cls = PyObject_GetAttrString(cls, "_backward_cls");
+  THPObjectPtr backward_cls(PyObject_GetAttrString(cls, "_backward_cls"));
   if (!backward_cls) return NULL;
-  THPObjectPtr ctx_obj = PyObject_CallFunctionObjArgs(backward_cls, NULL);
+  THPObjectPtr ctx_obj(PyObject_CallFunctionObjArgs(backward_cls, NULL));
   if (!ctx_obj) return NULL;
   THPFunction* ctx = (THPFunction*)ctx_obj.get();
 
@@ -708,7 +708,7 @@ PyObject *THPFunction_apply(PyObject *cls, PyObject *_inputs)
 
   // Prepend ctx to tensor_input, in preparation for static method call
   auto num_args = PyTuple_GET_SIZE(_inputs);
-  THPObjectPtr ctx_tensor_input = PyTuple_New(num_args + 1);
+  THPObjectPtr ctx_tensor_input(PyTuple_New(num_args + 1));
   PyTuple_SET_ITEM(ctx_tensor_input.get(), 0, ctx_obj.release());
   for (int i = 0; i < num_args; ++i) {
     PyObject *arg = PyTuple_GET_ITEM(unpacked_input.tensor_input.get(), i);
@@ -717,9 +717,9 @@ PyObject *THPFunction_apply(PyObject *cls, PyObject *_inputs)
   }
 
   // Call forward
-  THPObjectPtr forward_fn = PyObject_GetAttrString(cls, "forward");
+  THPObjectPtr forward_fn(PyObject_GetAttrString(cls, "forward"));
   if (!forward_fn) return NULL;
-  THPObjectPtr tensor_outputs = PyObject_CallObject(forward_fn, ctx_tensor_input);
+  THPObjectPtr tensor_outputs(PyObject_CallObject(forward_fn, ctx_tensor_input));
   if (!tensor_outputs) return NULL;
 
   return process_outputs(ctx, unpacked_input, std::move(tensor_outputs), is_volatile);
@@ -800,14 +800,14 @@ PyObject * THPFunction_do_backward(THPFunction *self, PyObject *args)
     // Some of the output might have been unused, so we have to allocate
     // zero-filled buffers instead
     Py_INCREF(raw_grad_output);
-    THPObjectPtr grad_output = raw_grad_output;
+    THPObjectPtr grad_output(raw_grad_output);
     _prepare_grad_output(self, grad_output);
 
     // self.backward(*grad_output)
-    THPObjectPtr backward_fn = PyObject_GetAttrString((PyObject*)self, "backward");
+    THPObjectPtr backward_fn(PyObject_GetAttrString((PyObject*)self, "backward"));
     THPUtils_assert(backward_fn.get(), "function %s doesn't implement a required "
         "'backward' method", THPUtils_typename((PyObject*)self));
-    THPObjectPtr grad_input = PyObject_CallObject(backward_fn, grad_output.get());
+    THPObjectPtr grad_input(PyObject_CallObject(backward_fn, grad_output.get()));
     if (!grad_input) return NULL;
     _ensure_tuple(grad_input);
 
@@ -854,7 +854,7 @@ PyObject *THPFunction_saved_tensors(THPFunction *self, void *_unused)
     return PyTuple_New(0);
 
   int num_saved = self->saved_variables->size();
-  THPObjectPtr saved_tensors = PyTuple_New(num_saved);
+  THPObjectPtr saved_tensors(PyTuple_New(num_saved));
   if (!saved_tensors)
     return NULL;
   auto& saved_variables = *self->saved_variables;
@@ -879,7 +879,7 @@ PyObject *THPFunction_saved_variables(THPFunction *self, void *_unused)
     return PyTuple_New(0);
 
   int num_saved = self->saved_variables->size();
-  THPObjectPtr py_saved_variables = PyTuple_New(num_saved);
+  THPObjectPtr py_saved_variables(PyTuple_New(num_saved));
   if (!py_saved_variables) return NULL;
   auto& saved_variables = *self->saved_variables;
   for (int i = 0; i < num_saved; i++) {
@@ -901,11 +901,11 @@ PyObject *THPFunction_next_functions(THPFunction *self, void *_unused)
 {
   auto& next_fns = self->cdata.next_functions;
   int size = next_fns.size();
-  THPObjectPtr result = PyTuple_New(size);
+  THPObjectPtr result(PyTuple_New(size));
   if (!result)
     return NULL;
   for (int i = 0; i < size; i++) {
-    THPObjectPtr fn_tuple = PyTuple_New(2);
+    THPObjectPtr fn_tuple(PyTuple_New(2));
     if (!fn_tuple) return NULL;
     PyObject* fn = functionToPyObject(next_fns[i].first);
     if (!fn) return NULL;

torch/csrc/autograd/python_hook.cpp

@@ -13,7 +13,7 @@
 using thpp::Tensor;
 using torch::autograd::variable_list;
 
-static THPObjectPtr wrap_variables(const variable_list& c_variables);
+static PyObject* wrap_variables(const variable_list& c_variables);
 static variable_list unwrap_variables(PyObject* py_variables);
 static std::string hook_name(PyObject* hook);
 static void check_result(PyObject* original, PyObject* result, PyObject* hook);
@@ -38,13 +38,13 @@ auto PyFunctionPreHook::operator()(const variable_list& values) -> variable_list
 {
   AutoGIL gil;
 
-  THPObjectPtr value = THPVariable_Wrap(values.at(value_idx));
+  THPObjectPtr value(THPVariable_Wrap(values.at(value_idx)));
   if (!value) throw python_error();
 
   PyObject *key, *hook;
   Py_ssize_t pos = 0;
   while (PyDict_Next(dict, &pos, &key, &hook)) {
-    THPObjectPtr res = PyObject_CallFunctionObjArgs(hook, value.get(), nullptr);
+    THPObjectPtr res(PyObject_CallFunctionObjArgs(hook, value.get(), nullptr));
     if (!res) throw python_error();
     if (res == Py_None) continue;
     check_single_result(value.get(), res.get(), hook);
@@ -71,14 +71,14 @@ auto PyFunctionPostHook::operator()(
 {
   AutoGIL gil;
 
-  THPObjectPtr outputs = wrap_variables(_outputs);
-  THPObjectPtr inputs = wrap_variables(_inputs);
+  THPObjectPtr outputs(wrap_variables(_outputs));
+  THPObjectPtr inputs(wrap_variables(_inputs));
 
   PyObject *key, *hook;
   Py_ssize_t pos = 0;
   while (PyDict_Next(dict, &pos, &key, &hook)) {
-    THPObjectPtr res = PyObject_CallFunctionObjArgs(
-        hook, outputs.get(), inputs.get(), nullptr);
+    THPObjectPtr res(PyObject_CallFunctionObjArgs(
+        hook, outputs.get(), inputs.get(), nullptr));
     if (!res) throw python_error();
     if (res == Py_None) continue;
     check_result(outputs, res, hook);
@@ -91,17 +91,17 @@ auto PyFunctionPostHook::operator()(
 }} // namespace torch::autograd
 
 
-static THPObjectPtr wrap_variables(const variable_list& c_variables)
+static PyObject *wrap_variables(const variable_list& c_variables)
 {
   size_t num_vars = c_variables.size();
-  THPObjectPtr tuple = PyTuple_New(num_vars);
+  THPObjectPtr tuple(PyTuple_New(num_vars));
   if (!tuple) throw python_error();
   for (size_t i = 0; i < num_vars; ++i) {
-    THPObjectPtr var = THPVariable_Wrap(c_variables[i]);
+    THPObjectPtr var(THPVariable_Wrap(c_variables[i]));
     if (!var) throw python_error();
     PyTuple_SET_ITEM(tuple.get(), i, var.release());
   }
-  return tuple;
+  return tuple.release();
 }
 
 static variable_list unwrap_variables(PyObject* py_variables)  {
@@ -185,7 +185,7 @@ static void check_single_result(PyObject* _original, PyObject* _result, PyObject
 }
 
 static std::string hook_name(PyObject* hook) {
-  THPObjectPtr name = PyObject_GetAttrString(hook, "__name__");
+  THPObjectPtr name(PyObject_GetAttrString(hook, "__name__"));
   if (name && THPUtils_checkString(name.get())) {
     return THPUtils_unpackString(name.get());
   }