Error on assignment to function parameter

[Shaikh-Ubaid]

towards #1784.

[Shaikh-Ubaid]

It seems that the runtime library assigns to function parameters at several places. In this PR, I updated three such places. With respect to #1784 (comment), I would like to know if we should update all places in the runtime library to not allow assignment to function parameters or if we should keep allowing assignment to function parameters.

[certik]

We should not allow assigning to function parameters, unless the parameter is marked Out or InOut, but that's only allowed for arrays. Integers in Python can only be In, and we should not allow assigning to them.

[Shaikh-Ubaid]

Sure, got it.

[certik]

Awesome, thanks for this!

[czgdp1807]

Well there is one case like,

def f(x: ClassA) -> i32:
    x.Member1 = 2
    return x.Member1 * x.Member1

Should the above error or work?

[Shaikh-Ubaid]

I think/guess it should work. I think it is one of the ways to pass variables/values by reference in python. Objects are passed by reference in python. In the above example, we pass the object x and inside the function, a data member of x is updated. After the call to the function f, the changes to data members of x would be visible to the caller function.

For example, consider the following:

$ cat examples/expr2.py   
from lpython import i32, dataclass

@dataclass
class N:
    val: i32

def f1(n: i32):
    n = 2
    return

def f2(n: N):
    n.val = 2
    return

def main0():
    a: i32
    b: N = N(0)
    a = 4
    b.val = 4

    f1(a)
    f2(b)

    print(a)
    print(b.val)

main0()
$ python examples/expr2.py 
4
2
$ lpython examples/expr2.py
2
2

[certik]

def f(x: ClassA) -> i32:
    x.Member1 = 2
    return x.Member1 * x.Member1

We have to decide what the default passing is, whether: In, InOut, Out. I would start with In, so the above is not allowed. To allow it, do:

def f(x: InOut[ClassA]) -> i32:
    x.Member1 = 2
    return x.Member1 * x.Member1

Then it is allowed.

[certik]

See #1807.

[Shaikh-Ubaid]

In the following example:

def f(x: In[ClassA]) -> i32:
    x.Member1 = 2 # Assignment to Member1 which is a local variable of `x`
    x = ClassA(Member1=5, ...) # Assignment to x which is an intent In variable
    return x.Member1 * x.Member1

Do we print errors for both the above assignments or just for the second assignment (whose target variable has intent as In)?

[Shaikh-Ubaid]

If in case we print error for the first assignment x.Member1 = 2 # Assignment to Member1 which is a local variable of x, do we need to print error in CPython as well? (I think/guess by default cpython allows assignment to class member variables).

[certik]

Do we print errors for both the above assignments or just for the second assignment (whose target variable has intent as In)?

I would print error for both. "In" means that "both the pointer and what it points to is constant". If you want to assign to any of it, you have to mark it "InOut".

Regarding CPython, I would not worry about it. The contract is: if LPython compiles it, it will run in CPython also. So if LPython enforces no modification, then CPython doesn't need to enforce it. In CPython we simply ignore type annotations.

[Shaikh-Ubaid]

For integration_tests/generics_02.py test case,

lpython/integration_tests/generics_02.py

Lines 5 to 13 in b9850da

	def swap(x: T, y: T):
	temp: T
	temp = x
	x = y
	y = temp
	print(x)
	print(y)
	swap(1,2)

Should it work or fail?

[certik]

This should fail, to allow it, do:

 def swap(x: InOut[T], y: InOut[T]): 
     temp: T 
     temp = x 
     x = y 
     y = temp 
     print(x) 
     print(y) 

Also note that Out and InOut in Python only really works for non-simple types, so not for ints or reals. See #1807.

[Shaikh-Ubaid]

Ready.

[Shaikh-Ubaid]

I temporarily commented this out.

[certik]

I made the PR a draft until we resolve it. First let's get everything else working, then we'll fix this.

[certik]

I think that this is good.

[Shaikh-Ubaid]

This PR prints errors on assignments to simple variables with intent In. I will handle other cases like assignments to struct local variables where the struct is passed with intent In in a new PR.