simplify

crates/hir/src/lib.rs

@@ -1744,6 +1744,10 @@ impl Type {
         }
     }
 
+    pub fn strip_references(&self) -> Type {
+        self.derived(self.ty.strip_references().clone())
+    }
+
     pub fn is_unknown(&self) -> bool {
         self.ty.is_unknown()
     }

crates/ide/src/inlay_hints.rs

@@ -218,9 +218,7 @@ fn hint_iterator(
     ty: &hir::Type,
 ) -> Option<SmolStr> {
     let db = sema.db;
-    let strukt = std::iter::successors(Some(ty.clone()), |ty| ty.remove_ref())
+    let strukt = ty.strip_references().as_adt()?;
-        .last()
-        .and_then(|strukt| strukt.as_adt())?;
     let krate = strukt.krate(db);
     if krate != famous_defs.core()? {
         return None;

crates/ide_completion/src/completions.rs

@@ -203,12 +203,9 @@ impl Completions {
 fn complete_enum_variants(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    ty: &hir::Type,
+    enum_data: hir::Enum,
     cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
 ) {
-    if let Some(hir::Adt::Enum(enum_data)) =
-        iter::successors(Some(ty.clone()), |ty| ty.remove_ref()).last().and_then(|ty| ty.as_adt())
-    {
     let variants = enum_data.variants(ctx.db);
 
     let module = if let Some(module) = ctx.scope.module() {
@@ -220,7 +217,7 @@ fn complete_enum_variants(
     };
 
     if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
-            if impl_.self_ty(ctx.db) == *ty {
+        if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_data)) {
             for &variant in &variants {
                 let self_path = hir::ModPath::from_segments(
                     hir::PathKind::Plain,
@@ -240,5 +237,4 @@ fn complete_enum_variants(
             }
         }
     }
-    }
 }

crates/ide_completion/src/completions/pattern.rs

@@ -12,8 +12,10 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     }
 
     if !ctx.is_irrefutable_pat_binding {
-        if let Some(ty) = ctx.expected_type.as_ref() {
+        if let Some(hir::Adt::Enum(e)) =
-            super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+            ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
+        {
+            super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
                 acc.add_qualified_variant_pat(ctx, variant, path.clone());
                 acc.add_qualified_enum_variant(ctx, variant, path);
             });

crates/ide_completion/src/completions/postfix.rs

@@ -35,14 +35,11 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         None => return,
     };
 
-    let ref_removed_ty =
-        std::iter::successors(Some(receiver_ty.clone()), |ty| ty.remove_ref()).last().unwrap();
-
     let cap = match ctx.config.snippet_cap {
         Some(it) => it,
         None => return,
     };
-    let try_enum = TryEnum::from_ty(&ctx.sema, &ref_removed_ty);
+    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty.strip_references());
     if let Some(try_enum) = &try_enum {
         match try_enum {
             TryEnum::Result => {

crates/ide_completion/src/completions/unqualified_path.rs

@@ -17,8 +17,10 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
 
-    if let Some(ty) = &ctx.expected_type {
+    if let Some(hir::Adt::Enum(e)) =
-        super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+        ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
+    {
+        super::complete_enum_variants(acc, ctx, e, |acc, ctx, variant, path| {
             acc.add_qualified_enum_variant(ctx, variant, path)
         });
     }