fix(dart): preserve optional constructor flows

Author: chaokunyang

dart/packages/fory-test/lib/model/inheritance_models.dart

@@ -39,6 +39,26 @@ final class CrossLibraryChild extends middle.PublicMiddleBoundary {
   String childMutable = '';
 }
 
+class OptionalMutableBase {
+  OptionalMutableBase([int decoded = 0])
+    : inheritedMutable = decoded,
+      observedAtConstruction = decoded;
+
+  @ForyField(id: 1)
+  int inheritedMutable;
+
+  @ForyField(ignore: true)
+  final int observedAtConstruction;
+}
+
+@ForyStruct()
+final class OptionalMutableChild extends OptionalMutableBase {
+  OptionalMutableChild(this.fixed, [int decoded = 0]) : super(decoded);
+
+  @ForyField(id: 2)
+  final int fixed;
+}
+
 @ForyStruct()
 final class XlangInheritedChild extends base.XlangInheritanceBoundary {
   XlangInheritedChild();

dart/packages/fory-test/test/struct_inheritance_test.dart

@@ -99,6 +99,19 @@ void main() {
       });
     }
 
+    test('passes optional mutable state through construction', () {
+      final fory = Fory();
+      InheritanceModelsForyModule.register(fory, OptionalMutableChild, id: 405);
+
+      final result = fory.deserialize<OptionalMutableChild>(
+        fory.serialize(OptionalMutableChild(7, 19)),
+      );
+
+      expect(result.fixed, 7);
+      expect(result.inheritedMutable, 19);
+      expect(result.observedAtConstruction, 19);
+    });
+
     for (final compatible in <bool>[false, true]) {
       test('matches flat and inherited schemas compatible=$compatible', () {
         final privateFory = Fory(compatible: compatible);

dart/packages/fory/lib/src/codegen/fory_constructor_analysis.dart

@@ -118,7 +118,7 @@ final class _OrdinaryConstructorAnalyzer {
     }
 
     for (final root in rootFrame.parameters) {
-      if (!root.parameter.isRequired || bindingByRoot.containsKey(root)) {
+      if (bindingByRoot.containsKey(root)) {
         continue;
       }
       _GeneratedFieldSpec? candidate;
@@ -135,16 +135,19 @@ final class _OrdinaryConstructorAnalyzer {
         ambiguousLabels.add(_fieldLabel(field));
       }
       if (candidate == null) {
-        _throwMissingRequiredSource(
-          declaration,
-          targetTypeLiteral,
-          root,
-          fields,
-        );
+        if (root.parameter.isRequired) {
+          _throwMissingRequiredSource(
+            declaration,
+            targetTypeLiteral,
+            root,
+            fields,
+          );
+        }
+        continue;
       }
       if (ambiguousLabels != null) {
         throw InvalidGenerationSourceError(
-          'Required constructor parameter ${root.parameter.displayName} on '
+          'Constructor parameter ${root.parameter.displayName} on '
           '$targetTypeLiteral has multiple writable identity-flow sources: '
           '${ambiguousLabels.join(', ')}. Select a constructor '
           'whose parameter flow identifies exactly one serialized field.',
@@ -155,10 +158,10 @@ final class _OrdinaryConstructorAnalyzer {
       final existingRoot = rootByArgumentField[field];
       if (existingRoot != null && !identical(existingRoot, root)) {
         throw InvalidGenerationSourceError(
-          'Serialized field ${_fieldLabel(field)} would supply both required '
-          'constructor parameters ${existingRoot.parameter.displayName} and '
+          'Serialized field ${_fieldLabel(field)} would supply constructor '
+          'parameters ${existingRoot.parameter.displayName} and '
           '${root.parameter.displayName} on $targetTypeLiteral. A field may '
-          'supply at most one required constructor argument.',
+          'supply at most one constructor argument.',
           element: field.declaration,
         );
       }
@@ -251,12 +254,11 @@ final class _OrdinaryConstructorAnalyzer {
       if (_isMixinApplicationConstructor(constructor)) {
         _addMixinForwardingEdges(frame, nextFrame, declaration);
       } else if (_isDeclaredConstructor(constructor)) {
-        // Field-formal elements completely prove a leaf constructor when
-        // every required argument and final field already has an exact
-        // storage edge. Resolve source only when an initializer or
-        // constructor hop is still needed for that proof; eager resolution
-        // makes the common flat-struct build pay for a whole resolved AST
-        // without changing the construction result.
+        // Summary elements completely prove a leaf constructor only when it
+        // has no optional parameters and every required argument and final
+        // field already has an exact storage edge. An explicit initializer
+        // may connect an optional parameter to mutable storage that must
+        // receive its decoded value during construction.
         if (nextFrame != null || !_summaryProvesLeaf(frame, fields)) {
           final node = await _astFor(constructor);
           if (node is ConstructorDeclaration) {
@@ -293,7 +295,7 @@ final class _OrdinaryConstructorAnalyzer {
     List<_GeneratedFieldSpec> fields,
   ) {
     for (final parameter in frame.parameters) {
-      if (parameter.parameter.isRequired && parameter.fieldTargets.isEmpty) {
+      if (parameter.parameter.isOptional || parameter.fieldTargets.isEmpty) {
         return false;
       }
     }

dart/packages/fory/test/struct_constructor_flow_generator_test.dart

@@ -179,6 +179,32 @@ final class FinalAndWritableValue {
       );
     });
 
+    test('passes an optional writable identity flow', () async {
+      await _expectGenerationOutput(
+        source: '''
+class OptionalMutableBase {
+  int mutable;
+
+  OptionalMutableBase([int decoded = 0]) : mutable = decoded;
+}
+
+@ForyStruct()
+final class OptionalMutableChild extends OptionalMutableBase {
+  final int fixed;
+
+  OptionalMutableChild(this.fixed, [int decoded = 0]) : super(decoded);
+}
+''',
+        output: allOf(
+          contains(
+            'final value = OptionalMutableChild('
+            '_fixedValue, _mutableValue);',
+          ),
+          isNot(contains('value.mutable = _mutableValue;')),
+        ),
+      );
+    });
+
     test('omits an unbound optional named parameter', () async {
       await _expectGenerationOutput(
         source: '''
@@ -413,6 +439,24 @@ final class AmbiguousWritableValue {
       );
     });
 
+    test('optional root with ambiguous writable fields', () async {
+      await _expectGenerationError(
+        source: '''
+@ForyStruct()
+final class AmbiguousOptionalValue {
+  final int fixed;
+  int first;
+  int second;
+
+  AmbiguousOptionalValue(this.fixed, [int decoded = 0])
+    : first = decoded,
+      second = decoded;
+}
+''',
+        message: 'has multiple writable identity-flow sources',
+      );
+    });
+
     test('required parameter without a field source', () async {
       await _expectGenerationError(
         source: '''