refactor: align named registration APIs

Author: chaokunyang

compiler/fory_compiler/generators/dart.py

@@ -436,13 +436,15 @@ def _dart_string_literal(self, value: str) -> str:
         escaped = value.replace("\\", "\\\\").replace("'", "\\'")
         return f"'{escaped}'"
 
-    def _registration_defaults(self, type_def: object) -> Tuple[str, str, str]:
+    def _registration_defaults(self, type_def: object) -> Tuple[str, str]:
         if self.should_register_by_id(type_def):
-            return str(type_def.type_id), "null", "null"
+            return str(type_def.type_id), "null"
+        name = self.registration_type_name(type_def)
+        if self.package:
+            name = f"{self.package}.{name}"
         return (
             "null",
-            self._dart_string_literal(self.package or ""),
-            self._dart_string_literal(self.registration_type_name(type_def)),
+            self._dart_string_literal(name),
         )
 
     def _supports_direct_container_cast(
@@ -1300,12 +1302,10 @@ def generate_module_type(self, indent: int) -> List[str]:
 
         def registration_lines(type_def: object, call_line: str) -> List[str]:
             n = self.local_name(type_def)
-            default_id, default_namespace, default_type_name = (
-                self._registration_defaults(type_def)
-            )
+            default_id, default_name = self._registration_defaults(type_def)
             return [
                 f"{self.indent_str * (indent + 2)}if (type == {n}) {{",
-                f"{self.indent_str * (indent + 3)}{call_line.format(id=default_id, namespace=default_namespace, type_name=default_type_name)}",
+                f"{self.indent_str * (indent + 3)}{call_line.format(id=default_id, name=default_name)}",
                 f"{self.indent_str * (indent + 3)}return;",
                 f"{self.indent_str * (indent + 2)}}}",
             ]
@@ -1318,7 +1318,7 @@ def registration_lines(type_def: object, call_line: str) -> List[str]:
             lines.extend(
                 registration_lines(
                     enum,
-                    f"registerGeneratedEnum(fory, {schema_name}, id: {{id}}, namespace: {{namespace}}, typeName: {{type_name}});",
+                    f"registerGeneratedEnum(fory, {schema_name}, id: {{id}}, name: {{name}});",
                 )
             )
         for union in self.schema.unions:
@@ -1328,7 +1328,7 @@ def registration_lines(type_def: object, call_line: str) -> List[str]:
             lines.extend(
                 registration_lines(
                     union,
-                    f"fory.registerSerializer({n}, const _{n}ForySerializer(), id: {{id}}, namespace: {{namespace}}, typeName: {{type_name}});",
+                    f"fory.registerSerializer({n}, const _{n}ForySerializer(), id: {{id}}, name: {{name}});",
                 )
             )
 
@@ -1340,7 +1340,7 @@ def visit_message(message: Message):
             lines.extend(
                 registration_lines(
                     message,
-                    f"registerGeneratedStruct(fory, {schema_name}, id: {{id}}, namespace: {{namespace}}, typeName: {{type_name}});",
+                    f"registerGeneratedStruct(fory, {schema_name}, id: {{id}}, name: {{name}});",
                 )
             )
             for enum in message.nested_enums:
@@ -1349,15 +1349,15 @@ def visit_message(message: Message):
                 lines.extend(
                     registration_lines(
                         enum,
-                        f"registerGeneratedEnum(fory, {schema_name}, id: {{id}}, namespace: {{namespace}}, typeName: {{type_name}});",
+                        f"registerGeneratedEnum(fory, {schema_name}, id: {{id}}, name: {{name}});",
                     )
                 )
             for union in message.nested_unions:
                 un = self.local_name(union)
                 lines.extend(
                     registration_lines(
                         union,
-                        f"fory.registerSerializer({un}, const _{un}ForySerializer(), id: {{id}}, namespace: {{namespace}}, typeName: {{type_name}});",
+                        f"fory.registerSerializer({un}, const _{un}ForySerializer(), id: {{id}}, name: {{name}});",
                     )
                 )
             for nested in message.nested_messages:

compiler/fory_compiler/generators/python.py

@@ -1031,7 +1031,7 @@ def generate_enum_registration(
         else:
             ns = self.package or "default"
             lines.append(
-                f'    fory.register_type({class_ref}, namespace="{ns}", typename="{type_name}")'
+                f'    fory.register_type({class_ref}, name="{ns}.{type_name}")'
             )
 
     def generate_message_registration(
@@ -1048,7 +1048,7 @@ def generate_message_registration(
         else:
             ns = self.package or "default"
             lines.append(
-                f'    fory.register_type({class_ref}, namespace="{ns}", typename="{type_name}")'
+                f'    fory.register_type({class_ref}, name="{ns}.{type_name}")'
             )
 
         # Register nested enums
@@ -1081,5 +1081,5 @@ def generate_union_registration(
         else:
             ns = self.package or "default"
             lines.append(
-                f'    fory.register_union({class_ref}, namespace="{ns}", typename="{type_name}", serializer={serializer_ref}(fory.type_resolver))'
+                f'    fory.register_union({class_ref}, name="{ns}.{type_name}", serializer={serializer_ref}(fory.type_resolver))'
             )

compiler/fory_compiler/generators/swift.py

@@ -1262,16 +1262,12 @@ def generate_module_type(self, indent: int = 0) -> List[str]:
                 continue
 
             schema_type_name = self.schema_type_name(type_def)
-            escaped_name = schema_type_name.replace('"', '\\"')
             if namespace:
-                escaped_ns = namespace.replace('"', '\\"')
-                lines.append(
-                    f'{ind}{self.indent_str * 2}try fory.register({type_name}.self, namespace: "{escaped_ns}", name: "{escaped_name}")'
-                )
-            else:
-                lines.append(
-                    f'{ind}{self.indent_str * 2}try fory.register({type_name}.self, name: "{escaped_name}")'
-                )
+                schema_type_name = f"{namespace}.{schema_type_name}"
+            escaped_name = schema_type_name.replace('"', '\\"')
+            lines.append(
+                f'{ind}{self.indent_str * 2}try fory.register({type_name}.self, name: "{escaped_name}")'
+            )
         lines.append(f"{ind}{self.indent_str}" + "}")
 
         lines.append(f"{ind}" + "}")

compiler/fory_compiler/tests/test_generated_code.py

@@ -613,6 +613,77 @@ def test_java_nested_name_registration_uses_owner_namespace():
     )
 
 
+def test_generated_registration_uses_single_name_for_dart_python_swift():
+    schema = parse_fdl(
+        """
+        option enable_auto_type_id = false;
+        package demo;
+
+        message Envelope {
+            message Payload {
+                int32 value = 1;
+            }
+
+            enum Kind {
+                UNKNOWN = 0;
+                ACTIVE = 1;
+            }
+
+            union Choice {
+                Payload payload = 1;
+                string note = 2;
+            }
+
+            Payload payload = 1;
+            Kind kind = 2;
+            Choice choice = 3;
+        }
+        """
+    )
+
+    dart_output = render_files(generate_files(schema, DartGenerator))
+    assert (
+        "registerGeneratedStruct(fory, _envelopeForySchema, id: null, name: 'demo.Envelope');"
+        in dart_output
+    )
+    assert (
+        "registerGeneratedEnum(fory, _envelopeKindForySchema, id: null, name: 'demo.Envelope.Kind');"
+        in dart_output
+    )
+    assert (
+        "fory.registerSerializer(Envelope_Choice, const _Envelope_ChoiceForySerializer(), id: null, name: 'demo.Envelope.Choice');"
+        in dart_output
+    )
+    assert "namespace:" not in dart_output
+    assert "typeName:" not in dart_output
+
+    python_output = render_files(generate_files(schema, PythonGenerator))
+    assert 'fory.register_type(Envelope, name="demo.Envelope")' in python_output
+    assert (
+        'fory.register_type(Envelope.Kind, name="demo.Envelope.Kind")' in python_output
+    )
+    assert (
+        'fory.register_union(Envelope.Choice, name="demo.Envelope.Choice", serializer=Envelope.ChoiceSerializer(fory.type_resolver))'
+        in python_output
+    )
+    assert "namespace=" not in python_output
+    assert "typename=" not in python_output
+
+    swift_output = render_files(generate_files(schema, SwiftGenerator))
+    assert (
+        'try fory.register(Demo.Envelope.self, name: "demo.Envelope")' in swift_output
+    )
+    assert (
+        'try fory.register(Demo.Envelope.Kind.self, name: "demo.Envelope.Kind")'
+        in swift_output
+    )
+    assert (
+        'try fory.register(Demo.Envelope.Choice.self, name: "demo.Envelope.Choice")'
+        in swift_output
+    )
+    assert "namespace:" not in swift_output
+
+
 def test_java_default_package_import_registers_dependency(tmp_path):
     common = tmp_path / "common.fdl"
     common.write_text(

csharp/src/Fory/Fory.cs

@@ -77,14 +77,15 @@ public Fory Register<T>(uint typeId)
     }
 
     /// <summary>
-    /// Registers a user type by name using an empty namespace.
+    /// Registers a user type by name.
     /// </summary>
     /// <typeparam name="T">Type to register.</typeparam>
-    /// <param name="typeName">Type name used on the wire.</param>
+    /// <param name="name">Name used on the wire. A dotted name is split at the last dot.</param>
     /// <returns>The same runtime instance.</returns>
-    public Fory Register<T>(string typeName)
+    public Fory Register<T>(string name)
     {
-        _typeResolver.Register(typeof(T), string.Empty, typeName);
+        (string namespaceName, string typeName) = TypeResolver.SplitTypeName(name);
+        _typeResolver.Register(typeof(T), namespaceName, typeName);
         return this;
     }
 
@@ -116,6 +117,22 @@ public Fory Register<T, TSerializer>(uint typeId)
         return this;
     }
 
+    /// <summary>
+    /// Registers a user type by name with a custom serializer.
+    /// </summary>
+    /// <typeparam name="T">Type to register.</typeparam>
+    /// <typeparam name="TSerializer">Serializer implementation used for <typeparamref name="T"/>.</typeparam>
+    /// <param name="name">Name used on the wire. A dotted name is split at the last dot.</param>
+    /// <returns>The same runtime instance.</returns>
+    public Fory Register<T, TSerializer>(string name)
+        where TSerializer : Serializer<T>, new()
+    {
+        (string namespaceName, string typeName) = TypeResolver.SplitTypeName(name);
+        TypeInfo typeInfo = _typeResolver.RegisterSerializer<T, TSerializer>();
+        _typeResolver.Register(typeof(T), namespaceName, typeName, typeInfo);
+        return this;
+    }
+
     /// <summary>
     /// Registers a user type by namespace and name with a custom serializer.
     /// </summary>
@@ -127,6 +144,7 @@ public Fory Register<T, TSerializer>(uint typeId)
     public Fory Register<T, TSerializer>(string typeNamespace, string typeName)
         where TSerializer : Serializer<T>, new()
     {
+        TypeResolver.ValidateSplitTypeName(typeNamespace, typeName);
         TypeInfo typeInfo = _typeResolver.RegisterSerializer<T, TSerializer>();
         _typeResolver.Register(typeof(T), typeNamespace, typeName, typeInfo);
         return this;

csharp/src/Fory/ThreadSafeFory.cs

@@ -57,11 +57,12 @@ public ThreadSafeFory Register<T>(uint typeId)
     /// Registers a user type by name for all current and future thread-local runtimes.
     /// </summary>
     /// <typeparam name="T">Type to register.</typeparam>
-    /// <param name="typeName">Type name used on the wire.</param>
+    /// <param name="name">Name used on the wire. A dotted name is split at the last dot.</param>
     /// <returns>The same runtime instance.</returns>
-    public ThreadSafeFory Register<T>(string typeName)
+    public ThreadSafeFory Register<T>(string name)
     {
-        ApplyRegistration(fory => fory.Register<T>(typeName));
+        _ = TypeResolver.SplitTypeName(name);
+        ApplyRegistration(fory => fory.Register<T>(name));
         return this;
     }
 
@@ -74,6 +75,7 @@ public ThreadSafeFory Register<T>(string typeName)
     /// <returns>The same runtime instance.</returns>
     public ThreadSafeFory Register<T>(string typeNamespace, string typeName)
     {
+        TypeResolver.ValidateSplitTypeName(typeNamespace, typeName);
         ApplyRegistration(fory => fory.Register<T>(typeNamespace, typeName));
         return this;
     }
@@ -92,6 +94,21 @@ public ThreadSafeFory Register<T, TSerializer>(uint typeId)
         return this;
     }
 
+    /// <summary>
+    /// Registers a user type by name with a custom serializer for all thread-local runtimes.
+    /// </summary>
+    /// <typeparam name="T">Type to register.</typeparam>
+    /// <typeparam name="TSerializer">Serializer implementation used for <typeparamref name="T"/>.</typeparam>
+    /// <param name="name">Name used on the wire. A dotted name is split at the last dot.</param>
+    /// <returns>The same runtime instance.</returns>
+    public ThreadSafeFory Register<T, TSerializer>(string name)
+        where TSerializer : Serializer<T>, new()
+    {
+        _ = TypeResolver.SplitTypeName(name);
+        ApplyRegistration(fory => fory.Register<T, TSerializer>(name));
+        return this;
+    }
+
     /// <summary>
     /// Registers a user type by namespace and name with a custom serializer for all thread-local runtimes.
     /// </summary>
@@ -103,6 +120,7 @@ public ThreadSafeFory Register<T, TSerializer>(uint typeId)
     public ThreadSafeFory Register<T, TSerializer>(string typeNamespace, string typeName)
         where TSerializer : Serializer<T>, new()
     {
+        TypeResolver.ValidateSplitTypeName(typeNamespace, typeName);
         ApplyRegistration(fory => fory.Register<T, TSerializer>(typeNamespace, typeName));
         return this;
     }

csharp/src/Fory/TypeResolver.cs

@@ -293,8 +293,43 @@ internal void Register(Type type, uint id, TypeInfo? explicitTypeInfo = null)
         InvalidateFinalizedVersion();
     }
 
+    internal static (string NamespaceName, string TypeName) SplitTypeName(string name)
+    {
+        ArgumentNullException.ThrowIfNull(name);
+        if (name.Length == 0)
+        {
+            throw new ArgumentException("registration name must not be empty", nameof(name));
+        }
+
+        int separator = name.LastIndexOf('.');
+        if (separator == name.Length - 1)
+        {
+            throw new ArgumentException("registration name must end with a non-empty type name", nameof(name));
+        }
+
+        return separator < 0
+            ? (string.Empty, name)
+            : (name[..separator], name[(separator + 1)..]);
+    }
+
+    internal static void ValidateSplitTypeName(string namespaceName, string typeName)
+    {
+        ArgumentNullException.ThrowIfNull(namespaceName);
+        ArgumentNullException.ThrowIfNull(typeName);
+        if (typeName.Length == 0)
+        {
+            throw new ArgumentException("typeName must not be empty", nameof(typeName));
+        }
+
+        if (typeName.Contains(".", StringComparison.Ordinal))
+        {
+            throw new ArgumentException("typeName must not contain '.'", nameof(typeName));
+        }
+    }
+
     internal void Register(Type type, string namespaceName, string typeName, TypeInfo? explicitTypeInfo = null)
     {
+        ValidateSplitTypeName(namespaceName, typeName);
         TypeInfo typeInfo = GetOrCreateTypeInfo(type, explicitTypeInfo);
         MetaString namespaceMeta = MetaStringEncoder.Namespace.Encode(namespaceName, TypeMetaEncodings.NamespaceMetaStringEncodings);
         MetaString typeNameMeta = MetaStringEncoder.TypeName.Encode(typeName, TypeMetaEncodings.TypeNameMetaStringEncodings);