get class codegen to work ans compile

Author: AvarianKnight

src/NativeCodeGen.Cli/Program.cs

@@ -5,6 +5,7 @@
 using NativeCodeGen.Core.Parsing;
 using NativeCodeGen.Core.Registry;
 using NativeCodeGen.Core.Utilities;
+using NativeCodeGen.Core.Validation;
 using NativeCodeGen.Lua;
 using NativeCodeGen.TypeScript;
 
@@ -300,6 +301,9 @@ static async Task Validate(string input, bool strict)
         var allNatives = new ConcurrentBag<NativeDefinition>();
         var processedCount = 0;
 
+        // Create type validator for type resolution and validation
+        var typeValidator = new TypeValidator(enumRegistry, structRegistry);
+
         // Process files in parallel (CPU-bound parsing)
         Parallel.ForEach(mdxFiles, file =>
         {
@@ -316,12 +320,10 @@ static async Task Validate(string input, bool strict)
 
                 if (result.Value != null)
                 {
-                    // Resolve enum types for parameters and return type
-                    foreach (var param in result.Value.Parameters)
-                    {
-                        param.Type.ResolveEnumType(enumRegistry.GetBaseType);
-                    }
-                    result.Value.ReturnType.ResolveEnumType(enumRegistry.GetBaseType);
+                    // Validate all types in the native definition
+                    var validationErrors = typeValidator.ValidateNative(result.Value, file);
+                    foreach (var error in validationErrors)
+                        allErrors.Add(error);
 
                     allNatives.Add(result.Value);
                 }

src/NativeCodeGen.Core/Generation/ArgumentBuilder.cs

@@ -34,18 +34,23 @@ public static string GetArgumentExpression(NativeParameter param, ITypeMapper ty
         if (param.IsInOut)
         {
             var format = typeMapper.GetInitializedPointerFormat(param.Type);
-            // Handle types need to pass .handle (unless raw mode)
-            var value = typeMapper.IsHandleType(param.Type) && !rawMode ? $"{param.Name}.handle" : param.Name;
+            // Only class handles (with generated classes) have .handle property
+            var value = typeMapper.IsHandleType(param.Type) && TypeInfo.IsClassHandle(param.Type.Name) && !rawMode
+                ? $"{param.Name}.handle"
+                : param.Name;
             return string.Format(format, value);
         }
 
-        // Vector3 expansion (non-pointer Vector3) - components are floats
-        if (typeMapper.IsVector3(param.Type) && !param.Type.IsPointer)
+        // Vector expansion (non-pointer Vector2/Vector3/Vector4) - components are floats
+        if (param.Type.IsVector && !param.Type.IsPointer)
         {
-            if (useFloat)
-                return $"{f}({param.Name}.x), {f}({param.Name}.y), {f}({param.Name}.z)";
-            else
-                return $"{param.Name}.x, {param.Name}.y, {param.Name}.z";
+            return ExpandVector(param.Name, param.Type.VectorComponentCount, useFloat, f);
+        }
+
+        // Color expansion (non-pointer Color) - components are integers (r, g, b, a)
+        if (param.Type.Category == TypeCategory.Color && !param.Type.IsPointer)
+        {
+            return $"{param.Name}.r, {param.Name}.g, {param.Name}.b, {param.Name}.a";
         }
 
         // Struct buffer
@@ -54,8 +59,9 @@ public static string GetArgumentExpression(NativeParameter param, ITypeMapper ty
             return $"{param.Name}.buffer";
         }
 
-        // Handle types - in raw mode, just pass the number directly
-        if (typeMapper.IsHandleType(param.Type) && !rawMode)
+        // Handle types - only class handles have a .handle property
+        // Non-class handles (ScrHandle, Prompt) are just numbers
+        if (typeMapper.IsHandleType(param.Type) && TypeInfo.IsClassHandle(param.Type.Name) && !rawMode)
         {
             return $"{param.Name}.handle";
         }
@@ -70,12 +76,9 @@ public static string GetArgumentExpression(NativeParameter param, ITypeMapper ty
         }
 
         // Float type - wrap with f() to prevent bundler optimization
-        if (param.Type.Name is "float" or "f32" or "f64" or "double")
+        if (param.Type.IsFloat)
         {
-            if (useFloat)
-                return $"{f}({param.Name})";
-            else
-                return param.Name;
+            return useFloat ? $"{f}({param.Name})" : param.Name;
         }
 
         // Regular value
@@ -135,4 +138,15 @@ public static List<string> BuildInvokeArgsWithFirst(
 
         return args;
     }
+
+    /// <summary>
+    /// Expands a vector parameter to its component arguments (x, y, [z], [w]).
+    /// </summary>
+    private static string ExpandVector(string paramName, int componentCount, bool useFloat, string floatAlias)
+    {
+        var components = TypeInfo.VectorComponents[..componentCount];
+        return useFloat
+            ? string.Join(", ", components.Select(c => $"{floatAlias}({paramName}.{c})"))
+            : string.Join(", ", components.Select(c => $"{paramName}.{c}"));
+    }
 }

src/NativeCodeGen.Core/Generation/DocBuilder.cs

@@ -80,6 +80,15 @@ public void Build()
 /// </summary>
 public class JsDocBuilder : DocBuilder
 {
+    /// <summary>
+    /// Escapes text that could break JSDoc comments (e.g., */ would close the comment prematurely).
+    /// </summary>
+    private static string EscapeJsDoc(string text)
+    {
+        // Replace */ with *\/ to prevent closing the JSDoc comment
+        return text.Replace("*/", "*\\/");
+    }
+
     public override void Render(CodeBuilder cb)
     {
         if (IsEmpty) return;
@@ -88,7 +97,7 @@ public override void Render(CodeBuilder cb)
 
         foreach (var line in DescriptionLines)
         {
-            cb.AppendLine($" * {line}");
+            cb.AppendLine($" * {EscapeJsDoc(line)}");
         }
 
         if (DescriptionLines.Count > 0 && (Params.Count > 0 || Throws.Count > 0 || Return != null))
@@ -98,17 +107,17 @@ public override void Render(CodeBuilder cb)
 
         foreach (var param in Params)
         {
-            cb.AppendLine($" * @param {param.Name} {param.Description}");
+            cb.AppendLine($" * @param {param.Name} {EscapeJsDoc(param.Description)}");
         }
 
         foreach (var throws in Throws)
         {
-            cb.AppendLine($" * @throws {{{throws.Type}}} {throws.Description}");
+            cb.AppendLine($" * @throws {{{throws.Type}}} {EscapeJsDoc(throws.Description)}");
         }
 
         if (Return != null)
         {
-            var desc = string.IsNullOrEmpty(Return.Description) ? "" : $" {Return.Description}";
+            var desc = string.IsNullOrEmpty(Return.Description) ? "" : $" {EscapeJsDoc(Return.Description)}";
             cb.AppendLine($" * @returns{desc}");
         }
 

src/NativeCodeGen.Core/Generation/ILanguageEmitter.cs

@@ -54,10 +54,20 @@ public interface ILanguageEmitter
     // === Class Generation ===
 
     /// <summary>
-    /// Emits imports for handle types used in a namespace class.
+    /// Emits imports for handle types (class handles) used in a namespace class.
     /// </summary>
     void EmitHandleImports(CodeBuilder cb, IEnumerable<string> handleTypes);
 
+    /// <summary>
+    /// Emits imports for non-class handle types (ScrHandle, Prompt, FireId, etc.).
+    /// </summary>
+    void EmitNonClassHandleImports(CodeBuilder cb, IEnumerable<string> handleTypes);
+
+    /// <summary>
+    /// Emits imports for enum and struct types used in a class.
+    /// </summary>
+    void EmitTypeImports(CodeBuilder cb, IEnumerable<string> enumTypes, IEnumerable<string> structTypes);
+
     /// <summary>
     /// Emits the start of a class definition.
     /// </summary>
@@ -66,7 +76,7 @@ public interface ILanguageEmitter
     /// <summary>
     /// Emits the end of a class definition.
     /// </summary>
-    void EmitClassEnd(CodeBuilder cb, string className);
+    void EmitClassEnd(CodeBuilder cb, string className, ClassKind kind);
 
     /// <summary>
     /// Emits a constructor for a handle-based class.
@@ -81,12 +91,17 @@ public interface ILanguageEmitter
     /// <summary>
     /// Emits a constructor for a task class (takes entity).
     /// </summary>
-    void EmitTaskConstructor(CodeBuilder cb, string className, string entityType);
+    void EmitTaskConstructor(CodeBuilder cb, string className, string entityType, string? baseClass);
 
     /// <summary>
     /// Emits a constructor for a model class (takes hash).
     /// </summary>
-    void EmitModelConstructor(CodeBuilder cb, string className);
+    void EmitModelConstructor(CodeBuilder cb, string className, string? baseClass);
+
+    /// <summary>
+    /// Emits a constructor for a weapon class (takes ped).
+    /// </summary>
+    void EmitWeaponConstructor(CodeBuilder cb, string className);
 
     // === Method Generation ===
 
@@ -170,6 +185,8 @@ public enum ClassKind
     Task,
     /// <summary>Model class that wraps a hash</summary>
     Model,
+    /// <summary>Weapon class that wraps a ped</summary>
+    Weapon,
     /// <summary>Namespace utility class with static methods</summary>
     Namespace
 }

src/NativeCodeGen.Core/Generation/NativeClassifier.cs

@@ -1,3 +1,4 @@
+using System.Collections.Frozen;
 using NativeCodeGen.Core.Models;
 using NativeCodeGen.Core.Parsing;
 
@@ -9,50 +10,63 @@ namespace NativeCodeGen.Core.Generation;
 /// </summary>
 public class NativeClassifier
 {
-    public static readonly Dictionary<string, string?> HandleClassHierarchy = new()
-    {
-        ["Entity"] = null,
-        ["Ped"] = "Entity",
-        ["Vehicle"] = "Entity",
-        ["Prop"] = "Entity",
-        ["Pickup"] = null,
-        ["Player"] = null,
-        ["Cam"] = null,
-        ["Blip"] = null,
-        ["Interior"] = null,
-        ["FireId"] = null,
-        ["AnimScene"] = null,
-        ["ItemSet"] = null,
-        ["PersChar"] = null,
-        ["PopZone"] = null,
-        ["PropSet"] = null,
-        ["Volume"] = null,
-        ["PedGroup"] = null,
-        ["BaseTask"] = null,
-        ["PedTask"] = "BaseTask",
-        ["VehicleTask"] = "BaseTask",
-        ["BaseModel"] = null,
-        ["PedModel"] = "BaseModel",
-        ["VehicleModel"] = "BaseModel",
-        ["WeaponModel"] = "BaseModel"
-    };
-
-    public static readonly Dictionary<string, string> TypeToNamespace = new()
-    {
-        ["Entity"] = "ENTITY",
-        ["Ped"] = "PED",
-        ["Vehicle"] = "VEHICLE",
-        ["Object"] = "OBJECT",
-        ["Pickup"] = "OBJECT",
-        ["Player"] = "PLAYER",
-        ["Cam"] = "CAM",
-        ["Blip"] = "HUD",
-        ["Interior"] = "INTERIOR"
-    };
-
-    public static readonly HashSet<string> TaskClasses = new() { "BaseTask", "PedTask", "VehicleTask" };
-    public static readonly HashSet<string> ModelClasses = new() { "BaseModel", "PedModel", "VehicleModel", "WeaponModel" };
-    public static readonly HashSet<string> EntitySubclasses = new() { "Ped", "Vehicle", "Object", "Prop" };
+    public static readonly FrozenDictionary<string, string?> HandleClassHierarchy =
+        new Dictionary<string, string?>
+        {
+            ["Entity"] = null,
+            ["Ped"] = "Entity",
+            ["Vehicle"] = "Entity",
+            ["Prop"] = "Entity",
+            ["Pickup"] = null,
+            ["Player"] = null,
+            ["Cam"] = null,
+            ["Blip"] = null,
+            ["Interior"] = null,
+            ["FireId"] = null,
+            ["AnimScene"] = null,
+            ["ItemSet"] = null,
+            ["PersChar"] = null,
+            ["PopZone"] = null,
+            ["PropSet"] = null,
+            ["Volume"] = null,
+            ["PedGroup"] = null,
+            ["BaseTask"] = null,
+            ["PedTask"] = "BaseTask",
+            ["VehicleTask"] = "BaseTask",
+            ["BaseModel"] = null,
+            ["PedModel"] = "BaseModel",
+            ["VehicleModel"] = "BaseModel",
+            ["WeaponModel"] = "BaseModel",
+            ["Weapon"] = null
+        }.ToFrozenDictionary(StringComparer.Ordinal);
+
+    public static readonly FrozenDictionary<string, string> TypeToNamespace =
+        new Dictionary<string, string>
+        {
+            ["Entity"] = "ENTITY",
+            ["Ped"] = "PED",
+            ["Vehicle"] = "VEHICLE",
+            ["Object"] = "OBJECT",
+            ["Pickup"] = "OBJECT",
+            ["Player"] = "PLAYER",
+            ["Cam"] = "CAM",
+            ["Blip"] = "HUD",
+            ["Interior"] = "INTERIOR",
+            ["AnimScene"] = "ANIMSCENE",
+            ["ItemSet"] = "ITEMSET",
+            ["PersChar"] = "PERSCHAR",
+            ["PropSet"] = "PROPSET",
+            ["Volume"] = "VOLUME"
+        }.ToFrozenDictionary(StringComparer.Ordinal);
+
+    public static readonly FrozenSet<string> TaskClasses =
+        new HashSet<string> { "BaseTask", "PedTask", "VehicleTask" }.ToFrozenSet(StringComparer.Ordinal);
+
+    public static readonly FrozenSet<string> ModelClasses =
+        new HashSet<string> { "BaseModel", "PedModel", "VehicleModel", "WeaponModel" }.ToFrozenSet(StringComparer.Ordinal);
+
+    public static readonly FrozenSet<string> EntitySubclasses =
+        new HashSet<string> { "Ped", "Vehicle", "Object", "Prop" }.ToFrozenSet(StringComparer.Ordinal);
 
     public ClassifiedNatives Classify(NativeDatabase db)
     {
@@ -65,27 +79,29 @@ public ClassifiedNatives Classify(NativeDatabase db)
                 var targetClass = DetermineTargetClass(native);
                 if (targetClass != null)
                 {
-                    if (!result.HandleClasses.ContainsKey(targetClass))
+                    if (!result.HandleClasses.TryGetValue(targetClass, out var list))
                     {
-                        result.HandleClasses[targetClass] = new List<NativeDefinition>();
+                        list = new List<NativeDefinition>();
+                        result.HandleClasses[targetClass] = list;
                     }
-                    result.HandleClasses[targetClass].Add(native);
+                    list.Add(native);
                 }
                 else
                 {
-                    if (!result.NamespaceClasses.ContainsKey(ns.Name))
+                    if (!result.NamespaceClasses.TryGetValue(ns.Name, out var list))
                     {
-                        result.NamespaceClasses[ns.Name] = new List<NativeDefinition>();
+                        list = new List<NativeDefinition>();
+                        result.NamespaceClasses[ns.Name] = list;
                     }
-                    result.NamespaceClasses[ns.Name].Add(native);
+                    list.Add(native);
                 }
             }
         }
 
         return result;
     }
 
-    private string? DetermineTargetClass(NativeDefinition native)
+    private static string? DetermineTargetClass(NativeDefinition native)
     {
         if (native.Parameters.Count == 0)
             return null;
@@ -113,6 +129,11 @@ public ClassifiedNatives Classify(NativeDatabase db)
                 };
             }
 
+            if (native.Namespace.Equals("WEAPON", StringComparison.OrdinalIgnoreCase) && handleType == "Ped")
+            {
+                return "Weapon";
+            }
+
             if (TypeToNamespace.TryGetValue(handleType, out var expectedNs))
             {
                 if (native.Namespace.Equals(expectedNs, StringComparison.OrdinalIgnoreCase))
@@ -145,6 +166,7 @@ public ClassifiedNatives Classify(NativeDatabase db)
 
     public static bool IsTaskClass(string className) => TaskClasses.Contains(className);
     public static bool IsModelClass(string className) => ModelClasses.Contains(className);
+    public static bool IsWeaponClass(string className) => className == "Weapon";
 
     public static string GetTaskEntityType(string className) => className switch
     {