Add ergonomic accessors to TypeSystem

Reviewed By: sadroeck, pranavtbhat

Differential Revision: D79479781

fbshipit-source-id: 9f019b71b5875d73bd63ca712c1ecd659e2fb913

Author: praihan

third-party/thrift/src/thrift/lib/cpp2/dynamic/TypeSystem.h

@@ -200,7 +200,7 @@ class TypeSystem {
    * Resolves an arbitrary TypeId ito a TypeRef.
    *
    * Throws:
-   *   - InvalidTypeError if the TypeId references user-defined tyeps that are
+   *   - InvalidTypeError if the TypeId references user-defined types that are
    *     not defined in the type system.
    */
   TypeRef resolveTypeId(const TypeId& typeId) const;
@@ -218,6 +218,71 @@ class TypeSystem {
    * serializable.
    */
   virtual std::optional<folly::F14FastSet<Uri>> getKnownUris() const = 0;
+
+  /**
+   * Creates a TypeRef for the `bool` type — either true or false.
+   */
+  static TypeRef Bool() noexcept;
+  /**
+   * Creates a TypeRef for the `byte` type — 8-bit signed integer.
+   */
+  static TypeRef Byte() noexcept;
+  /**
+   * Creates a TypeRef for the `i16` type — 16-bit signed integer.
+   */
+  static TypeRef I16() noexcept;
+  /**
+   * Creates a TypeRef for the `i32` type — 32-bit signed integer.
+   */
+  static TypeRef I32() noexcept;
+  /**
+   * Creates a TypeRef for the `i64` type — 64-bit signed integer.
+   */
+  static TypeRef I64() noexcept;
+  /**
+   * Creates a TypeRef for the `float` type — IEEE 754 binary32.
+   */
+  static TypeRef Float() noexcept;
+  /**
+   * Creates a TypeRef for the `double` type — IEEE 754 binary64.
+   */
+  static TypeRef Double() noexcept;
+  /**
+   * Creates a TypeRef for the `string` type — UTF-8 encoded bytes.
+   */
+  static TypeRef String() noexcept;
+  /**
+   * Creates a TypeRef for the `binary` type — a sequence of bytes.
+   */
+  static TypeRef Binary() noexcept;
+  /**
+   * Creates a TypeRef for the `any` type — a type-erased Thrift value.
+   */
+  static TypeRef Any() noexcept;
+
+  /**
+   * Creates a TypeRef for a `list` type.
+   * The provided element type must from the same type system.
+   */
+  TypeRef ListOf(TypeRef elementType) const;
+  /**
+   * Creates a TypeRef for a `set` type.
+   * The provided element type must from the same type system.
+   */
+  TypeRef SetOf(TypeRef elementType) const;
+  /**
+   * Creates a TypeRef for a `list` type.
+   * The provided key and value types must from the same type system.
+   */
+  TypeRef MapOf(TypeRef keyType, TypeRef valueType) const;
+
+  /**
+   * Creates a TypeRef for a user-defined type.
+   *
+   * Throws:
+   *   - InvalidTypeError if the type is not defined in the type system.
+   */
+  TypeRef UserDefined(UriView) const;
 };
 
 /**
@@ -997,6 +1062,62 @@ template <typename K, typename V>
 
 } // namespace detail
 
+/* static */ inline TypeRef TypeSystem::Bool() noexcept {
+  return TypeRef(TypeRef::Bool());
+}
+
+/* static */ inline TypeRef TypeSystem::Byte() noexcept {
+  return TypeRef(TypeRef::Byte());
+}
+
+/* static */ inline TypeRef TypeSystem::I16() noexcept {
+  return TypeRef(TypeRef::I16());
+}
+
+/* static */ inline TypeRef TypeSystem::I32() noexcept {
+  return TypeRef(TypeRef::I32());
+}
+
+/* static */ inline TypeRef TypeSystem::I64() noexcept {
+  return TypeRef(TypeRef::I64());
+}
+
+/* static */ inline TypeRef TypeSystem::Float() noexcept {
+  return TypeRef(TypeRef::Float());
+}
+
+/* static */ inline TypeRef TypeSystem::Double() noexcept {
+  return TypeRef(TypeRef::Double());
+}
+
+/* static */ inline TypeRef TypeSystem::String() noexcept {
+  return TypeRef(TypeRef::String());
+}
+
+/* static */ inline TypeRef TypeSystem::Binary() noexcept {
+  return TypeRef(TypeRef::Binary());
+}
+
+/* static */ inline TypeRef TypeSystem::Any() noexcept {
+  return TypeRef(TypeRef::Any());
+}
+
+inline TypeRef TypeSystem::ListOf(TypeRef elementType) const {
+  return TypeRef(TypeRef::List::of(std::move(elementType)));
+}
+
+inline TypeRef TypeSystem::SetOf(TypeRef elementType) const {
+  return TypeRef(TypeRef::Set::of(std::move(elementType)));
+}
+
+inline TypeRef TypeSystem::MapOf(TypeRef keyType, TypeRef valueType) const {
+  return TypeRef(TypeRef::Map::of(std::move(keyType), std::move(valueType)));
+}
+
+inline TypeRef TypeSystem::UserDefined(UriView uri) const {
+  return TypeRef::fromDefinition(this->getUserDefinedTypeOrThrow(uri));
+}
+
 } // namespace apache::thrift::type_system
 
 namespace std {

third-party/thrift/src/thrift/lib/cpp2/dynamic/TypeSystemBuilder.cpp

@@ -135,14 +135,14 @@ class TypeSystemImpl final : public SourceIndexedTypeSystem {
               fmt::format("Definition for uri '{}' was not found", uri));
         },
         [&](const TypeId::List& list) -> TypeRef {
-          return TypeRef(TypeRef::List(typeOf(list.elementType())));
+          return TypeSystem::ListOf(typeOf(list.elementType()));
         },
         [&](const TypeId::Set& set) -> TypeRef {
-          return TypeRef(TypeRef::Set(typeOf(set.elementType())));
+          return TypeSystem::SetOf(typeOf(set.elementType()));
         },
         [&](const TypeId::Map& map) -> TypeRef {
-          return TypeRef(
-              TypeRef::Map(typeOf(map.keyType()), typeOf(map.valueType())));
+          return TypeSystem::MapOf(
+              typeOf(map.keyType()), typeOf(map.valueType()));
         },
         [](const auto& primitive) -> TypeRef { return TypeRef(primitive); });
   }

third-party/thrift/src/thrift/lib/cpp2/schema/SyntaxGraph.cpp

@@ -912,23 +912,23 @@ class TypeSystemFacade final : public type_system::TypeSystem {
         [](const Primitive& primitive) {
           switch (primitive) {
             case Primitive::BOOL:
-              return type_system::TypeRef{type_system::TypeRef::Bool{}};
+              return type_system::TypeSystem::Bool();
             case Primitive::BYTE:
-              return type_system::TypeRef{type_system::TypeRef::Byte{}};
+              return type_system::TypeSystem::Byte();
             case Primitive::I16:
-              return type_system::TypeRef{type_system::TypeRef::I16{}};
+              return type_system::TypeSystem::I16();
             case Primitive::I32:
-              return type_system::TypeRef{type_system::TypeRef::I32{}};
+              return type_system::TypeSystem::I32();
             case Primitive::I64:
-              return type_system::TypeRef{type_system::TypeRef::I64{}};
+              return type_system::TypeSystem::I64();
             case Primitive::FLOAT:
-              return type_system::TypeRef{type_system::TypeRef::Float{}};
+              return type_system::TypeSystem::Float();
             case Primitive::DOUBLE:
-              return type_system::TypeRef{type_system::TypeRef::Double{}};
+              return type_system::TypeSystem::Double();
             case Primitive::STRING:
-              return type_system::TypeRef{type_system::TypeRef::String{}};
+              return type_system::TypeSystem::String();
             case Primitive::BINARY:
-              return type_system::TypeRef{type_system::TypeRef::Binary{}};
+              return type_system::TypeSystem::Binary();
           }
         },
         [&](const StructNode& s) {
@@ -952,16 +952,14 @@ class TypeSystemFacade final : public type_system::TypeSystem {
               "Typedefs should have been resolved by trueType call");
         },
         [&](const List& l) {
-          return type_system::TypeRef{
-              type_system::TypeRef::List{convertType(l.elementType())}};
+          return type_system::TypeSystem::ListOf(convertType(l.elementType()));
         },
         [&](const Set& s) {
-          return type_system::TypeRef{
-              type_system::TypeRef::Set{convertType(s.elementType())}};
+          return type_system::TypeSystem::SetOf(convertType(s.elementType()));
         },
         [&](const Map& m) {
-          return type_system::TypeRef{type_system::TypeRef::Map{
-              convertType(m.keyType()), convertType(m.valueType())}};
+          return type_system::TypeSystem::MapOf(
+              convertType(m.keyType()), convertType(m.valueType()));
         });
   }