path: root/tests/strictnotnil/tnilcheck.nim

discard """
action: compile
"""

import tables

{.experimental: "strictNotNil".}

type
  Nilable* = ref object
    a*: int
    field*: Nilable
    
  NonNilable* = Nilable not nil

  Nilable2* = nil NonNilable


# proc `[]`(a: Nilable, b: int): Nilable =
#   nil


# Nilable tests



# test deref
proc testDeref(a: Nilable) =
  echo a.a > 0 #[tt.Warning
       ^ can't deref a, it might be nil
  ]#



# # # test if else
proc testIfElse(a: Nilable) =
  if a.isNil:
    echo a.a #[tt.Warning
         ^ can't deref a, it is nil
    ]#
  else:
    echo a.a # ok

proc testIfNoElse(a: Nilable) =
  if a.isNil:
    echo a.a #[tt.Warning
         ^ can't deref a, it is nil
         ]#
  echo a.a #[tt.Warning
       ^ can't deref a, it might be nil
   ]#

proc testIfReturn(a: Nilable) =
  if not a.isNil:
    return
  echo a.a #[tt.Warning
       ^ can't deref a, it is nil
  ]#

proc testIfBreak(a: seq[Nilable]) =
  for b in a:
    if not b.isNil:
      break
    echo b.a #[tt.Warning
         ^ can't deref b, it is nil
    ]#

proc testIfContinue(a: seq[Nilable]) =
  for b in a:
    if not b.isNil:
      continue
    echo b.a #[tt.Warning
         ^ can't deref b, it is nil
    ]#

proc testIfRaise(a: Nilable) =
  if not a.isNil:
    raise newException(ValueError, "")
  echo a.a #[tt.Warning
       ^ can't deref a, it is nil
  ]#

proc testIfElif(a: Nilable) =
  var c = 0
  if c == 0:
    echo a.a #[tt.Warning
         ^ can't deref a, it might be nil
      ]#
  elif c == 1:
    echo a.a #[tt.Warning
         ^ can't deref a, it might be nil
      ]#
  elif not a.isNil:
    echo a.a # ok
  elif c == 2:
    echo 0
  else:
    echo a.a #[tt.Warning
         ^ can't deref a, it is nil
    ]#

proc testAssignUnify(a: Nilable, b: int) =
  var a2 = a
  if b == 0:
    a2 = Nilable()
  echo a2.a #[tt.Warning
       ^ can't deref a2, it might be nil
  ]#


# # test assign in branch and unifiying that with the main block after end of branch
proc testAssignUnifyNil(a: Nilable, b: int) =
  var a2 = a
  if b == 0:
    a2 = nil
  echo a2.a #[tt.Warning
       ^ can't deref a2, it might be nil
  ]#

# test loop
proc testForLoop(a: Nilable) =
  var b = Nilable()
  for i in 0 .. 5:
    echo b.a #[tt.Warning
         ^ can't deref b, it might be nil
    ]#
    if i == 2:
      b = a
  echo b.a #[tt.Warning
       ^ can't deref b, it might be nil
  ]#



# # TODO implement this after discussion
# # proc testResultCompoundNonNilableElement(a: Nilable): (NonNilable, NonNilable) = #[t t.Warning
# #      ^ result might be not initialized, so it or an element might be nil
# # ]#
# #   if not a.isNil:
# #     result[0] = a #[t t.Warning
# #                 ^ can't assign nilable to non nilable: it might be nil
# #     #]

# # proc testNonNilDeref(a: NonNilable) =
# #   echo a.a # ok



# # # not only calls: we can use partitions for dependencies for field aliases
# # # so we can detect on change what does this affect or was this mutated between us and the original field

# # proc testRootAliasField(a: Nilable) =
# #   var aliasA = a
# #   if not a.isNil and not a.field.isNil:
# #     aliasA.field = nil
# #     # a.field = nil
# #     # aliasA = nil 
# #     echo a.field.a # [tt.Warning
# #          ^ can't deref a.field, it might be nil
# #     ]#


proc testAliasChanging(a: Nilable) =
  var b = a
  var aliasA = b
  b = Nilable()
  if not b.isNil:
    echo aliasA.a #[tt.Warning
         ^ can't deref aliasA, it might be nil
    ]#

# # TODO
# # proc testAliasUnion(a: Nilable) =
# #   var a2 = a
# #   var b = a2
# #   if a.isNil:
# #     b = Nilable()
# #     a2 = nil
# #   else:
# #     a2 = Nilable()
# #     b = a2
# #   if not b.isNil:
# #     echo a2.a #[ tt.Warning
# #          ^ can't deref a2, it might be nil
# #     ]#

# # TODO after alias support
# #proc callVar(a: var Nilable) =
# #  a.field = nil


# # TODO ptr support
# # proc testPtrAlias(a: Nilable) =
# #   # pointer to a: hm.
# #   # alias to a?
# #   var ptrA = a.addr # {0, 1} 
# #   if not a.isNil: # {0, 1}
# #     ptrA[] = nil # {0, 1} 0: MaybeNil 1: MaybeNil
# #     echo a.a #[ tt.Warning
# #          ^ can't deref a, it might be nil
# #     ]#

# # TODO field stuff
# # currently it just doesnt support dot, so accidentally it shows a warning but because that
# # not alias i think
# # proc testFieldAlias(a: Nilable) =
# #   var b = a # {0, 1} {2} 
# #   if not a.isNil and not a.field.isNil: # {0, 1} {2}
# #     callVar(b) # {0, 1} {2} 0: Safe 1: Safe
# #     echo a.field.a #[ tt.Warning
# #           ^ can't deref a.field, it might be nil
# #     ]#
# #
# # proc testUniqueHashTree(a: Nilable): Nilable =
# #   # TODO what would be a clash
# #   var field = 0
# #   if not a.isNil and not a.field.isNil:
# #     # echo a.field.a
# #     echo a[field].a
# #   result = Nilable()
  
# # proc testSeparateShadowingResult(a: Nilable): Nilable =
# #   result = Nilable()
# #   if not a.isNil:
# #     var result: Nilable = nil
# #   echo result.a


proc testCStringDeref(a: cstring) =
  echo a[0] #[tt.Warning
       ^ can't deref a, it might be nil
  ]#


proc testNilablePtr(a: ptr int) =
  if not a.isNil:
    echo a[] # ok
  echo a[] #[tt.Warning
       ^ can't deref a, it might be nil
  ]#

# # proc testNonNilPtr(a: ptr int not nil) =
# #   echo a[] # ok

proc raiseCall: NonNilable = #[tt.Warning
^ return value is nil
]#
  raise newException(ValueError, "raise for test") 

# proc testTryCatch(a: Nilable) =
#   var other = a
#   try:
#     other = raiseCall()
#   except:
#     discard
#   echo other.a #[ tt.Warning
#             ^ can't deref other, it might be nil
#   ]#

# # proc testTryCatchDetectNoRaise(a: Nilable) =
# #   var other = Nilable()
# #   try:
# #     other = nil
# #     other = a
# #     other = Nilable()
# #   except:
# #     other = nil
# #   echo other.a # ok

# # proc testTryCatchDetectFinally =
# #   var other = Nilable()
# #   try:
# #     other = nil
# #     other = Nilable()
# #   except:
# #     other = Nilable()
# #   finally:
# #     other = nil
# #   echo other.a # can't deref other: it is nil

# # proc testTryCatchDetectNilableWithRaise(b: bool) =
# #   var other = Nilable()
# #   try:
# #     if b:
# #       other = nil
# #     else:
# #       other = Nilable()
# #       var other2 = raiseCall()
# #   except:
# #     echo other.a # ok

# #   echo other.a # can't deref a: it might be nil

# # proc testRaise(a: Nilable) =
# #   if a.isNil:
# #     raise newException(ValueError, "a == nil")
# #   echo a.a # ok


# # proc testBlockScope(a: Nilable) =
# #   var other = a
# #   block:
# #     var other = Nilable()
# #     echo other.a # ok
# #   echo other.a # can't deref other: it might be nil

# # ok we can't really get the nil value from here, so should be ok
# # proc testDirectRaiseCall: NonNilable =
# #   var a = raiseCall()
# #   result = NonNilable()

# # proc testStmtList =
# #   var a = Nilable()
# #   block:
# #     a = nil
# #     a = Nilable()
# #   echo a.a # ok

proc callChange(a: Nilable) =
  if not a.isNil:
    a.field = nil

proc testCallChangeField =
  var a = Nilable()
  a.field = Nilable()
  callChange(a)
  echo a.field.a #[ tt.Warning
        ^ can't deref a.field, it might be nil
       ]#

proc testReassignVarWithField =
  var a = Nilable()
  a.field = Nilable()
  echo a.field.a # ok
  a = Nilable()
  echo a.field.a #[ tt.Warning
        ^ can't deref a.field, it might be nil
        ]#


proc testItemDeref(a: var seq[Nilable]) =
  echo a[0].a #[tt.Warning
        ^ can't deref a[0], it might be nil
       ]#
  a[0] = Nilable() # good: now .. if we dont track, how do we know 
  echo a[0].a # ok
  echo a[1].a #[tt.Warning
        ^ can't deref a[1], it might be nil
  ]#
  var b = 1
  if a[b].isNil:
    echo a[1].a #[tt.Warning
          ^ can't deref a[1], it might be nil
    ]#
    var c = 0
    echo a[c].a #[tt.Warning
          ^ can't deref a[c], it might be nil
    ]#

  # known false positive
  if not a[b].isNil:
    echo a[b].a #[tt.Warning
          ^ can't deref a[b], it might be nil
    ]#

  const c = 0
  if a[c].isNil:
    echo a[0].a #[tt.Warning
          ^ can't deref a[0], it is nil
    ]#
  a[c] = Nilable()
  echo a[0].a # ok



# # # proc test10(a: Nilable) =
# # #   if not a.isNil and not a.b.isNil:
# # #     c_memset(globalA.addr, 0, globalA.sizeOf.csize_t)
# # #     globalA = nil
# # #     echo a.a # can't deref a: it might be nil