chore: rename true_dict ops to exact_dict

Author: BobTheBuidler

mypyc/irbuild/builder.py

@@ -124,7 +124,7 @@
 )
 from mypyc.irbuild.util import bytes_from_str, is_constant
 from mypyc.options import CompilerOptions
-from mypyc.primitives.dict_ops import dict_set_item_op, true_dict_get_item_op
+from mypyc.primitives.dict_ops import dict_set_item_op, exact_dict_get_item_op
 from mypyc.primitives.generic_ops import iter_op, next_op, py_setattr_op
 from mypyc.primitives.list_ops import list_get_item_unsafe_op, list_pop_last, to_list
 from mypyc.primitives.misc_ops import check_unpack_count_op, get_module_dict_op, import_op
@@ -431,7 +431,7 @@ def add_to_non_ext_dict(
     ) -> None:
         # Add an attribute entry into the class dict of a non-extension class.
         key_unicode = self.load_str(key)
-        # must use `dict_set_item_op` instead of `true_dict_set_item_op` because
+        # must use `dict_set_item_op` instead of `exact_dict_set_item_op` because
         # it breaks enums, and probably other stuff, if we take the fast path.
         self.primitive_op(dict_set_item_op, [non_ext.dict, key_unicode, val], line)
 
@@ -464,7 +464,7 @@ def get_module(self, module: str, line: int) -> Value:
         # Python 3.7 has a nice 'PyImport_GetModule' function that we can't use :(
         mod_dict = self.call_c(get_module_dict_op, [], line)
         # Get module object from modules dict.
-        return self.primitive_op(true_dict_get_item_op, [mod_dict, self.load_str(module)], line)
+        return self.primitive_op(exact_dict_get_item_op, [mod_dict, self.load_str(module)], line)
 
     def get_module_attr(self, module: str, attr: str, line: int) -> Value:
         """Look up an attribute of a module without storing it in the local namespace.
@@ -1372,7 +1372,7 @@ def load_global(self, expr: NameExpr) -> Value:
     def load_global_str(self, name: str, line: int) -> Value:
         _globals = self.load_globals_dict()
         reg = self.load_str(name)
-        return self.primitive_op(true_dict_get_item_op, [_globals, reg], line)
+        return self.primitive_op(exact_dict_get_item_op, [_globals, reg], line)
 
     def load_globals_dict(self) -> Value:
         return self.add(LoadStatic(exact_dict_rprimitive, "globals", self.module_name))

mypyc/irbuild/classdef.py

@@ -66,7 +66,7 @@
 )
 from mypyc.irbuild.prepare import GENERATOR_HELPER_NAME
 from mypyc.irbuild.util import dataclass_type, get_func_def, is_constant, is_dataclass_decorator
-from mypyc.primitives.dict_ops import dict_new_op, true_dict_set_item_op
+from mypyc.primitives.dict_ops import dict_new_op, exact_dict_set_item_op
 from mypyc.primitives.generic_ops import (
     iter_op,
     next_op,
@@ -269,7 +269,7 @@ def finalize(self, ir: ClassIR) -> None:
 
         # Add the non-extension class to the dict
         self.builder.primitive_op(
-            true_dict_set_item_op,
+            exact_dict_set_item_op,
             [
                 self.builder.load_globals_dict(),
                 self.builder.load_str(self.cdef.name),
@@ -480,7 +480,7 @@ def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
 
     # Add it to the dict
     builder.primitive_op(
-        true_dict_set_item_op,
+        exact_dict_set_item_op,
         [builder.load_globals_dict(), builder.load_str(cdef.name), tp],
         cdef.line,
     )
@@ -666,7 +666,7 @@ def add_non_ext_class_attr_ann(
             typ = builder.add(LoadAddress(type_object_op.type, type_object_op.src, stmt.line))
 
     key = builder.load_str(lvalue.name)
-    builder.primitive_op(true_dict_set_item_op, [non_ext.anns, key, typ], stmt.line)
+    builder.primitive_op(exact_dict_set_item_op, [non_ext.anns, key, typ], stmt.line)
 
 
 def add_non_ext_class_attr(

mypyc/irbuild/expression.py

@@ -97,7 +97,7 @@
 )
 from mypyc.irbuild.specialize import apply_function_specialization, apply_method_specialization
 from mypyc.primitives.bytes_ops import bytes_slice_op
-from mypyc.primitives.dict_ops import dict_new_op, true_dict_get_item_op, true_dict_set_item_op
+from mypyc.primitives.dict_ops import dict_new_op, exact_dict_get_item_op, exact_dict_set_item_op
 from mypyc.primitives.generic_ops import iter_op
 from mypyc.primitives.list_ops import list_append_op, list_extend_op, list_slice_op
 from mypyc.primitives.misc_ops import ellipsis_op, get_module_dict_op, new_slice_op, type_op
@@ -183,7 +183,7 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
             # instead load the module separately on each access.
             mod_dict = builder.call_c(get_module_dict_op, [], expr.line)
             obj = builder.primitive_op(
-                true_dict_get_item_op, [mod_dict, builder.load_str(expr.node.fullname)], expr.line
+                exact_dict_get_item_op, [mod_dict, builder.load_str(expr.node.fullname)], expr.line
             )
             return obj
         else:
@@ -1030,7 +1030,7 @@ def transform_dictionary_comprehension(builder: IRBuilder, o: DictionaryComprehe
     def gen_inner_stmts() -> None:
         k = builder.accept(o.key)
         v = builder.accept(o.value)
-        builder.primitive_op(true_dict_set_item_op, [builder.read(d), k, v], o.line)
+        builder.primitive_op(exact_dict_set_item_op, [builder.read(d), k, v], o.line)
 
     comprehension_helper(builder, loop_params, gen_inner_stmts, o.line)
     return builder.read(d)

mypyc/irbuild/for_helpers.py

@@ -70,11 +70,11 @@
     dict_next_key_op,
     dict_next_value_op,
     dict_value_iter_op,
-    true_dict_check_size_op,
-    true_dict_iter_fast_path_op,
-    true_dict_next_item_op,
-    true_dict_next_key_op,
-    true_dict_next_value_op,
+    exact_dict_check_size_op,
+    exact_dict_iter_fast_path_op,
+    exact_dict_next_item_op,
+    exact_dict_next_key_op,
+    exact_dict_next_value_op,
 )
 from mypyc.primitives.exc_ops import no_err_occurred_op, propagate_if_error_op
 from mypyc.primitives.generic_ops import aiter_op, anext_op, iter_op, next_op
@@ -1012,25 +1012,25 @@ def begin_body(self) -> None:
 class ForExactDictionaryKeys(ForDictionaryKeys):
     """Generate optimized IR for a for loop over dictionary items without type checks."""
 
-    dict_next_op = true_dict_next_key_op
-    dict_iter_op = true_dict_iter_fast_path_op
-    dict_size_op = true_dict_check_size_op
+    dict_next_op = exact_dict_next_key_op
+    dict_iter_op = exact_dict_iter_fast_path_op
+    dict_size_op = exact_dict_check_size_op
 
 
 class ForExactDictionaryValues(ForDictionaryValues):
     """Generate optimized IR for a for loop over dictionary items without type checks."""
 
-    dict_next_op = true_dict_next_value_op
-    dict_iter_op = true_dict_iter_fast_path_op
-    dict_size_op = true_dict_check_size_op
+    dict_next_op = exact_dict_next_value_op
+    dict_iter_op = exact_dict_iter_fast_path_op
+    dict_size_op = exact_dict_check_size_op
 
 
 class ForExactDictionaryItems(ForDictionaryItems):
     """Generate optimized IR for a for loop over dictionary items without type checks."""
 
-    dict_next_op = true_dict_next_item_op
-    dict_iter_op = true_dict_iter_fast_path_op
-    dict_size_op = true_dict_check_size_op
+    dict_next_op = exact_dict_next_item_op
+    dict_iter_op = exact_dict_iter_fast_path_op
+    dict_size_op = exact_dict_check_size_op
 
 
 class ForRange(ForGenerator):

mypyc/irbuild/function.py

@@ -78,8 +78,8 @@
 from mypyc.irbuild.targets import AssignmentTarget
 from mypyc.primitives.dict_ops import (
     dict_new_op,
-    true_dict_get_method_with_none,
-    true_dict_set_item_op,
+    exact_dict_get_method_with_none,
+    exact_dict_set_item_op,
 )
 from mypyc.primitives.generic_ops import py_setattr_op
 from mypyc.primitives.misc_ops import register_function
@@ -128,7 +128,7 @@ def transform_decorator(builder: IRBuilder, dec: Decorator) -> None:
     if decorated_func is not None:
         # Set the callable object representing the decorated function as a global.
         builder.primitive_op(
-            true_dict_set_item_op,
+            exact_dict_set_item_op,
             [builder.load_globals_dict(), builder.load_str(dec.func.name), decorated_func],
             decorated_func.line,
         )
@@ -805,7 +805,7 @@ def generate_singledispatch_dispatch_function(
     )
     call_find_impl, use_cache, call_func = BasicBlock(), BasicBlock(), BasicBlock()
     get_result = builder.primitive_op(
-        true_dict_get_method_with_none, [dispatch_cache, arg_type], line
+        exact_dict_get_method_with_none, [dispatch_cache, arg_type], line
     )
     is_not_none = builder.translate_is_op(get_result, builder.none_object(), "is not", line)
     impl_to_use = Register(object_rprimitive)
@@ -819,7 +819,7 @@ def generate_singledispatch_dispatch_function(
     find_impl = builder.load_module_attr_by_fullname("functools._find_impl", line)
     registry = load_singledispatch_registry(builder, dispatch_func_obj, line)
     uncached_impl = builder.py_call(find_impl, [arg_type, registry], line)
-    builder.primitive_op(true_dict_set_item_op, [dispatch_cache, arg_type, uncached_impl], line)
+    builder.primitive_op(exact_dict_set_item_op, [dispatch_cache, arg_type, uncached_impl], line)
     builder.assign(impl_to_use, uncached_impl, line)
     builder.goto(call_func)
 
@@ -996,7 +996,7 @@ def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
         registry = load_singledispatch_registry(builder, dispatch_func_obj, line)
         for typ in types:
             loaded_type = load_type(builder, typ, None, line)
-            builder.primitive_op(true_dict_set_item_op, [registry, loaded_type, to_insert], line)
+            builder.primitive_op(exact_dict_set_item_op, [registry, loaded_type, to_insert], line)
         dispatch_cache = builder.builder.get_attr(
             dispatch_func_obj, "dispatch_cache", exact_dict_rprimitive, line
         )

mypyc/irbuild/ll_builder.py

@@ -130,9 +130,9 @@
     dict_new_op,
     dict_ssize_t_size_op,
     dict_update_in_display_op,
-    true_dict_copy_op,
-    true_dict_ssize_t_size_op,
-    true_dict_update_in_display_op,
+    exact_dict_copy_op,
+    exact_dict_ssize_t_size_op,
+    exact_dict_update_in_display_op,
 )
 from mypyc.primitives.exc_ops import err_occurred_op, keep_propagating_op
 from mypyc.primitives.float_ops import copysign_op, int_to_float_op
@@ -797,7 +797,7 @@ def _construct_varargs(
                 if star2_result is None:
                     star2_result = self._create_dict(star2_keys, star2_values, line)
                 if is_exact_dict_rprimitive(value.type):
-                    op = true_dict_update_in_display_op
+                    op = exact_dict_update_in_display_op
                 else:
                     op = dict_update_in_display_op
                 self.call_c(op, [star2_result, value], line=line)
@@ -1666,12 +1666,12 @@ def make_dict(self, key_value_pairs: Sequence[DictEntry], line: int) -> Value:
                 if result is None:
                     if len(key_value_pairs) == 1 and is_exact_dict_rprimitive(value.type):
                         # fast path for cases like `my_func(**dict(zip(iterable, other)))` and similar
-                        return self.call_c(true_dict_copy_op, [value], line=line)
+                        return self.call_c(exact_dict_copy_op, [value], line=line)
 
                     result = self._create_dict(keys, values, line)
 
                 if is_exact_dict_rprimitive(value.type):
-                    op = true_dict_update_in_display_op
+                    op = exact_dict_update_in_display_op
                 else:
                     op = dict_update_in_display_op
 
@@ -2287,7 +2287,7 @@ def builtin_len(self, val: Value, line: int, use_pyssize_t: bool = False) -> Val
             size_value = self.load_mem(elem_address, c_pyssize_t_rprimitive)
             self.add(KeepAlive([val]))
         elif is_exact_dict_rprimitive(typ):
-            size_value = self.call_c(true_dict_ssize_t_size_op, [val], line)
+            size_value = self.call_c(exact_dict_ssize_t_size_op, [val], line)
         elif is_dict_rprimitive(typ):
             size_value = self.call_c(dict_ssize_t_size_op, [val], line)
         elif is_str_rprimitive(typ):

mypyc/irbuild/match.py

@@ -24,7 +24,7 @@
     dict_copy,
     mapping_has_key,
     supports_mapping_protocol,
-    true_dict_del_item,
+    exact_dict_del_item,
 )
 from mypyc.primitives.generic_ops import generic_ssize_t_len_op
 from mypyc.primitives.list_ops import (
@@ -239,7 +239,7 @@ def visit_mapping_pattern(self, pattern: MappingPattern) -> None:
             self.builder.assign(target, rest, pattern.rest.line)
 
             for i, key_name in enumerate(keys):
-                self.builder.call_c(true_dict_del_item, [rest, key_name], pattern.keys[i].line)
+                self.builder.call_c(exact_dict_del_item, [rest, key_name], pattern.keys[i].line)
 
             self.builder.goto(self.code_block)
 

mypyc/irbuild/specialize.py

@@ -92,9 +92,9 @@
     dict_setdefault_spec_init_op,
     dict_values_op,
     isinstance_dict,
-    true_dict_items_op,
-    true_dict_keys_op,
-    true_dict_values_op,
+    exact_dict_items_op,
+    exact_dict_keys_op,
+    exact_dict_values_op,
 )
 from mypyc.primitives.float_ops import isinstance_float
 from mypyc.primitives.int_ops import isinstance_int
@@ -255,17 +255,17 @@ def dict_methods_fast_path(builder: IRBuilder, expr: CallExpr, callee: RefExpr)
     # generic logic.
     if attr == "keys":
         if is_exact_dict_rprimitive(rtype):
-            op = true_dict_keys_op
+            op = exact_dict_keys_op
         else:
             op = dict_keys_op
     elif attr == "values":
         if is_exact_dict_rprimitive(rtype):
-            op = true_dict_values_op
+            op = exact_dict_values_op
         else:
             op = dict_values_op
     else:
         if is_exact_dict_rprimitive(rtype):
-            op = true_dict_items_op
+            op = exact_dict_items_op
         else:
             op = dict_items_op