feat: generic Array<T> + fix method lookup ambiguity

- Rewrite Std::Array as fully generic struct Array<T> with generic methods
- Use sizeof(T) for allocation/reallocation instead of hardcoded 8
- Fix method call lowering to lookup receiver type specifically instead of
  iterating all methodTable entries (prevents Array_Get matching for Box type)
- Add resolveTypeExpr typeSubst check for unknown named types
- Rename Array method parameters from 'arr' to 'self' for auto-registration

src/hir_lower.nim

@@ -227,7 +227,10 @@ proc resolveTypeExpr(ctx: var LowerCtx, te: TypeExpr): Type =
     of "float": return makeFloat64()
     of "float32": return makeFloat32()
     of "float64": return makeFloat64()
-    else: return makeNamed(te.typeName)
+    else:
+      if ctx.typeSubst.hasKey(te.typeName):
+        return ctx.typeSubst[te.typeName]
+      return makeNamed(te.typeName)
   of tekPointer: return makePointer(ctx.resolveTypeExpr(te.pointerPointee))
   of tekSlice: return makeSlice(ctx.resolveTypeExpr(te.sliceElement))
   else: return makeUnknown()
@@ -404,6 +407,15 @@ proc getReceiverTypeExpr(ctx: LowerCtx, expr: Expr): TypeExpr =
 
 proc generateMethodInstance(ctx: var LowerCtx, baseMethodName: string, typeArgs: seq[TypeExpr]): string
 
+proc findMethodEntry(ctx: LowerCtx, typeName: string): (string, seq[MethodInfo]) =
+  if ctx.methodTable.hasKey(typeName):
+    return (typeName, ctx.methodTable[typeName])
+  for i in countdown(typeName.len - 1, 1):
+    let prefix = typeName[0..<i]
+    if ctx.methodTable.hasKey(prefix):
+      return (prefix, ctx.methodTable[prefix])
+  return ("", @[])
+
 proc lowerExpr(ctx: var LowerCtx, expr: Expr): HirNode =
   if expr == nil: return nil
   let loc = expr.loc
@@ -442,9 +454,16 @@ proc lowerExpr(ctx: var LowerCtx, expr: Expr): HirNode =
     if expr.exprCallCallee.kind == ekField:
       let methodName = expr.exprCallCallee.exprFieldName
       let receiverExpr = expr.exprCallCallee.exprFieldObj
+      let receiverType = ctx.resolveExprType(receiverExpr)
+      var receiverTypeName = ""
+      if receiverType.kind == tkNamed:
+        receiverTypeName = receiverType.name
+      elif receiverType.kind == tkPointer and receiverType.inner.len > 0 and receiverType.inner[0].kind == tkNamed:
+        receiverTypeName = receiverType.inner[0].name
 
-      # Try to find the method in methodTable
-      for typeName, methods in ctx.methodTable:
+      # Look up method for receiver type specifically
+      let (typeName, methods) = ctx.findMethodEntry(receiverTypeName)
+      if typeName != "":
         for minfo in methods:
           if minfo.name == methodName:
             var calleeName = typeName & "_" & methodName
@@ -455,7 +474,6 @@ proc lowerExpr(ctx: var LowerCtx, expr: Expr): HirNode =
               calleeName = ctx.generateMethodInstance(calleeName, typeArgs)
             var args: seq[HirNode] = @[]
             let loweredReceiver = ctx.lowerExpr(receiverExpr)
-            let receiverType = ctx.resolveExprType(receiverExpr)
             # Auto-address if method expects pointer but receiver is value
             if minfo.params.len > 0 and minfo.params[0].kind == tkPointer and receiverType.kind != tkPointer:
               args.add(hirUnary(tkAmp, loweredReceiver, makePointer(receiverType), loc))

stdlib/Std/Array.bux

@@ -5,40 +5,40 @@ extern func bux_realloc(ptr: *void, size: uint) -> *void;
 extern func bux_free(ptr: *void);
 extern func bux_bounds_check(index: uint, len: uint);
 
-struct Array {
-    data: *int,
+struct Array<T> {
+    data: *T,
     len: uint,
     cap: uint,
 }
 
-func Array_New(cap: uint) -> Array {
-    let data = bux_alloc(cap * 8) as *int;
-    return Array { data: data, len: 0, cap: cap };
+func Array_New<T>(cap: uint) -> Array<T> {
+    let data = bux_alloc(cap * sizeof(T)) as *T;
+    return Array<T> { data: data, len: 0, cap: cap };
 }
 
-func Array_Push(arr: *Array, value: int) {
-    if arr.len >= arr.cap {
-        arr.cap = arr.cap * 2;
-        arr.data = bux_realloc(arr.data as *void, arr.cap * 8) as *int;
+func Array_Push<T>(self: *Array<T>, value: T) {
+    if self.len >= self.cap {
+        self.cap = self.cap * 2;
+        self.data = bux_realloc(self.data as *void, self.cap * sizeof(T)) as *T;
     }
-    arr.data[arr.len] = value;
-    arr.len = arr.len + 1;
+    self.data[self.len] = value;
+    self.len = self.len + 1;
 }
 
-func Array_Get(arr: *Array, index: uint) -> int {
-    bux_bounds_check(index, arr.len);
-    return arr.data[index];
+func Array_Get<T>(self: *Array<T>, index: uint) -> T {
+    bux_bounds_check(index, self.len);
+    return self.data[index];
 }
 
-func Array_Len(arr: *Array) -> uint {
-    return arr.len;
+func Array_Len<T>(self: *Array<T>) -> uint {
+    return self.len;
 }
 
-func Array_Free(arr: *Array) {
-    bux_free(arr.data as *void);
-    arr.data = null as *int;
-    arr.len = 0;
-    arr.cap = 0;
+func Array_Free<T>(self: *Array<T>) {
+    bux_free(self.data as *void);
+    self.data = null as *T;
+    self.len = 0;
+    self.cap = 0;
 }
 
 }