Sam De Roeck

This commit **adds new test fixtures** to support **cross-language validation of `TypeSystemDigest`** within the **Thrift dynamic type system**. It introduces several `.thrift` files, such as `digest_fixture_enum.thrift` and `digest_fixture_struct_with_fields.thrift`, defining various schemas (enums, structs, empty structs) and a `digest_expected_values.thrift` file containing pre-calculated "golden" digest values. These fixtures will be embedded in each target language to compute their respective `TypeSystemDigest` values, which must then match the "golden" values, the runtime representation, and the serialized representation. This **test infrastructure enhancement** is crucial for ensuring **consistent type system representation** and interoperability across different Thrift language implementations.

This commit **introduces new C++ tests** for the **`TypeSystemDigest`** functionality within the **`thrift/lib/cpp2/dynamic`** library. These tests are designed to **validate the correctness** of `SyntaxGraph` and `TypeRef` digests. They achieve this by loading cross-language schema fixtures as embedded resources and verifying that the computed digests match both their serializable representations and pre-established "golden" values. This work enhances the **quality assurance** and reliability of Thrift's type system digest mechanism, ensuring robust schema compatibility across different language bindings.

This commit **fixes a digest mismatch** in the **Thrift TypeSystem** by preventing compiler-consumed annotations, such as `thrift.Uri` and `scope.*`, from being included as runtime annotations during the conversion from `SyntaxGraph`. These annotations are already structurally projected into the type model, making their runtime annotation representation redundant. By filtering them out in `SyntaxGraph.cpp`'s `toTypeSystemAnnotations` function, the **runtime TypeSystem is now aligned with its serializable representation**. This **bug fix** unblocks `TypeSystemDigest` and ensures consistent hashing paths for `TypeRef` and `SerializableTypeDefinition`.

This commit introduces the **`type_system_digest` crate** to provide a **new capability** for generating canonical, deterministic SHA-256 digests within the **Thrift Rust dynamic type system**. It defines the `TypeSystemDigest` trait and implements it for key types such as `TypeSystem`, `SerializableTypeSystem`, and `SerializableRecord` (including annotations and field constants), utilizing a new streaming SHA-256 hasher. This ensures **order-independent and language/platform-independent hashing** for type definitions, aligning with the C++ implementation. The `TypeSystem` trait is updated to require this new digest functionality, enabling consistent and verifiable type system identification across different language bindings.

This commit introduces **round-trip conversion** capabilities between `SerializableTypeSystem` and `TypeSystem` instances within the **`thrift/lib/rust/dynamic/type_system`** module. A new `builder.rs` module provides the core logic for converting from `SerializableTypeSystem` to `IndexedTypeSystem` via `TryFrom` and for serializing `IndexedTypeSystem` back into a `SerializableTypeSystem` using `to_serializable`. This **new capability** enables the serialization and deserialization of type system definitions, facilitating their persistent storage or transmission. The `TypeSystem` trait now includes a default `to_serializable` implementation, which specific implementations can override for custom serialization.

This commit **introduces the foundational data model for the new Rust `TypeSystem` library**, establishing immutable node representations for all Thrift types within the `thrift/lib/rust/dynamic/type_system` module. As a **new feature**, it defines core Rust structs and methods for **Thrift primitive, container, and user-defined types** such as lists, maps, structs, unions, enums, and opaque aliases. Key enums like `TypeRef` and `DefinitionRef` are implemented for type identification, casting, and conversion, alongside an `InvalidTypeError` for robust error handling. This work provides the essential building blocks for dynamic Thrift type introspection and manipulation in Rust, mirroring an existing C++ implementation.

This commit **introduces foundational elements** for the **Rust Thrift dynamic type system**, mirroring existing C++ counterparts. It defines the core `TypeSystem` trait, enabling URI-based lookup and type resolution, and provides the `IndexedTypeSystem` implementation for in-memory type graph management, along with the `DefinitionNode` enum for storing user-defined types. Furthermore, **validation helpers** are added to the `nodes` module to ensure data integrity by enforcing constraints like field uniqueness and enum value distinctness during type system node construction. This **new capability** establishes the core architecture for managing and validating type definitions within the `thrift/lib/rust/dynamic/type_system` module.

This commit introduces a **new capability** by implementing a **canonical, deterministic SHA-256 digest** for the **Thrift C++ `TypeSystem`** and its related components. This digest ensures that structurally equivalent type systems, whether in runtime or serialized form, always produce identical hashes, independent of definition order or serialization specifics. This feature is crucial for enabling efficient **cache invalidation, version compatibility checks, and deduplication** within the **Thrift C++ runtime**. The implementation in `thrift/lib/cpp2/dynamic/TypeSystemDigest.cpp` includes ordering normalization and a version byte prefix for future algorithm evolution, with comprehensive unit tests verifying its determinism and order independence.

This commit introduces a **new capability** for the **Thrift C++2 dynamic type system**, providing explicit **pruning** functionality for `TypeSystem` and `SerializableTypeSystem` instances. It adds `buildPrunedFrom` static methods to `TypeSystemBuilder` and `SerializableTypeSystemBuilder`, allowing users to easily create a new type system containing only specified root types and their transitive dependencies. This **feature** improves the discoverability and usability of pruning, elevating it to a named operation akin to `merge` or `overlay`. New utilities, including `PruneOptions` and `forEachTransitiveDependency`, support this functionality, simplifying the creation of specialized type systems.

This commit introduces a **new capability** to the **Thrift annotation system** by defining the `thrift.Deprecated` structured annotation. This annotation allows developers to mark Thrift definitions, initially focusing on struct fields, as deprecated, optionally including a `message` to explain the change. The **Thrift compiler** is updated to recognize this annotation, specifically extending the `t_whisker_generator` to expose `deprecated?` and `deprecation_message` properties for code generation. This enables downstream code generators to produce **language-specific deprecation warnings**, facilitating API evolution and migration by guiding users away from outdated elements. New test fixtures are also added to validate its functionality on fields and union members.

This commit **introduces support for the `@thrift.Deprecated` annotation** within the **Thrift Java code generator**. It updates the `Union.mustache` and `FieldGetter.mustache` templates to ensure that **Java getter methods** for Thrift fields marked as deprecated are now correctly annotated with `@Deprecated`. This **new feature** provides developers with **compiler deprecation warnings** when accessing deprecated fields, thereby improving code quality and guiding API evolution in Java projects using Thrift.

This commit introduces **C++ support for `@thrift.Deprecated` fields**, enabling the Thrift compiler to generate `[[deprecated("message")]]` attributes for field accessor methods in C++ code. This **new capability** affects the **Thrift C++ code generator**, specifically for generated struct and union types, by adding deprecation warnings to `_ref()` and `_ref()&` methods. A minor **refactoring** in `thrift/compiler/generate/t_whisker_generator.cc` refines the internal logic for handling deprecation messages. The primary impact is that C++ developers will now receive **compiler-level deprecation warnings** when using deprecated Thrift fields, promoting better API evolution and usage.

This commit introduces a **new capability** to the **Rust Thrift compiler** by adding support for the `@thrift.Deprecated` annotation. It now generates Rust `#[deprecated]` attributes on **struct fields and enum variants** in the output code, specifically within `thrift/compiler/generate/templates/rust/lib/struct.mustache`. This ensures that Rust developers receive **compiler-level deprecation warnings** when using Thrift fields marked as deprecated. This enhancement improves code maintainability and guides API evolution by providing immediate feedback on deprecated usage.

This commit introduces **support for the `@thrift.Deprecated` annotation** within the **Go Thrift code generator**. It enhances the `thrift/compiler/generate/templates/go/types/field.mustache` template to emit `// Deprecated:` doc comments for Go struct fields that correspond to Thrift fields explicitly marked as deprecated. This **new feature** ensures that Go developers consuming generated Thrift code will receive **compile-time deprecation warnings** from tools like `go vet` or `staticcheck` when accessing these fields, thereby improving API usage clarity and guiding transitions away from outdated components.

This commit introduces a **new capability** to the **Thrift compiler's Hack generator**, enabling it to process the `@thrift.Deprecated` annotation. Specifically, the `t_hack_generator.cc` module is updated to generate the Hack-specific `<<__Deprecated("message")>>` attribute on struct fields that are marked as deprecated in their Thrift definition. This enhancement ensures that Hack code consuming Thrift services will now receive runtime deprecation warnings when accessing these fields. This significantly improves API evolution and code hygiene for Hack developers by providing clear guidance on deprecated field usage.

This commit introduces **Python support for `@thrift.Deprecated` fields**, enabling the Thrift Python runtime to emit `DeprecationWarning` when accessing fields marked as deprecated in the IDL. It implements a new `_DeprecatedFieldWrapper` in `thrift/lib/python/types.pyx` to handle these warnings without altering core descriptor classes, and adds a `deprecation_message` field to `FieldInfo` in `types.pxd`. The **Thrift Python code generator** (`types.mustache`) is updated to leverage this wrapper, ensuring that generated Python code correctly reflects deprecation status. This **new feature** enhances the developer experience by providing **runtime deprecation warnings** for deprecated API usage, facilitating smoother transitions and code maintenance.

This commit **enhances the Thrift compiler's semantic analysis** by **introducing new linting rules** to detect and report ambiguous usage of **scoped (`foo.Bar`) and fully-qualified (`foo.Bar.BAZ`) identifiers**. Primarily affecting the `thrift/compiler/sema/resolution_mismatch.cc` module, this **new feature** identifies conflicts where local definitions clash with included programs or when multiple included programs create name ambiguities. The linter now provides **actionable suggestions** for resolving these ambiguities, such as using include aliases or renaming, thereby **improving code clarity and preventing potential runtime issues** for Thrift definition authors.

This commit provides a **fix** for **Thrift's URI handling**, specifically addressing issues with converting `folly::cstring_view` and other string-like types into `std::string` for URI representation. It introduces a **templated overload** to the `uri` static method within `thrift/lib/cpp2/dynamic/TypeId.h`, enabling construction from any type convertible to `std::string`. This **enhances type flexibility** and improves the robustness of **Thrift's URI construction**, ensuring smoother integration and preventing conversion-related errors for various string types.

This commit **introduces a new `cpp.NonOrderable` annotation** within the **Thrift compiler** to explicitly manage ordering for **C++ structured types**. When applied, this **new capability** causes the C++ code generator to **delete the `operator<` declaration** and omit its definition for the annotated type. This **bug fix** addresses potential issues in dynamic library builds where a missing `operator<` definition could lead to runtime problems. By making the non-orderable nature of types explicit, it enhances the **correctness and reliability of generated C++ code**, preventing implicit or partially defined ordering operators.

This commit introduces the **`cpp.NonOrderable` annotation** to the **Thrift compiler**, providing a new **capability** for C++ code generation. When applied to structured types, this annotation explicitly **marks `operator<` as deleted** in the header and **omits its definition** in the generated C++ code. This **maintenance** change addresses potential issues in dynamic library builds where a missing `operator<` definition could lead to runtime problems, improving the **robustness of Thrift-generated C++ types**. The new annotation allows developers to explicitly control the ordering behavior of **C++ structured types** generated from Thrift definitions.