Investigated a little bit. Here is a way to make a similar error:

enum Foo {
    Bar { x: i32 },
}

fn f(Foo::Bar { x }: T) {}

Error: internal error: entered unreachable code: Only adt has field, found {error}\n.

And this:

fn f(&x: T) {}

Error: internal error: entered unreachable code: Overloaded deref on type {unknown} is not a projection\n

In general, the error-handling in this block is off:

rust-analyzer/crates/hir-ty/src/mir.rs

Lines 154 to 227 in 2b7b44b

    
           match self { 
        
               ProjectionElem::Deref => match &base.kind(Interner) { 
        
                   TyKind::Raw(_, inner) | TyKind::Ref(_, _, inner) => inner.clone(), 
        
                   TyKind::Adt(adt, subst) if is_box(db, adt.0) => { 
        
                       subst.at(Interner, 0).assert_ty_ref(Interner).clone() 
        
                   } 
        
                   _ => { 
        
                       never!("Overloaded deref on type {} is not a projection", base.display(db)); 
        
                       TyKind::Error.intern(Interner) 
        
                   } 
        
               }, 
        
               ProjectionElem::Field(Either::Left(f)) => match &base.kind(Interner) { 
        
                   TyKind::Adt(_, subst) => { 
        
                       db.field_types(f.parent)[f.local_id].clone().substitute(Interner, subst) 
        
                   } 
        
                   ty => { 
        
                       never!("Only adt has field, found {:?}", ty); 
        
                       TyKind::Error.intern(Interner) 
        
                   } 
        
               }, 
        
               ProjectionElem::Field(Either::Right(f)) => match &base.kind(Interner) { 
        
                   TyKind::Tuple(_, subst) => subst 
        
                       .as_slice(Interner) 
        
                       .get(f.index as usize) 
        
                       .map(|x| x.assert_ty_ref(Interner)) 
        
                       .cloned() 
        
                       .unwrap_or_else(|| { 
        
                           never!("Out of bound tuple field"); 
        
                           TyKind::Error.intern(Interner) 
        
                       }), 
        
                   _ => { 
        
                       never!("Only tuple has tuple field"); 
        
                       TyKind::Error.intern(Interner) 
        
                   } 
        
               }, 
        
               ProjectionElem::ClosureField(f) => match &base.kind(Interner) { 
        
                   TyKind::Closure(id, subst) => closure_field(*id, subst, *f), 
        
                   _ => { 
        
                       never!("Only closure has closure field"); 
        
                       TyKind::Error.intern(Interner) 
        
                   } 
        
               }, 
        
               ProjectionElem::ConstantIndex { .. } | ProjectionElem::Index(_) => { 
        
                   match &base.kind(Interner) { 
        
                       TyKind::Array(inner, _) | TyKind::Slice(inner) => inner.clone(), 
        
                       _ => { 
        
                           never!("Overloaded index is not a projection"); 
        
                           TyKind::Error.intern(Interner) 
        
                       } 
        
                   } 
        
               } 
        
               &ProjectionElem::Subslice { from, to } => match &base.kind(Interner) { 
        
                   TyKind::Array(inner, c) => { 
        
                       let next_c = usize_const( 
        
                           db, 
        
                           match try_const_usize(db, c) { 
        
                               None => None, 
        
                               Some(x) => x.checked_sub(u128::from(from + to)), 
        
                           }, 
        
                           krate, 
        
                       ); 
        
                       TyKind::Array(inner.clone(), next_c).intern(Interner) 
        
                   } 
        
                   TyKind::Slice(_) => base.clone(), 
        
                   _ => { 
        
                       never!("Subslice projection should only happen on slice and array"); 
        
                       TyKind::Error.intern(Interner) 
        
                   } 
        
               }, 
        
               ProjectionElem::OpaqueCast(_) => { 
        
                   never!("We don't emit these yet"); 
        
                   TyKind::Error.intern(Interner) 
        
               } 
        
           }

. It assumes type errors cannot happen, but evidently they can.

[ERROR hir_ty::mir] Only tuple or closure has tuple or closure field #15090

Description

Veykrilopenedon Jun 19, 2023

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Veykril
openedon Jun 19, 2023