[swift2objc] Support default parameter values (#1752)

pkgs/swift2objc/lib/src/ast/_core/shared/parameter.dart

@@ -10,11 +10,19 @@ class Parameter extends AstNode {
   String name;
   String? internalName;
   ReferredType type;
+  String? defaultValue;
 
-  Parameter({required this.name, this.internalName, required this.type});
+  Parameter({
+    required this.name,
+    this.internalName,
+    required this.type,
+    this.defaultValue,
+  });
 
   @override
-  String toString() => '$name $internalName: $type';
+  String toString() =>
+      '$name $internalName: $type'
+      '${defaultValue != null ? ' = $defaultValue' : ''}';
 
   @override
   void visitChildren(Visitor visitor) {

pkgs/swift2objc/lib/src/ast/declarations/enums/associated_value_enum_declaration.dart

@@ -113,6 +113,9 @@ class AssociatedValueParam extends AstNode implements Parameter {
   @override
   covariant Null internalName;
 
+  @override
+  String? defaultValue;
+
   AssociatedValueParam({required this.name, required this.type});
 
   @override

pkgs/swift2objc/lib/src/parser/_core/token_list.dart

@@ -30,42 +30,79 @@ class TokenList extends Iterable<Json> {
     return TokenList._(list, 0, list.length);
   }
 
+  /// Splits a single token on splittable characters, handling both prefix and
+  /// suffix cases.
+  ///
+  /// Swift's symbol graph concatenates some tokens together, for example when
+  /// a parameter has a default value: " = value) -> returnType" becomes a
+  /// single text token. This method splits such tokens by:
+  ///   1. Repeatedly extracting splittables from the start
+  ///   2. For the remaining content, pull splittables from the end
+  ///   3. Store removed suffix tokens and yield them in reverse order
+  ///   4. Yield any remaining non-splittable content as a single text token
+  ///
+  /// This approach preserves the correct token sequence and ensures that even
+  /// complex cases like " = foo) -> " are properly tokenized.
   @visibleForTesting
   static Iterable<Json> splitToken(Json token) sync* {
-    const splittables = ['(', ')', '?', ',', '->'];
+    const splittables = ['(', ')', '?', ',', '->', '='];
     Json textToken(String text) =>
         Json({'kind': 'text', 'spelling': text}, token.pathSegments);
 
     final text = getSpellingForKind(token, 'text')?.trim();
     if (text == null) {
-      // Not a text token. Pass it though unchanged.
+      // Not a text token. Pass it through unchanged.
       yield token;
       return;
     }
 
     if (text.isEmpty) {
-      // Input text token was nothing but whitespace. The loop below would yield
-      // nothing, but we still need it as a separator.
+      // Input text token was nothing but whitespace. We still need it as a
+      // separator for the parser.
       yield textToken(text);
       return;
     }
 
-    var suffix = text;
+    var remaining = text;
     while (true) {
-      var any = false;
-      for (final prefix in splittables) {
-        if (suffix.startsWith(prefix)) {
-          yield textToken(prefix);
-          suffix = suffix.substring(prefix.length).trim();
-          any = true;
+      var foundPrefix = false;
+      for (final splittable in splittables) {
+        if (remaining.startsWith(splittable)) {
+          yield textToken(splittable);
+          remaining = remaining.substring(splittable.length).trim();
+          foundPrefix = true;
           break;
         }
       }
-      if (!any) {
-        // Remaining text isn't splittable.
-        if (suffix.isNotEmpty) yield textToken(suffix);
-        break;
+
+      if (foundPrefix) continue;
+
+      // No more prefix splittables found; extract any trailing ones.
+      // We collect them in a list and yield in reverse order to maintain
+      // the original token sequence.
+      final trailingTokens = <String>[];
+      var currentSuffix = remaining;
+      while (currentSuffix.isNotEmpty) {
+        var foundSuffix = false;
+        for (final splittable in splittables) {
+          if (currentSuffix.endsWith(splittable)) {
+            trailingTokens.add(splittable);
+            currentSuffix = currentSuffix
+                .substring(0, currentSuffix.length - splittable.length)
+                .trim();
+            foundSuffix = true;
+            break;
+          }
+        }
+        if (!foundSuffix) break;
+      }
+
+      // Yield the core content, then trailing splittables in reverse order.
+      if (currentSuffix.isNotEmpty) yield textToken(currentSuffix);
+      for (var i = trailingTokens.length - 1; i >= 0; i--) {
+        yield textToken(trailingTokens[i]);
       }
+      break;
     }
   }
 

pkgs/swift2objc/lib/src/parser/parsers/declaration_parsers/parse_function_declaration.dart

@@ -146,11 +146,91 @@ ParsedFunctionInfo parseFunctionInfo(
       final (type, remainingTokens) = parseType(context, symbolgraph, tokens);
       tokens = remainingTokens;
 
+      // Optional: parse a default argument if present.
+      // Swift symbol graph can emit defaults in these formats:
+      // 1. Separate tokens: [": ", type..., " = ", value, ", "]
+      // 2. Combined: [":", type..., " = value, "] or
+      //    [":", type..., " = value)"]
+      // 3. With return: [":", type..., " = value) -> "]
+      //
+      // We carefully preserve string literals during parsing to avoid
+      // splitting on delimiters that appear inside quoted strings
+      // (e.g., the ") -> " in the string literal "World ) -> ").
+      String? defaultValue;
+      String? endToken;
+      var afterType = maybeConsume('text');
+
+      if (afterType != null) {
+        // Check if this text token contains '='
+        var remaining = afterType.trim();
+        if (remaining.startsWith('=')) {
+          // Extract default value from this token
+          remaining = remaining.substring(1).trim();
+
+          // Check for delimiters: ',' or ')' (possibly followed by ' ->')
+          if (remaining.contains(')')) {
+            final parenIndex = remaining.indexOf(')');
+            defaultValue = remaining.substring(0, parenIndex).trim();
+            endToken = ')';
+          } else if (remaining.contains(',')) {
+            final commaIndex = remaining.indexOf(',');
+            defaultValue = remaining.substring(0, commaIndex).trim();
+            endToken = ',';
+          } else if (remaining.isNotEmpty) {
+            // Default value but no delimiter yet
+            defaultValue = remaining;
+            endToken = maybeConsume('text');
+          } else {
+            // '=' alone, collect tokens until delimiter
+            final parts = <String>[];
+            while (tokens.isNotEmpty) {
+              final tok = tokens[0];
+              final kind = tok['kind'].get<String?>();
+              final spelling = tok['spelling'].get<String?>();
+              if (spelling != null) {
+                final s = spelling.trim();
+                // String tokens should be kept whole, not split on delimiters
+                if (kind == 'string') {
+                  parts.add(spelling);
+                  tokens = tokens.slice(1);
+                } else if (s == ',' || s == ')') {
+                  endToken = s;
+                  tokens = tokens.slice(1);
+                  break;
+                } else if (s.contains(',') || s.contains(')')) {
+                  final delimChar = s.contains(',') ? ',' : ')';
+                  final delimIndex = s.indexOf(delimChar);
+                  parts.add(s.substring(0, delimIndex).trim());
+                  endToken = delimChar;
+                  tokens = tokens.slice(1);
+                  break;
+                } else {
+                  parts.add(spelling);
+                  tokens = tokens.slice(1);
+                }
+              } else {
+                tokens = tokens.slice(1);
+              }
+            }
+            if (parts.isNotEmpty) {
+              defaultValue = parts.join('').trim();
+            }
+          }
+        } else {
+          endToken = afterType;
+        }
+      }
+
       parameters.add(
-        Parameter(name: externalParam, internalName: internalParam, type: type),
+        Parameter(
+          name: externalParam,
+          internalName: internalParam,
+          type: type,
+          defaultValue: defaultValue,
+        ),
       );
 
-      final end = maybeConsume('text');
+      final end = endToken ?? maybeConsume('text');
       if (end == ')') break;
       if (end != ',') throw malformedInitializerException;
     }

pkgs/swift2objc/lib/src/transformer/transformers/transform_compound.dart

@@ -81,28 +81,29 @@ ClassDeclaration transformCompound(
         .nonNulls
         .toList();
 
-    final transformedInitializers = originalCompound.initializers
-        .map(
-          (initializer) => transformInitializer(
-            initializer,
-            wrappedCompoundInstance,
-            parentNamer,
-            state,
-          ),
-        )
-        .toList();
+    final transformedInitializers = <Declaration>[];
+    for (final init in originalCompound.initializers) {
+      transformedInitializers.addAll(
+        transformInitializerWithOverloads(
+          init,
+          wrappedCompoundInstance,
+          parentNamer,
+          state,
+        ),
+      );
+    }
 
-    final transformedMethods = originalCompound.methods
-        .map(
-          (method) => transformMethod(
-            method,
-            wrappedCompoundInstance,
-            parentNamer,
-            state,
-          ),
-        )
-        .nonNulls
-        .toList();
+    final transformedMethods = <MethodDeclaration>[];
+    for (final method in originalCompound.methods) {
+      transformedMethods.addAll(
+        transformMethodWithOverloads(
+          method,
+          wrappedCompoundInstance,
+          parentNamer,
+          state,
+        ),
+      );
+    }
 
     transformedCompound.properties =
         transformedProperties.whereType<PropertyDeclaration>().toList()