Merge #9765

9765: internal: Introduce TypeInfo r=Veykril a=Veykril



Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Author: bors[bot]

crates/hir/src/lib.rs

@@ -89,7 +89,7 @@ pub use crate::{
         UnresolvedModule, UnresolvedProcMacro,
     },
     has_source::HasSource,
-    semantics::{PathResolution, Semantics, SemanticsScope},
+    semantics::{PathResolution, Semantics, SemanticsScope, TypeInfo},
 };
 
 // Be careful with these re-exports.

crates/hir/src/semantics.rs

@@ -87,6 +87,29 @@ impl PathResolution {
     }
 }
 
+#[derive(Debug)]
+pub struct TypeInfo {
+    /// The original type of the expression or pattern.
+    pub original: Type,
+    /// The adjusted type, if an adjustment happened.
+    pub adjusted: Option<Type>,
+}
+
+impl TypeInfo {
+    pub fn original(self) -> Type {
+        self.original
+    }
+
+    pub fn has_adjustment(&self) -> bool {
+        self.adjusted.is_some()
+    }
+
+    /// The adjusted type, or the original in case no adjustments occurred.
+    pub fn adjusted(self) -> Type {
+        self.adjusted.unwrap_or(self.original)
+    }
+}
+
 /// Primary API to get semantic information, like types, from syntax trees.
 pub struct Semantics<'db, DB> {
     pub db: &'db DB,
@@ -212,23 +235,14 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.imp.resolve_type(ty)
     }
 
-    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
+    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<TypeInfo> {
         self.imp.type_of_expr(expr)
     }
 
-    /// Returns true in case a coercion happened.
-    pub fn type_of_expr_with_coercion(&self, expr: &ast::Expr) -> Option<(Type, bool)> {
-        self.imp.type_of_expr_with_coercion(expr)
-    }
-
-    pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
+    pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<TypeInfo> {
         self.imp.type_of_pat(pat)
     }
 
-    pub fn type_of_pat_with_coercion(&self, expr: &ast::Pat) -> Option<(Type, bool)> {
-        self.imp.type_of_pat_with_coercion(expr)
-    }
-
     pub fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
         self.imp.type_of_self(param)
     }
@@ -565,20 +579,16 @@ impl<'db> SemanticsImpl<'db> {
         Type::new_with_resolver(self.db, &scope.resolver, ty)
     }
 
-    fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
-        self.analyze(expr.syntax()).type_of_expr(self.db, expr)
-    }
-
-    fn type_of_expr_with_coercion(&self, expr: &ast::Expr) -> Option<(Type, bool)> {
-        self.analyze(expr.syntax()).type_of_expr_with_coercion(self.db, expr)
-    }
-
-    fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
-        self.analyze(pat.syntax()).type_of_pat(self.db, pat)
+    fn type_of_expr(&self, expr: &ast::Expr) -> Option<TypeInfo> {
+        self.analyze(expr.syntax())
+            .type_of_expr(self.db, expr)
+            .map(|(ty, coerced)| TypeInfo { original: ty, adjusted: coerced })
     }
 
-    fn type_of_pat_with_coercion(&self, pat: &ast::Pat) -> Option<(Type, bool)> {
-        self.analyze(pat.syntax()).type_of_pat_with_coercion(self.db, pat)
+    fn type_of_pat(&self, pat: &ast::Pat) -> Option<TypeInfo> {
+        self.analyze(pat.syntax())
+            .type_of_pat(self.db, pat)
+            .map(|(ty, coerced)| TypeInfo { original: ty, adjusted: coerced })
     }
 
     fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
@@ -757,7 +767,7 @@ impl<'db> SemanticsImpl<'db> {
                     ast::Expr::FieldExpr(field_expr) => field_expr,
                     _ => return None,
                 };
-                let ty = self.type_of_expr(&field_expr.expr()?)?;
+                let ty = self.type_of_expr(&field_expr.expr()?)?.original;
                 if !ty.is_packed(self.db) {
                     return None;
                 }
@@ -784,7 +794,7 @@ impl<'db> SemanticsImpl<'db> {
                 self.type_of_expr(&expr)
             })
             // Binding a reference to a packed type is possibly unsafe.
-            .map(|ty| ty.is_packed(self.db))
+            .map(|ty| ty.original.is_packed(self.db))
             .unwrap_or(false)
 
         // FIXME This needs layout computation to be correct. It will highlight
@@ -830,7 +840,7 @@ impl<'db> SemanticsImpl<'db> {
                 }
             })
             // Binding a reference to a packed type is possibly unsafe.
-            .map(|ty| ty.is_packed(self.db))
+            .map(|ty| ty.original.is_packed(self.db))
             .unwrap_or(false)
     }
 }

crates/hir/src/source_analyzer.rs

@@ -116,46 +116,36 @@ impl SourceAnalyzer {
         Some(res)
     }
 
-    pub(crate) fn type_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
-        let expr_id = self.expr_id(db, expr)?;
-        let ty = self.infer.as_ref()?[expr_id].clone();
-        Type::new_with_resolver(db, &self.resolver, ty)
-    }
-
-    pub(crate) fn type_of_expr_with_coercion(
+    pub(crate) fn type_of_expr(
         &self,
         db: &dyn HirDatabase,
         expr: &ast::Expr,
-    ) -> Option<(Type, bool)> {
+    ) -> Option<(Type, Option<Type>)> {
         let expr_id = self.expr_id(db, expr)?;
         let infer = self.infer.as_ref()?;
-        let (ty, coerced) = infer
+        let coerced = infer
             .expr_adjustments
             .get(&expr_id)
-            .and_then(|adjusts| adjusts.last().map(|adjust| (&adjust.target, true)))
-            .unwrap_or_else(|| (&infer[expr_id], false));
-        Type::new_with_resolver(db, &self.resolver, ty.clone()).zip(Some(coerced))
-    }
-
-    pub(crate) fn type_of_pat(&self, db: &dyn HirDatabase, pat: &ast::Pat) -> Option<Type> {
-        let pat_id = self.pat_id(pat)?;
-        let ty = self.infer.as_ref()?[pat_id].clone();
-        Type::new_with_resolver(db, &self.resolver, ty)
+            .and_then(|adjusts| adjusts.last().map(|adjust| adjust.target.clone()));
+        let ty = infer[expr_id].clone();
+        let mk_ty = |ty| Type::new_with_resolver(db, &self.resolver, ty);
+        mk_ty(ty.clone()).zip(Some(coerced.and_then(mk_ty)))
     }
 
-    pub(crate) fn type_of_pat_with_coercion(
+    pub(crate) fn type_of_pat(
         &self,
         db: &dyn HirDatabase,
         pat: &ast::Pat,
-    ) -> Option<(Type, bool)> {
+    ) -> Option<(Type, Option<Type>)> {
         let pat_id = self.pat_id(pat)?;
         let infer = self.infer.as_ref()?;
-        let (ty, coerced) = infer
+        let coerced = infer
             .pat_adjustments
             .get(&pat_id)
-            .and_then(|adjusts| adjusts.last().map(|adjust| (&adjust.target, true)))
-            .unwrap_or_else(|| (&infer[pat_id], false));
-        Type::new_with_resolver(db, &self.resolver, ty.clone()).zip(Some(coerced))
+            .and_then(|adjusts| adjusts.last().map(|adjust| adjust.target.clone()));
+        let ty = infer[pat_id].clone();
+        let mk_ty = |ty| Type::new_with_resolver(db, &self.resolver, ty);
+        mk_ty(ty.clone()).zip(Some(coerced.and_then(mk_ty)))
     }
 
     pub(crate) fn type_of_self(

crates/ide/src/call_hierarchy.rs

@@ -86,7 +86,7 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
             let name_ref = call_node.name_ref()?;
             let func_target = match call_node {
                 FnCallNode::CallExpr(expr) => {
-                    let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
+                    let callable = sema.type_of_expr(&expr.expr()?)?.original.as_callable(db)?;
                     match callable.kind() {
                         hir::CallableKind::Function(it) => it.try_to_nav(db),
                         _ => None,

crates/ide/src/goto_type_definition.rs

@@ -32,8 +32,8 @@ pub(crate) fn goto_type_definition(
     let (ty, node) = sema.token_ancestors_with_macros(token).find_map(|node| {
         let ty = match_ast! {
             match node {
-                ast::Expr(it) => sema.type_of_expr(&it)?,
-                ast::Pat(it) => sema.type_of_pat(&it)?,
+                ast::Expr(it) => sema.type_of_expr(&it)?.original,
+                ast::Pat(it) => sema.type_of_pat(&it)?.original,
                 ast::SelfParam(it) => sema.type_of_self(&it)?,
                 ast::Type(it) => sema.resolve_type(&it)?,
                 ast::RecordField(it) => sema.to_def(&it).map(|d| d.ty(db.upcast()))?,

crates/ide/src/highlight_related.rs

@@ -123,7 +123,7 @@ fn highlight_exit_points(
                 }
             }
             ast::Expr::MethodCallExpr(_) | ast::Expr::CallExpr(_) | ast::Expr::MacroCall(_) => {
-                if sema.type_of_expr(&expr).map_or(false, |ty| ty.is_never()) {
+                if sema.type_of_expr(&expr).map_or(false, |ty| ty.original.is_never()) {
                     highlights
                         .push(HighlightedRange { access: None, range: expr.syntax().text_range() });
                 }

crates/ide/src/hover.rs

@@ -1,5 +1,5 @@
 use either::Either;
-use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
+use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo};
 use ide_db::{
     base_db::{FileRange, SourceDatabase},
     defs::{Definition, NameClass, NameRefClass},
@@ -225,33 +225,29 @@ fn hover_type_info(
     config: &HoverConfig,
     expr_or_pat: &Either<ast::Expr, ast::Pat>,
 ) -> Option<HoverResult> {
-    let (ty, coerced) = match expr_or_pat {
-        Either::Left(expr) => sema.type_of_expr_with_coercion(expr)?,
-        Either::Right(pat) => sema.type_of_pat_with_coercion(pat)?,
+    let TypeInfo { original, adjusted } = match expr_or_pat {
+        Either::Left(expr) => sema.type_of_expr(expr)?,
+        Either::Right(pat) => sema.type_of_pat(pat)?,
     };
 
     let mut res = HoverResult::default();
-    res.markup = if coerced {
-        let uncoerced_ty = match expr_or_pat {
-            Either::Left(expr) => sema.type_of_expr(expr)?,
-            Either::Right(pat) => sema.type_of_pat(pat)?,
-        };
-        let uncoerced = uncoerced_ty.display(sema.db).to_string();
-        let coerced = ty.display(sema.db).to_string();
+    res.markup = if let Some(adjusted_ty) = adjusted {
+        let original = original.display(sema.db).to_string();
+        let adjusted = adjusted_ty.display(sema.db).to_string();
         format!(
-            "```text\nType: {:>upad$}\nCoerced to: {:>cpad$}\n```\n",
-            uncoerced = uncoerced,
-            coerced = coerced,
+            "```text\nType: {:>apad$}\nCoerced to: {:>opad$}\n```\n",
+            uncoerced = original,
+            coerced = adjusted,
             // 6 base padding for static text prefix of each line
-            upad = 6 + coerced.len().max(uncoerced.len()),
-            cpad = uncoerced.len(),
+            apad = 6 + adjusted.len().max(original.len()),
+            opad = original.len(),
         )
         .into()
     } else {
         if config.markdown() {
-            Markup::fenced_block(&ty.display(sema.db))
+            Markup::fenced_block(&original.display(sema.db))
         } else {
-            ty.display(sema.db).to_string().into()
+            original.display(sema.db).to_string().into()
         }
     };
     Some(res)

crates/ide/src/inlay_hints.rs

@@ -1,5 +1,5 @@
 use either::Either;
-use hir::{known, Callable, HasVisibility, HirDisplay, Semantics};
+use hir::{known, Callable, HasVisibility, HirDisplay, Semantics, TypeInfo};
 use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
 use stdx::to_lower_snake_case;
@@ -117,7 +117,7 @@ fn get_chaining_hints(
             next_next = tokens.next()?.kind();
         }
         if next_next == T![.] {
-            let ty = sema.type_of_expr(&expr)?;
+            let ty = sema.type_of_expr(&expr)?.original;
             if ty.is_unknown() {
                 return None;
             }
@@ -189,7 +189,7 @@ fn get_bind_pat_hints(
     let krate = sema.scope(pat.syntax()).module().map(|it| it.krate());
     let famous_defs = FamousDefs(sema, krate);
 
-    let ty = sema.type_of_pat(&pat.clone().into())?;
+    let ty = sema.type_of_pat(&pat.clone().into())?.original;
 
     if should_not_display_type_hint(sema, &pat, &ty) {
         return None;
@@ -308,6 +308,7 @@ fn should_not_display_type_hint(
                     return it.in_token().is_none() ||
                         it.iterable()
                             .and_then(|iterable_expr| sema.type_of_expr(&iterable_expr))
+                            .map(TypeInfo::original)
                             .map_or(true, |iterable_ty| iterable_ty.is_unknown() || iterable_ty.is_unit())
                 },
                 _ => (),
@@ -393,7 +394,7 @@ fn is_enum_name_similar_to_param_name(
     argument: &ast::Expr,
     param_name: &str,
 ) -> bool {
-    match sema.type_of_expr(argument).and_then(|t| t.as_adt()) {
+    match sema.type_of_expr(argument).and_then(|t| t.original.as_adt()) {
         Some(hir::Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name,
         _ => false,
     }
@@ -430,7 +431,7 @@ fn get_callable(
 ) -> Option<(hir::Callable, ast::ArgList)> {
     match expr {
         ast::Expr::CallExpr(expr) => {
-            sema.type_of_expr(&expr.expr()?)?.as_callable(sema.db).zip(expr.arg_list())
+            sema.type_of_expr(&expr.expr()?)?.original.as_callable(sema.db).zip(expr.arg_list())
         }
         ast::Expr::MethodCallExpr(expr) => {
             sema.resolve_method_call_as_callable(expr).zip(expr.arg_list())

crates/ide/src/syntax_highlighting/highlight.rs

@@ -123,7 +123,7 @@ pub(super) fn element(
                 let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
 
                 let expr = prefix_expr.expr()?;
-                let ty = sema.type_of_expr(&expr)?;
+                let ty = sema.type_of_expr(&expr)?.original;
                 if ty.is_raw_ptr() {
                     HlTag::Operator(HlOperator::Other) | HlMod::Unsafe
                 } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
@@ -555,7 +555,7 @@ fn highlight_method_call(
                 if let Some(receiver_ty) =
                     method_call.receiver().and_then(|it| sema.type_of_expr(&it))
                 {
-                    if !receiver_ty.is_copy(sema.db) {
+                    if !receiver_ty.adjusted().is_copy(sema.db) {
                         h |= HlMod::Consuming
                     }
                 }

crates/ide_assists/src/handlers/add_explicit_type.rs

@@ -54,9 +54,10 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     }
 
     let ty = match (pat, expr) {
-        (ast::Pat::IdentPat(_), Some(expr)) => ctx.sema.type_of_expr_with_coercion(&expr)?.0,
+        (ast::Pat::IdentPat(_), Some(expr)) => ctx.sema.type_of_expr(&expr)?,
         (pat, _) => ctx.sema.type_of_pat(&pat)?,
-    };
+    }
+    .adjusted();
 
     // Unresolved or unnameable types can't be annotated
     if ty.contains_unknown() || ty.is_closure() {