[codex] arm64e upstream PR integration validation

.github/workflows/arm64e-upstream-sync-prep.yml

@@ -0,0 +1,113 @@
+name: arm64e Upstream Sync Prep
+
+on:
+  workflow_dispatch:
+    inputs:
+      integration_branch:
+        description: CypherAir arm64e integration branch to inspect.
+        required: true
+        default: integration/arm64e-upstream-prs
+        type: string
+      upstream_ref:
+        description: Upstream Rust ref to merge in the dry-run workspace.
+        required: true
+        default: upstream/main
+        type: string
+      create_refresh_pr:
+        description: Push a refresh branch and open a draft PR when the dry-run merge succeeds.
+        required: true
+        default: false
+        type: boolean
+permissions:
+  contents: write
+  pull-requests: write
+  actions: write
+
+jobs:
+  sync-prep:
+    if: github.repository == 'cypherair/rust'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout fork
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Fetch upstream and integration refs
+        env:
+          INTEGRATION_BRANCH: ${{ inputs.integration_branch }}
+        run: |
+          set -euo pipefail
+          git remote add upstream https://github.com/rust-lang/rust.git 2>/dev/null || git remote set-url upstream https://github.com/rust-lang/rust.git
+          git fetch --prune origin \
+            "+refs/heads/${INTEGRATION_BRANCH}:refs/remotes/origin/${INTEGRATION_BRANCH}" \
+            +refs/heads/main:refs/remotes/origin/main
+          git fetch --prune upstream +refs/heads/main:refs/remotes/upstream/main
+
+      - name: Report branch posture
+        env:
+          INTEGRATION_BRANCH: ${{ inputs.integration_branch }}
+          UPSTREAM_REF: ${{ inputs.upstream_ref }}
+        run: |
+          set -euo pipefail
+          {
+            echo "## arm64e upstream sync prep"
+            echo
+            echo "- integration branch: \`${INTEGRATION_BRANCH}\`"
+            echo "- upstream ref: \`${UPSTREAM_REF}\`"
+            echo "- origin/main: \`$(git rev-parse refs/remotes/origin/main)\`"
+            echo "- upstream/main: \`$(git rev-parse refs/remotes/upstream/main)\`"
+            echo "- integration head: \`$(git rev-parse refs/remotes/origin/${INTEGRATION_BRANCH})\`"
+            echo "- origin/main...upstream/main: \`$(git rev-list --left-right --count refs/remotes/origin/main...refs/remotes/upstream/main)\`"
+            echo "- integration...upstream: \`$(git rev-list --left-right --count refs/remotes/origin/${INTEGRATION_BRANCH}...${UPSTREAM_REF})\`"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Dry-run merge upstream into integration branch
+        id: dry_run
+        env:
+          INTEGRATION_BRANCH: ${{ inputs.integration_branch }}
+          UPSTREAM_REF: ${{ inputs.upstream_ref }}
+        run: |
+          set -euo pipefail
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git checkout -B arm64e-sync-dry-run "refs/remotes/origin/${INTEGRATION_BRANCH}"
+          if git merge --no-ff --no-commit "$UPSTREAM_REF"; then
+            echo "merge_ok=true" >> "$GITHUB_OUTPUT"
+            git diff --stat --cached || true
+            git merge --abort || true
+          else
+            echo "merge_ok=false" >> "$GITHUB_OUTPUT"
+            git status --short
+            exit 1
+          fi
+
+      - name: Create refresh branch and draft PR
+        id: refresh
+        if: ${{ inputs.create_refresh_pr && steps.dry_run.outputs.merge_ok == 'true' }}
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          INTEGRATION_BRANCH: ${{ inputs.integration_branch }}
+          UPSTREAM_REF: ${{ inputs.upstream_ref }}
+        run: |
+          set -euo pipefail
+          SHORT_SHA="$(git rev-parse --short=7 "refs/remotes/origin/${INTEGRATION_BRANCH}")"
+          REFRESH_BRANCH="automation/arm64e-refresh-$(date -u +"%Y%m%dT%H%M%SZ")-${SHORT_SHA}"
+
+          git checkout -B "$REFRESH_BRANCH" "refs/remotes/origin/${INTEGRATION_BRANCH}"
+          git merge --no-ff "$UPSTREAM_REF" -m "Merge ${UPSTREAM_REF} into ${INTEGRATION_BRANCH}"
+          git push origin "HEAD:refs/heads/${REFRESH_BRANCH}"
+
+          gh pr create \
+            --repo "$GITHUB_REPOSITORY" \
+            --base "$INTEGRATION_BRANCH" \
+            --head "$REFRESH_BRANCH" \
+            --title "[automation] Refresh arm64e integration branch from ${UPSTREAM_REF}" \
+            --body "Automated dry-run refresh branch for CypherAir arm64e Rust integration. This PR intentionally targets the integration branch and does not force-push it." \
+            --draft
+
+          echo "REFRESH_BRANCH=$REFRESH_BRANCH" >> "$GITHUB_ENV"
+          echo "branch=$REFRESH_BRANCH" >> "$GITHUB_OUTPUT"

.github/workflows/fork-arm64e.yml

@@ -0,0 +1,64 @@
+name: Fork arm64e validation
+
+# Fork-only CypherAir validation. Drop this workflow before proposing the
+# upstreamable arm64e prep patches to rust-lang/rust.
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - integration/arm64e-upstream-prs
+  pull_request:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+concurrency:
+  group: fork-arm64e-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  prep:
+    if: github.repository == 'cypherair/rust'
+    name: arm64e prep validation
+    runs-on: macos-15
+    timeout-minutes: 180
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 2
+          submodules: recursive
+
+      # CypherAir fork push runs reproduced a shallow-clone case where bootstrap could not
+      # safely treat HEAD^1 as the upstream nightly base commit. Keep this in sync with src/stage0.
+      - name: Fetch nightly base ref
+        run: |
+          git fetch --no-tags --prune --depth=1 origin \
+            +refs/heads/main:refs/remotes/origin/main
+
+      - name: Show environment
+        run: |
+          sw_vers
+          uname -a
+          git show -s --format='HEAD: %H %P %ae %s' HEAD
+          git show -s --format='origin/main: %H %P %ae %s' refs/remotes/origin/main
+          python3 --version
+
+      - name: Check metadata codegen crate
+        run: |
+          python3 x.py check compiler/rustc_codegen_ssa --stage 1
+
+      - name: Run Mach-O metadata subtype test
+        run: |
+          python3 x.py test --stage 1 --force-rerun \
+            tests/run-make/arm64e-macho-metadata-subtype
+
+      - name: Run bootstrap tests
+        run: |
+          python3 x.py test src/bootstrap --stage 1

.gitmodules

@@ -25,7 +25,7 @@
 [submodule "src/llvm-project"]
 	path = src/llvm-project
 	url = https://github.com/rust-lang/llvm-project.git
-	branch = rustc/22.1-2026-01-27
+	branch = rustc/22.1-2026-03-22
 	shallow = true
 [submodule "src/doc/embedded-book"]
 	path = src/doc/embedded-book

compiler/rustc_ast_lowering/src/asm.rs

@@ -18,11 +18,9 @@ use super::errors::{
     InvalidRegisterClass, RegisterClassOnlyClobber, RegisterClassOnlyClobberStable,
     RegisterConflict,
 };
-use crate::{
-    AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt,
-};
+use crate::{AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode};
 
-impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(crate) fn lower_inline_asm(
         &mut self,
         sp: Span,
@@ -203,7 +201,6 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                     },
                     InlineAsmOperand::Sym { sym } => {
                         let static_def_id = self
-                            .resolver
                             .get_partial_res(sym.id)
                             .and_then(|res| res.full_res())
                             .and_then(|res| match res {

compiler/rustc_ast_lowering/src/block.rs

@@ -4,9 +4,9 @@ use rustc_hir::Target;
 use rustc_span::sym;
 use smallvec::SmallVec;
 
-use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext, ResolverAstLoweringExt};
+use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
 
-impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_block(
         &mut self,
         b: &Block,

compiler/rustc_ast_lowering/src/contract.rs

@@ -2,9 +2,9 @@ use std::sync::Arc;
 
 use thin_vec::thin_vec;
 
-use crate::{LoweringContext, ResolverAstLoweringExt};
+use crate::LoweringContext;
 
-impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
+impl<'hir> LoweringContext<'_, 'hir> {
     /// Lowered contracts are guarded with the `contract_checks` compiler flag,
     /// i.e. the flag turns into a boolean guard in the lowered HIR. The reason
     /// for not eliminating the contract code entirely when the `contract_checks`

compiler/rustc_ast_lowering/src/delegation.rs

@@ -39,7 +39,7 @@
 use std::iter;
 
 use ast::visit::Visitor;
-use hir::def::{DefKind, PartialRes, Res};
+use hir::def::{DefKind, Res};
 use hir::{BodyId, HirId};
 use rustc_abi::ExternAbi;
 use rustc_ast as ast;
@@ -105,7 +105,7 @@ static ATTRS_ADDITIONS: &[AttrAdditionInfo] = &[
     },
 ];
 
-impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
@@ -266,7 +266,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     }
 
     fn get_resolution_id(&self, node_id: NodeId) -> Option<DefId> {
-        self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id())
+        self.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id())
     }
 
     // Function parameter count, including C variadic `...` if present.
@@ -417,7 +417,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                     && idx == 0
                 {
                     let mut self_resolver = SelfResolver {
-                        resolver: this.resolver,
+                        ctxt: this,
                         path_id: delegation.id,
                         self_param_id: pat_node_id,
                     };
@@ -508,7 +508,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
 
             // FIXME(fn_delegation): proper support for parent generics propagation
             // in method call scenario.
-            let segment = self.process_segment(span, &segment, &mut generics.child, false);
+            let segment = self.process_segment(span, &segment, &mut generics.child);
             let segment = self.arena.alloc(segment);
 
             self.arena.alloc(hir::Expr {
@@ -534,14 +534,10 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
 
                     new_path.segments = self.arena.alloc_from_iter(
                         new_path.segments.iter().enumerate().map(|(idx, segment)| {
-                            let mut process_segment = |result, add_lifetimes| {
-                                self.process_segment(span, segment, result, add_lifetimes)
-                            };
-
                             if idx + 2 == len {
-                                process_segment(&mut generics.parent, true)
+                                self.process_segment(span, segment, &mut generics.parent)
                             } else if idx + 1 == len {
-                                process_segment(&mut generics.child, false)
+                                self.process_segment(span, segment, &mut generics.child)
                             } else {
                                 segment.clone()
                             }
@@ -551,7 +547,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                     hir::QPath::Resolved(ty, self.arena.alloc(new_path))
                 }
                 hir::QPath::TypeRelative(ty, segment) => {
-                    let segment = self.process_segment(span, segment, &mut generics.child, false);
+                    let segment = self.process_segment(span, segment, &mut generics.child);
 
                     hir::QPath::TypeRelative(ty, self.arena.alloc(segment))
                 }
@@ -584,13 +580,12 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
         span: Span,
         segment: &hir::PathSegment<'hir>,
         result: &mut GenericsGenerationResult<'hir>,
-        add_lifetimes: bool,
     ) -> hir::PathSegment<'hir> {
         let details = result.generics.args_propagation_details();
 
         let segment = if details.should_propagate {
             let generics = result.generics.into_hir_generics(self, span);
-            let args = generics.into_generic_args(self, add_lifetimes, span);
+            let args = generics.into_generic_args(self, span);
 
             // Needed for better error messages (`trait-impl-wrong-args-count.rs` test).
             let args = if args.is_empty() { None } else { Some(args) };
@@ -670,25 +665,24 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     }
 }
 
-struct SelfResolver<'a, R> {
-    resolver: &'a mut R,
+struct SelfResolver<'a, 'b, 'hir> {
+    ctxt: &'a mut LoweringContext<'b, 'hir>,
     path_id: NodeId,
     self_param_id: NodeId,
 }
 
-impl<'tcx, R: ResolverAstLoweringExt<'tcx>> SelfResolver<'_, R> {
+impl SelfResolver<'_, '_, '_> {
     fn try_replace_id(&mut self, id: NodeId) {
-        if let Some(res) = self.resolver.get_partial_res(id)
+        if let Some(res) = self.ctxt.get_partial_res(id)
             && let Some(Res::Local(sig_id)) = res.full_res()
             && sig_id == self.path_id
         {
-            let new_res = PartialRes::new(Res::Local(self.self_param_id));
-            self.resolver.insert_partial_res(id, new_res);
+            self.ctxt.partial_res_overrides.insert(id, self.self_param_id);
         }
     }
 }
 
-impl<'ast, 'tcx, R: ResolverAstLoweringExt<'tcx>> Visitor<'ast> for SelfResolver<'_, R> {
+impl<'ast> Visitor<'ast> for SelfResolver<'_, '_, '_> {
     fn visit_id(&mut self, id: NodeId) {
         self.try_replace_id(id);
     }