3 files changed, 531 insertions, 30 deletions
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
new file mode 100644
index 000000000..44cdcc296
--- /dev/null
+++ b/crates/hir/src/display.rs
@@ -0,0 +1,441 @@
+//! HirDisplay implementations for various hir types.
+use hir_def::{
+    adt::VariantData,
+    generics::{TypeParamProvenance, WherePredicate, WherePredicateTypeTarget},
+    type_ref::{TypeBound, TypeRef},
+    AdtId, GenericDefId,
+};
+use hir_ty::display::{
+    write_bounds_like_dyn_trait_with_prefix, write_visibility, HirDisplay, HirDisplayError,
+    HirFormatter,
+};
+use syntax::ast::{self, NameOwner};
+use crate::{
+    Const, ConstParam, Enum, Field, Function, HasVisibility, Module, Static, Struct, Substs, Trait,
+    Type, TypeAlias, TypeParam, Union, Variant,
+};
+impl HirDisplay for Function {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        let data = f.db.function_data(self.id);
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let qual = &data.qualifier;
+        if qual.is_default {
+            write!(f, "default ")?;
+        }
+        if qual.is_const {
+            write!(f, "const ")?;
+        }
+        if qual.is_async {
+            write!(f, "async ")?;
+        }
+        if qual.is_unsafe {
+            write!(f, "unsafe ")?;
+        }
+        if let Some(abi) = &qual.abi {
+            // FIXME: String escape?
+            write!(f, "extern \"{}\" ", abi)?;
+        }
+        write!(f, "fn {}", data.name)?;
+        write_generic_params(GenericDefId::FunctionId(self.id), f)?;
+        write!(f, "(")?;
+        let write_self_param = |ty: &TypeRef, f: &mut HirFormatter| match ty {
+            TypeRef::Path(p) if p.is_self_type() => write!(f, "self"),
+            TypeRef::Reference(inner, lifetime, mut_) if matches!(&**inner,TypeRef::Path(p) if p.is_self_type()) =>
+            {
+                write!(f, "&")?;
+                if let Some(lifetime) = lifetime {
+                    write!(f, "{} ", lifetime.name)?;
+                }
+                if let hir_def::type_ref::Mutability::Mut = mut_ {
+                    write!(f, "mut ")?;
+                }
+                write!(f, "self")
+            }
+            _ => {
+                write!(f, "self: ")?;
+                ty.hir_fmt(f)
+            }
+        };
+        let mut first = true;
+        for (param, type_ref) in self.assoc_fn_params(f.db).into_iter().zip(&data.params) {
+            if !first {
+                write!(f, ", ")?;
+            } else {
+                first = false;
+                if data.has_self_param {
+                    write_self_param(type_ref, f)?;
+                    continue;
+                }
+            }
+            match param.pattern_source(f.db) {
+                Some(ast::Pat::IdentPat(p)) if p.name().is_some() => {
+                    write!(f, "{}: ", p.name().unwrap())?
+                }
+                _ => write!(f, "_: ")?,
+            }
+            // FIXME: Use resolved `param.ty` or raw `type_ref`?
+            // The former will ignore lifetime arguments currently.
+            type_ref.hir_fmt(f)?;
+        }
+        write!(f, ")")?;
+        // `FunctionData::ret_type` will be `::core::future::Future<Output = ...>` for async fns.
+        // Use ugly pattern match to strip the Future trait.
+        // Better way?
+        let ret_type = if !qual.is_async {
+            &data.ret_type
+        } else {
+            match &data.ret_type {
+                TypeRef::ImplTrait(bounds) => match &bounds[0] {
+                    TypeBound::Path(path) => {
+                        path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
+                            [0]
+                        .type_ref
+                        .as_ref()
+                        .unwrap()
+                    }
+                    _ => panic!("Async fn ret_type should be impl Future"),
+                },
+                _ => panic!("Async fn ret_type should be impl Future"),
+            }
+        };
+        match ret_type {
+            TypeRef::Tuple(tup) if tup.is_empty() => {}
+            ty => {
+                write!(f, " -> ")?;
+                ty.hir_fmt(f)?;
+            }
+        }
+        write_where_clause(GenericDefId::FunctionId(self.id), f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Struct {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "struct ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::StructId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Enum {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "enum ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Union {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "union ")?;
+        write!(f, "{}", self.name(f.db))?;
+        let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id));
+        write_generic_params(def_id, f)?;
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Field {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?;
+        write!(f, "{}: ", self.name(f.db))?;
+        self.signature_ty(f.db).hir_fmt(f)
+    }
+}
+impl HirDisplay for Variant {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))?;
+        let data = self.variant_data(f.db);
+        match &*data {
+            VariantData::Unit => {}
+            VariantData::Tuple(fields) => {
+                write!(f, "(")?;
+                let mut first = true;
+                for (_, field) in fields.iter() {
+                    if first {
+                        first = false;
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    // Enum variant fields must be pub.
+                    field.type_ref.hir_fmt(f)?;
+                }
+                write!(f, ")")?;
+            }
+            VariantData::Record(fields) => {
+                write!(f, " {{")?;
+                let mut first = true;
+                for (_, field) in fields.iter() {
+                    if first {
+                        first = false;
+                        write!(f, " ")?;
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    // Enum variant fields must be pub.
+                    write!(f, "{}: ", field.name)?;
+                    field.type_ref.hir_fmt(f)?;
+                }
+                write!(f, " }}")?;
+            }
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for Type {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        self.ty.value.hir_fmt(f)
+    }
+}
+impl HirDisplay for TypeParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "{}", self.name(f.db))?;
+        let bounds = f.db.generic_predicates_for_param(self.id);
+        let substs = Substs::type_params(f.db, self.id.parent);
+        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
+        if !(predicates.is_empty() || f.omit_verbose_types()) {
+            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for ConstParam {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write!(f, "const {}: ", self.name(f.db))?;
+        self.ty(f.db).hir_fmt(f)
+    }
+}
+fn write_generic_params(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+    let params = f.db.generic_params(def);
+    if params.lifetimes.is_empty()
+        && params.consts.is_empty()
+        && params
+            .types
+            .iter()
+            .all(|(_, param)| !matches!(param.provenance, TypeParamProvenance::TypeParamList))
+    {
+        return Ok(());
+    }
+    write!(f, "<")?;
+    let mut first = true;
+    let mut delim = |f: &mut HirFormatter| {
+        if first {
+            first = false;
+            Ok(())
+        } else {
+            write!(f, ", ")
+        }
+    };
+    for (_, lifetime) in params.lifetimes.iter() {
+        delim(f)?;
+        write!(f, "{}", lifetime.name)?;
+    }
+    for (_, ty) in params.types.iter() {
+        if ty.provenance != TypeParamProvenance::TypeParamList {
+            continue;
+        }
+        if let Some(name) = &ty.name {
+            delim(f)?;
+            write!(f, "{}", name)?;
+            if let Some(default) = &ty.default {
+                write!(f, " = ")?;
+                default.hir_fmt(f)?;
+            }
+        }
+    }
+    for (_, konst) in params.consts.iter() {
+        delim(f)?;
+        write!(f, "const {}: ", konst.name)?;
+        konst.ty.hir_fmt(f)?;
+    }
+    write!(f, ">")?;
+    Ok(())
+}
+fn write_where_clause(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+    let params = f.db.generic_params(def);
+    if params.where_predicates.is_empty() {
+        return Ok(());
+    }
+    let write_target = |target: &WherePredicateTypeTarget, f: &mut HirFormatter| match target {
+        WherePredicateTypeTarget::TypeRef(ty) => ty.hir_fmt(f),
+        WherePredicateTypeTarget::TypeParam(id) => match &params.types[*id].name {
+            Some(name) => write!(f, "{}", name),
+            None => write!(f, "{{unnamed}}"),
+        },
+    };
+    write!(f, "\nwhere")?;
+    for (pred_idx, pred) in params.where_predicates.iter().enumerate() {
+        let prev_pred =
+            if pred_idx == 0 { None } else { Some(&params.where_predicates[pred_idx - 1]) };
+        let new_predicate = |f: &mut HirFormatter| {
+            write!(f, "{}", if pred_idx == 0 { "\n    " } else { ",\n    " })
+        };
+        match pred {
+            WherePredicate::TypeBound { target, bound } => {
+                if matches!(prev_pred, Some(WherePredicate::TypeBound { target: target_, .. }) if target_ == target)
+                {
+                    write!(f, " + ")?;
+                } else {
+                    new_predicate(f)?;
+                    write_target(target, f)?;
+                    write!(f, ": ")?;
+                }
+                bound.hir_fmt(f)?;
+            }
+            WherePredicate::Lifetime { target, bound } => {
+                if matches!(prev_pred, Some(WherePredicate::Lifetime { target: target_, .. }) if target_ == target)
+                {
+                    write!(f, " + {}", bound.name)?;
+                } else {
+                    new_predicate(f)?;
+                    write!(f, "{}: {}", target.name, bound.name)?;
+                }
+            }
+            WherePredicate::ForLifetime { lifetimes, target, bound } => {
+                if matches!(
+                    prev_pred,
+                    Some(WherePredicate::ForLifetime { lifetimes: lifetimes_, target: target_, .. })
+                    if lifetimes_ == lifetimes && target_ == target,
+                ) {
+                    write!(f, " + ")?;
+                } else {
+                    new_predicate(f)?;
+                    write!(f, "for<")?;
+                    for (idx, lifetime) in lifetimes.iter().enumerate() {
+                        if idx != 0 {
+                            write!(f, ", ")?;
+                        }
+                        write!(f, "{}", lifetime)?;
+                    }
+                    write!(f, "> ")?;
+                    write_target(target, f)?;
+                    write!(f, ": ")?;
+                }
+                bound.hir_fmt(f)?;
+            }
+        }
+    }
+    // End of final predicate. There must be at least one predicate here.
+    write!(f, ",")?;
+    Ok(())
+}
+impl HirDisplay for Const {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.const_data(self.id);
+        write!(f, "const ")?;
+        match &data.name {
+            Some(name) => write!(f, "{}: ", name)?,
+            None => write!(f, "_: ")?,
+        }
+        data.type_ref.hir_fmt(f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Static {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.static_data(self.id);
+        write!(f, "static ")?;
+        if data.mutable {
+            write!(f, "mut ")?;
+        }
+        match &data.name {
+            Some(name) => write!(f, "{}: ", name)?,
+            None => write!(f, "_: ")?,
+        }
+        data.type_ref.hir_fmt(f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for Trait {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.trait_data(self.id);
+        if data.is_unsafe {
+            write!(f, "unsafe ")?;
+        }
+        if data.is_auto {
+            write!(f, "auto ")?;
+        }
+        write!(f, "trait {}", data.name)?;
+        let def_id = GenericDefId::TraitId(self.id);
+        write_generic_params(def_id, f)?;
+        if !data.bounds.is_empty() {
+            write!(f, ": ")?;
+            f.write_joined(&*data.bounds, " + ")?;
+        }
+        write_where_clause(def_id, f)?;
+        Ok(())
+    }
+}
+impl HirDisplay for TypeAlias {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
+        let data = f.db.type_alias_data(self.id);
+        write!(f, "type {}", data.name)?;
+        if !data.bounds.is_empty() {
+            write!(f, ": ")?;
+            f.write_joined(&data.bounds, " + ")?;
+        }
+        if let Some(ty) = &data.type_ref {
+            write!(f, " = ")?;
+            ty.hir_fmt(f)?;
+        }
+        Ok(())
+    }
+}
+impl HirDisplay for Module {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        // FIXME: Module doesn't have visibility saved in data.
+        match self.name(f.db) {
+            Some(name) => write!(f, "mod {}", name),
+            None if self.crate_root(f.db) == *self => match self.krate().display_name(f.db) {
+                Some(name) => write!(f, "extern crate {}", name),
+                None => write!(f, "extern crate {{unknown}}"),
+            },
+            None => write!(f, "mod {{unnamed}}"),
+        }
+    }
+}
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index c5161dadd..f0bc2c7b9 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -29,6 +29,8 @@ mod has_source;
 pub mod diagnostics;
 pub mod db;
+mod display;
 use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
@@ -50,8 +52,8 @@ use hir_def::{
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
    autoderef,
-    display::{write_bounds_like_dyn_trait_with_prefix, HirDisplayError, HirFormatter},
    method_resolution::{self, TyFingerprint},
+    primitive::UintTy,
    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
@@ -571,6 +573,12 @@ impl Struct {
    }
 }
+impl HasVisibility for Struct {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.struct_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Union {
    pub(crate) id: UnionId,
@@ -603,6 +611,12 @@ impl Union {
    }
 }
+impl HasVisibility for Union {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.union_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Enum {
    pub(crate) id: EnumId,
@@ -630,6 +644,12 @@ impl Enum {
    }
 }
+impl HasVisibility for Enum {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.enum_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Variant {
    pub(crate) parent: Enum,
@@ -821,7 +841,8 @@ impl Function {
        db.function_data(self.id)
            .params
            .iter()
-            .map(|type_ref| {
+            .enumerate()
+            .map(|(idx, type_ref)| {
                let ty = Type {
                    krate,
                    ty: InEnvironment {
@@ -829,7 +850,7 @@ impl Function {
                        environment: environment.clone(),
                    },
                };
-                Param { ty }
+                Param { func: self, ty, idx }
            })
            .collect()
    }
@@ -843,7 +864,7 @@ impl Function {
    }
    pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
-        db.function_data(self.id).is_unsafe
+        db.function_data(self.id).qualifier.is_unsafe
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
@@ -892,6 +913,9 @@ impl From<hir_ty::Mutability> for Access {
 #[derive(Debug)]
 pub struct Param {
+    func: Function,
+    /// The index in parameter list, including self parameter.
+    idx: usize,
    ty: Type,
 }
@@ -899,6 +923,15 @@ impl Param {
    pub fn ty(&self) -> &Type {
        &self.ty
    }
+    pub fn pattern_source(&self, db: &dyn HirDatabase) -> Option<ast::Pat> {
+        let params = self.func.source(db)?.value.param_list()?;
+        if params.self_param().is_some() {
+            params.params().nth(self.idx.checked_sub(1)?)?.pat()
+        } else {
+            params.params().nth(self.idx)?.pat()
+        }
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -921,6 +954,14 @@ impl SelfParam {
            })
            .unwrap_or(Access::Owned)
    }
+    pub fn display(self, db: &dyn HirDatabase) -> &'static str {
+        match self.access(db) {
+            Access::Shared => "&self",
+            Access::Exclusive => "&mut self",
+            Access::Owned => "self",
+        }
+    }
 }
 impl HasVisibility for Function {
@@ -948,6 +989,10 @@ impl Const {
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.const_data(self.id).name.clone()
    }
+    pub fn type_ref(self, db: &dyn HirDatabase) -> TypeRef {
+        db.const_data(self.id).type_ref.clone()
+    }
 }
 impl HasVisibility for Const {
@@ -981,6 +1026,12 @@ impl Static {
    }
 }
+impl HasVisibility for Static {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.static_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Trait {
    pub(crate) id: TraitId,
@@ -1000,7 +1051,13 @@ impl Trait {
    }
    pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
-        db.trait_data(self.id).auto
+        db.trait_data(self.id).is_auto
+    }
+}
+impl HasVisibility for Trait {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        db.trait_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
    }
 }
@@ -1412,19 +1469,6 @@ impl TypeParam {
    }
 }
-impl HirDisplay for TypeParam {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        write!(f, "{}", self.name(f.db))?;
-        let bounds = f.db.generic_predicates_for_param(self.id);
-        let substs = Substs::type_params(f.db, self.id.parent);
-        let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>();
-        if !(predicates.is_empty() || f.omit_verbose_types()) {
-            write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?;
-        }
-        Ok(())
-    }
-}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct LifetimeParam {
    pub(crate) id: LifetimeParamId,
@@ -1631,6 +1675,10 @@ impl Type {
        matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
    }
+    pub fn is_usize(&self) -> bool {
+        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
+    }
    pub fn remove_ref(&self) -> Option<Type> {
        match &self.ty.value.interned(&Interner) {
            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
@@ -2054,12 +2102,6 @@ impl Type {
    }
 }
-impl HirDisplay for Type {
-    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        self.ty.value.hir_fmt(f)
-    }
-}
 // FIXME: closures
 #[derive(Debug)]
 pub struct Callable {
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 519339c0c..03c9371b5 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -143,6 +143,12 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.diagnostics_display_range(diagnostics)
    }
+    pub fn token_ancestors_with_macros(
+        &self,
+        token: SyntaxToken,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        token.parent().into_iter().flat_map(move |it| self.ancestors_with_macros(it))
+    }
    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
        self.imp.ancestors_with_macros(node)
    }
@@ -270,8 +276,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.scope(node)
    }
-    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
+    pub fn scope_at_offset(&self, token: &SyntaxToken, offset: TextSize) -> SemanticsScope<'db> {
-        self.imp.scope_at_offset(node, offset)
+        self.imp.scope_at_offset(&token.parent().unwrap(), offset)
    }
    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
@@ -341,7 +347,10 @@ impl<'db> SemanticsImpl<'db> {
    fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
        let _p = profile::span("descend_into_macros");
-        let parent = token.parent();
+        let parent = match token.parent() {
+            Some(it) => it,
+            None => return token,
+        };
        let sa = self.analyze(&parent);
        let token = successors(Some(InFile::new(sa.file_id, token)), |token| {
@@ -360,7 +369,9 @@ impl<'db> SemanticsImpl<'db> {
                .as_ref()?
                .map_token_down(token.as_ref())?;
-            self.cache(find_root(&token.value.parent()), token.file_id);
+            if let Some(parent) = token.value.parent() {
+                self.cache(find_root(&parent), token.file_id);
+            }
            Some(token)
        })
@@ -378,7 +389,7 @@ impl<'db> SemanticsImpl<'db> {
        // Handle macro token cases
        node.token_at_offset(offset)
            .map(|token| self.descend_into_macros(token))
-            .map(|it| self.ancestors_with_macros(it.parent()))
+            .map(|it| self.token_ancestors_with_macros(it))
            .flatten()
    }
@@ -394,6 +405,13 @@ impl<'db> SemanticsImpl<'db> {
        src.with_value(&node).original_file_range(self.db.upcast())
    }
+    fn token_ancestors_with_macros(
+        &self,
+        token: SyntaxToken,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        token.parent().into_iter().flat_map(move |parent| self.ancestors_with_macros(parent))
+    }
    fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
        let node = self.find_file(node);
        node.ancestors_with_macros(self.db.upcast()).map(|it| it.value)
@@ -405,7 +423,7 @@ impl<'db> SemanticsImpl<'db> {
        offset: TextSize,
    ) -> impl Iterator<Item = SyntaxNode> + '_ {
        node.token_at_offset(offset)
-            .map(|token| self.ancestors_with_macros(token.parent()))
+            .map(|token| self.token_ancestors_with_macros(token))
            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
    }