Bad error message when writing to a data structure within read-only object

[genotrance]

import sets

type
  parent = object
    hash: HashSet[string]

proc getParent(): parent =
  result.hash.init()

let a = getParent()
a.hash.incl("Hello")

Here a is read-only so Nim should tell you that. Instead you see the following error which is hard to figure out.

ctest.nim(11, 7) Error: type mismatch: got <HashSet[system.string], string>
but expected one of:
proc incl[T](x: var set[T]; y: T)
  first type mismatch at position: 1
  required type: var set[T]
  but expression 'a.hash' is of type: HashSet[system.string]
template incl[T](s: var set[T]; flags: set[T])
  first type mismatch at position: 1
  required type: var set[T]
  but expression 'a.hash' is of type: HashSet[system.string]
proc incl[A](s: var HashSet[A]; key: A)
  first type mismatch at position: 1
  required type: var HashSet[incl.A]
  but expression 'a.hash' is of type: HashSet[system.string]
proc incl[A](s: var HashSet[A]; other: OrderedSet[A])
  first type mismatch at position: 1
  required type: var HashSet[incl.A]
  but expression 'a.hash' is of type: HashSet[system.string]
proc incl[A](s: var OrderedSet[A]; key: A)
  first type mismatch at position: 1
  required type: var OrderedSet[incl.A]
  but expression 'a.hash' is of type: HashSet[system.string]
proc incl[A](s: var HashSet[A]; other: HashSet[A])
  first type mismatch at position: 1
  required type: var HashSet[incl.A]
  but expression 'a.hash' is of type: HashSet[system.string]

expression: incl(a.hash, "Hello")

[genotrance]

You don't see this issue if hash is of type string, int, etc - Nim tells you a.hash cannot be assigned to.

If hash: Table[int, int], you see a similar error.

ctest.nim(13, 6) Error: type mismatch: got (Table[system.int, system.int], int literal(2), 
int literal(2)) but expected one of: 
proc `[]=`[Idx, T, U, V](a: var array[Idx, T]; x: HSlice[U, V]; b: openArray[T])
proc `[]=`[Idx, T](a: var array[Idx, T]; i: BackwardsIndex; x: T)
proc `[]=`[T, U](s: var string; x: HSlice[T, U]; b: string)
proc `[]=`[T, U, V](s: var seq[T]; x: HSlice[U, V]; b: openArray[T])
proc `[]=`[I: Ordinal; T, S](a: T; i: I; x: S)
proc `[]=`[T](s: var openArray[T]; i: BackwardsIndex; x: T)
proc `[]=`(s: var string; i: BackwardsIndex; x: char)
proc `[]=`[A](t: var CountTable[A]; key: A; val: int)
proc `[]=`[A](t: CountTableRef[A]; key: A; val: int)
proc `[]=`[A, B](t: TableRef[A, B]; key: A; val: B)
proc `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
proc `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
proc `[]=`[A, B](t: var OrderedTable[A, B]; key: A; val: B)

expression: []=(a.arr, 2, 2)

If hash: TableRef[int, int], you can happily write to the table, probably because it is a pointer. Not sure if that's valid behavior either.

[genotrance]

Feedback on IRC from Araq.