revert _extract_value_int64 return type change in favor of casting in grammar.y itself

Author: vustef

meta/src/meta/codegen_go.py

@@ -935,20 +935,6 @@ 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}{self.gen_assignment(var_name, f'{var_type}({expr.expr.value})')}"
-                )
-                return self.gen_none()
-
         # Regular assignment
         expr_code = self.generate_lines(expr.expr, lines, indent)
         assert expr_code is not None, (

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) -> Int64:
+def _extract_value_int64(value: Optional[logic.Value], default: int) -> int:
     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
@@ -1669,14 +1669,10 @@ def construct_export_iceberg_config_full(
     columns: Sequence[transactions.IcebergExportColumn],
     config_dict: Optional[Sequence[Tuple[String, logic.Value]]],
 ) -> transactions.ExportIcebergConfig:
-    prefix: String = ""
-    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))
-        prefix = _extract_value_string(builtin.dict_get(cfg, "prefix"), "")
-        target_file_size_bytes = _extract_value_int64(builtin.dict_get(cfg, "target_file_size_bytes"), 0)
-        compression = _extract_value_string(builtin.dict_get(cfg, "compression"), "")
+    cfg: Dict[String, logic.Value] = builtin.dict_from_list(builtin.unwrap_option_or(config_dict, list[Tuple[String, logic.Value]]()))
+    prefix: String = _extract_value_string(builtin.dict_get(cfg, "prefix"), "")
+    target_file_size_bytes: int = _extract_value_int64(builtin.dict_get(cfg, "target_file_size_bytes"), 0)
+    compression: String = _extract_value_string(builtin.dict_get(cfg, "compression"), "")
     return transactions.ExportIcebergConfig(
         locator=locator,
         config=config,

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 := int64(42)" in lines[0]
+    assert "x := 42" in lines[0]
 
     # Second assignment uses =
     lines = []
     expr = Assign(Var("x", _int_type), Lit(100))
     gen.generate_lines(expr, lines, "")
-    assert "x = int64(100)" in lines[0]
+    assert "x = 100" in lines[0]
 
 
 def test_go_return_generation():

sdks/go/src/parser.go

@@ -863,20 +863,19 @@ func (p *Parser) construct_iceberg_config(catalog_uri string, scope_opt *string,
 }
 
 func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergConfig, columns []*pb.IcebergExportColumn, config_dict [][]interface{}) *pb.ExportIcebergConfig {
-	prefix := ""
-	target_file_size_bytes := int64(0)
-	compression := ""
-	if config_dict != nil {
-		cfg := dictFromList(config_dict)
-		_t2098 := p._extract_value_string(dictGetValue(cfg, "prefix"), "")
-		prefix = _t2098
-		_t2099 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0)
-		target_file_size_bytes = _t2099
-		_t2100 := p._extract_value_string(dictGetValue(cfg, "compression"), "")
-		compression = _t2100
-	}
-	_t2101 := &pb.ExportIcebergConfig{Locator: locator, Config: config, Columns: columns, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression}
-	return _t2101
+	_t2098 := config_dict
+	if config_dict == nil {
+		_t2098 = [][]interface{}{}
+	}
+	cfg := dictFromList(_t2098)
+	_t2099 := p._extract_value_string(dictGetValue(cfg, "prefix"), "")
+	prefix := _t2099
+	_t2100 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0)
+	target_file_size_bytes := _t2100
+	_t2101 := p._extract_value_string(dictGetValue(cfg, "compression"), "")
+	compression := _t2101
+	_t2102 := &pb.ExportIcebergConfig{Locator: locator, Config: config, Columns: columns, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression}
+	return _t2102
 }
 
 // --- Parse functions ---

sdks/julia/LogicalQueryProtocol.jl/src/parser.jl

@@ -572,18 +572,13 @@ function construct_iceberg_config(parser::ParserState, catalog_uri::String, scop
 end
 
 function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergConfig, columns::Vector{Proto.IcebergExportColumn}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig
-    prefix = ""
-    target_file_size_bytes = 0
-    compression = ""
-    if !isnothing(config_dict)
-        cfg = Dict(config_dict)
-        _t2087 = _extract_value_string(parser, get(cfg, "prefix", nothing), "")
-        prefix = _t2087
-        _t2088 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0)
-        target_file_size_bytes = _t2088
-        _t2089 = _extract_value_string(parser, get(cfg, "compression", nothing), "")
-        compression = _t2089
-    end
+    cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[]))
+    _t2087 = _extract_value_string(parser, get(cfg, "prefix", nothing), "")
+    prefix = _t2087
+    _t2088 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0)
+    target_file_size_bytes = _t2088
+    _t2089 = _extract_value_string(parser, get(cfg, "compression", nothing), "")
+    compression = _t2089
     _t2090 = Proto.ExportIcebergConfig(locator=locator, config=config, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression)
     return _t2090
 end

sdks/python/src/lqp/gen/parser.py

@@ -650,18 +650,13 @@ def construct_iceberg_config(self, catalog_uri: str, scope_opt: str | None, prop
         return _t2095
 
     def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergConfig, columns: Sequence[transactions_pb2.IcebergExportColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig:
-        prefix = ""
-        target_file_size_bytes = 0
-        compression = ""
-        if config_dict is not None:
-            assert config_dict is not None
-            cfg = dict(config_dict)
-            _t2096 = self._extract_value_string(cfg.get("prefix"), "")
-            prefix = _t2096
-            _t2097 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0)
-            target_file_size_bytes = _t2097
-            _t2098 = self._extract_value_string(cfg.get("compression"), "")
-            compression = _t2098
+        cfg = dict((config_dict if config_dict is not None else []))
+        _t2096 = self._extract_value_string(cfg.get("prefix"), "")
+        prefix = _t2096
+        _t2097 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0)
+        target_file_size_bytes = _t2097
+        _t2098 = self._extract_value_string(cfg.get("compression"), "")
+        compression = _t2098
         _t2099 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, columns=columns, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression)
         return _t2099