Toolchain upgrade to nightly-2025-10-31

crates/flux-driver/src/collector/detached_specs.rs

@@ -114,12 +114,11 @@ impl TraitImplResolver {
         for (trait_id, impl_ids) in tcx.all_local_trait_impls(()) {
             let trait_ = LookupRes::DefId(*trait_id);
             for impl_id in impl_ids {
-                if let Some(poly_trait_ref) = tcx.impl_trait_ref(*impl_id) {
-                    let self_ty = poly_trait_ref.instantiate_identity().self_ty();
-                    let self_ty = LookupRes::new(&self_ty);
-                    let key = TraitImplKey { trait_, self_ty };
-                    items.insert(key, *impl_id);
-                }
+                let poly_trait_ref = tcx.impl_trait_ref(*impl_id);
+                let self_ty = poly_trait_ref.instantiate_identity().self_ty();
+                let self_ty = LookupRes::new(&self_ty);
+                let key = TraitImplKey { trait_, self_ty };
+                items.insert(key, *impl_id);
             }
         }
         Self { items }

crates/flux-driver/src/collector/extern_specs.rs

@@ -315,7 +315,7 @@ impl<'a, 'sess, 'tcx> ExternSpecCollector<'a, 'sess, 'tcx> {
             } else {
                 let opt_extern_impl_id = self.tcx().impl_of_assoc(callee_id);
                 if let Some(extern_impl_id) = opt_extern_impl_id {
-                    debug_assert!(self.tcx().trait_id_of_impl(extern_impl_id).is_none());
+                    debug_assert!(!self.tcx().impl_is_of_trait(extern_impl_id));
                     Ok(ExternImplItem { impl_id: extern_impl_id, item_id: callee_id })
                 } else {
                     Err(self.invalid_item_in_inherent_impl(item.owner_id, callee_id))

crates/flux-errors/src/lib.rs

@@ -17,10 +17,7 @@ use rustc_errors::{
     json::JsonEmitter,
     translation::Translator,
 };
-use rustc_session::{
-    config::{self, ErrorOutputType},
-    parse::ParseSess,
-};
+use rustc_session::{config, parse::ParseSess};
 use rustc_span::source_map::SourceMap;
 
 pub struct FluxSession {
@@ -75,43 +72,99 @@ impl FluxSession {
 }
 
 fn emitter(
-    opts: &config::Options,
+    sopts: &config::Options,
     source_map: Arc<SourceMap>,
     fallback_fluent_bundle: LazyFallbackBundle,
 ) -> Box<dyn Emitter + sync::DynSend> {
-    let track_diagnostics = opts.unstable_opts.track_diagnostics;
-
     let translator = Translator { fluent_bundle: None, fallback_fluent_bundle };
-    match opts.error_format {
-        ErrorOutputType::HumanReadable { kind, color_config } => {
+
+    // All the code below is copied from rustc
+    let macro_backtrace = sopts.unstable_opts.macro_backtrace;
+    let track_diagnostics = sopts.unstable_opts.track_diagnostics;
+    let terminal_url = match sopts.unstable_opts.terminal_urls {
+        rustc_errors::TerminalUrl::Auto => {
+            match (std::env::var("COLORTERM").as_deref(), std::env::var("TERM").as_deref()) {
+                (Ok("truecolor"), Ok("xterm-256color"))
+                    if sopts.unstable_features.is_nightly_build() =>
+                {
+                    rustc_errors::TerminalUrl::Yes
+                }
+                _ => rustc_errors::TerminalUrl::No,
+            }
+        }
+        t => t,
+    };
+
+    let source_map = if sopts.unstable_opts.link_only { None } else { Some(source_map) };
+
+    match sopts.error_format {
+        config::ErrorOutputType::HumanReadable { kind, color_config } => {
+            let short = kind.short();
+
             if let HumanReadableErrorType::AnnotateSnippet = kind {
                 let emitter =
-                    AnnotateSnippetEmitter::new(Some(source_map), translator, false, false);
-                Box::new(emitter)
+                    AnnotateSnippetEmitter::new(stderr_destination(color_config), translator)
+                        .sm(source_map)
+                        .short_message(short)
+                        .diagnostic_width(sopts.diagnostic_width)
+                        .macro_backtrace(macro_backtrace)
+                        .track_diagnostics(track_diagnostics)
+                        .terminal_url(terminal_url)
+                        .theme(if let HumanReadableErrorType::Unicode = kind {
+                            rustc_errors::emitter::OutputTheme::Unicode
+                        } else {
+                            rustc_errors::emitter::OutputTheme::Ascii
+                        })
+                        .ignored_directories_in_source_blocks(
+                            sopts
+                                .unstable_opts
+                                .ignore_directory_in_diagnostics_source_blocks
+                                .clone(),
+                        );
+                Box::new(emitter.ui_testing(sopts.unstable_opts.ui_testing))
             } else {
-                let dst = stderr_destination(color_config);
-                let emitter = HumanEmitter::new(dst, translator)
-                    .sm(Some(source_map))
-                    .short_message(kind.short())
-                    .diagnostic_width(opts.diagnostic_width)
+                let emitter = HumanEmitter::new(stderr_destination(color_config), translator)
+                    .sm(source_map)
+                    .short_message(short)
+                    .diagnostic_width(sopts.diagnostic_width)
+                    .macro_backtrace(macro_backtrace)
                     .track_diagnostics(track_diagnostics)
-                    .terminal_url(opts.unstable_opts.terminal_urls);
-                Box::new(emitter)
+                    .terminal_url(terminal_url)
+                    .theme(if let HumanReadableErrorType::Unicode = kind {
+                        rustc_errors::emitter::OutputTheme::Unicode
+                    } else {
+                        rustc_errors::emitter::OutputTheme::Ascii
+                    })
+                    .ignored_directories_in_source_blocks(
+                        sopts
+                            .unstable_opts
+                            .ignore_directory_in_diagnostics_source_blocks
+                            .clone(),
+                    );
+                Box::new(emitter.ui_testing(sopts.unstable_opts.ui_testing))
             }
         }
-        ErrorOutputType::Json { pretty, json_rendered, color_config } => {
+        config::ErrorOutputType::Json { pretty, json_rendered, color_config } => {
             Box::new(
                 JsonEmitter::new(
                     Box::new(io::BufWriter::new(io::stderr())),
-                    Some(source_map),
+                    source_map,
                     translator,
                     pretty,
                     json_rendered,
                     color_config,
                 )
+                .ui_testing(sopts.unstable_opts.ui_testing)
+                .ignored_directories_in_source_blocks(
+                    sopts
+                        .unstable_opts
+                        .ignore_directory_in_diagnostics_source_blocks
+                        .clone(),
+                )
+                .diagnostic_width(sopts.diagnostic_width)
+                .macro_backtrace(macro_backtrace)
                 .track_diagnostics(track_diagnostics)
-                .diagnostic_width(opts.diagnostic_width)
-                .terminal_url(opts.unstable_opts.terminal_urls),
+                .terminal_url(terminal_url),
             )
         }
     }

crates/flux-fhir-analysis/src/conv/mod.rs

@@ -914,8 +914,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P> {
                 let assoc_segment =
                     fhir::PathSegment { args: &[], constraints: &[], ident, res: fhir::Res::Err };
                 let mut env = Env::empty();
-                let alias_ty =
-                    self.conv_type_relative_type_path(&mut env, ident.span, res, &assoc_segment)?;
+                let alias_ty = self.conv_type_relative_type_path(&mut env, res, &assoc_segment)?;
                 return Ok(rty::Sort::Alias(rty::AliasKind::Projection, alias_ty));
             }
             fhir::SortRes::PrimSort(fhir::PrimSort::Set) => {
@@ -1444,7 +1443,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P> {
                 let qself_res =
                     if let Some(path) = qself.as_path() { path.res } else { fhir::Res::Err };
                 let alias_ty = self
-                    .conv_type_relative_type_path(env, qself.span, qself_res, segment)?
+                    .conv_type_relative_type_path(env, qself_res, segment)?
                     .shift_in_escaping(1);
                 let bty = rty::BaseTy::Alias(rty::AliasKind::Projection, alias_ty);
                 let sort = bty.sort();
@@ -1464,18 +1463,14 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P> {
     fn conv_type_relative_path<Tag: AssocItemTag>(
         &mut self,
         tag: Tag,
-        qself_span: Span,
         qself_res: fhir::Res,
         assoc_ident: Ident,
     ) -> QueryResult<(Tag::AssocItem<'tcx>, rty::TraitRef)> {
         let tcx = self.tcx();
 
         let bound = match qself_res {
             fhir::Res::SelfTyAlias { alias_to: impl_def_id, is_trait_impl: true } => {
-                let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) else {
-                    // A cycle error occurred most likely (comment copied from rustc)
-                    span_bug!(qself_span, "expected cycle error");
-                };
+                let trait_ref = tcx.impl_trait_ref(impl_def_id);
 
                 self.probe_single_bound_for_assoc_item(
                     || {
@@ -1535,16 +1530,11 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P> {
     fn conv_type_relative_type_path(
         &mut self,
         env: &mut Env,
-        qself_span: Span,
         qself_res: fhir::Res,
         assoc_segment: &fhir::PathSegment,
     ) -> QueryResult<rty::AliasTy> {
-        let (assoc_item, trait_ref) = self.conv_type_relative_path(
-            AssocTag::Type,
-            qself_span,
-            qself_res,
-            assoc_segment.ident,
-        )?;
+        let (assoc_item, trait_ref) =
+            self.conv_type_relative_path(AssocTag::Type, qself_res, assoc_segment.ident)?;
 
         let assoc_id = assoc_item.def_id;
         let mut args = trait_ref.args.to_vec();
@@ -2469,7 +2459,7 @@ impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P> {
                 let qself_res =
                     if let Some(path) = qself.as_path() { path.res } else { fhir::Res::Err };
                 let (assoc_reft, trait_ref) =
-                    self.conv_type_relative_path(AssocReftTag, qself.span, qself_res, *name)?;
+                    self.conv_type_relative_path(AssocReftTag, qself_res, *name)?;
                 rty::AliasReft { assoc_id: assoc_reft.def_id, args: trait_ref.args }
             }
         };

crates/flux-infer/src/projections.rs

@@ -201,11 +201,7 @@ impl<'a, 'infcx, 'genv, 'tcx> Normalizer<'a, 'infcx, 'genv, 'tcx> {
                 //        IntoIter<{v. i32[v] | v > 0}, Global> MATCH IntoIter<T, A>
                 //            => {T -> {v. i32[v] | v > 0}, A -> Global}
 
-                let impl_trait_ref = self
-                    .genv()
-                    .impl_trait_ref(impl_def_id)?
-                    .unwrap()
-                    .skip_binder();
+                let impl_trait_ref = self.genv().impl_trait_ref(impl_def_id)?.skip_binder();
 
                 let generics = self.tcx().generics_of(impl_def_id);
 

crates/flux-middle/src/global_env.rs

@@ -253,17 +253,14 @@ impl<'genv, 'tcx> GlobalEnv<'genv, 'tcx> {
         self.inner.queries.check_wf(self, def_id)
     }
 
-    pub fn impl_trait_ref(
-        self,
-        impl_id: DefId,
-    ) -> QueryResult<Option<rty::EarlyBinder<rty::TraitRef>>> {
-        let Some(trait_ref) = self.tcx().impl_trait_ref(impl_id) else { return Ok(None) };
+    pub fn impl_trait_ref(self, impl_id: DefId) -> QueryResult<rty::EarlyBinder<rty::TraitRef>> {
+        let trait_ref = self.tcx().impl_trait_ref(impl_id);
         let trait_ref = trait_ref.skip_binder();
         let trait_ref = trait_ref
             .lower(self.tcx())
             .map_err(|err| QueryErr::unsupported(trait_ref.def_id, err.into_err()))?
             .refine(&Refiner::default_for_item(self, impl_id)?)?;
-        Ok(Some(rty::EarlyBinder(trait_ref)))
+        Ok(rty::EarlyBinder(trait_ref))
     }
 
     pub fn generics_of(self, def_id: impl IntoQueryParam<DefId>) -> QueryResult<rty::Generics> {
@@ -323,10 +320,7 @@ impl<'genv, 'tcx> GlobalEnv<'genv, 'tcx> {
 
         // Otherwise, check if the trait has a default body
         if let Some(body) = self.default_assoc_refinement_body(trait_assoc_id)? {
-            let impl_trait_ref = self
-                .impl_trait_ref(impl_id)?
-                .unwrap()
-                .instantiate_identity();
+            let impl_trait_ref = self.impl_trait_ref(impl_id)?.instantiate_identity();
             return Ok(rty::EarlyBinder(body.instantiate(self.tcx(), &impl_trait_ref.args, &[])));
         }
 

crates/flux-refineck/src/checker.rs

@@ -396,10 +396,8 @@ fn find_trait_item(
 ) -> QueryResult<Option<(rty::TraitRef, DefId)>> {
     let tcx = genv.tcx();
     let def_id = def_id.to_def_id();
-    if let Some(impl_id) = tcx.impl_of_assoc(def_id)
-        && let Some(impl_trait_ref) = genv.impl_trait_ref(impl_id)?
-    {
-        let impl_trait_ref = impl_trait_ref.instantiate_identity();
+    if let Some(impl_id) = tcx.trait_impl_of_assoc(def_id) {
+        let impl_trait_ref = genv.impl_trait_ref(impl_id)?.instantiate_identity();
         let trait_item_id = tcx.associated_item(def_id).trait_item_def_id().unwrap();
         return Ok(Some((impl_trait_ref, trait_item_id)));
     }
@@ -1289,7 +1287,7 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> {
                 self.check_binary_op(infcx, env, stmt_span, *bin_op, op1, op2)
                     .with_span(stmt_span)
             }
-            Rvalue::NullaryOp(null_op, ty) => Ok(self.check_nullary_op(*null_op, ty)),
+
             Rvalue::UnaryOp(UnOp::PtrMetadata, Operand::Copy(place))
             | Rvalue::UnaryOp(UnOp::PtrMetadata, Operand::Move(place)) => {
                 self.check_raw_ptr_metadata(infcx, env, stmt_span, place)
@@ -1415,16 +1413,6 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> {
         }
     }
 
-    fn check_nullary_op(&self, null_op: mir::NullOp, _ty: &ty::Ty) -> Ty {
-        match null_op {
-            mir::NullOp::SizeOf | mir::NullOp::AlignOf => {
-                // We could try to get the layout of type to index this with the actual value, but
-                // this enough for now. Revisit if we ever need the precision.
-                Ty::uint(UintTy::Usize)
-            }
-        }
-    }
-
     fn check_unary_op(
         &mut self,
         infcx: &mut InferCtxt<'_, 'genv, 'tcx>,

crates/flux-refineck/src/compare_impl_item.rs

@@ -15,7 +15,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::ty::TypingMode;
 
 pub fn check_impl_against_trait(genv: GlobalEnv, impl_id: MaybeExternId) -> QueryResult {
-    let trait_id = genv.tcx().trait_id_of_impl(impl_id.resolved_id()).unwrap();
+    let trait_id = genv.tcx().impl_trait_id(impl_id.resolved_id());
 
     let impl_assoc_refts = genv.assoc_refinements_of(impl_id)?;
     let trait_assoc_refts = genv.assoc_refinements_of(trait_id)?;
@@ -37,7 +37,6 @@ pub fn check_impl_against_trait(genv: GlobalEnv, impl_id: MaybeExternId) -> Quer
 
     let impl_trait_ref = genv
         .impl_trait_ref(impl_id.resolved_id())?
-        .unwrap()
         .instantiate_identity();
 
     let rustc_infcx = genv

crates/flux-refineck/src/ghost_statements/fold_unfold.rs

@@ -335,7 +335,6 @@ impl<M: Mode> FoldUnfoldAnalysis<'_, '_, '_, M> {
                     Rvalue::Repeat(op, _) => {
                         self.operand(op, env)?;
                     }
-                    Rvalue::NullaryOp(_, _) => {}
                 }
                 M::projection(self, env, place)?;
             }

crates/flux-refineck/src/ghost_statements/points_to.rs

@@ -84,10 +84,6 @@ impl<'a> PointsToAnalysis<'a> {
                 // StorageDead makes it UB to access the local afterwards.
                 state.flood_with(mir::Place::from(*local).as_ref(), self.map, FlatSet::BOTTOM);
             }
-            mir::StatementKind::Deinit(box place) => {
-                // Deinit makes the place uninitialized.
-                state.flood_with(place.as_ref(), self.map, FlatSet::BOTTOM);
-            }
             mir::StatementKind::Retag(..)
             | mir::StatementKind::Intrinsic(..)
             | mir::StatementKind::SetDiscriminant { .. }

crates/flux-rustc-bridge/src/lowering.rs

@@ -21,7 +21,7 @@ use rustc_trait_selection::traits::SelectionContext;
 use super::{
     mir::{
         AggregateKind, AssertKind, BasicBlockData, BinOp, Body, CallArgs, CastKind, Constant,
-        LocalDecl, NonDivergingIntrinsic, NullOp, Operand, Place, PlaceElem, PointerCast, Rvalue,
+        LocalDecl, NonDivergingIntrinsic, Operand, Place, PlaceElem, PointerCast, Rvalue,
         Statement, StatementKind, Terminator, TerminatorKind,
     },
     ty::{
@@ -274,7 +274,6 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
             }
 
             rustc_mir::StatementKind::Retag(_, _)
-            | rustc_mir::StatementKind::Deinit(_)
             | rustc_mir::StatementKind::AscribeUserType(..)
             | rustc_mir::StatementKind::Coverage(_)
             | rustc_mir::StatementKind::ConstEvalCounter
@@ -470,9 +469,6 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
                     self.lower_operand(op2)?,
                 ))
             }
-            rustc_mir::Rvalue::NullaryOp(null_op, ty) => {
-                Ok(Rvalue::NullaryOp(self.lower_null_op(*null_op)?, ty.lower(self.tcx)?))
-            }
             rustc_mir::Rvalue::UnaryOp(un_op, op) => {
                 Ok(Rvalue::UnaryOp(*un_op, self.lower_operand(op)?))
             }
@@ -488,6 +484,7 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
                 Ok(Rvalue::ShallowInitBox(self.lower_operand(op)?, ty.lower(self.tcx)?))
             }
             rustc_mir::Rvalue::ThreadLocalRef(_)
+            | rustc_mir::Rvalue::NullaryOp(..)
             | rustc_mir::Rvalue::CopyForDeref(_)
             | rustc_mir::Rvalue::WrapUnsafeBinder(..) => {
                 Err(UnsupportedReason::new(format!("unsupported rvalue `{rvalue:?}`")))
@@ -603,18 +600,6 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
         }
     }
 
-    fn lower_null_op(&self, null_op: rustc_mir::NullOp) -> Result<NullOp, UnsupportedReason> {
-        match null_op {
-            rustc_mir::NullOp::SizeOf => Ok(NullOp::SizeOf),
-            rustc_mir::NullOp::AlignOf => Ok(NullOp::AlignOf),
-            rustc_mir::NullOp::OffsetOf(_)
-            | rustc_mir::NullOp::UbChecks
-            | rustc_mir::NullOp::ContractChecks => {
-                Err(UnsupportedReason::new(format!("unsupported nullary op `{null_op:?}`")))
-            }
-        }
-    }
-
     fn lower_operand(&self, op: &rustc_mir::Operand<'tcx>) -> Result<Operand, UnsupportedReason> {
         match op {
             rustc_mir::Operand::Copy(place) => Ok(Operand::Copy(lower_place(self.tcx, place)?)),