Fixes #25340

Author: yglukhov

compiler/ccgexprs.nim

@@ -3317,8 +3317,9 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
         cCast(ptrType(destType),
           wrapPar(cAddr(wrapPar(val))))),
       a.storage)
-  elif p.module.compileToCpp:
+  elif p.module.compileToCpp or isImportedType(src):
     # C++ implicitly downcasts for us
+    # importc types don't have a Sup field, so we must cast
     expr(p, arg, d)
   else:
     var a: TLoc = initLocExpr(p, arg)

compiler/semtypes.nim

@@ -1014,7 +1014,7 @@ proc skipGenericInvocation(t: PType): PType {.inline.} =
 proc tryAddInheritedFields(c: PContext, check: var IntSet, pos: var int,
                         obj: PType, n: PNode, isPartial = false, innerObj: PType = nil): bool =
   if ((not isPartial) and (obj.kind notin {tyObject, tyGenericParam} or tfFinal in obj.flags)) or
-    (innerObj != nil and obj.sym.id == innerObj.sym.id):
+    (innerObj != nil and obj.sym != nil and innerObj.sym != nil and obj.sym.id == innerObj.sym.id):
     localError(c.config, n.info, "Cannot inherit from: '" & $obj & "'")
     result = false
   elif obj.kind == tyObject:

compiler/semtypinst.nim

@@ -499,6 +499,19 @@ proc handleGenericInvocation(cl: var TReplTypeVars, t: PType): PType =
   newbody.flags = newbody.flags + (t.flags + body.flags - tfInstClearedFlags)
   result.flags = result.flags + newbody.flags - tfInstClearedFlags
 
+  # Propagate importc from generic body to instantiated body (for computed type aliases)
+  if body.sym != nil and sfImportc in body.sym.flags:
+    if newbody.sym != nil and sfImportc notin newbody.sym.flags:
+      incl(newbody.sym.flagsImpl, sfImportc)
+      newbody.sym.locImpl.snippet = body.sym.loc.snippet  # copy the C name
+    elif newbody.sym.isNil and newbody.kind == tyObject:
+      # Computed type alias returned an anonymous object type - create a symbol for it
+      let s = newSym(skType, body.sym.name, cl.c.idgen, body.sym.owner, cl.info)
+      incl(s.flagsImpl, sfImportc)
+      s.locImpl.snippet = body.sym.loc.snippet
+      s.typ = newbody
+      newbody.sym = s
+
   setToPreviousLayer(cl.typeMap)
 
   # This is actually wrong: tgeneric_closure fails with this line:

compiler/sigmatch.nim

@@ -1702,6 +1702,15 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
               if hasCovariance:
                 continue
 
+            # Fallback for computed generic type aliases (bug #25340):
+            # Check if the aliased types (last elements) have inheritance relationship
+            let aLast = roota.last
+            let fLast = rootf.last
+            if aLast.kind == tyObject and fLast.kind == tyObject and trIsOutParam notin flags:
+              let depth = isObjectSubtype(c, aLast, fLast, nil)
+              if depth > 0:
+                inc c.inheritancePenalty, depth + ord(c.inheritancePenalty < 0)
+                return isSubtype
             return isNone
         if prev == nil: put(c, f, a)
       else:

tests/typerel/t25340.nim

@@ -0,0 +1,72 @@
+import macros
+
+block:
+  type
+    JSObj {.inheritable, pure.} = object
+    JSExternObjBase {.inheritable, pure, noinit, importc: "int", bycopy.} = object
+    HTMLElement = object of JSObj
+    Document = object of HTMLElement
+
+  macro parent(t: typedesc): untyped =
+    let n = t.getType()[1]
+    if $n == "JSObj":
+      return ident"JSExternObjBase"
+    else:
+      let imp = n.getTypeImpl()
+      imp.expectKind(nnkObjectTy)
+      let base = imp[1][0]
+      result = newTree(nnkObjectTy,
+                      newEmptyNode(),
+                      newTree(nnkOfInherit,
+                              newTree(nnkBracketExpr, ident"JSExternObj", base)),
+                      newEmptyNode())
+
+  type
+    JSExternObj[T] {.noinit, importc: "int", bycopy.} = parent(T)
+
+  var a: JSExternObj[JSObj]
+  var d: JSExternObj[Document]
+  a = d
+  proc p(a: JSExternObj[JSObj]) =
+    discard
+  p(d)
+
+  assert JSExternObj[Document] is JSExternObj[HTMLElement]
+  assert JSExternObj[HTMLElement] is JSExternObj[JSObj]
+  assert JSExternObj[Document] is JSExternObj[JSObj]
+
+block:
+  type
+    JSObj {.inheritable.} = object
+    JSExternObjBase {.inheritable, pure.} = object
+    HTMLElement = object of JSObj
+    Document = object of HTMLElement
+
+  macro parent(t: typedesc): untyped =
+    let n = t.getType()[1]
+    if $n == "JSObj":
+      return ident"JSExternObjBase"
+    else:
+      let imp = n.getTypeImpl()
+      imp.expectKind(nnkObjectTy)
+      let base = imp[1][0]
+      result = newTree(nnkObjectTy,
+                      newEmptyNode(),
+                      newTree(nnkOfInherit,
+                              newTree(nnkBracketExpr, ident"JSExternObj", base)),
+                      newEmptyNode())
+
+  type
+    JSExternObj[T] = parent(T)
+
+  var a: JSExternObj[JSObj]
+  var d: JSExternObj[Document]
+  a = d
+  proc p(a: JSExternObj[JSObj]) =
+    discard
+  p(d)
+
+  assert JSExternObj[Document] is JSExternObj[HTMLElement]
+  assert JSExternObj[HTMLElement] is JSExternObj[JSObj]
+  assert JSExternObj[Document] is JSExternObj[JSObj]
+