Skip to content

Tracking Issue for type_info #146922

Open
0 of 1 issue completed
Open

Description

@oli-obk

This is a tracking issue for the project goal rust-lang/goals#406
The feature gate for the issue is #![feature(type_info)].

About tracking issues

Tracking issues are used to record the overall progress of implementation.
They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions.
A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature.
Instead, open a dedicated issue for the specific matter and add the relevant feature gate label.
Discussion comments will get marked as off-topic or deleted.
Repeated discussions on the tracking issue may lead to the tracking issue getting locked.

Steps

Unresolved Questions

  • Should we use fine grained (many) intrinsics for individual information or keep the one big intrinsic returning an enum of the information?
  • what semver implications does all this have and what guarantees of semver do we retain?
  • should we even do this at all? Reflection allows causing monomorphization time errors similar to const { assert!(size_of::<T>(), 5) }, but for much more fine-grained details of a generic parameter T.
  • Is something lifetime-aware even possible at all?
  • Should we use a non-const-eval based scheme (const generics based or even proc macro based?)
  • Should free functions be used rather than methods on existing types? Tracking Issue for type_info #146922 (comment)

Implementation history

Activity

  1. added
    C-tracking-issueCategory: An issue tracking the progress of sth. like the implementation of an RFC
    T-langRelevant to the language team
    T-libsRelevant to the library team, which will review and decide on the PR/issue.
    on Sep 23, 2025
  2. added
    B-experimentalBlocker: In-tree experiment; RFC pending, not yet approved or unneeded (requires FCP to stabilize).
    on Sep 23, 2025
  3. added a commit that references this issue on Jan 3, 2026
  4. added a commit that references this issue on Jan 7, 2026
  5. added a commit that references this issue on Jan 10, 2026
  6. added a commit that references this issue on Jan 10, 2026
  7. added a commit that references this issue on Jan 10, 2026
  8. added 2 commits that reference this issue on Jan 13, 2026
  9. 75 remaining items

  10. added a commit that references this issue on Aug 22, 2026
  11. added 6 commits that reference this issue on Sep 7, 2026
  12. added a commit that references this issue on Sep 7, 2026
  13. added a commit that references this issue on Sep 7, 2026
  14. added a commit that references this issue on Sep 8, 2026
  15. yara-blue commented on Oct 27, 2026

    @yara-blue
    Contributor

    unresolved question:
    Should we turn the reflection methods into plain functions taking a TypeId as argument so we do not pollute TypeId and we can have a nicer API in the (far) future?

    Context:
    The entry point to reflection is methods on TypeId. For various reasons, we're making the API fine grained and targeted. We'll end up with a wide and shallow API with many methods on TypeId. This is not nice to use directly, however we intend for end-users to use an ergonomic wrapper crate. We'll ensure there is at least one of those. We're doing this for the usual reasons (1).

    At some point, potentially many years in the future (2), the ecosystem may coalesce on a single nice ergonomic wrapper for all use cases. If we end up stabilizing a lot of reflection methods on TypeId any future API using TypeId as the entry point will have it's methods drowned out by the existing stable ones. Instead could keep TypeId "clean" at the cost of worse ergonomics now.

    (1): faster iteration, more accessible to ppl outside the compiler, less code in the compiler, avoid stabilizing a nice API that turns out to be bad later etc etc.
    (2): we may even have reflection synthesize new code at some point. That could very well change what an ergonomic API looks like.

  16. Tess4552 commented on Oct 28, 2026

    @Tess4552
    Contributor

    Before stabilizing, we should consider what the methods querying doc comments should return. Would we want to merge and transform different doc comments together and/or beautify them?

    It could look as follows:

    #[doc = "first"]
    /// second
    /**   third
     *  forth
     */
    struct A;
    
    // using comment field out of DocComment
    TypeId::of::<A>().docs() == ["first", " second", "   third\n *  forth\n "] 
    // alternatively using rustc_resolve to apply transformations
    TypeId::of::<A>().doc() == "first\nsecond\n third\n forth\n"

    To me it seems to make sense to expose a slice of (non-transformed) str to keep the const time machine minimal

  17. added a commit that references this issue on Oct 29, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    B-experimentalBlocker: In-tree experiment; RFC pending, not yet approved or unneeded (requires FCP to stabilize).C-tracking-issueCategory: An issue tracking the progress of sth. like the implementation of an RFCF-type_info#![feature(type_info)]T-langRelevant to the language teamT-libsRelevant to the library team, which will review and decide on the PR/issue.T-typesRelevant to the types team, which will review and decide on the PR/issue.

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions