rust-analyzer

diff --git a/crates/hir-def/src/resolver.rs b/crates/hir-def/src/resolver.rs
index c10a0ac3eb..d32e53fc6b 100644
--- a/crates/hir-def/src/resolver.rs
+++ b/crates/hir-def/src/resolver.rs

@@ -32,7 +32,7 @@ use crate::{

BindingId, ExprId, LabelId,

generics::{GenericParams, TypeOrConstParamData},

- item_scope::{BUILTIN_SCOPE, BuiltinShadowMode, ImportOrExternCrate, ImportOrGlob, ItemScope},

+ item_scope::{BUILTIN_SCOPE, BuiltinShadowMode, ImportOrExternCrate, ItemScope},

lang_item::LangItemTarget,

nameres::{DefMap, LocalDefMap, MacroSubNs, ResolvePathResultPrefixInfo, block_def_map},

per_ns::PerNs,

@@ -111,8 +111,8 @@ pub enum TypeNs {

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

pub enum ResolveValueResult {

- ValueNs(ValueNs, Option<ImportOrGlob>),

- Partial(TypeNs, usize, Option<ImportOrExternCrate>),

+ ValueNs(ValueNs),

+ Partial(TypeNs, usize),

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]

@@ -332,20 +332,17 @@ impl<'db> Resolver<'db> {

Path::Normal(it) => &it.mod_path,

Path::LangItem(l, None) => {

return Some((

- ResolveValueResult::ValueNs(

- match *l {

- LangItemTarget::FunctionId(it) => ValueNs::FunctionId(it),

- LangItemTarget::StaticId(it) => ValueNs::StaticId(it),

- LangItemTarget::StructId(it) => ValueNs::StructId(it),

- LangItemTarget::EnumVariantId(it) => ValueNs::EnumVariantId(it),

- LangItemTarget::UnionId(_)

- | LangItemTarget::ImplId(_)

- | LangItemTarget::TypeAliasId(_)

- | LangItemTarget::TraitId(_)

- | LangItemTarget::EnumId(_) => return None,

- },

- None,

- ),

+ ResolveValueResult::ValueNs(match *l {

+ LangItemTarget::FunctionId(it) => ValueNs::FunctionId(it),

+ LangItemTarget::StaticId(it) => ValueNs::StaticId(it),

+ LangItemTarget::StructId(it) => ValueNs::StructId(it),

+ LangItemTarget::EnumVariantId(it) => ValueNs::EnumVariantId(it),

+ LangItemTarget::UnionId(_)

+ | LangItemTarget::ImplId(_)

+ | LangItemTarget::TypeAliasId(_)

+ | LangItemTarget::TraitId(_)

+ | LangItemTarget::EnumId(_) => return None,

+ }),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -363,7 +360,7 @@ impl<'db> Resolver<'db> {

};

// Remaining segments start from 0 because lang paths have no segments other than the remaining.

return Some((

- ResolveValueResult::Partial(type_ns, 0, None),

+ ResolveValueResult::Partial(type_ns, 0),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -388,10 +385,7 @@ impl<'db> Resolver<'db> {

if let Some(e) = entry {

return Some((

- ResolveValueResult::ValueNs(

- ValueNs::LocalBinding(e.binding()),

- None,

- ),

+ ResolveValueResult::ValueNs(ValueNs::LocalBinding(e.binding())),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -404,14 +398,14 @@ impl<'db> Resolver<'db> {

&& *first_name == sym::Self_

{

return Some((

- ResolveValueResult::ValueNs(ValueNs::ImplSelf(impl_), None),

+ ResolveValueResult::ValueNs(ValueNs::ImplSelf(impl_)),

ResolvePathResultPrefixInfo::default(),

));

}

if let Some(id) = params.find_const_by_name(first_name, *def) {

let val = ValueNs::GenericParam(id);

return Some((

- ResolveValueResult::ValueNs(val, None),

+ ResolveValueResult::ValueNs(val),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -431,7 +425,7 @@ impl<'db> Resolver<'db> {

if let &GenericDefId::ImplId(impl_) = def {

if *first_name == sym::Self_ {

return Some((

- ResolveValueResult::Partial(TypeNs::SelfType(impl_), 1, None),

+ ResolveValueResult::Partial(TypeNs::SelfType(impl_), 1),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -440,14 +434,14 @@ impl<'db> Resolver<'db> {

{

let ty = TypeNs::AdtSelfType(adt);

return Some((

- ResolveValueResult::Partial(ty, 1, None),

+ ResolveValueResult::Partial(ty, 1),

ResolvePathResultPrefixInfo::default(),

));

}

if let Some(id) = params.find_type_by_name(first_name, *def) {

let ty = TypeNs::GenericParam(id);

return Some((

- ResolveValueResult::Partial(ty, 1, None),

+ ResolveValueResult::Partial(ty, 1),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -473,7 +467,7 @@ impl<'db> Resolver<'db> {

&& let Some(builtin) = BuiltinType::by_name(first_name)

{

return Some((

- ResolveValueResult::Partial(TypeNs::BuiltinType(builtin), 1, None),

+ ResolveValueResult::Partial(TypeNs::BuiltinType(builtin), 1),

ResolvePathResultPrefixInfo::default(),

));

}

@@ -488,7 +482,7 @@ impl<'db> Resolver<'db> {

hygiene: HygieneId,

) -> Option<ValueNs> {

match self.resolve_path_in_value_ns(db, path, hygiene)? {

- ResolveValueResult::ValueNs(it, _) => Some(it),

+ ResolveValueResult::ValueNs(it) => Some(it),

ResolveValueResult::Partial(..) => None,

}

@@ -1153,12 +1147,12 @@ impl<'db> ModuleItemMap<'db> {

);

match unresolved_idx {

None => {

- let (value, import) = to_value_ns(module_def, self.def_map)?;

- Some((ResolveValueResult::ValueNs(value, import), prefix_info))

+ let value = to_value_ns(module_def, self.def_map)?;

+ Some((ResolveValueResult::ValueNs(value), prefix_info))

}

Some(unresolved_idx) => {

- let def = module_def.take_types_full()?;

- let ty = match def.def {

+ let def = module_def.take_types()?;

+ let ty = match def {

ModuleDefId::AdtId(it) => TypeNs::AdtId(it),

ModuleDefId::TraitId(it) => TypeNs::TraitId(it),

ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),

@@ -1171,7 +1165,7 @@ impl<'db> ModuleItemMap<'db> {

| ModuleDefId::MacroId(_)

| ModuleDefId::StaticId(_) => return None,

};

- Some((ResolveValueResult::Partial(ty, unresolved_idx, def.import), prefix_info))

+ Some((ResolveValueResult::Partial(ty, unresolved_idx), prefix_info))

}

@@ -1194,12 +1188,12 @@ impl<'db> ModuleItemMap<'db> {

}

-fn to_value_ns(per_ns: PerNs, def_map: &DefMap) -> Option<(ValueNs, Option<ImportOrGlob>)> {

- let (def, import) = per_ns.take_values_import().or_else(|| {

+fn to_value_ns(per_ns: PerNs, def_map: &DefMap) -> Option<ValueNs> {

+ let def = per_ns.take_values().or_else(|| {

let Some(MacroId::ProcMacroId(proc_macro)) = per_ns.take_macros() else { return None };

// If we cannot resolve to value ns, but we can resolve to a proc macro, and this is the crate

// defining this proc macro - inside this crate, we should treat the macro as a function.

- def_map.proc_macro_as_fn(proc_macro).map(|it| (ModuleDefId::FunctionId(it), None))

+ def_map.proc_macro_as_fn(proc_macro).map(ModuleDefId::FunctionId)

})?;

let res = match def {

ModuleDefId::FunctionId(it) => ValueNs::FunctionId(it),

@@ -1215,7 +1209,7 @@ fn to_value_ns(per_ns: PerNs, def_map: &DefMap) -> Option<(ValueNs, Option<Impor

| ModuleDefId::MacroId(_)

| ModuleDefId::ModuleId(_) => return None,

};

- Some((res, import))

+ Some(res)

}

fn to_type_ns(per_ns: PerNs) -> Option<(TypeNs, Option<ImportOrExternCrate>)> {

diff --git a/crates/hir-ty/src/diagnostics/unsafe_check.rs b/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 50d4517d01..21f263723b 100644
--- a/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir-ty/src/diagnostics/unsafe_check.rs

@@ -430,7 +430,7 @@ impl<'db> UnsafeVisitor<'db> {

fn mark_unsafe_path(&mut self, node: ExprOrPatId, path: &Path) {

let hygiene = self.body.expr_or_pat_path_hygiene(node);

let value_or_partial = self.resolver.resolve_path_in_value_ns(self.db, path, hygiene);

- if let Some(ResolveValueResult::ValueNs(ValueNs::StaticId(id), _)) = value_or_partial {

+ if let Some(ResolveValueResult::ValueNs(ValueNs::StaticId(id))) = value_or_partial {

let static_data = self.db.static_signature(id);

if static_data.flags.contains(StaticFlags::MUTABLE) {

self.on_unsafe_op(node, UnsafetyReason::MutableStatic);

diff --git a/crates/hir-ty/src/infer.rs b/crates/hir-ty/src/infer.rs
index 35d744e7d1..991acda14b 100644
--- a/crates/hir-ty/src/infer.rs
+++ b/crates/hir-ty/src/infer.rs

@@ -1584,7 +1584,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {

return (self.err_ty(), None);

};

match res {

- ResolveValueResult::ValueNs(value, _) => match value {

+ ResolveValueResult::ValueNs(value) => match value {

ValueNs::EnumVariantId(var) => {

let args = path_ctx.substs_from_path(var.into(), true, false);

drop(ctx);

@@ -1608,7 +1608,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {

return (self.err_ty(), None);

}

- ResolveValueResult::Partial(typens, unresolved, _) => (typens, Some(unresolved)),

+ ResolveValueResult::Partial(typens, unresolved) => (typens, Some(unresolved)),

}

} else {

match path_ctx.resolve_path_in_type_ns() {

diff --git a/crates/hir-ty/src/infer/path.rs b/crates/hir-ty/src/infer/path.rs
index ef1a610a32..40c6fdf3cc 100644
--- a/crates/hir-ty/src/infer/path.rs
+++ b/crates/hir-ty/src/infer/path.rs

@@ -164,11 +164,11 @@ impl<'db> InferenceContext<'_, 'db> {

let value_or_partial = path_ctx.resolve_path_in_value_ns(hygiene)?;

match value_or_partial {

- ResolveValueResult::ValueNs(it, _) => {

+ ResolveValueResult::ValueNs(it) => {

drop_ctx(ctx, no_diagnostics);

(it, None)

}

- ResolveValueResult::Partial(def, remaining_index, _) => {

+ ResolveValueResult::Partial(def, remaining_index) => {

// there may be more intermediate segments between the resolved one and

// the end. Only the last segment needs to be resolved to a value; from

// the segments before that, we need to get either a type or a trait ref.

diff --git a/crates/hir-ty/src/lower/path.rs b/crates/hir-ty/src/lower/path.rs
index f3d0de1227..517f67b828 100644
--- a/crates/hir-ty/src/lower/path.rs
+++ b/crates/hir-ty/src/lower/path.rs

@@ -396,12 +396,10 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {

}

let (mod_segments, enum_segment, resolved_segment_idx) = match res {

- ResolveValueResult::Partial(_, unresolved_segment, _) => {

+ ResolveValueResult::Partial(_, unresolved_segment) => {

(segments.take(unresolved_segment - 1), None, unresolved_segment - 1)

}

- ResolveValueResult::ValueNs(ValueNs::EnumVariantId(_), _)

- if prefix_info.enum_variant =>

- {

+ ResolveValueResult::ValueNs(ValueNs::EnumVariantId(_)) if prefix_info.enum_variant => {

(segments.strip_last_two(), segments.len().checked_sub(2), segments.len() - 1)

}

ResolveValueResult::ValueNs(..) => (segments.strip_last(), None, segments.len() - 1),

@@ -431,7 +429,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {

}

match &res {

- ResolveValueResult::ValueNs(resolution, _) => {

+ ResolveValueResult::ValueNs(resolution) => {

let resolved_segment_idx = self.current_segment_u32();

let resolved_segment = self.current_or_prev_segment;

@@ -469,7 +467,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {

| ValueNs::ConstId(_) => {}

}

- ResolveValueResult::Partial(resolution, _, _) => {

+ ResolveValueResult::Partial(resolution, _) => {

if !self.handle_type_ns_resolution(resolution) {

return None;

}

diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index 199db7a3e7..8d5e5c2e6e 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs

@@ -1429,7 +1429,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {

.resolve_path_in_value_ns(self.db, c, HygieneId::ROOT)

.ok_or_else(unresolved_name)?;

match pr {

- ResolveValueResult::ValueNs(v, _) => {

+ ResolveValueResult::ValueNs(v) => {

if let ValueNs::ConstId(c) = v {

self.lower_const_to_operand(

GenericArgs::empty(self.interner()),

@@ -1439,7 +1439,7 @@ impl<'a, 'db> MirLowerCtx<'a, 'db> {

not_supported!("bad path in range pattern");

}

- ResolveValueResult::Partial(_, _, _) => {

+ ResolveValueResult::Partial(_, _) => {

not_supported!("associated constants in range pattern")

}

diff --git a/crates/hir-ty/src/mir/lower/pattern_matching.rs b/crates/hir-ty/src/mir/lower/pattern_matching.rs
index a8aacbff16..83139821e3 100644
--- a/crates/hir-ty/src/mir/lower/pattern_matching.rs
+++ b/crates/hir-ty/src/mir/lower/pattern_matching.rs

@@ -373,7 +373,7 @@ impl<'db> MirLowerCtx<'_, 'db> {

if let (

MatchingMode::Assign,

- ResolveValueResult::ValueNs(ValueNs::LocalBinding(binding), _),

+ ResolveValueResult::ValueNs(ValueNs::LocalBinding(binding)),

) = (mode, &pr)

{

let local = self.binding_local(*binding)?;

@@ -398,7 +398,7 @@ impl<'db> MirLowerCtx<'_, 'db> {

{

break 'b (c, x.1);

}

- if let ResolveValueResult::ValueNs(ValueNs::ConstId(c), _) = pr {

+ if let ResolveValueResult::ValueNs(ValueNs::ConstId(c)) = pr {

break 'b (c, GenericArgs::empty(self.interner()));

}

not_supported!("path in pattern position that is not const or variant")