Fix Dart default ctor generation code around Options (rust-diplomat#676)

core/src/hir/types.rs

@@ -149,9 +149,13 @@ impl<P: TyPosition> Type<P> {
         }
     }
 
-    /// Whether this type is a `DiplomatOption`
+    /// Whether this type is a `DiplomatOption` or optional Opaque
     pub fn is_option(&self) -> bool {
-        matches!(self, Self::DiplomatOption(..))
+        match self {
+            Self::DiplomatOption(..) => true,
+            Self::Opaque(ref o) if o.is_optional() => true,
+            _ => false,
+        }
     }
 }
 

feature_tests/src/option.rs

@@ -45,6 +45,20 @@ pub mod ffi {
         c: DiplomatOption<OptionEnum>,
     }
 
+    impl OptionInputStruct {
+        // Specifically test the Dart default constructor generation code
+        // around Options
+        #[diplomat::attr(not(dart), disable)]
+        #[diplomat::attr(auto, constructor)]
+        pub fn default_ctor() -> Self {
+            Self {
+                a: None.into(),
+                b: None.into(),
+                c: None.into(),
+            }
+        }
+    }
+
     #[diplomat::attr(not(supports = option), disable)]
     #[derive(Debug)]
     pub enum OptionEnum {

tool/src/dart/mod.rs

@@ -338,7 +338,15 @@ impl<'a, 'cx> TyGenContext<'a, 'cx> {
                 // If there's an existing zero-arg constructor, we repurpose it with optional arguments for all fields
                 let args = fields
                     .iter()
-                    .map(|field| format!("{}? {}", field.dart_type_name, field.name))
+                    .map(|field| {
+                        let question_mark = if field.ty.is_option() {
+                            // If it's optional we don't need to double-wrap in `?`
+                            ""
+                        } else {
+                            "?"
+                        };
+                        format!("{}{question_mark} {}", field.dart_type_name, field.name)
+                    })
                     .collect::<Vec<_>>();
                 constructor.declaration =
                     format!("factory {type_name}({{{args}}})", args = args.join(", "));
@@ -347,9 +355,13 @@ impl<'a, 'cx> TyGenContext<'a, 'cx> {
                 writeln!(&mut r, "final dart = {type_name}._fromFfi(result);").unwrap();
                 for field in &fields {
                     let name = &field.name;
-                    writeln!(&mut r, "if ({name} != null) {{").unwrap();
-                    writeln!(&mut r, "  dart.{name} = {name};").unwrap();
-                    writeln!(&mut r, "}}").unwrap();
+                    if field.ty.is_option() {
+                        writeln!(&mut r, "dart.{name} = {name};").unwrap();
+                    } else {
+                        writeln!(&mut r, "if ({name} != null) {{").unwrap();
+                        writeln!(&mut r, "  dart.{name} = {name};").unwrap();
+                        writeln!(&mut r, "}}").unwrap();
+                    }
                 }
                 write!(&mut r, "return dart;").unwrap();
                 constructor.return_expression = Some(r.into());