PaddlePaddle
diff --git a/‎paddle/fluid/framework/new_executor/interpreter/data_transfer.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/fluid/framework/new_executor/interpreter/data_transfer.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/pir/core/builtin_type.h
Copy file name to clipboard
+7-9Lines changed: 7 additions & 9 deletions b/‎paddle/pir/core/builtin_type.h
Copy file name to clipboard
+7-9Lines changed: 7 additions & 9 deletions
diff --git a/‎paddle/pir/core/builtin_type_interfaces.cc
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions b/‎paddle/pir/core/builtin_type_interfaces.cc
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions
diff --git a/‎paddle/pir/core/builtin_type_interfaces.h
Copy file name to clipboard
+61-44Lines changed: 61 additions & 44 deletions b/‎paddle/pir/core/builtin_type_interfaces.h
Copy file name to clipboard
+61-44Lines changed: 61 additions & 44 deletions
diff --git a/‎paddle/pir/core/cast_utils.h
Copy file name to clipboard
+12-1Lines changed: 12 additions & 1 deletion b/‎paddle/pir/core/cast_utils.h
Copy file name to clipboard
+12-1Lines changed: 12 additions & 1 deletion
diff --git a/‎paddle/pir/core/interface_support.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/pir/core/interface_support.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/pir/core/interface_value.h
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/pir/core/interface_value.h
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎paddle/pir/core/op_base.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/pir/core/op_base.h
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/pir/core/op_info_impl.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎paddle/pir/core/op_info_impl.cc
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
@@ -187,7 +187,7 @@ void DataTranferHelper::RunAndConstructOpFuncNode(
   } else if (platform::is_gpu_place(place)) {
     // MemcpyD2H in gpu is synchronous, see
     // https://docs.nvidia.com/cuda/cuda-runtime-api/api-sync-behavior.html#api-sync-behavior__memcpy-async
-    // for more detial.
+    // for more detail.
     new_op_func_node.type_ =
         (op_type == kMemcpyD2H ? OpFuncType::kGpuSync : OpFuncType::kGpuAsync);
   } else if (platform::is_xpu_place(place)) {
 
@@ -39,7 +39,7 @@ namespace pir {
 // in IrContextImpl because it is not widely used.
 
 class IR_API VectorType
-    : public pir::Type::TypeBase<VectorType, pir::Type, VectorTypeStorage> {
+    : public Type::TypeBase<VectorType, Type, VectorTypeStorage> {
  public:
   using Base::Base;
 
@@ -52,14 +52,14 @@ class IR_API VectorType
   Type operator[](size_t index) const { return data()[index]; }
 };
 
-class DenseTensorType : public pir::Type::TypeBase<DenseTensorType,
-                                                   pir::Type,
-                                                   DenseTensorTypeStorage,
-                                                   pir::ShapedTypeInterface> {
+class DenseTensorType : public Type::TypeBase<DenseTensorType,
+                                              Type,
+                                              DenseTensorTypeStorage,
+                                              ShapedTypeInterface> {
  public:
   using Base::Base;
 
-  const pir::Type &dtype() const;
+  const Type &dtype() const;
 
   const DenseTensorTypeStorage::Dim &dims() const;
 
@@ -71,9 +71,7 @@ class DenseTensorType : public pir::Type::TypeBase<DenseTensorType,
 };
 
 #define DECLARE_BUILTIN_TYPE(__name)                                       \
-  class IR_API __name : public ::pir::Type::TypeBase<__name,               \
-                                                     ::pir::Type,          \
-                                                     ::pir::TypeStorage> { \
+  class IR_API __name : public Type::TypeBase<__name, Type, TypeStorage> { \
    public:                                                                 \
     using Base::Base;                                                      \
     static __name get(IrContext *context);                                 \
 
@@ -15,4 +15,15 @@
 #include "paddle/pir/core/builtin_type_interfaces.h"
 #include "paddle/pir/core/type_id.h"
 
+namespace pir {
+
+Type ShapedTypeInterface::getElementType() const {
+  return impl_->get_element_type_(*this);
+}
+
+phi::DDim ShapedTypeInterface::getShape() const {
+  return impl_->get_shape_(*this);
+}
+
+}  // namespace pir
 IR_DEFINE_EXPLICIT_TYPE_ID(pir::ShapedTypeInterface)
@@ -20,7 +20,9 @@
 #include "paddle/pir/core/enforce.h"
 #include "paddle/pir/core/type.h"
 
-namespace details {
+namespace pir {
+
+namespace detail {
 
 template <typename RangeT>
 constexpr auto begin_impl(RangeT &&range)
@@ -34,117 +36,132 @@ constexpr auto end_impl(RangeT &&range)
   return std::end(std::forward<RangeT>(range));
 }
 
-/// Returns the begin iterator to \p range using `std::begin` and
-/// function found through Argument-Dependent Lookup (ADL).
 template <typename RangeT>
 constexpr auto adl_begin(RangeT &&range)
     -> decltype(begin_impl(std::forward<RangeT>(range))) {
   return begin_impl(std::forward<RangeT>(range));
 }
 
-/// Returns the end iterator to \p range using `std::end` and
-/// functions found through Argument-Dependent Lookup (ADL).
 template <typename RangeT>
 constexpr auto adl_end(RangeT &&range)
     -> decltype(end_impl(std::forward<RangeT>(range))) {
   return end_impl(std::forward<RangeT>(range));
 }
 
-/// Provide wrappers to std::any_of which take ranges instead of having to pass
-/// begin/end explicitly.
 template <typename R, typename UnaryPredicate>
 bool any_of(R &&Range, UnaryPredicate P) {
   return std::any_of(adl_begin(Range), adl_end(Range), P);
 }
 
-/// Wrapper function around std::count_if to count the number of times an
-/// element satisfying a given predicate occurs in a range.
 template <typename R, typename UnaryPredicate>
 auto count_if(R &&Range, UnaryPredicate P) {
   return std::count_if(adl_begin(Range), adl_end(Range), P);
 }
 
-}  // namespace details
-namespace pir {
-class ShapedTypeInterface : public pir::TypeInterfaceBase<ShapedTypeInterface> {
+}  // namespace detail
+
+class ShapedTypeInterface : public TypeInterfaceBase<ShapedTypeInterface> {
  public:
   using DDim = phi::DDim;
-  using DataType = pir::Type;
+  using DataType = Type;
   struct Concept {
     /// Defined these methods with the interface.
-    explicit Concept(DataType (*get_element_type)(pir::Type),
-                     DDim (*get_shape)(pir::Type))
+    explicit Concept(DataType (*get_element_type)(Type),
+                     DDim (*get_shape)(Type))
         : get_element_type_(get_element_type), get_shape_(get_shape) {}
 
-    DataType (*get_element_type_)(pir::Type);
-    DDim (*get_shape_)(pir::Type);
+    DataType (*get_element_type_)(Type);
+    DDim (*get_shape_)(Type);
   };
 
   template <class ConcreteType>
   struct Model : public Concept {
-    static inline DataType getElementType(pir::Type type) {
+    static inline DataType getElementType(Type type) {
       return pir::cast<ConcreteType>(type).dtype();
     }
 
-    static inline DDim getShape(pir::Type type) {
+    static inline DDim getShape(Type type) {
       return pir::cast<ConcreteType>(type).dims();
     }
 
     Model() : Concept(getElementType, getShape) {}
   };
 
   /// Constructor
-  ShapedTypeInterface(pir::Type type, Concept *impl)
-      : pir::TypeInterfaceBase<ShapedTypeInterface>(type), impl_(impl) {}
-
-  /// Get the element type.
-  DataType getElementType() const { return impl_->get_element_type_(*this); }
-
-  /// Get the shape of this type.
-  DDim getShape() const { return impl_->get_shape_(*this); }
-
+  ShapedTypeInterface(Type type, Concept *impl)
+      : TypeInterfaceBase<ShapedTypeInterface>(type), impl_(impl) {}
+
+  ///
+  /// \brief Get the element type.
+  ///
+  DataType getElementType() const;
+
+  ///
+  /// \brief Get the shape of this type.
+  ///
+  DDim getShape() const;
+
+  ///
+  /// \brief kDynamic
+  ///
   static constexpr int64_t kDynamic = std::numeric_limits<int64_t>::min();
 
-  /// Check whether this type is ranked, currently return true.
+  ///
+  /// \brief Check whether this type is ranked, currently return true.
+  ///
   bool hasRank() const { return true; }
 
+  ///
   /// If this is a ranked type, return the rank. Otherwise, abort.
+  ///
   int64_t getRank() const {
     IR_ENFORCE((*this).hasRank(), "Cannot query rank of unranked shaped type.");
     return (*this).getShape().size();
   }
 
-  /// Check whether the given dimension size is a dynamic dimension.
+  ///
+  /// \brief Check whether the given dimension size is a dynamic dimension.
+  ///
   static constexpr bool isDynamic(int64_t dValue) { return dValue == kDynamic; }
 
-  /// Check whether the given shape has any size indicating a dynamic dimension.
+  ///
+  /// \brief Check whether the given shape has any size indicating a dynamic
+  /// dimension.
+  ///
   static bool isDynamicShape(DDim dSizes) {
-    return ::details::any_of(vectorize(dSizes),
-                             [](int64_t dSize) { return isDynamic(dSize); });
+    return detail::any_of(vectorize(dSizes),
+                          [](int64_t dSize) { return isDynamic(dSize); });
   }
 
-  /// Check whether shape has any size indicating a dynamic dimension.
+  ///
+  /// \brief Check whether shape has any size indicating a dynamic dimension.
+  ///
   bool hasStaticShape() const {
-    return (*this).hasRank() &&
-           !pir::ShapedTypeInterface::isDynamicShape((*this).getShape());
+    return (*this).hasRank() && !isDynamicShape((*this).getShape());
   }
 
-  /// Check whether the given dimension has a dynamic size.
-  /// Aborts for unranked types.
+  ///
+  /// \brief Check whether the given dimension has a dynamic size.Aborts for
+  /// unranked types.
+  ///
   bool isDynamicDim(unsigned idx) const {
     IR_ENFORCE(idx < getRank(), "Invalid index for shaped type.");
-    return pir::ShapedTypeInterface::isDynamic((*this).getShape()[idx]);
+    return ShapedTypeInterface::isDynamic((*this).getShape()[idx]);
   }
 
-  /// Get the number of dimensions with dynamic size for a ranked type.
+  ///
+  /// \brief Get the number of dimensions with dynamic size for a ranked type.
   /// Aborts for unranked types.
+  ///
   int64_t getNumDynamicDims() const {
-    return ::details::count_if(vectorize((*this).getShape()),
-                               pir::ShapedTypeInterface::isDynamic);
+    return detail::count_if(vectorize((*this).getShape()),
+                            ShapedTypeInterface::isDynamic);
   }
 
-  /// Get the size of the specified dimension for a ranked type.
-  /// Aborts for unranked types.
+  ///
+  /// \brief Get the size of the specified dimension for a ranked type. Aborts
+  /// for unranked types.
+  ///
   int64_t getDimSize(unsigned idx) const {
     IR_ENFORCE(idx < getRank(), "Invalid index for shaped type.");
     return (*this).getShape()[idx];
 
@@ -113,7 +113,7 @@ struct ReturnTypeDuduction {
 };
 
 ///
-/// cast From to To
+/// \brief cast From to To
 ///
 template <typename To, typename From, typename Enable = void>
 struct cast_impl {
@@ -160,6 +160,11 @@ inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
 ///
 /// \brief dyn_cast From to To.
 ///
+template <typename To, typename From>
+inline decltype(auto) dyn_cast(const From &Val) {
+  return isa<To>(Val) ? cast<To>(Val) : nullptr;
+}
+
 template <typename To, typename From>
 inline decltype(auto) dyn_cast(From &Val) {  // NOLINT
   return isa<To>(Val) ? cast<To>(Val) : nullptr;
@@ -170,4 +175,10 @@ inline decltype(auto) dyn_cast(From *Val) {
   return isa<To>(Val) ? cast<To>(Val) : nullptr;
 }
 
+template <typename To, typename From>
+inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
+  return isa<To>(Val) ? cast<To>(std::forward<std::unique_ptr<From> &&>(Val))
+                      : nullptr;
+}
+
 }  // namespace pir
@@ -18,7 +18,7 @@
 #include "paddle/pir/core/interface_value.h"
 
 namespace pir {
-namespace details {
+namespace detail {
 template <typename ConcreteT, typename... Args>
 class ConstructInterfacesOrTraits {
  public:
@@ -117,6 +117,6 @@ std::vector<TypeId> GetTraitSet() {
   return trait_set;
 }
 
-}  // namespace details
+}  // namespace detail
 
 }  // namespace pir
@@ -19,7 +19,7 @@
 namespace pir {
 
 namespace details {
-class IR_API InterfaceValue {
+class InterfaceValue {
  public:
   template <typename ConcreteT, typename T>
   static InterfaceValue get() {
 
@@ -126,11 +126,11 @@ class Op : public OpBase {
   }
 
   static std::vector<details::InterfaceValue> GetInterfaceMap() {
-    return pir::details::GetInterfaceMap<ConcreteOp, InterfaceList>();
+    return pir::detail::GetInterfaceMap<ConcreteOp, InterfaceList>();
   }
 
   static std::vector<TypeId> GetTraitSet() {
-    return pir::details::GetTraitSet<ConcreteOp, TraitList>();
+    return pir::detail::GetTraitSet<ConcreteOp, TraitList>();
   }
 
   // Checking that the derived class does not define any member by comparing
 
@@ -100,7 +100,7 @@ bool OpInfoImpl::HasInterface(TypeId interface_id) const {
 }
 
 void *OpInfoImpl::GetInterfaceImpl(TypeId interface_id) const {
-  return pir::details::LookUp<OpInfoImpl>(
+  return pir::detail::LookUp<OpInfoImpl>(
       interface_id, num_interfaces_, num_traits_, this);
 }
Original file line number	Diff line number	Diff line change
`@@ -126,11 +126,11 @@ class Op : public OpBase {`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`static std::vector<details::InterfaceValue> GetInterfaceMap() {`
`129`		`- return pir::details::GetInterfaceMap<ConcreteOp, InterfaceList>();`
	`129`	`+ return pir::detail::GetInterfaceMap<ConcreteOp, InterfaceList>();`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`static std::vector<TypeId> GetTraitSet() {`
`133`		`- return pir::details::GetTraitSet<ConcreteOp, TraitList>();`
	`133`	`+ return pir::detail::GetTraitSet<ConcreteOp, TraitList>();`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`// Checking that the derived class does not define any member by comparing`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ bool OpInfoImpl::HasInterface(TypeId interface_id) const {`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`void *OpInfoImpl::GetInterfaceImpl(TypeId interface_id) const {`
`103`		`- return pir::details::LookUp<OpInfoImpl>(`
	`103`	`+ return pir::detail::LookUp<OpInfoImpl>(`
`104`	`104`	`interface_id, num_interfaces_, num_traits_, this);`
`105`	`105`	`}`
`106`	`106`