+fn for_loops() {

+ check_number(

+ r#"

+ //- minicore: iterator

+

+ struct Range {

+ start: u8,

+ end: u8,

+ }

+

+ impl Iterator for Range {

+ type Item = u8;

+ fn next(&mut self) -> Option<u8> {

+ if self.start >= self.end {

+ None

+ } else {

+ let r = self.start;

+ self.start = self.start + 1;

+ Some(r)

+ }

+ }

+ }

+

+ const GOAL: u8 = {

+ let mut sum = 0;

+ let ar = Range { start: 1, end: 11 };

+ for i in ar {

+ sum = sum + i;

+ }

+ sum

+ };

+ "#,

+ 55,

+ );

+}

+

+#[test]

+fn path_pattern_matching() {

+ check_number(

+ r#"

+ enum Season {

+ Spring,

+ Summer,

+ Fall,

+ Winter,

+ }

+

+ use Season::*;

+

+ const fn f(x: Season) -> i32 {

+ match x {

+ Spring => 1,

+ Summer => 2,

+ Fall => 3,

+ Winter => 4,

+ }

+ }

+ const GOAL: i32 = f(Spring) + 10 * f(Summer) + 100 * f(Fall) + 1000 * f(Winter);

+ "#,

+ 4321,

+ );

+}

+

+#[test]

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

+ pub type_of_for_iterator: ArenaMap<ExprId, Ty>,

+ for ty in result.type_of_for_iterator.values_mut() {

+ *ty = table.resolve_completely(ty.clone());

+ }

+ let pat_ty = self

+ .resolve_associated_type(into_iter_ty.clone(), self.resolve_iterator_item());

+

+ self.result.type_of_for_iterator.insert(tgt_expr, into_iter_ty);

+

+ fn const_zst(ty: Ty) -> Operand {

+ Self::from_bytes(vec![], ty)

+ }

+ let candidate = lang_attr(self.db.upcast(), def)?;

+ // filter normal lang functions out

+ if [LangItem::IntoIterIntoIter, LangItem::IteratorNext].contains(&candidate) {

+ return None;

+ }

+ Some(candidate)

+ lang_item::{LangItem, LangItemTarget},

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

+ utils::generics, Adjust, AutoBorrow, CallableDefId, TyBuilder, TyExt,

+ LangItemNotFound(LangItem),

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

+ let into_iter_fn = self.resolve_lang_item(LangItem::IntoIterIntoIter)?

+ .as_function().ok_or(MirLowerError::LangItemNotFound(LangItem::IntoIterIntoIter))?;

+ let iter_next_fn = self.resolve_lang_item(LangItem::IteratorNext)?

+ .as_function().ok_or(MirLowerError::LangItemNotFound(LangItem::IteratorNext))?;

+ let option_some = self.resolve_lang_item(LangItem::OptionSome)?

+ .as_enum_variant().ok_or(MirLowerError::LangItemNotFound(LangItem::OptionSome))?;

+ let option = option_some.parent;

+ let into_iter_fn_op = Operand::const_zst(

+ TyKind::FnDef(

+ self.db.intern_callable_def(CallableDefId::FunctionId(into_iter_fn)).into(),

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

+ ).intern(Interner));

+ let iter_next_fn_op = Operand::const_zst(

+ TyKind::FnDef(

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

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

+ ).intern(Interner));

+ let iterator_ty = &self.infer.type_of_for_iterator[expr_id];

+ 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);

+ let iterator_place: Place = self.temp(iterator_ty.clone())?.into();

+ let option_item_place: Place = self.temp(option_item_ty.clone())?.into();

+ let ref_mut_iterator_place: Place = self.temp(ref_mut_iterator_ty)?.into();

+ let Some(current) = self.lower_call_and_args(into_iter_fn_op, Some(iterable).into_iter(), iterator_place.clone(), current, false)?

+ else {

+ return Ok(None);

+ };

+ 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| {

+ this.push_storage_live(pat, 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(());

+ };

+ let end = this.current_loop_end()?;

+ let (current, _) = this.pattern_matching_variant(

+ option_item_ty.clone(),

+ BindingAnnotation::Unannotated,

+ option_item_place.into(),

+ option_some.into(),

+ current,

+ pat.into(),

+ Some(end),

+ &[pat], &None)?;

+ if let (_, Some(block)) = this.lower_expr_to_some_place(body, current)? {

+ this.set_goto(block, begin);

+ }

+ Ok(())

+ })

+ },

+ self.lower_call_and_args(func, args.iter().copied(), place, current, self.is_uninhabited(expr_id))

+ self.lower_call_and_args(

+ fn lower_call_and_args(

+ self.lower_call(func, args, place, current, is_uninhabited)

+ }

+

+ fn lower_call(

+ &mut self,

+ func: Operand,

+ args: Vec<Operand>,

+ place: Place,

+ current: BasicBlockId,

+ is_uninhabited: bool,

+ ) -> Result<Option<BasicBlockId>> {

+ Pat::Path(_) => {

+ let Some(variant) = self.infer.variant_resolution_for_pat(pattern) else {

+ not_supported!("unresolved variant");

+ };

+ self.pattern_matching_variant(

+ cond_ty,

+ binding_mode,

+ cond_place,

+ variant,

+ current,

+ pattern.into(),

+ current_else,

+ &[],

+ &None,

+ )?

+ }

+ self.pattern_matching_variant(

+ cond_ty,

+ binding_mode,

+ cond_place,

+ variant,

+ current,

+ pattern.into(),

+ current_else,

+ args,

+ ellipsis,

+ )?

+ fn pattern_matching_variant(

+ &mut self,

+ mut cond_ty: Ty,

+ mut binding_mode: BindingAnnotation,

+ mut cond_place: Place,

+ variant: VariantId,

+ current: BasicBlockId,

+ span: MirSpan,

+ current_else: Option<BasicBlockId>,

+ args: &[PatId],

+ ellipsis: &Option<usize>,

+ ) -> Result<(BasicBlockId, Option<BasicBlockId>)> {

+ pattern_matching_dereference(&mut cond_ty, &mut binding_mode, &mut cond_place);

+ let subst = match cond_ty.kind(Interner) {

+ TyKind::Adt(_, s) => s,

+ _ => return Err(MirLowerError::TypeError("non adt type matched with tuple struct")),

+ };

+ let fields_type = self.db.field_types(variant);

+ Ok(match variant {

+ VariantId::EnumVariantId(v) => {

+ let e = self.db.const_eval_discriminant(v)? as u128;

+ let next = self.new_basic_block();

+ let tmp = self.discr_temp_place();

+ self.push_assignment(

+ current,

+ tmp.clone(),

+ Rvalue::Discriminant(cond_place.clone()),

+ span,

+ );

+ let else_target = current_else.unwrap_or_else(|| self.new_basic_block());

+ self.set_terminator(

+ current,

+ Terminator::SwitchInt {

+ discr: Operand::Copy(tmp),

+ targets: SwitchTargets::static_if(e, next, else_target),

+ },

+ );

+ let enum_data = self.db.enum_data(v.parent);

+ let fields =

+ enum_data.variants[v.local_id].variant_data.fields().iter().map(|(x, _)| {

+ (

+ PlaceElem::Field(FieldId { parent: v.into(), local_id: x }),

+ fields_type[x].clone().substitute(Interner, subst),

+ )

+ });

+ self.pattern_match_tuple_like(

+ next,

+ Some(else_target),

+ args.iter().zip(fields).map(|(x, y)| (y.0, *x, y.1)),

+ *ellipsis,

+ &cond_place,

+ binding_mode,

+ )?

+ }

+ VariantId::StructId(s) => {

+ let struct_data = self.db.struct_data(s);

+ let fields = struct_data.variant_data.fields().iter().map(|(x, _)| {

+ (

+ PlaceElem::Field(FieldId { parent: s.into(), local_id: x }),

+ fields_type[x].clone().substitute(Interner, subst),

+ )

+ });

+ self.pattern_match_tuple_like(

+ current,

+ current_else,

+ args.iter().zip(fields).map(|(x, y)| (y.0, *x, y.1)),

+ *ellipsis,

+ &cond_place,

+ binding_mode,

+ )?

+ }

+ VariantId::UnionId(_) => {

+ return Err(MirLowerError::TypeError("pattern matching on union"))

+ }

+ })

+ }

+

+

+ fn resolve_lang_item(&self, item: LangItem) -> Result<LangItemTarget> {

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

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

+ }

+

+ #[test]

+ fn for_loop() {

+ check_diagnostics(

+ r#"

+//- minicore: iterators

+fn f(x: [(i32, u8); 10]) {

+ for (a, mut b) in x {

+ //^^^^^ 💡 weak: remove this `mut`

+ a = 2;

+ //^^^^^ 💡 error: cannot mutate immutable variable `a`

+ }

+}

+"#,

+ );

+ }

+ pub struct IntoIter<T, const N: usize>([T; N]);

+ impl<T, const N: usize> IntoIterator for [T; N] {

+ type Item = T;

+ type IntoIter = IntoIter<T, N>;

+ fn into_iter(self) -> I {

+ IntoIter(self)

+ }

+ }

+ impl<T, const N: usize> Iterator for IntoIter<T, N> {

+ type Item = T;

+ fn next(&mut self) -> Option<T> {

+ loop {}

+ }

+ }