}

}

pub fn pretty_print(&self, db: &dyn DefDatabase, owner: DefWithBodyId) -> String {

pretty::print_body_hir(db, self, owner)

}

}

#[test]

fn function_call() {

check_number(

r#"

/// call, with the signature `&'a T -> &'a U` or `&'a mut T -> &'a mut U`.

/// The target type is `U` in both cases, with the region and mutability

/// being those shared by both the receiver and the returned reference.

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

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

pub enum AutoBorrow {

pub type_of_binding: ArenaMap<BindingId, Ty>,

pub type_of_rpit: ArenaMap<RpitId, Ty>,

/// Type of the result of `.into_iter()` on the for. `ExprId` is the one of the whole for loop.

type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>,

/// Interned common types to return references to.

standard_types: InternedStandardTypes,

.iter()

.map(|(kind, _source)| match kind {

// We do not know what kind of deref we require at this point yet

AutoderefKind::Builtin => None,

})

.zip(targets)

use chalk_ir::Mutability;

use hir_def::{

body::Body,

path::Path,

};

use hir_expand::name::Name;

ty = new_ty.clone();

adjust.push(Adjustment {

kind: Adjust::Deref(match kind {

AutoderefKind::Builtin => None,

}),

target: new_ty,

},

lang_item::{LangItem, LangItemTarget},

layout::LayoutError,

resolver::{resolver_for_expr, ResolveValueResult, ValueNs},

DefWithBodyId, EnumVariantId, HasModule,

};

use la_arena::ArenaMap;

use crate::{

consteval::ConstEvalError, db::HirDatabase, display::HirDisplay, infer::TypeMismatch,

inhabitedness::is_ty_uninhabited_from, layout::layout_of_ty, mapping::ToChalk, static_lifetime,

};

use super::*;

#[derive(Debug, Clone, Copy)]

struct LoopBlocks {

begin: BasicBlockId,

/// Something that should never happen and is definitely a bug, but we don't want to panic if it happened

ImplementationError(&'static str),

LangItemNotFound(LangItem),

}

macro_rules! not_supported {

};

}

impl From<ConstEvalError> for MirLowerError {

fn from(value: ConstEvalError) -> Self {

match value {

}

}

type Result<T> = std::result::Result<T, MirLowerError>;

impl MirLowerCtx<'_> {

fn temp(&mut self, ty: Ty) -> Result<LocalId> {

if matches!(ty.kind(Interner), TyKind::Slice(_) | TyKind::Dyn(_)) {

}

Ok(self.result.locals.alloc(Local { ty }))

}

fn lower_expr_to_some_operand(

&mut self,

expr_id: ExprId,

current: BasicBlockId,

if !self.has_adjustments(expr_id) {

match &self.body.exprs[expr_id] {

Expr::Literal(l) => {

let ty = self.expr_ty(expr_id);

}

_ => (),

}

}

}

&mut self,

expr_id: ExprId,

}

}

fn lower_expr_to_place(

place: Place,

prev_block: BasicBlockId,

) -> Result<Option<BasicBlockId>> {

}

self.lower_expr_to_place_without_adjust(expr_id, place, prev_block)

}

match &self.body.exprs[expr_id] {

Expr::Missing => Err(MirLowerError::IncompleteExpr),

Expr::Path(p) => {

let resolver = resolver_for_expr(self.db.upcast(), self.owner, expr_id);

let pr = resolver

.resolve_path_in_value_ns(self.db.upcast(), p.mod_path())

match variant {

VariantId::EnumVariantId(e) => ValueNs::EnumVariantId(e),

VariantId::StructId(s) => ValueNs::StructId(s),

}

} else {

return Err(unresolved_name());

}

}

Expr::If { condition, then_branch, else_branch } => {

return Ok(None);

};

let start_of_then = self.new_basic_block();

Ok(self.merge_blocks(end_of_then, end_of_else))

}

Expr::Let { pat, expr } => {

return Ok(None);

};

let (then_target, else_target) = self.pattern_match(

self.lower_block_to_place(None, statements, current, *tail, place)

}

Expr::Block { id: _, statements, tail, label } => {

}

Expr::Loop { body, label } => self.lower_loop(current, *label, |this, begin| {

this.set_goto(block, begin);

}

Ok(())

}),

Expr::While { condition, body, label } => {

self.lower_loop(current, *label, |this, begin| {

return Ok(());

};

let end = this.current_loop_end()?;

targets: SwitchTargets::static_if(1, after_cond, end),

},

);

this.set_goto(block, begin);

}

Ok(())

self.db.intern_callable_def(CallableDefId::FunctionId(iter_next_fn)).into(),

Substitution::from1(Interner, self.expr_ty(iterable))

).intern(Interner));

let ref_mut_iterator_ty = TyKind::Ref(Mutability::Mut, static_lifetime(), iterator_ty.clone()).intern(Interner);

let item_ty = &self.infer.type_of_pat[pat];

let option_item_ty = TyKind::Adt(chalk_ir::AdtId(option.into()), Substitution::from1(Interner, item_ty.clone())).intern(Interner);

};

self.push_assignment(current, ref_mut_iterator_place.clone(), Rvalue::Ref(BorrowKind::Mut { allow_two_phase_borrow: false }, iterator_place), expr_id.into());

self.lower_loop(current, label, |this, begin| {

let Some(current) = this.lower_call(iter_next_fn_op, vec![Operand::Copy(ref_mut_iterator_place)], option_item_place.clone(), begin, false)?

else {

return Ok(());

pat.into(),

Some(end),

&[pat], &None)?;

this.set_goto(block, begin);

}

Ok(())

)

}

Expr::Match { expr, arms } => {

else {

return Ok(None);

};

if guard.is_some() {

not_supported!("pattern matching with guard");

}

let (then, otherwise) = self.pattern_match(

current,

None,

for RecordLitField { name, expr } in fields.iter() {

let field_id =

variant_data.field(name).ok_or(MirLowerError::UnresolvedField)?;

return Ok(None);

};

current = c;

}

}

}

Expr::Await { .. } => not_supported!("await"),

Expr::Try { .. } => not_supported!("? operator"),

Expr::Yeet { .. } => not_supported!("yeet"),

Expr::Async { .. } => not_supported!("async block"),

Expr::Const { .. } => not_supported!("anonymous const block"),

Expr::Cast { expr, type_ref: _ } => {

return Ok(None);

};

let source_ty = self.infer[*expr].clone();

Ok(Some(current))

}

Expr::Ref { expr, rawness: _, mutability } => {

return Ok(None);

};

let bk = BorrowKind::from_hir(*mutability);

Ok(Some(current))

}

Expr::Box { .. } => not_supported!("box expression"),

},

Expr::BinaryOp { lhs, rhs, op } => {

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

if op.is_some() {

not_supported!("assignment with arith op (like +=)");

}

};

return Ok(None);

};

self.push_assignment(current, lhs_place, rhs_op.into(), expr_id.into());

return Ok(Some(current));

}

return Ok(None);

};

return Ok(None);

};

self.push_assignment(

Ok(Some(current))

}

Expr::Range { .. } => not_supported!("range"),

Expr::Closure { .. } => not_supported!("closure"),

Expr::Tuple { exprs, is_assignee_expr: _ } => {

let Some(values) = exprs

.iter()

.map(|x| {

return Ok(None);

};

current = c;

let Some(values) = elements

.iter()

.map(|x| {

return Ok(None);

};

current = c;

) -> Result<Option<BasicBlockId>> {

let Some(args) = args

.map(|arg| {

current = c;

Ok(Some(temp))

} else {

if matches!(mode, BindingAnnotation::Ref | BindingAnnotation::RefMut) {

binding_mode = mode;

}

self.push_assignment(

current,

target_place.into(),

}

/// This function push `StorageLive` statements for each binding in the pattern.

// Current implementation is wrong. It adds no `StorageDead` at the end of scope, and before each break

// and continue. It just add a `StorageDead` before the `StorageLive`, which is not wrong, but unneeeded in

// the proper implementation. Due this limitation, implementing a borrow checker on top of this mir will falsely

// ```

// But I think this approach work for mutability analysis, as user can't write code which mutates a binding

// after StorageDead, except loops, which are handled by this hack.

Ok(())

}

let crate_id = self.owner.module(self.db.upcast()).krate();

self.db.lang_item(crate_id, item).ok_or(MirLowerError::LangItemNotFound(item))

}

}

fn pattern_matching_dereference(

pub fn mir_body_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Result<Arc<MirBody>> {

let body = db.body(def);

let infer = db.infer(def);

}

pub fn mir_body_recover(

// need to take this input explicitly.

root_expr: ExprId,

) -> Result<MirBody> {

return Err(MirLowerError::TypeMismatch(x.clone()));

}

let mut basic_blocks = Arena::new();

#[test]

fn coerce_autoderef_block() {

check_no_mismatches(

r#"

//- minicore: deref

fn returns_string() -> String { loop {} }

fn test() {

takes_ref_str(&{ returns_string() });

}

"#,

);

#[test]

fn autoderef_visibility_field() {

check(

r#"

//- minicore: deref

mod b {

fn foo() {

let x = super::a::Bar::new().0;

// ^^^^^^^^^^^^^^^^^^^^^^ type: char

}

}

use crate::{

db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam,

};

pub trait HasSource {

pub use crate::{

attrs::{HasAttrs, Namespace},

diagnostics::{

ReplaceFilterMapNextWithFindMap, TypeMismatch, UnimplementedBuiltinMacro,

},

has_source::HasSource,

semantics::{PathResolution, Semantics, SemanticsScope, TypeInfo, VisibleTraits},

let kind = match adjust.kind {

hir_ty::Adjust::NeverToAny => Adjust::NeverToAny,

hir_ty::Adjust::Deref(Some(hir_ty::OverloadedDeref(m))) => {

}

hir_ty::Adjust::Deref(None) => Adjust::Deref(None),

hir_ty::Adjust::Borrow(hir_ty::AutoBorrow::RawPtr(m)) => {

#[test]

fn overloaded_deref() {

check_diagnostics(

r#"

//- minicore: deref_mut

}

}

fn f() {

let mut x = Foo;

}

"#,

);