Use TypeAscriptionOwner

This replaces places where we would use node + node.type_ref() with things that
have an ascribed type, with using the TypeAscriptionOwner as the trait bound so
we can simply pass the node.

2 files changed, 15 insertions, 12 deletions

diff --git a/crates/ra_hir/src/code_model_impl/konst.rs b/crates/ra_hir/src/code_model_impl/konst.rs
index ecf4c8122..8b861a81f 100644
--- a/crates/ra_hir/src/code_model_impl/konst.rs
+++ b/crates/ra_hir/src/code_model_impl/konst.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;

 

-use ra_syntax::ast::{self, NameOwner};

+use ra_syntax::ast::{NameOwner, TypeAscriptionOwner};

 

 use crate::{

     Name, AsName, Const, ConstSignature, Static,

@@ -8,12 +8,9 @@ use crate::{
     PersistentHirDatabase,

 };

 

-fn const_signature_for<N: NameOwner>(

-    node: &N,

-    type_ref: Option<&ast::TypeRef>,

-) -> Arc<ConstSignature> {

+fn const_signature_for<N: NameOwner + TypeAscriptionOwner>(node: &N) -> Arc<ConstSignature> {

     let name = node.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);

-    let type_ref = TypeRef::from_ast_opt(type_ref);

+    let type_ref = TypeRef::from_ast_opt(node.ascribed_type());

     let sig = ConstSignature { name, type_ref };

     Arc::new(sig)

 }

@@ -24,7 +21,7 @@ impl ConstSignature {
         konst: Const,

     ) -> Arc<ConstSignature> {

         let (_, node) = konst.source(db);

-        const_signature_for(&*node, node.type_ref())

+        const_signature_for(&*node)

     }

 

     pub(crate) fn static_signature_query(

@@ -32,6 +29,6 @@ impl ConstSignature {
         konst: Static,

     ) -> Arc<ConstSignature> {

         let (_, node) = konst.source(db);

-        const_signature_for(&*node, node.type_ref())

+        const_signature_for(&*node)

     }

 }

diff --git a/crates/ra_ide_api_light/src/structure.rs b/crates/ra_ide_api_light/src/structure.rs
index dea494daa..ec2c9bbc6 100644
--- a/crates/ra_ide_api_light/src/structure.rs
+++ b/crates/ra_ide_api_light/src/structure.rs
@@ -2,7 +2,7 @@ use crate::TextRange;
 
 use ra_syntax::{
     algo::visit::{visitor, Visitor},
-    ast::{self, AttrsOwner, NameOwner, TypeParamsOwner},
+    ast::{self, AttrsOwner, NameOwner, TypeParamsOwner, TypeAscriptionOwner},
     AstNode, SourceFile, SyntaxKind, SyntaxNode, WalkEvent,
 };
 
@@ -45,6 +45,12 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
         decl_with_detail(node, None)
     }
 
+    fn decl_with_ascription<N: NameOwner + AttrsOwner + TypeAscriptionOwner>(
+        node: &N,
+    ) -> Option<StructureNode> {
+        decl_with_type_ref(node, node.ascribed_type())
+    }
+
     fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
         node: &N,
         type_ref: Option<&ast::TypeRef>,
@@ -107,14 +113,14 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
             decl_with_detail(fn_def, Some(detail))
         })
         .visit(decl::<ast::StructDef>)
-        .visit(|nfd: &ast::NamedFieldDef| decl_with_type_ref(nfd, nfd.type_ref()))
         .visit(decl::<ast::EnumDef>)
         .visit(decl::<ast::EnumVariant>)
         .visit(decl::<ast::TraitDef>)
         .visit(decl::<ast::Module>)
         .visit(|td: &ast::TypeAliasDef| decl_with_type_ref(td, td.type_ref()))
-        .visit(|cd: &ast::ConstDef| decl_with_type_ref(cd, cd.type_ref()))
-        .visit(|sd: &ast::StaticDef| decl_with_type_ref(sd, sd.type_ref()))
+        .visit(decl_with_ascription::<ast::NamedFieldDef>)
+        .visit(decl_with_ascription::<ast::ConstDef>)
+        .visit(decl_with_ascription::<ast::StaticDef>)
         .visit(|im: &ast::ImplBlock| {
             let target_type = im.target_type()?;
             let target_trait = im.target_trait();