Move resolve_path to rustc_builtin_macros and make it private

compiler/rustc_builtin_macros/src/source_util.rs

@@ -3,15 +3,17 @@ use rustc_ast::ptr::P;
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast_pretty::pprust;
+use rustc_errors::PResult;
 use rustc_expand::base::{self, *};
 use rustc_expand::module::DirOwnership;
 use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_parse::{self, new_parser_from_file};
 use rustc_session::lint::builtin::INCOMPLETE_INCLUDE;
 use rustc_span::symbol::Symbol;
-use rustc_span::{self, Pos, Span};
+use rustc_span::{self, FileName, Pos, Span};
 
 use smallvec::SmallVec;
+use std::path::PathBuf;
 use std::rc::Rc;
 
 // These macros all relate to the file system; they either return
@@ -102,7 +104,7 @@ pub fn expand_include<'cx>(
  return DummyResult::any(sp);
  };
  // The file will be added to the code map by the parser
- let file = match cx.resolve_path(file, sp) {
+ let file = match resolve_path(cx, file, sp) {
  Ok(f) => f,
  Err(mut err) => {
  err.emit();
@@ -171,7 +173,7 @@ pub fn expand_include_str(
  let Some(file) = get_single_str_from_tts(cx, sp, tts, "include_str!") else {
  return DummyResult::any(sp);
  };
- let file = match cx.resolve_path(file, sp) {
+ let file = match resolve_path(cx, file, sp) {
  Ok(f) => f,
  Err(mut err) => {
  err.emit();
@@ -205,7 +207,7 @@ pub fn expand_include_bytes(
  let Some(file) = get_single_str_from_tts(cx, sp, tts, "include_bytes!") else {
  return DummyResult::any(sp);
  };
- let file = match cx.resolve_path(file, sp) {
+ let file = match resolve_path(cx, file, sp) {
  Ok(f) => f,
  Err(mut err) => {
  err.emit();
@@ -220,3 +222,40 @@ pub fn expand_include_bytes(
  }
  }
 }
+
+/// Resolves a `path` mentioned inside Rust code, returning an absolute path.
+///
+/// This unifies the logic used for resolving `include_X!`.
+fn resolve_path<'a>(
+ cx: &mut ExtCtxt<'a>,
+ path: impl Into<PathBuf>,
+ span: Span,
+) -> PResult<'a, PathBuf> {
+ let path = path.into();
+
+ // Relative paths are resolved relative to the file in which they are found
+ // after macro expansion (that is, they are unhygienic).
+ if !path.is_absolute() {
+ let callsite = span.source_callsite();
+ let mut result = match cx.source_map().span_to_filename(callsite) {
+ FileName::Real(name) => name
+ .into_local_path()
+ .expect("attempting to resolve a file path in an external file"),
+ FileName::DocTest(path, _) => path,
+ other => {
+ return Err(cx.struct_span_err(
+ span,
+ &format!(
+ "cannot resolve relative path in non-file source `{}`",
+ cx.source_map().filename_for_diagnostics(&other)
+ ),
+ ));
+ }
+ };
+ result.pop();
+ result.push(path);
+ Ok(result)
+ } else {
+ Ok(path)
+ }
+}

compiler/rustc_expand/src/base.rs

@@ -10,7 +10,7 @@ use rustc_ast::{self as ast, AstLike, Attribute, Item, NodeId, PatKind};
 use rustc_attr::{self as attr, Deprecation, Stability};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::{self, Lrc};
-use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed, PResult};
+use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed};
 use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT;
 use rustc_lint_defs::BuiltinLintDiagnostics;
 use rustc_parse::{self, nt_to_tokenstream, parser, MACRO_ARGUMENTS};
@@ -20,7 +20,7 @@ use rustc_span::edition::Edition;
 use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{FileName, MultiSpan, Span, DUMMY_SP};
+use rustc_span::{MultiSpan, Span, DUMMY_SP};
 use smallvec::{smallvec, SmallVec};
 
 use std::default::Default;
@@ -1128,41 +1128,6 @@ impl<'a> ExtCtxt<'a> {
  pub fn check_unused_macros(&mut self) {
  self.resolver.check_unused_macros();
  }
-
- /// Resolves a `path` mentioned inside Rust code, returning an absolute path.
- ///
- /// This unifies the logic used for resolving `include_X!`.
- ///
- /// FIXME: move this to `rustc_builtin_macros` and make it private.
- pub fn resolve_path(&self, path: impl Into<PathBuf>, span: Span) -> PResult<'a, PathBuf> {
- let path = path.into();
-
- // Relative paths are resolved relative to the file in which they are found
- // after macro expansion (that is, they are unhygienic).
- if !path.is_absolute() {
- let callsite = span.source_callsite();
- let mut result = match self.source_map().span_to_filename(callsite) {
- FileName::Real(name) => name
- .into_local_path()
- .expect("attempting to resolve a file path in an external file"),
- FileName::DocTest(path, _) => path,
- other => {
- return Err(self.struct_span_err(
- span,
- &format!(
- "cannot resolve relative path in non-file source `{}`",
- self.source_map().filename_for_diagnostics(&other)
- ),
- ));
- }
- };
- result.pop();
- result.push(path);
- Ok(result)
- } else {
- Ok(path)
- }
- }
 }
 
 /// Extracts a string literal from the macro expanded version of `expr`,