sway-core 0.37.3

Sway core language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use sway_error::handler::{ErrorEmitted, Handler};

use crate::{language::ty, monomorphize::priv_prelude::*, type_system::*};

pub(crate) fn gather_from_exp(
    ctx: GatherContext,
    handler: &Handler,
    exp: &ty::TyExpression,
) -> Result<(), ErrorEmitted> {
    gather_from_exp_inner(ctx, handler, &exp.expression, exp.return_type)
}

pub(crate) fn gather_from_exp_inner(
    mut ctx: GatherContext,
    handler: &Handler,
    exp: &ty::TyExpressionVariant,
    return_type: TypeId,
) -> Result<(), ErrorEmitted> {
    ctx.add_constraint(return_type.into());
    match exp {
        ty::TyExpressionVariant::FunctionApplication {
            arguments,
            contract_call_params,
            ..
        } => {
            arguments
                .iter()
                .try_for_each(|(_, arg)| gather_from_exp(ctx.by_ref(), handler, arg))?;
            contract_call_params
                .iter()
                .try_for_each(|(_, arg)| gather_from_exp(ctx.by_ref(), handler, arg))?;
            ctx.add_constraint(exp.into());
        }
        ty::TyExpressionVariant::LazyOperator { lhs, rhs, .. } => {
            gather_from_exp(ctx.by_ref(), handler, lhs)?;
            gather_from_exp(ctx.by_ref(), handler, rhs)?;
        }
        ty::TyExpressionVariant::ConstantExpression { .. } => {
            // NOTE: may need to do something here later
        }
        ty::TyExpressionVariant::VariableExpression { .. } => {
            // NOTE: may need to do something here later
        }
        ty::TyExpressionVariant::Tuple { fields } => {
            fields
                .iter()
                .try_for_each(|field| gather_from_exp(ctx.by_ref(), handler, field))?;
        }
        ty::TyExpressionVariant::Array {
            contents: _,
            elem_type: _,
        } => {
            todo!();
            // contents
            //     .iter()
            //     .try_for_each(|elem| gather_from_exp(ctx.by_ref(), handler, elem))?;
        }
        ty::TyExpressionVariant::ArrayIndex {
            prefix: _,
            index: _,
        } => {
            todo!();
            // gather_from_exp(ctx.by_ref(), handler, prefix)?;
            // gather_from_exp(ctx.by_ref(), handler, index)?;
        }
        ty::TyExpressionVariant::StructExpression { .. } => todo!(),
        ty::TyExpressionVariant::CodeBlock(block) => {
            gather_from_code_block(ctx, handler, block)?;
        }
        ty::TyExpressionVariant::IfExp { .. } => todo!(),
        ty::TyExpressionVariant::MatchExp { .. } => todo!(),
        ty::TyExpressionVariant::AsmExpression { .. } => todo!(),
        ty::TyExpressionVariant::StructFieldAccess { .. } => todo!(),
        ty::TyExpressionVariant::TupleElemAccess { prefix, .. } => {
            gather_from_exp(ctx, handler, prefix)?;
        }
        ty::TyExpressionVariant::EnumInstantiation { .. } => todo!(),
        ty::TyExpressionVariant::AbiCast { .. } => todo!(),
        ty::TyExpressionVariant::StorageAccess(_) => todo!(),
        ty::TyExpressionVariant::IntrinsicFunction(_) => todo!(),
        ty::TyExpressionVariant::AbiName(_) => todo!(),
        ty::TyExpressionVariant::EnumTag { exp } => {
            gather_from_exp(ctx.by_ref(), handler, exp)?;
        }
        ty::TyExpressionVariant::UnsafeDowncast { .. } => todo!(),
        ty::TyExpressionVariant::WhileLoop { .. } => todo!(),
        ty::TyExpressionVariant::Reassignment(_) => todo!(),
        ty::TyExpressionVariant::StorageReassignment(_) => todo!(),
        ty::TyExpressionVariant::Return(exp) => {
            gather_from_exp(ctx.by_ref(), handler, exp)?;
        }
        ty::TyExpressionVariant::Literal(_) => {}
        ty::TyExpressionVariant::Break => {}
        ty::TyExpressionVariant::Continue => {}
        ty::TyExpressionVariant::FunctionParameter => {}
    }

    Ok(())
}