feat: Add AOT support for returning Class types and enhance method call generation with object type handling

Author: edusperoni

NativeScript/runtime/NativeScriptAOT.h

@@ -38,6 +38,7 @@ void __ns_aot_return_bool(NSAOTCallInfo info, BOOL value);
 void __ns_aot_return_double(NSAOTCallInfo info, double value);
 void __ns_aot_return_struct(NSAOTCallInfo info, const void* data,
                             const char* structName);
+void __ns_aot_return_class(NSAOTCallInfo info, Class value);
 
 // --- Exception handling ---
 void __ns_aot_throw_exception(NSAOTCallInfo info, id exception);

NativeScript/runtime/NativeScriptAOTBridge.mm

@@ -261,6 +261,27 @@ void __ns_aot_return_struct(NSAOTCallInfo _info, const void* data, const char* s
   info.GetReturnValue().Set(result);
 }
 
+void __ns_aot_return_class(NSAOTCallInfo _info, Class value) {
+  auto& info = *reinterpret_cast<const FunctionCallbackInfo<Value>*>(_info);
+  Isolate* isolate = info.GetIsolate();
+  if (value == nil) {
+    info.GetReturnValue().Set(Null(isolate));
+    return;
+  }
+  auto cache = tns::Caches::Get(isolate);
+  Class klass = value;
+  while (klass != nil) {
+    std::string name = class_getName(klass);
+    auto it = cache->CtorFuncs.find(name);
+    if (it != cache->CtorFuncs.end()) {
+      info.GetReturnValue().Set(it->second->Get(isolate));
+      return;
+    }
+    klass = class_getSuperclass(klass);
+  }
+  info.GetReturnValue().Set(Null(isolate));
+}
+
 void __ns_aot_throw_exception(NSAOTCallInfo _info, id exception) {
   auto& info = *reinterpret_cast<const FunctionCallbackInfo<Value>*>(_info);
   Isolate* isolate = info.GetIsolate();

scripts/generate-aot.py

@@ -175,9 +175,9 @@ def method_stub_name(cls, sel):
     return f"AOT_{cls}_{sanitize_selector(sel)}"
 
 
-def build_objc_call(cls, sel, args, target="target", is_static=False, class_var=None, ret=None):
+def build_objc_call(cls, sel, args, target="target", is_static=False, class_var=None, ret=None, object_types=frozenset()):
     if class_var:
-        return _build_msgsend_call(class_var if is_static else target, sel, ret or "id", args)
+        return _build_msgsend_call(class_var if is_static else target, sel, ret or "id", args, object_types)
     if is_static:
         receiver = cls
     else:
@@ -189,23 +189,27 @@ def build_objc_call(cls, sel, args, target="target", is_static=False, class_var=
     return f"[{receiver} {expr}]"
 
 
-def _c_type(t):
-    return t if t not in TYPES else TYPES[t]["c_type"]
+def _c_type(t, object_types=frozenset()):
+    if t in TYPES:
+        return TYPES[t]["c_type"]
+    if t in object_types:
+        return "id"
+    return t
 
 
-def _build_msgsend_call(receiver, sel, ret, args):
-    c_ret = _c_type(ret)
-    c_args = ["id", "SEL"] + [_c_type(a) for a in args]
+def _build_msgsend_call(receiver, sel, ret, args, object_types=frozenset()):
+    c_ret = _c_type(ret, object_types)
+    c_args = ["id", "SEL"] + [_c_type(a, object_types) for a in args]
     cast = f"(({c_ret}(*)({', '.join(c_args)}))objc_msgSend)"
     arg_str = ", ".join(f"arg{i}" for i in range(len(args)))
     suffix = f", {arg_str}" if arg_str else ""
     return f"{cast}((id){receiver}, @selector({sel}){suffix})"
 
 
-def build_super_call(cls, sel, ret, args, struct_tag=False):
+def build_super_call(cls, sel, ret, args, struct_tag=False, object_types=frozenset()):
     prefix = "struct " if struct_tag else ""
-    c_ret = _c_type(ret)
-    c_args = [f"{prefix}objc_super*", "SEL"] + [_c_type(a) for a in args]
+    c_ret = _c_type(ret, object_types)
+    c_args = [f"{prefix}objc_super*", "SEL"] + [_c_type(a, object_types) for a in args]
     cast = f"(({c_ret}(*)({', '.join(c_args)}))"
     arg_str = ", ".join(f"arg{i}" for i in range(len(args)))
     suffix = f", {arg_str}" if arg_str else ""
@@ -715,28 +719,32 @@ def generate(config_path, output_dir):
     "NSString": "__ns_aot_return_string(info, {result})",
     "instancetype": "__ns_aot_return_object(info, {result})",
     "BOOL": "__ns_aot_return_bool(info, {result})",
-    "Class": "__ns_aot_return_id(info, (id){result})",
+    "Class": "__ns_aot_return_class(info, {result})",
 }
 
 
-def external_arg_expr(arg_type, i):
+def external_arg_expr(arg_type, i, object_types=frozenset()):
     if arg_type in EXTERNAL_ARG:
         return EXTERNAL_ARG[arg_type].format(i=i)
+    if arg_type in object_types:
+        return EXTERNAL_ARG["id"].format(i=i)
     if arg_type in TYPES:
         return f"({TYPES[arg_type]['c_type']})__ns_aot_arg_double(info, {i})"
     return None
 
 
-def is_struct_type(ret_type):
-    return ret_type not in TYPES and ret_type not in EXTERNAL_RET
+def is_struct_type(ret_type, object_types=frozenset()):
+    return ret_type not in TYPES and ret_type not in EXTERNAL_RET and ret_type not in object_types
 
 
-def external_ret_call(ret_type, result_var):
+def external_ret_call(ret_type, result_var, object_types=frozenset()):
     if ret_type == "void":
         return None
     if ret_type in EXTERNAL_RET:
         return EXTERNAL_RET[ret_type].format(result=result_var)
-    if is_struct_type(ret_type):
+    if ret_type in object_types:
+        return EXTERNAL_RET["id"].format(result=result_var)
+    if is_struct_type(ret_type, object_types):
         return f'__ns_aot_return_struct(info, &{result_var}, "{ret_type}")'
     return f"__ns_aot_return_double(info, (double){result_var})"
 
@@ -745,18 +753,18 @@ def class_var_name(cls):
     return f"_cls_{cls}"
 
 
-def gen_external_method_stub(method, swift_classes):
+def gen_external_method_stub(method, object_types=frozenset(), protocol_types=frozenset(), swift_classes=frozenset()):
     cls = method["class"]
     sel = method["selector"]
     ret = method["ret"]
     args = method["args"]
     is_static = method.get("static", False)
     name = method_stub_name(cls, sel)
     is_void = ret == "void"
-    is_struct = is_struct_type(ret)
-    c_ret_type = ret if is_struct else TYPES[ret]["c_type"]
-    is_swift = cls in swift_classes
-    cvar = class_var_name(cls) if is_swift else None
+    is_obj = ret in object_types
+    is_struct = is_struct_type(ret, object_types)
+    c_ret_type = "id" if is_obj else (ret if is_struct else TYPES[ret]["c_type"])
+    needs_msgsend = cls in protocol_types or cls in swift_classes
 
     sign = "+" if is_static else "-"
     lines = []
@@ -772,9 +780,9 @@ def gen_external_method_stub(method, swift_classes):
         lines.append("    if (target == nil) return;")
 
     for i, arg in enumerate(args):
-        expr = external_arg_expr(arg, i)
+        expr = external_arg_expr(arg, i, object_types)
         if expr is not None:
-            c_type = TYPES[arg]['c_type'] if arg in TYPES else arg
+            c_type = "id" if arg in object_types else (TYPES[arg]['c_type'] if arg in TYPES else arg)
             lines.append(f"    {c_type} arg{i} = {expr};")
         else:
             lines.append(f"    {arg} arg{i};")
@@ -785,14 +793,17 @@ def gen_external_method_stub(method, swift_classes):
         lines.append(f"    {c_ret_type} result;")
 
     if is_static:
-        static_call = _build_msgsend_call("_cls", sel, ret, args)
+        static_call = _build_msgsend_call("_cls", sel, ret, args, object_types)
         if is_void:
             lines.append(f"    {static_call};")
         else:
             lines.append(f"    result = {static_call};")
     else:
-        objc_call = build_objc_call(cls, sel, args, is_static=False, class_var=cvar, ret=ret)
-        super_call = build_super_call(cls, sel, ret, args, struct_tag=True)
+        if needs_msgsend:
+            objc_call = _build_msgsend_call("target", sel, ret, args, object_types)
+        else:
+            objc_call = build_objc_call(cls, sel, args, is_static=False, ret=ret, object_types=object_types)
+        super_call = build_super_call(cls, sel, ret, args, struct_tag=True, object_types=object_types)
         lines.append("    if (callSuper) {")
         lines.append("        struct objc_super sup = {target, class_getSuperclass(object_getClass(target))};")
         if is_void:
@@ -806,7 +817,7 @@ def gen_external_method_stub(method, swift_classes):
             lines.append(f"        result = {objc_call};")
         lines.append("    }")
 
-    ret_call = external_ret_call(ret, "result")
+    ret_call = external_ret_call(ret, "result", object_types)
     if ret_call:
         lines.append(f"    {ret_call};")
 
@@ -878,6 +889,8 @@ def generate_external(config_path, output_path):
     methods = _dedup_methods(config.get("methods", []))
     imports = config.get("imports", [])
     swift_classes = set(config.get("swiftClasses", []))
+    object_types = frozenset(config.get("objectTypes", []))
+    protocol_types = frozenset(config.get("protocolTypes", []))
 
     extra_imports = [i if i.startswith("#") else f"#import <{i}/{i}.h>" for i in imports]
     if extra_imports:
@@ -890,7 +903,7 @@ def generate_external(config_path, output_path):
         parts.append("")
 
     for m in methods:
-        parts.append(gen_external_method_stub(m, swift_classes))
+        parts.append(gen_external_method_stub(m, object_types, protocol_types, swift_classes))
         parts.append("")
 
     parts.append(gen_external_registration(methods, swift_classes))

scripts/resolve-aot-imports.py

@@ -210,25 +210,74 @@ def parse_json_file(json_path):
     return module
 
 
+def _collect_protocol_names_json(json_path):
+    """Extract Protocol names from a metadata JSON file."""
+    names = set()
+    with open(json_path) as f:
+        data = json.load(f)
+    for item in data.get("Items", []):
+        if item.get("Type") == "Protocol":
+            names.add(item.get("Name", ""))
+            js = item.get("JsName", "")
+            if js:
+                names.add(js)
+    names.discard("")
+    return names
+
+
+def _collect_protocol_names_yaml(yaml_path):
+    """Extract Protocol names from a metadata YAML file."""
+    names = set()
+    current_name = None
+    current_js_name = None
+    with open(yaml_path, errors="replace") as f:
+        for line in f:
+            m = re.match(r"^  - Name:\s+(.+)$", line)
+            if m:
+                current_name = m.group(1).strip().strip("'\"")
+                current_js_name = None
+                continue
+            if current_name is not None:
+                m = re.match(r"^    JsName:\s+(.+)$", line)
+                if m:
+                    current_js_name = m.group(1).strip().strip("'\"")
+                    continue
+                m = re.match(r"^    Type:\s+(\S+)", line)
+                if m:
+                    if m.group(1) == "Protocol":
+                        names.add(current_name)
+                        if current_js_name:
+                            names.add(current_js_name)
+                    current_name = None
+                    current_js_name = None
+                    continue
+    return names
+
+
 def scan_metadata_dir(metadata_dir):
     """Build lookup maps from all JSON or YAML files.
 
     Prefers JSON files when present; falls back to YAML.
 
     Returns:
+        (name_to_entries, protocol_names)
         name_to_entries: dict mapping Name or JsName → [(ModuleInfo, InterfaceInfo), ...]
+        protocol_names: set of protocol type names
     """
     name_to_entries = {}
+    protocol_names = set()
 
     json_files = sorted(glob.glob(os.path.join(metadata_dir, "*.json")))
     yaml_files = sorted(glob.glob(os.path.join(metadata_dir, "*.yaml")))
 
     if json_files:
         files_and_parser = [(p, parse_json_file) for p in json_files]
+        proto_collector = _collect_protocol_names_json
     elif yaml_files:
         files_and_parser = [(p, parse_yaml) for p in yaml_files]
+        proto_collector = _collect_protocol_names_yaml
     else:
-        return name_to_entries
+        return name_to_entries, protocol_names
 
     for path, parser in files_and_parser:
         if os.path.basename(path).startswith("metadata-generation"):
@@ -241,8 +290,9 @@ def scan_metadata_dir(metadata_dir):
             name_to_entries.setdefault(iface.name, []).append(entry)
             if iface.js_name != iface.name:
                 name_to_entries.setdefault(iface.js_name, []).append(entry)
+        protocol_names.update(proto_collector(path))
 
-    return name_to_entries
+    return name_to_entries, protocol_names
 
 
 def pick_module(cls, entries):
@@ -297,6 +347,22 @@ def import_for_swift(iface):
     return None
 
 
+def import_for_framework(mod, iface):
+    """Derive the framework import for an interface.
+
+    For non-system frameworks, uses the specific header from the Filename field
+    (e.g. #import <TNSListView/TKCollectionView.h>) since they may not have an
+    umbrella header. System frameworks always use the umbrella header.
+    """
+    if mod.is_system:
+        return f"#import <{mod.name}/{mod.name}.h>"
+    if iface.filename:
+        m = re.search(r'\.framework/Headers/(.+\.h)$', iface.filename)
+        if m:
+            return f"#import <{mod.name}/{m.group(1)}>"
+    return f"#import <{mod.name}/{mod.name}.h>"
+
+
 def resolve(config_path, yaml_dir):
     with open(config_path) as f:
         config = json.load(f)
@@ -320,7 +386,7 @@ def resolve(config_path, yaml_dir):
         return
 
     print(f"Scanning {yaml_dir} for {len(class_names)} classes...")
-    name_to_entries = scan_metadata_dir(yaml_dir)
+    name_to_entries, protocol_names = scan_metadata_dir(yaml_dir)
 
     needed_imports = set()
     unresolved = []
@@ -344,8 +410,9 @@ def resolve(config_path, yaml_dir):
         elif mod.is_system and not mod.is_framework:
             print(f"  {cls} → {mod.name} (non-framework system, covered by Foundation)")
         elif mod.is_framework:
-            needed_imports.add(f"#import <{mod.name}/{mod.name}.h>")
-            print(f"  {cls} → {mod.name}")
+            imp = import_for_framework(mod, iface)
+            needed_imports.add(imp)
+            print(f"  {cls} → {mod.name} ({imp})")
         else:
             needed_imports.add(f"#import <{mod.name}.h>")
             print(f"  {cls} → {mod.name} (non-framework)")
@@ -355,6 +422,30 @@ def resolve(config_path, yaml_dir):
         for cls in unresolved:
             print(f"    - {cls}")
 
+    # Detect ObjC object types used in args/ret that aren't primitives.
+    # Types found as Interface in metadata are objects (passed as id),
+    # everything else unknown is treated as a struct by the generator.
+    PRIMITIVE_TYPES = {
+        "void", "BOOL", "id", "instancetype", "NSString", "SEL", "Class",
+        "int", "uint", "long", "ulong", "longlong", "ulonglong",
+        "float", "double", "char", "uchar", "short", "ushort",
+    }
+    all_types = set()
+    for m in methods:
+        all_types.add(m["ret"])
+        all_types.update(m["args"])
+    unknown_types = all_types - PRIMITIVE_TYPES
+    object_types = set()
+    for t in sorted(unknown_types):
+        if t in name_to_entries:
+            object_types.add(t)
+    if object_types:
+        print(f"\n  Object types (not structs): {', '.join(sorted(object_types))}")
+
+    used_protocols = set(c for c in class_names if c in protocol_names)
+    if used_protocols:
+        print(f"\n  Protocol types (use objc_msgSend): {', '.join(sorted(used_protocols))}")
+
     # Detect static methods
     changed = False
     static_changes = []
@@ -393,6 +484,24 @@ def resolve(config_path, yaml_dir):
             del config["swiftClasses"]
         changed = True
 
+    obj_list = sorted(object_types)
+    existing_obj = sorted(config.get("objectTypes", []))
+    if obj_list != existing_obj:
+        if obj_list:
+            config["objectTypes"] = obj_list
+        elif "objectTypes" in config:
+            del config["objectTypes"]
+        changed = True
+
+    proto_list = sorted(used_protocols)
+    existing_proto = sorted(config.get("protocolTypes", []))
+    if proto_list != existing_proto:
+        if proto_list:
+            config["protocolTypes"] = proto_list
+        elif "protocolTypes" in config:
+            del config["protocolTypes"]
+        changed = True
+
     if not changed:
         print(f"\n  Config already up to date.")
         return