chore: rename true dict to exact dict

Author: BobTheBuidler

mypyc/analysis/ircheck.py

@@ -70,7 +70,7 @@
     range_rprimitive,
     set_rprimitive,
     str_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
     tuple_rprimitive,
 )
 
@@ -177,7 +177,7 @@ def check_op_sources_valid(fn: FuncIR) -> list[FnError]:
     int_rprimitive.name,
     bytes_rprimitive.name,
     str_rprimitive.name,
-    true_dict_rprimitive.name,
+    exact_dict_rprimitive.name,
     dict_rprimitive.name,
     list_rprimitive.name,
     set_rprimitive.name,

mypyc/ir/rtypes.py

@@ -488,8 +488,8 @@ def __hash__(self) -> int:
 )
 
 # Python dict object.
-true_dict_rprimitive: Final = RPrimitive(
-    "builtins.dict[confirmed]", is_unboxed=False, is_refcounted=True
+exact_dict_rprimitive: Final = RPrimitive(
+    "builtins.dict[exact]", is_unboxed=False, is_refcounted=True
 )
 """A primitive for dicts that are confirmed to be actual instances of builtins.dict, not a subclass."""
 
@@ -608,12 +608,12 @@ def is_list_rprimitive(rtype: RType) -> bool:
 def is_dict_rprimitive(rtype: RType) -> bool:
     return isinstance(rtype, RPrimitive) and rtype.name in (
         "builtins.dict",
-        "builtins.dict[confirmed]",
+        "builtins.dict[exact]",
     )
 
 
-def is_true_dict_rprimitive(rtype: RType) -> bool:
-    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.dict[confirmed]"
+def is_exact_dict_rprimitive(rtype: RType) -> bool:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.dict[exact]"
 
 
 def is_set_rprimitive(rtype: RType) -> bool:

mypyc/irbuild/builder.py

@@ -102,7 +102,7 @@
     none_rprimitive,
     object_rprimitive,
     str_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
 )
 from mypyc.irbuild.context import FuncInfo, ImplicitClass
 from mypyc.irbuild.ll_builder import LowLevelIRBuilder
@@ -1375,7 +1375,7 @@ def load_global_str(self, name: str, line: int) -> Value:
         return self.primitive_op(true_dict_get_item_op, [_globals, reg], line)
 
     def load_globals_dict(self) -> Value:
-        return self.add(LoadStatic(true_dict_rprimitive, "globals", self.module_name))
+        return self.add(LoadStatic(exact_dict_rprimitive, "globals", self.module_name))
 
     def load_module_attr_by_fullname(self, fullname: str, line: int) -> Value:
         module, _, name = fullname.rpartition(".")

mypyc/irbuild/classdef.py

@@ -54,7 +54,7 @@
     is_object_rprimitive,
     is_optional_type,
     object_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder, create_type_params
 from mypyc.irbuild.function import (
@@ -603,7 +603,7 @@ def setup_non_ext_dict(
         py_hasattr_op, [metaclass, builder.load_str("__prepare__")], cdef.line
     )
 
-    non_ext_dict = Register(true_dict_rprimitive)
+    non_ext_dict = Register(exact_dict_rprimitive)
 
     true_block, false_block, exit_block = BasicBlock(), BasicBlock(), BasicBlock()
     builder.add_bool_branch(has_prepare, true_block, false_block)

mypyc/irbuild/for_helpers.py

@@ -52,7 +52,7 @@
     is_sequence_rprimitive,
     is_short_int_rprimitive,
     is_str_rprimitive,
-    is_true_dict_rprimitive,
+    is_exact_dict_rprimitive,
     is_tuple_rprimitive,
     object_pointer_rprimitive,
     object_rprimitive,
@@ -422,7 +422,7 @@ def make_for_loop_generator(
         expr_reg = builder.accept(expr)
         target_type = builder.get_dict_key_type(expr)
         for_loop_cls = (
-            ForTrueDictionaryKeys if is_true_dict_rprimitive(rtyp) else ForDictionaryKeys
+            ForExactDictionaryKeys if is_exact_dict_rprimitive(rtyp) else ForDictionaryKeys
         )
         for_dict = for_loop_cls(builder, index, body_block, loop_exit, line, nested)
         for_dict.init(expr_reg, target_type)
@@ -506,20 +506,20 @@ def make_for_loop_generator(
             for_dict_type: type[ForGenerator] | None = None
             if expr.callee.name == "keys":
                 target_type = builder.get_dict_key_type(expr.callee.expr)
-                if is_true_dict_rprimitive(rtype):
-                    for_dict_type = ForTrueDictionaryKeys
+                if is_exact_dict_rprimitive(rtype):
+                    for_dict_type = ForExactDictionaryKeys
                 else:
                     for_dict_type = ForDictionaryKeys
             elif expr.callee.name == "values":
                 target_type = builder.get_dict_value_type(expr.callee.expr)
-                if is_true_dict_rprimitive(rtype):
-                    for_dict_type = ForTrueDictionaryValues
+                if is_exact_dict_rprimitive(rtype):
+                    for_dict_type = ForExactDictionaryValues
                 else:
                     for_dict_type = ForDictionaryValues
             else:
                 target_type = builder.get_dict_item_type(expr.callee.expr)
-                if is_true_dict_rprimitive(rtype):
-                    for_dict_type = ForTrueDictionaryItems
+                if is_exact_dict_rprimitive(rtype):
+                    for_dict_type = ForExactDictionaryItems
                 else:
                     for_dict_type = ForDictionaryItems
             for_dict_gen = for_dict_type(builder, index, body_block, loop_exit, line, nested)
@@ -1009,23 +1009,23 @@ def begin_body(self) -> None:
             builder.assign(target, rvalue, line)
 
 
-class ForTrueDictionaryKeys(ForDictionaryKeys):
+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
 
 
-class ForTrueDictionaryValues(ForDictionaryValues):
+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
 
 
-class ForTrueDictionaryItems(ForDictionaryItems):
+class ForExactDictionaryItems(ForDictionaryItems):
     """Generate optimized IR for a for loop over dictionary items without type checks."""
 
     dict_next_op = true_dict_next_item_op

mypyc/irbuild/function.py

@@ -58,7 +58,7 @@
     bool_rprimitive,
     int_rprimitive,
     object_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder, calculate_arg_defaults, gen_arg_defaults
 from mypyc.irbuild.callable_class import (
@@ -801,7 +801,7 @@ def generate_singledispatch_dispatch_function(
 
     arg_type = builder.builder.get_type_of_obj(arg_info.args[0], line)
     dispatch_cache = builder.builder.get_attr(
-        dispatch_func_obj, "dispatch_cache", true_dict_rprimitive, line
+        dispatch_func_obj, "dispatch_cache", exact_dict_rprimitive, line
     )
     call_find_impl, use_cache, call_func = BasicBlock(), BasicBlock(), BasicBlock()
     get_result = builder.primitive_op(
@@ -883,8 +883,8 @@ def gen_dispatch_func_ir(
     """
     builder.enter(FuncInfo(fitem, dispatch_name))
     setup_callable_class(builder)
-    builder.fn_info.callable_class.ir.attributes["registry"] = true_dict_rprimitive
-    builder.fn_info.callable_class.ir.attributes["dispatch_cache"] = true_dict_rprimitive
+    builder.fn_info.callable_class.ir.attributes["registry"] = exact_dict_rprimitive
+    builder.fn_info.callable_class.ir.attributes["dispatch_cache"] = exact_dict_rprimitive
     builder.fn_info.callable_class.ir.has_dict = True
     builder.fn_info.callable_class.ir.needs_getseters = True
     generate_singledispatch_callable_class_ctor(builder)
@@ -947,7 +947,7 @@ def add_register_method_to_callable_class(builder: IRBuilder, fn_info: FuncInfo)
 
 
 def load_singledispatch_registry(builder: IRBuilder, dispatch_func_obj: Value, line: int) -> Value:
-    return builder.builder.get_attr(dispatch_func_obj, "registry", true_dict_rprimitive, line)
+    return builder.builder.get_attr(dispatch_func_obj, "registry", exact_dict_rprimitive, line)
 
 
 def singledispatch_main_func_name(orig_name: str) -> str:
@@ -998,7 +998,7 @@ def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
             loaded_type = load_type(builder, typ, None, line)
             builder.primitive_op(true_dict_set_item_op, [registry, loaded_type, to_insert], line)
         dispatch_cache = builder.builder.get_attr(
-            dispatch_func_obj, "dispatch_cache", true_dict_rprimitive, line
+            dispatch_func_obj, "dispatch_cache", exact_dict_rprimitive, line
         )
         builder.gen_method_call(dispatch_cache, "clear", [], None, line)
 

mypyc/irbuild/ll_builder.py

@@ -109,7 +109,7 @@
     is_short_int_rprimitive,
     is_str_rprimitive,
     is_tagged,
-    is_true_dict_rprimitive,
+    is_exact_dict_rprimitive,
     is_tuple_rprimitive,
     is_uint8_rprimitive,
     list_rprimitive,
@@ -120,7 +120,7 @@
     pointer_rprimitive,
     short_int_rprimitive,
     str_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
 )
 from mypyc.irbuild.util import concrete_arg_kind
 from mypyc.options import CompilerOptions
@@ -796,7 +796,7 @@ def _construct_varargs(
             elif kind == ARG_STAR2:
                 if star2_result is None:
                     star2_result = self._create_dict(star2_keys, star2_values, line)
-                if is_true_dict_rprimitive(value.type):
+                if is_exact_dict_rprimitive(value.type):
                     op = true_dict_update_in_display_op
                 else:
                     op = dict_update_in_display_op
@@ -1664,13 +1664,13 @@ def make_dict(self, key_value_pairs: Sequence[DictEntry], line: int) -> Value:
             else:
                 # **value
                 if result is None:
-                    if len(key_value_pairs) == 1 and is_true_dict_rprimitive(value.type):
+                    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)
 
                     result = self._create_dict(keys, values, line)
 
-                if is_true_dict_rprimitive(value.type):
+                if is_exact_dict_rprimitive(value.type):
                     op = true_dict_update_in_display_op
                 else:
                     op = dict_update_in_display_op
@@ -1779,7 +1779,7 @@ def bool_value(self, value: Value) -> Value:
             result = self.add(ComparisonOp(value, zero, ComparisonOp.NEQ))
         elif is_same_type(value.type, str_rprimitive):
             result = self.call_c(str_check_if_true, [value], value.line)
-        elif is_same_type(value.type, true_dict_rprimitive):
+        elif is_same_type(value.type, exact_dict_rprimitive):
             result = self.call_c(dict_is_true_op, [value], line=value.line)
         elif is_same_type(value.type, list_rprimitive) or is_same_type(
             value.type, dict_rprimitive
@@ -2286,7 +2286,7 @@ def builtin_len(self, val: Value, line: int, use_pyssize_t: bool = False) -> Val
             elem_address = self.add(GetElementPtr(val, PySetObject, "used"))
             size_value = self.load_mem(elem_address, c_pyssize_t_rprimitive)
             self.add(KeepAlive([val]))
-        elif is_true_dict_rprimitive(typ):
+        elif is_exact_dict_rprimitive(typ):
             size_value = self.call_c(true_dict_ssize_t_size_op, [val], line)
         elif is_dict_rprimitive(typ):
             size_value = self.call_c(dict_ssize_t_size_op, [val], line)

mypyc/irbuild/mapper.py

@@ -44,7 +44,7 @@
     range_rprimitive,
     set_rprimitive,
     str_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
     tuple_rprimitive,
     uint8_rprimitive,
 )
@@ -90,7 +90,7 @@ def type_to_rtype(self, typ: Type | None) -> RType:
             # specifically support them, so make sure that dict operations
             # get optimized on them.
             elif typ.type.fullname == "builtins.dict":
-                return true_dict_rprimitive
+                return exact_dict_rprimitive
             elif any(cls.fullname == "builtins.dict" for cls in typ.type.mro):
                 return dict_rprimitive
             elif typ.type.fullname == "builtins.set":
@@ -150,7 +150,7 @@ def type_to_rtype(self, typ: Type | None) -> RType:
         elif isinstance(typ, Overloaded):
             return object_rprimitive
         elif isinstance(typ, TypedDictType):
-            return true_dict_rprimitive
+            return exact_dict_rprimitive
         elif isinstance(typ, LiteralType):
             return self.type_to_rtype(typ.fallback)
         elif isinstance(typ, (UninhabitedType, UnboundType)):
@@ -165,7 +165,7 @@ def get_arg_rtype(self, typ: Type, kind: ArgKind) -> RType:
         if kind == ARG_STAR:
             return tuple_rprimitive
         elif kind == ARG_STAR2:
-            return true_dict_rprimitive
+            return exact_dict_rprimitive
         else:
             return self.type_to_rtype(typ)
 

mypyc/irbuild/prepare.py

@@ -57,7 +57,7 @@
     none_rprimitive,
     object_pointer_rprimitive,
     object_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
     tuple_rprimitive,
 )
 from mypyc.irbuild.mapper import Mapper
@@ -543,7 +543,7 @@ def prepare_init_method(cdef: ClassDef, ir: ClassIR, module_name: str, mapper: M
                 [
                     init_sig.args[0],
                     RuntimeArg("args", tuple_rprimitive, ARG_STAR),
-                    RuntimeArg("kwargs", true_dict_rprimitive, ARG_STAR2),
+                    RuntimeArg("kwargs", exact_dict_rprimitive, ARG_STAR2),
                 ],
                 init_sig.ret_type,
             )

mypyc/irbuild/specialize.py

@@ -64,12 +64,12 @@
     is_int64_rprimitive,
     is_int_rprimitive,
     is_list_rprimitive,
-    is_true_dict_rprimitive,
+    is_exact_dict_rprimitive,
     is_uint8_rprimitive,
     list_rprimitive,
     set_rprimitive,
     str_rprimitive,
-    true_dict_rprimitive,
+    exact_dict_rprimitive,
     uint8_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder
@@ -254,17 +254,17 @@ def dict_methods_fast_path(builder: IRBuilder, expr: CallExpr, callee: RefExpr)
     # so the corresponding helpers in CPy.h fallback to (inlined)
     # generic logic.
     if attr == "keys":
-        if is_true_dict_rprimitive(rtype):
+        if is_exact_dict_rprimitive(rtype):
             op = true_dict_keys_op
         else:
             op = dict_keys_op
     elif attr == "values":
-        if is_true_dict_rprimitive(rtype):
+        if is_exact_dict_rprimitive(rtype):
             op = true_dict_values_op
         else:
             op = dict_values_op
     else:
-        if is_true_dict_rprimitive(rtype):
+        if is_exact_dict_rprimitive(rtype):
             op = true_dict_items_op
         else:
             op = dict_items_op
@@ -378,7 +378,7 @@ def faster_min_max(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
 @specialize_function("join", str_rprimitive)
 @specialize_function("extend", list_rprimitive)
 @specialize_function("update", dict_rprimitive)
-@specialize_function("update", true_dict_rprimitive)
+@specialize_function("update", exact_dict_rprimitive)
 @specialize_function("update", set_rprimitive)
 def translate_safe_generator_call(
     builder: IRBuilder, expr: CallExpr, callee: RefExpr
@@ -620,7 +620,7 @@ def translate_isinstance(builder: IRBuilder, expr: CallExpr, callee: RefExpr) ->
 
 
 @specialize_function("setdefault", dict_rprimitive)
-@specialize_function("setdefault", true_dict_rprimitive)
+@specialize_function("setdefault", exact_dict_rprimitive)
 def translate_dict_setdefault(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     """Special case for 'dict.setdefault' which would only construct
     default empty collection when needed.