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

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:
@@ -1525,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)

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/typeallowed.nim

@@ -156,8 +156,7 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
       result = typeAllowedAux(marker, t.elementType, kind, c, flags+{taIsOpenArray})
   of tySink:
     # you cannot nest openArrays/sinks/etc.
-    # `sink openarray` is not allowed
-    if kind != skParam or taIsOpenArray in flags or t.elementType.kind in {tySink, tyLent, tyVar, tyOpenArray, tyVarargs}:
+    if kind != skParam or taIsOpenArray in flags or t.elementType.kind in {tySink, tyLent, tyVar}:
       result = t
     else:
       result = typeAllowedAux(marker, t.elementType, kind, c, flags)

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)
 

lib/pure/collections/critbits.nim

@@ -526,7 +526,7 @@ func commonPrefixLen*[T](c: CritBitTree[T]): int {.inline, since((1, 3)).} =
     else: c.root.byte
   else: 0
 
-proc toCritBitTree*[T](pairs: openArray[(string, T)]): CritBitTree[T] {.since: (1, 3).} =
+proc toCritBitTree*[T](pairs: sink openArray[(string, T)]): CritBitTree[T] {.since: (1, 3).} =
   ## Creates a new `CritBitTree` that contains the given `pairs`.
   runnableExamples:
     doAssert {"a": "0", "b": "1", "c": "2"}.toCritBitTree is CritBitTree[string]
@@ -534,7 +534,7 @@ proc toCritBitTree*[T](pairs: openArray[(string, T)]): CritBitTree[T] {.since: (
 
   for item in pairs: result.incl item[0], item[1]
 
-proc toCritBitTree*(items: openArray[string]): CritBitTree[void] {.since: (1, 3).} =
+proc toCritBitTree*(items: sink openArray[string]): CritBitTree[void] {.since: (1, 3).} =
   ## Creates a new `CritBitTree` that contains the given `items`.
   runnableExamples:
     doAssert ["a", "b", "c"].toCritBitTree is CritBitTree[void]

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/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/destructor/tmove_objconstr.nim

@@ -186,7 +186,7 @@ type
   TableNonCopyable = object
     x: seq[(string, MySeqNonCopyable)]
 
-proc toTable(pairs: openArray[(string, MySeqNonCopyable)]): TableNonCopyable =
+proc toTable(pairs: sink openArray[(string, MySeqNonCopyable)]): TableNonCopyable =
   discard
 
 

tests/destructor/tnewruntime_misc.nim

@@ -1,6 +1,5 @@
 discard """
   cmd: '''nim cpp -d:nimAllocStats --newruntime --threads:on $file'''
-  disabled: true
   output: '''(field: "value")
 Indeed
 axc

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/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/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"
-