fix compiler bugs

Author: chaokunyang

compiler/README.md

@@ -345,7 +345,7 @@ Generates structs with:
 
 ```go
 type Cat struct {
-    Friend *Dog              `fory:"trackRef"`
+    Friend *Dog              `fory:"ref"`
     Name   *string           `fory:"nullable"`
     Tags   []string
 }
@@ -362,7 +362,7 @@ Generates structs with:
 ```rust
 #[derive(ForyObject, Debug, Clone, PartialEq, Default)]
 pub struct Cat {
-    pub friend: Rc<Dog>,
+    pub friend: Arc<Dog>,
     #[fory(nullable = true)]
     pub name: Option<String>,
     pub tags: Vec<String>,

compiler/fory_compiler/generators/cpp.py

@@ -165,7 +165,14 @@ def generate_header(self) -> GeneratedFile:
     def collect_message_includes(self, message: Message, includes: Set[str]):
         """Collect includes for a message and its nested types recursively."""
         for field in message.fields:
-            self.collect_includes(field.field_type, field.optional, field.ref, includes)
+            self.collect_includes(
+                field.field_type,
+                field.optional,
+                field.ref,
+                includes,
+                field.element_optional,
+                field.element_ref,
+            )
         for nested_msg in message.nested_messages:
             self.collect_message_includes(nested_msg, includes)
 
@@ -236,6 +243,8 @@ def generate_message(
                 field.field_type,
                 field.optional,
                 field.ref,
+                field.element_optional,
+                field.element_ref,
                 lineage,
             )
             field_name = self.to_snake_case(field.name)
@@ -258,8 +267,11 @@ def generate_message(
         lines.append("};")
 
         # FORY_STRUCT macro (must stay in type namespace for ADL)
-        field_names = ", ".join(self.to_snake_case(f.name) for f in message.fields)
-        lines.append(f"FORY_STRUCT({type_name}, {field_names});")
+        if message.fields:
+            field_names = ", ".join(self.to_snake_case(f.name) for f in message.fields)
+            lines.append(f"FORY_STRUCT({type_name}, {field_names});")
+        else:
+            lines.append(f"FORY_STRUCT({type_name});")
 
         return lines
 
@@ -309,6 +321,8 @@ def generate_type(
         field_type: FieldType,
         nullable: bool = False,
         ref: bool = False,
+        element_optional: bool = False,
+        element_ref: bool = False,
         parent_stack: Optional[List[Message]] = None,
     ) -> str:
         """Generate C++ type string."""
@@ -321,25 +335,40 @@ def generate_type(
         elif isinstance(field_type, NamedType):
             type_name = self.resolve_nested_type_name(field_type.name, parent_stack)
             if ref:
-                return f"std::shared_ptr<{type_name}>"
+                type_name = f"std::shared_ptr<{type_name}>"
             if nullable:
-                return f"std::optional<{type_name}>"
+                type_name = f"std::optional<{type_name}>"
             return type_name
 
         elif isinstance(field_type, ListType):
             element_type = self.generate_type(
-                field_type.element_type, False, False, parent_stack
+                field_type.element_type,
+                element_optional,
+                element_ref,
+                False,
+                False,
+                parent_stack,
             )
-            return f"std::vector<{element_type}>"
+            list_type = f"std::vector<{element_type}>"
+            if ref:
+                list_type = f"std::shared_ptr<{list_type}>"
+            if nullable:
+                list_type = f"std::optional<{list_type}>"
+            return list_type
 
         elif isinstance(field_type, MapType):
             key_type = self.generate_type(
-                field_type.key_type, False, False, parent_stack
+                field_type.key_type, False, False, False, False, parent_stack
             )
             value_type = self.generate_type(
-                field_type.value_type, False, False, parent_stack
+                field_type.value_type, False, False, False, False, parent_stack
             )
-            return f"std::map<{key_type}, {value_type}>"
+            map_type = f"std::map<{key_type}, {value_type}>"
+            if ref:
+                map_type = f"std::shared_ptr<{map_type}>"
+            if nullable:
+                map_type = f"std::optional<{map_type}>"
+            return map_type
 
         return "void*"
 
@@ -363,7 +392,13 @@ def resolve_nested_type_name(
         return type_name
 
     def collect_includes(
-        self, field_type: FieldType, nullable: bool, ref: bool, includes: Set[str]
+        self,
+        field_type: FieldType,
+        nullable: bool,
+        ref: bool,
+        includes: Set[str],
+        element_optional: bool = False,
+        element_ref: bool = False,
     ):
         """Collect required includes for a field type."""
         if nullable:
@@ -381,7 +416,12 @@ def collect_includes(
 
         elif isinstance(field_type, ListType):
             includes.add("<vector>")
-            self.collect_includes(field_type.element_type, False, False, includes)
+            self.collect_includes(
+                field_type.element_type,
+                element_optional,
+                element_ref,
+                includes,
+            )
 
         elif isinstance(field_type, MapType):
             includes.add("<map>")

compiler/fory_compiler/generators/go.py

@@ -244,6 +244,8 @@ def generate_field(
             field.field_type,
             field.optional,
             field.ref,
+            field.element_optional,
+            field.element_ref,
             parent_stack,
         )
         field_name = self.to_pascal_case(
@@ -252,10 +254,29 @@ def generate_field(
 
         # Build fory tag
         tags = []
+        is_list = isinstance(field.field_type, ListType)
+        nullable_tag: Optional[bool] = None
+        ref_tag: Optional[bool] = None
+
         if field.optional:
-            tags.append("nullable")
+            nullable_tag = True
+        elif is_list and (field.ref or field.element_optional or field.element_ref):
+            nullable_tag = False
+
         if field.ref:
-            tags.append("trackRef")
+            ref_tag = True
+        elif is_list and field.element_ref:
+            ref_tag = False
+
+        if nullable_tag is True:
+            tags.append("nullable")
+        elif nullable_tag is False:
+            tags.append("nullable=false")
+
+        if ref_tag is True:
+            tags.append("ref")
+        elif ref_tag is False:
+            tags.append("ref=false")
 
         if tags:
             tag_str = ",".join(tags)
@@ -270,6 +291,8 @@ def generate_type(
         field_type: FieldType,
         nullable: bool = False,
         ref: bool = False,
+        element_optional: bool = False,
+        element_ref: bool = False,
         parent_stack: Optional[List[Message]] = None,
     ) -> str:
         """Generate Go type string."""
@@ -287,16 +310,31 @@ def generate_type(
 
         elif isinstance(field_type, ListType):
             element_type = self.generate_type(
-                field_type.element_type, False, False, parent_stack
+                field_type.element_type,
+                element_optional,
+                element_ref,
+                False,
+                False,
+                parent_stack,
             )
             return f"[]{element_type}"
 
         elif isinstance(field_type, MapType):
             key_type = self.generate_type(
-                field_type.key_type, False, False, parent_stack
+                field_type.key_type,
+                False,
+                False,
+                False,
+                False,
+                parent_stack,
             )
             value_type = self.generate_type(
-                field_type.value_type, False, False, parent_stack
+                field_type.value_type,
+                False,
+                False,
+                False,
+                False,
+                parent_stack,
             )
             return f"map[{key_type}]{value_type}"
 

compiler/fory_compiler/generators/java.py

@@ -322,7 +322,7 @@ def generate_outer_class_file(self, outer_classname: str) -> GeneratedFile:
     def collect_message_imports(self, message: Message, imports: Set[str]):
         """Collect imports for a message and all its nested types recursively."""
         for field in message.fields:
-            self.collect_imports(field.field_type, imports)
+            self.collect_field_imports(field, imports)
             if field.optional or field.ref:
                 imports.add("org.apache.fory.annotation.ForyField")
 
@@ -422,7 +422,12 @@ def generate_field(self, field: Field) -> List[str]:
             lines.append(f"@ForyField({', '.join(annotations)})")
 
         # Field type
-        java_type = self.generate_type(field.field_type, field.optional)
+        java_type = self.generate_type(
+            field.field_type,
+            field.optional,
+            field.element_optional,
+            field.element_ref,
+        )
 
         lines.append(f"private {java_type} {self.to_camel_case(field.name)};")
         lines.append("")
@@ -432,7 +437,12 @@ def generate_field(self, field: Field) -> List[str]:
     def generate_getter_setter(self, field: Field) -> List[str]:
         """Generate getter and setter for a field."""
         lines = []
-        java_type = self.generate_type(field.field_type, field.optional)
+        java_type = self.generate_type(
+            field.field_type,
+            field.optional,
+            field.element_optional,
+            field.element_ref,
+        )
         field_name = self.to_camel_case(field.name)
         pascal_name = self.to_pascal_case(field.name)
 
@@ -450,7 +460,13 @@ def generate_getter_setter(self, field: Field) -> List[str]:
 
         return lines
 
-    def generate_type(self, field_type: FieldType, nullable: bool = False) -> str:
+    def generate_type(
+        self,
+        field_type: FieldType,
+        nullable: bool = False,
+        element_optional: bool = False,
+        element_ref: bool = False,
+    ) -> str:
         """Generate Java type string."""
         if isinstance(field_type, PrimitiveType):
             if nullable and field_type.kind in self.BOXED_MAP:
@@ -463,7 +479,11 @@ def generate_type(self, field_type: FieldType, nullable: bool = False) -> str:
         elif isinstance(field_type, ListType):
             # Use primitive arrays for numeric types
             if isinstance(field_type.element_type, PrimitiveType):
-                if field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP:
+                if (
+                    field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP
+                    and not element_optional
+                    and not element_ref
+                ):
                     return self.PRIMITIVE_ARRAY_MAP[field_type.element_type.kind]
             element_type = self.generate_type(field_type.element_type, True)
             return f"List<{element_type}>"
@@ -475,7 +495,13 @@ def generate_type(self, field_type: FieldType, nullable: bool = False) -> str:
 
         return "Object"
 
-    def collect_imports(self, field_type: FieldType, imports: Set[str]):
+    def collect_type_imports(
+        self,
+        field_type: FieldType,
+        imports: Set[str],
+        element_optional: bool = False,
+        element_ref: bool = False,
+    ):
         """Collect required imports for a field type."""
         if isinstance(field_type, PrimitiveType):
             if field_type.kind == PrimitiveKind.DATE:
@@ -486,26 +512,37 @@ def collect_imports(self, field_type: FieldType, imports: Set[str]):
         elif isinstance(field_type, ListType):
             # Primitive arrays don't need List import
             if isinstance(field_type.element_type, PrimitiveType):
-                if field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP:
+                if (
+                    field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP
+                    and not element_optional
+                    and not element_ref
+                ):
                     return  # No import needed for primitive arrays
             imports.add("java.util.List")
-            self.collect_imports(field_type.element_type, imports)
+            self.collect_type_imports(field_type.element_type, imports)
 
         elif isinstance(field_type, MapType):
             imports.add("java.util.Map")
-            self.collect_imports(field_type.key_type, imports)
-            self.collect_imports(field_type.value_type, imports)
+            self.collect_type_imports(field_type.key_type, imports)
+            self.collect_type_imports(field_type.value_type, imports)
+
+    def collect_field_imports(self, field: Field, imports: Set[str]):
+        """Collect imports for a field, including list modifiers."""
+        self.collect_type_imports(
+            field.field_type,
+            imports,
+            field.element_optional,
+            field.element_ref,
+        )
 
     def has_array_field(self, message: Message) -> bool:
         """Check if message has any array fields (byte[] or primitive arrays)."""
         for field in message.fields:
             if isinstance(field.field_type, PrimitiveType):
                 if field.field_type.kind == PrimitiveKind.BYTES:
                     return True
-            elif isinstance(field.field_type, ListType):
-                if isinstance(field.field_type.element_type, PrimitiveType):
-                    if field.field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP:
-                        return True
+            elif self.is_primitive_array_field(field):
+                return True
         return False
 
     def is_primitive_array_field(self, field: Field) -> bool:
@@ -514,7 +551,11 @@ def is_primitive_array_field(self, field: Field) -> bool:
             return field.field_type.kind == PrimitiveKind.BYTES
         if isinstance(field.field_type, ListType):
             if isinstance(field.field_type.element_type, PrimitiveType):
-                return field.field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP
+                return (
+                    field.field_type.element_type.kind in self.PRIMITIVE_ARRAY_MAP
+                    and not field.element_optional
+                    and not field.element_ref
+                )
         return False
 
     def generate_equals_method(self, message: Message) -> List[str]: