deps: apply rustc module loading changes

Author: calebcartwright

Diff for: src/formatting.rs

@@ -117,7 +117,7 @@ fn format_project(
 
     let files = modules::ModResolver::new(
         &parse_session,
-        directory_ownership.unwrap_or(DirectoryOwnership::UnownedViaMod),
+        directory_ownership.unwrap_or(DirectoryOwnership::UnownedViaBlock),
         !input_is_stdin && operation_setting.recursive,
     )
     .visit_crate(&krate)?;

Diff for: src/formatting/modules.rs

@@ -13,7 +13,9 @@ use crate::config::FileName;
 use crate::formatting::{
     attr::MetaVisitor,
     items::is_mod_decl,
-    syntux::parser::{Directory, DirectoryOwnership, ModulePathSuccess, Parser, ParserError},
+    syntux::parser::{
+        Directory, DirectoryOwnership, ModError, ModulePathSuccess, Parser, ParserError,
+    },
     syntux::session::ParseSess,
     utils::contains_skip,
 };
@@ -104,6 +106,9 @@ impl<'a> AstLike for Module<'a> {
     fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<ast::Attribute>)) {
         f(&mut self.inner_attr)
     }
+    fn tokens_mut(&mut self) -> Option<&mut Option<rustc_ast::tokenstream::LazyTokenStream>> {
+        unimplemented!()
+    }
 }
 
 /// Maps each module to the corresponding file.
@@ -371,7 +376,7 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
     ) -> Result<Option<SubModKind<'ast>>, ModuleResolutionError> {
         let relative = match self.directory.ownership {
             DirectoryOwnership::Owned { relative } => relative,
-            DirectoryOwnership::UnownedViaBlock | DirectoryOwnership::UnownedViaMod => None,
+            DirectoryOwnership::UnownedViaBlock => None,
         };
         if let Some(path) =
             Parser::submod_path_from_attr(sub_mod.outer_attrs(), &self.directory.path)
@@ -412,34 +417,35 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
         match self
             .parse_sess
             .default_submod_path(sub_mod.ident(), relative, &self.directory.path)
-            .result
         {
             Ok(ModulePathSuccess {
-                path, ownership, ..
+                file_path,
+                dir_ownership,
+                ..
             }) => {
                 let outside_mods_empty = mods_outside_ast.is_empty();
                 let should_insert = !mods_outside_ast
                     .iter()
-                    .any(|(outside_path, _, _)| outside_path == &path);
-                if self.parse_sess.is_file_parsed(&path) {
+                    .any(|(outside_path, _, _)| outside_path == &file_path);
+                if self.parse_sess.is_file_parsed(&file_path) {
                     if outside_mods_empty {
                         return Ok(None);
                     } else {
                         if should_insert {
-                            mods_outside_ast.push((path, ownership, sub_mod.clone()));
+                            mods_outside_ast.push((file_path, dir_ownership, sub_mod.clone()));
                         }
                         return Ok(Some(SubModKind::MultiExternal(mods_outside_ast)));
                     }
                 }
                 match Parser::parse_file_as_module(
                     self.parse_sess,
-                    &path,
+                    &file_path,
                     sub_mod.outside_ast_mod_span(),
                 ) {
                     Ok((attrs, items, span)) if outside_mods_empty => {
                         Ok(Some(SubModKind::External(
-                            path,
-                            ownership,
+                            file_path,
+                            dir_ownership,
                             Module::new(
                                 span,
                                 Some(Cow::Owned(ast::ModKind::Unloaded)),
@@ -451,8 +457,8 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
                     }
                     Ok((attrs, items, span)) => {
                         mods_outside_ast.push((
-                            path.clone(),
-                            ownership,
+                            file_path.clone(),
+                            dir_ownership,
                             Module::new(
                                 span,
                                 Some(Cow::Owned(ast::ModKind::Unloaded)),
@@ -462,39 +468,38 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
                             ),
                         ));
                         if should_insert {
-                            mods_outside_ast.push((path, ownership, sub_mod.clone()));
+                            mods_outside_ast.push((file_path, dir_ownership, sub_mod.clone()));
                         }
                         Ok(Some(SubModKind::MultiExternal(mods_outside_ast)))
                     }
                     Err(ParserError::ParseError) => Err(ModuleResolutionError {
                         module: sub_mod.name(),
-                        kind: ModuleResolutionErrorKind::ParseError { file: path },
+                        kind: ModuleResolutionErrorKind::ParseError { file: file_path },
                     }),
                     Err(..) if outside_mods_empty => Err(ModuleResolutionError {
                         module: sub_mod.name(),
-                        kind: ModuleResolutionErrorKind::NotFound { file: path },
+                        kind: ModuleResolutionErrorKind::NotFound { file: file_path },
                     }),
                     Err(..) => {
                         if should_insert {
-                            mods_outside_ast.push((path, ownership, sub_mod.clone()));
+                            mods_outside_ast.push((file_path, dir_ownership, sub_mod.clone()));
                         }
                         Ok(Some(SubModKind::MultiExternal(mods_outside_ast)))
                     }
                 }
             }
-            Err(mut e) if !mods_outside_ast.is_empty() => {
-                e.cancel();
+            Err(mod_err) if !mods_outside_ast.is_empty() => {
+                if let ModError::ParserError(mut e) = mod_err {
+                    e.cancel();
+                }
                 Ok(Some(SubModKind::MultiExternal(mods_outside_ast)))
             }
-            Err(mut e) => {
-                e.cancel();
-                Err(ModuleResolutionError {
-                    module: sub_mod.name(),
-                    kind: ModuleResolutionErrorKind::NotFound {
-                        file: self.directory.path.clone(),
-                    },
-                })
-            }
+            Err(_) => Err(ModuleResolutionError {
+                module: sub_mod.name(),
+                kind: ModuleResolutionErrorKind::NotFound {
+                    file: self.directory.path.clone(),
+                },
+            }),
         }
     }
 

Diff for: src/formatting/syntux/parser.rs

@@ -14,8 +14,9 @@ use crate::formatting::attr::first_attr_value_str_by_name;
 use crate::formatting::syntux::session::ParseSess;
 use crate::{Config, Input};
 
-pub(crate) type DirectoryOwnership = rustc_expand::module::DirectoryOwnership;
+pub(crate) type DirectoryOwnership = rustc_expand::module::DirOwnership;
 pub(crate) type ModulePathSuccess = rustc_expand::module::ModulePathSuccess;
+pub(crate) type ModError<'a> = rustc_expand::module::ModError<'a>;
 
 #[derive(Clone)]
 pub(crate) struct Directory {

Diff for: src/formatting/syntux/session.rs

@@ -146,14 +146,8 @@ impl ParseSess {
         id: symbol::Ident,
         relative: Option<symbol::Ident>,
         dir_path: &Path,
-    ) -> rustc_expand::module::ModulePath<'_> {
-        rustc_expand::module::default_submod_path(
-            &self.parse_sess,
-            id,
-            rustc_span::DUMMY_SP,
-            relative,
-            dir_path,
-        )
+    ) -> Result<rustc_expand::module::ModulePathSuccess, rustc_expand::module::ModError<'_>> {
+        rustc_expand::module::default_submod_path(&self.parse_sess, id, relative, dir_path)
     }
 
     pub(crate) fn is_file_parsed(&self, path: &Path) -> bool {