expand: Less path cloning during module loading

Author: petrochenkov

compiler/rustc_expand/src/expand.rs

@@ -3,7 +3,7 @@ use crate::config::StripUnconfigured;
 use crate::configure;
 use crate::hygiene::SyntaxContext;
 use crate::mbe::macro_rules::annotate_err_with_kind;
-use crate::module::{parse_external_mod, push_directory, Directory, DirectoryOwnership};
+use crate::module::{parse_external_mod, push_directory, DirectoryOwnership, ParsedExternalMod};
 use crate::placeholders::{placeholder, PlaceholderExpander};
 
 use rustc_ast as ast;
@@ -1277,28 +1277,36 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                 })
             }
             ast::ItemKind::Mod(_, ref mut mod_kind) if ident != Ident::invalid() => {
-                let dir = Directory {
-                    ownership: self.cx.current_expansion.directory_ownership,
-                    path: self.cx.current_expansion.module.dir_path.clone(),
-                };
-                let (file_path, Directory { ownership, path }) = match mod_kind {
+                let (file_path, dir_path, dir_ownership) = match mod_kind {
                     ModKind::Loaded(_, Inline::Yes, _) => {
                         // Inline `mod foo { ... }`, but we still need to push directories.
-                        let dir_path = push_directory(&self.cx.sess, ident, &attrs, dir);
+                        let (dir_path, dir_ownership) = push_directory(
+                            &self.cx.sess,
+                            ident,
+                            &attrs,
+                            &self.cx.current_expansion.module,
+                            self.cx.current_expansion.directory_ownership,
+                        );
                         item.attrs = attrs;
-                        (None, dir_path)
+                        (None, dir_path, dir_ownership)
                     }
                     ModKind::Loaded(_, Inline::No, _) => {
                         panic!("`mod` item is loaded from a file for the second time")
                     }
                     ModKind::Unloaded => {
                         // We have an outline `mod foo;` so we need to parse the file.
-                        let (items, inner_span, file_path, dir_path) = parse_external_mod(
+                        let ParsedExternalMod {
+                            items,
+                            inner_span,
+                            file_path,
+                            dir_path,
+                            dir_ownership,
+                        } = parse_external_mod(
                             &self.cx.sess,
                             ident,
                             span,
-                            &self.cx.current_expansion.module.file_path_stack,
-                            dir,
+                            &self.cx.current_expansion.module,
+                            self.cx.current_expansion.directory_ownership,
                             &mut attrs,
                         );
 
@@ -1312,12 +1320,12 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                         item.attrs = krate.attrs;
                         // File can have inline attributes, e.g., `#![cfg(...)]` & co. => Reconfigure.
                         item = configure!(self, item);
-                        (Some(file_path), dir_path)
+                        (Some(file_path), dir_path, dir_ownership)
                     }
                 };
 
                 // Set the module info before we flat map.
-                let mut module = self.cx.current_expansion.module.with_dir_path(path);
+                let mut module = self.cx.current_expansion.module.with_dir_path(dir_path);
                 module.mod_path.push(ident);
                 if let Some(file_path) = file_path {
                     module.file_path_stack.push(file_path);
@@ -1326,7 +1334,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                 let orig_module =
                     mem::replace(&mut self.cx.current_expansion.module, Rc::new(module));
                 let orig_dir_ownership =
-                    mem::replace(&mut self.cx.current_expansion.directory_ownership, ownership);
+                    mem::replace(&mut self.cx.current_expansion.directory_ownership, dir_ownership);
 
                 let result = noop_flat_map_item(item, self);
 

compiler/rustc_expand/src/module.rs

@@ -1,3 +1,4 @@
+use crate::base::ModuleData;
 use rustc_ast::ptr::P;
 use rustc_ast::{token, Attribute, Item};
 use rustc_errors::{struct_span_err, PResult};
@@ -9,12 +10,6 @@ use rustc_span::Span;
 
 use std::path::{self, Path, PathBuf};
 
-#[derive(Clone)]
-pub struct Directory {
-    pub path: PathBuf,
-    pub ownership: DirectoryOwnership,
-}
-
 #[derive(Copy, Clone)]
 pub enum DirectoryOwnership {
     Owned {
@@ -38,22 +33,30 @@ pub struct ModulePathSuccess {
     pub ownership: DirectoryOwnership,
 }
 
+crate struct ParsedExternalMod {
+    pub items: Vec<P<Item>>,
+    pub inner_span: Span,
+    pub file_path: PathBuf,
+    pub dir_path: PathBuf,
+    pub dir_ownership: DirectoryOwnership,
+}
+
 crate fn parse_external_mod(
     sess: &Session,
     id: Ident,
     span: Span, // The span to blame on errors.
-    file_path_stack: &[PathBuf],
-    Directory { mut ownership, path }: Directory,
+    module: &ModuleData,
+    mut dir_ownership: DirectoryOwnership,
     attrs: &mut Vec<Attribute>,
-) -> (Vec<P<Item>>, Span, PathBuf, Directory) {
+) -> ParsedExternalMod {
     // We bail on the first error, but that error does not cause a fatal error... (1)
     let result: PResult<'_, _> = try {
         // Extract the file path and the new ownership.
-        let mp = submod_path(sess, id, span, &attrs, ownership, &path)?;
-        ownership = mp.ownership;
+        let mp = submod_path(sess, id, span, &attrs, dir_ownership, &module.dir_path)?;
+        dir_ownership = mp.ownership;
 
         // Ensure file paths are acyclic.
-        error_on_circular_module(&sess.parse_sess, span, &mp.path, file_path_stack)?;
+        error_on_circular_module(&sess.parse_sess, span, &mp.path, &module.file_path_stack)?;
 
         // Actually parse the external file as a module.
         let mut parser = new_parser_from_file(&sess.parse_sess, &mp.path, Some(span));
@@ -65,9 +68,9 @@ crate fn parse_external_mod(
     let (items, inner_span, file_path) = result.map_err(|mut err| err.emit()).unwrap_or_default();
 
     // Extract the directory path for submodules of the module.
-    let path = file_path.parent().unwrap_or(&file_path).to_owned();
+    let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
 
-    (items, inner_span, file_path, Directory { ownership, path })
+    ParsedExternalMod { items, inner_span, file_path, dir_path, dir_ownership }
 }
 
 fn error_on_circular_module<'a>(
@@ -92,27 +95,30 @@ crate fn push_directory(
     sess: &Session,
     id: Ident,
     attrs: &[Attribute],
-    Directory { mut ownership, mut path }: Directory,
-) -> Directory {
-    if let Some(filename) = sess.first_attr_value_str_by_name(attrs, sym::path) {
-        path.push(&*filename.as_str());
-        ownership = DirectoryOwnership::Owned { relative: None };
+    module: &ModuleData,
+    mut dir_ownership: DirectoryOwnership,
+) -> (PathBuf, DirectoryOwnership) {
+    let mut dir_path = module.dir_path.clone();
+    if let Some(file_path) = sess.first_attr_value_str_by_name(attrs, sym::path) {
+        dir_path.push(&*file_path.as_str());
+        dir_ownership = DirectoryOwnership::Owned { relative: None };
     } else {
         // We have to push on the current module name in the case of relative
         // paths in order to ensure that any additional module paths from inline
         // `mod x { ... }` come after the relative extension.
         //
         // For example, a `mod z { ... }` inside `x/y.rs` should set the current
         // directory path to `/x/y/z`, not `/x/z` with a relative offset of `y`.
-        if let DirectoryOwnership::Owned { relative } = &mut ownership {
+        if let DirectoryOwnership::Owned { relative } = &mut dir_ownership {
             if let Some(ident) = relative.take() {
                 // Remove the relative offset.
-                path.push(&*ident.as_str());
+                dir_path.push(&*ident.as_str());
             }
         }
-        path.push(&*id.as_str());
+        dir_path.push(&*id.as_str());
     }
-    Directory { ownership, path }
+
+    (dir_path, dir_ownership)
 }
 
 fn submod_path<'a>(