[Compat] Add more constructors for compatible at::Tensor

paddle/fluid/pybind/torch_compat.h

@@ -138,7 +138,7 @@ inline torch::IValue OperationInvoker::to_ivalue(py::handle obj) {
   } else if (py::isinstance<py::bool_>(obj)) {
     return torch::IValue(py::cast<bool>(obj));
   } else if (py::isinstance<py::int_>(obj)) {
-    return torch::IValue(py::cast<int>(obj));
+    return torch::IValue(py::cast<int64_t>(obj));
   } else if (py::isinstance<py::float_>(obj)) {
     return torch::IValue(py::cast<double>(obj));
   } else if (py::isinstance<py::str>(obj)) {

paddle/phi/api/include/compat/ATen/ATen.h

@@ -17,6 +17,7 @@
 #include <ATen/Device.h>
 #include <ATen/Functions.h>
 #include <ATen/Tensor.h>
+#include <ATen/Utils.h>
 #include <c10/core/Device.h>
 #include <c10/core/DeviceType.h>
 #include <c10/core/MemoryFormat.h>

paddle/phi/api/include/compat/ATen/Utils.h

@@ -14,7 +14,6 @@
 
 #pragma once
 
-#include <ATen/EmptyTensor.h>
 #include <c10/core/ScalarType.h>
 #include <c10/util/ArrayRef.h>
 #include <c10/util/Exception.h>

paddle/phi/api/include/compat/ATen/core/TensorBase.h

@@ -34,6 +34,26 @@ class PADDLE_API TensorBase {
  public:
   TensorBase() = default;
   TensorBase(const PaddleTensor& tensor) : tensor_(tensor){};  // NOLINT
+  TensorBase(const TensorBase&) = default;
+  TensorBase(TensorBase&&) noexcept = default;
+  ~TensorBase() noexcept = default;
+
+#if defined(_MSC_VER)
+  TensorBase& operator=(const TensorBase& x) & {
+    tensor_ = x.tensor_;
+    return *this;
+  }
+  TensorBase& operator=(TensorBase&& x) & noexcept {
+    tensor_ = std::move(x.tensor_);
+    return *this;
+  }
+#else
+  TensorBase& operator=(const TensorBase& x) & = default;
+  TensorBase& operator=(TensorBase&& x) & noexcept = default;
+#endif
+
+  TensorBase& operator=(const TensorBase&) && = delete;
+  TensorBase& operator=(TensorBase&&) && noexcept = delete;
 
   void* data_ptr() const { return const_cast<void*>(tensor_.data()); }
   template <typename T>
@@ -211,8 +231,9 @@ class PADDLE_API TensorBase {
   template <typename T, size_t N>
   TensorAccessor<T, N> accessor() && = delete;
 
-  PaddleTensor _PD_GetInner() const { return tensor_; }
-  PaddleTensor& _PD_GetInner() { return tensor_; }
+  const PaddleTensor& _PD_GetInner() const& { return tensor_; }
+  PaddleTensor& _PD_GetInner() & { return tensor_; }
+  PaddleTensor&& _PD_GetInner() && { return std::move(tensor_); }
 
  protected:
   PaddleTensor tensor_;

paddle/phi/api/include/compat/ATen/core/TensorBody.h

@@ -24,25 +24,42 @@ class Tensor : public TensorBase {
  public:
   Tensor() = default;
   Tensor(const PaddleTensor& tensor) : TensorBase(tensor){};  // NOLINT
+  Tensor(const Tensor& tensor) = default;
+  Tensor(Tensor&& tensor) = default;
 
   // Implicitly move-constructible from TensorBase, but must be explicit to
   // increase refcount
   explicit Tensor(const TensorBase& base) : TensorBase(base) {}  // NOLINT
   /*implicit*/ Tensor(TensorBase&& base)                         // NOLINT
       : TensorBase(std::move(base)) {}
 
-  // TODO(dev): Implement assignment operators
-  // Tensor& operator=(const Tensor& x) & noexcept {
-  //   return operator=(static_cast<const TensorBase&>(x));
-  // }
-  // Tensor& operator=(Tensor&& x) & noexcept {
-  //   return operator=(static_cast<TensorBase&&>(x));
-  // }
+  Tensor& operator=(const PaddleTensor& x) & noexcept {
+    tensor_ = x;
+    return *this;
+  }
+  Tensor& operator=(const TensorBase& x) & noexcept {
+    const PaddleTensor& inner = x._PD_GetInner();
+    tensor_ = inner;
+    return *this;
+  }
+  Tensor& operator=(PaddleTensor&& x) & noexcept {
+    tensor_ = std::move(x);
+    return *this;
+  }
+  Tensor& operator=(TensorBase&& x) & noexcept {
+    tensor_ = std::move(x)._PD_GetInner();
+    return *this;
+  }
 
+  Tensor& operator=(const Tensor& x) & noexcept {
+    return operator=(static_cast<const TensorBase&>(x));
+  }
+  Tensor& operator=(Tensor&& x) & noexcept {
+    return operator=(static_cast<TensorBase&&>(x));
+  }
   Tensor& operator=(const Scalar& v) && { return fill_(v); }
-  // TODO(dev): Implement assignment operators
-  // Tensor& operator=(const Tensor& rhs) && { return copy_(rhs); }
-  // Tensor& operator=(Tensor&& rhs) && { return copy_(rhs); }
+  Tensor& operator=(const Tensor& rhs) && { return copy_(rhs); }
+  Tensor& operator=(Tensor&& rhs) && { return copy_(rhs); }
 
   void* data_ptr() const { return const_cast<void*>(tensor_.data()); }
   template <typename T>

paddle/phi/api/include/compat/ATen/core/TensorMethods.cpp

@@ -48,7 +48,7 @@ void check_type(const TensorBase& tensor,
   template <>                                                       \
   PADDLE_API T* TensorBase::mutable_data_ptr() const {              \
     check_type(*this, ScalarType::name, #name);                     \
-    return const_cast<PaddleTensor&>(tensor_).mutable_data<T>();    \
+    return const_cast<PaddleTensor&>(tensor_).data<T>();            \
   }                                                                 \
                                                                     \
   template <>                                                       \