Toolchain upgrade to nightly-2025-11-13

crates/flux-desugar/src/desugar/lift.rs

@@ -430,12 +430,6 @@ impl<'genv> RustItemCtxt<'_, 'genv, '_> {
                 let segment = self.lift_path_segment(segment)?;
                 Ok(fhir::QPath::TypeRelative(self.genv.alloc(qself), self.genv.alloc(segment)))
             }
-            hir::QPath::LangItem(_, _) => {
-                Err(self.emit_unsupported(&format!(
-                    "unsupported type: `{}`",
-                    rustc_hir_pretty::qpath_to_string(&self.genv.tcx(), &qpath)
-                )))
-            }
         }
     }
 

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-driver/src/collector/mod.rs

@@ -139,7 +139,7 @@ impl<'a, 'tcx> SpecCollector<'a, 'tcx> {
             ItemKind::TyAlias(..) => self.collect_type_alias(owner_id, attrs)?,
             ItemKind::Impl(..) => self.collect_impl(owner_id, attrs)?,
             ItemKind::Trait(..) => self.collect_trait(owner_id, attrs)?,
-            ItemKind::Const(.., body_id) => {
+            ItemKind::Const(.., rhs) => {
                 // The flux-rs macro puts defs as an outer attribute on a `const _: () = { }`. We
                 // consider these defs to be defined in the parent of the const.
                 self.specs
@@ -148,7 +148,9 @@ impl<'a, 'tcx> SpecCollector<'a, 'tcx> {
                     .or_default()
                     .extend(attrs.items());
 
-                if attrs.extern_spec() {
+                if attrs.extern_spec()
+                    && let hir::ConstItemRhs::Body(body_id) = rhs
+                {
                     return ExternSpecCollector::collect(self, *body_id);
                 }
 

crates/flux-errors/src/lib.rs

@@ -11,16 +11,13 @@ use flux_common::result::{ErrorCollector, ErrorEmitter};
 use rustc_data_structures::sync;
 pub use rustc_errors::ErrorGuaranteed;
 use rustc_errors::{
-    Diagnostic, ErrCode, FatalAbort, FatalError, LazyFallbackBundle,
+    Diagnostic, ErrCode, FatalAbort, FatalError, LazyFallbackBundle, TerminalUrl,
     annotate_snippet_emitter_writer::AnnotateSnippetEmitter,
-    emitter::{Emitter, HumanEmitter, HumanReadableErrorType, stderr_destination},
+    emitter::{Emitter, HumanEmitter, HumanReadableErrorType, OutputTheme, stderr_destination},
     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,92 @@ 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 } => {
-            if let HumanReadableErrorType::AnnotateSnippet = kind {
-                let emitter =
-                    AnnotateSnippetEmitter::new(Some(source_map), translator, false, false);
-                Box::new(emitter)
-            } 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)
-                    .track_diagnostics(track_diagnostics)
-                    .terminal_url(opts.unstable_opts.terminal_urls);
-                Box::new(emitter)
+
+    // All the code below is copied from rustc_session::session::default_emitter
+    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 {
+        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() =>
+                {
+                    TerminalUrl::Yes
+                }
+                _ => TerminalUrl::No,
             }
         }
-        ErrorOutputType::Json { pretty, json_rendered, color_config } => {
+        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 } => {
+            match kind {
+                HumanReadableErrorType::AnnotateSnippet { short, unicode } => {
+                    let 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 unicode { OutputTheme::Unicode } else { 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))
+                }
+                HumanReadableErrorType::Default { short } => {
+                    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(terminal_url)
+                        .theme(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))
+                }
+            }
+        }
+        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();
@@ -2487,7 +2477,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

@@ -401,10 +401,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)));
     }
@@ -1377,7 +1375,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)
@@ -1507,16 +1505,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)?;
             }