10 files changed, 112 insertions, 91 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 7fc4cd76e..be4b0accb 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use either::Either;
 use hir_expand::{
+    hygiene::Hygiene,
     name::{AsName, Name},
     InFile,
 };
@@ -12,9 +13,9 @@ use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 
 use crate::{
-    db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef,
-    visibility::RawVisibility, EnumId, LocalEnumVariantId, LocalStructFieldId, Lookup, StructId,
-    UnionId, VariantId,
+    attr::Attrs, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
+    type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId,
+    LocalStructFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!
@@ -56,7 +57,8 @@ impl StructData {
         let src = id.lookup(db).source(db);
 
         let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let variant_data = VariantData::new(db, src.map(|s| s.kind()));
+        let variant_data =
+            VariantData::new(db, src.map(|s| s.kind()), id.lookup(db).container.module(db));
         let variant_data = Arc::new(variant_data);
         Arc::new(StructData { name, variant_data })
     }
@@ -70,6 +72,7 @@ impl StructData {
                     .map(ast::StructKind::Record)
                     .unwrap_or(ast::StructKind::Unit)
             }),
+            id.lookup(db).container.module(db),
         );
         let variant_data = Arc::new(variant_data);
         Arc::new(StructData { name, variant_data })
@@ -82,7 +85,7 @@ impl EnumData {
         let src = e.lookup(db).source(db);
         let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
         let mut trace = Trace::new_for_arena();
-        lower_enum(db, &mut trace, &src);
+        lower_enum(db, &mut trace, &src, e.lookup(db).container.module(db));
         Arc::new(EnumData { name, variants: trace.into_arena() })
     }
 
@@ -98,7 +101,7 @@ impl HasChildSource for EnumId {
     fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
         let src = self.lookup(db).source(db);
         let mut trace = Trace::new_for_map();
-        lower_enum(db, &mut trace, &src);
+        lower_enum(db, &mut trace, &src, self.lookup(db).container.module(db));
         src.with_value(trace.into_map())
     }
 }
@@ -107,22 +110,23 @@ fn lower_enum(
     db: &dyn DefDatabase,
     trace: &mut Trace<EnumVariantData, ast::EnumVariant>,
     ast: &InFile<ast::EnumDef>,
+    module_id: ModuleId,
 ) {
     for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
         trace.alloc(
             || var.clone(),
             || EnumVariantData {
                 name: var.name().map_or_else(Name::missing, |it| it.as_name()),
-                variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()))),
+                variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()), module_id)),
             },
         );
     }
 }
 
 impl VariantData {
-    fn new(db: &dyn DefDatabase, flavor: InFile<ast::StructKind>) -> Self {
+    fn new(db: &dyn DefDatabase, flavor: InFile<ast::StructKind>, module_id: ModuleId) -> Self {
         let mut trace = Trace::new_for_arena();
-        match lower_struct(db, &mut trace, &flavor) {
+        match lower_struct(db, &mut trace, &flavor, module_id) {
             StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
             StructKind::Record => VariantData::Record(trace.into_arena()),
             StructKind::Unit => VariantData::Unit,
@@ -155,22 +159,27 @@ impl HasChildSource for VariantId {
     type Value = Either<ast::TupleFieldDef, ast::RecordFieldDef>;
 
     fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
-        let src = match self {
+        let (src, module_id) = match self {
             VariantId::EnumVariantId(it) => {
                 // I don't really like the fact that we call into parent source
                 // here, this might add to more queries then necessary.
                 let src = it.parent.child_source(db);
-                src.map(|map| map[it.local_id].kind())
+                (src.map(|map| map[it.local_id].kind()), it.parent.lookup(db).container.module(db))
             }
-            VariantId::StructId(it) => it.lookup(db).source(db).map(|it| it.kind()),
-            VariantId::UnionId(it) => it.lookup(db).source(db).map(|it| {
-                it.record_field_def_list()
-                    .map(ast::StructKind::Record)
-                    .unwrap_or(ast::StructKind::Unit)
-            }),
+            VariantId::StructId(it) => {
+                (it.lookup(db).source(db).map(|it| it.kind()), it.lookup(db).container.module(db))
+            }
+            VariantId::UnionId(it) => (
+                it.lookup(db).source(db).map(|it| {
+                    it.record_field_def_list()
+                        .map(ast::StructKind::Record)
+                        .unwrap_or(ast::StructKind::Unit)
+                }),
+                it.lookup(db).container.module(db),
+            ),
         };
         let mut trace = Trace::new_for_map();
-        lower_struct(db, &mut trace, &src);
+        lower_struct(db, &mut trace, &src, module_id);
         src.with_value(trace.into_map())
     }
 }
@@ -186,10 +195,17 @@ fn lower_struct(
     db: &dyn DefDatabase,
     trace: &mut Trace<StructFieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
     ast: &InFile<ast::StructKind>,
+    module_id: ModuleId,
 ) -> StructKind {
+    let crate_graph = db.crate_graph();
     match &ast.value {
         ast::StructKind::Tuple(fl) => {
             for (i, fd) in fl.fields().enumerate() {
+                let attrs = Attrs::new(&fd, &Hygiene::new(db.upcast(), ast.file_id));
+                if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
+                    continue;
+                }
+
                 trace.alloc(
                     || Either::Left(fd.clone()),
                     || StructFieldData {
@@ -203,6 +219,11 @@ fn lower_struct(
         }
         ast::StructKind::Record(fl) => {
             for fd in fl.fields() {
+                let attrs = Attrs::new(&fd, &Hygiene::new(db.upcast(), ast.file_id));
+                if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
+                    continue;
+                }
+
                 trace.alloc(
                     || Either::Right(fd.clone()),
                     || StructFieldData {
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 71a18f5e1..7b0c506b1 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -5,6 +5,7 @@ use std::{ops, sync::Arc};
 use either::Either;
 use hir_expand::{hygiene::Hygiene, AstId, InFile};
 use mbe::ast_to_token_tree;
+use ra_cfg::CfgOptions;
 use ra_syntax::{
     ast::{self, AstNode, AttrsOwner},
     SmolStr,
@@ -90,6 +91,10 @@ impl Attrs {
     pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
         AttrQuery { attrs: self, key }
     }
+
+    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> bool {
+        self.by_key("cfg").tt_values().all(|tt| cfg_options.is_cfg_enabled(tt) != Some(false))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 5f9d53ecb..e09996c6f 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -236,7 +236,7 @@ impl Index<PatId> for Body {
 
 impl BodySourceMap {
     pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
-        self.expr_map_back[expr]
+        self.expr_map_back[expr].clone()
     }
 
     pub fn node_expr(&self, node: InFile<&ast::Expr>) -> Option<ExprId> {
@@ -255,7 +255,7 @@ impl BodySourceMap {
     }
 
     pub fn pat_syntax(&self, pat: PatId) -> Result<PatSource, SyntheticSyntax> {
-        self.pat_map_back[pat]
+        self.pat_map_back[pat].clone()
     }
 
     pub fn node_pat(&self, node: InFile<&ast::Pat>) -> Option<PatId> {
@@ -264,6 +264,6 @@ impl BodySourceMap {
     }
 
     pub fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {
-        self.field_map[&(expr, field)]
+        self.field_map[&(expr, field)].clone()
     }
 }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index c4a5ec59c..9d6ee095e 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -4,6 +4,7 @@
 use either::Either;
 
 use hir_expand::{
+    hygiene::Hygiene,
     name::{name, AsName, Name},
     MacroDefId, MacroDefKind,
 };
@@ -20,6 +21,7 @@ use test_utils::tested_by;
 use super::{ExprSource, PatSource};
 use crate::{
     adt::StructKind,
+    attr::Attrs,
     body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
     builtin_type::{BuiltinFloat, BuiltinInt},
     db::DefDatabase,
@@ -31,8 +33,8 @@ use crate::{
     path::GenericArgs,
     path::Path,
     type_ref::{Mutability, TypeRef},
-    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
-    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, HasModule, Intern,
+    ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 
 pub(super) fn lower(
@@ -104,7 +106,7 @@ impl ExprCollector<'_> {
     fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
         let ptr = Either::Left(ptr);
         let src = self.expander.to_source(ptr);
-        let id = self.make_expr(expr, Ok(src));
+        let id = self.make_expr(expr, Ok(src.clone()));
         self.source_map.expr_map.insert(src, id);
         id
     }
@@ -116,7 +118,7 @@ impl ExprCollector<'_> {
     fn alloc_expr_field_shorthand(&mut self, expr: Expr, ptr: AstPtr<ast::RecordField>) -> ExprId {
         let ptr = Either::Right(ptr);
         let src = self.expander.to_source(ptr);
-        let id = self.make_expr(expr, Ok(src));
+        let id = self.make_expr(expr, Ok(src.clone()));
         self.source_map.expr_map.insert(src, id);
         id
     }
@@ -134,7 +136,7 @@ impl ExprCollector<'_> {
 
     fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
         let src = self.expander.to_source(ptr);
-        let id = self.make_pat(pat, Ok(src));
+        let id = self.make_pat(pat, Ok(src.clone()));
         self.source_map.pat_map.insert(src, id);
         id
     }
@@ -298,28 +300,41 @@ impl ExprCollector<'_> {
                 self.alloc_expr(Expr::Return { expr }, syntax_ptr)
             }
             ast::Expr::RecordLit(e) => {
+                let crate_graph = self.db.crate_graph();
                 let path = e.path().and_then(|path| self.expander.parse_path(path));
                 let mut field_ptrs = Vec::new();
                 let record_lit = if let Some(nfl) = e.record_field_list() {
                     let fields = nfl
                         .fields()
                         .inspect(|field| field_ptrs.push(AstPtr::new(field)))
-                        .map(|field| RecordLitField {
-                            name: field
-                                .name_ref()
-                                .map(|nr| nr.as_name())
-                                .unwrap_or_else(Name::missing),
-                            expr: if let Some(e) = field.expr() {
-                                self.collect_expr(e)
-                            } else if let Some(nr) = field.name_ref() {
-                                // field shorthand
-                                self.alloc_expr_field_shorthand(
-                                    Expr::Path(Path::from_name_ref(&nr)),
-                                    AstPtr::new(&field),
-                                )
-                            } else {
-                                self.missing_expr()
-                            },
+                        .filter_map(|field| {
+                            let module_id = ContainerId::DefWithBodyId(self.def).module(self.db);
+                            let attrs = Attrs::new(
+                                &field,
+                                &Hygiene::new(self.db.upcast(), self.expander.current_file_id),
+                            );
+
+                            if !attrs.is_cfg_enabled(&crate_graph[module_id.krate].cfg_options) {
+                                return None;
+                            }
+
+                            Some(RecordLitField {
+                                name: field
+                                    .name_ref()
+                                    .map(|nr| nr.as_name())
+                                    .unwrap_or_else(Name::missing),
+                                expr: if let Some(e) = field.expr() {
+                                    self.collect_expr(e)
+                                } else if let Some(nr) = field.name_ref() {
+                                    // field shorthand
+                                    self.alloc_expr_field_shorthand(
+                                        Expr::Path(Path::from_name_ref(&nr)),
+                                        AstPtr::new(&field),
+                                    )
+                                } else {
+                                    self.missing_expr()
+                                },
+                            })
                         })
                         .collect();
                     let spread = nfl.spread().map(|s| self.collect_expr(s));
@@ -357,7 +372,7 @@ impl ExprCollector<'_> {
             }
             ast::Expr::RefExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let mutability = Mutability::from_mutable(e.is_mut());
+                let mutability = Mutability::from_mutable(e.mut_token().is_some());
                 self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
             }
             ast::Expr::PrefixExpr(e) => {
@@ -572,10 +587,8 @@ impl ExprCollector<'_> {
         let pattern = match &pat {
             ast::Pat::BindPat(bp) => {
                 let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
-                let annotation = BindingAnnotation::new(
-                    bp.mut_kw_token().is_some(),
-                    bp.ref_kw_token().is_some(),
-                );
+                let annotation =
+                    BindingAnnotation::new(bp.mut_token().is_some(), bp.ref_token().is_some());
                 let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
                 if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
                     // This could also be a single-segment path pattern. To
@@ -616,7 +629,7 @@ impl ExprCollector<'_> {
             }
             ast::Pat::RefPat(p) => {
                 let pat = self.collect_pat_opt(p.pat());
-                let mutability = Mutability::from_mutable(p.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(p.mut_token().is_some());
                 Pat::Ref { pat, mutability }
             }
             ast::Pat::PathPat(p) => {
@@ -655,7 +668,9 @@ impl ExprCollector<'_> {
                 });
                 fields.extend(iter);
 
-                Pat::Record { path, args: fields }
+                let ellipsis = record_field_pat_list.dotdot_token().is_some();
+
+                Pat::Record { path, args: fields, ellipsis }
             }
             ast::Pat::SlicePat(p) => {
                 let SlicePatComponents { prefix, slice, suffix } = p.components();
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 689bb6c5c..b8fbf0ed4 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -7,7 +7,6 @@ use hir_expand::{
     name::{name, AsName, Name},
     AstId, InFile,
 };
-use ra_cfg::CfgOptions;
 use ra_prof::profile;
 use ra_syntax::ast::{
     self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, VisibilityOwner,
@@ -75,7 +74,7 @@ impl FunctionData {
             TypeRef::unit()
         };
 
-        let ret_type = if src.value.async_kw_token().is_some() {
+        let ret_type = if src.value.async_token().is_some() {
             let future_impl = desugar_future_path(ret_type);
             let ty_bound = TypeBound::Path(future_impl);
             TypeRef::ImplTrait(vec![ty_bound])
@@ -136,7 +135,7 @@ impl TraitData {
     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
         let src = tr.lookup(db).source(db);
         let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let auto = src.value.auto_kw_token().is_some();
+        let auto = src.value.auto_token().is_some();
         let ast_id_map = db.ast_id_map(src.file_id);
 
         let container = AssocContainerId::TraitId(tr);
@@ -318,10 +317,6 @@ fn collect_impl_items_in_macro(
     }
 }
 
-fn is_cfg_enabled(cfg_options: &CfgOptions, attrs: &Attrs) -> bool {
-    attrs.by_key("cfg").tt_values().all(|tt| cfg_options.is_cfg_enabled(tt) != Some(false))
-}
-
 fn collect_impl_items(
     db: &dyn DefDatabase,
     impl_items: impl Iterator<Item = ImplItem>,
@@ -341,10 +336,11 @@ fn collect_impl_items(
                 }
                 .intern(db);
 
-                if !is_cfg_enabled(
-                    &crate_graph[module_id.krate].cfg_options,
-                    &db.function_data(def).attrs,
-                ) {
+                if !db
+                    .function_data(def)
+                    .attrs
+                    .is_cfg_enabled(&crate_graph[module_id.krate].cfg_options)
+                {
                     None
                 } else {
                     Some(def.into())
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 095498429..cfa0f2f76 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -20,7 +20,7 @@ impl Diagnostic for UnresolvedModule {
         "unresolved module".to_string()
     }
     fn source(&self) -> InFile<SyntaxNodePtr> {
-        InFile { file_id: self.file, value: self.decl.into() }
+        InFile { file_id: self.file, value: self.decl.clone().into() }
     }
     fn as_any(&self) -> &(dyn Any + Send + 'static) {
         self
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index 197bbe9bd..e11bdf3ec 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -376,35 +376,14 @@ pub enum Pat {
     Wild,
     Tuple(Vec<PatId>),
     Or(Vec<PatId>),
-    Record {
-        path: Option<Path>,
-        args: Vec<RecordFieldPat>,
-        // FIXME: 'ellipsis' option
-    },
-    Range {
-        start: ExprId,
-        end: ExprId,
-    },
-    Slice {
-        prefix: Vec<PatId>,
-        slice: Option<PatId>,
-        suffix: Vec<PatId>,
-    },
+    Record { path: Option<Path>, args: Vec<RecordFieldPat>, ellipsis: bool },
+    Range { start: ExprId, end: ExprId },
+    Slice { prefix: Vec<PatId>, slice: Option<PatId>, suffix: Vec<PatId> },
     Path(Path),
     Lit(ExprId),
-    Bind {
-        mode: BindingAnnotation,
-        name: Name,
-        subpat: Option<PatId>,
-    },
-    TupleStruct {
-        path: Option<Path>,
-        args: Vec<PatId>,
-    },
-    Ref {
-        pat: PatId,
-        mutability: Mutability,
-    },
+    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
+    TupleStruct { path: Option<Path>, args: Vec<PatId> },
+    Ref { pat: PatId, mutability: Mutability },
 }
 
 impl Pat {
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index 01b367278..d96ac8c0a 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -4,6 +4,7 @@
 //! features, such as Fn family of traits.
 use std::sync::Arc;
 
+use ra_prof::profile;
 use ra_syntax::SmolStr;
 use rustc_hash::FxHashMap;
 
@@ -78,6 +79,8 @@ impl LangItems {
 
     /// Salsa query. This will look for lang items in a specific crate.
     pub(crate) fn crate_lang_items_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<LangItems> {
+        let _p = profile("crate_lang_items_query");
+
         let mut lang_items = LangItems::default();
 
         let crate_def_map = db.crate_def_map(krate);
@@ -95,6 +98,7 @@ impl LangItems {
         db: &dyn DefDatabase,
         module: ModuleId,
     ) -> Option<Arc<LangItems>> {
+        let _p = profile("module_lang_items_query");
         let mut lang_items = LangItems::default();
         lang_items.collect_lang_items(db, module);
         if lang_items.items.is_empty() {
@@ -111,6 +115,7 @@ impl LangItems {
         start_crate: CrateId,
         item: SmolStr,
     ) -> Option<LangItemTarget> {
+        let _p = profile("lang_item_query");
         let lang_items = db.crate_lang_items(start_crate);
         let start_crate_target = lang_items.items.get(&item);
         if let Some(target) = start_crate_target {
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index e72ba52cf..afd538e4a 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -287,7 +287,7 @@ impl RawItemsCollector {
         let visibility = RawVisibility::from_ast_with_hygiene(module.visibility(), &self.hygiene);
 
         let ast_id = self.source_ast_id_map.ast_id(&module);
-        if module.semi_token().is_some() {
+        if module.semicolon_token().is_some() {
             let item =
                 self.raw_items.modules.alloc(ModuleData::Declaration { name, visibility, ast_id });
             self.push_item(current_module, attrs, RawItemKind::Module(item));
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index 7a8338937..ea29c4176 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -77,7 +77,7 @@ impl TypeRef {
             }
             ast::TypeRef::PointerType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
-                let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::RawPtr(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::ArrayType(inner) => {
@@ -88,7 +88,7 @@ impl TypeRef {
             }
             ast::TypeRef::ReferenceType(inner) => {
                 let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
-                let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
+                let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::Reference(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,