【Hackathon 10th Spring No.2】Add schema parser and related functionality for Torch compatibility

paddle/fluid/pybind/torch_compat.h

@@ -206,12 +206,11 @@ inline FunctionArgs OperationInvoker::convert_args_kwargs_to_function_args(
     function_args.add_arg(std::move(value));
   }
 
-  for (auto item : kwargs) {
-    py::str key = item.first.cast<py::str>();
-    py::object value_obj = item.second.cast<py::object>();
-
-    torch::IValue value = to_ivalue(value_obj);
-    function_args.add_arg(std::move(value));
+  for (const auto& item : kwargs) {
+    std::string key = py::cast<std::string>(item.first);
+    torch::arg keyword(std::move(key));
+    keyword = to_ivalue(item.second);
+    function_args.add_arg(std::move(keyword));
   }
 
   return function_args;
@@ -248,12 +247,18 @@ class CustomClassProxyInstance {
     if (ClassRegistry::instance().has_method(qualified_name_, method_name)) {
       return py::cpp_function(
           [this, method_name](py::args args, py::kwargs kwargs) -> py::object {
+            FunctionArgs converted =
+                OperationInvoker::convert_args_kwargs_to_function_args(args,
+                                                                       kwargs);
             FunctionArgs function_args;
             function_args.add_arg(instance_);  // this pointer
-            for (auto arg :
-                 OperationInvoker::convert_args_kwargs_to_function_args(
-                     args, kwargs)) {
-              function_args.add_arg(std::move(arg));
+            for (size_t i = 0; i < converted.size(); ++i) {
+              function_args.add_arg(converted.get_value(i));
+            }
+            for (const auto& [name, value] : converted.named_args()) {
+              torch::arg keyword(name);
+              keyword = value;
+              function_args.add_arg(std::move(keyword));
             }
 
             auto result = ClassRegistry::instance().call_method_with_args(

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

@@ -0,0 +1,156 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The file has been adapted from pytorch project
+// Licensed under BSD-style license -
+// https://github.com/pytorch/pytorch/blob/main/LICENSE
+
+#pragma once
+
+#include <ostream>
+#include <set>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace c10 {
+/**
+ * class AliasInfo
+ *
+ * Data structure to hold aliasing information for an `Argument`. They can be
+ * nested to represent aliasing information on contained types.
+ *
+ * There is a `beforeSet` which describes the aliasing information before the
+ * operator executes, and an `afterSet` that describes aliasing info
+ * after execution.
+ */
+class AliasInfo {
+ public:
+  AliasInfo() = default;
+  AliasInfo(bool is_write,
+            const std::set<std::string>& before_qual_strings,
+            const std::set<std::string>& after_qual_strings)
+      : isWrite_(is_write) {
+    for (const auto& s : before_qual_strings) {
+      beforeSets_.insert(s);
+    }
+    for (const auto& s : after_qual_strings) {
+      afterSets_.insert(s);
+    }
+  }
+
+  bool isWrite() const { return isWrite_; }
+
+  const std::unordered_set<std::string>& beforeSets() const {
+    return beforeSets_;
+  }
+
+  const std::unordered_set<std::string>& afterSets() const {
+    return afterSets_;
+  }
+
+  // the alias info for the contained types of the type
+  // e.g. if this is an annotation on List[T], `sets` refers to
+  // the alias sets that the list may be in
+  // while containedTypes()[0] refers to the sets that members of the list
+  // may be in
+  void addContainedType(AliasInfo aliasInfo) {
+    containedTypes_.push_back(std::move(aliasInfo));
+  }
+  const std::vector<AliasInfo>& containedTypes() const {
+    return containedTypes_;
+  }
+
+ private:
+  std::unordered_set<std::string> beforeSets_;
+  std::unordered_set<std::string> afterSets_;
+  std::vector<AliasInfo> containedTypes_;
+  bool isWrite_ = false;
+};
+
+inline bool operator==(const AliasInfo& lhs, const AliasInfo& rhs) {
+  return lhs.isWrite() == rhs.isWrite() &&
+         lhs.beforeSets() == rhs.beforeSets() &&
+         lhs.afterSets() == rhs.afterSets() &&
+         lhs.containedTypes() == rhs.containedTypes();
+}
+
+// this does match the way things are represented in the schema
+inline std::ostream& operator<<(std::ostream& out, const AliasInfo& aliasInfo) {
+  out << '(';
+  bool first = true;
+  for (const auto& set : aliasInfo.beforeSets()) {
+    if (first) {
+      first = false;
+    } else {
+      out << '|';
+    }
+    out << set;
+  }
+  if (aliasInfo.isWrite()) {
+    out << '!';
+  }
+  if (aliasInfo.beforeSets() != aliasInfo.afterSets()) {
+    out << " -> ";
+    first = true;
+    for (const auto& set : aliasInfo.afterSets()) {
+      if (first) {
+        first = false;
+      } else {
+        out << '|';
+      }
+      out << set;
+    }
+  }
+  out << ')';
+  return out;
+}
+}  // namespace c10
+
+inline std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
+  lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
+  return lhs;
+}
+
+namespace std {
+template <>
+struct hash<c10::AliasInfo> {
+  size_t operator()(const c10::AliasInfo& aliasInfo) const {
+    auto hash = std::hash<bool>()(aliasInfo.isWrite());
+
+    // NOTE: for unordered_set hashes, we couldn't use hash_combine
+    // because hash_combine is order dependent. Instead, we choose to
+    // use XOR as the combining function as XOR is commutative.
+    size_t before_set_hash_seed = 0;
+    for (auto& e : aliasInfo.beforeSets()) {
+      auto symbol_hash = std::hash<std::string>()(e);
+      before_set_hash_seed = before_set_hash_seed ^ symbol_hash;
+    }
+    size_t after_set_hash_seed = 0;
+    for (auto& e : aliasInfo.afterSets()) {
+      auto symbol_hash = std::hash<std::string>()(e);
+      after_set_hash_seed = after_set_hash_seed ^ symbol_hash;
+    }
+
+    hash = hash_combine(hash, before_set_hash_seed);
+    hash = hash_combine(hash, after_set_hash_seed);
+    for (auto& e : aliasInfo.containedTypes()) {
+      auto contained_type_hash = std::hash<c10::AliasInfo>()(e);
+      hash = hash_combine(hash, contained_type_hash);
+    }
+    return hash;
+  }
+};
+}  // namespace std

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

@@ -0,0 +1,201 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The file has been adapted from pytorch project
+// Licensed under BSD-style license -
+// https://github.com/pytorch/pytorch/blob/main/LICENSE
+
+#include "ATen/core/function_schema.h"
+
+namespace c10 {
+
+namespace {
+
+constexpr char kWildcardAliasSet[] = "*";
+
+const char* schemaArgTypeName(SchemaArgType type) {
+  if (type == SchemaArgType::input) {
+    return "input";
+  }
+  if (type == SchemaArgType::output) {
+    return "output";
+  }
+  return "unknown";
+}
+
+bool aliasSetsMayOverlap(const std::unordered_set<std::string>& lhs,
+                         const std::unordered_set<std::string>& rhs) {
+  if (lhs.empty() || rhs.empty()) {
+    return false;
+  }
+  if (lhs.count(kWildcardAliasSet) > 0 || rhs.count(kWildcardAliasSet) > 0) {
+    return true;
+  }
+  for (const auto& set : lhs) {
+    if (rhs.count(set) > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const Argument& getSchemaArgumentOrThrow(const FunctionSchema& schema,
+                                         const SchemaArgument& argument) {
+  const auto& args = schema.getCorrectList(argument);
+  TORCH_CHECK(argument.index < args.size(),
+              "Schema ",
+              schemaArgTypeName(argument.type),
+              " index ",
+              argument.index,
+              " is out of bounds for size ",
+              args.size());
+  return args.at(argument.index);
+}
+
+bool aliasInfoMayContainAlias(const AliasInfo& lhs,
+                              const AliasInfo& rhs,
+                              bool bidirectional) {
+  if (aliasSetsMayOverlap(lhs.afterSets(), rhs.afterSets())) {
+    return true;
+  }
+
+  for (const auto& child : lhs.containedTypes()) {
+    if (aliasInfoMayContainAlias(child, rhs, /*bidirectional=*/true)) {
+      return true;
+    }
+  }
+
+  if (!bidirectional) {
+    return false;
+  }
+  for (const auto& child : rhs.containedTypes()) {
+    if (aliasInfoMayContainAlias(lhs, child, /*bidirectional=*/true)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+std::ostream& operator<<(std::ostream& out, const Argument& arg) {
+  out << arg.type()->str() << " " << arg.name();
+  if (arg.default_value()) {
+    out << " = " << arg.default_value();
+  }
+  return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const FunctionSchema& schema) {
+  out << "(";
+  bool first = true;
+  for (const auto& arg : schema.arguments()) {
+    if (!first) {
+      out << ", ";
+    }
+    out << arg;
+    first = false;
+  }
+  if (schema.is_vararg()) {
+    if (!first) {
+      out << ", ";
+    }
+    out << "...";
+  }
+  out << ")";
+
+  out << " -> ";
+
+  if (schema.returns().size() == 1) {
+    out << schema.returns()[0];
+  } else {
+    out << "(";
+    first = true;
+    for (const auto& ret : schema.returns()) {
+      if (!first) {
+        out << ", ";
+      }
+      out << ret;
+      first = false;
+    }
+    out << ")";
+  }
+
+  return out;
+}
+
+std::optional<int> FunctionSchema::argumentIndexWithName(
+    const std::string& name) const {
+  for (size_t i = 0; i < arguments_.size(); ++i) {
+    if (arguments_[i].name() == name) {
+      return static_cast<int>(i);
+    }
+  }
+  return std::nullopt;
+}
+
+const std::vector<Argument>& FunctionSchema::getCorrectList(
+    const SchemaArgument& argument) const {
+  if (argument.type == SchemaArgType::input) {
+    return arguments();
+  }
+  if (argument.type == SchemaArgType::output) {
+    return returns();
+  }
+  TORCH_INTERNAL_ASSERT(false, "Could not match argument type");
+}
+
+bool FunctionSchema::is_aliasing(const SchemaArgument& argument) const {
+  const auto& arg = getSchemaArgumentOrThrow(*this, argument);
+  return arg.alias_info() != nullptr;
+}
+
+bool FunctionSchema::is_mutable(const SchemaArgument& argument) const {
+  const auto& arg = getSchemaArgumentOrThrow(*this, argument);
+  return arg.alias_info() != nullptr && arg.alias_info()->isWrite();
+}
+
+bool FunctionSchema::is_mutable(const std::string& name) const {
+  const auto index = argumentIndexWithName(name);
+  TORCH_CHECK(
+      index.has_value(), "Tried to test mutability of nonexistent name ", name);
+  return is_mutable({SchemaArgType::input, static_cast<size_t>(*index)});
+}
+
+bool FunctionSchema::may_alias(const SchemaArgument& lhs,
+                               const SchemaArgument& rhs) const {
+  const auto& lhs_arg = getSchemaArgumentOrThrow(*this, lhs);
+  const auto& rhs_arg = getSchemaArgumentOrThrow(*this, rhs);
+  const auto* lhs_alias = lhs_arg.alias_info();
+  const auto* rhs_alias = rhs_arg.alias_info();
+  if (lhs_alias == nullptr || rhs_alias == nullptr) {
+    return false;
+  }
+  return aliasSetsMayOverlap(lhs_alias->afterSets(), rhs_alias->afterSets());
+}
+
+bool FunctionSchema::may_contain_alias(const SchemaArgument& lhs,
+                                       const SchemaArgument& rhs,
+                                       bool bidirectional) const {
+  const auto& lhs_arg = getSchemaArgumentOrThrow(*this, lhs);
+  const auto& rhs_arg = getSchemaArgumentOrThrow(*this, rhs);
+  const auto* lhs_alias = lhs_arg.alias_info();
+  const auto* rhs_alias = rhs_arg.alias_info();
+  if (lhs_alias == nullptr || rhs_alias == nullptr) {
+    return false;
+  }
+  return aliasInfoMayContainAlias(*lhs_alias, *rhs_alias, bidirectional);
+}
+
+}  // namespace c10