Introduce the major change process for the compiler team. This process has the following goals:
The intent here is that if you have a plan to make some "major change" to the compiler, you will start with this process. It may either simply be approved, but if the change proves more controversial or complex, we may escalate towards design meetings, longer write-ups, or full RFCs before reaching a final decision.
This process does not apply to adding new language features, but it can be used for minor features such as adding new
-C flags to the compiler.
As the compiler grows in complexity, it becomes harder and harder to track what's going on. We don't currently have a clear channel for people to signal their intention to make "major changes" that may impact other developers in a lightweight way (and potentially receive feedback).
Our goal is to create a channel for signaling intentions that lies somewhere between opening a PR (and perhaps cc'ing others on that PR) and creating a compiler team design meeting proposal or RFC.
Our goals with the MCP are as follows:
If you would like to make a major change to the compiler, the process is as follows:
#t-compiler/major changeswill automatically be created for you by a bot.
rfcbot fcp mergecomment.
Some major change proposals will be conditionally accepted. This indicates that we'd like to see the work land, but we'd like to re-evaluate the decision of whether to commit to the design after we've had time to gain experience. We should try to be clear about the things we'd like to evaluate, and ideally a timeline.
Some proposals will not be accepted. Some of the possible reasons:
The PR should be closed or marked as blocked, with a request to create a major change proposal first.
If the PR description already contains suitable text that could serve as an MCP, then simply copy and paste that into an MCP issue. Using an issue consistently helps to ensure that the tooling and process works smoothly.
Of course! You are free to work on PRs or write code. But those PRs should be marked as experimental and they should not land, nor should anyone be expected to review them (unless folks want to).
Note that, in some cases, the change may be deemed too big and a full FCP or RFC may be required to move forward. This could occur with significant public facing change or with sufficiently large changes to the architecture. The compiler team leads can make this call.
Note that whether something is a major change proposal is not necessarily related to the number of lines of code that are affected. Renaming a method can affect a large number of lines, and even require edits to the rustc-dev-guide, but it may not be a major change. At the same time, changing names that are very broadly used could constitute a major change (for example, renaming from the
tcx context in the compiler to something else would be a major change).
The MCP "seconding" process is only meant to be used to get agreement
on the technical architecture we plan to use. It is not sufficient to
stabilize new features or make public-facing changes like adding a -C
flag. For that, an
rfcbot fcp is required (or perhaps an RFC, if the
change is large enough).
For landing compiler flags in particular, a good approach is to start
with an MCP introducing a
-Z flag and then "stabilize" the flag by
moving it to
-C in a PR later (which would require
Major change proposals are not sufficient for language changes or changes that affect cargo.
Please direct technical conversation to the Zulip stream.
The compiler-team repo issues are intended to be low traffic and used for procedural purposes. Note that to "second" a design or offer to review, you should be someone who is familiar with the code, typically but not necessarily a compiler team member or contributor.
These types of procedural comments can be left on the issue (it's also good to leave a message in Zulip). See the previous section.
Usually the experts in the given area will reach a consensus here. But if there is some need for a "tie breaker" vote or judgment call, the compiler-team leads make the final call.
Here are some examples of changes that were made in the past that would warrant the major change process:
-Cflag that exposes some minor variant
Here are some examples of changes that are too big for the major change process, or which at least would require auxiliary design meetings or a more fleshed out design before they can proceed:
Here are some examples of things that don't merit any MCP:
Major Change Proposals can be closed:
The template for major change proposals is as follows:
# What is this issue? This is a **major change proposal**, which means a proposal to make a notable change to the compiler -- one that either alters the architecture of some component, affects a lot of people, or makes a small but noticeable public change (e.g., adding a compiler flag). You can read more about the MCP process on https://forge.rust-lang.org/. **This issue is not meant to be used for technical discussion. There is a Zulip stream for that. Use this issue to leave procedural comments, such as volunteering to review, indicating that you second the proposal (or third, etc), or raising a concern that you would like to be addressed.** # MCP Checklist * [x] MCP **filed**. Automatically, as a result of filing this issue: * The @rust-lang/wg-prioritization group will add this to the triage meeting agenda so folks see it. * A Zulip topic in the stream `#t-compiler/major changes` will be created for this issue. * [ ] MCP **seconded**. The MCP is "seconded" when a compiler team member or contributor issues the `@rustbot second` command. This should only be done by someone knowledgable with the area -- before seconding, it may be a good idea to cc other stakeholders as well and get their opinion. * [ ] **Final comment period** (FCP). Once the MCP is approved, the FCP begins and lasts for 10 days. This is a time for other members to review and raise concerns -- **concerns that should block acceptance should be noted as comments on the thread**, ideally with a link to Zulip for further discussion. * [ ] MCP **Accepted**. At the end of the FCP, a compiler team lead will review the comments and discussion and decide whether to accept the MCP. * At this point, the `major-change-accepted` label is added and the issue is closed. You can link to it for future reference. **A note on stability.** If your change is proposing a new stable feature, such as a `-C flag`, then a full team checkoff will be required before the feature can be landed. Often it is better to start with an unstable flag, like a `-Z` flag, and then move to stabilize as a secondary step. # TL;DR *Summarize what you'd like to do in a sentence or two, or a few bullet points.* # Links and Details *Add a few paragraphs explaining your design. The level of detail should be sufficient for someone familiar with the compiler to understand what you're proposing. Where possible, linking to relevant issues, old PRs, or external documents like LLVM pages etc is very useful.* # Mentors or Reviewers *Who will review this work? If you are being mentored by someone, then list their name here. If you are a compiler team member/contributor, and you intend to mentor someone else, then you can put your own name here. You can also leave it blank if you are looking for a reviewer. (Multiple names are ok too.)*
It adds procedural overhead.
We opted not to require an ordinary rfcbot fcp because that feels too cumbersome. We want this to be lightweight. Requesting at least one person to approve seems like the minimal process.
The state of the art for these sorts of things in practice is that either people just write PRs, or perhaps someone opens a Zulip topic and pings a suitable set of people. This often works well in practice but can also lead to surprises, where stakeholders are overlooked. Moreover, it offers no means to manage review load or to have a chance to express concerns before a lot of code is written.
This idea was loosely based on the "intent to ship" convention that many browsers have adopted. See e.g. Mozilla's Exposure Guidelines or Chrome's process for launching features. Unlike those processes, however, it's meant for internal refactors as well as (minor) public facing features.
RFCs themselves are a form of "major change proposal", but they are much more heavyweight and suitable for longer conversations or more controversial decisions. They wind up requesting feedback from a broader audience and they require all team members to actively agree before being accepted. The MCP process is meant to be something we can use to float and advertise ideas and quickly either reach consensus or else -- if controversy is discovered -- move the proposal to a more involved process.
The details of this procedure are sure to evolve, and we don't expect to use the RFC process for each such evolution. The main focus of this RFC is to approve of a mandatory major change process for major changes to the compiler.