Toolchain upgrade to nightly-2025-12-15

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

@@ -433,12 +433,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/callbacks.rs

@@ -215,11 +215,11 @@ impl<'genv, 'tcx> CrateChecker<'genv, 'tcx> {
         let span = tcx.def_span(def_id);
         let sm = tcx.sess.source_map();
         let FileName::Real(file_name) = sm.span_to_filename(span) else { return true };
-        let mut file_path = file_name.local_path_if_available();
+        let Some(mut file_path) = file_name.local_path() else { return true };
 
         // If the path is absolute try to normalize it to be relative to the working_dir
         if file_path.is_absolute() {
-            let working_dir = tcx.sess.opts.working_dir.local_path_if_available();
+            let Some(working_dir) = sm.working_dir().local_path() else { return true };
             let Ok(p) = file_path.strip_prefix(working_dir) else { return true };
             file_path = p;
         }

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

@@ -896,8 +896,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) => {
@@ -1433,7 +1432,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();
@@ -1454,18 +1453,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(
                     || {
@@ -1525,16 +1520,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();
@@ -2475,7 +2465,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/lean_encoding.rs

@@ -36,10 +36,10 @@ impl<'genv, 'tcx> LeanEncoder<'genv, 'tcx> {
         let path = genv
             .tcx()
             .sess
-            .opts
-            .working_dir
-            .local_path_if_available()
-            .to_path_buf()
+            .source_map()
+            .working_dir()
+            .local_path()
+            .unwrap()
             .join(config::lean_dir());
         let project = config::lean_project().to_string();
         Self { genv, path, project, defs_file_name, pretty_var_map }

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-macros/src/diagnostics/fluent.rs

@@ -1,15 +1,19 @@
-use std::collections::{HashMap, HashSet};
-use std::fs::read_to_string;
-use std::path::{Path, PathBuf};
+use std::{
+    collections::{HashMap, HashSet},
+    fs::read_to_string,
+    path::{Path, PathBuf},
+};
 
 use annotate_snippets::{Renderer, Snippet};
 use fluent_bundle::{FluentBundle, FluentError, FluentResource};
-use fluent_syntax::ast::{
-    Attribute, Entry, Expression, Identifier, InlineExpression, Message, Pattern, PatternElement,
+use fluent_syntax::{
+    ast::{
+        Attribute, Entry, Expression, Identifier, InlineExpression, Message, Pattern,
+        PatternElement,
+    },
+    parser::ParserError,
 };
-use fluent_syntax::parser::ParserError;
-use proc_macro::tracked_path::path;
-use proc_macro::{Diagnostic, Level, Span};
+use proc_macro::{Diagnostic, Level, Span, tracked::path};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Ident, LitStr, parse_macro_input};
@@ -158,7 +162,9 @@ pub(crate) fn fluent_messages(input: proc_macro::TokenStream) -> proc_macro::Tok
     for entry in resource.entries() {
         if let Entry::Message(msg) = entry {
             let Message { id: Identifier { name }, attributes, value, .. } = msg;
-            let _ = previous_defns.entry((*name).to_string()).or_insert(resource_span);
+            let _ = previous_defns
+                .entry((*name).to_string())
+                .or_insert(resource_span);
             if name.contains('-') {
                 Diagnostic::spanned(
                     resource_span,

crates/flux-macros/src/lib.rs

@@ -1,4 +1,10 @@
-#![feature(proc_macro_diagnostic, never_type, proc_macro_span, if_let_guard, track_path)]
+#![feature(
+    proc_macro_diagnostic,
+    never_type,
+    proc_macro_span,
+    if_let_guard,
+    proc_macro_tracked_path
+)]
 
 mod diagnostics;
 mod fold;