8000 Clean up `DbInterner` · rust-lang/rust-analyzer@fbf45f7 · GitHub
[go: up one dir, main page]
Skip to content
  • Insights

    • Commit fbf45f7

    Browse files
    VeykrilVeykril
    committed
    Clean up DbInterner 
    1 parent 2c2aad3 commit fbf45f7

    31 files changed

    +441
    -465
    lines changed

    ‎crates/hir-ty/src/consteval.rs‎

    Lines changed: 11 additions & 13 deletions
    Original file line numberDiff line numberDiff line change
    @@ -248,19 +248,17 @@ pub(crate) fn const_eval_query(
    248248
    subst: Substitution,
    249249
    trait_env: Option<Arc<TraitEnvironment>>,
    250250
    ) -> Result<Const, ConstEvalError> {
    251-
    crate::next_solver::tls::with_db(db, || {
    252-
    let body = match def {
    253-
    GeneralConstId::ConstId(c) => {
    254-
    db.monomorphized_mir_body(c.into(), subst, db.trait_environment(c.into()))?
    255-
    }
    256-
    GeneralConstId::StaticId(s) => {
    257-
    let krate = s.module(db).krate();
    258-
    db.monomorphized_mir_body(s.into(), subst, TraitEnvironment::empty(krate))?
    259-
    }
    260-
    };
    261-
    let c = interpret_mir(db, body, false, trait_env)?.0?;
    262-
    Ok(c)
    263-
    })
    251+
    let body = match def {
    252+
    GeneralConstId::ConstId(c) => {
    253+
    db.monomorphized_mir_body(c.into(), subst, db.trait_environment(c.into()))?
    254+
    }
    255+
    GeneralConstId::StaticId(s) => {
    256+
    let krate = s.module(db).krate();
    257+
    db.monomorphized_mir_body(s.into(), subst, TraitEnvironment::empty(krate))?
    258+
    }
    259+
    };
    260+
    let c = interpret_mir(db, body, false, trait_env)?.0?;
    261+
    Ok(c)
    264262
    }
    265263

    266264
    pub(crate) fn const_eval_static_query(

    ‎crates/hir-ty/src/consteval_nextsolver.rs‎

    Lines changed: 5 additions & 5 deletions
    Original file line numberDiff line numberDiff line change
    @@ -37,7 +37,7 @@ pub(crate) fn path_to_const<'a, 'g>(
    3737
    args: impl FnOnce() -> &'g Generics,
    3838
    expected_ty: Ty<'a>,
    3939
    ) -> Option<Const<'a>> {
    40-
    let interner = DbInterner::new();
    40+
    let interner = DbInterner::new(db);
    4141
    match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) {
    4242
    Some(ValueNs::GenericParam(p)) => {
    4343
    let args = args();
    @@ -69,7 +69,7 @@ pub(crate) fn path_to_const<'a, 'g>(
    6969

    7070
    pub fn unknown_const<'db>(ty: Ty<'db>) -> Const<'db> {
    7171
    Const::new(
    72-
    DbInterner::new(),
    72+
    DbInterner::conjure(),
    7373
    rustc_type_ir::ConstKind::Value(ValueConst::new(ty, ConstScalar::Unknown)),
    7474
    )
    7575
    }
    @@ -80,7 +80,7 @@ pub fn unknown_const_as_generic<'db>(ty: Ty<'db>) -> GenericArg<'db> {
    8080

    8181
    /// Interns a constant scalar with the given type
    8282
    pub fn intern_const_scalar<'db>(value: ConstScalar, ty: Ty<'db>) -> Const<'db> {
    83-
    Const::new(DbInterner::new(), rustc_type_ir::ConstKind::Value(ValueConst::new(ty, value)))
    83+
    Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Value(ValueConst::new(ty, value)))
    8484
    }
    8585

    8686
    /// Interns a constant scalar with the given type
    @@ -115,13 +115,13 @@ pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Cr
    115115
    intern_const_ref(
    116116
    db,
    117117
    &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt),
    118-
    Ty::new_uint(DbInterner::new(), rustc_type_ir::UintTy::Usize),
    118+
    Ty::new_uint(DbInterner::new(db), rustc_type_ir::UintTy::Usize),
    119119
    krate,
    120120
    )
    121121
    }
    122122

    123123
    pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<u128> {
    124-
    let interner = DbInterner::new_with(db, None, None);
    124+
    let interner = DbInterner::new(db);
    125125
    match c.clone().kind() {
    126126
    ConstKind::Param(_) => None,
    127127
    ConstKind::Infer(_) => None,

    ‎crates/hir-ty/src/db.rs‎

    Lines changed: 2 additions & 0 deletions
    Original file line numberDiff line numberDiff line change
    @@ -307,6 +307,8 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
    307307
    #[salsa::cycle(cycle_result = crate::drop::has_drop_glue_cycle_result)]
    308308
    fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue;
    309309

    310+
    // next trait solver
    311+
    310312
    #[salsa::invoke(crate::layout_nextsolver::layout_of_adt_query)]
    311313
    #[salsa::cycle(cycle_result = crate::layout_nextsolver::layout_of_adt_cycle_result)]
    312314
    fn layout_of_adt_ns<'db>(

    ‎crates/hir-ty/src/infer.rs‎

    Lines changed: 40 additions & 42 deletions
    Original file line numberDiff line numberDiff line change
    @@ -89,54 +89,52 @@ pub(crate) use closure::{CaptureKind, CapturedItem, CapturedItemWithoutTy};
    8989
    /// The entry point of type inference.
    9090
    pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
    9191
    crate::next_solver::with_new_cache(|| {
    92-
    crate::next_solver::tls::with_db(db, || {
    93-
    let _p = tracing::info_span!("infer_query").entered();
    94-
    let resolver = def.resolver(db);
    95-
    let body = db.body(def);
    96-
    let mut ctx = InferenceContext::new(db, def, &body, resolver);
    97-
    98-
    match def {
    99-
    DefWithBodyId::FunctionId(f) => {
    100-
    ctx.collect_fn(f);
    101-
    }
    102-
    DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
    103-
    DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
    104-
    DefWithBodyId::VariantId(v) => {
    105-
    ctx.return_ty = TyBuilder::builtin(
    106-
    match db.enum_signature(v.lookup(db).parent).variant_body_type() {
    107-
    hir_def::layout::IntegerType::Pointer(signed) => match signed {
    108-
    true => BuiltinType::Int(BuiltinInt::Isize),
    109-
    false => BuiltinType::Uint(BuiltinUint::Usize),
    110-
    },
    111-
    hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
    112-
    true => BuiltinType::Int(match size {
    113-
    Integer::I8 => BuiltinInt::I8,
    114-
    Integer::I16 => BuiltinInt::I16,
    115-
    Integer::I32 => BuiltinInt::I32,
    116-
    Integer::I64 => BuiltinInt::I64,
    117-
    Integer::I128 => BuiltinInt::I128,
    118-
    }),
    119-
    false => BuiltinType::Uint(match size {
    120-
    Integer::I8 => BuiltinUint::U8,
    121-
    Integer::I16 => BuiltinUint::U16,
    122-
    Integer::I32 => BuiltinUint::U32,
    123-
    Integer::I64 => BuiltinUint::U64,
    124-
    Integer::I128 => BuiltinUint::U128,
    125-
    }),
    126-
    },
    92+
    let _p = tracing::info_span!("infer_query").entered();
    93+
    let resolver = def.resolver(db);
    94+
    let body = db.body(def);
    95+
    let mut ctx = InferenceContext::new(db, def, &body, resolver);
    96+
    97+
    match def {
    98+
    DefWithBodyId::FunctionId(f) => {
    99+
    ctx.collect_fn(f);
    100+
    }
    101+
    DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
    102+
    DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
    103+
    DefWithBodyId::VariantId(v) => {
    104+
    ctx.return_ty = TyBuilder::builtin(
    105+
    match db.enum_signature(v.lookup(db).parent).variant_body_type() {
    106+
    hir_def::layout::IntegerType::Pointer(signed) => match signed {
    107+
    true => BuiltinType::Int(BuiltinInt::Isize),
    108+
    false => BuiltinType::Uint(BuiltinUint::Usize),
    127109
    },
    128-
    );
    129-
    }
    110+
    hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
    111+
    true => BuiltinType::Int(match size {
    112+
    Integer::I8 => BuiltinInt::I8,
    113+
    Integer::I16 => BuiltinInt::I16,
    114+
    Integer::I32 => BuiltinInt::I32,
    115+
    Integer::I64 => BuiltinInt::I64,
    116+
    Integer::I128 => BuiltinInt::I128,
    117+
    }),
    118+
    false => BuiltinType::Uint(match size {
    119+
    Integer::I8 => BuiltinUint::U8,
    120+
    Integer::I16 => BuiltinUint::U16,
    121+
    Integer::I32 => BuiltinUint::U32,
    122+
    Integer::I64 => BuiltinUint::U64,
    123+
    Integer::I128 => BuiltinUint::U128,
    124+
    }),
    125+
    },
    126+
    },
    127+
    );
    130128
    }
    129+
    }
    131130

    132-
    ctx.infer_body();
    131+
    ctx.infer_body();
    133132

    134-
    ctx.infer_mut_body();
    133+
    ctx.infer_mut_body();
    135134

    136-
    ctx.infer_closures();
    135+
    ctx.infer_closures();
    137136

    138-
    Arc::new(ctx.resolve_all())
    139-
    })
    137+
    Arc::new(ctx.resolve_all())
    140138
    })
    141139
    }
    142140

    ‎crates/hir-ty/src/layout_nextsolver.rs‎

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -335,7 +335,7 @@ fn field_ty<'a>(
    335335
    fd: LocalFieldId,
    336336
    args: &GenericArgs<'a>,
    337337
    ) -> Ty<'a> {
    338-
    db.field_types_ns(def)[fd].clone().instantiate(DbInterner::new(), args)
    338+
    db.field_types_ns(def)[fd].clone().instantiate(DbInterner::new(db), args)
    339339
    }
    340340

    341341
    fn scalar_unit(dl: &TargetDataLayout, value: Primitive) -> Scalar {

    ‎crates/hir-ty/src/layout_nextsolver/adt.rs‎

    Lines changed: 66 additions & 72 deletions
    Original file line numberDiff line numberDiff line change
    @@ -26,80 +26,74 @@ pub fn layout_of_adt_query<'db>(
    2626
    args: GenericArgs<'db>,
    2727
    trait_env: Arc<TraitEnvironment>,
    2828
    ) -> Result<Arc<Layout>, LayoutError> {
    29-
    crate::next_solver::tls::with_db(db, || {
    30-
    let krate = trait_env.krate;
    31-
    let Ok(target) = db.target_data_layout(krate) else {
    32-
    return Err(LayoutError::TargetLayoutNotAvailable);
    33-
    };
    34-
    let dl = &*target;
    35-
    let cx = LayoutCx::new(dl);
    36-
    let handle_variant = |def: VariantId, var: &VariantFields| {
    37-
    var.fields()
    29+
    let krate = trait_env.krate;
    30+
    let Ok(target) = db.target_data_layout(krate) else {
    31+
    return Err(LayoutError::TargetLayoutNotAvailable);
    32+
    };
    33+
    let dl = &*target;
    34+
    let cx = LayoutCx::new(dl);
    35+
    let handle_variant = |def: VariantId, var: &VariantFields| {
    36+
    var.fields()
    37+
    .iter()
    38+
    .map(|(fd, _)| layout_of_ty_query(db, field_ty(db, def, fd, &args), trait_env.clone()))
    39+
    .collect::<Result<Vec<_>, _>>()
    40+
    };
    41+
    let (variants, repr, is_special_no_niche) = match def {
    42+
    AdtId::StructId(s) => {
    43+
    let data = db.struct_signature(s);
    44+
    let mut r = SmallVec::<[_; 1]>::new();
    45+
    r.push(handle_variant(s.into(), s.fields(db))?);
    46+
    (
    47+
    r,
    48+
    data.repr.unwrap_or_default(),
    49+
    data.flags.intersects(StructFlags::IS_UNSAFE_CELL | StructFlags::IS_UNSAFE_PINNED),
    50+
    )
    51+
    }
    52+
    AdtId::UnionId(id) => {
    53+
    let data = db.union_signature(id);
    54+
    let mut r = SmallVec::new();
    55+
    r.push(handle_variant(id.into(), id.fields(db))?);
    56+
    (r, data.repr.unwrap_or_default(), false)
    57+
    }
    58+
    AdtId::EnumId(e) => {
    59+
    let variants = e.enum_variants(db);
    60+
    let r = variants
    61+
    .variants
    3862
    .iter()
    39-
    .map(|(fd, _)| {
    40-
    layout_of_ty_query(db, field_ty(db, def, fd, &args), trait_env.clone())
    41-
    })
    42-
    .collect::<Result<Vec<_>, _>>()
    43-
    };
    44-
    let (variants, repr, is_special_no_niche) = match def {
    45-
    AdtId::StructId(s) => {
    46-
    let data = db.struct_signature(s);
    47-
    let mut r = SmallVec::<[_; 1]>::new();
    48-
    r.push(handle_variant(s.into(), s.fields(db))?);
    49-
    (
    50-
    r,
    51-
    data.repr.unwrap_or_default(),
    52-
    data.flags
    53-
    .intersects(StructFlags::IS_UNSAFE_CELL | StructFlags::IS_UNSAFE_PINNED),
    54-
    )
    55-
    }
    56-
    AdtId::UnionId(id) => {
    57-
    let data = db.union_signature(id);
    58-
    let mut r = SmallVec::new();
    59-
    r.push(handle_variant(id.into(), id.fields(db))?);
    60-
    (r, data.repr.unwrap_or_default(), false)
    61-
    }
    62-
    AdtId::EnumId(e) => {
    63-
    let variants = e.enum_variants(db);
    64-
    let r = variants
    65-
    .variants
    63+
    .map(|&(v, _, _)| handle_variant(v.into(), v.fields(db)))
    64+
    .collect::<Result<SmallVec<_>, _>>()?;
    65+
    (r, db.enum_signature(e).repr.unwrap_or_default(), false)
    66+
    }
    67+
    };
    68+
    let variants = variants
    69+
    .iter()
    70+
    .map(|it| it.iter().map(|it| &**it).collect::<Vec<_>>())
    71+
    .collect::<SmallVec<[_; 1]>>();
    72+
    let variants = variants.iter().map(|it| it.iter().collect()).collect::<IndexVec<_, _>>();
    73+
    let result = if matches!(def, AdtId::UnionId(..)) {
    74+
    cx.calc.layout_of_union(&repr, &variants)?
    75+
    } else {
    76+
    cx.calc.layout_of_struct_or_enum(
    77+
    &repr,
    78+
    &variants,
    79+
    matches!(def, AdtId::EnumId(..)),
    80+
    is_special_no_niche,
    81+
    layout_scalar_valid_range(db, def),
    82+
    |min, max| repr_discr(dl, &repr, min, max).unwrap_or((Integer::I8, false)),
    83+
    variants.iter_enumerated().filter_map(|(id, _)| {
    84+
    let AdtId::EnumId(e) = def else { return None };
    85+
    let d = db.const_eval_discriminant(e.enum_variants(db).variants[id.0].0).ok()?;
    86+
    Some((id, d))
    87+
    }),
    88+
    !matches!(def, AdtId::EnumId(..))
    89+
    && variants
    6690
    .iter()
    67-
    .map(|&(v, _, _)| handle_variant(v.into(), v.fields(db)))
    68-
    .collect::<Result<SmallVec<_>, _>>()?;
    69-
    (r, db.enum_signature(e).repr.unwrap_or_default(), false)
    70-
    }
    71-
    };
    72-
    let variants = variants
    73-
    .iter()
    74-
    .map(|it| it.iter().map(|it| &**it).collect::<Vec<_>>())
    75-
    .collect::<SmallVec<[_; 1]>>();
    76-
    let variants = variants.iter().map(|it| it.iter().collect()).collect::<IndexVec<_, _>>();
    77-
    let result = if matches!(def, AdtId::UnionId(..)) {
    78-
    cx.calc.layout_of_union(&repr, &variants)?
    79-
    } else {
    80-
    cx.calc.layout_of_struct_or_enum(
    81-
    &repr,
    82-
    &variants,
    83-
    matches!(def, AdtId::EnumId(..)),
    84-
    is_special_no_niche,
    85-
    layout_scalar_valid_range(db, def),
    86-
    |min, max| repr_discr(dl, &repr, min, max).unwrap_or((Integer::I8, false)),
    87-
    variants.iter_enumerated().filter_map(|(id, _)| {
    88-
    let AdtId::EnumId(e) = def else { return None };
    89-
    let d =
    90-
    db.const_eval_discriminant(e.enum_variants(db).variants[id.0].0).ok()?;
    91-
    Some((id, d))
    92-
    }),
    93-
    !matches!(def, AdtId::EnumId(..))
    94-
    && variants
    95-
    .iter()
    96-
    .next()
    97-
    .and_then(|it| it.iter().last().map(|it| !it.is_unsized()))
    98-
    .unwrap_or(true),
    99-
    )?
    100-
    };
    101-
    Ok(Arc::new(result))
    102-
    })
    91+
    .next()
    92+
    .and_then(|it| it.iter().last().map(|it| !it.is_unsized()))
    93+
    .unwrap_or(true),
    94+
    )?
    95+
    };
    96+
    Ok(Arc::new(result))
    10397
    }
    10498

    10599
    pub(crate) fn layout_of_adt_cycle_result<'db>(

    0 commit comments

    Comments
     (0)
    0