fix(types): refine alias skipping logic in type comparison functions

compiler/ast.nim

@@ -1647,13 +1647,9 @@ proc canRaise*(fn: PNode): bool =
     if fn.typ.n[0].kind == nkSym:
       result = false
     else:
-      # A proc-typed value with no explicit raises slot still has
-      # unspecified effects, which sempass2 treats conservatively.
-      # Codegen needs to do the same in order to keep goto-exception
-      # checks after indirect/closure calls.
       result = ((fn.typ.n[0].len < effectListLen) or
-        fn.typ.n[0][exceptionEffects] == nil or
-        fn.typ.n[0][exceptionEffects].safeLen > 0)
+        (fn.typ.n[0][exceptionEffects] != nil and
+        fn.typ.n[0][exceptionEffects].safeLen > 0))
   else:
     result = false
 

compiler/ccgexprs.nim

@@ -974,9 +974,7 @@ proc cow(p: BProc; n: PNode) {.inline.} =
   if n.kind == nkHiddenAddr: cowBracket(p, n[0])
 
 template ignoreConv(e: PNode): bool =
-  let destType = e.typ.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink})
-  let srcType = e[1].typ.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink})
-  sameBackendTypePickyAliases(destType, srcType)
+  sameBackendTypePickyAliases(e.typ, e[1].typ)
 
 proc genAddr(p: BProc, e: PNode, d: var TLoc) =
   # careful  'addr(myptrToArray)' needs to get the ampersand:

compiler/ccgstmts.nim

@@ -1237,7 +1237,6 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
         else:
           scope = initScope(p.s(cpsStmts))
       # we handled the error:
-      linefmt(p, cpsStmts, "T$1_ = nullptr;$n", [etmp])
       expr(p, t[i][0], d)
       linefmt(p, cpsStmts, "#popCurrentException();$n", [])
       endBlockWith(p):

compiler/guards.nim

@@ -46,7 +46,7 @@ proc isLocation(n: PNode): bool = not n.isValue
 
 proc isLet(n: PNode): bool =
   if n.kind == nkSym:
-    if n.sym.kind in {skLet, skConst, skTemp, skForVar}: # guard immutable variables
+    if n.sym.kind in {skLet, skTemp, skForVar}:
       result = true
     elif n.sym.kind == skParam and skipTypes(n.sym.typ,
                                              abstractInst).kind notin {tyVar}:

compiler/semexprs.nim

@@ -578,7 +578,14 @@ proc isOpImpl(c: PContext, n: PNode, flags: TExprFlags): PNode =
     if efExplain in flags:
       m.diagnostics = @[]
       m.diagnosticsEnabled = true
-    res = typeRel(m, t2, t1) >= isSubtype # isNone
+    let rel = typeRel(m, t2, t1)
+    res = rel >= isSubtype # isNone
+    if res and rel == isEqual and
+        not compareTypes(t1, t2,
+                         flags = {ExactTypeDescValues,
+                                  PickyCAliases,
+                                  PickyBackendAliases}):
+      res = false
     # `res = sameType(t1, t2)` would be wrong, e.g. for `int is (int|float)`
 
   result = newIntNode(nkIntLit, ord(res))

compiler/seminst.nim

@@ -81,7 +81,8 @@ proc sameInstantiation(a, b: TInstantiation): bool =
       if not compareTypes(a.concreteTypes[i], b.concreteTypes[i],
                           flags = {ExactTypeDescValues,
                                    ExactGcSafety,
-                                   PickyCAliases}): return
+                                   PickyCAliases,
+                                   PickyBackendAliases}): return
     result = true
   else:
     result = false

compiler/sempass2.nim

@@ -1208,7 +1208,6 @@ type
     enforcedGcSafety, enforceNoSideEffects: bool
     oldExc, oldTags, oldForbids: int
     exc, tags, forbids: PNode
-    excSource, tagsSource, forbidsSource: PNode
 
 proc createBlockContext(tracked: PEffects): PragmaBlockContext =
   var oldForbidsLen = 0
@@ -1231,18 +1230,17 @@ proc unapplyBlockContext(tracked: PEffects; bc: PragmaBlockContext) =
     # anything about 'raises' in the 'cast' at all. Same applies for 'tags'.
     setLen(tracked.exc.sons, bc.oldExc)
     for e in bc.exc:
-      addRaiseEffect(tracked, e, if bc.excSource != nil: bc.excSource else: e)
+      addRaiseEffect(tracked, e, e)
   if bc.tags != nil:
     setLen(tracked.tags.sons, bc.oldTags)
     for t in bc.tags:
-      addTag(tracked, t, if bc.tagsSource != nil: bc.tagsSource else: t)
+      addTag(tracked, t, t)
   if bc.forbids != nil:
     setLen(tracked.forbids.sons, bc.oldForbids)
     for t in bc.forbids:
-      addNotTag(tracked, t, if bc.forbidsSource != nil: bc.forbidsSource else: t)
+      addNotTag(tracked, t, t)
 
-proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext) =
-  let pragma = castPragma[1]
+proc castBlock(tracked: PEffects, pragma: PNode, bc: var PragmaBlockContext) =
   case whichPragma(pragma)
   of wGcSafe:
     bc.enforcedGcSafety = true
@@ -1255,7 +1253,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.tags = newNodeI(nkArgList, pragma.info)
       bc.tags.add n
-    bc.tagsSource = castPragma
   of wForbids:
     let n = pragma[1]
     if n.kind in {nkCurly, nkBracket}:
@@ -1263,7 +1260,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.forbids = newNodeI(nkArgList, pragma.info)
       bc.forbids.add n
-    bc.forbidsSource = castPragma
   of wRaises:
     let n = pragma[1]
     if n.kind in {nkCurly, nkBracket}:
@@ -1271,7 +1267,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.exc = newNodeI(nkArgList, pragma.info)
       bc.exc.add n
-    bc.excSource = castPragma
   of wUncheckedAssign:
     discard "handled in sempass1"
   else:
@@ -1308,8 +1303,6 @@ proc allowCStringConv(n: PNode): bool =
 
 proc track(tracked: PEffects, n: PNode) =
   case n.kind
-  of nkTypeOfExpr:
-    discard "typeof() never evaluates its operand; not a definite-assignment use"
   of nkSym:
     useVar(tracked, n)
     if n.sym.typ != nil and tfHasAsgn in n.sym.typ.flags:
@@ -1527,7 +1520,7 @@ proc track(tracked: PEffects, n: PNode) =
       of wNoSideEffect:
         bc.enforceNoSideEffects = true
       of wCast:
-        castBlock(tracked, pragmaList[i], bc)
+        castBlock(tracked, pragmaList[i][1], bc)
       else:
         discard
     applyBlockContext(tracked, bc)
@@ -1559,10 +1552,9 @@ proc track(tracked: PEffects, n: PNode) =
       message(tracked.config, n.info, warnPtrToCstringConv,
           $n[1].typ)
 
-    # Check for implicit range conversions. Compile-time constants are already
-    # fully known here, so only non-constant values need the downsizing warning.
+    # Check for implicit range conversions
     if n.kind == nkHiddenStdConv and (not tracked.isArrayIndexing) and
-          getConstExpr(tracked.ownerModule, n[1], tracked.c.idgen, tracked.graph) == nil and
+          n[1].kind notin {nkCharLit..nkUInt64Lit, nkFloatLit..nkFloat128Lit} and
           shouldWarnRangeConversion(tracked.config, n.info, n.typ, n[1].typ):
       message(tracked.config, n.info, warnImplicitRangeConversion,
               typeToString(n[1].typ) & " -> " & typeToString(n.typ))

compiler/semtypinst.nim

@@ -52,7 +52,8 @@ proc searchInstTypes*(g: ModuleGraph; key: PType): PType =
       for j in FirstGenericParamAt..<key.kidsLen:
         # XXX sameType is not really correct for nested generics?
         if not compareTypes(inst[j], key[j],
-                            flags = {ExactGenericParams, PickyCAliases}):
+                            flags = {ExactGenericParams, PickyCAliases,
+                                     PickyBackendAliases}):
           break matchType
 
       return inst

compiler/sigmatch.nim

@@ -791,10 +791,8 @@ proc procParamTypeRel(c: var TCandidate; f, a: PType): TTypeRelation =
     # different C types (size_t vs unsigned long long).
     let fCheck = concreteType(c, f)
     let aCheck = concreteType(c, a)
-    # Note that `result` is equal; now check whether they have the same
-    # backend type.
     if fCheck != nil and aCheck != nil and
-      not sameBackendTypePickyAliases(fCheck, aCheck, {IgnoreFlags}):
+        not sameBackendTypePickyAliases(fCheck, aCheck):
       result = isNone
 
   if result <= isSubrange or inconsistentVarTypes(f, a):
@@ -2473,10 +2471,6 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
       return arg
     elif f.kind == tyStatic and arg.typ.n != nil:
       return arg.typ.n
-    elif f.kind == tyUntyped:
-      # bug #25693: a different overload candidate may have sem-checked the
-      # operand and left symbols behind; templates expect the pristine AST.
-      return argOrig
     else:
       return argSemantized # argOrig
 

compiler/types.nim

@@ -897,7 +897,11 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
     c.flags = oldFlags
 
   if x == y: return true
-  let aliasSkipSet = maybeSkipRange({tyAlias, tyInferred})
+  let aliasSkipSet = maybeSkipRange(
+    if PickyBackendAliases in c.flags:
+      {tyInferred}
+    else:
+      {tyAlias, tyInferred})
   var a = skipTypes(x, aliasSkipSet)
   while a.kind == tyUserTypeClass and tfResolved in a.flags:
     a = skipTypes(a.last, aliasSkipSet)
@@ -1069,10 +1073,11 @@ proc sameBackendTypeIgnoreRange*(x, y: PType): bool =
   c.cmp = dcEqIgnoreDistinct
   result = sameTypeAux(x, y, c)
 
-proc sameBackendTypePickyAliases*(x, y: PType, flags: TTypeCmpFlags = {}): bool =
+proc sameBackendTypePickyAliases*(x, y: PType): bool =
+  let x = x.skipTypes({tyVar, tyLent, tySink, tyOwned})
+  let y = y.skipTypes({tyVar, tyLent, tySink, tyOwned})
   var c = initSameTypeClosure()
   c.flags.incl {IgnoreTupleFields, IgnoreRangeShallow, PickyCAliases, PickyBackendAliases}
-  c.flags.incl flags
   c.cmp = dcEqIgnoreDistinct
   result = sameTypeAux(x, y, c)
 

compiler/vmgen.nim

@@ -1842,8 +1842,6 @@ proc genArrAccessOpcode(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode;
   if dest < 0: dest = c.getTemp(n.typ)
   if opc in {opcLdArrAddr, opcLdStrIdxAddr} and gfNodeAddr in flags:
     c.gABC(n, opc, dest, a, b)
-    if c.prc.regInfo[a].kind >= slotTempUnknown:
-      c.prc.regInfo[a].kind = slotTempPerm
   elif needsRegLoad():
     var cc = c.getTemp(n.typ)
     c.gABC(n, opc, cc, a, b)
@@ -1860,8 +1858,6 @@ proc genObjAccessAux(c: PCtx; n: PNode; a, b: int, dest: var TDest; flags: TGenF
   if dest < 0: dest = c.getTemp(n.typ)
   if {gfNodeAddr} * flags != {}:
     c.gABC(n, opcLdObjAddr, dest, a, b)
-    if a < c.prc.regInfo.len and c.prc.regInfo[a].kind >= slotTempUnknown:
-      c.prc.regInfo[a].kind = slotTempPerm
   elif needsRegLoad():
     var cc = c.getTemp(n.typ)
     c.gABC(n, opcLdObj, cc, a, b)

lib/pure/parsejson.nim

@@ -175,48 +175,23 @@ proc parseEscapedUTF16*(buf: cstring, pos: var int): int =
     else:
       return -1
 
-proc addSpan(dst: var string; src: string; startPos, endPos: int) {.inline.} =
-  let n = endPos - startPos
-  if n <= 0:
-    return
-
-  let old = dst.len
-  dst.setLen old + n
-
-  template impl =
-    for i in 0..<n:
-      dst[old + i] = src[startPos + i]
-
-  when nimvm:
-    impl
-  else:
-    when defined(js) or defined(nimscript):
-      impl
-    else:
-      {.noSideEffect.}:
-        copyMem dst[old].addr, src[startPos].unsafeAddr, n
-
 proc parseString(my: var JsonParser): TokKind =
   result = tkString
   var pos = my.bufpos + 1
-  var spanStart = pos
   if my.rawStringLiterals:
     add(my.a, '"')
   while true:
     case my.buf[pos]
     of '\0':
-      my.err = errInvalidToken
-      addSpan(my.a, my.buf, spanStart, pos)
+      my.err = errQuoteExpected
       result = tkError
       break
     of '"':
-      addSpan(my.a, my.buf, spanStart, pos)
       if my.rawStringLiterals:
         add(my.a, '"')
       inc(pos)
       break
     of '\\':
-      addSpan(my.a, my.buf, spanStart, pos)
       if my.rawStringLiterals:
         add(my.a, '\\')
       case my.buf[pos+1]
@@ -276,18 +251,14 @@ proc parseString(my: var JsonParser): TokKind =
         # don't bother with the error
         add(my.a, my.buf[pos])
         inc(pos)
-      spanStart = pos
     of '\c':
-      addSpan(my.a, my.buf, spanStart, pos)
       pos = lexbase.handleCR(my, pos)
       add(my.a, '\c')
-      spanStart = pos
     of '\L':
-      addSpan(my.a, my.buf, spanStart, pos)
       pos = lexbase.handleLF(my, pos)
       add(my.a, '\L')
-      spanStart = pos
     else:
+      add(my.a, my.buf[pos])
       inc(pos)
   my.bufpos = pos # store back
 

tests/ccg/tclosure_err_panic_goto.nim

@@ -1,36 +0,0 @@
-discard """
-  matrix: "; --panics:on"
-"""
-# issue #25851: --panics:on must not drop the nimErr_ check after a closure
-# call whose result is consumed directly (e.g. `result.add elem(src)`).
-# Regression from #25295.
-
-type
-  Overrun = object of CatchableError
-  Source = object
-    data: seq[bool]
-    cursor: int
-  ElemFn = proc(src: var Source): bool {.closure.}
-
-proc drawBool(src: var Source): bool =
-  if src.cursor >= src.data.len: raise newException(Overrun, "exhausted")
-  result = src.data[src.cursor]; inc src.cursor
-
-proc listRun(elem: ElemFn, src: var Source): seq[bool] =
-  result = @[]
-  while true:
-    if not src.drawBool(): break
-    result.add elem(src)        # closure call – the result flows straight
-                                # into `add`, which previously caused the
-                                # compiler to skip the nimErr_ check.
-
-let elem: ElemFn = proc(src: var Source): bool = src.drawBool()
-
-# Both --panics:on and --panics:off must propagate the Overrun.
-var caught = false
-try:
-  var src = Source(data: @[true])
-  discard listRun(elem, src)
-except Overrun:
-  caught = true
-doAssert caught, "Overrun exception was swallowed"

tests/ccgbugs2/m25294/c.nim

@@ -1,13 +0,0 @@
-template a(T: type): int =
-  when T is uint64: 1 else: 2
-
-type
-  M*[T] = object
-    data*: seq[T]
-    b: seq[int]
-    indices*: array[a(T), int64]
-  U = distinct uint64
-  D* = object
-    c: M[U]
-    v: array[180000, int64]
-    g*: M[uint64]

tests/ccgbugs2/m25294/t.nim

@@ -1,5 +0,0 @@
-import ./c
-
-proc p*(): D =
-  let c = M[uint64](data: @[0], indices: [1])
-  result = D(g: c)

tests/ccgbugs2/t25294.nim

@@ -1,18 +0,0 @@
-discard """
-  matrix: "--mm:refc; --mm:orc"
-"""
-
-import ./m25294/[c, t]
-
-block:
-  let a = new D
-  a[] = p()
-  discard a[]
-block:
-  let a = new D
-  a[] = p()
-  discard a[]
-block:
-  let a = new D
-  a[] = p()
-  discard a[]

tests/ccgbugs2/tcodegen.nim

@@ -75,3 +75,19 @@ block: # importc type inheritance
   doAssert(cast[cint](b) == 123)
   var c = foo(b)
   doAssert(cast[cint](c) == 123)
+
+
+# bug #23765
+type
+  X11[T, E] = object
+    m: T
+  B = X11[culonglong, cstring]
+  S = ref object of RootObj
+
+proc j[T, E](m: X11[T, E]): T = discard
+proc n(T: typedesc[SomeUnsignedInt]): X11[T, cstring] = discard
+method call(client: S): uint64 {.base.} =
+  discard j(n(uint64))
+
+var s = S()
+discard s.call()

tests/effects/tcast_effect_violation.nim

@@ -1,8 +0,0 @@
-discard """
-  errormsg: "cast(raises: ValueError) can raise an unlisted exception: ValueError"
-  line: 7
-"""
-
-proc fff() {.raises: [].} =
-  {.cast(raises: ValueError).}:
-    discard

tests/exception/treraise_typeless_except_finally.nim

@@ -1,30 +0,0 @@
-discard """
-  targets: "cpp"
-  matrix: "--mm:arc; --mm:orc; --mm:refc"
-  output: '''
-finally
-after
-'''
-"""
-
-# Regression test: typeless `except:` followed by `finally:` must not
-# trigger ReraiseDefect at the end of the proc.
-#
-# Previously, `genTryCpp` only emitted `T_ = nullptr;` in the *typed*
-# except branches, leaving the typeless `except:` path with a still-set
-# `T_`.  After the handler body and `popCurrentException`, the trailing
-# `if (T_) std::rethrow_exception(T_);` in the finally block would still
-# fire — but with the Nim exception stack already popped, the rethrow
-# bubbled up as a `ReraiseDefect: no exception to reraise`.
-
-proc test() =
-  try:
-    raise newException(CatchableError, "x")
-  except:
-    let e = getCurrentException()
-    discard e
-  finally:
-    echo "finally"
-
-test()
-echo "after"

tests/init/t25857.nim

@@ -1,19 +0,0 @@
-discard """
-  output: "1"
-"""
-
-# Regression for #25857: `typeof(result)` inside `result`'s initializer must not be
-# treated as a use-before-initialization of `result`. `typeof` is a type query and
-# never evaluates its operand, so this compiles and runs.
-# (Before the fix this errored: "'result' requires explicit initialization" on
-#  {.requiresInit.} return types, breaking the `ok(typeof(result), v)` idiom.)
-
-type Box[T] {.requiresInit.} = object
-  v: T
-
-func make[T](_: typedesc[Box[T]], v: T): Box[T] = Box[T](v: v)
-
-proc f(): Box[int] =
-  make(typeof(result), 1)
-
-echo f().v

tests/objvariant/tcorrectcheckedfield.nim

@@ -20,25 +20,3 @@ block: # issue #24021
       discard
     else:
       discard foo.z
-
-
-# bug #22791
-type Foo = object
-  case a: bool
-  of false:
-    discard
-  of true:
-    case b: bool
-    of false:
-      discard
-    of true:
-      c: bool
-
-const f = Foo(a: true, b: true, c: true)
-case f.a
-of true:
-  case f.b
-  of true:
-    echo f.c
-  else: discard
-else: discard

tests/proc/tproc.nim

@@ -29,30 +29,3 @@ block tnestprc:
       result = x + y
     result = add(x, 3)
   doAssert Add3(7) == 10
-
-block:
-  type A = object
-    c: int
-  type H = proc(): lent A {.nimcall.}
-  const u = A(c: 0)
-  proc e(T: typedesc): lent A = u
-  proc y(T: typedesc): H =
-    proc(): lent A {.nimcall.} = T.e
-  discard y(int)
-
-block:
-  type A = object
-    c: int
-  type H = proc(): lent A {.nimcall.}
-  let u = A(c: 0)
-  proc y(_: int | int): H =
-    proc(): lent A {.nimcall.} = u
-  discard y(0)
-
-block:
-  type A = object
-    c: int
-  type H = proc(): lent A {.nimcall.}
-  let u = A()
-  let _: H = proc(): lent A {.nimcall.} = u
-

tests/range/timplicitrangeconsts.nim

@@ -1,30 +0,0 @@
-discard """
-cmd: "nim check $options --hints:off --warning:ImplicitRangeConversion --warningaserror:ImplicitRangeConversion $file"
-action: "compile"
-"""
-
-type
-  E = enum
-    ea, eb
-
-  R = range[eb..eb]
-  I = range[0..3]
-
-proc accept(r: R) = discard
-proc accept(i: I) = discard
-
-var r: R
-var i: I
-const enumOk = eb
-const enumAlias = enumOk
-const intOk = 1 + 2
-
-r = eb
-r = enumOk
-r = enumAlias
-accept(eb)
-accept(enumOk)
-accept(enumAlias)
-
-i = intOk
-accept(intOk)

tests/template/toverload_over_untyped.nim

@@ -1,32 +0,0 @@
-discard """
-  output: "ok"
-"""
-
-# bug #25693
-
-template g(b: untyped) {.dirty.} =
-  template t: untyped = b
-
-proc d() = discard @[0]
-proc g(_: int) = discard
-
-proc f(a: var seq[int], _: string) =
-  let p = @[0]
-  d()
-  a = p
-
-let q = "a"
-g:
-  var a: seq[int]
-  try:
-    f(a, q & "1")
-  except CatchableError:
-    discard
-  try:
-    f(a, q & "1")
-  except CatchableError:
-    discard
-block: t()
-block: t()
-echo "ok"
-

tests/vm/t25849.nim

@@ -1,16 +0,0 @@
-discard """
-  targets: "c cpp js"
-"""
-
-import std/os
-from std/sequtils import toSeq
-
-iterator items(a: array[3, string]): lent string {.inline.} =
-  for i in 0..2:
-    yield a[i]
-
-static:
-  const key = "NIM_TESTS_TOSENV_KEY"
-  for val in items(["a", "b", "c"]):
-    putEnv(key, val)
-    doAssert (key, val) in toSeq(envPairs())