grammar and template updates

Author: vustef

meta/src/meta/codegen_go.py

@@ -592,7 +592,13 @@ def unwrap_if_option(field_expr, field_value: str) -> tuple[str, str]:
                         lines.append(f"{indent}}}")
                         return (field_value, tmp)
                     else:
-                        # Ptr-wrapped scalar: use deref()
+                        # Ptr-wrapped scalar: usually deref for plain struct fields (float64, int64, …).
+                        # Proto `optional string` fields are *string in Go — pass *string through.
+                        inner_go = self.gen_type(field_expr.type.element_type)
+                        if inner_go == "string":
+                            opt_go = self.gen_option_type(inner_go)
+                            if opt_go.startswith("*"):
+                                return (field_value, field_value)
                         return (field_value, f"deref({field_value}, {zero})")
             return (field_value, field_value)
 
@@ -905,6 +911,21 @@ def _generate_Assign(self, expr, lines: list[str], indent: str) -> str:
             self.mark_declared(var_name)
             return self.gen_none()
 
+        # Integer literal with explicit Int32/Int64/... annotation: avoid untyped `:= 0` (int)
+        # so later assignments from int64 (e.g. _extract_value_int64) type-check.
+        if (
+            isinstance(expr.expr, Lit)
+            and type(expr.expr.value) is int
+            and expr.var.type is not None
+        ):
+            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)
+                return self.gen_none()
+
         # Regular assignment
         expr_code = self.generate_lines(expr.expr, lines, indent)
         assert expr_code is not None, (

meta/src/meta/codegen_templates.py

@@ -33,6 +33,7 @@ class BuiltinTemplate:
     "none": BuiltinTemplate("None"),
     "make_empty_bytes": BuiltinTemplate('b""'),
     "dict_from_list": BuiltinTemplate("dict({0})"),
+    "string_map_from_pairs": BuiltinTemplate("dict({0})"),
     "dict_get": BuiltinTemplate("{0}.get({1})"),
     "dict_to_pairs": BuiltinTemplate("sorted({0}.items())"),
     "has_proto_field": BuiltinTemplate("{0}.HasField({1})"),
@@ -144,6 +145,7 @@ class BuiltinTemplate:
     "none": BuiltinTemplate("nothing"),
     "make_empty_bytes": BuiltinTemplate("UInt8[]"),
     "dict_from_list": BuiltinTemplate("Dict({0})"),
+    "string_map_from_pairs": BuiltinTemplate("Dict({0})"),
     "dict_get": BuiltinTemplate("get({0}, {1}, nothing)"),
     "dict_to_pairs": BuiltinTemplate("sort([(k, v) for (k, v) in {0}])"),
     "has_proto_field": BuiltinTemplate("_has_proto_field({0}, Symbol({1}))"),
@@ -260,6 +262,7 @@ class BuiltinTemplate:
     "none": BuiltinTemplate("nil"),
     "make_empty_bytes": BuiltinTemplate("[]byte{}"),
     "dict_from_list": BuiltinTemplate("dictFromList({0})"),
+    "string_map_from_pairs": BuiltinTemplate("stringMapFromPairs({0})"),
     "dict_get": BuiltinTemplate("dictGetValue({0}, {1})"),
     "dict_to_pairs": BuiltinTemplate("dictToPairs({0})"),
     "has_proto_field": BuiltinTemplate("hasProtoField({0}, {1})"),

meta/src/meta/grammar.y

@@ -1328,7 +1328,7 @@ def _extract_value_int32(value: Optional[logic.Value], default: int) -> Int32:
     return builtin.int64_to_int32(default)
 
 
-def _extract_value_int64(value: Optional[logic.Value], default: int) -> int:
+def _extract_value_int64(value: Optional[logic.Value], default: int) -> Int64:
     if value is not None and builtin.has_proto_field(builtin.unwrap_option(value), 'int_value'):
         return builtin.unwrap_option(value).int_value
     return default
@@ -1641,8 +1641,8 @@ def construct_iceberg_config(
     property_pairs: Sequence[Tuple[String, String]],
     auth_property_pairs: Sequence[Tuple[String, String]],
 ) -> logic.IcebergConfig:
-    props: Dict[String, String] = builtin.dict_from_list(property_pairs)
-    auth_props: Dict[String, String] = builtin.dict_from_list(auth_property_pairs)
+    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)
     return logic.IcebergConfig(
         catalog_uri=catalog_uri,
@@ -1677,7 +1677,7 @@ def construct_export_iceberg_config_full(
     config_dict: Optional[Sequence[Tuple[String, logic.Value]]],
 ) -> transactions.ExportIcebergConfig:
     prefix: String = ""
-    target_file_size_bytes: int = 0
+    target_file_size_bytes: Int64 = 0
     compression: String = ""
     if config_dict is not None:
         cfg: Dict[String, logic.Value] = builtin.dict_from_list(builtin.unwrap_option(config_dict))

meta/src/meta/target_builtins.py

@@ -217,6 +217,11 @@ def is_builtin(name: str) -> bool:
 
 # === Dict operations ===
 register_builtin("dict_from_list", [SequenceType(TupleType([K, V]))], DictType(K, V))
+register_builtin(
+    "string_map_from_pairs",
+    [SequenceType(TupleType([STRING, STRING]))],
+    DictType(STRING, STRING),
+)
 register_builtin("dict_get", [DictType(K, V), K], OptionType(V))
 register_builtin("dict_to_pairs", [DictType(K, V)], ListType(TupleType([K, V])))
 

meta/src/meta/templates/parser.go.template

@@ -543,6 +543,19 @@ func dictFromList(pairs [][]interface{{}}) map[string]interface{{}} {{
 	return result
 }}
 
+// stringMapFromPairs builds map[string]string from (prop key value) pair rows.
+func stringMapFromPairs(pairs [][]interface{{}}) map[string]string {{
+	out := make(map[string]string)
+	for _, pair := range pairs {{
+		if len(pair) >= 2 {{
+			k, _ := pair[0].(string)
+			v, _ := pair[1].(string)
+			out[k] = v
+		}}
+	}}
+	return out
+}}
+
 // dictGetValue retrieves a Value from the config dict with type assertion
 func dictGetValue(m map[string]interface{{}}, key string) *pb.Value {{
 	if v, ok := m[key]; ok {{

meta/src/meta/templates/pretty_printer.go.template

@@ -261,6 +261,23 @@ func listSort(pairs [][]interface{{}}) [][]interface{{}} {{
 	return pairs
 }}
 
+// dictToPairs converts map[string]string to sorted key/value rows for pretty printing.
+func dictToPairs(m map[string]string) [][]interface{{}} {{
+	if len(m) == 0 {{
+		return nil
+	}}
+	keys := make([]string, 0, len(m))
+	for k := range m {{
+		keys = append(keys, k)
+	}}
+	sort.Strings(keys)
+	out := make([][]interface{{}}, 0, len(keys))
+	for _, k := range keys {{
+		out = append(out, []interface{{}}{{k, m[k]}})
+	}}
+	return out
+}}
+
 // --- Free functions ---
 
 func uint128ToString(low, high uint64) string {{