-
Notifications
You must be signed in to change notification settings - Fork 1
Where's my Commit?
Frequently, issues will be fixed in repositories other than flutter/flutter
. When this happens, it's common to want to know when the fix will be available in the framework.
Other times, issues will be root-caused to a particular commit, and it's common to want to know which Flutter versions are afflicted by the issue.
This page outlines the current process for determining that information.
To find out which Dart SDK sha is contained in a particular commit of the Flutter engine:
-
Let the engine commit be ENGINE_COMMIT
-
Navigate to https://github.com/flutter/engine/blob/${ENGINE_COMMIT}/DEPS#L37 and search for the value corresponding to the 'dart_revision' key.
To find the published Flutter versions that contain any given commit in flutter/flutter
:
-
Navigate to the page for that commit. You can do this by either clicking on the commit from https://github.com/flutter/flutter/commits, or by constructing the URL manually. The URL format is
https://github.com/flutter/flutter/commit/<sha>
. -
Look in the lower left corner of the commit description box for a list of version tags. For example:
The list of versions here is comprehensive (it lists every individual version that contains the commit).
If there are no versions listed there, it means that this commit has not yet been published to the dev channel and exists only on master.
If there are too many version tags to display cleanly, GitHub hides them behind an ellipsis. For example:
Clicking on that ellipsis will expand the list out to show all version tags that contain the commit. For example:
To find out when a given engine change rolled into the framework:
-
Find the engine PR that corresponds to your desired commit. For example, for commit 7292d47, the corresponding PR is flutter/engine#11206.
If the commit in question does not have a corresponding PR (most commonly seen with Dart rolls), then use the newest commit before your desired engine commit that has a corresponding PR as a proxy.
Once you've identified an engine PR, navigate to that PR.
-
Somewhere in the comment stream for the PR (usually at or near the bottom), there will be a cross-referenced "Roll engine <commit>..<commit>" link with a "Merged" badge to the right of it. For example:
That was the PR in which this engine commit merged into the framework. Click on that link.
-
Near the bottom of the comment stream for the framework PR will be a line that says:
"<user> merged commit <commit>"
Usually, the user will be "engine-flutter-autoroll". Click on the commit sha to navigate to the commit.
-
The full commit sha is contained in the URL. It's also listed on the page:
-
To find the published Flutter versions that contain this commit, follow the process above for "Finding the versions that contain Framework commit X".
To find out when a given Dart SDK change rolled into the engine:
-
If you're starting from the Dart review CL (e.g. https://dart-review.googlesource.com/c/sdk/+/113126), wait until the CL has merged. You can see the status of a CL in the upper left corner of the page. For example:
-
The merged badge then hyperlinks to the commit where it was merged. The text says "Merged as <commit>", and the commit sha is a hyperlink. Click on that link.
-
The commit page gives you the full sha of the Dart SDK commit. For example:
-
Note the time (and the timezone!) that the commit landed. For example:
-
Navigate to https://github.com/flutter/engine/commits, and look for commits that landed shortly after the timestamp in question, where the commit description is "Roll src/third_party/dart ...". These commits are "Dart SDK roll" commits.
For each commit, GitHub says "<author> committed <time reference>" (e.g. "skia-flutter-autoroll committed 8 hours ago"). If you hover over the time reference, a tooltip shows you the exact commit time.
Important: be sure to adjust for timezones when comparing times between the Dart SDK commit and the time when the engine commits landed.
-
Once you've found a candidate commit, click on the hyperlink of the commit description to go to the commit details page. The full commit description will list what Dart SDK comitts were contained in the roll. For example:
-
Keep searching newer Dart SDK roll commits until you find the roll that contains your desired Dart SDK commit. This roll commit is the engine commit that contains your Dart SDK change.
-
To find out when this engine commit landed in the framework, follow the process above for "Finding the Framework commit that contains Engine commit X".
To find out when a given Skia commit rolled into the engine, follow the same process as above for "Finding the Engine commit that contains Dart SDK commit X", with the following differences:
-
The review CLs will have URLs of the form
https://skia-review.googlesource.com/c/skia/+/<cl_number>
instead ofhttps://dart-review.googlesource.com/c/sdk/+/<cl_number>
. -
The roll commits will start with "Roll src/third_party/skia ..." instead of "Roll src/third_party/dart ...".
- Home of the Wiki
- Roadmap
- API Reference (stable)
- API Reference (master)
- Glossary
- Contributor Guide
- Chat on Discord
- Code of Conduct
- Issue triage reports
- Our Values
- Tree hygiene
- Issue hygiene and Triage
- Style guide for Flutter repo
- Project teams
- Contributor access
- What should I work on?
- Running and writing tests
- Release process
- Rolling Dart
- Manual Engine Roll with Breaking Commits
- Updating Material Design Fonts & Icons
- Postmortems
- Setting up the Framework development environment
- The Framework architecture
- The flutter tool
- API Docs code block generation
- Running examples
- Using the Dart analyzer
- The flutter run variants
- Test coverage for package:flutter
- Writing a golden-file test for package:flutter
- Setting up the Engine development environment
- Compiling the engine
- Debugging the engine
- Using Sanitizers with the Flutter Engine
- Testing the engine
- The Engine architecture
- Flutter's modes
- Engine disk footprint
- Comparing AOT Snapshot Sizes
- Custom Flutter engine embedders
- Custom Flutter Engine Embedding in AOT Mode
- Flutter engine operation in AOT Mode
- Engine-specific Service Protocol extensions
- Crashes
- Supporting legacy platforms
- Metal on iOS FAQ
- Engine Clang Tidy Linter
- Why we have a separate engine repo
- Reduce Flutter engine size with MLGO
- Setting up the Plugins development environment
- Setting up the Packages development environment
- Plugins and Packages repository structure
- Plugin Tests
- Contributing to Plugins and Packages
- Releasing a Plugin or Package
- Unexpected Plugins and Packages failures