Fix places where assignable_expr should be used.

[g-r-a-n-t]

What is wrong?

There are a few places in the analyzer where we use expressions::expr to analyze expressions, when we should be using expressions::assignable_expr.

The name assignable_expr is not very clear, so we should consider changing that too.

The purpose of assignable_expr is to make sure expressions are in the default location of their type. The yulgen phase is then able to assume the location of a given value. If we don't do this, then we will have all sorts of undefined behavior.

How can it be fixed

• Fix the following places and double check that we are using these functions correctly every where else.

  • fe/crates/analyzer/src/traversal/expressions.rs

    Line 77 in 52df65b

    let attr = expr(

  • fe/crates/analyzer/src/traversal/expressions.rs

    Line 89 in 52df65b

    let first_attr = expr(Rc::clone(&scope), context, &elts[0], None)?;

  • fe/crates/analyzer/src/traversal/expressions.rs

    Line 108 in 52df65b

    let attr = expr(Rc::clone(&scope), context, elt, Some(&first_attr.typ))?;

  • fe/crates/analyzer/src/traversal/functions.rs

    Line 415 in 52df65b

    let test_type = expressions::expr(Rc::clone(&scope), context, &test, None)?.typ;

  • fe/crates/analyzer/src/traversal/functions.rs

    Line 426 in 52df65b

    let msg_attributes = expressions::expr(scope, context, msg, None)?;

  • fe/crates/analyzer/src/traversal/functions.rs

    Line 449 in 52df65b

    let error_attributes = expressions::expr(Rc::clone(&scope), context, error_expr, None)?;

• Add tests for most or all features that use assignable_expr where we use values in both storage and memory.

[g-r-a-n-t]

It might make sense to move all of this location business into the yulgen pass.

[g-r-a-n-t]

contract Foo:
    my_array: u256[3]

    pub def bar() -> u256:
        self.my_array = [1,2,3]
        sum: u256 = 0
        for i in self.my_array:
            sum = sum + i

        return sum

^ example of a feature that does not work properly at the moment

The yulgen phase expects the iterabe value to be in memory, but since we're not analyzing the expression with assignable_expr, there is no move_location attributed to it, so the array stays in storage. This results in OOG error during the execution of bar, since it attempts to access the array in memory using the very large storage pointer.