+//! It is written in "OO" style. Each type is self contained (as in, it knows its

+use std::{iter, ops::ControlFlow};

+ data::adt::VariantData,

+ hir::{BindingAnnotation, BindingId, ExprOrPatId, LabelId, Pat},

+ lang_item::LangItemTarget,

+ layout::{self, ReprOptions, TargetDataLayout},

+ macro_id_to_def_id,

+ AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId, DefWithBodyId, EnumId,

+ layout::{Layout as TyLayout, RustcEnumVariantIdx, TagEncoding},

+ TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyDefId, TyExt, TyKind, ValueTyDefId,

+ WhereClause,

+use triomphe::Arc;

+ IncorrectCase, InvalidDeriveTarget, MacroDefError, MacroError, MacroExpansionParseError,

+ MalformedDerive, MismatchedArgCount, MissingFields, MissingMatchArms, MissingUnsafe,

+ MovedOutOfRef, NeedMut, NoSuchField, PrivateAssocItem, PrivateField,

+ ReplaceFilterMapNextWithFindMap, TypeMismatch, TypedHole, UndeclaredLabel,

+ UnimplementedBuiltinMacro, UnreachableLabel, UnresolvedExternCrate, UnresolvedField,

+ UnresolvedImport, UnresolvedMacroCall, UnresolvedMethodCall, UnresolvedModule,

+ UnresolvedProcMacro, UnusedMut,

+ attr::{builtin::AttributeTemplate, Attrs, AttrsWithOwner, Documentation},

+ data::adt::StructKind,

+ lang_item::LangItem,

+ nameres::{DefMap, ModuleSource},

+ // FIXME: This is here since some queries take it as input that are used

+ // outside of hir.

+ {AdtId, ModuleDefId},

+ display::{ClosureStyle, HirDisplay, HirDisplayError, HirWrite},

+ layout::LayoutError,

+ Module { id: def_map.module_id(DefMap::ROOT) }

+ let data = &db.crate_graph()[self.id];

+ data.potential_cfg_options.clone().unwrap_or_else(|| data.cfg_options.clone())

+ Some(segments.iter().map(|it| it.display(db.upcast())).join("::"))

+ Module { id: def_map.module_id(DefMap::ROOT) }

+ pub fn is_crate_root(self) -> bool {

+ DefMap::ROOT == self.id.local_id

+ format!(

+ "{:?}",

+ self.name(db)

+ .map_or("<unknown>".into(), |name| name.display(db.upcast()).to_string())

+ )

+

+ ModuleDef::Macro(m) => emit_macro_def_diagnostics(db, acc, m),

+ self.legacy_macros(db).into_iter().for_each(|m| emit_macro_def_diagnostics(db, acc, m));

+fn emit_macro_def_diagnostics(db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>, m: Macro) {

+ let id = macro_id_to_def_id(db.upcast(), m.id);

+ if let Err(e) = db.macro_def(id) {

+ let Some(ast) = id.ast_id().left() else {

+ never!("MacroDefError for proc-macro: {:?}", e);

+ return;

+ };

+ emit_def_diagnostic_(

+ db,

+ acc,

+ &DefDiagnosticKind::MacroDefError { ast, message: e.to_string() },

+ );

+ }

+}

+

+ emit_def_diagnostic_(db, acc, &diag.kind)

+}

+

+fn emit_def_diagnostic_(

+ db: &dyn HirDatabase,

+ acc: &mut Vec<AnyDiagnostic>,

+ diag: &DefDiagnosticKind,

+) {

+ match diag {

+ DefDiagnosticKind::MacroExpansionParseError { ast, errors } => {

+ let (node, precise_location, _, _) = precise_macro_call_location(ast, db);

+ acc.push(

+ MacroExpansionParseError { node, precise_location, errors: errors.clone() }.into(),

+ );

+ }

+ DefDiagnosticKind::MacroDefError { ast, message } => {

+ let node = ast.to_node(db.upcast());

+ acc.push(

+ MacroDefError {

+ node: InFile::new(ast.file_id, AstPtr::new(&node)),

+ name: node.name().map(|it| it.syntax().text_range()),

+ message: message.clone(),

+ }

+ .into(),

+ );

+ }

+ // FIXME: maybe we actually want slightly different ranges for the different macro diagnostics

+ db.layout_of_ty(self.ty(db).ty.clone(), self.parent.module(db).krate().into())

+ .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).into()).unwrap()))

+ pub fn constructor_ty(self, db: &dyn HirDatabase) -> Type {

+ Type::from_value_def(db, self.id)

+ }

+

+ pub fn constructor_ty(self, db: &dyn HirDatabase) -> Type {

+ Type::from_value_def(db, self.id)

+ }

+

+ pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprOptions> {

+ db.enum_data(self.id).repr

+ }

+

+ layout::IntegerType::Pointer(sign) => match sign {

+ layout::IntegerType::Fixed(i, sign) => match sign {

+ layout::Integer::I8 => hir_def::builtin_type::BuiltinInt::I8,

+ layout::Integer::I16 => hir_def::builtin_type::BuiltinInt::I16,

+ layout::Integer::I32 => hir_def::builtin_type::BuiltinInt::I32,

+ layout::Integer::I64 => hir_def::builtin_type::BuiltinInt::I64,

+ layout::Integer::I128 => hir_def::builtin_type::BuiltinInt::I128,

+ layout::Integer::I8 => hir_def::builtin_type::BuiltinUint::U8,

+ layout::Integer::I16 => hir_def::builtin_type::BuiltinUint::U16,

+ layout::Integer::I32 => hir_def::builtin_type::BuiltinUint::U32,

+ layout::Integer::I64 => hir_def::builtin_type::BuiltinUint::U64,

+ layout::Integer::I128 => hir_def::builtin_type::BuiltinUint::U128,

+ /// Returns true if at least one variant of this enum is a non-unit variant.

+

+ pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

+ Adt::from(self).layout(db)

+ }

+ pub fn constructor_ty(self, db: &dyn HirDatabase) -> Type {

+ Type::from_value_def(db, EnumVariantId { parent: self.parent.id, local_id: self.id })

+ }

+

+

+ pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

+ let parent_enum = self.parent_enum(db);

+ let parent_layout = parent_enum.layout(db)?;

+ Ok(match &parent_layout.0.variants {

+ layout::Variants::Multiple { variants, .. } => Layout(

+ Arc::new(variants[RustcEnumVariantIdx(self.id)].clone()),

+ db.target_data_layout(parent_enum.krate(db).into()).unwrap(),

+ ),

+ _ => parent_layout,

+ })

+ }

+ let krate = self.krate(db).id;

+ db.layout_of_adt(self.into(), Substitution::empty(Interner), krate)

+ .map(|layout| Layout(layout, db.target_data_layout(krate).unwrap()))

+ BodyDiagnostic::UnreachableLabel { node, name } => {

+ acc.push(UnreachableLabel { node: node.clone(), name: name.clone() }.into())

+ }

+ BodyDiagnostic::UndeclaredLabel { node, name } => {

+ acc.push(UndeclaredLabel { node: node.clone(), name: name.clone() }.into())

+ }

+ &hir_ty::InferenceDiagnostic::BreakOutsideOfLoop {

+ expr,

+ is_break,

+ bad_value_break,

+ } => {

+ let expr = expr_syntax(expr);

+ acc.push(BreakOutsideOfLoop { expr, is_break, bad_value_break }.into())

+ }

+ hir_ty::InferenceDiagnostic::TypedHole { expr, expected } => {

+ let expr = expr_syntax(*expr);

+ acc.push(

+ TypedHole {

+ expr,

+ expected: Type::new(db, DefWithBodyId::from(self), expected.clone()),

+ }

+ .into(),

+ )

+ }

+ // FIXME: Here and elsewhere in this file, the `expr` was

+ if let Ok(borrowck_results) = db.borrowck(self.into()) {

+ for borrowck_result in borrowck_results.iter() {

+ let mir_body = &borrowck_result.mir_body;

+ for moof in &borrowck_result.moved_out_of_ref {

+ let span: InFile<SyntaxNodePtr> = match moof.span {

+ mir::MirSpan::ExprId(e) => match source_map.expr_syntax(e) {

+ Ok(s) => s.map(|x| x.into()),

+ Err(_) => continue,

+ },

+ mir::MirSpan::PatId(p) => match source_map.pat_syntax(p) {

+ Ok(s) => s.map(|x| match x {

+ Either::Left(e) => e.into(),

+ Either::Right(e) => e.into(),

+ }),

+ Err(_) => continue,

+ },

+ mir::MirSpan::Unknown => continue,

+ };

+ acc.push(

+ MovedOutOfRef { ty: Type::new_for_crate(krate, moof.ty.clone()), span }

+ .into(),

+ )

+ }

+ let mol = &borrowck_result.mutability_of_locals;

+ for (binding_id, binding_data) in hir_body.bindings.iter() {

+ if binding_data.problems.is_some() {

+ // We should report specific diagnostics for these problems, not `need-mut` and `unused-mut`.

+ continue;

+ }

+ let Some(&local) = mir_body.binding_locals.get(binding_id) else {

+ continue;

+ };

+ let need_mut = &mol[local];

+ let local = Local { parent: self.into(), binding_id };

+ match (need_mut, local.is_mut(db)) {

+ (mir::MutabilityReason::Mut { .. }, true)

+ | (mir::MutabilityReason::Not, false) => (),

+ (mir::MutabilityReason::Mut { spans }, false) => {

+ for span in spans {

+ let span: InFile<SyntaxNodePtr> = match span {

+ mir::MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {

+ Ok(s) => s.map(|x| x.into()),

+ Err(_) => continue,

+ },

+ mir::MirSpan::PatId(p) => match source_map.pat_syntax(*p) {

+ Ok(s) => s.map(|x| match x {

+ Either::Left(e) => e.into(),

+ Either::Right(e) => e.into(),

+ }),

+ Err(_) => continue,

+ },

+ mir::MirSpan::Unknown => continue,

+ };

+ acc.push(NeedMut { local, span }.into());

+ }

+ }

+ (mir::MutabilityReason::Not, true) => {

+ if !infer.mutated_bindings_in_closure.contains(&binding_id) {

+ let should_ignore = matches!(body[binding_id].name.as_str(), Some(x) if x.starts_with("_"));

+ if !should_ignore {

+ acc.push(UnusedMut { local }.into())

+ }

+ }

+ pub fn ty(self, db: &dyn HirDatabase) -> Type {

+ Type::from_value_def(db, self.id)

+ }

+

+ pub fn eval(

+ self,

+ db: &dyn HirDatabase,

+ span_formatter: impl Fn(FileId, TextRange) -> String,

+ ) -> String {

+ let body = match db.monomorphized_mir_body(

+ self.id.into(),

+ Substitution::empty(Interner),

+ db.trait_environment(self.id.into()),

+ ) {

+ Ok(body) => body,

+ Err(e) => {

+ let mut r = String::new();

+ _ = e.pretty_print(&mut r, db, &span_formatter);

+ return r;

+ }

+ };

+ let (result, stdout, stderr) = interpret_mir(db, &body, false);

+ let mut text = match result {

+ Ok(_) => "pass".to_string(),

+ Err(e) => {

+ let mut r = String::new();

+ _ = e.pretty_print(&mut r, db, &span_formatter);

+ r

+ }

+ };

+ if !stdout.is_empty() {

+ text += "\n--------- stdout ---------\n";

+ text += &stdout;

+ }

+ if !stderr.is_empty() {

+ text += "\n--------- stderr ---------\n";

+ text += &stderr;

+ }

+ text

+ Some(self.as_local(db)?.name(db))

+ .map(|param| match &**param {

+ Type::from_value_def(db, self.id)

+ let c = db.const_eval(self.id.into(), Substitution::empty(Interner))?;

+ Type::from_value_def(db, self.id)

+ pub fn file(&self) -> HirFileId {

+ self.source.file_id

+ }

+

+ pub fn name(&self) -> Option<InFile<ast::Name>> {

+ self.source.as_ref().map(|it| it.name()).transpose()

+ hir_def::attr::builtin::find_builtin_attr_idx(name)

+ None => SmolStr::new(hir_def::attr::builtin::INERT_ATTRIBUTES[self.idx as usize].name),

+ None => Some(hir_def::attr::builtin::INERT_ATTRIBUTES[self.idx as usize].template),

+ hir_def::attr::builtin::TOOL_MODULES

+ None => SmolStr::new(hir_def::attr::builtin::TOOL_MODULES[self.idx as usize]),

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

+pub struct Closure {

+ id: ClosureId,

+ subst: Substitution,

+}

+

+impl From<Closure> for ClosureId {

+ fn from(value: Closure) -> Self {

+ value.id

+ }

+}

+

+impl Closure {

+ fn as_ty(self) -> Ty {

+ TyKind::Closure(self.id, self.subst).intern(Interner)

+ }

+

+ pub fn display_with_id(&self, db: &dyn HirDatabase) -> String {

+ self.clone().as_ty().display(db).with_closure_style(ClosureStyle::ClosureWithId).to_string()

+ }

+

+ pub fn display_with_impl(&self, db: &dyn HirDatabase) -> String {

+ self.clone().as_ty().display(db).with_closure_style(ClosureStyle::ImplFn).to_string()

+ }

+

+ pub fn captured_items(&self, db: &dyn HirDatabase) -> Vec<ClosureCapture> {

+ let owner = db.lookup_intern_closure((self.id).into()).0;

+ let infer = &db.infer(owner);

+ let info = infer.closure_info(&self.id);

+ info.0

+ .iter()

+ .cloned()

+ .map(|capture| ClosureCapture { owner, closure: self.id, capture })

+ .collect()

+ }

+

+ pub fn capture_types(&self, db: &dyn HirDatabase) -> Vec<Type> {

+ let owner = db.lookup_intern_closure((self.id).into()).0;

+ let infer = &db.infer(owner);

+ let (captures, _) = infer.closure_info(&self.id);

+ captures

+ .iter()

+ .cloned()

+ .map(|capture| Type {

+ env: db.trait_environment_for_body(owner),

+ ty: capture.ty(&self.subst),

+ })

+ .collect()

+ }

+

+ pub fn fn_trait(&self, db: &dyn HirDatabase) -> FnTrait {

+ let owner = db.lookup_intern_closure((self.id).into()).0;

+ let infer = &db.infer(owner);

+ let info = infer.closure_info(&self.id);

+ info.1

+ }

+}

+

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

+pub struct ClosureCapture {

+ owner: DefWithBodyId,

+ closure: ClosureId,

+ capture: hir_ty::CapturedItem,

+}

+

+impl ClosureCapture {

+ pub fn local(&self) -> Local {

+ Local { parent: self.owner, binding_id: self.capture.local() }

+ }

+

+ pub fn kind(&self) -> CaptureKind {

+ match self.capture.kind() {

+ hir_ty::CaptureKind::ByRef(

+ hir_ty::mir::BorrowKind::Shallow | hir_ty::mir::BorrowKind::Shared,

+ ) => CaptureKind::SharedRef,

+ hir_ty::CaptureKind::ByRef(hir_ty::mir::BorrowKind::Unique) => {

+ CaptureKind::UniqueSharedRef

+ }

+ hir_ty::CaptureKind::ByRef(hir_ty::mir::BorrowKind::Mut { .. }) => {

+ CaptureKind::MutableRef

+ }

+ hir_ty::CaptureKind::ByValue => CaptureKind::Move,

+ }

+ }

+

+ pub fn display_place(&self, db: &dyn HirDatabase) -> String {

+ self.capture.display_place(self.owner, db)

+ }

+}

+

+pub enum CaptureKind {

+ SharedRef,

+ UniqueSharedRef,

+ MutableRef,

+ Move,

+}

+

+ fn from_def(db: &dyn HirDatabase, def: impl Into<TyDefId> + HasResolver) -> Type {

+ let ty = db.ty(def.into());

+ let substs = TyBuilder::unknown_subst(

+ db,

+ match def.into() {

+ TyDefId::AdtId(it) => GenericDefId::AdtId(it),

+ TyDefId::TypeAliasId(it) => GenericDefId::TypeAliasId(it),

+ TyDefId::BuiltinType(_) => return Type::new(db, def, ty.skip_binders().clone()),

+ );

+ Type::new(db, def, ty.substitute(Interner, &substs))

+ }

+

+ fn from_value_def(db: &dyn HirDatabase, def: impl Into<ValueTyDefId> + HasResolver) -> Type {

+ let ty = db.value_ty(def.into());

+ let substs = TyBuilder::unknown_subst(

+ db,

+ match def.into() {

+ ValueTyDefId::ConstId(it) => GenericDefId::ConstId(it),

+ ValueTyDefId::FunctionId(it) => GenericDefId::FunctionId(it),

+ ValueTyDefId::StructId(it) => GenericDefId::AdtId(AdtId::StructId(it)),

+ ValueTyDefId::UnionId(it) => GenericDefId::AdtId(AdtId::UnionId(it)),

+ ValueTyDefId::EnumVariantId(it) => GenericDefId::EnumVariantId(it),

+ ValueTyDefId::StaticId(_) => return Type::new(db, def, ty.skip_binders().clone()),

+ },

+ );

+ Type::new(db, def, ty.substitute(Interner, &substs))

+ db.trait_solve(self.env.krate, self.env.block, goal).is_some()

+ let mut the_ty = &self.ty;

+ TyKind::Ref(_, _, ty) if ty.as_closure().is_some() => {

+ the_ty = ty;

+ Callee::Closure(ty.as_closure().unwrap())

+ }

+ let sig = the_ty.callable_sig(db)?;

+ pub fn as_closure(&self) -> Option<Closure> {

+ match self.ty.kind(Interner) {

+ TyKind::Closure(id, subst) => Some(Closure { id: *id, subst: subst.clone() }),

+ _ => None,

+ }

+ }

+

+ pub fn as_array(&self, db: &dyn HirDatabase) -> Option<(Type, usize)> {

+ try_const_usize(db, len).map(|x| (self.derived(ty.clone()), x as usize))

+ autoderef(db, self.env.clone(), canonical).map(|canonical| canonical.value)

+ // add the type and const parameters

+

+ pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

+ db.layout_of_ty(self.ty.clone(), self.env.krate)

+ .map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap()))

+ }

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

+pub struct Layout(Arc<TyLayout>, Arc<TargetDataLayout>);

+

+impl Layout {

+ pub fn size(&self) -> u64 {

+ self.0.size.bytes()

+ }

+

+ pub fn align(&self) -> u64 {

+ self.0.align.abi.bytes()

+ }

+

+ pub fn niches(&self) -> Option<u128> {

+ Some(self.0.largest_niche?.available(&*self.1))

+ }

+

+ pub fn field_offset(&self, idx: usize) -> Option<u64> {

+ match self.0.fields {

+ layout::FieldsShape::Primitive => None,

+ layout::FieldsShape::Union(_) => Some(0),

+ layout::FieldsShape::Array { stride, count } => {

+ let i = u64::try_from(idx).ok()?;

+ (i < count).then_some((stride * i).bytes())

+ }

+ layout::FieldsShape::Arbitrary { ref offsets, .. } => Some(offsets.get(idx)?.bytes()),

+ }

+ }

+

+ pub fn enum_tag_size(&self) -> Option<usize> {

+ let tag_size =

+ if let layout::Variants::Multiple { tag, tag_encoding, .. } = &self.0.variants {

+ match tag_encoding {

+ TagEncoding::Direct => tag.size(&*self.1).bytes_usize(),

+ TagEncoding::Niche { .. } => 0,

+ }

+ } else {

+ return None;

+ };

+ Some(tag_size)

+ }

+}

+

+impl HasCrate for Enum {

+ fn krate(&self, db: &dyn HirDatabase) -> Crate {

+ self.module(db).krate()

+ }

+}

+

+

+pub trait HasContainer {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer;

+}

+

+impl HasContainer for Module {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ // FIXME: handle block expressions as modules (their parent is in a different DefMap)

+ let def_map = self.id.def_map(db.upcast());

+ match def_map[self.id.local_id].parent {

+ Some(parent_id) => ItemContainer::Module(Module { id: def_map.module_id(parent_id) }),

+ None => ItemContainer::Crate(def_map.krate()),

+ }

+ }

+}

+

+impl HasContainer for Function {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ container_id_to_hir(self.id.lookup(db.upcast()).container)

+ }

+}

+

+impl HasContainer for Struct {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ ItemContainer::Module(Module { id: self.id.lookup(db.upcast()).container })

+ }

+}

+

+impl HasContainer for Union {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ ItemContainer::Module(Module { id: self.id.lookup(db.upcast()).container })

+ }

+}

+

+impl HasContainer for Enum {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ ItemContainer::Module(Module { id: self.id.lookup(db.upcast()).container })

+ }

+}

+

+impl HasContainer for TypeAlias {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ container_id_to_hir(self.id.lookup(db.upcast()).container)

+ }

+}

+

+impl HasContainer for Const {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ container_id_to_hir(self.id.lookup(db.upcast()).container)

+ }

+}

+

+impl HasContainer for Static {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ container_id_to_hir(self.id.lookup(db.upcast()).container)

+ }

+}

+

+impl HasContainer for Trait {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ ItemContainer::Module(Module { id: self.id.lookup(db.upcast()).container })

+ }

+}

+

+impl HasContainer for TraitAlias {

+ fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

+ ItemContainer::Module(Module { id: self.id.lookup(db.upcast()).container })

+ }

+}

+

+fn container_id_to_hir(c: ItemContainerId) -> ItemContainer {

+ match c {

+ ItemContainerId::ExternBlockId(_id) => ItemContainer::ExternBlock(),

+ ItemContainerId::ModuleId(id) => ItemContainer::Module(Module { id }),

+ ItemContainerId::ImplId(id) => ItemContainer::Impl(Impl { id }),

+ ItemContainerId::TraitId(id) => ItemContainer::Trait(Trait { id }),

+ }

+}

+

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

+pub enum ItemContainer {

+ Trait(Trait),

+ Impl(Impl),

+ Module(Module),

+ ExternBlock(),

+ Crate(CrateId),

+}