Split-up the AST to index it.

Author: cjgillot

Cargo.lock

@@ -3354,7 +3354,6 @@ version = "0.0.0"
 dependencies = [
  "rustc_abi",
  "rustc_ast",
- "rustc_ast_pretty",
  "rustc_attr_data_structures",
  "rustc_attr_parsing",
  "rustc_data_structures",

compiler/rustc_ast/src/ast.rs

@@ -4055,14 +4055,14 @@ impl TryFrom<ItemKind> for ForeignItemKind {
 pub type ForeignItem = Item<ForeignItemKind>;
 
 #[derive(Debug)]
-pub enum AstOwner<'a> {
+pub enum AstOwner {
     NonOwner,
     Synthetic(rustc_span::def_id::LocalDefId),
-    Crate(&'a Crate),
-    Item(&'a Item),
-    TraitItem(&'a AssocItem),
-    ImplItem(&'a AssocItem),
-    ForeignItem(&'a ForeignItem),
+    Crate(P<Crate>),
+    Item(P<Item>),
+    TraitItem(P<AssocItem>),
+    ImplItem(P<AssocItem>),
+    ForeignItem(P<ForeignItem>),
 }
 
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.

compiler/rustc_ast/src/mut_visit.rs

@@ -142,7 +142,10 @@ pub fn walk_flat_map_stmt<T: MutVisitor>(
     stmts
 }
 
-fn walk_flat_map_stmt_kind<T: MutVisitor>(vis: &mut T, kind: StmtKind) -> SmallVec<[StmtKind; 1]> {
+pub fn walk_flat_map_stmt_kind<T: MutVisitor>(
+    vis: &mut T,
+    kind: StmtKind,
+) -> SmallVec<[StmtKind; 1]> {
     match kind {
         StmtKind::Let(mut local) => smallvec![StmtKind::Let({
             vis.visit_local(&mut local);

compiler/rustc_ast_lowering/Cargo.toml

@@ -10,7 +10,6 @@ doctest = false
 # tidy-alphabetical-start
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
-rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }

compiler/rustc_ast_lowering/src/block.rs

@@ -43,17 +43,11 @@ impl<'hir> LoweringContext<'hir> {
                     stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Item(it) => {
-                    stmts.extend(self.lower_item_ref(it).into_iter().enumerate().map(
-                        |(i, item_id)| {
-                            let hir_id = match i {
-                                0 => self.lower_node_id(s.id),
-                                _ => self.next_id(),
-                            };
-                            let kind = hir::StmtKind::Item(item_id);
-                            let span = self.lower_span(s.span);
-                            hir::Stmt { hir_id, kind, span }
-                        },
-                    ));
+                    let item_id = self.lower_item_ref(it);
+                    let hir_id = self.lower_node_id(s.id);
+                    let kind = hir::StmtKind::Item(item_id);
+                    let span = self.lower_span(s.span);
+                    stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Expr(e) => {
                     let e = self.lower_expr(e);

compiler/rustc_ast_lowering/src/expr.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 use rustc_ast::ptr::P as AstP;
 use rustc_ast::*;
-use rustc_ast_pretty::pprust::expr_to_string;
 use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir as hir;
@@ -463,13 +462,16 @@ impl<'hir> LoweringContext<'hir> {
         let mut invalid_expr_error = |tcx: TyCtxt<'_>, span| {
             // Avoid emitting the error multiple times.
             if error.is_none() {
+                let sm = tcx.sess.source_map();
                 let mut const_args = vec![];
                 let mut other_args = vec![];
                 for (idx, arg) in args.iter().enumerate() {
-                    if legacy_args_idx.contains(&idx) {
-                        const_args.push(format!("{{ {} }}", expr_to_string(arg)));
-                    } else {
-                        other_args.push(expr_to_string(arg));
+                    if let Ok(arg) = sm.span_to_snippet(arg.span) {
+                        if legacy_args_idx.contains(&idx) {
+                            const_args.push(format!("{{ {} }}", arg));
+                        } else {
+                            other_args.push(arg);
+                        }
                     }
                 }
                 let suggestion = UseConstGenericArg {

compiler/rustc_ast_lowering/src/item.rs

@@ -10,7 +10,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{DesugaringKind, Ident, Span, Symbol, kw, sym};
-use smallvec::{SmallVec, smallvec};
+use smallvec::SmallVec;
 use thin_vec::ThinVec;
 use tracing::instrument;
 
@@ -27,6 +27,7 @@ use super::{
 pub(super) struct ItemLowerer<'hir> {
     pub(super) tcx: TyCtxt<'hir>,
     pub(super) resolver: &'hir ResolverAstLowering,
+    pub(super) next_node_id: NodeId,
 }
 
 /// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set the span
@@ -56,7 +57,7 @@ impl<'hir> ItemLowerer<'hir> {
         owner: NodeId,
         f: impl FnOnce(&mut LoweringContext<'hir>) -> hir::OwnerNode<'hir>,
     ) -> hir::MaybeOwner<'hir> {
-        let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner);
+        let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner, self.next_node_id);
 
         let item = f(&mut lctx);
         debug_assert_eq!(lctx.current_hir_id_owner, item.def_id());
@@ -105,28 +106,12 @@ impl<'hir> LoweringContext<'hir> {
                 inner_span: self.lower_span(spans.inner_span),
                 inject_use_span: self.lower_span(spans.inject_use_span),
             },
-            item_ids: self.arena.alloc_from_iter(items.iter().flat_map(|x| self.lower_item_ref(x))),
+            item_ids: self.arena.alloc_from_iter(items.iter().map(|x| self.lower_item_ref(x))),
         })
     }
 
-    pub(super) fn lower_item_ref(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
-        let mut node_ids = smallvec![hir::ItemId { owner_id: self.owner_id(i.id) }];
-        if let ItemKind::Use(use_tree) = &i.kind {
-            self.lower_item_id_use_tree(use_tree, &mut node_ids);
-        }
-        node_ids
-    }
-
-    fn lower_item_id_use_tree(&mut self, tree: &UseTree, vec: &mut SmallVec<[hir::ItemId; 1]>) {
-        match &tree.kind {
-            UseTreeKind::Nested { items, .. } => {
-                for &(ref nested, id) in items {
-                    vec.push(hir::ItemId { owner_id: self.owner_id(id) });
-                    self.lower_item_id_use_tree(nested, vec);
-                }
-            }
-            UseTreeKind::Simple(..) | UseTreeKind::Glob => {}
-        }
+    pub(super) fn lower_item_ref(&mut self, i: &Item) -> hir::ItemId {
+        hir::ItemId { owner_id: self.owner_id(i.id) }
     }
 
     fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {