Preventing immutable parameters from becoming mutable.

[mratsim]

Currently, after CPS transformation immutable parameters become mutable and the compiler will not help detect that:

Example

proc foo(a: int) =
  let b = 1234 # <- immutable declaration
  if true:
    b += 10 # <-- incorrect, would be caught
    echo b+a
    return
  else:
    echo b + 1
    return

is rewritten and one of the proc becomes

proc ifBranch(c: var Continuation) =
  template a: untyped = c.a
  template b: untyped = c.b

  b += 10 # <-- suddenly correct
  echo b+a
  c.fn = nil

or

proc ifBranch(c: Continuation): Continuation =
  template a: untyped = c.a
  template b: untyped = c.b

  b += 10 # <-- suddenly correct
  echo b+a
  return nil

To keep the mutability semantics, we can introduce a wrapper proc that just does unpacking instead, and the inner keep the var/non-var

proc ifBranch(a, b: int) =
  # Notice immutable param
  b += 10 # <-- now the compiler won't compile.
  echo b+a

proc ifBranchUnpack(c: var Continuation) =
  ifBranch(c.a, c.b)
  c = nil

And for efficiency, one of them, at least, should be tagged inline.

[mratsim]

Note, in Arraymancer I use a trick with distinct type to enforce immutability even through pointers:

• https://github.com/mratsim/Arraymancer/blob/bdcdfe1/src/arraymancer/laser/tensor/datatypes.nim#L19-L20
• https://github.com/mratsim/Arraymancer/blob/bdcdfe1/src/arraymancer/laser/tensor/datatypes.nim#L200-L210

type
  RawImmutableView*[T] = distinct ptr UncheckedArray[T]
  RawMutableView*[T] = distinct ptr UncheckedArray[T]

template `[]`*[T](v: RawImmutableView[T], idx: int): T =
  bind distinctBase
  distinctBase(type v)(v)[idx]

template `[]`*[T](v: RawMutableView[T], idx: int): var T =
  bind distinctBase
  distinctBase(type v)(v)[idx]

template `[]=`*[T](v: RawMutableView[T], idx: int, val: T) =
  bind distinctBase
  distinctBase(type v)(v)[idx] = val

Though this is likely not applicable here because you need to know all the operations you need to generate the overload for, but maybe a converter .... or no, forget it.

[disruptek]

We do track let versus var so we can invalidate assignments, both in proc signatures and declarations within the body. Anyway, I think you're not using the typed code because otherwise, the code below would never pass sem.

proc foo(a: int) =
  let b = 1234 # <- immutable declaration
  if true:
    b += 10 # <-- incorrect, would be caught
    echo b+a
    return
  else:
    echo b + 1
    return