Revise TypeInfo::ty usage

Author: Veykril

crates/hir/src/semantics.rs

@@ -100,11 +100,11 @@ impl TypeInfo {
         self.ty
     }
 
-    pub fn coerced(self) -> Option<Type> {
-        self.coerced
+    pub fn has_coercion(&self) -> bool {
+        self.coerced.is_some()
     }
 
-    pub fn coerced_or_original(self) -> Type {
+    pub fn coerced(self) -> Type {
         self.coerced.unwrap_or(self.ty)
     }
 }

crates/ide/src/syntax_highlighting/highlight.rs

@@ -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.ty.is_copy(sema.db) {
+                    if !receiver_ty.coerced().is_copy(sema.db) {
                         h |= HlMod::Consuming
                     }
                 }

crates/ide_assists/src/handlers/add_explicit_type.rs

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

crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs

@@ -86,7 +86,7 @@ fn validate_method_call_expr(
     let receiver = expr.receiver()?;
     let expr = ast::Expr::MethodCallExpr(expr);
 
-    let it_type = sema.type_of_expr(&receiver)?.ty;
+    let it_type = sema.type_of_expr(&receiver)?.coerced();
     let module = sema.scope(receiver.syntax()).module()?;
     let krate = module.krate();
 

crates/ide_assists/src/handlers/extract_function.rs

@@ -345,7 +345,7 @@ impl FlowKind {
             FlowKind::Return(Some(expr))
             | FlowKind::Break(Some(expr))
             | FlowKind::TryReturn { expr, .. } => {
-                ctx.sema.type_of_expr(expr).map(TypeInfo::coerced_or_original)
+                ctx.sema.type_of_expr(expr).map(TypeInfo::coerced)
             }
             FlowKind::Try { .. } => {
                 stdx::never!("try does not have defined expr_ty");

crates/ide_assists/src/handlers/extract_variable.rs

@@ -40,7 +40,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
         .take_while(|it| it.text_range().contains_range(ctx.frange.range))
         .find_map(valid_target_expr)?;
     if let Some(ty_info) = ctx.sema.type_of_expr(&to_extract) {
-        if ty_info.ty.is_unit() {
+        if ty_info.coerced().is_unit() {
             return None;
         }
     }

crates/ide_assists/src/handlers/fill_match_arms.rs

@@ -223,7 +223,7 @@ impl ExtendedEnum {
 }
 
 fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<ExtendedEnum> {
-    sema.type_of_expr(expr)?.ty.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
+    sema.type_of_expr(expr)?.coerced().autoderef(sema.db).find_map(|ty| match ty.as_adt() {
         Some(Adt::Enum(e)) => Some(ExtendedEnum::Enum(e)),
         _ => ty.is_bool().then(|| ExtendedEnum::Bool),
     })
@@ -234,7 +234,7 @@ fn resolve_tuple_of_enum_def(
     expr: &ast::Expr,
 ) -> Option<Vec<ExtendedEnum>> {
     sema.type_of_expr(expr)?
-        .ty
+        .coerced()
         .tuple_fields(sema.db)
         .iter()
         .map(|ty| {

crates/ide_assists/src/handlers/generate_function.rs

@@ -331,7 +331,7 @@ fn fn_arg_type(
     target_module: hir::Module,
     fn_arg: &ast::Expr,
 ) -> Option<String> {
-    let ty = ctx.sema.type_of_expr(fn_arg)?.ty;
+    let ty = ctx.sema.type_of_expr(fn_arg)?.coerced();
     if ty.is_unknown() {
         return None;
     }

crates/ide_assists/src/handlers/infer_function_return_type.rs

@@ -18,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let (fn_type, tail_expr, builder_edit_pos) = extract_tail(ctx)?;
     let module = ctx.sema.scope(tail_expr.syntax()).module()?;
-    let ty = ctx.sema.type_of_expr(&tail_expr)?.ty;
+    let ty = ctx.sema.type_of_expr(&tail_expr)?.coerced();
     if ty.is_unit() {
         return None;
     }

crates/ide_assists/src/handlers/inline_call.rs

@@ -190,7 +190,7 @@ pub(crate) fn inline_(
                         let ty = ctx
                             .sema
                             .type_of_expr(&expr)
-                            .and_then(TypeInfo::coerced)
+                            .filter(TypeInfo::has_coercion)
                             .and_then(|_| param_ty);
                         body.push_front(
                             make::let_stmt(pat, ty, Some(expr)).clone_for_update().into(),