Rename hygiene vars and fields to span_map

Author: Veykril

crates/hir-def/src/attr.rs

@@ -415,35 +415,32 @@ impl AttrsWithOwner {
             AttrDefId::StaticId(it) => attrs_from_item_tree_assoc(db, it),
             AttrDefId::FunctionId(it) => attrs_from_item_tree_assoc(db, it),
             AttrDefId::TypeAliasId(it) => attrs_from_item_tree_assoc(db, it),
-            AttrDefId::GenericParamId(it) => {
-                // FIXME: we could probably just make these relative to the params?
-                match it {
-                    GenericParamId::ConstParamId(it) => {
-                        let src = it.parent().child_source(db);
-                        RawAttrs::from_attrs_owner(
-                            db.upcast(),
-                            src.with_value(&src.value[it.local_id()]),
-                            db.span_map(src.file_id).as_ref(),
-                        )
-                    }
-                    GenericParamId::TypeParamId(it) => {
-                        let src = it.parent().child_source(db);
-                        RawAttrs::from_attrs_owner(
-                            db.upcast(),
-                            src.with_value(&src.value[it.local_id()]),
-                            db.span_map(src.file_id).as_ref(),
-                        )
-                    }
-                    GenericParamId::LifetimeParamId(it) => {
-                        let src = it.parent.child_source(db);
-                        RawAttrs::from_attrs_owner(
-                            db.upcast(),
-                            src.with_value(&src.value[it.local_id]),
-                            db.span_map(src.file_id).as_ref(),
-                        )
-                    }
+            AttrDefId::GenericParamId(it) => match it {
+                GenericParamId::ConstParamId(it) => {
+                    let src = it.parent().child_source(db);
+                    RawAttrs::from_attrs_owner(
+                        db.upcast(),
+                        src.with_value(&src.value[it.local_id()]),
+                        db.span_map(src.file_id).as_ref(),
+                    )
                 }
-            }
+                GenericParamId::TypeParamId(it) => {
+                    let src = it.parent().child_source(db);
+                    RawAttrs::from_attrs_owner(
+                        db.upcast(),
+                        src.with_value(&src.value[it.local_id()]),
+                        db.span_map(src.file_id).as_ref(),
+                    )
+                }
+                GenericParamId::LifetimeParamId(it) => {
+                    let src = it.parent.child_source(db);
+                    RawAttrs::from_attrs_owner(
+                        db.upcast(),
+                        src.with_value(&src.value[it.local_id]),
+                        db.span_map(src.file_id).as_ref(),
+                    )
+                }
+            },
             AttrDefId::ExternBlockId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::ExternCrateId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::UseId(it) => attrs_from_item_tree_loc(db, it),

crates/hir-def/src/expander.rs

@@ -18,7 +18,7 @@ use crate::{
 #[derive(Debug)]
 pub struct Expander {
     cfg_options: CfgOptions,
-    hygiene: SpanMap,
+    span_map: SpanMap,
     krate: CrateId,
     pub(crate) current_file_id: HirFileId,
     pub(crate) module: ModuleId,
@@ -41,7 +41,7 @@ impl Expander {
             recursion_depth: 0,
             recursion_limit,
             cfg_options: db.crate_graph()[module.krate].cfg_options.clone(),
-            hygiene: db.span_map(current_file_id),
+            span_map: db.span_map(current_file_id),
             krate: module.krate,
         }
     }
@@ -95,7 +95,7 @@ impl Expander {
     }
 
     pub fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
-        self.hygiene = db.span_map(mark.file_id);
+        self.span_map = db.span_map(mark.file_id);
         self.current_file_id = mark.file_id;
         if self.recursion_depth == u32::MAX {
             // Recursion limit has been reached somewhere in the macro expansion tree. Reset the
@@ -110,15 +110,15 @@ impl Expander {
     }
 
     pub fn ctx<'a>(&self, db: &'a dyn DefDatabase) -> LowerCtx<'a> {
-        LowerCtx::new(db, self.hygiene.clone(), self.current_file_id)
+        LowerCtx::new(db, self.span_map.clone(), self.current_file_id)
     }
 
     pub(crate) fn to_source<T>(&self, value: T) -> InFile<T> {
         InFile { file_id: self.current_file_id, value }
     }
 
     pub(crate) fn parse_attrs(&self, db: &dyn DefDatabase, owner: &dyn ast::HasAttrs) -> Attrs {
-        Attrs::filter(db, self.krate, RawAttrs::new(db.upcast(), owner, self.hygiene.as_ref()))
+        Attrs::filter(db, self.krate, RawAttrs::new(db.upcast(), owner, self.span_map.as_ref()))
     }
 
     pub(crate) fn cfg_options(&self) -> &CfgOptions {
@@ -130,7 +130,7 @@ impl Expander {
     }
 
     pub(crate) fn parse_path(&mut self, db: &dyn DefDatabase, path: ast::Path) -> Option<Path> {
-        let ctx = LowerCtx::new(db, self.hygiene.clone(), self.current_file_id);
+        let ctx = LowerCtx::new(db, self.span_map.clone(), self.current_file_id);
         Path::from_src(path, &ctx)
     }
 
@@ -174,7 +174,7 @@ impl Expander {
                     let parse = value.cast::<T>()?;
 
                     self.recursion_depth += 1;
-                    self.hygiene = db.span_map(file_id);
+                    self.span_map = db.span_map(file_id);
                     let old_file_id = std::mem::replace(&mut self.current_file_id, file_id);
                     let mark = Mark {
                         file_id: old_file_id,

crates/hir-def/src/item_tree.rs

@@ -776,8 +776,8 @@ impl Use {
         // Note: The AST unwraps are fine, since if they fail we should have never obtained `index`.
         let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());
         let ast_use_tree = ast.use_tree().expect("missing `use_tree`");
-        let hygiene = db.span_map(file_id);
-        let (_, source_map) = lower::lower_use_tree(db, hygiene.as_ref(), ast_use_tree)
+        let span_map = db.span_map(file_id);
+        let (_, source_map) = lower::lower_use_tree(db, span_map.as_ref(), ast_use_tree)
             .expect("failed to lower use tree");
         source_map[index].clone()
     }
@@ -791,8 +791,8 @@ impl Use {
         // Note: The AST unwraps are fine, since if they fail we should have never obtained `index`.
         let ast = InFile::new(file_id, self.ast_id).to_node(db.upcast());
         let ast_use_tree = ast.use_tree().expect("missing `use_tree`");
-        let hygiene = db.span_map(file_id);
-        lower::lower_use_tree(db, hygiene.as_ref(), ast_use_tree)
+        let span_map = db.span_map(file_id);
+        lower::lower_use_tree(db, span_map.as_ref(), ast_use_tree)
             .expect("failed to lower use tree")
             .1
     }

crates/hir-def/src/item_tree/lower.rs

@@ -657,7 +657,8 @@ impl<'a> Ctx<'a> {
     }
 
     fn lower_visibility(&mut self, item: &dyn ast::HasVisibility) -> RawVisibilityId {
-        let vis = RawVisibility::from_ast_with_hygiene(self.db, item.visibility(), self.span_map());
+        let vis =
+            RawVisibility::from_ast_with_span_map(self.db, item.visibility(), self.span_map());
         self.data().vis.alloc(vis)
     }
 
@@ -735,7 +736,7 @@ fn lower_abi(abi: ast::Abi) -> Interned<str> {
 
 struct UseTreeLowering<'a> {
     db: &'a dyn DefDatabase,
-    hygiene: SpanMapRef<'a>,
+    span_map: SpanMapRef<'a>,
     mapping: Arena<ast::UseTree>,
 }
 
@@ -748,7 +749,7 @@ impl UseTreeLowering<'_> {
                 // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
                 // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
                 Some(path) => {
-                    match ModPath::from_src(self.db.upcast(), path, self.hygiene) {
+                    match ModPath::from_src(self.db.upcast(), path, self.span_map) {
                         Some(it) => Some(it),
                         None => return None, // FIXME: report errors somewhere
                     }
@@ -767,7 +768,7 @@ impl UseTreeLowering<'_> {
         } else {
             let is_glob = tree.star_token().is_some();
             let path = match tree.path() {
-                Some(path) => Some(ModPath::from_src(self.db.upcast(), path, self.hygiene)?),
+                Some(path) => Some(ModPath::from_src(self.db.upcast(), path, self.span_map)?),
                 None => None,
             };
             let alias = tree.rename().map(|a| {
@@ -803,10 +804,10 @@ impl UseTreeLowering<'_> {
 
 pub(crate) fn lower_use_tree(
     db: &dyn DefDatabase,
-    hygiene: SpanMapRef<'_>,
+    span_map: SpanMapRef<'_>,
     tree: ast::UseTree,
 ) -> Option<(UseTree, Arena<ast::UseTree>)> {
-    let mut lowering = UseTreeLowering { db, hygiene, mapping: Arena::new() };
+    let mut lowering = UseTreeLowering { db, span_map, mapping: Arena::new() };
     let tree = lowering.lower_use_tree(tree)?;
     Some((tree, lowering.mapping))
 }

crates/hir-def/src/lower.rs

@@ -13,26 +13,30 @@ use crate::{db::DefDatabase, path::Path};
 
 pub struct LowerCtx<'a> {
     pub db: &'a dyn DefDatabase,
-    hygiene: SpanMap,
+    span_map: SpanMap,
     // FIXME: This optimization is probably pointless, ast id map should pretty much always exist anyways.
     ast_id_map: Option<(HirFileId, OnceCell<Arc<AstIdMap>>)>,
 }
 
 impl<'a> LowerCtx<'a> {
-    pub fn new(db: &'a dyn DefDatabase, hygiene: SpanMap, file_id: HirFileId) -> Self {
-        LowerCtx { db, hygiene, ast_id_map: Some((file_id, OnceCell::new())) }
+    pub fn new(db: &'a dyn DefDatabase, span_map: SpanMap, file_id: HirFileId) -> Self {
+        LowerCtx { db, span_map, ast_id_map: Some((file_id, OnceCell::new())) }
     }
 
     pub fn with_file_id(db: &'a dyn DefDatabase, file_id: HirFileId) -> Self {
-        LowerCtx { db, hygiene: db.span_map(file_id), ast_id_map: Some((file_id, OnceCell::new())) }
+        LowerCtx {
+            db,
+            span_map: db.span_map(file_id),
+            ast_id_map: Some((file_id, OnceCell::new())),
+        }
     }
 
-    pub fn with_hygiene(db: &'a dyn DefDatabase, hygiene: SpanMap) -> Self {
-        LowerCtx { db, hygiene, ast_id_map: None }
+    pub fn with_span_map(db: &'a dyn DefDatabase, span_map: SpanMap) -> Self {
+        LowerCtx { db, span_map, ast_id_map: None }
     }
 
     pub(crate) fn span_map(&self) -> SpanMapRef<'_> {
-        self.hygiene.as_ref()
+        self.span_map.as_ref()
     }
 
     pub(crate) fn lower_path(&self, ast: ast::Path) -> Option<Path> {

crates/hir-def/src/path/lower.rs

@@ -26,7 +26,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx<'_>) -> Option<Path
     let mut type_anchor = None;
     let mut segments = Vec::new();
     let mut generic_args = Vec::new();
-    let hygiene = ctx.span_map();
+    let span_map = ctx.span_map();
     loop {
         let segment = path.segment()?;
 
@@ -39,7 +39,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx<'_>) -> Option<Path
                 let name = if name_ref.text() == "$crate" {
                     kind = resolve_crate_root(
                         ctx.db.upcast(),
-                        hygiene.span_for_range(name_ref.syntax().text_range()).ctx,
+                        span_map.span_for_range(name_ref.syntax().text_range()).ctx,
                     )
                     .map(PathKind::DollarCrate)
                     .unwrap_or(PathKind::Crate);
@@ -159,7 +159,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx<'_>) -> Option<Path
     // We follow what it did anyway :)
     if segments.len() == 1 && kind == PathKind::Plain {
         if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
-            let syn_ctxt = hygiene.span_for_range(path.segment()?.syntax().text_range()).ctx;
+            let syn_ctxt = span_map.span_for_range(path.segment()?.syntax().text_range()).ctx;
             if let Some(macro_call_id) = ctx.db.lookup_intern_syntax_context(syn_ctxt).outer_expn {
                 if ctx.db.lookup_intern_macro_call(macro_call_id).def.local_inner {
                     kind = match resolve_crate_root(ctx.db.upcast(), syn_ctxt) {

crates/hir-def/src/visibility.rs

@@ -34,30 +34,30 @@ impl RawVisibility {
         db: &dyn DefDatabase,
         node: InFile<Option<ast::Visibility>>,
     ) -> RawVisibility {
-        Self::from_ast_with_hygiene(db, node.value, db.span_map(node.file_id).as_ref())
+        Self::from_ast_with_span_map(db, node.value, db.span_map(node.file_id).as_ref())
     }
 
-    pub(crate) fn from_ast_with_hygiene(
+    pub(crate) fn from_ast_with_span_map(
         db: &dyn DefDatabase,
         node: Option<ast::Visibility>,
-        hygiene: SpanMapRef<'_>,
+        span_map: SpanMapRef<'_>,
     ) -> RawVisibility {
-        Self::from_ast_with_hygiene_and_default(db, node, RawVisibility::private(), hygiene)
+        Self::from_ast_with_span_map_and_default(db, node, RawVisibility::private(), span_map)
     }
 
-    pub(crate) fn from_ast_with_hygiene_and_default(
+    pub(crate) fn from_ast_with_span_map_and_default(
         db: &dyn DefDatabase,
         node: Option<ast::Visibility>,
         default: RawVisibility,
-        hygiene: SpanMapRef<'_>,
+        span_map: SpanMapRef<'_>,
     ) -> RawVisibility {
         let node = match node {
             None => return default,
             Some(node) => node,
         };
         match node.kind() {
             ast::VisibilityKind::In(path) => {
-                let path = ModPath::from_src(db.upcast(), path, hygiene);
+                let path = ModPath::from_src(db.upcast(), path, span_map);
                 let path = match path {
                     None => return RawVisibility::private(),
                     Some(path) => path,

crates/hir-expand/src/attrs.rs

@@ -42,18 +42,18 @@ impl RawAttrs {
     pub fn new(
         db: &dyn ExpandDatabase,
         owner: &dyn ast::HasAttrs,
-        hygiene: SpanMapRef<'_>,
+        span_map: SpanMapRef<'_>,
     ) -> Self {
         let entries = collect_attrs(owner)
             .filter_map(|(id, attr)| match attr {
                 Either::Left(attr) => {
-                    attr.meta().and_then(|meta| Attr::from_src(db, meta, hygiene, id))
+                    attr.meta().and_then(|meta| Attr::from_src(db, meta, span_map, id))
                 }
                 Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                     id,
                     input: Some(Interned::new(AttrInput::Literal(SmolStr::new(doc)))),
                     path: Interned::new(ModPath::from(crate::name!(doc))),
-                    ctxt: hygiene.span_for_range(comment.syntax().text_range()).ctx,
+                    ctxt: span_map.span_for_range(comment.syntax().text_range()).ctx,
                 }),
             })
             .collect::<Vec<_>>();
@@ -66,9 +66,9 @@ impl RawAttrs {
     pub fn from_attrs_owner(
         db: &dyn ExpandDatabase,
         owner: InFile<&dyn ast::HasAttrs>,
-        hygiene: SpanMapRef<'_>,
+        span_map: SpanMapRef<'_>,
     ) -> Self {
-        Self::new(db, owner.value, hygiene)
+        Self::new(db, owner.value, span_map)
     }
 
     pub fn merge(&self, other: Self) -> Self {
@@ -216,23 +216,23 @@ impl Attr {
     fn from_src(
         db: &dyn ExpandDatabase,
         ast: ast::Meta,
-        hygiene: SpanMapRef<'_>,
+        span_map: SpanMapRef<'_>,
         id: AttrId,
     ) -> Option<Attr> {
-        let path = Interned::new(ModPath::from_src(db, ast.path()?, hygiene)?);
+        let path = Interned::new(ModPath::from_src(db, ast.path()?, span_map)?);
         let input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
             let value = match lit.kind() {
                 ast::LiteralKind::String(string) => string.value()?.into(),
                 _ => lit.syntax().first_token()?.text().trim_matches('"').into(),
             };
             Some(Interned::new(AttrInput::Literal(value)))
         } else if let Some(tt) = ast.token_tree() {
-            let tree = syntax_node_to_token_tree(tt.syntax(), hygiene);
+            let tree = syntax_node_to_token_tree(tt.syntax(), span_map);
             Some(Interned::new(AttrInput::TokenTree(Box::new(tree))))
         } else {
             None
         };
-        Some(Attr { id, path, input, ctxt: hygiene.span_for_range(ast.syntax().text_range()).ctx })
+        Some(Attr { id, path, input, ctxt: span_map.span_for_range(ast.syntax().text_range()).ctx })
     }
 
     fn from_tt(db: &dyn ExpandDatabase, tt: &tt::Subtree, id: AttrId) -> Option<Attr> {

crates/hir-expand/src/eager.rs

@@ -127,7 +127,7 @@ fn lazy_expand(
 
 fn eager_macro_recur(
     db: &dyn ExpandDatabase,
-    hygiene: &ExpansionSpanMap,
+    span_map: &ExpansionSpanMap,
     curr: InFile<SyntaxNode>,
     krate: CrateId,
     call_site: SyntaxContextId,
@@ -170,7 +170,7 @@ fn eager_macro_recur(
         };
         let def = match call
             .path()
-            .and_then(|path| ModPath::from_src(db, path, SpanMapRef::ExpansionSpanMap(hygiene)))
+            .and_then(|path| ModPath::from_src(db, path, SpanMapRef::ExpansionSpanMap(span_map)))
         {
             Some(path) => match macro_resolver(path.clone()) {
                 Some(def) => def,