incorrect ProveInitwith delayed initialization of field

[jangko]

proc make[T](): T = new(result)

produces warning:

nimpng.nim(1926, 7) Warning: Cannot prove that 'result' is initialized. This wil
l become a compile time error in the future. [ProveInit]

how could the 'result' is not initialized? 😄

[Araq]

Not enough context. It could be that 'result' has not-nil fields etc.

[jangko]

ok, here is the minimal code to reproduce the warning

type
  xx = ref object of RootObj
    a: range[0..0x7FFFFFFF]

  zz = ref object of xx
    b: range[1..0x7FFFFFFF]

proc make[T](): T = new(result)

discard make[xx]()
discard make[zz]()  #if this line is removed, the warning dissapear

shouldn't both line cause warning? and why uninitialized range should become compile time error in the future? couldn't the uninitialized range like range[1..n] just given value 1 like range[0..n] default value is 0?

[jangko]

this very simple example also produce incorrrect warning same as above

type
  abc* = ref object
    w: range[2..100]

proc createABC(): abc =
  new(result)
  result.w = 20 #i think the compiler missed to check this part

the warning doesn't make any sense, right?

[Araq]

On the contrary, it works as designed. That doesn't mean I like it, but it is not a bug.

Use this instead:

proc createABC(): abc =
  result = abc(w: 20)

[jangko]

then it is an unpleasant feature, reduce code/coding flexibility

[Araq]

IME it works well enough.

[andreaferretti]

@Araq Your suggestion works in this simple case, but not in more complex ones. For instance

type
  Foo* = ref object
    w: range[2..100]
  Bar* = ref object
    w: range[10..50]

template create(result: expr) =
  new(result)
  result.w = 20

proc createFoo(): Foo = create(result)

proc createBar(): Bar = create(result)

In the template here you do not know if you are creating a Foo or a Bar, but you want to perform the same operations.

This is not a theoretical possibility: it is happening always to me when dealing with similar 32-bit/64-bit code.

[refi64]

Couldn't you do something like (untested):

result = new type(result)

[andreaferretti]

In my case result is one of the two following types:

type
  Matrix32*[M, N: static[int]] = object
    order: OrderType
    data: ref array[N * M, float32]
  Matrix64*[M, N: static[int]] = object
    order: OrderType
    data: ref array[M * N, float64]

Changing

template makeSMatrixPrivate(M, N, f, order, result: expr) =
  new result.data
  result.order = order
  # ...

into

template makeSMatrixPrivate(M, N, f, order, result: expr) =
  result.data = new type(result.data)
  result.order = order
  # ...

did not make the warning go away.

[Araq]

But that might work:

template makeSMatrixPrivate(M, N, f, orderParam, result: expr) =
  result.data = type(result.data)(order: orderParam)
  # ...

[andreaferretti]

Unfortunately, it doesn't seem to work. I have switched to this style in a proveinit branch of linalg, but the warnings are still there (just try nimble test on that branch).

[stale]

This issue has been automatically marked as stale because it has not had recent activity. If you think it is still a valid issue, write a comment below; otherwise it will be closed. Thank you for your contributions.