Rename {create,emit}_warning as {create,emit}_warn.

nnethercote · nnethercote · commit 3c4f1d85af07 · 2024-01-10T07:33:06.000+11:00
For consistency with `warn`/`struct_warn`, and also `{create,emit}_err`,
all of which use an abbreviated form.
diff --git a/compiler/rustc_ast_passes/src/show_span.rs b/compiler/rustc_ast_passes/src/show_span.rs
@@ -38,21 +38,21 @@ struct ShowSpanVisitor<'a> {
 impl<'a> Visitor<'a> for ShowSpanVisitor<'a> {
     fn visit_expr(&mut self, e: &'a ast::Expr) {
         if let Mode::Expression = self.mode {
-            self.dcx.emit_warning(errors::ShowSpan { span: e.span, msg: "expression" });
+            self.dcx.emit_warn(errors::ShowSpan { span: e.span, msg: "expression" });
         }
         visit::walk_expr(self, e);
     }
 
     fn visit_pat(&mut self, p: &'a ast::Pat) {
         if let Mode::Pattern = self.mode {
-            self.dcx.emit_warning(errors::ShowSpan { span: p.span, msg: "pattern" });
+            self.dcx.emit_warn(errors::ShowSpan { span: p.span, msg: "pattern" });
         }
         visit::walk_pat(self, p);
     }
 
     fn visit_ty(&mut self, t: &'a ast::Ty) {
         if let Mode::Type = self.mode {
-            self.dcx.emit_warning(errors::ShowSpan { span: t.span, msg: "type" });
+            self.dcx.emit_warn(errors::ShowSpan { span: t.span, msg: "type" });
         }
         visit::walk_ty(self, t);
     }
diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
@@ -621,7 +621,7 @@ pub fn eval_condition(
                 }
             };
             let Some(min_version) = parse_version(*min_version) else {
-                dcx.emit_warning(session_diagnostics::UnknownVersionLiteral { span: *span });
+                dcx.emit_warn(session_diagnostics::UnknownVersionLiteral { span: *span });
                 return false;
             };
 
diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -52,7 +52,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
                 Some(c @ ('+' | '-')) => c,
                 Some(_) => {
                     if diagnostics {
-                        sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });
+                        sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
                     }
                     return None;
                 }
@@ -79,7 +79,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
                     else {
                         UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
                     };
-                sess.dcx().emit_warning(unknown_feature);
+                sess.dcx().emit_warn(unknown_feature);
             }
 
             if diagnostics {
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -191,7 +191,7 @@ impl CodegenBackend for GccCodegenBackend {
         #[cfg(feature="master")]
         gccjit::set_global_personality_function_name(b"rust_eh_personality\0");
         if sess.lto() == Lto::Thin {
-            sess.dcx().emit_warning(LTONotSupported {});
+            sess.dcx().emit_warn(LTONotSupported {});
         }
 
         #[cfg(not(feature="master"))]
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -245,12 +245,12 @@ pub fn target_machine_factory(
     match sess.opts.debuginfo_compression {
         rustc_session::config::DebugInfoCompression::Zlib => {
             if !unsafe { LLVMRustLLVMHasZlibCompressionForDebugSymbols() } {
-                sess.dcx().emit_warning(UnknownCompression { algorithm: "zlib" });
+                sess.dcx().emit_warn(UnknownCompression { algorithm: "zlib" });
             }
         }
         rustc_session::config::DebugInfoCompression::Zstd => {
             if !unsafe { LLVMRustLLVMHasZstdCompressionForDebugSymbols() } {
-                sess.dcx().emit_warning(UnknownCompression { algorithm: "zstd" });
+                sess.dcx().emit_warn(UnknownCompression { algorithm: "zstd" });
             }
         }
         rustc_session::config::DebugInfoCompression::None => {}
@@ -457,7 +457,7 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void
                 llvm::LLVMRustWriteDiagnosticInfoToString(diagnostic_ref, s)
             })
             .expect("non-UTF8 diagnostic");
-            dcx.emit_warning(FromLlvmDiag { message });
+            dcx.emit_warn(FromLlvmDiag { message });
         }
         llvm::diagnostic::Unsupported(diagnostic_ref) => {
             let message = llvm::build_string(|s| {
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -529,7 +529,7 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
                 Some(c @ ('+' | '-')) => c,
                 Some(_) => {
                     if diagnostics {
-                        sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });
+                        sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
                     }
                     return None;
                 }
@@ -557,12 +557,12 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str
                     } else {
                         UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
                     };
-                    sess.dcx().emit_warning(unknown_feature);
+                    sess.dcx().emit_warn(unknown_feature);
                 } else if feature_state
                     .is_some_and(|(_name, feature_gate)| !feature_gate.is_stable())
                 {
                     // An unstable feature. Warn about using it.
-                    sess.dcx().emit_warning(UnstableCTargetFeature { feature });
+                    sess.dcx().emit_warn(UnstableCTargetFeature { feature });
                 }
             }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1016,7 +1016,7 @@ fn link_natively<'a>(
                     if !prog.status.success() {
                         let mut output = prog.stderr.clone();
                         output.extend_from_slice(&prog.stdout);
-                        sess.dcx().emit_warning(errors::ProcessingDymutilFailed {
+                        sess.dcx().emit_warn(errors::ProcessingDymutilFailed {
                             status: prog.status,
                             output: escape_string(&output),
                         });
@@ -1091,7 +1091,7 @@ fn strip_symbols_with_external_utility<'a>(
             if !prog.status.success() {
                 let mut output = prog.stderr.clone();
                 output.extend_from_slice(&prog.stdout);
-                sess.dcx().emit_warning(errors::StrippingDebugInfoFailed {
+                sess.dcx().emit_warn(errors::StrippingDebugInfoFailed {
                     util,
                     status: prog.status,
                     output: escape_string(&output),
@@ -2406,7 +2406,7 @@ fn collect_natvis_visualizers(
                 visualizer_paths.push(visualizer_out_file);
             }
             Err(error) => {
-                sess.dcx().emit_warning(errors::UnableToWriteDebuggerVisualizer {
+                sess.dcx().emit_warn(errors::UnableToWriteDebuggerVisualizer {
                     path: visualizer_out_file,
                     error,
                 });
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -446,11 +446,11 @@ impl<'a> Linker for GccLinker<'a> {
                 // FIXME(81490): ld64 doesn't support these flags but macOS 11
                 // has -needed-l{} / -needed_library {}
                 // but we have no way to detect that here.
-                self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
+                self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);
             } else if self.is_gnu && !self.sess.target.is_like_windows {
                 self.linker_arg("--no-as-needed");
             } else {
-                self.sess.dcx().emit_warning(errors::LinkerUnsupportedModifier);
+                self.sess.dcx().emit_warn(errors::LinkerUnsupportedModifier);
             }
         }
         self.hint_dynamic();
@@ -504,7 +504,7 @@ impl<'a> Linker for GccLinker<'a> {
             // FIXME(81490): ld64 as of macOS 11 supports the -needed_framework
             // flag but we have no way to detect that here.
             // self.cmd.arg("-needed_framework").arg(framework);
-            self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);
+            self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);
         }
         self.cmd.arg("-framework").arg(framework);
     }
@@ -950,7 +950,7 @@ impl<'a> Linker for MsvcLinker<'a> {
                                 }
                             }
                             Err(error) => {
-                                self.sess.dcx().emit_warning(errors::NoNatvisDirectory { error });
+                                self.sess.dcx().emit_warn(errors::NoNatvisDirectory { error });
                             }
                         }
                     }
@@ -1501,7 +1501,7 @@ impl<'a> Linker for L4Bender<'a> {
 
     fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[String]) {
         // ToDo, not implemented, copy from GCC
-        self.sess.dcx().emit_warning(errors::L4BenderExportingSymbolsUnimplemented);
+        self.sess.dcx().emit_warn(errors::L4BenderExportingSymbolsUnimplemented);
         return;
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -573,11 +573,11 @@ fn produce_final_output_artifacts(
             if crate_output.outputs.contains_key(&output_type) {
                 // 2) Multiple codegen units, with `--emit foo=some_name`. We have
                 //    no good solution for this case, so warn the user.
-                sess.dcx().emit_warning(errors::IgnoringEmitPath { extension });
+                sess.dcx().emit_warn(errors::IgnoringEmitPath { extension });
             } else if crate_output.single_output_file.is_some() {
                 // 3) Multiple codegen units, with `-o some_name`. We have
                 //    no good solution for this case, so warn the user.
-                sess.dcx().emit_warning(errors::IgnoringOutput { extension });
+                sess.dcx().emit_warn(errors::IgnoringOutput { extension });
             } else {
                 // 4) Multiple codegen units, but no explicit name. We
                 //    just leave the `foo.0.x` files in place.
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -630,7 +630,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                 // current number of evaluated terminators is a power of 2. The latter gives us a cheap
                 // way to implement exponential backoff.
                 let span = ecx.cur_span();
-                ecx.tcx.dcx().emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });
+                ecx.tcx.dcx().emit_warn(LongRunningWarn { span, item_span: ecx.tcx.span });
             }
         }
 
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
@@ -1429,7 +1429,7 @@ fn report_ice(
             }
             Err(err) => {
                 // The path ICE couldn't be written to disk, provide feedback to the user as to why.
-                dcx.emit_warning(session_diagnostics::IcePathError {
+                dcx.emit_warn(session_diagnostics::IcePathError {
                     path: path.clone(),
                     error: err.to_string(),
                     env_var: std::env::var_os("RUSTC_ICE")
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -1086,16 +1086,16 @@ impl DiagCtxt {
     }
 
     #[track_caller]
-    pub fn create_warning<'a>(
+    pub fn create_warn<'a>(
         &'a self,
         warning: impl IntoDiagnostic<'a, ()>,
     ) -> DiagnosticBuilder<'a, ()> {
         warning.into_diagnostic(self, Warning(None))
     }
 
     #[track_caller]
-    pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
-        self.create_warning(warning).emit()
+    pub fn emit_warn<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
+        self.create_warn(warning).emit()
     }
 
     #[track_caller]
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
@@ -273,7 +273,7 @@ pub(crate) fn prepare_session_directory(
             debug!("successfully copied data from: {}", source_directory.display());
 
             if !allows_links {
-                sess.dcx().emit_warning(errors::HardLinkFailed { path: &session_dir });
+                sess.dcx().emit_warn(errors::HardLinkFailed { path: &session_dir });
             }
 
             sess.init_incr_comp_session(session_dir, directory_lock);
@@ -288,7 +288,7 @@ pub(crate) fn prepare_session_directory(
             // Try to remove the session directory we just allocated. We don't
             // know if there's any garbage in it from the failed copy action.
             if let Err(err) = safe_remove_dir_all(&session_dir) {
-                sess.dcx().emit_warning(errors::DeletePartial { path: &session_dir, err });
+                sess.dcx().emit_warn(errors::DeletePartial { path: &session_dir, err });
             }
 
             delete_session_dir_lock_file(sess, &lock_file_path);
@@ -322,7 +322,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
         );
 
         if let Err(err) = safe_remove_dir_all(&*incr_comp_session_dir) {
-            sess.dcx().emit_warning(errors::DeleteFull { path: &incr_comp_session_dir, err });
+            sess.dcx().emit_warn(errors::DeleteFull { path: &incr_comp_session_dir, err });
         }
 
         let lock_file_path = lock_file_path(&*incr_comp_session_dir);
@@ -365,7 +365,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Option<Svh>) {
         }
         Err(e) => {
             // Warn about the error. However, no need to abort compilation now.
-            sess.dcx().emit_warning(errors::Finalize { path: &incr_comp_session_dir, err: e });
+            sess.dcx().emit_warn(errors::Finalize { path: &incr_comp_session_dir, err: e });
 
             debug!("finalize_session_directory() - error, marking as invalid");
             // Drop the file lock, so we can garage collect
@@ -500,7 +500,7 @@ fn lock_directory(
 
 fn delete_session_dir_lock_file(sess: &Session, lock_file_path: &Path) {
     if let Err(err) = safe_remove_file(lock_file_path) {
-        sess.dcx().emit_warning(errors::DeleteLock { path: lock_file_path, err });
+        sess.dcx().emit_warn(errors::DeleteLock { path: lock_file_path, err });
     }
 }
 
@@ -724,7 +724,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
         if !lock_file_to_session_dir.items().any(|(_, dir)| *dir == directory_name) {
             let path = crate_directory.join(directory_name);
             if let Err(err) = safe_remove_dir_all(&path) {
-                sess.dcx().emit_warning(errors::InvalidGcFailed { path: &path, err });
+                sess.dcx().emit_warn(errors::InvalidGcFailed { path: &path, err });
             }
         }
     }
@@ -830,7 +830,7 @@ pub(crate) fn garbage_collect_session_directories(sess: &Session) -> io::Result<
         debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
 
         if let Err(err) = safe_remove_dir_all(&path) {
-            sess.dcx().emit_warning(errors::FinalizedGcFailed { path: &path, err });
+            sess.dcx().emit_warn(errors::FinalizedGcFailed { path: &path, err });
         } else {
             delete_session_dir_lock_file(sess, &lock_file_path(&path));
         }
@@ -848,7 +848,7 @@ fn delete_old(sess: &Session, path: &Path) {
     debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
 
     if let Err(err) = safe_remove_dir_all(path) {
-        sess.dcx().emit_warning(errors::SessionGcFailed { path: path, err });
+        sess.dcx().emit_warn(errors::SessionGcFailed { path: path, err });
     } else {
         delete_session_dir_lock_file(sess, &lock_file_path(path));
     }
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
@@ -51,7 +51,7 @@ impl<T: Default> LoadResult<T> {
 
         match self {
             LoadResult::LoadDepGraph(path, err) => {
-                sess.dcx().emit_warning(errors::LoadDepGraph { path, err });
+                sess.dcx().emit_warn(errors::LoadDepGraph { path, err });
                 Default::default()
             }
             LoadResult::DataOutOfDate => {
diff --git a/compiler/rustc_incremental/src/persist/work_product.rs b/compiler/rustc_incremental/src/persist/work_product.rs
@@ -30,7 +30,7 @@ pub fn copy_cgu_workproduct_to_incr_comp_cache_dir(
                 let _ = saved_files.insert(ext.to_string(), file_name);
             }
             Err(err) => {
-                sess.dcx().emit_warning(errors::CopyWorkProductToCache {
+                sess.dcx().emit_warn(errors::CopyWorkProductToCache {
                     from: path,
                     to: &path_in_incr_dir,
                     err,
@@ -50,7 +50,7 @@ pub(crate) fn delete_workproduct_files(sess: &Session, work_product: &WorkProduc
     for (_, path) in work_product.saved_files.items().into_sorted_stable_ord() {
         let path = in_incr_comp_dir_sess(sess, path);
         if let Err(err) = std_fs::remove_file(&path) {
-            sess.dcx().emit_warning(errors::DeleteWorkProduct { path: &path, err });
+            sess.dcx().emit_warn(errors::DeleteWorkProduct { path: &path, err });
         }
     }
 }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
@@ -254,7 +254,7 @@ fn configure_and_expand(
     }
 
     if is_proc_macro_crate && sess.panic_strategy() == PanicStrategy::Abort {
-        sess.dcx().emit_warning(errors::ProcMacroCratePanicAbort);
+        sess.dcx().emit_warn(errors::ProcMacroCratePanicAbort);
     }
 
     sess.time("maybe_create_a_macro_crate", || {
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
@@ -213,9 +213,8 @@ impl<'tcx> Queries<'tcx> {
 
                 // Some other attribute.
                 Some(_) => {
-                    tcx.dcx().emit_warning(RustcErrorUnexpectedAnnotation {
-                        span: tcx.def_span(def_id),
-                    });
+                    tcx.dcx()
+                        .emit_warn(RustcErrorUnexpectedAnnotation { span: tcx.def_span(def_id) });
                 }
             }
         }
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
@@ -431,7 +431,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
 
     base.retain(|crate_type| {
         if output::invalid_output_for_target(session, *crate_type) {
-            session.dcx().emit_warning(errors::UnsupportedCrateTypeForTarget {
+            session.dcx().emit_warn(errors::UnsupportedCrateTypeForTarget {
                 crate_type: *crate_type,
                 target_triple: &session.opts.target_triple,
             });
@@ -507,16 +507,16 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
             let unnamed_output_types =
                 sess.opts.output_types.values().filter(|a| a.is_none()).count();
             let ofile = if unnamed_output_types > 1 {
-                sess.dcx().emit_warning(errors::MultipleOutputTypesAdaption);
+                sess.dcx().emit_warn(errors::MultipleOutputTypesAdaption);
                 None
             } else {
                 if !sess.opts.cg.extra_filename.is_empty() {
-                    sess.dcx().emit_warning(errors::IgnoringExtraFilename);
+                    sess.dcx().emit_warn(errors::IgnoringExtraFilename);
                 }
                 Some(out_file.clone())
             };
             if sess.io.output_dir != None {
-                sess.dcx().emit_warning(errors::IgnoringOutDir);
+                sess.dcx().emit_warn(errors::IgnoringOutDir);
             }
 
             let out_filestem =
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -1093,7 +1093,7 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Co
                 MonoItemCollectionMode::Eager
             } else {
                 if mode != "lazy" {
-                    tcx.dcx().emit_warning(UnknownCguCollectionMode { mode });
+                    tcx.dcx().emit_warn(UnknownCguCollectionMode { mode });
                 }
 
                 MonoItemCollectionMode::Lazy
diff --git a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
diff --git a/compiler/rustc_passes/src/check_const.rs b/compiler/rustc_passes/src/check_const.rs
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs

Original file line number	Diff line number	Diff line change
`@@ -38,21 +38,21 @@ struct ShowSpanVisitor<'a> {`
`38`	`38`	`impl<'a> Visitor<'a> for ShowSpanVisitor<'a> {`
`39`	`39`	`fn visit_expr(&mut self, e: &'a ast::Expr) {`
`40`	`40`	`if let Mode::Expression = self.mode {`
`41`		`- self.dcx.emit_warning(errors::ShowSpan { span: e.span, msg: "expression" });`
	`41`	`+ self.dcx.emit_warn(errors::ShowSpan { span: e.span, msg: "expression" });`
`42`	`42`	`}`
`43`	`43`	`visit::walk_expr(self, e);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`fn visit_pat(&mut self, p: &'a ast::Pat) {`
`47`	`47`	`if let Mode::Pattern = self.mode {`
`48`		`- self.dcx.emit_warning(errors::ShowSpan { span: p.span, msg: "pattern" });`
	`48`	`+ self.dcx.emit_warn(errors::ShowSpan { span: p.span, msg: "pattern" });`
`49`	`49`	`}`
`50`	`50`	`visit::walk_pat(self, p);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`fn visit_ty(&mut self, t: &'a ast::Ty) {`
`54`	`54`	`if let Mode::Type = self.mode {`
`55`		`- self.dcx.emit_warning(errors::ShowSpan { span: t.span, msg: "type" });`
	`55`	`+ self.dcx.emit_warn(errors::ShowSpan { span: t.span, msg: "type" });`
`56`	`56`	`}`
`57`	`57`	`visit::walk_ty(self, t);`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -621,7 +621,7 @@ pub fn eval_condition(`
`621`	`621`	`}`
`622`	`622`	`};`
`623`	`623`	`let Some(min_version) = parse_version(*min_version) else {`
`624`		`- dcx.emit_warning(session_diagnostics::UnknownVersionLiteral { span: *span });`
	`624`	`+ dcx.emit_warn(session_diagnostics::UnknownVersionLiteral { span: *span });`
`625`	`625`	`return false;`
`626`	`626`	`};`
`627`	`627`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri`
`52`	`52`	`Some(c @ ('+' \| '-')) => c,`
`53`	`53`	`Some(_) => {`
`54`	`54`	`if diagnostics {`
`55`		`- sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });`
	`55`	`+ sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });`
`56`	`56`	`}`
`57`	`57`	`return None;`
`58`	`58`	`}`
`@@ -79,7 +79,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri`
`79`	`79`	`else {`
`80`	`80`	`UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }`
`81`	`81`	`};`
`82`		`- sess.dcx().emit_warning(unknown_feature);`
	`82`	`+ sess.dcx().emit_warn(unknown_feature);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`if diagnostics {`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ impl CodegenBackend for GccCodegenBackend {`
`191`	`191`	`#[cfg(feature="master")]`
`192`	`192`	`gccjit::set_global_personality_function_name(b"rust_eh_personality\0");`
`193`	`193`	`if sess.lto() == Lto::Thin {`
`194`		`- sess.dcx().emit_warning(LTONotSupported {});`
	`194`	`+ sess.dcx().emit_warn(LTONotSupported {});`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`#[cfg(not(feature="master"))]`
Original file line number	Diff line number	Diff line change
`@@ -245,12 +245,12 @@ pub fn target_machine_factory(`
`245`	`245`	`match sess.opts.debuginfo_compression {`
`246`	`246`	`rustc_session::config::DebugInfoCompression::Zlib => {`
`247`	`247`	`if !unsafe { LLVMRustLLVMHasZlibCompressionForDebugSymbols() } {`
`248`		`- sess.dcx().emit_warning(UnknownCompression { algorithm: "zlib" });`
	`248`	`+ sess.dcx().emit_warn(UnknownCompression { algorithm: "zlib" });`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`	`rustc_session::config::DebugInfoCompression::Zstd => {`
`252`	`252`	`if !unsafe { LLVMRustLLVMHasZstdCompressionForDebugSymbols() } {`
`253`		`- sess.dcx().emit_warning(UnknownCompression { algorithm: "zstd" });`
	`253`	`+ sess.dcx().emit_warn(UnknownCompression { algorithm: "zstd" });`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`	`rustc_session::config::DebugInfoCompression::None => {}`
`@@ -457,7 +457,7 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void`
`457`	`457`	`llvm::LLVMRustWriteDiagnosticInfoToString(diagnostic_ref, s)`
`458`	`458`	`})`
`459`	`459`	`.expect("non-UTF8 diagnostic");`
`460`		`- dcx.emit_warning(FromLlvmDiag { message });`
	`460`	`+ dcx.emit_warn(FromLlvmDiag { message });`
`461`	`461`	`}`
`462`	`462`	`llvm::diagnostic::Unsupported(diagnostic_ref) => {`
`463`	`463`	`let message = llvm::build_string(\|s\| {`
Original file line number	Diff line number	Diff line change
`@@ -529,7 +529,7 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str`
`529`	`529`	`Some(c @ ('+' \| '-')) => c,`
`530`	`530`	`Some(_) => {`
`531`	`531`	`if diagnostics {`
`532`		`- sess.dcx().emit_warning(UnknownCTargetFeaturePrefix { feature: s });`
	`532`	`+ sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });`
`533`	`533`	`}`
`534`	`534`	`return None;`
`535`	`535`	`}`
`@@ -557,12 +557,12 @@ pub(crate) fn global_llvm_features(sess: &Session, diagnostics: bool) -> Vec<Str`
`557`	`557`	`} else {`
`558`	`558`	`UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }`
`559`	`559`	`};`
`560`		`- sess.dcx().emit_warning(unknown_feature);`
	`560`	`+ sess.dcx().emit_warn(unknown_feature);`
`561`	`561`	`} else if feature_state`
`562`	`562`	`.is_some_and(\|(_name, feature_gate)\| !feature_gate.is_stable())`
`563`	`563`	`{`
`564`	`564`	`// An unstable feature. Warn about using it.`
`565`		`- sess.dcx().emit_warning(UnstableCTargetFeature { feature });`
	`565`	`+ sess.dcx().emit_warn(UnstableCTargetFeature { feature });`
`566`	`566`	`}`
`567`	`567`	`}`
`568`	`568`
Original file line number	Diff line number	Diff line change
`@@ -446,11 +446,11 @@ impl<'a> Linker for GccLinker<'a> {`
`446`	`446`	`// FIXME(81490): ld64 doesn't support these flags but macOS 11`
`447`	`447`	`// has -needed-l{} / -needed_library {}`
`448`	`448`	`// but we have no way to detect that here.`
`449`		`- self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);`
	`449`	`+ self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);`
`450`	`450`	`} else if self.is_gnu && !self.sess.target.is_like_windows {`
`451`	`451`	`self.linker_arg("--no-as-needed");`
`452`	`452`	`} else {`
`453`		`- self.sess.dcx().emit_warning(errors::LinkerUnsupportedModifier);`
	`453`	`+ self.sess.dcx().emit_warn(errors::LinkerUnsupportedModifier);`
`454`	`454`	`}`
`455`	`455`	`}`
`456`	`456`	`self.hint_dynamic();`
`@@ -504,7 +504,7 @@ impl<'a> Linker for GccLinker<'a> {`
`504`	`504`	`// FIXME(81490): ld64 as of macOS 11 supports the -needed_framework`
`505`	`505`	`// flag but we have no way to detect that here.`
`506`	`506`	`// self.cmd.arg("-needed_framework").arg(framework);`
`507`		`- self.sess.dcx().emit_warning(errors::Ld64UnimplementedModifier);`
	`507`	`+ self.sess.dcx().emit_warn(errors::Ld64UnimplementedModifier);`
`508`	`508`	`}`
`509`	`509`	`self.cmd.arg("-framework").arg(framework);`
`510`	`510`	`}`
`@@ -950,7 +950,7 @@ impl<'a> Linker for MsvcLinker<'a> {`
`950`	`950`	`}`
`951`	`951`	`}`
`952`	`952`	`Err(error) => {`
`953`		`- self.sess.dcx().emit_warning(errors::NoNatvisDirectory { error });`
	`953`	`+ self.sess.dcx().emit_warn(errors::NoNatvisDirectory { error });`
`954`	`954`	`}`
`955`	`955`	`}`
`956`	`956`	`}`
`@@ -1501,7 +1501,7 @@ impl<'a> Linker for L4Bender<'a> {`
`1501`	`1501`
`1502`	`1502`	`fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[String]) {`
`1503`	`1503`	`// ToDo, not implemented, copy from GCC`
`1504`		`- self.sess.dcx().emit_warning(errors::L4BenderExportingSymbolsUnimplemented);`
	`1504`	`+ self.sess.dcx().emit_warn(errors::L4BenderExportingSymbolsUnimplemented);`
`1505`	`1505`	`return;`
`1506`	`1506`	`}`
`1507`	`1507`
Original file line number	Diff line number	Diff line change
`@@ -630,7 +630,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,`
`630`	`630`	`// current number of evaluated terminators is a power of 2. The latter gives us a cheap`
`631`	`631`	`// way to implement exponential backoff.`
`632`	`632`	`let span = ecx.cur_span();`
`633`		`- ecx.tcx.dcx().emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });`
	`633`	`+ ecx.tcx.dcx().emit_warn(LongRunningWarn { span, item_span: ecx.tcx.span });`
`634`	`634`	`}`
`635`	`635`	`}`
`636`	`636`
Original file line number	Diff line number	Diff line change
`@@ -1429,7 +1429,7 @@ fn report_ice(`
`1429`	`1429`	`}`
`1430`	`1430`	`Err(err) => {`
`1431`	`1431`	`// The path ICE couldn't be written to disk, provide feedback to the user as to why.`
`1432`		`- dcx.emit_warning(session_diagnostics::IcePathError {`
	`1432`	`+ dcx.emit_warn(session_diagnostics::IcePathError {`
`1433`	`1433`	`path: path.clone(),`
`1434`	`1434`	`error: err.to_string(),`
`1435`	`1435`	`env_var: std::env::var_os("RUSTC_ICE")`
Original file line number	Diff line number	Diff line change
`@@ -1086,16 +1086,16 @@ impl DiagCtxt {`
`1086`	`1086`	`}`
`1087`	`1087`
`1088`	`1088`	`#[track_caller]`
`1089`		`- pub fn create_warning<'a>(`
	`1089`	`+ pub fn create_warn<'a>(`
`1090`	`1090`	`&'a self,`
`1091`	`1091`	`warning: impl IntoDiagnostic<'a, ()>,`
`1092`	`1092`	`) -> DiagnosticBuilder<'a, ()> {`
`1093`	`1093`	`warning.into_diagnostic(self, Warning(None))`
`1094`	`1094`	`}`
`1095`	`1095`
`1096`	`1096`	`#[track_caller]`
`1097`		`- pub fn emit_warning<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {`
`1098`		`- self.create_warning(warning).emit()`
	`1097`	`+ pub fn emit_warn<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {`
	`1098`	`+ self.create_warn(warning).emit()`
`1099`	`1099`	`}`
`1100`	`1100`
`1101`	`1101`	`#[track_caller]`