};

use arrayvec::ArrayVec;

use either::Either;

use hir_def::{

lang_item::LangItemTarget,

layout::{self, ReprOptions, TargetDataLayout},

nameres::{self, diagnostics::DefDiagnostic},

per_ns::PerNs,

resolver::{HasResolver, Resolver},

};

use hir_expand::{

};

use hir_ty::{

diagnostics::BodyValidationDiagnostic,

direct_super_traits, error_lifetime, known_const_to_ast,

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

method_resolution,

primitive::UintTy,

traits::FnTrait,

};

use itertools::Itertools;

use nameres::diagnostics::DefDiagnosticKind;

use rustc_hash::FxHashSet;

use smallvec::SmallVec;

use stdx::{format_to, impl_from, never};

use syntax::{

};

use triomphe::{Arc, ThinArc};

use crate::db::{DefDatabase, HirDatabase};

pub use crate::{

diagnostics::*,

has_source::HasSource,

semantics::{

pub use {

cfg::{CfgAtom, CfgExpr, CfgOptions},

hir_def::{

attr::{AttrSourceMap, Attrs, AttrsWithOwner},

find_path::PrefixKind,

import_map,

lang_item::LangItem,

nameres::{DefMap, ModuleSource},

per_ns::Namespace,

type_ref::{Mutability, TypeRef},

visibility::Visibility,

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

// outside of hir.

{ModuleDefId, TraitId},

},

hir_expand::{

attrs::{Attr, AttrId},

change::ChangeWithProcMacros,

files::{

HirFileRange, InFile, InFileWrapper, InMacroFile, InRealFile, MacroFilePosition,

MacroFileRange,

},

inert_attr_macro::AttributeTemplate,

name::Name,

prettify_macro_expansion,

proc_macro::{ProcMacros, ProcMacrosBuilder},

},

hir_ty::{

consteval::ConstEvalError,

diagnostics::UnsafetyReason,

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

layout::LayoutError,

method_resolution::TyFingerprint,

mir::{MirEvalError, MirLowerError},

},

// FIXME: Properly encapsulate mir

};

// These are negative re-exports: pub using these names is forbidden, they

// should remain private to hir internals.

#[allow(unused)]

use {

hir_expand::{

name::AsName,

span_map::{ExpansionSpanMap, RealSpanMap, SpanMap, SpanMapRef},

/// root module.

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

pub struct Crate {

}

#[derive(Debug)]

impl Crate {

pub fn origin(self, db: &dyn HirDatabase) -> CrateOrigin {

}

pub fn is_builtin(self, db: &dyn HirDatabase) -> bool {

}

pub fn dependencies(self, db: &dyn HirDatabase) -> Vec<CrateDependency> {

.dependencies

.iter()

.map(|dep| {

}

pub fn reverse_dependencies(self, db: &dyn HirDatabase) -> Vec<Crate> {

.iter()

.map(|id| Crate { id })

.collect()

}

self,

db: &dyn HirDatabase,

) -> impl Iterator<Item = Crate> {

}

pub fn root_module(self) -> Module {

}

pub fn root_file(self, db: &dyn HirDatabase) -> FileId {

}

pub fn edition(self, db: &dyn HirDatabase) -> Edition {

}

pub fn version(self, db: &dyn HirDatabase) -> Option<String> {

}

pub fn display_name(self, db: &dyn HirDatabase) -> Option<CrateDisplayName> {

}

pub fn query_external_importables(

self,

db: &dyn DefDatabase,

query: import_map::Query,

let _p = tracing::info_span!("query_external_importables").entered();

}

pub fn all(db: &dyn HirDatabase) -> Vec<Crate> {

}

/// Try to get the root URL of the documentation of a crate.

pub fn get_html_root_url(self: &Crate, db: &dyn HirDatabase) -> Option<String> {

// Look for #![doc(html_root_url = "...")]

let attrs = db.attrs(AttrDefId::ModuleId(self.root_module().into()));

doc_url.map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")

}

}

}

pub fn to_display_target(self, db: &dyn HirDatabase) -> DisplayTarget {

}

fn core(db: &dyn HirDatabase) -> Option<Crate> {

.iter()

.find(|&krate| {

})

}

}

segments.extend(m.name(db))

}

segments.reverse();

}

pub fn canonical_module_path(

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

match self.module(db) {

Some(module) => module.krate(),

}

}

}

impl Module {

/// Name of this module.

pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {

}

/// Returns the crate this module is part of.

/// Iterates over all child modules.

pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {

let children = def_map[self.id.local_id]

.children

.values()

/// Finds a parent module.

pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {

let parent_id = def_map.containing_module(self.id.local_id)?;

Some(Module { id: parent_id })

}

pub fn nearest_non_block_module(self, db: &dyn HirDatabase) -> Module {

let mut id = self.id;

while id.is_block_module() {

}

Module { id }

}

db: &dyn HirDatabase,

visible_from: Option<Module>,

) -> Vec<(Name, ScopeDef)> {

.scope

.entries()

.filter_map(|(name, def)| {

if let Some(m) = visible_from {

} else {

Some((name, def))

}

.collect()

}

/// Fills `acc` with the module's diagnostics.

pub fn diagnostics(

self,

style_lints: bool,

) {

let _p = tracing::info_span!("diagnostics", name = ?self.name(db)).entered();

for diag in def_map.diagnostics() {

if diag.in_module != self.id.local_id {

// FIXME: This is accidentally quadratic.

acc.extend(def.diagnostics(db, style_lints))

}

ModuleDef::Trait(t) => {

emit_def_diagnostic(db, acc, diag, edition);

}

ModuleDef::Adt(adt) => {

match adt {

Adt::Struct(s) => {

push_ty_diagnostics(

db,

acc,

db.field_types_with_diagnostics(s.id.into()).1,

);

}

Adt::Union(u) => {

push_ty_diagnostics(

db,

acc,

db.field_types_with_diagnostics(u.id.into()).1,

);

}

Adt::Enum(e) => {

push_ty_diagnostics(

db,

acc,

);

}

}

}

}

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

ModuleDef::TypeAlias(type_alias) => {

push_ty_diagnostics(

db,

acc,

db.type_for_type_alias_with_diagnostics(type_alias.id).1,

);

acc.extend(def.diagnostics(db, style_lints));

}

for impl_def in self.impl_defs(db) {

GenericDef::Impl(impl_def).diagnostics(db, acc);

let node = &tree[loc.id.value];

let file_id = loc.id.file_id();

// these expansion come from us, diagnosing them is a waste of resources

// FIXME: Once we diagnose the inputs to builtin derives, we should at least extract those diagnostics somehow

continue;

let ast_id_map = db.ast_id_map(file_id);

emit_def_diagnostic(db, acc, diag, edition);

}

))

});

let res = type_params.chain(lifetime_params).any(|p| {

});

Some(res)

})()

// Negative impls can't have items, don't emit missing items diagnostic for them

if let (false, Some(trait_)) = (impl_is_negative, trait_) {

let required_items = items.iter().filter(|&(_, assoc)| match *assoc {

});

let redundant = impl_assoc_items_scratch

.iter()

db,

acc,

db.impl_self_ty_with_diagnostics(impl_def.id).1,

);

push_ty_diagnostics(

db,

acc,

db.impl_trait_with_diagnostics(impl_def.id).and_then(|it| it.1),

);

AssocItem::from(item).diagnostics(db, acc, style_lints);

}

}

}

pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {

let scope = &def_map[self.id.local_id].scope;

scope

.declarations()

}

pub fn legacy_macros(self, db: &dyn HirDatabase) -> Vec<Macro> {

let scope = &def_map[self.id.local_id].scope;

scope.legacy_macros().flat_map(|(_, it)| it).map(|&it| it.into()).collect()

}

pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {

def_map[self.id.local_id].scope.impls().map(Impl::from).collect()

}

let file_id = loc.kind.file_id();

let node =

InFile::new(file_id, db.ast_id_map(file_id).get_erased(loc.kind.erased_ast_id()));

Some(

err.span().range

.get_erased(err.span().anchor.ast_id)

.text_range()

.start(),

never!("declarative expander for non decl-macro: {:?}", e);

return;

};

emit_def_diagnostic_(

db,

acc,

) {

match diag {

DefDiagnosticKind::UnresolvedModule { ast: declaration, candidates } => {

acc.push(

UnresolvedModule {

decl: InFile::new(declaration.file_id, decl),

)

}

DefDiagnosticKind::UnresolvedExternCrate { ast } => {

acc.push(UnresolvedExternCrate { decl: InFile::new(ast.file_id, item) }.into());

}

DefDiagnosticKind::MacroError { ast, path, err } => {

acc.push(

MacroError {

node: InFile::new(ast.file_id, item.syntax_node_ptr()),

precise_location: None,

error,

kind,

}

}

DefDiagnosticKind::UnresolvedImport { id, index } => {

let file_id = id.file_id();

let import = &item_tree[id.value];

acc.push(

UnresolvedImport { decl: InFile::new(file_id, AstPtr::new(&use_tree)) }.into(),

);

}

DefDiagnosticKind::UnconfiguredCode { tree, item, cfg, opts } => {

let ast_id_map = db.ast_id_map(tree.file_id());

// FIXME: This parses... We could probably store relative ranges for the children things

// here in the item tree?

AttrOwner::Variant(it) => {

ast_id_map.get(item_tree[it].ast_id).syntax_node_ptr()

}

ast_id_map

.get(item_tree[parent].ast_id)

.to_node(&db.parse_or_expand(tree.file_id()))

.nth(idx.into_raw().into_u32() as usize)?

.syntax(),

),

};

acc.push(

InactiveCode {

);

}

DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {

// Must have a name, otherwise we wouldn't emit it.

let name = node.name().expect("unimplemented builtin macro with no name");

acc.push(

);

}

DefDiagnosticKind::InvalidDeriveTarget { ast, id } => {

let derive = node.attrs().nth(*id);

match derive {

Some(derive) => {

}

}

DefDiagnosticKind::MalformedDerive { ast, id } => {

let derive = node.attrs().nth(*id);

match derive {

Some(derive) => {

}

}

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

acc.push(

MacroDefError {

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

// - e.g. the full attribute for macro errors, but only the name for name resolution

match ast {

MacroCallKind::FnLike { ast_id, .. } => {

(

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))),

node.path()

)

}

MacroCallKind::Derive { ast_id, derive_attr_index, derive_index, .. } => {

// Compute the precise location of the macro name's token in the derive

// list.

let token = (|| {

.nth(derive_attr_index.ast_index())

.and_then(|x| Either::left(x.1))?;

let token_tree = derive_attr.meta()?.token_tree()?;

.syntax()

.children_with_tokens()

.filter_map(|elem| match elem {

syntax::NodeOrToken::Token(tok) => Some(tok),

_ => None,

})

.into_iter()

.filter(|&(comma, _)| !comma)

.nth(*derive_index as usize)?;

)

}

MacroCallKind::Attr { ast_id, invoc_attr_index, .. } => {

let attr = collect_attrs(&node)

.nth(invoc_attr_index.ast_index())

.and_then(|x| Either::left(x.1))

impl HasVisibility for Module {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

let module_data = &def_map[self.id.local_id];

module_data.visibility

}

impl Field {

pub fn name(&self, db: &dyn HirDatabase) -> Name {

}

pub fn index(&self) -> usize {

let generic_def_id: GenericDefId = match self.parent {

VariantDef::Struct(it) => it.id.into(),

VariantDef::Union(it) => it.id.into(),

};

let substs = TyBuilder::placeholder_subst(db, generic_def_id);

let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs);

self.ty(db).ty,

db.trait_environment(match hir_def::VariantId::from(self.parent) {

hir_def::VariantId::EnumVariantId(id) => {

}

hir_def::VariantId::StructId(id) => GenericDefId::AdtId(id.into()),

hir_def::VariantId::UnionId(id) => GenericDefId::AdtId(id.into()),

impl HasVisibility for Field {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

let visibility = &variant_data.fields()[self.id].visibility;

let parent_id: hir_def::VariantId = self.parent.into();

}

}

impl Struct {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {

.fields()

.iter()

.map(|(id, _)| Field { parent: self.into(), id })

}

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

}

pub fn kind(self, db: &dyn HirDatabase) -> StructKind {

}

}

pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {

impl HasVisibility for Struct {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl Union {

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

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

Type::from_value_def(db, self.id)

}

pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {

.fields()

.iter()

.map(|(id, _)| Field { parent: self.into(), id })

.collect()

}

pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {

db.attrs(self.id.into()).is_unstable()

}

impl HasVisibility for Union {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl Enum {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {

}

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

}

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

/// The type of the enum variant bodies.

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

Type::new_for_crate(

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

true => hir_def::builtin_type::BuiltinType::Int(

hir_def::builtin_type::BuiltinInt::Isize,

impl HasVisibility for Enum {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl Variant {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn parent_enum(self, db: &dyn HirDatabase) -> Enum {

}

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {

.fields()

.iter()

.map(|(id, _)| Field { parent: self.into(), id })

}

pub fn kind(self, db: &dyn HirDatabase) -> StructKind {

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

Ok(match &parent_layout.0.variants {

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

{

let rustc_enum_variant_idx = RustcEnumVariantIdx(lookup.index as usize);

Arc::new(variants[rustc_enum_variant_idx].clone())

},

}

}

/// Variants inherit visibility from the parent enum.

impl HasVisibility for Variant {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

impl Adt {

pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {

let subst = db.generic_defaults(self.into());

}

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

/// Returns the lifetime of the DataType

pub fn lifetime(&self, db: &dyn HirDatabase) -> Option<LifetimeParamData> {

let resolver = match self {

};

resolver

.generic_params()

}

pub fn as_struct(&self) -> Option<Struct> {

}

pub fn as_enum(&self) -> Option<Enum> {

}

}

VariantDef::Variant(e) => e.name(db),

}

}

}

/// The defs which have a body.

Static(Static),

Const(Const),

Variant(Variant),

}

impl DefWithBody {

pub fn module(self, db: &dyn HirDatabase) -> Module {

DefWithBody::Function(f) => f.module(db),

DefWithBody::Static(s) => s.module(db),

DefWithBody::Variant(v) => v.module(db),

}

}

DefWithBody::Static(s) => Some(s.name(db)),

DefWithBody::Const(c) => c.name(db),

DefWithBody::Variant(v) => Some(v.name(db)),

}

}

DefWithBody::Static(it) => it.ty(db),

DefWithBody::Const(it) => it.ty(db),

DefWithBody::Variant(it) => it.parent_enum(db).variant_body_ty(db),

}

}

DefWithBody::Static(it) => it.id.into(),

DefWithBody::Const(it) => it.id.into(),

DefWithBody::Variant(it) => it.into(),

}

}

/// A textual representation of the HIR of this def's body for debugging purposes.

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

let body = db.body(self.id());

}

/// A textual representation of the MIR of this def's body for debugging purposes.

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

let (body, source_map) = db.body_with_source_map(self.into());

}

};

Module { id: def_map.module_id(DefMap::ROOT) }.diagnostics(db, acc, style_lints);

}

source_map

.macro_calls()

let infer = db.infer(self.into());

for d in &infer.diagnostics {

db,

self.into(),

d,

&source_map,

));

}

continue;

}

let mut need_mut = &mol[local];

&& need_mut == &mir::MutabilityReason::Unused

{

need_mut = &mir::MutabilityReason::Not;

DefWithBody::Static(it) => it.into(),

DefWithBody::Const(it) => it.into(),

DefWithBody::Variant(it) => it.into(),

};

for diag in hir_ty::diagnostics::incorrect_case(db, def.into()) {

acc.push(diag.into())

}

}

}

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

pub struct Function {

pub(crate) id: FunctionId,

impl Function {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

}

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

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ty = TyKind::Function(callable_sig.to_fn_ptr()).intern(Interner);

/// Get this function's return type

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

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ty = callable_sig.ret().clone();

db: &dyn HirDatabase,

generics: impl Iterator<Item = Type>,

) -> Type {

ItemContainerId::ImplId(it) => Some(it.into()),

ItemContainerId::TraitId(it) => Some(it.into()),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

if !self.is_async(db) {

return None;

}

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ret_ty = callable_sig.ret().clone();

}

pub fn has_self_param(self, db: &dyn HirDatabase) -> bool {

}

pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {

}

pub fn num_params(self, db: &dyn HirDatabase) -> usize {

}

pub fn method_params(self, db: &dyn HirDatabase) -> Option<Vec<Param>> {

let environment = db.trait_environment(self.id.into());

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

callable_sig

.params()

.iter()

generics: impl Iterator<Item = Type>,

) -> Vec<Param> {

let environment = db.trait_environment(self.id.into());

ItemContainerId::ImplId(it) => Some(it.into()),

ItemContainerId::TraitId(it) => Some(it.into()),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

})

.build();

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

callable_sig

.params()

.iter()

}

pub fn is_const(self, db: &dyn HirDatabase) -> bool {

}

pub fn is_async(self, db: &dyn HirDatabase) -> bool {

}

pub fn extern_block(self, db: &dyn HirDatabase) -> Option<ExternBlock> {

ItemContainerId::ExternBlockId(id) => Some(ExternBlock { id }),

_ => None,

}

/// is this a `fn main` or a function with an `export_name` of `main`?

pub fn is_main(self, db: &dyn HirDatabase) -> bool {

db.attrs(self.id.into()).export_name() == Some(&sym::main)

}

/// Is this a function with an `export_name` of `main`?

///

/// This is false in the case of required (not provided) trait methods.

pub fn has_body(self, db: &dyn HirDatabase) -> bool {

}

pub fn as_proc_macro(self, db: &dyn HirDatabase) -> Option<Macro> {

{

return None;

}

def_map.fn_as_proc_macro(self.id).map(|id| Macro { id: id.into() })

}

impl SelfParam {

pub fn access(self, db: &dyn HirDatabase) -> Access {

func_data

.params

.first()

TypeRef::Reference(ref_) => match ref_.mutability {

hir_def::type_ref::Mutability::Shared => Access::Shared,

hir_def::type_ref::Mutability::Mut => Access::Exclusive,

// FIXME: Find better API to also handle const generics

pub fn ty_with_args(&self, db: &dyn HirDatabase, generics: impl Iterator<Item = Type>) -> Type {

ItemContainerId::ImplId(it) => it.into(),

ItemContainerId::TraitId(it) => it.into(),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => {

impl ExternCrateDecl {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn resolved_crate(self, db: &dyn HirDatabase) -> Option<Crate> {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn alias(self, db: &dyn HirDatabase) -> Option<ImportAlias> {

}

/// Returns the name under which this crate is made accessible, taking `_` into account.

pub fn alias_or_name(self, db: &dyn HirDatabase) -> Option<Name> {

Some(ImportAlias::Underscore) => None,

Some(ImportAlias::Alias(alias)) => Some(alias.clone()),

}

}

}

impl HasVisibility for ExternCrateDecl {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl Const {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

impl Static {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn is_mut(self, db: &dyn HirDatabase) -> bool {

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

}

pub fn extern_block(self, db: &dyn HirDatabase) -> Option<ExternBlock> {

ItemContainerId::ExternBlockId(id) => Some(ExternBlock { id }),

_ => None,

}

impl HasVisibility for Static {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn direct_supertraits(self, db: &dyn HirDatabase) -> Vec<Trait> {

traits.iter().map(|tr| Trait::from(*tr)).collect()

}

pub fn all_supertraits(self, db: &dyn HirDatabase) -> Vec<Trait> {

traits.iter().map(|tr| Trait::from(*tr)).collect()

}

pub fn function(self, db: &dyn HirDatabase, name: impl PartialEq<Name>) -> Option<Function> {

}

pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {

}

pub fn items_with_supertraits(self, db: &dyn HirDatabase) -> Vec<AssocItem> {

}

pub fn is_auto(self, db: &dyn HirDatabase) -> bool {

}

pub fn is_unsafe(&self, db: &dyn HirDatabase) -> bool {

}

pub fn type_or_const_param_count(

db: &dyn HirDatabase,

) -> Option<Vec<DynCompatibilityViolation>> {

let mut violations = vec![];

violations.is_empty().not().then_some(violations)

}

fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {

.macro_calls

.as_ref()

.map(|it| it.as_ref().clone().into_boxed_slice())

.unwrap_or_default()

}

}

impl HasVisibility for Trait {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl TraitAlias {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

}

impl HasVisibility for TraitAlias {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl TypeAlias {

pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {

let subst = db.generic_defaults(self.id.into());

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

}

impl HasVisibility for TypeAlias {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

}

}

impl ExternBlock {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

}

impl StaticLifetime {

pub fn name(self) -> Name {

}

}

}

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

}

pub fn name(self) -> Name {

impl Macro {

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

match self.id {

}

}

pub fn is_macro_export(self, db: &dyn HirDatabase) -> bool {

}

pub fn is_proc_macro(self) -> bool {

pub fn kind(&self, db: &dyn HirDatabase) -> MacroKind {

match self.id {

MacroExpander::Declarative => MacroKind::Declarative,

MacroExpander::BuiltIn(_) | MacroExpander::BuiltInEager(_) => {

MacroKind::DeclarativeBuiltIn

MacroExpander::BuiltInAttr(_) => MacroKind::AttrBuiltIn,

MacroExpander::BuiltInDerive(_) => MacroKind::DeriveBuiltIn,

},

MacroExpander::Declarative => MacroKind::Declarative,

MacroExpander::BuiltIn(_) | MacroExpander::BuiltInEager(_) => {

MacroKind::DeclarativeBuiltIn

MacroExpander::BuiltInAttr(_) => MacroKind::AttrBuiltIn,

MacroExpander::BuiltInDerive(_) => MacroKind::DeriveBuiltIn,

},

ProcMacroKind::CustomDerive => MacroKind::Derive,

ProcMacroKind::Bang => MacroKind::ProcMacro,

ProcMacroKind::Attr => MacroKind::Attr,

pub fn is_builtin_derive(&self, db: &dyn HirDatabase) -> bool {

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

pub fn is_env_or_option_env(&self, db: &dyn HirDatabase) -> bool {

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

pub fn is_asm_or_global_asm(&self, db: &dyn HirDatabase) -> bool {

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

match self.id {

MacroId::Macro2Id(id) => {

}

MacroId::MacroRulesId(_) => Visibility::Public,

MacroId::ProcMacroId(_) => Visibility::Public,

match self {

DefWithBody::Function(it) => it.as_assoc_item(db),

DefWithBody::Const(it) => it.as_assoc_item(db),

}

}

}

id: ID,

) -> Option<AssocItem>

where

DEF: From<ID>,

LOC: ItemTreeNode,

{

ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) => Some(ctor(DEF::from(id))),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

}

id: ID,

) -> Option<ExternAssocItem>

where

DEF: From<ID>,

LOC: ItemTreeNode,

{

ItemContainerId::ExternBlockId(_) => Some(ctor(DEF::from(id))),

ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) | ItemContainerId::ModuleId(_) => {

None

pub fn container(self, db: &dyn HirDatabase) -> AssocItemContainer {

let container = match self {

};

match container {

ItemContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),

DefWithBody::from(func).diagnostics(db, acc, style_lints);

}

AssocItem::Const(const_) => {

DefWithBody::from(const_).diagnostics(db, acc, style_lints);

}

AssocItem::TypeAlias(type_alias) => {

GenericDef::TypeAlias(type_alias).diagnostics(db, acc);

push_ty_diagnostics(

db,

acc,

db.type_for_type_alias_with_diagnostics(type_alias.id).1,

);

for diag in hir_ty::diagnostics::incorrect_case(db, type_alias.id.into()) {

acc.push(diag.into());

pub fn diagnostics(self, db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>) {

let def = self.id();

if generics.is_empty() && generics.no_predicates() {

return;

}

};

push_ty_diagnostics(

db,

acc,

db.generic_predicates_without_parent_with_diagnostics(def).1,

);

for (param_id, param) in generics.iter_type_or_consts() {

if let TypeOrConstParamData::ConstParamData(_) = param {

TypeOrConstParamId { parent: def, local_id: param_id },

))

.1,

);

}

}

}

}

// We cannot call this `Substitution` unfortunately...

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

let container = match self.def {

_ => None,

};

let container_type_params = container

TypeOrConstParamData::TypeParamData(param) => Some(param.name.clone()),

TypeOrConstParamData::ConstParamData(_) => None,

});

.iter()

.filter_map(|param| param.ty(Interner).cloned())

.zip(container_type_params.into_iter().flatten());

container_params

.chain(self_params)

.filter_map(|(ty, name)| {

})

.collect()

}

}

pub fn original_file(&self, db: &dyn HirDatabase) -> EditionedFileId {

}

pub fn file(&self) -> HirFileId {

}

pub fn is_self(self, db: &dyn HirDatabase) -> bool {

}

pub fn is_mut(self, db: &dyn HirDatabase) -> bool {

let (body, source_map) = db.body_with_source_map(self.parent);

match body.self_param.zip(source_map.self_param_syntax()) {

Some((param, source)) if param == self.binding_id => {

vec![LocalSource {

local: self,

source: source.map(|ast| Either::Right(ast.to_node(&root))),

.iter()

.map(|&definition| {

let src = source_map.pat_syntax(definition).unwrap(); // Hmm...

LocalSource {

local: self,

source: src.map(|ast| match ast.to_node(&root) {

let (body, source_map) = db.body_with_source_map(self.parent);

match body.self_param.zip(source_map.self_param_syntax()) {

Some((param, source)) if param == self.binding_id => {

LocalSource {

local: self,

source: source.map(|ast| Either::Right(ast.to_node(&root))),

.first()

.map(|&definition| {

let src = source_map.pat_syntax(definition).unwrap(); // Hmm...

LocalSource {

local: self,

source: src.map(|ast| match ast.to_node(&root) {

pub fn name(&self, db: &dyn HirDatabase) -> Name {

match self.derive {

MacroId::MacroRulesId(_) => None,

}

.unwrap_or_else(Name::missing)

}

// FIXME: Wrong name? This is could also be a registered attribute

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

pub struct BuiltinAttr {

idx: u32,

}

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

pub struct ToolModule {

idx: u32,

}

GenericParam::ConstParam(_) => return None,

GenericParam::LifetimeParam(it) => it.id.parent,

};

let index = match self {

GenericParam::TypeParam(it) => generics.type_or_const_param_idx(it.id.into())?,

GenericParam::ConstParam(_) => return None,

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

/// Is this type parameter implicitly introduced (eg. `Self` in a trait or an `impl Trait`

let params = db.generic_params(self.id.parent());

let data = &params[self.id.local_id()];

match data.type_param().unwrap().provenance {

}

}

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

let ty =

TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);

Type::new_with_resolver_inner(db, &resolver, ty)

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

let ty = generic_arg_from_param(db, self.id.into())?;

match ty.data(Interner) {

GenericArgData::Ty(it) if *it.kind(Interner) != TyKind::Error => {

Some(Type::new_with_resolver_inner(db, &resolver, it.clone()))

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

let local_idx = hir_ty::param_idx(db, id)?;

let defaults = db.generic_defaults(id.parent);

let ty = defaults.get(local_idx)?.clone();

Some(ty.substitute(Interner, &subst))

}

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

pub fn split(self, db: &dyn HirDatabase) -> Either<ConstParam, TypeParam> {

let params = db.generic_params(self.id.parent);

match &params[self.id.local_id] {

Either::Right(TypeParam { id: TypeParamId::from_unchecked(self.id) })

}

Either::Left(ConstParam { id: ConstParamId::from_unchecked(self.id) })

}

}

pub fn as_type_param(self, db: &dyn HirDatabase) -> Option<TypeParam> {

let params = db.generic_params(self.id.parent);

match &params[self.id.local_id] {

Some(TypeParam { id: TypeParamId::from_unchecked(self.id) })

}

}

}

pub fn as_const_param(self, db: &dyn HirDatabase) -> Option<ConstParam> {

let params = db.generic_params(self.id.parent);

match &params[self.id.local_id] {

Some(ConstParam { id: ConstParamId::from_unchecked(self.id) })

}

}

}

pub fn all_in_module(db: &dyn HirDatabase, module: Module) -> Vec<Impl> {

}

pub fn all_for_type(db: &dyn HirDatabase, Type { ty, env }: Type) -> Vec<Impl> {

);

}

{

if let Some(inherent_impls) = db.inherent_impls_in_block(block) {

all.extend(

pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef> {

let substs = TyBuilder::placeholder_subst(db, self.id);

let trait_ref = db.impl_trait(self.id)?.substitute(Interner, &substs);

Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))

}

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

let substs = TyBuilder::placeholder_subst(db, self.id);

let ty = db.impl_self_ty(self.id).substitute(Interner, &substs);

Type::new_with_resolver_inner(db, &resolver, ty)

}

pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {

}

pub fn is_negative(self, db: &dyn HirDatabase) -> bool {

}

pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn as_builtin_derive_path(self, db: &dyn HirDatabase) -> Option<InMacroFile<ast::Path>> {

let src = self.source(db)?;

let macro_file = src.file_id.macro_file()?;

let (derive_attr, derive_index) = match loc.kind {

MacroCallKind::Derive { ast_id, derive_attr_index, derive_index, .. } => {

(

db.crate_def_map(module_id.krate())[module_id.local_id]

.scope

}

_ => return None,

};

let path = db

.value

.0

.syntax_node()

.nth(derive_index as usize)

.and_then(<ast::Attr as AstNode>::cast)

.and_then(|it| it.path())?;

}

pub fn check_orphan_rules(self, db: &dyn HirDatabase) -> bool {

}

fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {

.macro_calls

.as_ref()

.map(|it| it.as_ref().clone().into_boxed_slice())

impl CaptureUsages {

pub fn sources(&self, db: &dyn HirDatabase) -> Vec<CaptureUsageSource> {

let (body, source_map) = db.body_with_source_map(self.parent);

let mut result = Vec::with_capacity(self.spans.len());

for &span in self.spans.iter() {

let is_ref = span.is_ref_span(&body);

Type { env: environment, ty }

}

Type { env: TraitEnvironment::empty(krate), ty }

}

fn new(db: &dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty) -> Type {

let environment = resolver

.generic_def()

.map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

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

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

ValueTyDefId::EnumVariantId(it) => {

}

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

},

Type { env: ty.env, ty: TyBuilder::slice(ty.ty) }

}

let tys = tys.iter().map(|it| it.ty.clone());

Type { env: TraitEnvironment::empty(krate), ty: TyBuilder::tuple_with(tys) }

}

pub fn contains_reference(&self, db: &dyn HirDatabase) -> bool {

return go(db, self.env.krate, &self.ty);

match ty.kind(Interner) {

// Reference itself

TyKind::Ref(_, _, _) => true,

return None;

}

self.normalize_trait_assoc_type(db, &[], output_assoc_type.into())

}

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

let iterator_trait = db.lang_item(self.env.krate, LangItem::Iterator)?.as_trait()?;

let iterator_item = db

self.normalize_trait_assoc_type(db, &[], iterator_item.into())

}

}

let into_iter_assoc_type = db

self.normalize_trait_assoc_type(db, &[], into_iter_assoc_type.into())

}

alias: TypeAlias,

) -> Option<Type> {

let mut args = args.iter();

ItemContainerId::TraitId(id) => id,

_ => unreachable!("non assoc type alias reached in normalize_trait_assoc_type()"),

};

let projection = TyBuilder::assoc_type_projection(db, alias.id, Some(parent_subst)).build();

let ty = db.normalize_projection(projection, self.env.clone());

}

pub fn is_copy(&self, db: &dyn HirDatabase) -> bool {

/// Returns types that this type dereferences to (including this type itself). The returned

/// iterator won't yield the same type more than once even if the deref chain contains a cycle.

self.autoderef_(db).map(move |ty| self.derived(ty))

}

let impls = db.inherent_impls_in_crate(krate);

for impl_def in impls.for_self_ty(&self.ty) {

if callback(item) {

return;

}

.generic_def()

.map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));

&canonical,

db,

environment,

.generic_def()

.map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));

&canonical,

db,

environment,

let _p = tracing::info_span!("applicable_inherent_traits").entered();

self.autoderef_(db)

.filter_map(|ty| ty.dyn_trait())

.map(Trait::from)

}

.flat_map(|ty| {

self.env

.traits_in_scope_from_clauses(ty)

})

.map(Trait::from)

}

self.ty.impl_trait_bounds(db).map(|it| {

it.into_iter().filter_map(|pred| match pred.skip_binders() {

hir_ty::WhereClause::Implemented(trait_ref) => {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility;

fn is_visible_from(&self, db: &dyn HirDatabase, module: Module) -> bool {

let vis = self.visibility(db);

}

}

impl<T: hir_def::HasModule> HasCrate for T {

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

}

}

impl HasContainer for ExternCrateDecl {

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)

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

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

}

}

}

impl HasContainer for Function {

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

}

}

impl HasContainer for Struct {

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

}

}

impl HasContainer for Union {

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

}

}

impl HasContainer for Enum {

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

}

}

impl HasContainer for TypeAlias {

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

}

}

impl HasContainer for Const {

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

}

}

impl HasContainer for Static {

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

}

}

impl HasContainer for Trait {

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

}

}

impl HasContainer for TraitAlias {

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

}

}

impl HasContainer for ExternBlock {

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

}

}

Impl(Impl),

Module(Module),

ExternBlock(ExternBlock),

}

/// Subset of `ide_db::Definition` that doc links can resolve to.

db: &dyn HirDatabase,

acc: &mut Vec<AnyDiagnostic>,

diagnostics: Option<ThinArc<(), TyLoweringDiagnostic>>,

) {

if let Some(diagnostics) = diagnostics {

acc.extend(

self(item)

}

}