Files

arret

subcommand

repl

arret_helper.rscommand.rshistory.rsmod.rssyntax.rs

compile.rseval.rsmod.rs

main.rs

arret_compiler

codegen

alloc

core.rsmod.rsplan.rstypes.rs

analysis

escape.rsmod.rsnames.rs

box_layout.rscallee.rsconst_gen.rsdebug_info.rsfun_gen.rsjit.rslibcstr.rsmath_gen.rsmod.rsmod_gen.rsop_gen.rspanic_gen.rsprogram.rsrange_md.rsrecord_struct.rstarget_gen.rstarget_machine.rsvector_gen.rs

hir

import

filter.rsmod.rsparse.rs

macros

expander.rslinker.rsmatcher.rsmod.rs

destruc.rserror.rsexports.rsloader.rslowering.rsmod.rsns.rsprim.rsrecords.rsscope.rstypes.rsutil.rsvar_id.rsvisitor.rs

mir

intrinsic

bitwise.rslist.rsmath.rsmod.rsnum_utils.rsnumber.rspanics.rspartial_print.rsprint.rstesting.rsvector.rs

optimise

duplicate_alloc_ops.rsmod.rsunused_ops.rs

value

arret_fun.rsbuild_reg.rsfrom_reg.rslist.rsmod.rsplan_phi.rssynthetic_fun.rsto_const.rstypes.rs

app_purity.rsarg_list.rsbuilder.rscosting.rsenv_values.rsequality.rserror.rseval_hir.rsinliner.rsmod.rsops.rspolymorph.rsprinter.rsrecord_field.rsret_value.rsrust_fun.rsspecific_abi_type.rstagset.rstypred.rsvector_member.rs

rfi

mod.rs

ty

conv_abi.rsdatum.rsintersect.rsis_a.rslist_iter.rsmod.rspred.rsprops.rspurity.rsrecord.rsselect.rssubst.rssubtract.rsty_args.rsunify.rsvar_usage.rs

typeck

dce.rsdestruc.rserror.rsinfer.rsmod.rs

arret_root.rscontext.rsid_type.rslib.rspromise.rsrepl.rsreporting.rssource.rs

arret_lsp_server

handler

mod.rstext_synchronisation.rsworkspace.rs

model

document.rsmod.rsworkspace.rs

transport

bytestream.rsmod.rs

watcher

mod.rssyntax.rs

capabilities.rsjson_rpc.rsmain.rssession.rs

arret_rfi_derive

lib.rs

arret_runtime

boxed

heap

collect.rsmod.rstype_info.rs

types

char.rsfield_value.rsfloat.rsfun.rsint.rslist.rsmap.rsmod.rsrecord.rsrecord_data.rsset.rsshared_str.rsstr.rssym.rsvector.rs

mod.rsrefs.rs

persistent

mod.rsvector.rs

abitype.rsbinding.rscallback.rsclass_map.rscompiler_support.rsintern.rslib.rstask.rs

arret_runtime_syntax

lib.rsreader.rswriter.rs

arret_syntax

anon_fun.rsdatum.rserror.rslib.rsparser.rsspan.rs

stdlib

bitwise.rshash.rslib.rslist.rsmath.rsnumber.rsread.rsset.rstesting.rsvector.rswrite.rs

>

use crate::hir;
use crate::hir::destruc;
use crate::ty;
use crate::ty::list_iter::ListIterator;
use crate::ty::Ty;

pub fn type_for_decl_list_destruc(
    list: &destruc::List<hir::Lowered>,
    mut guide_type_iter: Option<ListIterator<'_, ty::Poly>>,
) -> ty::List<ty::Poly> {
    let fixed_polys = list
        .fixed()
        .iter()
        .map(|fixed_destruc| {
            let guide_type = if let Some(guide_type_iter) = guide_type_iter.as_mut() {
                guide_type_iter.next()
            } else {
                None
            };

            type_for_decl_destruc(fixed_destruc, guide_type)
        })
        .collect();

    let rest_poly = match list.rest() {
        Some(rest) => match rest.ty() {
            hir::DeclTy::Known(poly) => poly.clone(),
            hir::DeclTy::Free => guide_type_iter
                .map(ListIterator::collect_rest)
                .unwrap_or_else(|| Ty::Any.into()),
        },
        None => Ty::never().into(),
    };

    ty::List::new(fixed_polys, rest_poly)
}

/// Returns the required type for a destruc
pub fn type_for_decl_destruc(
    destruc: &destruc::Destruc<hir::Lowered>,
    guide_type: Option<&ty::Ref<ty::Poly>>,
) -> ty::Ref<ty::Poly> {
    match destruc {
        destruc::Destruc::Scalar(_, scalar) => match scalar.ty() {
            hir::DeclTy::Known(poly) => poly.clone(),
            hir::DeclTy::Free => guide_type.cloned().unwrap_or_else(|| Ty::Any.into()),
        },

        destruc::Destruc::List(_, list) => {
            let guide_type_iter =
                guide_type.and_then(|guide_type| ListIterator::try_new_from_ty_ref(guide_type));

            type_for_decl_list_destruc(list, guide_type_iter).into()
        }
    }
}

fn visit_scalar_locals<F>(scalar: &destruc::Scalar<hir::Lowered>, visitor: &mut F)
where
    F: FnMut(hir::LocalId, &hir::DeclTy),
{
    if let Some(local_id) = scalar.local_id() {
        visitor(*local_id, scalar.ty());
    }
}

/// Visits the local variables in the passed destruc with the given visitor function
///
/// If the root destruc is scalar its VarId will be returned, otherwise None
pub fn visit_locals<F>(
    destruc: &destruc::Destruc<hir::Lowered>,
    visitor: &mut F,
) -> Option<hir::LocalId>
where
    F: FnMut(hir::LocalId, &hir::DeclTy),
{
    match destruc {
        destruc::Destruc::Scalar(_, ref scalar) => {
            visit_scalar_locals(scalar, visitor);
            *scalar.local_id()
        }
        destruc::Destruc::List(_, ref list) => {
            for fixed in list.fixed() {
                visit_locals(fixed, visitor);
            }

            if let Some(rest) = list.rest() {
                visit_scalar_locals(rest, visitor);
            }

            None
        }
    }
}