[[package]]

name = "lsp-server"

dependencies = [

"crossbeam-channel",

"log",

[[package]]

name = "serde"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"serde_derive",

]

[[package]]

name = "serde_derive"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"proc-macro2",

"quote",

[[package]]

name = "serde_json"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"indexmap",

"itoa",

[[package]]

name = "xflags"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"xflags-macros",

]

[[package]]

name = "xflags-macros"

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]

name = "xshell"

Env::default(),

Ok(Vec::new()),

false,

);

} else {

for (from, to, prelude) in crate_deps {

Env::default(),

Ok(proc_macro),

true,

);

for krate in all_crates {

let (version, origin) = match b.split_once(':') {

Some(("CratesIo", data)) => match data.split_once(',') {

Some((version, url)) => {

}

_ => panic!("Bad crates.io parameter: {}", data),

},

let crate_origin = match &*crate_str {

"std" => CrateOrigin::Lang(LangCrateOrigin::Std),

"core" => CrateOrigin::Lang(LangCrateOrigin::Core),

};

(crate_str, crate_origin, None)

}

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

pub enum CrateOrigin {

/// Crates that are from crates.io official registry,

/// Crates that are provided by the language, like std, core, proc-macro, ...

Lang(LangCrateOrigin),

}

Env::default(),

Ok(Vec::new()),

false,

);

let crate2 = graph.add_crate_root(

FileId(2u32),

Env::default(),

Ok(Vec::new()),

false,

);

let crate3 = graph.add_crate_root(

FileId(3u32),

Env::default(),

Ok(Vec::new()),

false,

);

assert!(graph

.add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2))

Env::default(),

Ok(Vec::new()),

false,

);

let crate2 = graph.add_crate_root(

FileId(2u32),

Env::default(),

Ok(Vec::new()),

false,

);

assert!(graph

.add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2))

Env::default(),

Ok(Vec::new()),

false,

);

let crate2 = graph.add_crate_root(

FileId(2u32),

Env::default(),

Ok(Vec::new()),

false,

);

let crate3 = graph.add_crate_root(

FileId(3u32),

Env::default(),

Ok(Vec::new()),

false,

);

assert!(graph

.add_dep(crate1, Dependency::new(CrateName::new("crate2").unwrap(), crate2))

Env::default(),

Ok(Vec::new()),

false,

);

let crate2 = graph.add_crate_root(

FileId(2u32),

Env::default(),

Ok(Vec::new()),

false,

);

assert!(graph

.add_dep(

}

fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {

let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);

select! {

recv(inbox) -> msg => msg.ok().map(Event::Restart),

recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),

}

}

fn run(mut self, inbox: Receiver<Restart>) {

match event {

Event::Restart(Restart::No) => {

self.cancel_check_process();

Event::Restart(Restart::Yes) => {

// Cancel the previously spawned process

self.cancel_check_process();

let command = self.check_command();

tracing::debug!(?command, "will restart flycheck");

//! Defines hir-level representation of structs, enums and unions

use base_db::CrateId;

use either::Either;

use hir_expand::{

name::{AsName, Name},

};

use la_arena::{Arena, ArenaMap};

use syntax::ast::{self, HasName, HasVisibility};

use crate::{

body::{CfgExpander, LowerCtx},

db::DefDatabase,

intern::Interned,

src::HasChildSource,

src::HasSource,

trace::Trace,

type_ref::TypeRef,

visibility::RawVisibility,

};

use cfg::CfgOptions;

pub struct StructData {

pub name: Name,

pub variant_data: Arc<VariantData>,

pub visibility: RawVisibility,

}

pub struct EnumData {

pub name: Name,

pub variants: Arena<EnumVariantData>,

pub visibility: RawVisibility,

}

pub visibility: RawVisibility,

}

pub enum ReprKind {

}

fn repr_from_value(

krate: CrateId,

item_tree: &ItemTree,

of: AttrOwner,

item_tree.attrs(db, krate, of).by_key("repr").tt_values().find_map(parse_repr_tt)

}

match tt.delimiter {

Some(Delimiter { kind: DelimiterKind::Parenthesis, .. }) => {}

_ => return None,

}

}

}

impl StructData {

pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {

let loc = id.lookup(db);

let krate = loc.container.krate;

let item_tree = loc.id.item_tree(db);

let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();

let strukt = &item_tree[loc.id.value];

}

pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {

let loc = id.lookup(db);

let krate = loc.container.krate;

let item_tree = loc.id.item_tree(db);

let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();

let union = &item_tree[loc.id.value];

}

}

impl EnumData {

pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {

let loc = e.lookup(db);

let krate = loc.container.krate;

let item_tree = loc.id.item_tree(db);

let cfg_options = db.crate_graph()[krate].cfg_options.clone();

let enum_ = &item_tree[loc.id.value];

let mut variants = Arena::new();

for tree_id in enum_.variants.clone() {

db,

krate,

&item_tree,

&cfg_options,

&var.fields,

Some(enum_.visibility),

);

variants.alloc(EnumVariantData {

name: var.name.clone(),

variant_data: Arc::new(var_data),

});

}

}

}

pub fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {

let (id, _) = self.variants.iter().find(|(_id, data)| &data.name == name)?;

Some(id)

}

}

impl HasChildSource<LocalEnumVariantId> for EnumId {

fn lower_fields(

db: &dyn DefDatabase,

krate: CrateId,

item_tree: &ItemTree,

cfg_options: &CfgOptions,

fields: &Fields,

override_visibility: Option<RawVisibilityId>,

match fields {

Fields::Record(flds) => {

let mut arena = Arena::new();

for field_id in flds.clone() {

}

}

}

Fields::Tuple(flds) => {

let mut arena = Arena::new();

for field_id in flds.clone() {

}

}

}

}

}

macro_id_to_def_id,

nameres::DefMap,

path::{ModPath, Path},

AsMacroCall, BlockId, DefWithBodyId, HasModule, LocalModuleId, Lookup, MacroId, ModuleId,

UnresolvedMacro,

};

let src = s.source(db);

(src.file_id, s.module(db), src.value.body())

}

};

let expander = Expander::new(db, file_id, module);

let (mut body, source_map) = Body::new(db, expander, params, body);

builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},

db::DefDatabase,

expr::{

},

intern::Interned,

item_scope::BuiltinShadowMode,

name_to_pat_grouping: Default::default(),

is_lowering_inside_or_pat: false,

is_lowering_assignee_expr: false,

}

.collect(params, body)

}

name_to_pat_grouping: FxHashMap<Name, Vec<PatId>>,

is_lowering_inside_or_pat: bool,

is_lowering_assignee_expr: bool,

}

impl ExprCollector<'_> {

self.alloc_expr(Expr::Return { expr }, syntax_ptr)

}

ast::Expr::YieldExpr(e) => {

let expr = e.expr().map(|e| self.collect_expr(e));

self.alloc_expr(Expr::Yield { expr }, syntax_ptr)

}

.ret_type()

.and_then(|r| r.ty())

.map(|it| Interned::new(TypeRef::from_ast(&self.ctx(), it)));

let body = self.collect_expr_opt(e.body());

self.alloc_expr(

Expr::Closure {

args: args.into(),

arg_types: arg_types.into(),

ret_type,

body,

},

syntax_ptr,

)

use std::fmt::{self, Write};

use crate::{

pretty::{print_generic_args, print_path, print_type_ref},

type_ref::TypeRef,

};

};

format!("const {} = ", name)

}

};

let mut p = Printer { body, buf: header, indent_level: 0, needs_indent: false };

self.print_expr(*index);

w!(self, "]");

}

w!(self, "|");

for (i, (pat, ty)) in args.iter().zip(arg_types.iter()).enumerate() {

if i != 0 {

impl ChildBySource for DefWithBodyId {

fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {

let body = db.body(*self);

for (_, def_map) in body.blocks(db) {

// All block expressions are merged into the same map, because they logically all add

// inner items to the containing `DefWithBodyId`.

pub(crate) fn trait_data_with_diagnostics_query(

db: &dyn DefDatabase,

tr: TraitId,

let tr_loc @ ItemLoc { container: module_id, id: tree_id } = tr.lookup(db);

let item_tree = tree_id.item_tree(db);

let tr_def = &item_tree[tree_id.value];

visibility,

skip_array_during_method_dispatch,

}),

)

}

pub(crate) fn impl_data_with_diagnostics_query(

db: &dyn DefDatabase,

id: ImplId,

let _p = profile::span("impl_data_with_diagnostics_query");

let ItemLoc { container: module_id, id: tree_id } = id.lookup(db);

(

Arc::new(ImplData { target_trait, self_ty, items, is_negative, attribute_calls }),

)

}

#[salsa::invoke(StructData::struct_data_query)]

fn struct_data(&self, id: StructId) -> Arc<StructData>;

#[salsa::invoke(StructData::union_data_query)]

fn union_data(&self, id: UnionId) -> Arc<StructData>;

#[salsa::invoke(EnumData::enum_data_query)]

fn enum_data(&self, e: EnumId) -> Arc<EnumData>;

#[salsa::invoke(ImplData::impl_data_query)]

fn impl_data(&self, e: ImplId) -> Arc<ImplData>;

#[salsa::invoke(ImplData::impl_data_with_diagnostics_query)]

#[salsa::invoke(TraitData::trait_data_query)]

fn trait_data(&self, e: TraitId) -> Arc<TraitData>;

#[salsa::invoke(TraitData::trait_data_with_diagnostics_query)]

#[salsa::invoke(TypeAliasData::type_alias_data_query)]

fn type_alias_data(&self, e: TypeAliasId) -> Arc<TypeAliasData>;

arg_types: Box<[Option<Interned<TypeRef>>]>,

ret_type: Option<Interned<TypeRef>>,

body: ExprId,

},

Tuple {

exprs: Box<[ExprId]>,

Underscore,

}

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

pub enum Array {

ElementList { elements: Box<[ExprId]>, is_assignee_expr: bool },

db,

def_map,

visited_modules,

crate_root,

info.container,

max_len - 1,

prefixed,

pub struct Variant {

pub name: Name,

pub fields: Fields,

}

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

Unit,

}

/// A single field of an enum variant or struct

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

pub struct Field {

pub name: Name,

pub type_ref: Interned<TypeRef>,

pub visibility: RawVisibilityId,

}

let name = field.name()?.as_name();

let visibility = self.lower_visibility(field);

let type_ref = self.lower_type_ref_opt(field.ty());

Some(res)

}

let name = Name::new_tuple_field(idx);

let visibility = self.lower_visibility(field);

let type_ref = self.lower_type_ref_opt(field.ty());

}

fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> {

fn lower_variant(&mut self, variant: &ast::Variant) -> Option<Variant> {

let name = variant.name()?.as_name();

let fields = self.lower_fields(&variant.kind());

Some(res)

}

w!(self, "{{");

self.indented(|this| {

for field in fields.clone() {

this.print_attrs_of(field);

this.print_visibility(*visibility);

w!(this, "{}: ", name);

w!(self, "(");

self.indented(|this| {

for field in fields.clone() {

this.print_attrs_of(field);

this.print_visibility(*visibility);

w!(this, "{}: ", name);

self.print_where_clause_and_opening_brace(generic_params);

self.indented(|this| {

for variant in variants.clone() {

this.print_attrs_of(variant);

w!(this, "{}", name);

this.print_fields(fields);

FunctionId(FunctionId),

StaticId(StaticId),

ConstId(ConstId),

}

impl_from!(FunctionId, ConstId, StaticId for DefWithBodyId);

impl DefWithBodyId {

pub fn as_generic_def_id(self) -> Option<GenericDefId> {

match self {

DefWithBodyId::FunctionId(f) => Some(f.into()),

DefWithBodyId::StaticId(_) => None,

DefWithBodyId::ConstId(c) => Some(c.into()),

}

}

}

DefWithBodyId::FunctionId(it) => it.lookup(db).module(db),

DefWithBodyId::StaticId(it) => it.lookup(db).module(db),

DefWithBodyId::ConstId(it) => it.lookup(db).module(db),

}

}

}

DefWithBodyId::FunctionId(it) => it.lookup(db).id.value.into(),

DefWithBodyId::StaticId(it) => it.lookup(db).id.value.into(),

DefWithBodyId::ConstId(it) => it.lookup(db).id.value.into(),

}

}

}

fn emit_unconfigured_diagnostic(&mut self, item: ModItem, cfg: &CfgExpr) {

let ast_id = item.ast_id(self.item_tree);

self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(

self.module_id,

ast_id,

use cfg::{CfgExpr, CfgOptions};

use hir_expand::MacroCallKind;

use la_arena::Idx;

use crate::{

attr::AttrId,

UnresolvedImport { id: ItemTreeId<item_tree::Import>, index: Idx<ast::UseTree> },

UnresolvedProcMacro { ast: MacroCallKind, krate: CrateId },

pub fn unconfigured_code(

container: LocalModuleId,

cfg: CfgExpr,

opts: CfgOptions,

) -> Self {

DefWithBodyId::ConstId(c) => c.resolver(db),

DefWithBodyId::FunctionId(f) => f.resolver(db),

DefWithBodyId::StaticId(s) => s.resolver(db),

}

}

}

// trait does not change ids of top-level items, which helps caching.

bdfs(node, |it| {

let kind = it.kind();

res.alloc(&it);

true

} else {

_ => None,

}

}

}

impl InFile<SyntaxToken> {

Iterator,

IntoIterator,

Item,

Try,

Ok,

Future,

let target = db.trait_data(deref_trait).associated_type_by_name(&name![Target])?;

let projection = {

if b.remaining() != 1 {

// the Target type + Deref trait should only have one generic parameter,

// namely Deref's Self type

return None;

}

};

// Check that the type implements Deref at all

cast::{Cast, CastTo, Caster},

fold::TypeFoldable,

interner::HasInterner,

};

use hir_def::{

};

use smallvec::SmallVec;

use crate::{

consteval::unknown_const_as_generic, db::HirDatabase, infer::unify::InferenceTable, primitive,

};

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

data: D,

vec: SmallVec<[GenericArg; 2]>,

param_kinds: SmallVec<[ParamKind; 2]>,

}

impl<A> TyBuilder<A> {

fn with_data<B>(self, data: B) -> TyBuilder<B> {

}

}

impl<D> TyBuilder<D> {

}

fn build_internal(self) -> (D, Substitution) {

for (a, e) in self.vec.iter().zip(self.param_kinds.iter()) {

self.assert_match_kind(a, e);

}

(self.data, subst)

}

pub fn push(mut self, arg: impl CastTo<GenericArg>) -> Self {

let arg = arg.cast(Interner);

let expected_kind = &self.param_kinds[self.vec.len()];

let arg_kind = match arg.data(Interner) {

chalk_ir::GenericArgData::Ty(_) => ParamKind::Type,

chalk_ir::GenericArgData::Lifetime(_) => panic!("Got lifetime in TyBuilder::push"),

}

};

assert_eq!(*expected_kind, arg_kind);

self.vec.push(arg);

self

}

pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self {

// self.fill is inlined to make borrow checker happy

let mut this = self;

let filler = (starting_from..).zip(other).map(|(idx, kind)| match kind {

}

});

this.vec.extend(filler.take(this.remaining()).casted(Interner));

assert_eq!(this.remaining(), 0);

pub fn fill_with_unknown(self) -> Self {

// self.fill is inlined to make borrow checker happy

let mut this = self;

ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()),

});

this.vec.extend(filler.casted(Interner));

pub(crate) fn fill_with_inference_vars(self, table: &mut InferenceTable<'_>) -> Self {

self.fill(|x| match x {

})

}

pub fn fill(mut self, filler: impl FnMut(&ParamKind) -> GenericArg) -> Self {

assert_eq!(self.remaining(), 0);

self

}

fn assert_match_kind(&self, a: &chalk_ir::GenericArg<Interner>, e: &ParamKind) {

match (a.data(Interner), e) {

(chalk_ir::GenericArgData::Ty(_), ParamKind::Type)

params.placeholder_subst(db)

}

}

pub fn build(self) -> Substitution {

impl TyBuilder<hir_def::AdtId> {

pub fn adt(db: &dyn HirDatabase, def: hir_def::AdtId) -> TyBuilder<hir_def::AdtId> {

}

pub fn fill_with_defaults(

db: &dyn HirDatabase,

mut fallback: impl FnMut() -> Ty,

) -> Self {

let defaults = db.generic_defaults(self.data.into());

for default_ty in defaults.iter().skip(self.vec.len()) {

if x.is_unknown() {

self.vec.push(fallback().cast(Interner));

continue;

}

self.vec.push(default_ty.clone().substitute(Interner, &subst_so_far).cast(Interner));

}

self

pub struct Tuple(usize);

impl TyBuilder<Tuple> {

pub fn tuple(size: usize) -> TyBuilder<Tuple> {

}

pub fn build(self) -> Ty {

impl TyBuilder<TraitId> {

pub fn trait_ref(db: &dyn HirDatabase, def: TraitId) -> TyBuilder<TraitId> {

}

pub fn build(self) -> TraitRef {

}

impl TyBuilder<TypeAliasId> {

}

pub fn build(self) -> ProjectionTy {

}

impl<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>> TyBuilder<Binders<T>> {

pub fn build(self) -> T {

let (b, subst) = self.build_internal();

b.substitute(Interner, &subst)

}

impl TyBuilder<Binders<Ty>> {

}

pub fn impl_self_ty(db: &dyn HirDatabase, def: hir_def::ImplId) -> TyBuilder<Binders<Ty>> {

}

}

}

use base_db::CrateId;

use hir_def::{

lang_item::{lang_attr, LangItemTarget},

AssocItemId, GenericDefId, HasModule, ItemContainerId, Lookup, ModuleId, TypeAliasId,

};

to_assoc_type_id, to_chalk_trait_id,

traits::ChalkContext,

utils::generics,

};

pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;

}

fn generator_datum(

&self,

) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {

}

fn generator_witness_datum(

&self,

) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {

}

fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {

let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());

let ctx = crate::TyLoweringContext::new(db, &resolver)

.with_type_param_mode(crate::lower::ParamLoweringMode::Variable);

.fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)

.build();

let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);

let mut bounds: Vec<_> = type_alias_data

.bounds

.iter()

TyKind::FnDef(def, parameters) => {

let callable_def = db.lookup_intern_callable_def((*def).into());

let sig = db.callable_item_signature(callable_def);

}

TyKind::Closure(.., substs) => {

let sig_param = substs.at(Interner, 0).assert_ty_ref(Interner);

let trait_ref = match self.kind(Interner) {

// The principal trait bound should be the first element of the bounds. This is an

// invariant ensured by `TyLoweringContext::lower_dyn_trait()`.

TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().get(0).and_then(|b| {

match b.skip_binders() {

WhereClause::Implemented(trait_ref) => Some(trait_ref),

use chalk_ir::{BoundVar, DebruijnIndex, GenericArgData, IntTy, Scalar};

use hir_def::{

expr::{ArithOp, BinaryOp, Expr, ExprId, Literal, Pat, PatId},

path::ModPath,

resolver::{resolver_for_expr, ResolveValueResult, Resolver, ValueNs},

type_ref::ConstScalar,

};

use stdx::never;

use crate::{

db::HirDatabase, infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx,

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

pub enum ComputedExpr {

Literal(Literal),

Tuple(Box<[ComputedExpr]>),

}

Literal::String(x) => std::fmt::Debug::fmt(x, f),

Literal::ByteString(x) => std::fmt::Debug::fmt(x, f),

},

ComputedExpr::Tuple(t) => {

f.write_char('(')?;

for x in &**t {

}

}

pub fn eval_const(

expr_id: ExprId,

ctx: &mut ConstEvalCtx<'_>,

) -> Result<ComputedExpr, ConstEvalError> {

let expr = &ctx.exprs[expr_id];

match expr {

Expr::Literal(l) => Ok(ComputedExpr::Literal(l.clone())),

&Expr::UnaryOp { expr, op } => {

let ty = &ctx.expr_ty(expr);

return Ok(ComputedExpr::Literal(Literal::Bool(!b)))

}

ComputedExpr::Literal(Literal::Int(v, _)) => v,

_ => return Err(ConstEvalError::NotSupported("this kind of operator")),

};

let r = match ty.kind(Interner) {

hir_def::expr::UnaryOp::Neg => {

let v = match ev {

ComputedExpr::Literal(Literal::Int(v, _)) => v,

_ => return Err(ConstEvalError::NotSupported("this kind of operator")),

};

Ok(ComputedExpr::Literal(Literal::Int(

let op = op.ok_or(ConstEvalError::IncompleteExpr)?;

let v1 = match lhs {

ComputedExpr::Literal(Literal::Int(v, _)) => v,

_ => return Err(ConstEvalError::NotSupported("this kind of operator")),

};

let v2 = match rhs {

ComputedExpr::Literal(Literal::Int(v, _)) => v,

_ => return Err(ConstEvalError::NotSupported("this kind of operator")),

};

match op {

ValueNs::GenericParam(_) => {

Err(ConstEvalError::NotSupported("const generic without substitution"))

}

_ => Err(ConstEvalError::NotSupported("path that are not const or local")),

}

}

_ => Err(ConstEvalError::NotSupported("This kind of expression")),

}

}

Err(ConstEvalError::Loop)

}

db: &dyn HirDatabase,

const_id: ConstId,

) -> Result<ComputedExpr, ConstEvalError> {

result

}

pub(crate) fn eval_to_const<'a>(

expr: Idx<Expr>,

mode: ParamLoweringMode,

}

#[test]

fn const_loop() {

check_fail(

r#"

use arrayvec::ArrayVec;

use base_db::{impl_intern_key, salsa, CrateId, Upcast};

use hir_def::{

};

use la_arena::ArenaMap;

#[salsa::invoke(crate::lower::const_param_ty_query)]

fn const_param_ty(&self, def: ConstParamId) -> Ty;

#[salsa::cycle(crate::consteval::const_eval_recover)]

fn const_eval(&self, def: ConstId) -> Result<ComputedExpr, ConstEvalError>;

#[salsa::invoke(crate::lower::impl_trait_query)]

fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;

fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId;

#[salsa::interned]

fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;

#[salsa::invoke(chalk_db::associated_ty_data_query)]

fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;

DefWithBodyId::ConstId(it) => {

db.const_data(it).name.clone().unwrap_or_else(Name::missing).to_string()

}

});

db.infer_query(def)

}

pub struct InternedClosureId(salsa::InternId);

impl_intern_key!(InternedClosureId);

/// This exists just for Chalk, because Chalk just has a single `FnDefId` where

/// we have different IDs for struct and enum variant constructors.

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

let is_unsafe = match def {

DefWithBodyId::FunctionId(it) => db.function_data(it).has_unsafe_kw(),

};

if is_unsafe {

return res;

};

use hir_expand::{hygiene::Hygiene, name::Name};

use itertools::Itertools;

use syntax::SmolStr;

use crate::{

db::HirDatabase,

from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, lt_from_placeholder_idx,

mapping::from_chalk,

utils::{self, generics},

AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Const, ConstValue, DomainGoal,

GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData, LifetimeOutlives, Mutability,

PathNotFound,

UnknownType,

Closure,

}

pub enum HirDisplayError {

let total_len = parent_params + self_param + type_params + const_params;

// We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?

if total_len > 0 {

write!(f, "<")?;

write!(f, ">")?;

}

}

Some(x) => x,

None => return true,

};

parameter != &actual_default

}

let mut default_from = 0;

write!(f, "{{unknown}}")?;

}

TyKind::InferenceVar(..) => write!(f, "_")?,

TyKind::GeneratorWitness(..) => write!(f, "{{generator witness}}")?,

}

Ok(())

use chalk_ir::{cast::Cast, ConstValue, DebruijnIndex, Mutability, Safety, Scalar, TypeFlags};

use hir_def::{

body::Body,

data::{ConstData, StaticData},

expr::{BindingAnnotation, ExprId, PatId},

lang_item::LangItemTarget,

path::{path, Path},

resolver::{HasResolver, ResolveValueResult, Resolver, TypeNs, ValueNs},

type_ref::TypeRef,

};

use hir_expand::name::{name, Name};

use itertools::Either;

DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)),

DefWithBodyId::FunctionId(f) => ctx.collect_fn(f),

DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_data(s)),

}

ctx.infer_body();

/// unresolved or missing subpatterns or subpatterns of mismatched types.

pub type_of_pat: ArenaMap<PatId, Ty>,

type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>,

standard_types: InternedStandardTypes,

/// Stores the types which were implicitly dereferenced in pattern binding modes.

pub pat_adjustments: FxHashMap<PatId, Vec<Ty>>,

/// closures, but currently this is the only field that will change there,

/// so it doesn't make sense.

return_ty: Ty,

diverges: Diverges,

breakables: Vec<BreakableContext>,

}

table: unify::InferenceTable::new(db, trait_env.clone()),

trait_env,

return_ty: TyKind::Error.intern(Interner), // set in collect_fn_signature

db,

owner,

body,

&mut self,

inner_ty: Ty,

assoc_ty: Option<TypeAliasId>,

params: &[GenericArg],

) -> Ty {

match assoc_ty {

self.resolve_variant_on_alias(ty, unresolved, path)

}

TypeNs::TypeAliasId(it) => {

.fill_with_inference_vars(&mut self.table)

.build();

self.resolve_variant_on_alias(ty, unresolved, path)

fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {

let path = path![core::iter::IntoIterator];

let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?;

self.db.trait_data(trait_).associated_type_by_name(&name![Item])

}

use super::{Expectation, InferenceContext};

impl InferenceContext<'_> {

pub(super) fn deduce_closure_type_from_expectations(

&mut self,

closure_expr: ExprId,

// Deduction from where-clauses in scope, as well as fn-pointer coercion are handled here.

let _ = self.coerce(Some(closure_expr), closure_ty, &expected_ty);

// Deduction based on the expected `dyn Fn` is done separately.

if let TyKind::Dyn(dyn_ty) = expected_ty.kind(Interner) {

if let Some(sig) = self.deduce_sig_from_dyn_ty(dyn_ty) {

cast::Cast, fold::Shift, DebruijnIndex, GenericArgData, Mutability, TyVariableKind,

};

use hir_def::{

generics::TypeOrConstParamData,

path::{GenericArg, GenericArgs},

resolver::resolver_for_expr,

}

&Expr::For { iterable, body, pat, label } => {

let iterable_ty = self.infer_expr(iterable, &Expectation::none());

self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item());

self.infer_pat(pat, &pat_ty, BindingMode::default());

self.with_breakable_ctx(BreakableKind::Loop, self.err_ty(), label, |this| {

self.diverges = Diverges::Maybe;

TyBuilder::unit()

}

assert_eq!(args.len(), arg_types.len());

let mut sig_tys = Vec::new();

),

})

.intern(Interner);

// Eagerly try to relate the closure type with the expected

// type, otherwise we often won't have enough information to

// infer the body.

// Now go through the argument patterns

for (arg_pat, arg_ty) in args.iter().zip(sig_tys) {

let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);

let prev_ret_ty = mem::replace(&mut self.return_ty, ret_ty.clone());

self.with_breakable_ctx(BreakableKind::Border, self.err_ty(), None, |this| {

this.infer_expr_coerce(*body, &Expectation::has_type(ret_ty));

self.diverges = prev_diverges;

self.return_ty = prev_ret_ty;

}

Expr::Call { callee, args, .. } => {

let callee_ty = self.infer_expr(*callee, &Expectation::none());

TyKind::Never.intern(Interner)

}

Expr::Yield { expr } => {

}

}

Expr::RecordLit { path, fields, spread, .. } => {

let (ty, def_id) = self.resolve_variant(path.as_deref(), false);

let lhs_ty = self.infer_expr(lhs, &lhs_expectation);

let rhs_ty = self.table.new_type_var();

});

None => {

let rhs_ty = self.builtin_binary_op_rhs_expectation(op, lhs_ty.clone());

let rhs_ty = self.infer_expr_coerce(rhs, &Expectation::from_option(rhs_ty));

}

};

.push(lhs_ty.clone())

.push(rhs_ty.clone())

.build();

assert_eq!(self_params, 0); // method shouldn't have another Self param

let total_len = parent_params + type_params + const_params + impl_trait_params;

let mut substs = Vec::with_capacity(total_len);

// handle provided arguments

if let Some(generic_args) = generic_args {

// if args are provided, it should be all of them, but we can't rely on that

.iter()

.filter(|arg| !matches!(arg, GenericArg::Lifetime(_)))

.take(type_params + const_params)

{

if let Some(g) = generic_arg_to_chalk(

self.db,

}

}

};

for (id, data) in def_generics.iter().skip(substs.len()) {

match data {

TypeOrConstParamData::TypeParamData(_) => {

CallableDefId::FunctionId(f) => {

if let ItemContainerId::TraitId(trait_) = f.lookup(self.db.upcast()).container {

// construct a TraitRef

);

self.push_obligation(

TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs }

builder::ParamKind,

consteval,

method_resolution::{self, VisibleFromModule},

};

use super::{ExprOrPatId, InferenceContext, TraitRef};

ValueNs::GenericParam(it) => return Some(self.db.const_param_ty(it)),

};

let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);

let substs = ctx.substs_from_path(path, typable, true);

.fill(|x| {

it.next().unwrap_or_else(|| match x {

ParamKind::Const(ty) => consteval::unknown_const_as_generic(ty.clone()),

})

})

};

let substs = match container {

ItemContainerId::ImplId(impl_id) => {

.fill_with_inference_vars(&mut self.table)

.build();

let impl_self_ty =

.build();

let projection = {

if b.remaining() != 2 {

return None;

}

};

let trait_env = self.trait_env.env.clone();

// FIXME we're probably doing something wrong here

self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16);

let (

self_params,

list_params,

const_params,

};

TyKind::BoundVar(BoundVar::new(

self.in_binders,

))

.intern(Interner)

}

.intern(Interner)

}

TypeNs::SelfType(impl_id) => {

ParamLoweringMode::Variable => {

}

}

TypeNs::AdtSelfType(adt) => {

let generics = generics(self.db.upcast(), adt.into());

fn substs_from_path_segment(

&self,

segment: PathSegment<'_>,

infer_args: bool,

explicit_self_ty: Option<Ty>,

) -> Substitution {

let mut substs = Vec::new();

} else {

return Substitution::empty(Interner);

};

let (parent_params, self_params, type_params, const_params, impl_trait_params) =

def_generics.provenance_split();

let mut def_generic_iter = def_generics.iter_id();

let fill_self_params = || {

for x in explicit_self_ty

.into_iter()

.chain(iter::repeat(ty_error.clone()))

.take(self_params)

{

fill_self_params();

}

// handle defaults. In expression or pattern path segments without

// explicitly specified type arguments, missing type arguments are inferred

// (i.e. defaults aren't used).

if !infer_args || had_explicit_args {

}

}

Substitution::from_iter(Interner, substs)

}

fn lower_dyn_trait(&self, bounds: &[Interned<TypeBound>]) -> Ty {

let self_ty = TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(Interner);

let bounds = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {

let mut bounds: Vec<_> = bounds

.iter()

return None;

}

// As multiple occurrences of the same auto traits *are* permitted, we dedulicate the

// bounds. We shouldn't have repeated elements besides auto traits at this point.

bounds.dedup();

let bounds = crate::make_single_type_binders(bounds);

TyKind::Dyn(DynTy { bounds, lifetime: static_lifetime() }).intern(Interner)

} else {

TyKind::Error.intern(Interner)

}

}

};

match res {

// we're _in_ the impl -- the binders get added back later. Correct,

// but it would be nice to make this more explicit

TypeNs::GenericParam(param_id) => {

let predicates = db.generic_predicates_for_param(def, param_id.into(), assoc_name);

let res = predicates.iter().find_map(|pred| match pred.skip_binders().skip_binders() {

}

// Handle `Self::Type` referring to own associated type in trait definitions

if let GenericDefId::TraitId(trait_id) = param_id.parent() {

let trait_ref = TyBuilder::trait_ref(db, trait_id)

.build();

return search(trait_ref);

}

let ctx =

TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable);

let generic_params = generics(db.upcast(), def);

let defaults = generic_params

.iter()

let val = unknown_const_as_generic(

db.const_param_ty(ConstParamId::from_unchecked(id)),

);

}

};

let mut ty =

p.default.as_ref().map_or(TyKind::Error.intern(Interner), |t| ctx.lower_ty(t));

// Each default can only refer to previous parameters.

})

.collect();

// we still need one default per parameter

let defaults = generic_params

.iter_id()

let val = match id {

itertools::Either::Left(_) => {

GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner)

}

itertools::Either::Right(id) => unknown_const_as_generic(db.const_param_ty(id)),

};

})

.collect();

}

impl_from!(FunctionId, StructId, UnionId, EnumVariantId, ConstId, StaticId for ValueTyDefId);

/// Build the declared type of an item. This depends on the namespace; e.g. for

/// `struct Foo(usize)`, we have two types: The type of the struct itself, and

/// the constructor function `(usize) -> Foo` which lives in the values

}

}

fn fallback_bound_vars<T: TypeFoldable<Interner> + HasInterner<Interner = Interner>>(

s: T,

) -> T {

crate::fold_free_vars(

s,

|bound, binders| {

bound.shifted_in_from(binders).to_ty(Interner)

}

},

|ty, bound, binders| {

bound.shifted_in_from(binders).to_const(Interner, ty)

}

},

)

}

}

pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId {

chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id))

}

let r = table.run_in_snapshot(|table| {

let impl_data = db.impl_data(impl_);

let substs =

let impl_ty = db.impl_self_ty(impl_).substitute(Interner, &substs);

table

}));

if let ItemContainerId::ImplId(impl_id) = c.lookup(db.upcast()).container {

let self_ty_matches = table.run_in_snapshot(|table| {

table.unify(&expected_self_ty, &self_ty)

});

if !self_ty_matches {

table.run_in_snapshot(|table| {

let container = fn_id.lookup(db.upcast()).container;

ItemContainerId::ImplId(it) => {

}

ItemContainerId::TraitId(it) => {

}

_ => unreachable!(),

};

.fill_with_inference_vars(table)

.build();

check_that!(table.unify(&expect_self_ty, self_ty));

if let Some(receiver_ty) = receiver_ty {

use expect_test::Expect;

use hir_def::{

body::{Body, BodySourceMap, SyntheticSyntax},

expr::{ExprId, PatId},

item_scope::ItemScope,

nameres::DefMap,

let loc = it.lookup(&db);

loc.source(&db).value.syntax().text_range().start()

}

});

let mut unexpected_type_mismatches = String::new();

for def in defs {

let loc = it.lookup(&db);

loc.source(&db).value.syntax().text_range().start()

}

});

for def in defs {

let (_body, source_map) = db.body_with_source_map(def);

let body = db.body(def);

visit_body(db, &body, cb);

}

ModuleDefId::TraitId(it) => {

let trait_data = db.trait_data(it);

for &(_, item) in trait_data.items.iter() {

}

#[test]

fn assign_coerce() {

check_no_mismatches(

r"

#[test]

fn gat_crash_1() {

check_no_mismatches(

r#"

trait ATrait {}

#[test]

fn gat_crash_3() {

trait Collection {

}

struct ConstGen<T, const N: usize> {

}

impl<T, const N: usize> Collection for ConstGen<T, N> {

}

}

#[test]

"#,

);

}

fn infer_const() {

check_infer(

r#"

expect![[r#"

48..49 '0': u32

79..82 '101': u32

fn infer_static() {

check_infer(

r#"

expect![[r#"

28..31 '101': u32

69..72 '101': u32

}

#[test]

fn shadowing_primitive() {

check_types(

r#"

}

#[test]

fn fn_pointer_return() {

check_infer(

r#"

pub mod iter {

pub trait IntoIterator {

type Item;

}

}

pub mod prelude {

}

impl<T> IntoIterator for Vec<T> {

}

}

"#,

use std::iter;

use base_db::CrateId;

use hir_def::{

db::DefDatabase,

generics::{

use syntax::SmolStr;

use crate::{

};

pub(crate) fn fn_traits(db: &dyn DefDatabase, krate: CrateId) -> impl Iterator<Item = TraitId> {

pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {

let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def)));

Generics { def, params: db.generic_params(def), parent_generics }

}

})

}

pub(crate) fn iter<'a>(

&'a self,

) -> impl DoubleEndedIterator<Item = (TypeOrConstParamId, &'a TypeOrConstParamData)> + 'a {

let to_toc_id = |it: &'a Generics| {

move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p)

};

}

/// Iterator over types and const params of parent.

pub(crate) fn iter_parent<'a>(

&'a self,

self.parent_generics().into_iter().flat_map(|it| {

let to_toc_id =

move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p);

})

}

pub(crate) fn len(&self) -> usize {

let parent = self.parent_generics().map_or(0, Generics::len);

let child = self.params.type_or_consts.len();

parent + child

}

/// (parent total, self param, type param list, const param list, impl trait)

pub(crate) fn provenance_split(&self) -> (usize, usize, usize, usize, usize) {

let ty_iter = || self.params.iter().filter_map(|x| x.1.type_param());

if param.parent == self.def {

let (idx, (_local_id, data)) =

self.params.iter().enumerate().find(|(_, (idx, _))| *idx == param.local_id)?;

} else {

}

}

}

/// Returns a Substitution that replaces each parameter by a bound variable.

Substitution::from_iter(

Interner,

self.iter_id().enumerate().map(|(idx, id)| match id {

}),

)

}

Substitution::from_iter(

Interner,

self.iter_id().map(|id| match id {

}),

)

}

//! Re-export diagnostics such that clients of `hir` don't have to depend on

//! low-level crates.

//!

//! be expressed in terms of hir types themselves.

use base_db::CrateId;

use cfg::{CfgExpr, CfgOptions};

write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;

let data = f.db.type_alias_data(self.id);

write!(f, "type {}", data.name)?;

if !data.bounds.is_empty() {

f.write_str(": ")?;

f.write_joined(&data.bounds, " + ")?;

DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id),

DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),

DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),

}

}

}

DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),

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

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

}

}

}

GenericDef::Trait(it) => GenericDefId::TraitId(it.id),

GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),

GenericDef::Impl(it) => GenericDefId::ImplId(it.id),

GenericDef::Const(it) => GenericDefId::ConstId(it.id),

}

}

GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),

GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),

GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),

GenericDefId::ConstId(it) => GenericDef::Const(it.into()),

}

}

use base_db::{CrateDisplayName, CrateId, CrateOrigin, Edition, FileId, ProcMacroKind};

use either::Either;

use hir_def::{

body::{BodyDiagnostic, SyntheticSyntax},

expr::{BindingAnnotation, LabelId, Pat, PatId},

generics::{TypeOrConstParamData, TypeParamProvenance},

resolver::{HasResolver, Resolver},

src::HasSource as _,

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

LocalEnumVariantId, LocalFieldId, Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId,

TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

};

diagnostics::BodyValidationDiagnostic,

method_resolution::{self, TyFingerprint},

primitive::UintTy,

traits::FnTrait,

AliasTy, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast, ClosureId,

GenericArgData, Interner, ParamKind, QuantifiedWhereClause, Scalar, Substitution,

use rustc_hash::FxHashSet;

use stdx::{impl_from, never};

use syntax::{

AstNode, AstPtr, SmolStr, SyntaxNodePtr, TextRange, T,

};

ModuleDef::Module(it) => it.id.into(),

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

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

};

let module = match self.module(db) {

ModuleDef::Function(it) => Some(it.into()),

ModuleDef::Const(it) => Some(it.into()),

ModuleDef::Static(it) => Some(it.into()),

ModuleDef::Module(_)

| ModuleDef::Adt(_)

| ModuleDef::Trait(_)

| ModuleDef::TypeAlias(_)

| ModuleDef::Macro(_)

}

acc.extend(decl.diagnostics(db))

}

_ => acc.extend(decl.diagnostics(db)),

}

}

Type::from_def(db, self.id)

}

db.struct_data(self.id).repr.clone()

}

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

Type::from_def(db, self.id)

}

}

impl HasVisibility for Enum {

}

}

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

pub struct Variant {

pub(crate) parent: Enum,

pub(crate) fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {

db.enum_data(self.parent.id).variants[self.id].variant_data.clone()

}

}

/// Variants inherit visibility from the parent enum.

pub fn ty_with_args(self, db: &dyn HirDatabase, args: &[Type]) -> Type {

let id = AdtId::from(self);

let mut it = args.iter().map(|t| t.ty.clone());

.fill(|x| {

let r = it.next().unwrap_or_else(|| TyKind::Error.intern(Interner));

match x {

Function(Function),

Static(Static),

Const(Const),

}

impl DefWithBody {

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

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

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

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

}

}

DefWithBody::Function(f) => Some(f.name(db)),

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

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

}

}

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

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

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

}

}

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

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

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

}

}

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

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

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

};

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

acc.push(diag.into())

let resolver = self.id.parent().resolver(db.upcast());

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

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

match ty.data(Interner) {

GenericArgData::Ty(x) => Some(Type::new_with_resolver_inner(db, &resolver, x.clone())),

_ => None,

}

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

Type::new(db, def, ty)

}

alias: TypeAlias,

) -> Option<Type> {

let mut args = args.iter();

.push(self.ty.clone())

.fill(|x| {

// FIXME: this code is not covered in tests.

}

})

.build();

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

if ty.is_unknown() {

let adt = adt_id.into();

match adt {

_ => false,

}

}

pub fn original_ast_node<N: AstNode>(&self, node: N) -> Option<N> {

self.imp.original_ast_node(node)

}

pub fn diagnostics_display_range(&self, diagnostics: InFile<SyntaxNodePtr>) -> FileRange {

self.imp.diagnostics_display_range(diagnostics)

)

}

fn diagnostics_display_range(&self, src: InFile<SyntaxNodePtr>) -> FileRange {

let root = self.parse_or_expand(src.file_id).unwrap();

let node = src.map(|it| it.to_node(&root));

}

impl SourceToDefCtx<'_, '_> {

let _p = profile::span("SourceBinder::to_module_def");

let mut mods = SmallVec::new();

for &crate_id in self.db.relevant_crates(file).iter() {

mods

}

let _p = profile::span("module_to_def");

let parent_declaration = src

.syntax()

Some(def_map.module_id(child_id))

}

let _p = profile::span("source_file_to_def");

let file_id = src.file_id.original_file(self.db.upcast());

self.file_to_def(file_id).get(0).copied()

} else {

let it = ast::Variant::cast(container.value)?;

let def = self.enum_variant_to_def(InFile::new(container.file_id, it))?;

};

Some(cont)

}

resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},

type_ref::Mutability,

AsMacroCall, AssocItemId, DefWithBodyId, FieldId, FunctionId, ItemContainerId, LocalFieldId,

};

use hir_expand::{

builtin_fn_macro::BuiltinFnLikeExpander,

}

}

let poll_fn = db

.lang_item(self.resolver.krate(), hir_expand::name![poll].to_smol_str())?

.as_function()?;

Some(self.resolve_impl_method_or_trait_def(db, poll_fn, &substs))

}

};

let ty = self.ty_of_expr(db, &prefix_expr.expr()?.into())?;

Some(self.resolve_impl_method_or_trait_def(db, op_fn, &substs))

}

let lang_item_name = name![index];

.push(base_ty.clone())

.push(index_ty.clone())

.build();

let lhs = self.ty_of_expr(db, &binop_expr.lhs()?.into())?;

let rhs = self.ty_of_expr(db, &binop_expr.rhs()?.into())?;

.and_then(|(name, lang_item)| self.lang_trait_fn(db, &lang_item, &name))?;

Some(self.resolve_impl_method_or_trait_def(db, op_fn, &substs))

}

let op_fn =

db.lang_item(self.resolver.krate(), name![branch].to_smol_str())?.as_function()?;

Some(self.resolve_impl_method_or_trait_def(db, op_fn, &substs))

}

db: &dyn HirDatabase,

lang_trait: &Name,

method_name: &Name,

}

fn ty_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<&Ty> {

DefWithBodyId::ConstId(id) => Some(

id.lookup(self.db.upcast()).source(self.db.upcast()).value.name()?.text().into(),

),

}

}

},

};

use itertools::Itertools;

use syntax::{ast, AstNode, AstToken, NodeOrToken, SyntaxKind::COMMA, TextRange};

// Assist: move_format_string_arg

// Extract existing arguments in macro

let tokens =

let mut existing_args: Vec<String> = vec![];

let mut current_arg = String::new();

tokens.as_slice()

{

for t in tokens {

}

}

existing_args.push(current_arg.trim().into());

),

);

}

}

mod replace_turbofish_with_explicit_type;

mod split_import;

mod unmerge_match_arm;

mod sort_items;

mod toggle_ignore;

mod unmerge_use;

unnecessary_async::unnecessary_async,

unwrap_block::unwrap_block,

unwrap_result_return_type::unwrap_result_return_type,

wrap_return_type_in_result::wrap_return_type_in_result,

// These are manually sorted for better priorities. By default,

// priority is determined by the size of the target range (smaller

});

let actual = {

let mut actual = before;

if let Some(source_file_edit) = source_change.get_source_edit(file_id) {

source_file_edit.apply(&mut actual);

match (assist, expected) {

(Some(assist), ExpectedResult::After(after)) => {

let skip_header = source_change.source_file_edits.len() == 1

&& source_change.file_system_edits.len() == 0;

}

#[test]

fn doctest_wrap_return_type_in_result() {

check_doc_test(

"wrap_return_type_in_result",

};

use syntax::{

ast::{self, edit_in_place::AttrsOwnerEdit},

};

use text_edit::TextEdit;

name: &Option<ast::Name>,

kind: ImplCompletionKind,

) -> Option<()> {

let item = match name {

Some(name) => name.syntax().parent(),

}?;

Some(())

}

syntax.trim_end().to_owned()

}

#[cfg(test)]

mod tests {

use expect_test::{expect, Expect};

DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),

DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),

DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),

};

return match def {

Some(def) => SearchScope::file_range(def.as_ref().original_file_range(db)),

"#,

);

}

}

use syntax::{ast::HasName, AstNode, TextRange};

use crate::{

goto_implementation::goto_implementation,

references::find_all_refs,

runnables::{runnables, Runnable},

NavigationTarget, RunnableKind,

};

// Feature: Annotations

//

// Provides user with annotations above items for looking up references or impl blocks

#[derive(Debug)]

pub enum AnnotationKind {

Runnable(Runnable),

}

pub struct AnnotationConfig {

}

}

visit_file_defs(&Semantics::new(db), file_id, &mut |def| {

let range = match def {

Definition::Const(konst) if config.annotate_references => {

}

Definition::Trait(trait_) if config.annotate_references || config.annotate_impls => {

}

Definition::Adt(adt) => match adt {

hir::Adt::Enum(enum_) => {

.variants(db)

.into_iter()

.map(|variant| {

})

.flatten()

.for_each(|range| {

annotations.push(Annotation {

})

})

}

if config.annotate_references || config.annotate_impls {

} else {

None

}

}

_ => {

if config.annotate_references || config.annotate_impls {

} else {

None

}

Some(range) => range,

None => return,

};

if config.annotate_impls && !matches!(def, Definition::Const(_)) {

}

if config.annotate_references {

annotations.push(Annotation {

});

}

fn name_range<T: HasName>(

db: &RootDatabase,

node: InFile<T>,

source_file_id: FileId,

if let Some(InFile { file_id, value }) = node.original_ast_node(db) {

if file_id == source_file_id.into() {

}

}

None

});

if config.annotate_method_references {

}

annotations

pub(crate) fn resolve_annotation(db: &RootDatabase, mut annotation: Annotation) -> Annotation {

match annotation.kind {

}

result

.into_iter()

.flat_map(|res| res.references)

Annotation {

range: 6..10,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 30..36,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 53..57,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 7..11,

kind: HasImpls {

data: Some(

[],

),

Annotation {

range: 7..11,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 17..21,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 7..11,

kind: HasImpls {

data: Some(

[

NavigationTarget {

Annotation {

range: 7..11,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 20..31,

kind: HasImpls {

data: Some(

[

NavigationTarget {

Annotation {

range: 20..31,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 69..73,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 3..7,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 7..11,

kind: HasImpls {

data: Some(

[

NavigationTarget {

Annotation {

range: 7..11,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 33..44,

kind: HasReferences {

data: Some(

[

FileRange {

Annotation {

range: 61..65,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 3..7,

kind: HasReferences {

data: Some(

[],

),

Annotation {

range: 0..71,

kind: HasImpls {

data: Some(

[],

),

Annotation {

range: 0..71,

kind: HasReferences {

),

},

},

]

use hir::Semantics;

use ide_assists::utils::test_related_attribute;

use ide_db::RootDatabase;

let sema = Semantics::new(db);

let source_file = sema.parse(file_id);

}

ast::Fn::cast(item).and_then(|fn_def| {

if test_related_attribute(&fn_def).is_some() {

None

} else {

}

})

}

#[cfg(test)]

mod tests {

use crate::fixture;

use std::ops::RangeInclusive;

#[test]

"#,

);

check_result(&refs, &[3..=13, 27..=33, 47..=57]);

}

"#,

);

check_result(&refs, &[19..=22, 35..=38]);

}

"#,

);

check_result(&refs, &[28..=34]);

}

assert_eq!(refs.len(), expected.len());

let range = &expected[i];

}

}

}

(match_ast! {

match doc_token {

ast::Comment(comment) => TextSize::try_from(comment.prefix().len()).ok(),

_ => None,

}

}).map(|prefix_len| DocCommentToken { prefix_len, doc_token: doc_token.clone() })

if !matches!(&*name.text(), "include" | "include_str" | "include_bytes") {

return None;

}

let file_id = sema.db.resolve_path(AnchoredPath { anchor: file_id, path: &path })?;

let size = sema.db.file_text(file_id).len().try_into().ok()?;

Some(NavigationTarget {

fn check(ra_fixture: &str) {

let (analysis, position, expected) = fixture::annotations(ra_fixture);

let navs = analysis.goto_definition(position).unwrap().expect("no definition found").info;

let cmp = |&FileRange { file_id, range }: &_| (file_id, range.start());

let navs = navs

check(

r#"

//- /main.rs

fn main() {

let str = include_str!("foo.txt$0");

}

"#,

);

}

#[cfg(test)]

mod goto_impl_of_trait_fn {

use super::check;

"#,

);

}

}

Definition::Module(it) => label_and_docs(db, it),

Definition::Function(it) => label_and_docs(db, it),

Definition::Adt(it) => label_and_docs(db, it),

Definition::Const(it) => label_value_and_docs(db, it, |it| {

let body = it.eval(db);

match body {

check(

r#"

enum Option<T> {

/// The None variant

Non$0e

}

}

#[test]

fn hover_const_eval() {

// show hex for <10

check(

This is a doc

"#]],

);

}

#[test]

// * elided lifetimes

// * compiler inserted reborrows

//

// image::https://user-images.githubusercontent.com/48062697/113020660-b5f98b80-917a-11eb-8d70-3be3fd558cdd.png[]

pub(crate) fn inlay_hints(

db: &RootDatabase,

}

impl<T> IntoIterator for Vec<T> {

}

fn main() {

mod expand_macro;

mod extend_selection;

mod file_structure;

mod folding_ranges;

mod goto_declaration;

mod goto_definition;

Env::default(),

Ok(Vec::new()),

false,

);

change.change_file(file_id, Some(Arc::new(text)));

change.set_crate_graph(crate_graph);

self.with_db(|db| references::find_all_refs(&Semantics::new(db), position, search_scope))

}

/// Returns a short text describing element at position.

pub fn hover(

&self,

},

kind: if krate == from_crate { MonikerKind::Export } else { MonikerKind::Import },

package_information: {

CrateOrigin::Lang(lang) => (

"https://github.com/rust-lang/rust/".to_string(),

match lang {

LangCrateOrigin::Other => {

let parent = token.parent();

let parent_kind = parent.as_ref().map_or(EOF, SyntaxNode::kind);

match (kind, parent_kind) {

(T![&], BIN_EXPR) => HlOperator::Bitwise.into(),

let h = HlTag::Operator(HlOperator::Other).into();

let is_unsafe = parent

.and_then(ast::RefExpr::cast)

h

}

}

(T![!], MACRO_CALL | MACRO_RULES) => HlPunct::MacroBang.into(),

(T![!], NEVER_TYPE) => HlTag::BuiltinType.into(),

(T![!], PREFIX_EXPR) => HlOperator::Logical.into(),

(T![+=] | T![-=] | T![*=] | T![/=] | T![%=], BIN_EXPR) => {

Highlight::from(HlOperator::Arithmetic) | HlMod::Mutable

}

(T![|=] | T![&=] | T![^=] | T![>>=] | T![<<=], BIN_EXPR) => {

Highlight::from(HlOperator::Bitwise) | HlMod::Mutable

}

(T![>] | T![<] | T![==] | T![>=] | T![<=] | T![!=], BIN_EXPR) => {

HlOperator::Comparison.into()

}

(_, ATTR) => HlTag::AttributeBracket.into(),

(kind, _) => match kind {

T!['['] | T![']'] => HlPunct::Bracket,

<span class="keyword">impl</span> <span class="struct">foo</span> <span class="brace">{</span>

<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration public static">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>

<span class="brace">}</span>

<span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="brace">{</span>

<span class="keyword">fn</span> <span class="function associated declaration static trait">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>

<span class="brace">}</span>

<span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="brace">{</span>

<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function associated declaration public static trait">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>

<span class="brace">}</span></code></pre> \ No newline at end of file

<span class="comment documentation">/// ```sh</span>

<span class="comment documentation">/// echo 1</span>

<span class="comment documentation">/// ```</span>

<span class="bool_literal">true</span>

<span class="brace">}</span>

<span class="brace">}</span>

<span class="brace">}</span>

<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="brace">{</span>

<span class="brace">}</span>

<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="brace">{</span>

<span class="self_keyword reference">self</span><span class="operator">.</span><span class="field">x</span>

<span class="brace">}</span>

<span class="brace">}</span>

<span class="value_param">f</span><span class="operator">.</span><span class="function associated consuming">baz</span><span class="parenthesis">(</span><span class="self_keyword consuming mutable">self</span><span class="parenthesis">)</span>

<span class="brace">}</span>

<span class="self_keyword mutable reference">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>

<span class="brace">}</span>

<span class="self_keyword reference">self</span><span class="operator">.</span><span class="field">x</span>

<span class="brace">}</span>

<span class="brace">}</span>

<span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="parenthesis">)</span>

<span class="brace">}</span>

<span class="self_keyword mutable reference">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>

<span class="brace">}</span>

<span class="self_keyword reference">self</span><span class="operator">.</span><span class="field">x</span>

<span class="brace">}</span>

<span class="brace">}</span>

.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }

</style>

<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>

<span class="function">fixture</span><span class="parenthesis">(</span><span class="string_literal">r#"</span>

<pre><code>

<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="attribute attribute default_library library">derive</span><span class="parenthesis attribute">(</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>

<span class="keyword">struct</span> <span class="struct declaration">Foo</span><span class="angle">&lt;</span><span class="lifetime declaration">'a</span><span class="comma">,</span> <span class="lifetime declaration">'b</span><span class="comma">,</span> <span class="lifetime declaration">'c</span><span class="angle">&gt;</span> <span class="keyword">where</span> <span class="lifetime">'a</span><span class="colon">:</span> <span class="lifetime">'a</span><span class="comma">,</span> <span class="lifetime">'static</span><span class="colon">:</span> <span class="lifetime">'static</span> <span class="brace">{</span>

<span class="brace">}</span>

<span class="keyword">impl</span><span class="angle">&lt;</span><span class="lifetime declaration">'a</span><span class="angle">&gt;</span> <span class="struct">Foo</span><span class="angle">&lt;</span><span class="lifetime">'_</span><span class="comma">,</span> <span class="lifetime">'a</span><span class="comma">,</span> <span class="lifetime">'static</span><span class="angle">&gt;</span>

<span class="keyword">where</span>

<span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="parenthesis">(</span>

<span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>panicking<span class="colon">:</span><span class="colon">:</span>panic<span class="parenthesis">(</span><span class="string_literal">"explicit panic"</span><span class="parenthesis">)</span>

<span class="parenthesis">)</span><span class="comma">,</span>

<span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>panicking<span class="colon">:</span><span class="colon">:</span>panic<span class="parenthesis">(</span><span class="punctuation">$</span>msg<span class="parenthesis">)</span>

<span class="parenthesis">)</span><span class="comma">,</span>

<span class="comment">// Use `panic_str` instead of `panic_display::&lt;&str&gt;` for non_fmt_panic lint.</span>

<span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>panicking<span class="colon">:</span><span class="colon">:</span>panic_str<span class="parenthesis">(</span><span class="punctuation">$</span>msg<span class="parenthesis">)</span>

<span class="parenthesis">)</span><span class="comma">,</span>

<span class="comment">// Special-case the single-argument case for const_panic.</span>

<span class="parenthesis">)</span><span class="comma">,</span>

<span class="parenthesis">(</span><span class="punctuation">$</span>fmt<span class="colon">:</span>expr<span class="comma">,</span> <span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>arg<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">+</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="parenthesis">(</span>

<span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>panicking<span class="colon">:</span><span class="colon">:</span>panic_fmt<span class="parenthesis">(</span><span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>const_format_args<span class="punctuation">!</span><span class="parenthesis">(</span><span class="punctuation">$</span>fmt<span class="comma">,</span> <span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>arg<span class="parenthesis">)</span><span class="punctuation">+</span><span class="parenthesis">)</span><span class="parenthesis">)</span>

<span class="brace">}</span>

<span class="keyword">macro_rules</span><span class="macro_bang">!</span> <span class="macro declaration">unsafe_deref</span> <span class="brace">{</span>

<span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>

<span class="brace">}</span><span class="semicolon">;</span>

<span class="brace">}</span>

<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">MUT_GLOBAL</span><span class="colon">:</span> <span class="struct">Struct</span> <span class="operator">=</span> <span class="struct">Struct</span> <span class="brace">{</span> <span class="field">field</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span><span class="semicolon">;</span>

<span class="keyword">struct</span> <span class="struct declaration">Struct</span> <span class="brace">{</span> <span class="field declaration">field</span><span class="colon">:</span> <span class="builtin_type">i32</span> <span class="brace">}</span>

<span class="keyword">impl</span> <span class="struct">Struct</span> <span class="brace">{</span>

<span class="brace">}</span>

<span class="attribute_bracket attribute">#</span><span class="attribute_bracket attribute">[</span><span class="builtin_attr attribute library">repr</span><span class="parenthesis attribute">(</span><span class="none attribute">packed</span><span class="parenthesis attribute">)</span><span class="attribute_bracket attribute">]</span>

<span class="keyword">fn</span> <span class="function declaration">unsafe_trait_bound</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="colon">:</span> <span class="trait">UnsafeTrait</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="punctuation">_</span><span class="colon">:</span> <span class="type_param">T</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>

<span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="brace">{</span>

<span class="brace">}</span>

<span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="brace">{</span>

<span class="brace">}</span>

<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>

use super::PanicMessage;

pub(crate) struct Abi {

exported_macros: Vec<proc_macro::bridge::client::ProcMacro>,

}

include!(concat!(env!("OUT_DIR"), "/rustc_version.rs"));

// Used by `test/utils.rs`

use super::dylib::LoadProcMacroDylibError;

pub(crate) use abi_1_58::Abi as Abi_1_58;

}

}

}

mod dylib;

mod abis;

use std::{

collections::{hash_map::Entry, HashMap},

env,

}

}

#[cfg(test)]

#[macro_use]

mod utils;

use utils::*;

#[test]

fn test_derive_empty() {

assert_expand("DeriveEmpty", r#"struct S;"#, expect![[r#"SUBTREE $"#]]);

DeriveError [CustomDerive]"#]]

.assert_eq(&res);

}

//! utils used in proc-macro tests

use expect_test::Expect;

use std::str::FromStr;

fn parse_string(code: &str) -> Option<crate::abis::TestTokenStream> {

// This is a bit strange. We need to parse a string into a token stream into

}

fn assert_expand_impl(macro_name: &str, input: &str, attr: Option<&str>, expect: Expect) {

let expander = dylib::Expander::new(&path).unwrap();

let fixture = parse_string(input).unwrap();

let attr = attr.map(|attr| parse_string(attr).unwrap().into_subtree());

}

pub(crate) fn list() -> Vec<String> {

let mut srv = ProcMacroSrv::default();

let res = srv.list_macros(&dylib_path).unwrap();

res.into_iter().map(|(name, kind)| format!("{} [{:?}]", name, kind)).collect()

use semver::Version;

use serde::Deserialize;

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

pub struct WorkspaceBuildScripts {

let mut cmd = Command::new(toolchain::cargo());

cmd.envs(&config.extra_env);

cmd.args(&["check", "--quiet", "--workspace", "--message-format=json"]);

// --all-targets includes tests, benches and examples in addition to the

cmd.args(&["--target", target]);

}

}

}

}

}

}

/// List of features to activate.

/// rustc target

pub target: Option<String>,

/// rustc private crate source

pub rustc_source: Option<RustcSource>,

/// crates to disable `#[cfg(test)]` on

pub unset_test_crates: UnsetTestCrates,

pub wrap_rustc_in_build_scripts: bool,

pub run_build_script_command: Option<Vec<String>>,

pub extra_env: FxHashMap<String, String>,

}

pub targets: Vec<Target>,

/// Does this package come from the local filesystem (and is editable)?

pub is_local: bool,

pub is_member: bool,

/// List of packages this package depends on

pub dependencies: Vec<PackageDependency>,

}

}

#[derive(Deserialize, Default)]

struct PackageMetadata {

#[serde(rename = "rust-analyzer")]

rust_analyzer: Option<RustAnalyzerPackageMetaData>,

let target = config

.target

.clone()

let mut meta = MetadataCommand::new();

meta.cargo_path(toolchain::cargo());

meta.manifest_path(cargo_toml.to_path_buf());

}

}

}

meta.current_dir(current_dir.as_os_str());

// unclear whether cargo itself supports it.

progress("metadata".to_string());

let output = command.output()?;

if !output.status.success() {

return Err(cargo_metadata::Error::CargoMetadata {

.find(|line| line.starts_with('{'))

.ok_or(cargo_metadata::Error::NoJson)?;

cargo_metadata::MetadataCommand::parse(stdout)

}

pub fn new(mut meta: cargo_metadata::Metadata) -> CargoWorkspace {

}

let resolve = meta.resolve.expect("metadata executed with deps");

for mut node in resolve.nodes {

node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg));

.deps

.iter()

let dep = PackageDependency { name: dep_node.name.clone(), pkg, kind };

packages[source].dependencies.push(dep);

}

found = true

}

self[pkg].dependencies.iter().find_map(|dep| {

})

})

.collect::<Vec<ManifestPath>>();

}

}

let mut rustc = Command::new(toolchain::rustc());

rustc.current_dir(cargo_toml.parent()).arg("-vV");

tracing::debug!("Discovering host platform by {:?}", rustc);

match utf8_stdout(rustc) {

}

}

let mut cargo_config = Command::new(toolchain::cargo());

cargo_config

.current_dir(cargo_toml.parent())

.args(&["-Z", "unstable-options", "config", "get", "build.target"])

pub use crate::{

build_scripts::WorkspaceBuildScripts,

cargo_workspace::{

},

manifest_path::ManifestPath,

project_json::{ProjectJson, ProjectJsonData},

.collect::<Vec<_>>(),

}

}

/// Returns the number of crates in the project.

pub fn n_crates(&self) -> usize {

self.crates.len()

}

/// Returns an iterator over the crates in the project.

pub fn crates(&self) -> impl Iterator<Item = (CrateId, &Crate)> + '_ {

self.crates.iter().enumerate().map(|(idx, krate)| (CrateId(idx as u32), krate))

}

/// Returns the path to the project's root folder.

pub fn path(&self) -> &AbsPath {

&self.project_root

use std::process::Command;

use anyhow::Result;

pub(crate) fn get(

cargo_toml: Option<&ManifestPath>,

target: Option<&str>,

) -> Vec<CfgFlag> {

let _p = profile::span("rustc_cfg::get");

let mut res = Vec::with_capacity(6 * 2 + 1);

}

}

Ok(rustc_cfgs) => {

tracing::debug!(

"rustc cfgs found: {:?}",

fn get_rust_cfgs(

cargo_toml: Option<&ManifestPath>,

target: Option<&str>,

) -> Result<String> {

if let Some(cargo_toml) = cargo_toml {

let mut cargo_config = Command::new(toolchain::cargo());

cargo_config

.current_dir(cargo_toml.parent())

.args(&["-Z", "unstable-options", "rustc", "--print", "cfg"])

}

// using unstable cargo features failed, fall back to using plain rustc

let mut cmd = Command::new(toolchain::rustc());

cmd.args(&["--print", "cfg", "-O"]);

if let Some(target) = target {

cmd.args(&["--target", target]);

use anyhow::{format_err, Result};

use la_arena::{Arena, Idx};

use paths::{AbsPath, AbsPathBuf};

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

pub struct Sysroot {

pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a {

self.crates.iter().map(|(id, _data)| id)

}

tracing::debug!("Discovering sysroot for {}", dir.display());

let res = Sysroot::load(sysroot_dir, sysroot_src_dir)?;

Ok(res)

}