Area: lifetime related

Area: Custom and system allocators

A-associated-items

Area: Associated items such as associated types and consts.

Area: Async & Await

Area: #[attributes(..)]

A-borrow-checker

Area: The borrow checker

Area: `do catch { .. }` expressions

Area: closures (`|args| { .. }`)

A-code-coverage

Area: Source-based code coverage (-Zinstrument-coverage)

Area: Code generation

Area: implicit and explicit `expr as Type` coercions

Area: std::collections.

Area: Concurrency related issues.

Area: constant evaluation (mir interpretation)

Area: const fn foo(..) {..}. Pure functions which can be applied at compile time.

A-const-generics

Area: const generics (parameters and arguments)

A-contributor-roadblock

Area: Makes things more difficult for new contributors to rust itself

Area: Relating to control flow

Things relevant to the [future] cranelift backend

A-cross-crate-reexports

Area: Documentation that has been re-exported from a different crate

Area: Cross compilation

Area: Debugging information in compiled programs (DWARF, PDB, etc.)

Area: destructors (Drop, ..)

Area: Messages for errors, warnings, and lints

Area: #[doc(alias)]

Area: Calculating how much of a crate has documentation

Area: Documentation tests, run by rustdoc

Area: rustc_driver that ties everything together into the `rustc` compiler

Area: Dynamically Sized Types

A-edition-2018-lints

Area: lints supporting the 2018 edition

Area: The 2021 edition

Area: Explanation of an error code (--explain)

A-error-handling

Area: Error handling

A-exhaustiveness-checking

Relating to exhaustiveness / usefulness checking of patterns

Area: Foreign Function Interface (FFI)

A-floating-point

Area: Floating point numbers and arithmetic

Area: frontend (errors, parsing and HIR)

Area: Generators

A-github-actions

Area: The grammar of Rust

Relating to the HAIR IR.

Area: the High level Intermediate Representation (HIR)

Area: impl Trait. Universally / existentially quantified anonymous types with static dispatch.

Area: Incremental compilation

Area: Type inference

A-inline-assembly

Area: inline asm!(..)

A-intra-doc-links

Area: Intra-doc links, the ability to link to items in docs by name

Area: intrinsics

Area: std::io, std::fs and std::net

Area: Iterators

Area: lang items

Area: Memory layout of types

A-lazy-normalization

Area: lazy normalization (tracking issue: #60471)

Area: #[test] related

Area: linking into static, shared libraries and binaries

Area: Lints (warnings about flaws in source code) such as unused_mut.

Area: Code generation parts specific to LLVM. Both correctness bugs and optimization-related issues.

Area: Link Time Optimization

Issues which affect macros 1.2

Area: declarative macros 2.0, https://github.com/rust-lang/rust/issues/39412

Area: All kinds of macros (custom derive, macro_rules!, proc macros, ..)

A-markdown-parsing

Area: Markdown parsing for doc-comments

Area: Issues about the rust-lang/rust repository.

Area: crate metadata

A-mir-opt-inlining

Area: MIR inlining

Area: MIR optimizations

Area: MIR validator (-Z validate-mir)

Area: Mid-level IR (MIR) - https://blog.rust-lang.org/2016/04/19/MIR.html

Area: The miri tool

Area: #[naked], prologue and epilogue-free, functions, https://git.io/vAzzS

Area: Non Lexical Lifetimes (NLL)

A-parallel-queries

Area: Parallel query execution

Area: The parsing of Rust source code to an AST.

Relating to patterns and pattern matching

Area: compiler plugins, doc.rust-lang.org/nightly/unstable-book/language-features/plugin.html

A-polymorphization

Area: Polymorphization

Area: Pretty printing.

A-proc-macro-back-compat

Area: Backwards compatibility hacks for proc macros -s

Area: Procedural macros

Area: The rustc query system (https://rustc-dev-guide.rust-lang.org/query.html)

Area: raw pointers, MaybeUninit, NonNull

A-reproducibility

Area: Reproducible / Deterministic builds

Area: Path resolution

A-result-option

Area: Result and Option combinators

Area: Rust Language Server (RLS)

Area: The standard library's runtime (backtraces, unwinding, stack overflow detection)

A-rust-2018-preview

Area: The 2018 edition preview

Area: Rust's build system (x.py and bootstrap)

Area: Rustdoc's front-end

Area: Rustdoc JSON backend

A-rustdoc-search

Area: Rustdoc's search feature

A-rustdoc-themes

Area: themes for HTML pages generated by rustdoc

Area: rustdoc UI (generated HTML)

Area: Sanitizers for correctness and code quality.

A-save-analysis

Area: saving results of analyses such as inference and borrowck results to a file.

Area: Security related issues (example: adress space layout randomization)

Area: Self-profiling feature of the compiler

Area: SIMD (Single Instruction Multiple Data)

A-slice-patterns

Area: slice patterns, https://github.com/rust-lang/rust/issues/23121

A-specialization

Area: Trait impl specialization

Area: Spurious failures in builds (spuriously == for no apparent reason)

Area: issues related to #[stable] and #[unstable] attributes themselves.

Area: str and String

A-suggestion-diagnostics

Area: suggestions generated by the compiler applied by cargo fix

Area: Syntax extensions

A-synthetic-impls

Area: Synthetic impls, used by rustdoc to document auto traits and traits with blanket impls

Area: compile-target specifications

Area: The testsuite used to check the correctness of rustc

A-thread-locals

Area: Thread local storage (TLS)

Area: Trait system

A-type-based-search

Area: searching rustdoc pages using type signatures

Area: The type system

Area: unicode related

Things about value trees or fixed by value trees

Area: visibility/privacy modifiers such as `pub`

Area: Zero-sized types

Started on the 1st of April

AsyncAwait-Focus

Async-await issues presently being focused on.

AsyncAwait-OnDeck

Async-await issues prioritized as possible next focus items

AsyncAwait-Triaged

Async-await issues that have been triaged during a working group meeting.

Approved by a merged RFC but not yet implemented.

B-RFC-implemented

Approved by a merged RFC and implemented.

Implemented in the nightly compiler and unstable.

Accepted for backporting to the compiler in the beta channel.

Nominated for backporting to the compiler in the beta channel.

Category: This is a bug.

Category: PRs that clean code up or issues documenting cleanup.

Category: Discussion or questions that doesn't represent real issues.

Category: An issue proposing an enhancement or a PR with one.

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-compatibility

Category: future compatibility lints

C-tracking-issue

Category: A tracking issue for an RFC or an unstable feature.

chalk-integration

Issues blocking "preliminary chalk integration" milestone

const-generics-bad-diagnostics

An error is correctly emitted, but is confusing, for `min_const_generics`.

const-generics-blocking

An issue blocking the stabilisation of `min_const_generics`

const-generics-fixed-by-const_generics

A bug that has been fixed once `const_generics` is enabled.

const-generics-fixed-by-min_const_generics

A bug that has been fixed once `min_const_generics` is enabled.

This PR introduced a hack to make things valid in `const fn`.

Confusing diagnostic error that should be reworked

D-crate-version-mismatch

Errors caused be the use of two different crate versions.

Diagnostic error that should account for edition differences

Inconsistency in formatting, grammar or style between diagnostic messages

A diagnostic that is giving misleading or incorrect information

D-invalid-suggestion

A structured suggestion resulting in incorrect code

D-newcomer-roadblock

Confusing diagnostic error hard to understand for new users

Diagnostic error that needs small tweaks

A diagnostic that doesn't give enough information about the problem at hand

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

Call for participation: Experience needed to fix: Easy / not much

Call for participation: Experience needed to fix: Hard / a lot

Call for participation: Help is requested to fix this issue.

Call for participation: Experience needed to fix: Medium / intermediate

Call for participation: This issue is currently mentored.

E-needs-bisection

Call for participation: This issue needs a bisection to find the exact PR causing the regression

Call for participation: This issue needs a Minimal Complete and Verifiable Example

Call for participation: This issue is in need of a mentor.

Call for participation: writing correctness tests

F-abi_c_cmse_nonsecure_call

`#![feature(abi_c_cmse_nonsecure_call)]`

F-arbitrary_self_types

`#![feature(arbitrary_self_types)]`

`#![feature(asm)]` (not `llvm_asm`)

F-associated_type_bounds

`#![feature(associated_type_bounds)]`

F-associated_type_defaults

`#![feature(associated_type_defaults)]`

`#![feature(async_await)]`

F-async_closures

`#![feature(async_closures)]`

`#![feature(auto_traits)]`

F-bindings_after_at

`#![feature(bindings_after_at)]`

`#![feature(c_unwind)]`

`#![feature(c_variadic)]`

F-cfg_accessible

`#![feature(cfg_accessible)]`

`#![feature(cfg_version)]`

F-cmse_nonsecure_entry

`#![feature(cmse_nonsecure_entry)]`

F-coerce_unsized

The `CoerceUnsized` trait

F-const_async_blocks

`#![feature(const_async_blocks)]`

F-const_evaluatable_checked

`#![feature(const_evaluatable_checked)]`

F-const_extern_fn

`#![feature(const_extern_fn)]`

`#![feature(const_fn)]`

F-const_generics_defaults

`#![feature(const_generics_defaults)]`

F-const_generics

`#![feature(const_generics)]`

F-const_if_match

`#![feature(const_if_match)]`

F-const_in_array_repeat_expressions

`#[feature(const_in_array_repeat_expressions)]`

`#![feature(const_loop)]`

F-const_mut_refs

`#![feature(const_mut_refs)]`

F-const_trait_bound_opt_out

`#![feature(const_trait_bound_opt_out)]`

F-const_trait_impl

`#![feature(const_trait_impl)]`

F-custom_test_frameworks

`#![feature(custom_test_frameworks)]`

`#![feature(decl_macro)]`

F-destructuring_assignment

`#![feature(destructuring_assignment)]`

F-dispatch_from_dyn

`#![feature(dispatch_from_dyn)]`

`#![feature(doc_cfg)]`

F-dropck_eyepatch

`#![feature(dropck_eyepatch)]`

F-exclusive_range_pattern

`#![feature(exclusive_range_pattern)]`

F-extended_key_value_attributes

`#![feature(extended_key_value_attributes)]

`#![feature(extern_types)]`

`#![feature(external_doc)]`

F-fixed-by-type_alias_impl_trait

The issue can be fixed with type_alias_impl_trait

F-format_implicit_args

implicit arguments for format strings (RFC 2795)

`#![feature(generators)]`

F-generic_associated_types

`#![feature(generic_associated_types)]`

F-half_open_range_patterns

`#![feature(half_open_range_patterns)]`

`#![feature(if_let_guard)]`

F-impl_trait_in_bindings

`#![feature(impl_trait_in_bindings)]`

F-inherent_associated_types

`#![feature(inherent_associated_types)]`

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_normalization_consts

`#![feature(lazy_normalization_consts)]`

`#![feature(let_chains)]`

F-macro-metavar-expr

feature(macro_metavar_expr)

F-marker_trait_attr

`#![feature(marker_trait_attr)]`

F-member_constraints

`#[feature(member_constraints)]`

F-min_const_generics

Minimal const generics MVP

F-move_ref_pattern

`#![feature(move_ref_pattern)]`

F-negative_impls

#![feature(negative_impls)]

`#![feature(never_type)]`

F-non_ascii_idents

`#![feature(non_ascii_idents)]`

F-non_exhaustive

`#![feature(non_exhaustive)]`

F-object_safe_for_dispatch

`#![feature(object_safe_for_dispatch)]`

F-on_unimplemented

Error messages that can be tackled with `#[rustc_on_unimplemented]`

`#![feature(or_patterns)]`

`#![feature(param_attrs)]`

F-pub_macro_rules

`#![feature(pub_macro_rules)]`

`#![feature(raw_dylib)]`

`#![feature(raw_ref_op)]`

F-re_rebalance_coherence

`#![feature(re_rebalance_coherence)]`

F-reserved_prefixes

`#![feature(reserved_prefixes)]`

Internal rustc attributes gated on the `#[rustc_attrs]` feature gate.

`#![feature(simd_ffi)]`

F-slice_patterns

`#![feature(slice_patterns)]`

F-specialization

`#![feature(specialization)]`

F-target_feature_11

target feature 1.1 RFC

`#![feature(thread_local)]`

`#![feature(track_caller)]`

`#![feature(trait_alias)]`

F-trait_upcasting

`#![feature(trait_upcasting)]`

`#![feature(try_blocks)]`

Tracking issue for RFC#3058

F-type_alias_impl_trait

`#[feature(type_alias_impl_trait)]`

F-type_ascription

`#![feature(type_ascription)]`

F-unboxed_closures

`#![feature(unboxed_closures)]`

F-unsafe-block-in-unsafe-fn

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)]

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.

ICE tracked in rust-lang/glacier

hacktoberfest projects - https://hacktoberfest.digitalocean.com/

Problems and improvements with respect to memory usage during compilation.

Problems and improvements with respect to compile times.

Issue: The compiler crashes (SIGSEGV, SIGABRT, etc). Use I-ICE instead when the compiler panics.

Issue: The compiler never terminates, due to infinite loops, deadlock, livelock, etc.

Problems and improvements with respect to binary size of generated code.

Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️

I-monomorphization

Issue: An error at monomorphization time

I-needs-decision

Issues in need of decision.

Indicates that an issue has been nominated for discussion during a team meeting.

Indicates that prioritization has been requested for this issue

Problems and improvements with respect to performance of generated code.

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

The issue is invalid and has been raised in error.

lang-team-202x-edition

Something we may consider if we do another edition

Libs issues that are considered "small" or self-contained

Libs issues that are tracked on the team's project board.

This PR was explicitly merged by bors

Issues about issues themselves ("bugs about bugs")

This change is insta-stable, so needs a completed FCP to proceed.

This change is large or controversial enough that it should have an (e-)RFC accepted before doing it

Working towards the "valid code works" goal

NLL-diagnostics

Working torwads the "diagnostic parity" goal

NLL-fixed-by-NLL

Bugs fixed, but only when NLL is enabled.

Working towards the "performance is good" goal

Issues related for using Polonius in the borrow checker

Reference material for NLL

Working towards the "invalid code does not compile" goal

Operating system: Android

Target: ARM processors (arm, thumb and AArch64 targets)

Target: asm.js - http://asmjs.org/

Target: AVR processors (ATtiny, ATmega, etc.)

Operating system: DragonFly BSD

Operating system: FreeBSD

Operating system: Fuchsia

Operating system: Guix, https://www.gnu.org/software/guix/

Operating system: iOS

Operating system: Linux

Operating system: macOS

Target: MIPS processors

Target: The musl libc

Operating system: NetBSD

Operating system: NixOS, https://nixos.org/

Target: the NVPTX LLVM backend for running rust on GPUs, https://llvm.org/docs/NVPTXUsage.html

Operating system: OpenBSD

Target: PowerPC processors

Operating system: Redox, https://www.redox-os.org/

Target: RISC-V architecture

Operating system: Solaris

Target: SPARC processors

Target: SystemZ processors (s390x)

Operating system: Unix-like

Target: WASM (WebAssembly), http://webassembly.org/

Toolchain: GNU, Operating system: Windows

Toolchain: MSVC, Operating system: Windows

Operating system: Windows

Target: x86 processors

Target: x64 processors

Critical priority

Medium priority

PG-error-handling

Project Group: Error handling (https://github.com/rust-lang/project-error-handling)

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.

Performance improvements that should be mentioned in the release notes

Marks issues that should be documented in the release notes of the next release.

requires-nightly

This issue requires a nightly compiler in some way.

A PR which is a rollup

rust-2-breakage-wishlist

In the wishlist of breaking changes that requires rust 2.0

Status: marked as blocked ❌ on something else such as an RFC or other implementation work.

Status: Experimental PR that will not be merged and does not require reviewing.

Status: Inactive and waiting on the author. This is often applied to closed PRs.

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-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-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.

Relevant to the cargo team, which will review and decide on the PR/issue.

Relevant to the compiler team, which will review and decide on the PR/issue.

Relevant to the core team, which will review and decide on the PR/issue.

Relevant to the crates.io team, which will review and decide on the PR/issue.

Relevant to the dev-tools subteam, which will review and decide on the PR/issue.

Relevant to the documentation subteam, which will review and decide on the PR/issue.

Relevant to the docs-rs subteam, which will review and decide on the PR/issue.

Relevant to the infrastructure team, which will review and decide on the PR/issue.

Relevant to the language team, which will review and decide on the PR/issue.

All implementation that underlies the public API of the Rust standard libraries

Relevant to the libraries team, which will review and decide on the PR/issue.

Relevant to the release subteam, which will review and decide on the PR/issue.

Decisions relevant to the rustdoc team. Use A-rustdoc as well

Announce this issue on triage meeting

Working Group: Codegen (Runtime perf and code size)

WG-compiler-front

Working group: front end (Parser, HIR)

WG-compiler-middle

Working group: Middle end; Everything between frontend (parser, HIR) and backend (trans, llvm)

WG-compiler-parallel

Working group working on parallelizing the compiler

WG-compiler-performance

Working group: Compiler Performance

WG-compiler-traits

Working group: Traits, https://internals.rust-lang.org/t/announcing-traits-working-group/6804

Working group: diagnostics

Of interest to the embedded Working Group

Working group: Epoch (2018) management

Working group: incremental compilation

Working group: parser librarification

No labels found. Sorry about that.