finish dict literals

Author: BobTheBuidler

mypyc/analysis/ircheck.py

@@ -285,6 +285,25 @@ def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[obj
             else:
                 self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")
 
+    def check_dict_items_valid_literals(self, op: LoadLiteral, d: dict[object, object]) -> None:
+        key_types = (str, bytes, bool, int, float, complex, tuple)
+        value_types = (str, bytes, bool, int, float, complex, tuple, dict, frozenset)
+        for k, v in d.items():
+            # Acceptable key types: str, bytes, bool, int, float, complex, tuple, None
+            if k is not None and not isinstance(k, key_types):
+                self.fail(op, f"Invalid type for key of dict literal: {type(k)})")
+            if isinstance(k, tuple):
+                self.check_tuple_items_valid_literals(op, k)
+            # Acceptable value types: str, bytes, bool, int, float, complex, tuple, dict, frozenset, None
+            if v is not None and not isinstance(v, value_types):
+                self.fail(op, f"Invalid type for value of dict literal: {type(v)})")
+            if isinstance(v, tuple):
+                self.check_tuple_items_valid_literals(op, v)
+            elif isinstance(v, dict):
+                self.check_dict_items_valid_literals(op, v)
+            elif isinstance(v, frozenset):
+                self.check_frozenset_items_valid_literals(op, v)
+
     def visit_load_literal(self, op: LoadLiteral) -> None:
         expected_type = None
         if op.value is None:
@@ -309,6 +328,9 @@ def visit_load_literal(self, op: LoadLiteral) -> None:
             # it's a set (when it's really a frozenset).
             expected_type = "builtins.set"
             self.check_frozenset_items_valid_literals(op, op.value)
+        elif isinstance(op.value, dict):
+            expected_type = "builtins.dict"
+            self.check_dict_items_valid_literals(op, op.value)
 
         assert expected_type is not None, "Missed a case for LoadLiteral check"
 

mypyc/codegen/emitmodule.py

@@ -708,6 +708,9 @@ def generate_literal_tables(self) -> None:
         # Descriptions of frozenset literals
         init_frozenset = c_array_initializer(literals.encoded_frozenset_values())
         self.declare_global("const int []", "CPyLit_FrozenSet", initializer=init_frozenset)
+        # Descriptions of dict literals
+        init_dict = c_array_initializer(literals.encoded_dict_values())
+        self.declare_global("const int []", "CPyLit_Dict", initializer=init_dict)
 
     def generate_export_table(self, decl_emitter: Emitter, code_emitter: Emitter) -> None:
         """Generate the declaration and definition of the group's export struct.
@@ -926,11 +929,13 @@ def generate_globals_init(self, emitter: Emitter) -> None:
         for symbol, fixup in self.simple_inits:
             emitter.emit_line(f"{symbol} = {fixup};")
 
-        values = "CPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSet"
+        values = "CPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSet, CPyLit_Dict"
         emitter.emit_lines(
             f"if (CPyStatics_Initialize(CPyStatics, {values}) < 0) {{", "return -1;", "}"
         )
 
+        # (No per-dict static assignments needed; dict statics are handled by Literals)
+
         emitter.emit_lines("is_initialized = 1;", "return 0;", "}")
 
     def generate_module_def(self, emitter: Emitter, module_name: str, module: ModuleIR) -> None:

mypyc/codegen/literals.py

@@ -72,8 +72,7 @@ def record_literal(self, value: LiteralValue) -> None:
                     self.record_literal(item)
                 frozenset_literals[value] = len(frozenset_literals)
         elif isinstance(value, dict):
-            # Represent dicts as a tuple of sorted (key, value) pairs for uniqueness
-            items = tuple(sorted(value.items()))
+            items = self.make_dict_literal_key(value)
             dict_literals = self.dict_literals
             if items not in dict_literals:
                 for k, v in items:
@@ -118,10 +117,14 @@ def literal_index(self, value: LiteralValue) -> int:
             return n + self.frozenset_literals[value]
         n += len(self.frozenset_literals)
         if isinstance(value, dict):
-            items = tuple(sorted(value.items()))
-            return n + self.dict_literals[items]
+            key = self.make_dict_literal_key(value)
+            return n + self.dict_literals[key]
         assert False, "invalid literal: %r" % value
 
+    def make_dict_literal_key(self, value: dict) -> tuple:
+        """Make a unique key for a literal dict."""
+        return tuple(value.items())
+    
     def num_literals(self) -> int:
         # The first three are for None, True and False
         return (

mypyc/ir/ops.py

@@ -812,6 +812,10 @@ class LoadLiteral(RegisterOp):
 
     Tuple / frozenset literals must contain only valid literal values as items.
 
+    Dict literals must contain only literal keys and literal values.
+    Due to their mutability, dict literals will be copied from the main template
+    at each use.
+
     NOTE: You can use this to load boxed (Python) int objects. Use
           Integer to load unboxed, tagged integers or fixed-width,
           low-level integers.

mypyc/irbuild/expression.py

@@ -1015,8 +1015,8 @@ def _visit_tuple_display(builder: IRBuilder, expr: TupleExpr) -> Value:
 def dict_literal_values(builder: IRBuilder, items: Sequence[tuple[Expression | None, Expression]], line: int) -> "Value | None":
     """Try to extract a constant dict from a dict literal.
 
-    If all keys and values are deeply immutable and constant, build a static dict at module init,
-    register it as a static, and return a LoadStatic for it. Otherwise, return None.
+    If all keys and values are deeply immutable and constant, register it as a static
+    and return a LoadLiteral for it. Otherwise, return None.
     """
     result = {}
     for key_expr, value_expr in items:
@@ -1032,19 +1032,7 @@ def dict_literal_values(builder: IRBuilder, items: Sequence[tuple[Expression | N
             return None
         result[key] = value
 
-    dict_reg = builder.call_c(dict_new_op, [], line)
-    for k, v in result.items():
-        key = builder.load_literal_value(k)
-        value = builder.load_literal_value(v)
-        builder.primitive_op(dict_set_item_op, [dict_reg, key, value], line)
-
-    # Register as a static with a unique name
-    static_name = f"__mypyc_dict_template__{abs(hash(tuple(sorted(result.items()))))}"
-
-    if _static_dicts.get(static_name) is None:
-        _static_dicts[static_name] = builder.add(InitStatic(dict_reg, static_name, builder.module_name))
-    
-    return builder.add(LoadStatic(dict_rprimitive, static_name, builder.module_name))
+    return builder.add(LoadLiteral(result, dict_rprimitive)) if result else None
 
 def transform_dict_expr(builder: IRBuilder, expr: DictExpr) -> Value:
     """First accepts all keys and values, then makes a dict out of them.
@@ -1068,8 +1056,6 @@ def transform_dict_expr(builder: IRBuilder, expr: DictExpr) -> Value:
     return builder.builder.make_dict(key_value_pairs, expr.line)
 
 
-_static_dicts = {}
-
 def transform_set_expr(builder: IRBuilder, expr: SetExpr) -> Value:
     return _visit_display(
         builder, expr.items, builder.new_set_op, set_add_op, set_update_op, expr.line, False

mypyc/lib-rt/CPy.h

@@ -931,7 +931,8 @@ int CPyStatics_Initialize(PyObject **statics,
                           const double *floats,
                           const double *complex_numbers,
                           const int *tuples,
-                          const int *frozensets);
+                          const int *frozensets,
+                          const int *dicts);
 PyObject *CPy_Super(PyObject *builtins, PyObject *self);
 PyObject *CPy_CallReverseOpMethod(PyObject *left, PyObject *right, const char *op,
                                   _Py_Identifier *method);

mypyc/lib-rt/misc_ops.c

@@ -615,7 +615,8 @@ int CPyStatics_Initialize(PyObject **statics,
                           const double *floats,
                           const double *complex_numbers,
                           const int *tuples,
-                          const int *frozensets) {
+                          const int *frozensets,
+                          const int *dicts) {
     PyObject **result = statics;
     // Start with some hard-coded values
     *result++ = Py_None;
@@ -733,6 +734,31 @@ int CPyStatics_Initialize(PyObject **statics,
             *result++ = obj;
         }
     }
+    if (dicts) {
+        int num = *dicts++;
+        while (num-- > 0) {
+            int num_items = *dicts++;
+            PyObject *obj = PyDict_New();
+            if (obj == NULL) {
+                return -1;
+            }
+            for (int i = 0; i < num_items; i++) {
+                PyObject *key = statics[*dicts++];
+                PyObject *value = statics[*dicts++];
+                Py_INCREF(key);
+                Py_INCREF(value);
+                if (PyDict_SetItem(obj, key, value) == -1) {
+                    Py_DECREF(key);
+                    Py_DECREF(value);
+                    Py_DECREF(obj);
+                    return -1;
+                }
+                Py_DECREF(key);
+                Py_DECREF(value);
+            }
+            *result++ = obj;
+        }
+    }
     return 0;
 }
 

mypyc/test-data/irbuild-basic.test

@@ -1730,61 +1730,49 @@ L0:
     r0 = (a, b, c)
     return r0
 def g():
-    r0, r1, r2 :: str
-    r3, r4, r5 :: object
-    r6, r7 :: dict
-    r8 :: str
-    r9 :: object
-    r10 :: tuple
-    r11 :: dict
-    r12 :: object
-    r13 :: tuple[int, int, int]
-L0:
-    r0 = 'a'
-    r1 = 'b'
-    r2 = 'c'
-    r3 = object 1
-    r4 = object 2
-    r5 = object 3
-    r6 = CPyDict_Build(3, r0, r3, r1, r4, r2, r5)
-    r7 = __main__.globals :: static
-    r8 = 'f'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = CPyTuple_LoadEmptyTupleConstant()
-    r11 = PyDict_Copy(r6)
-    r12 = PyObject_Call(r9, r10, r11)
-    r13 = unbox(tuple[int, int, int], r12)
-    return r13
-def h():
-    r0, r1 :: str
-    r2, r3 :: object
-    r4, r5 :: dict
-    r6 :: str
+    r0, r1, r2 :: dict
+    r3 :: str
+    r4 :: object
+    r5 :: tuple
+    r6 :: dict
     r7 :: object
-    r8 :: dict
-    r9 :: i32
-    r10 :: bit
-    r11 :: object
-    r12 :: tuple
-    r13 :: object
-    r14 :: tuple[int, int, int]
+    r8 :: tuple[int, int, int]
+L0:
+    r0 = {'a': 1, 'b': 2, 'c': 3}
+    r1 = PyDict_Copy(r0)
+    r2 = __main__.globals :: static
+    r3 = 'f'
+    r4 = CPyDict_GetItem(r2, r3)
+    r5 = CPyTuple_LoadEmptyTupleConstant()
+    r6 = PyDict_Copy(r1)
+    r7 = PyObject_Call(r4, r5, r6)
+    r8 = unbox(tuple[int, int, int], r7)
+    return r8
+def h():
+    r0, r1, r2 :: dict
+    r3 :: str
+    r4 :: object
+    r5 :: dict
+    r6 :: i32
+    r7 :: bit
+    r8 :: object
+    r9 :: tuple
+    r10 :: object
+    r11 :: tuple[int, int, int]
 L0:
-    r0 = 'b'
-    r1 = 'c'
-    r2 = object 2
-    r3 = object 3
-    r4 = CPyDict_Build(2, r0, r2, r1, r3)
-    r5 = __main__.globals :: static
-    r6 = 'f'
-    r7 = CPyDict_GetItem(r5, r6)
-    r8 = PyDict_New()
-    r9 = CPyDict_UpdateInDisplay(r8, r4)
-    r10 = r9 >= 0 :: signed
-    r11 = object 1
-    r12 = PyTuple_Pack(1, r11)
-    r13 = PyObject_Call(r7, r12, r8)
-    r14 = unbox(tuple[int, int, int], r13)
-    return r14
+    r0 = {'b': 2, 'c': 3}
+    r1 = PyDict_Copy(r0)
+    r2 = __main__.globals :: static
+    r3 = 'f'
+    r4 = CPyDict_GetItem(r2, r3)
+    r5 = PyDict_New()
+    r6 = CPyDict_UpdateInDisplay(r5, r1)
+    r7 = r6 >= 0 :: signed
+    r8 = object 1
+    r9 = PyTuple_Pack(1, r8)
+    r10 = PyObject_Call(r4, r9, r5)
+    r11 = unbox(tuple[int, int, int], r10)
+    return r11
 
 [case testFunctionCallWithDefaultArgs]
 def f(x: int, y: int = 3, z: str = "test") -> None:

mypyc/test-data/irbuild-dict.test

@@ -565,3 +565,18 @@ L2:
 L3:
     r7 = box(None, 1)
     return r7
+
+[case testNestedDictLiteral]
+def f() -> None:
+    d = {"a": {2: 3.4}}
+[out]
+def f():
+    r0 :: str
+    r1, r2, r3, d :: dict
+L0:
+    r0 = 'a'
+    r1 = {2: 3.4}
+    r2 = PyDict_Copy(r1)
+    r3 = CPyDict_Build(1, r0, r2)
+    d = r3
+    return 1