Unlabeled
-Cprefer-dynamic
Codegen option: Prefer dynamic linking to static linking.
-Zbuild-std
Unstable Cargo option: Compile the standard library yourself.
-Zdebuginfo-compression
Unstable option: debuginfo compression
-Zdwarf-version
Unstable option: set dwarf version
-Zfmt-debug
Unstable option: fmt-debug
-Zmetrics-dir
Unstable option: metrics directory
-Znormalize-docs
Unstable rustdoc option: Normalize/evaluate types when generating docs
-Zpolymorphize
Unstable option: Polymorphization.
-Zrandomize-layout
Unstable option: Randomize the layout of types.
-Zterminal-urls
Unstable option: emit OSC8 hyperlinks in diagnostics
-Zthir-unsafeck
Unstable option: THIR unsafeck
-Ztrace-macros
Unstable option: trace-macros
-Zvalidate-mir
Unstable option: MIR validation
A-a11y
Area: Anything to do with accessibility
A-ABI
Area: Concerning the application binary interface (ABI)
A-align
Area: alignment control (`repr(align(N))` and so on)
A-allocators
Area: Custom and system allocators
A-array
Area: `[T; N]`
A-associated-items
Area: Associated items (types, constants & functions)
A-ast
Area: AST
A-async-await
Area: Async & Await
A-atomic
Area: Atomics, barriers, and sync primitives
A-attributes
Area: Attributes (`#[…]`, `#![…]`)
A-auto-traits
Area: auto traits (e.g., `auto trait Send {}`)
A-autovectorization
Area: Autovectorization, which can impact perf or code size
A-backtrace
Area: Backtraces
A-bootstrap-config
Area: bootstrap `config.toml` and the config system
A-borrow-checker
Area: The borrow checker
A-box
Area: Our favorite opsem complication
A-cfg
Area: `cfg` conditional compilation
A-CI
Area: Our Github Actions CI
A-CLI
Area: Command-line interface (CLI) to the compiler
A-clippy
Area: Clippy
A-closures
Area: Closures (`|…| { … }`)
A-code-coverage
Area: Source-based code coverage (-Cinstrument-coverage)
A-codegen
Area: Code generation
A-coercions
Area: implicit and explicit `expr as Type` coercions
A-coherence
Area: Coherence
A-coinduction
Area: Concerning coinduction, most often for auto traits
A-collections
Area: `std::collection`
A-compiletest
Area: The compiletest test runner
A-concurrency
Area: Concurrency
A-const-eval
Area: Constant evaluation (MIR interpretation)
A-const-fn
Area: const fn foo(..) {..}. Pure functions which can be applied at compile time.
A-const-generics
Area: const generics (parameters and arguments)
A-const-prop
Area: Constant propagation
A-contributor-roadblock
Area: Makes things more difficult for new contributors to rust itself
A-control-flow
Area: Control flow
A-coroutines
Area: Coroutines
A-cranelift
Things relevant to the [future] cranelift backend
A-crate-compat
Area: Impacting SemVer compatibility of crates in the ecosystem
A-crates
Area: Crates and their interactions (like crate loading)
A-cross
Area: Cross compilation
A-cross-crate-reexports
Area: Documentation that has been re-exported from a different crate
A-debuginfo
Area: Debugging information in compiled programs (DWARF, PDB, etc.)
A-destructors
Area: Destructors (`Drop`, …)
A-diagnostics
Area: Messages for errors, warnings, and lints
A-doc-alias
Area: `#[doc(alias)]`
A-doc-coverage
Area: Calculating how much of a crate has documentation
A-docs
Area: documentation for any part of the project, including the compiler, standard library, and tools
A-doctests
Area: Documentation tests, run by rustdoc
A-download-rustc
Area: The `rust.download-rustc` build option.
A-driver
Area: rustc_driver that ties everything together into the `rustc` compiler
A-DSTs
Area: Dynamically-sized types (DSTs)
A-edition-2018-lints
Area: Lints supporting the 2018 edition
A-edition-2021
Area: The 2021 edition
A-edition-2024
Area: The 2024 edition
A-edition-2027
Area: The 2027 edition
A-enum
🤓 akshually it's an "ADT" or "algebraic data type"
A-error-codes
Area: Explanation of an error code (--explain)
A-error-handling
Area: Error handling
A-exhaustiveness-checking
Relating to exhaustiveness / usefulness checking of patterns
A-extern-fn
Area: `extern` functions
A-FFI
Area: Foreign function interface (FFI)
A-filesystem
Area: `std::fs`
A-floating-point
Area: Floating point numbers and arithmetic
A-fmt
Area: `std::fmt`
A-frontend
Area: Compiler frontend (errors, parsing and HIR)
A-GATs
Area: Generic associated types (GATs)
A-gcc
Things relevant to the [future] GCC backend
A-github-actions
Area: GitHub Actions (GHA)
A-grammar
Area: The grammar of Rust
A-hardware-interrupts
Area: Code for handling the "interrupt ABI" of various processors
A-higher-ranked
Area: Higher-ranked things (e.g., lifetimes, types, trait bounds aka HRTBs)
A-HIR
Area: The high-level intermediate representation (HIR)
A-hygiene
Area: Macro hygiene
A-impl-trait
Area: `impl Trait`. Universally / existentially quantified anonymous types with static dispatch.
A-implied-bounds
Area: Implied bounds / inferred outlives-bounds
A-incr-comp
Area: Incremental compilation
A-inference
Area: Type inference
A-inline-assembly
Area: Inline assembly (`asm!(…)`)
A-intra-doc-links
Area: Intra-doc links, the ability to link to items in docs by name
A-intrinsics
Area: Intrinsics
A-io
Area: `std::io`, `std::fs`, `std::net` and `std::path`
A-iterators
Area: Iterators
A-lang-item
Area: Language items
A-layout
Area: Memory layout of types
A-lazy-normalization
Area: Lazy normalization (tracking issue: #60471)
A-libtest
Area: `#[test]` / the `test` library
A-licensing
Area: Compiler licensing
A-lifetimes
Area: Lifetimes / regions
A-link-to-definition
rustdoc --generate-link-to-definition nightly-only feature
A-linkage
Area: linking into static, shared libraries and binaries
A-linkers
Area: linkers... you gotta love linkers
A-lint
Area: Lints (warnings about flaws in source code) such as unused_mut.
A-LLVM
Area: Code generation parts specific to LLVM. Both correctness bugs and optimization-related issues.
A-local-reexports
Area: Documentation that has been locally re-exported (i.e., non-cross-crate)
A-LTO
Area: Link-time optimization (LTO)
A-macros
Area: All kinds of macros (custom derive, macro_rules!, proc macros, ..)
A-macros-1.2
Area: Declarative macros 1.2
A-macros-2.0
Area: Declarative macros 2.0 (#39412)
A-markdown-parsing
Area: Markdown parsing for doc-comments
A-maybe-future-edition
Something we may consider for a future edition.
A-meta
Area: Issues & PRs about the rust-lang/rust repository itself
A-metadata
Area: Crate metadata
A-metrics
Area: Metrics
A-MIR
Area: Mid-level IR (MIR) - https://blog.rust-lang.org/2016/04/19/MIR.html
A-mir-opt
Area: MIR optimizations
A-mir-opt-inlining
Area: MIR inlining
A-mir-opt-nrvo
Fixed by NRVO
A-miri
Area: The miri tool
A-monomorphization
Area: Monomorphization
A-naked
Area: `#[naked]`, prologue and epilogue-free, functions, https://git.io/vAzzS
A-NLL
Area: Non-lexical lifetimes (NLL)
A-panic
Area: Panicking machinery
A-parallel-queries
Area: Parallel query execution
A-parser
Area: The parsing of Rust source code to an AST
A-path-remapping
Area: path remapping, --remap-path-prefix, --remap-cwd-prefix, --remap-diagnostics-scope etc.
A-patterns
Relating to patterns and pattern matching
A-permissions
Area: filesystem perms and other kind of permissions
A-PGO
Area: Profile-guided optimizations (PGO)
A-pin
Area: Pin
A-plugin
Area: compiler plugins, doc.rust-lang.org/nightly/unstable-book/language-features/plugin.html
A-pretty
Area: Pretty printing (including `-Z unpretty`)
A-proc-macro-back-compat
Area: Backwards compatibility hacks for proc macros
A-proc-macros
Area: Procedural macros
A-process
Area: `std::process` and `std::env`
A-profile-rt
Area: The profiler runtime for llvm-profdata and llvm-cov
A-query-system
Area: The rustc query system (https://rustc-dev-guide.rust-lang.org/query.html)
A-raw-pointers
Area: raw pointers, MaybeUninit, NonNull
A-reachable-priv
Issues involving private types that are indirectly reachable or effect the public api
A-repr
Area: the `#[repr(stuff)]` attribute
A-repr-packed
Area: the naughtiest repr
A-reproducibility
Area: Reproducible / deterministic builds
A-resolve
Area: Name resolution
A-result-option
Area: Result and Option combinators
A-run-make
Area: port run-make Makefiles to rmake.rs
A-runtime
Area: std's runtime and "pre-main" init for handling backtraces, unwinds, stack overflows
A-rust-2018-preview
Area: The 2018 edition preview
A-rust-for-linux
Relevant for the Rust-for-Linux project
A-rustdoc-js
Area: Rustdoc's JS front-end
A-rustdoc-json
Area: Rustdoc JSON backend
A-rustdoc-scrape-examples
Area: The (unstable) rustdoc scrape-examples feature described in RFC 3123
A-rustdoc-search
Area: Rustdoc's search feature
A-rustdoc-themes
Area: Themes for HTML pages generated by rustdoc
A-rustdoc-type-layout
Area: `rustdoc --show-type-layout` (nightly-only)
A-rustdoc-ui
Area: Rustdoc UI (generated HTML)
A-rustfmt
Area: Rustfmt
A-sanitizers
Area: Sanitizers for correctness and code quality
A-save-analysis
Area: saving results of analyses such as inference and borrowck results to a file.
A-security
Area: Security (example: address space layout randomization).
A-self-profile
Area: Self-profiling feature of the compiler
A-SIMD
Area: SIMD (Single Instruction Multiple Data)
A-slice
Area: `[T]`
A-slice-patterns
Area: Slice patterns, https://github.com/rust-lang/rust/issues/23121
A-specialization
Area: Trait impl specialization
A-spurious
Area: Spurious failures in builds (spuriously == for no apparent reason)
A-stability
Area: `#[stable]`, `#[unstable]` etc.
A-stable-MIR
Area: stable MIR
A-stack-probe
Area: Stack probing and guard pages
A-str
Area: str and String
A-strict-provenance
Area: Strict provenance for raw pointers
A-suggestion-diagnostics
Area: Suggestions generated by the compiler applied by `cargo fix`
A-syntaxext
Area: Syntax extensions
A-synthetic-impls
Area: Synthetic impls, used by rustdoc to document auto traits and traits with blanket impls
A-target-feature
Area: Enabling/disabling target features like AVX, Neon, etc.
A-target-specs
Area: Compile-target specifications
A-targets
Area: Concerning the implications of different compiler targets
A-technical-debt
Area: Internal cleanup work
A-test-infra
Area: test infrastructure (may span bootstrap/compiletest/more)
A-testsuite
Area: The testsuite used to check the correctness of rustc
A-THIR
Area: Typed HIR
A-thread
Area: `std::thread`
A-thread-locals
Area: Thread local storage (TLS)
A-tidy
Area: The tidy tool
A-time
Area: Time
A-tool-attributes
Area: tool attributes like `#[rustfmt::skip]`
A-trait-objects
Area: trait objects, vtable layout
A-trait-system
Area: Trait system
A-translation
Area: Translation infrastructure, and migrating existing diagnostics to SessionDiagnostic
A-type-based-search
Area: Searching rustdoc pages using type signatures
A-type-system
Area: Type system
A-Unicode
Area: Unicode
A-unnameable-reexports
`pub use something as _;`
A-valtree
Area: Value trees or fixed by value trees
A-variance
Area: Variance (https://doc.rust-lang.org/nomicon/subtyping.html)
A-visibility
Area: Visibility / privacy
A-zst
Area: Zero-sized types (ZST).
april-1st
Started on the 1st of April
AsyncAwait-Polish
Async-await issues that are part of the "polish" area
AsyncAwait-Triaged
Async-await issues that have been triaged during a working group meeting.
B-experimental
Blocker: In-tree experiment; RFC pending, not yet approved or unneeded.
B-MCP-approved
Blocker: Approved by an accepted MCP.
B-RFC-approved
Blocker: Approved by a merged RFC but not yet implemented.
B-RFC-implemented
Blocker: Approved by a merged RFC and implemented.
B-unstable
Blocker: Implemented in the nightly compiler and unstable.
beta-accepted
Accepted for backporting to the compiler in the beta channel.
beta-nominated
Nominated for backporting to the compiler in the beta channel.
C-bug
Category: This is a bug.
C-cleanup
Category: PRs that clean code up or issues documenting cleanup.
C-defective-hardware
Category: Issue that was filed as a possible software bug but is actually defective hardware
C-discussion
Category: Discussion or questions that doesn't represent real issues.
C-enhancement
Category: An issue proposing an enhancement or a PR with one.
C-external-bug
Category: issue that is caused by bugs in software beyond our control
C-feature-accepted
Category: A feature request that has been accepted pending implementation.
C-feature-request
Category: A feature request, i.e: not implemented / a PR.
C-future-incompatibility
Category: Future-incompatibility lints
C-gub
Category: the reverse of a compiler bug is generally UB
C-optimization
Category: An issue highlighting optimization opportunities or PRs implementing such
C-tracking-issue
Category: An issue tracking the progress of sth. like the implementation of an RFC
call-for-testing
Marks issues that require broader testing from the community, e.g. before stabilization.
CI-ABA-ptr-provenance-lockless-queue-fail
CI spurious failure: related to #121950
CI-spurious-fail-msvc
CI spurious failure: target env msvc
const-generics-bad-diagnostics
An error is correctly emitted, but is confusing, for `min_const_generics`.
const-generics-fixed-by-const_generics
A bug that has been fixed once `const_generics` is enabled.
D-confusing
Diagnostics: Confusing error or lint that should be reworked.
D-crate-version-mismatch
Diagnostics: Errors or lints caused be the use of two different crate versions.
D-diagnostic-infra
Diagnostics: Issues that affect all diagnostics, or relate to the diagnostic machinery itself.
D-edition
Diagnostics: An error or lint that should account for edition differences.
D-imprecise-spans
Diagnostics: spans don't point to exactly the erroneous code
D-inconsistent
Diagnostics: Inconsistency in formatting, grammar or style between diagnostic messages.
D-incorrect
Diagnostics: A diagnostic that is giving misleading or incorrect information.
D-invalid-suggestion
Diagnostics: A structured suggestion resulting in incorrect code.
D-newcomer-roadblock
Diagnostics: Confusing error or lint; hard to understand for new users.
D-papercut
Diagnostics: An error or lint that needs small tweaks.
D-terse
Diagnostics: An error or lint that doesn't give enough information about the problem at hand.
D-Unicode-unaware
Diagnostics: Diagnostics that are unaware of Unicode and trigger codepoint boundary assertions
D-verbose
Diagnostics: Too much output caused by a single piece of incorrect code.
disposition-close
This PR / issue is in PFCP or FCP with a disposition to close it.
disposition-merge
This issue / PR is in PFCP or FCP with a disposition to merge it.
disposition-postpone
This issue / PR is in PFCP or FCP with a disposition to postpone it.
E-easy
Call for participation: Easy difficulty. Experience needed to fix: Not much. Good first issue.
E-hard
Call for participation: Hard difficulty. Experience needed to fix: A lot.
E-help-wanted
Call for participation: Help is requested to fix this issue.
E-medium
Call for participation: Medium difficulty. Experience needed to fix: Intermediate.
E-mentor
Call for participation: This issue has a mentor. Use #t-compiler/help on Zulip for discussion.
E-needs-bisection
Call for participation: This issue needs bisection: https://github.com/rust-lang/cargo-bisect-rustc
E-needs-design
This issue needs exploration and design to see how and if we can fix/implement it
E-needs-investigation
Call for partcipation: This issues needs some investigation to determine current status
E-needs-mcve
Call for participation: This issue has a repro, but needs a Minimal Complete and Verifiable Example
E-needs-stack
Call for participation: This issue needs a stacktrace.
E-needs-test
Call for participation: An issue has been fixed and does not reproduce, but no test has been added.
E-tedious
Call for participation: An issue involves lots of work and is better handled as many small tasks.
F-abi_c_cmse_nonsecure_call
`#![feature(abi_c_cmse_nonsecure_call)]`
F-abi_x86_interrupt
F-adt_const_params
`#![feature(adt_const_params)]`
F-allow_internal_unstable
`#![feature(allow_internal_unstable)]`
F-anonymous_lifetime_in_impl_trait
`#![feature(anonymous_lifetime_in_impl_trait)]`
F-arbitrary_self_types
`#![feature(arbitrary_self_types)]`
F-array_repeat
`#![feature(array_repeat)]`
F-asm
`#![feature(asm)]` (not `llvm_asm`)
F-associated_const_equality
`#![feature(associated_const_equality)]`
F-associated_type_bounds
`#![feature(associated_type_bounds)]`
F-associated_type_defaults
`#![feature(associated_type_defaults)]`
F-async_closure
`#![feature(async_closure)]`
F-async_drop
Async drop
F-async_fn_in_trait
Static async fn in traits
F-async_fn_traits
`#![feature(async_fn_traits)]`
F-async_for_loop
`#![feature(async_for_loop)]`
F-auto_traits
`#![feature(auto_traits)]`
F-autodiff
`#![feature(autodiff)]`
F-bindings_after_at
`#![feature(bindings_after_at)]`
F-box_patterns
`#![feature(box_patterns)]`
F-box_uninit_write
F-bufreader_peek
`#![feature(bufreader_peek)]`
F-c_str_literals
`#![feature(c_str_literals)]`
F-c_unwind
`#![feature(c_unwind)]`
F-c_variadic
`#![feature(c_variadic)]`
F-cfg_accessible
`#![feature(cfg_accessible)]`
F-cfg_version
`#![feature(cfg_version)]`
F-check-cfg
--check-cfg
F-closure_lifetime_binder
`#![feature(closure_lifetime_binder)]`
F-cmse_nonsecure_entry
`#![feature(cmse_nonsecure_entry)]`
F-coerce_unsized
The `CoerceUnsized` trait
F-collapse_debuginfo
`#![feature(collapse_debuginfo)]`
F-const_async_blocks
`#![feature(const_async_blocks)]`
F-const_closures
`#![feature(const_closures)]`
F-const_extern_fn
`#![feature(const_extern_fn)]`
F-const_generics_defaults
`#![feature(const_generics_defaults)]`
F-const_generics
`#![feature(const_generics)]`
F-const_heap
`#[feature(const_heap)]`
F-const_mut_refs
`#![feature(const_mut_refs)]`
F-const_refs_to_cell
`#[feature(const_refs_to_cell)]`
F-const_refs_to_static
`#![feature(const_refs_to_static)]`
F-const_trait_impl
`#![feature(const_trait_impl)]`
F-context_ext
`#![feature(context_ext)]`
F-core_intrinsics
Issue in the "core intrinsics" for internal usage only.
F-core_pattern_type
`#![feature(core_pattern_type)]`
F-core_pattern_types
`#![feature(core_pattern_types)]`
F-coroutine_clone
`#![feature(coroutine_clone)]`
F-coroutines
`#![feature(coroutines)]`
F-custom_test_frameworks
`#![feature(custom_test_frameworks)]`
F-debugger_visualizer
`#![feature(debugger_visualizer)]`
F-decl_macro
`#![feature(decl_macro)]`
F-default_field_values
`#![feature(default_field_values)]`
F-default_type_parameter_fallback
`#![feature(default_type_parameter_fallback)]`
F-deprecated_safe
`#![feature(deprecated_safe)]`
F-deref_patterns
`#![feature(deref_patterns)]`
F-derive_smart_pointer
`#![feature(derive_smart_pointer)]`
F-destructuring_assignment
`#![feature(destructuring_assignment)]`
F-dispatch_from_dyn
`#![feature(dispatch_from_dyn)]`
F-doc_auto_cfg
`#![feature(doc_auto_cfg)]`
F-doc_cfg
`#![feature(doc_cfg)]`
F-doc_masked
`#![feature(doc_masked)]`
F-dropck_eyepatch
`#![feature(dropck_eyepatch)]`
F-dyn_compatible_for_dispatch
`#![feature(dyn_compatible_for_dispatch)]`; formerly `object_safe_for_ispatch`
F-dyn_star
`#![feature(dyn_star)]`
F-effects
`#![feature(effects)]`
F-ergonomic_clones
`#![feature(ergonomic_clones)]`
F-exclusive_range_pattern
`#![feature(exclusive_range_pattern)]`
F-exhaustive_patterns
`#![feature(exhaustive_patterns)]`
F-explicit_tail_calls
`#![feature(explicit_tail_calls)]`
F-export_executable_symbols
`#![feature(export_executable_symbols)]`
F-extended_key_value_attributes
`#![feature(extended_key_value_attributes)]
F-extended_varargs_abi_support
`#![feature(extended_varargs_abi_support)]`
F-extern_item_impls
`#![feature(extern_item_impls)]`
F-extern_types
`#![feature(extern_types)]`
F-external_doc
`#![feature(external_doc)]`
F-externally_constructed_attr
`#![feature(externally_constructed_attr)]`
F-f16_and_f128
`#![feature(f16)]`, `#![feature(f128)]`
F-float_semantics
`#![feature(float_semantics)]`
F-fmt_debug
`#![feature(fmt_debug)]`
F-fn_align
`#![feature(fn_align)]`
F-fn_delegation
`#![feature(fn_delegation)]`
F-format_implicit_args
implicit arguments for format strings (RFC 2795)
F-gen_blocks
`gen {}` expressions that produce `Iterator`s
F-generic_arg_infer
Using `_` as a const argument: #![feature(generic_arg_infer)]`
F-generic_assert
`#![feature(generic_assert)]`
F-generic_associated_types_extended
`#![feature(generic_associated_types_extended)]`
F-generic_associated_types
`#![feature(generic_associated_types)]` a.k.a. GATs
F-generic_const_exprs
`#![feature(generic_const_exprs)]`
F-generic_const_items
`#![feature(generic_const_items)]`
F-generic_const_parameter_types
`#![feature(generic_const_parameter_types)]`: allowing `<T, const V: T>` (not yet implemented))
F-global_registration
`#![feature(global_registration)]`
F-gpu_offload
`#![feature(gpu_offload)]`
F-guard_patterns
`#![feature(guard_patterns)]`
F-half_open_range_patterns
`#![feature(half_open_range_patterns)]`
F-if_let_guard
`#![feature(if_let_guard)]`
F-impl_restriction
`#![feature(impl_restriction)]`
F-impl_trait_in_assoc_type
`#![feature(impl_trait_in_assoc_type)]`
F-impl_trait_in_bindings
`#![feature(impl_trait_in_bindings)]`
F-impl_trait_in_fn_trait_return
`#![feature(impl_trait_in_fn_trait_return)]`
F-inherent_associated_types
`#![feature(inherent_associated_types)]`
F-inline_const_pat
#![feature(inline_const_pat)]
F-inline_const
Inline constants (aka: const blocks, const expressions, anonymous constants)
F-isa_attribute
Related to #[instruction_set] attribute introduced by RFC 2867
F-label_break_value
`#![feature(label_break_value)]`
F-lazy_type_alias
`#![feature(lazy_type_alias)]`
F-let_chains
`#![feature(let_chains)]`
F-let_else
Issues related to let-else statements (RFC 3137)
F-lifetime_capture_rules_2024
`#![feature(lifetime_capture_rules_2024)]`
F-lint_reasons
`#![feature(lint_reasons)]`
F-lint-single_use_lifetimes
`single_use_lifetimes` lint
F-linux_pidfd
`#![feature(linux_pidfd)]`
F-macro_metavar_expr_concat
`#![feature(macro_metavar_expr_concat)]`
F-macro_metavar_expr
`#![feature(macro_metavar_expr)]`
F-marker_trait_attr
`#![feature(marker_trait_attr)]`
F-member_constraints
`#[feature(member_constraints)]`
F-min_exhaustive_patterns
`#![feature(min_exhaustive_patterns)]`
F-min_generic_const_args
`#![feature(min_generic_const_args)]` (not yet implemented)
F-min_specialization
`#![feature(min_specialization)]`
F-mixed_utf8_literals
#![feature(mixed_utf8_literals)]
F-more_qualified_paths
`#![feature(more_qualified_paths)]`
F-move_ref_pattern
`#![feature(move_ref_pattern)]`
F-mut_restriction
`#![feature(mut_restriction)]`
F-naked_functions
`#![feature(naked_functions)]`
F-negative_bounds
`#![feature(negative_bounds)]`
F-negative_impls
#![feature(negative_impls)]
F-never_patterns
`#![feature(never_patterns)]`
F-never_type
`#![feature(never_type)]`
F-new_range
`#![feature(new_range)]`
F-no_core
`#![feature(no_core)]`
F-non_ascii_idents
`#![feature(non_ascii_idents)]`
F-non_exhaustive_omitted_patterns_lint
`#![feature(non_exhaustive_omitted_patterns_lint)]`
F-non_exhaustive
`#![feature(non_exhaustive)]`
F-non_lifetime_binders
`#![feature(non_lifetime_binders)]`
F-offset_of_enum
`#![feature(offset_of_enum)]`
F-offset_of_nested
`#![feature(offset_of_nested)]`
F-offset_of_slice
`#![feature(offset_of_slice)]`
F-offset_of
`#![feature(offset_of)]`
F-on_unimplemented
Error messages that can be tackled with `#[rustc_on_unimplemented]`
F-or_patterns
`#![feature(or_patterns)]`
F-param_attrs
`#![feature(param_attrs)]`
F-patchable_function_entry
#![feature(patchable_function_entry)]
F-pattern_types
`#![feature(pattern_types)]`
F-pin_ergonomics
`#![feature(pin_ergonomics)]`
F-postfix_match
`#![feature(postfix_match)]`
F-precise_capturing_in_traits
`#![feature(precise_capturing_in_traits)]`
F-precise_capturing_of_types
`#![feature(precise_capturing_of_types)]`
F-precise_capturing
`#![feature(precise_capturing)]`
F-proc_macro_expand
`#![feature(proc_macro_expand)]`
F-pub_macro_rules
`#![feature(pub_macro_rules)]`
F-public_private_dependencies
feature: public_private_dependencies
F-raw_dylib
`#![feature(raw_dylib)]`
F-raw_ref_op
`#![feature(raw_ref_op)]`
F-re_rebalance_coherence
`#![feature(re_rebalance_coherence)]`
F-refine
`#![feature(refine)]`; RFC #3245
F-relaxed_struct_unsize
`#![feature(relaxed_struct_unsize)]`
F-reserved_prefixes
`#![feature(reserved_prefixes)]`
F-return_position_impl_trait_in_trait
`#![feature(return_position_impl_trait_in_trait)]`
F-return_type_notation
`#[feature(return_type_notation)]`
F-rust_cold_cc
`#![feature(rust_cold_cc)]`
F-rustc_attrs
Internal rustc attributes gated on the `#[rustc_attrs]` feature gate.
F-rustc_contracts
`#![feature(rustc_contracts)]`
F-shorter_tail_lifetimes
`#![feature(shorter_tail_lifetimes)]`
F-simd_ffi
`#![feature(simd_ffi)]`
F-sleep_until
`#![feature(sleep_until)]`
F-slice_patterns
`#![feature(slice_patterns)]`
F-specialization
`#![feature(specialization)]`
F-stdarch_aarch64_mte
`#![feature(stdarch_aarch64_mte)]`
F-stdarch_x86_avx512
`#![feature(stdarch_x86_avx512)]`
F-stmt_expr_attributes
`#![feature(stmt_expr_attributes)]`
F-string_from_utf8_lossy_owned
F-struct_target_features
`#![feature(struct_target_features)]`
F-supertrait_item_shadowing
`#![feature(supertrait_item_shadowing)]`
F-target_feature_11
target feature 1.1 RFC
F-thread_local
`#![feature(thread_local)]`
F-track_caller
`#![feature(track_caller)]`
F-trait_alias
`#![feature(trait_alias)]`
F-trait_upcasting
`#![feature(trait_upcasting)]`
F-transmutability
`#![feature(transmutability)]`
F-trim-paths
Feature: trim-paths
F-trivial_bounds
`#![feature(trivial_bounds)]`
F-try_blocks
`#![feature(try_blocks)]`
F-try_trait_v2
Tracking issue for RFC#3058
F-type_alias_impl_trait
`#[feature(type_alias_impl_trait)]`
F-type_ascription
`#![feature(type_ascription)]`
F-type-changing-struct-update
`#![feature(type_changing_struct_update)]`
F-unboxed_closures
`#![feature(unboxed_closures)]`
F-unnamed_fields
`#![feature(unnamed_fields)]`
F-unprefixed_guarded_strings
`#![feature(unprefixed_guarded_strings)]`
F-unsafe_attributes
`#![feature(unsafe_attributes)]`
F-unsafe_extern_blocks
`#![feature(unsafe_extern_blocks)]`
F-unsafe_fields
`#![feature(unsafe_fields)]`
F-unsafe_pinned
`#![feature(unsafe_pinned)]`
F-unsafe-block-in-unsafe-fn
RFC #2585
F-unsized_const_params
`#![feature(unsized_const_params)]`
F-unsized_fn_params
`#![feature(unsized_fn_params)]`
F-unsized_locals
`#![feature(unsized_locals)]`
F-untagged_unions
`#![feature(untagged_unions)]`
F-variant_count
`#![feature(variant_count)]`
F-wasip2
`#[feature(wasip2)]`
F-with_negative_coherence
`#![feature(with_negative_coherence)]`
final-comment-period
In the final comment period and will be merged soon unless new substantive objections are raised.
finished-final-comment-period
The final comment period is finished for this PR / Issue.
fixed-by-async-closures
Fixed by `#![feature(async_closure)]`
fixed-by-effects
The effect system based scheme for const fns resolves this.
fixed-by-next-solver
Fixed by the next-generation trait solver, `-Znext-solver`.
fixed-by-polonius
Compiling with `-Zpolonius` fixes this issue.
fixed-by-TAIT
Fixed by the feature `type_alias_impl_trait`.
fixed-by-thir-unsafeck
`-Z thir-unsafeck` handles this correctly.
GATs-blocking
Issues using the `generic_associated_types` feature that block stabilization
GATs-triaged
Issues using the `generic_associated_types` feature that have been triaged
glacier
ICE tracked in rust-lang/glacier.
hacktoberfest-accepted
has-merge-commits
PR has merge commits, merge with caution.
I-async-nominated
Nominated for discussion during an async working group meeting.
I-compilemem
Issue: Problems and improvements with respect to memory usage during compilation.
I-compiler-nominated
Nominated for discussion during a compiler team meeting.
I-compiletime
Issue: Problems and improvements with respect to compile times.
I-crash
Issue: The compiler crashes (SIGSEGV, SIGABRT, etc). Use I-ICE instead when the compiler panics.
I-cycle
Issue: A query cycle occurred while none was expected
I-edition-nominated
Nominated for discussion during an edition team meeting.
I-flaky-test
Issue: A test is flaky/unreliable/spuriously fails
I-hang
Issue: The compiler never terminates, due to infinite loops, deadlock, livelock, etc.
I-heavy
Issue: Problems and improvements with respect to binary size of generated code.
I-ICE
Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️
I-lang-easy-decision
Issue: The decision needed by the team is conjectured to be easy.
I-lang-nominated
Nominated for discussion during a lang team meeting.
I-libs-api-nominated
Nominated for discussion during a libs-api team meeting.
I-libs-nominated
Nominated for discussion during a libs team meeting.
I-memleak
Issue: Runtime memory leak without `mem::forget`.
I-miscompile
Issue: Correct Rust code lowers to incorrect machine code
I-monomorphization
Issue: An error at monomorphization time.
I-needs-decision
Issue: In need of a decision.
I-prioritize
Issue: Indicates that prioritization has been requested for this issue.
I-release-nominated
Nominated for the release team.
I-slow
Issue: Problems and improvements with respect to performance of generated code.
I-style-nominated
Nominated for discussion during a style team meeting.
I-types-nominated
Nominated for discussion during a types team meeting.
I-unsound
Issue: A soundness hole (worst kind of bug), see: https://en.wikipedia.org/wiki/Soundness
ICEBreaker-Cleanup-Crew
Helping to "clean up" bugs with minimal examples and bisections
ICEBreaker-LLVM
Bugs identified for the LLVM ICE-breaker group
L-abi_unsupported_vector_types
Lint: abi_unsupported_vector_types
L-arithmetic_overflow
Lint: arithmetic_overflow
L-binary_asm_labels
Lint: LLVM parses labels like 0, 1, 10, 11, etc. oddly
L-conflicting_repr_hint
Lint: conflicting_repr_hint
L-confusable_idents
Lint: confusable_idents
L-dead_code
Lint: dead_code
L-dependency_on_unit_never_type_fallback
Lint: dependency_on_unit_never_type_fallback
L-dropping_copy_types
Lint: dropping_copy_types
L-elided_lifetimes_in_associated_constant
Lint: elided_lifetimes_in_associated_constant
L-elided_lifetimes_in_paths
Lint: elided_lifetimes_in_paths
L-explicit_outlives_requirements
Lint: explicit_outlives_requirements
L-exported_private_dependencies
Lint: exported_private_dependencies
L-false-negative
Lint: False negative (should have fired but didn't).
L-false-positive
Lint: False positive (should not have fired).
L-for_loops_over_fallibles
Lint: for_loops_over_fallibles
L-if_let_rescope
Lint: if_let_rescope
L-impl_trait_overcaptures
Lint: impl_trait_overcaptures
L-improper_ctypes_definitions
Lint: improper_ctypes_definitions
L-improper_ctypes
Lint: improper_ctypes
L-invalid_nan_comparisons
Lint: invalid_nan_comparisons
L-invalid_reference_casting
Lint: invalid_reference_casting
L-invalid_value
Lint: invalid_value
L-irrefutable_let_patterns
Lint: irrefutable_let_patterns
L-keyword_idents
Lint group: keyword_idents
L-keyword_idents_2018
Lint: keyword_idents_2018
L-keyword_idents_2024
Lint: keyword_idents_2024
L-large_assignments
Lint: large_assignments
L-let_underscore_drop
Lint: let_underscore_drop
L-macro_use_extern_crate
Lint: macro_use_extern_crate
L-missing_copy_implementations
Lint: missing_copy_implementations
L-never_type_fallback_flowing_into_unsafe
Lint: never_type_fallback_flowing_into_unsafe
L-non_camel_case_types
Lint: non_camel_case_types
L-non_local_definitions
Lint: non_local_definitions
L-non_snake_case
Lint: non_snake_case
L-out_of_scope_macro_calls
Lint: out_of_scope_macro_calls
L-overflowing_literals
Lint: overflowing_literals
L-path_statements
Lint: path_statements
L-private_bounds
Lint: private_bounds
L-private_interfaces
Lint: private_interfaces
L-public_private_dependencies
Lint: public_private_dependencies
L-redundant_imports
Lint: redundant_imports
L-repr_transparent_external_private_fields
Lint: repr_transparent_external_private_fields
L-rust_2024_incompatible_pat
Lint: rust_2024_incompatible_pat
L-semicolon_in_expressions_from_macros
Lint: semicolon_in_expressions_from_macros
L-special_module_name
Lint: special_module_name
L-suspicious_double_ref_op
Lint: suspicious_double_ref_op
L-tail_expr_drop_order
Lint: tail_expr_drop_order
L-type_alias_bounds
Lint: type_alias_bounds
L-uncommon_codepoints
Lint: uncommon_codepoints
L-unconditional_panic
Lint: unconditional_panic
L-unconditional_recursion
Lint: unconditional_recursion
L-uncovered_param_in_projection
Lint: uncovered_param_in_projection
L-unexpected_cfgs
Lint: unexpected_cfgs
L-unit_bindings
Lint: unit_bindings
L-unknown_lints
Lint: unknown_lints
L-unnameable_test_items
Lint: unnameable_test_items
L-unnameable_types
Lint: unnameable_types
L-unreachable_code
Lint: unreachable_code
L-unreachable_patterns
Lint: unreachable_patterns
L-unreachable_pub
Lint: unreachable_pub
L-unsafe_attr_outside_unsafe
Lint: unsafe_attr_outside_unsafe
L-unsafe_code
Lint: unsafe_code
L-unsafe_op_in_unsafe_fn
Lint: unsafe_op_in_unsafe_fn
L-unused_assignments
Lint: unused_assignments
L-unused_braces
Lint: unused_braces
L-unused_crate_dependencies
Lint: unused_crate_dependencies
L-unused_doc_comments
Lint: unused_doc_comments
L-unused_imports
Lint: unused_imports
L-unused_lifetimes
Lint: unused_lifetimes
L-unused_mut
Lint: unused_mut
L-unused_parens
Lint: unused_parens
L-unused_qualifications
Lint: unused_qualifications
L-unused_variables
Lint: unused_variables
Libs-Small
Libs issues that are considered "small" or self-contained
Libs-Tracked
Libs issues that are tracked on the team's project board.
link-dead-code
Linkage: using -Clink-dead-code
llvm-fixed-upstream
Issue expected to be fixed by the next major LLVM upgrade, or backported fixes
llvm-main
Marks PRs that are making Rust work with LLVM main (this label is consumed by CI tooling)
merged-by-bors
This PR was explicitly merged by bors.
metabug
Issues about issues themselves ("bugs about bugs")
needs-acp
This change is blocked on the author creating an ACP.
needs-fcp
This change is insta-stable, so needs a completed FCP to proceed.
needs-mcp
This change is large enough that it needs a major change proposal before starting work.
needs-rfc
This change is large or controversial enough that it should have an RFC accepted before doing it.
needs-triage
This issue may need triage. Remove it if it has been sufficiently triaged.
NLL-complete
Working towards the "valid code works" goal
NLL-diagnostics
Working towards the "diagnostic parity" goal
NLL-fixed-by-NLL
Bugs fixed, but only when NLL is enabled.
NLL-performant
Working towards the "performance is good" goal
NLL-polonius
Issues related for using Polonius in the borrow checker
NLL-reference
Reference material for NLL
NLL-sound
Working towards the "invalid code does not compile" goal
O-AArch64
Armv8-A or later processors in AArch64 mode
O-aix
OS: Big Blue's Advanced Interactive eXecutive..
O-android
Operating system: Android
O-apple
Operating system: Apple (macOS, iOS, tvOS, visionOS, watchOS)
O-arch-linux
Operating system: Arch Linux
O-Arm
Target: 32-bit Arm processors (armv6, armv7, thumb...), including 64-bit Arm in AArch32 state
O-asmjs
Target: asm.js - http://asmjs.org/
O-AVR
Target: AVR processors (ATtiny, ATmega, etc.)
O-bare-metal
Target: Rust without an operating system
O-csky
Target: glaCSKY above covers over me~
O-dragonfly
Operating system: DragonFly BSD
O-eBPF
Target: I heard you liked code execution so I put some code execution in your code execution
O-emscripten
Target: 50% off wasm32-unknown-musl. the savings come out of stdio.h, but hey, you get SDL!
O-ESP-IDF
Target: Espressif IoT Development Framework
O-freebsd
Operating system: FreeBSD
O-fuchsia
Operating system: Fuchsia
O-guix
Operating system: Guix, https://www.gnu.org/software/guix/
O-haiku
Target: Be extant; from mouldering old leaves; spring arrives again
O-hermit
Operating System: Hermit
O-hurd
Operating system: GNU/Hurd
O-illumos
the other shiny OS
O-ios
Operating system: iOS
O-itron
Operating System: ITRON
O-linux
Operating system: Linux
O-linux-gnu
Operating system: Linux with glibc (i.e. a bug that can't happen with musl)
O-loongarch
Target: LoongArch (LA32R, LA32S, LA64)
O-macos
Operating system: macOS
O-MIPS
Target: MIPS processors
O-motorola68k
Target: Rust from the parallel universe where the Amiga won.
O-msp430
O-musl
Target: The musl libc
O-netbsd
Operating system: NetBSD
O-neutrino
OS: QNX Neutrino, a POSIX-compatible real-time operating system
O-nintendo3ds
Target: ninTENdooooo
O-NixOS
Operating system: NixOS, https://nixos.org/
O-NVPTX
Target: the NVPTX LLVM backend for running rust on GPUs, https://llvm.org/docs/NVPTXUsage.html
O-openbsd
Operating system: OpenBSD
O-PowerPC
Target: PowerPC processors
O-redox
Operating system: Redox, https://www.redox-os.org/
O-riscv
Target: RISC-V architecture
O-SGX
Target: SGX
O-solaris
Operating system: Solaris
O-solid
Operating System: SOLID
O-SPARC
Target: SPARC processors
O-SystemZ
Target: SystemZ processors (s390x)
O-teeos
Target: Arm's secure enclave that code isn't supposed to be able to jailbreak
O-tvos
Operating system: tvOS (including simulator)
O-UEFI
UEFI
O-unix
Operating system: Unix-like
O-visionos
Apple visionOS
O-vxworks
Target: when they made us, they called us Curiosity, and Spirit, and told us to tell you hello
O-wasi
Operating system: Wasi, Webassembly System Interface
O-wasm
Target: WASM (WebAssembly), http://webassembly.org/
O-watchos
Operating System: watchOS
O-windows
Operating system: Windows
O-windows-7
OS: Windows 7 or Windows Server 2008 R2 or etc.
O-windows-gnu
Toolchain: GNU, Operating system: Windows
O-windows-msvc
Toolchain: MSVC, Operating system: Windows
O-x32
x32 ABI
O-x86_32
Target: x86 processors, 32 bit (like i686-*)
O-x86_64
Target: x86-64 processors (like x86_64-*)
O-xous
OS: A microkernel OS for privacy in computing
O-xtensa
P-critical
Critical priority
P-high
High priority
P-low
Low priority
P-medium
Medium priority
perf-regression
Performance regression.
perf-regression-triaged
The performance regression has been triaged.
PG-const-generics
Project group: Const generics
PG-const-traits
Project group: Const traits
PG-error-handling
Project group: Error handling (https://github.com/rust-lang/project-error-handling)
PG-exploit-mitigations
Project group: Exploit mitigations
PG-portable-simd
Project group: Portable SIMD (https://github.com/rust-lang/project-portable-simd)
proposed-final-comment-period
Proposed to merge/close by relevant subteam, see T-<team> label. Will enter FCP once signed off.
regression-from-stable-to-beta
Performance or correctness regression from stable to beta.
regression-from-stable-to-nightly
Performance or correctness regression from stable to nightly.
regression-from-stable-to-stable
Performance or correctness regression from one stable version to another.
regression-untriaged
Untriaged performance or correctness regression.
relnotes
Marks issues that should be documented in the release notes of the next release.
relnotes-perf
Performance improvements that should be mentioned in the release notes.
relnotes-tracking-issue
Marks issues tracking what text to put in release notes.
requires-custom-config
This issue requires custom config/build for rustc in some way
requires-debug-assertions
This issue requires a build of rustc or tooling with debug-assertions in some way
requires-incomplete-features
This issue requires the use of incomplete features.
requires-internal-features
This issue requires the use of internal features.
requires-nightly
This issue requires a nightly compiler in some way.
rla-silenced
Silences rust-log-analyzer postings to the PR it's added on.
rollup
A PR which is a rollup
rust-2-breakage-wishlist
In the wishlist of breaking changes that requires rust 2.0
S-blocked
Status: Blocked on something else such as an RFC or other implementation work.
S-bug-has-test
Status: This bug is tracked inside the repo by a `known-bug` test.
S-experimental
Status: Ongoing experiment that does not require reviewing and won't be merged in its current state.
S-has-bisection
Status: a bisection has been found for this issue
S-has-mcve
Status: A Minimal Complete and Verifiable Example has been found for this issue
S-inactive
Status: Inactive and waiting on the author. This is often applied to closed PRs.
S-needs-info
Status: The issue lacks details necessary to triage or act on it.
S-needs-repro
Status: This issue has no reproduction and needs a reproduction to make progress.
S-tracking-at-risk
Status: This item is at risk of missing e.g. edition deadlines.
S-tracking-blocked
Status: This tracking issue is blocked on another tracking issue
S-tracking-design-concerns
Status: There are blocking design concerns.
S-tracking-forever
Status: Never to be closed.
S-tracking-impl-incomplete
Status: The implementation is incomplete.
S-tracking-needs-deep-research
Status: This feature needs deep research to solve design or implementation issues.
S-tracking-needs-design-proposal
Status: This needs a clear design proposal and then a meeting with the team.
S-tracking-needs-documentation
Status: Needs documentation.
S-tracking-needs-migration-lint
Status: This item needs a migration lint.
S-tracking-needs-summary
Status: It's hard to tell what's been done and what hasn't! Someone should do some investigation.
S-tracking-needs-to-bake
Status: The implementation is "complete" but it needs time to bake.
S-tracking-perma-unstable
Status: The feature will stay unstable indefinitely.
S-tracking-ready-for-edition
Status: This issue is ready for inclusion in the edition.
S-tracking-ready-to-stabilize
Status: This is ready to stabilize; it may need a stabilization report and a PR
S-tracking-remove-implementation
Status: The feature needs to be removed from the Rust toolchain before this issue can be closed
S-tracking-unimplemented
Status: The feature has not been implemented.
S-triggers-future-incompat-lint
Status: This bug triggers a future-incompatibility lint
S-types-deferred
Status: Identified as a valid potential future enhancement that is not currently being worked on
S-types-tracked
Status: Being actively tracked by the types team
S-waiting-on-ACP
Status: PR has an ACP and is waiting for the ACP to complete.
S-waiting-on-author
Status: This is awaiting some action (such as code changes or more information) from the author.
S-waiting-on-bikeshed
Status: Awaiting a decision on trivial things.
S-waiting-on-bors
Status: Waiting on bors to run and complete tests. Bors will change the label on completion.
S-waiting-on-concerns
Status: Awaiting concerns to be addressed by the author
S-waiting-on-crater
Status: Waiting on a crater run to be completed.
S-waiting-on-fcp
Status: PR is in FCP and is awaiting for FCP to complete.
S-waiting-on-LLVM
Status: the compiler-dragon is eepy, can someone get it some tea?
S-waiting-on-MCP
Status: PR has a compiler MCP and is waiting for the compiler MCP to complete.
S-waiting-on-perf
Status: Waiting on a perf run to be completed.
S-waiting-on-review
Status: Awaiting review from the assignee but also interested parties.
S-waiting-on-team
Status: Awaiting decision from the relevant subteam (see the T-<team> label).
stable-accepted
Accepted for backporting to the compiler in the stable channel.
stable-nominated
Nominated for backporting to the compiler in the stable channel.
subtree-sync
PR updates a subtree (miri, clippy, etc). Ignored by no-merges check
T-bootstrap
Relevant to the bootstrap subteam: Rust's build system (x.py and src/bootstrap)
T-cargo
Relevant to the cargo team, which will review and decide on the PR/issue.
T-community
T-compiler
Relevant to the compiler team, which will review and decide on the PR/issue.
T-core
Relevant to the core team, which will review and decide on the PR/issue.
T-crates-io
Relevant to the crates.io team, which will review and decide on the PR/issue.
T-dev-tools
Relevant to the dev-tools subteam, which will review and decide on the PR/issue.
T-docs-rs
Relevant to the docs-rs subteam, which will review and decide on the PR/issue.
T-infra
Relevant to the infrastructure team, which will review and decide on the PR/issue.
T-lang
Relevant to the language team, which will review and decide on the PR/issue.
T-lang-docs
Relevant to the lang-docs team.
T-libs
Relevant to the library team, which will review and decide on the PR/issue.
T-libs-api
Relevant to the library API team, which will review and decide on the PR/issue.
T-opsem
Relevant to the opsem team
T-release
Relevant to the release subteam, which will review and decide on the PR/issue.
T-rustdoc
Relevant to the rustdoc team, which will review and decide on the PR/issue.
T-rustdoc-frontend
Relevant to the rustdoc-frontend team, which will review and decide on the web UI/UX output.
T-spec
Relevant to the spec team.
T-style
Relevant to the style team, which will review and decide on the PR/issue.
T-testing-devex
Relevant to the testing devex team (testing DX), which will review and decide on the PR/issue.
T-types
Relevant to the types team, which will review and decide on the PR/issue.
to-announce
Announce this issue on triage meeting
WG-async
Working group: Async & await
WG-compiler-parallel
Working group: Parallelizing the compiler
WG-compiler-performance
Working group: Compiler Performance
WG-const-eval
Working group: Const evaluation
WG-debugging
Working group: Bad Rust debugging experiences
WG-diagnostics
Working group: Diagnostics
WG-embedded
Working group: Embedded systems
WG-epoch
Working group: Epoch (2018) management
WG-ffi-unwind
Working group: FFI unwind
WG-incr-comp
Working group: Incremental compilation
WG-llvm
Working group: LLVM backend code generation
WG-macros
Working group: Macros
WG-mir-opt
Working group: MIR optimizations
WG-nll
Working group: Non-lexical lifetimes
WG-none
Indicates that no working group is assigned to an issue, but it *does* have an active owner
WG-trait-system-refactor
The Rustc Trait System Refactor Initiative (-Znext-solver)
WG-traits
Working group: Traits, https://internals.rust-lang.org/t/announcing-traits-working-group/6804
No labels found. Sorry about that.