fix cd meta && uv run python -m pytest

Author: vustef

meta/src/meta/codegen_go.py

@@ -562,7 +562,15 @@ def _generate_NewMessage(
         # option_var is the original Option variable name for checking .Valid
         oneof_groups: dict[str, list[tuple[str, str, str]]] = {}
 
-        from .target import OptionType, Var
+        from .target import Builtin, OptionType, Var
+
+        def _go_optional_string_unwrap_needs_ptr(field_expr: TargetExpr) -> bool:
+            """unwrap_option_or yields a plain string; optional proto fields need *string."""
+            return (
+                isinstance(field_expr, Call)
+                and isinstance(field_expr.func, Builtin)
+                and field_expr.func.name == "unwrap_option_or"
+            )
 
         def unwrap_if_option(field_expr, field_value: str) -> tuple[str, str]:
             """Unwrap Option type values for struct field assignment.
@@ -654,6 +662,22 @@ def unwrap_if_option(field_expr, field_value: str) -> tuple[str, str]:
                     assert field_value is not None
                     pascal_field = to_pascal_case(field_name)
                     _, field_value = unwrap_if_option(field_expr, field_value)
+
+                    proto_msg = self.proto_messages.get((expr.module, expr.name))
+                    if proto_msg is not None:
+                        pf = next(
+                            (f for f in proto_msg.fields if f.name == field_name),
+                            None,
+                        )
+                        if (
+                            pf is not None
+                            and pf.is_optional
+                            and not pf.is_repeated
+                            and pf.type == "string"
+                            and _go_optional_string_unwrap_needs_ptr(field_expr)
+                        ):
+                            field_value = f"ptr({field_value})"
+
                     regular_assignments.append(f"{pascal_field}: {field_value}")
 
         # Generate struct literal with regular fields only
@@ -920,8 +944,9 @@ def _generate_Assign(self, expr, lines: list[str], indent: str) -> str:
         ):
             var_type = self.gen_type(expr.var.type)
             if var_type in ("int64", "int32", "uint32", "uint64"):
-                lines.append(f"{indent}{var_name} := {var_type}({expr.expr.value})")
-                self.mark_declared(var_name)
+                lines.append(
+                    f"{indent}{self.gen_assignment(var_name, f'{var_type}({expr.expr.value})')}"
+                )
                 return self.gen_none()
 
         # Regular assignment

meta/src/meta/grammar.y

@@ -1182,7 +1182,7 @@ iceberg_to_snapshot
 
 iceberg_data
     : "(" "iceberg_data" iceberg_locator iceberg_config gnf_columns iceberg_to_snapshot? ")"
-      construct: $$ = logic.IcebergData(locator=$3, config=$4, columns=$5, to_snapshot=iceberg_optional_string_field($6))
+      construct: $$ = logic.IcebergData(locator=$3, config=$4, columns=$5, to_snapshot=builtin.unwrap_option_or($6, ""))
       deconstruct:
         $3: logic.IcebergLocator = $$.locator
         $4: logic.IcebergConfig = $$.config
@@ -1643,7 +1643,7 @@ def construct_iceberg_config(
 ) -> logic.IcebergConfig:
     props: Dict[String, String] = builtin.string_map_from_pairs(property_pairs)
     auth_props: Dict[String, String] = builtin.string_map_from_pairs(auth_property_pairs)
-    scope_pb: Optional[String] = iceberg_optional_string_field(scope_opt)
+    scope_pb: String = builtin.unwrap_option_or(scope_opt, "")
     return logic.IcebergConfig(
         catalog_uri=catalog_uri,
         scope=scope_pb,
@@ -1652,12 +1652,6 @@ def construct_iceberg_config(
     )
 
 
-def iceberg_optional_string_field(s: Optional[String]) -> Optional[String]:
-    if s is None:
-        return builtin.none()
-    return builtin.some(s)
-
-
 def deconstruct_iceberg_config_scope_optional(msg: logic.IcebergConfig) -> Optional[String]:
     if builtin.has_proto_field(msg, "scope"):
         return builtin.some(builtin.unwrap_option(msg.scope))

meta/src/meta/grammar_validator.py

@@ -62,6 +62,19 @@
 from .validation_result import ValidationResult
 
 
+def _optional_string_allows_plain_string(
+    actual: TargetType, expected: TargetType
+) -> bool:
+    """True if actual is String and expected is Option[String] (optional proto string)."""
+    if isinstance(expected, OptionType) and isinstance(
+        expected.element_type, BaseType
+    ):
+        if expected.element_type.name != "String":
+            return False
+        return isinstance(actual, BaseType) and actual.name == "String"
+    return False
+
+
 class GrammarValidator:
     """Validates grammar against protobuf specification."""
 
@@ -271,12 +284,17 @@ def _check_new_message_types(self, new_msg: NewMessage, context: str) -> None:
 
             # Check actual type is a subtype of expected type (actual_type <: expected_type)
             if actual_type is not None and not is_subtype(actual_type, expected_type):
-                self.result.add_error(
-                    "field_type",
-                    f"In {context}: NewMessage {new_msg.name} field '{field_name}' has type {actual_type}, expected {expected_type}",
-                    proto_type=new_msg.name,
-                    rule_name=context,
-                )
+                # Optional proto string fields are often represented as plain String at runtime
+                # (e.g. ProtoBuf.jl uses "" for unset); allow String where Option[String] is expected.
+                if _optional_string_allows_plain_string(actual_type, expected_type):
+                    pass
+                else:
+                    self.result.add_error(
+                        "field_type",
+                        f"In {context}: NewMessage {new_msg.name} field '{field_name}' has type {actual_type}, expected {expected_type}",
+                        proto_type=new_msg.name,
+                        rule_name=context,
+                    )
 
         # Check for missing fields
         for field in proto_message.fields:

meta/tests/meta/test_codegen_go.py

@@ -232,13 +232,13 @@ def test_go_assignment_generation():
     lines = []
     expr = Assign(Var("x", _int_type), Lit(42))
     gen.generate_lines(expr, lines, "")
-    assert "x := 42" in lines[0]
+    assert "x := int64(42)" in lines[0]
 
     # Second assignment uses =
     lines = []
     expr = Assign(Var("x", _int_type), Lit(100))
     gen.generate_lines(expr, lines, "")
-    assert "x = 100" in lines[0]
+    assert "x = int64(100)" in lines[0]
 
 
 def test_go_return_generation():