Get empty dict issue

Author: huandy4

mypy/checkexpr.py

@@ -473,6 +473,32 @@ def module_type(self, node: MypyFile) -> Instance:
 
     def visit_call_expr(self, e: CallExpr, allow_none_return: bool = False) -> Type:
         """Type check a call expression."""
+        if (
+            self.refers_to_typeddict(e.callee)
+            or isinstance(e.callee, IndexExpr)
+            and self.refers_to_typeddict(e.callee.base)
+        ):
+            typeddict_callable = get_proper_type(self.accept(e.callee, is_callee=True))
+            if isinstance(typeddict_callable, CallableType):
+                typeddict_type = get_proper_type(typeddict_callable.ret_type)
+                assert isinstance(typeddict_type, TypedDictType)
+                return self.check_typeddict_call(
+                    e, typeddict_type, typeddict_callable
+                )
+        
+        # Add logic to handle the `get` method
+        if isinstance(e.callee, MemberExpr) and e.callee.name == 'get':
+            dict_type = self.accept(e.callee.expr)
+            if isinstance(dict_type, Instance) and dict_type.type.fullname == 'builtins.dict':
+                key_type = self.accept(e.args[0])
+                if len(e.args) == 2:
+                    default_type = self.accept(e.args[1])
+                    return UnionType.make_union([dict_type.args[1], default_type])
+                return UnionType.make_union([dict_type.args[1], NoneType()])
+            elif isinstance(dict_type, Instance) and dict_type.type.fullname == 'builtins.dict':
+                # Handle empty dictionary case
+                return AnyType(TypeOfAny.special_form)
+            
         if e.analyzed:
             if isinstance(e.analyzed, NamedTupleExpr) and not e.analyzed.is_typed:
                 # Type check the arguments, but ignore the results. This relies

mypy/checkmember.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Callable, Sequence, cast
-
+from mypy.nodes import ARG_POS, ARG_OPT
 from mypy import meet, message_registry, subtypes
 from mypy.erasetype import erase_typevars
 from mypy.expandtype import (
@@ -203,6 +203,11 @@ def analyze_member_access(
         no_deferral=no_deferral,
         is_self=is_self,
     )
+    
+    if name == 'get' and isinstance(typ, Instance) and typ.type.fullname == 'builtins.dict':
+        # Handle overload resolution for dict.get
+        return analyze_dict_get(typ, context)
+    
     result = _analyze_member_access(name, typ, mx, override_info)
     possible_literal = get_proper_type(result)
     if (
@@ -214,7 +219,17 @@ def analyze_member_access(
     else:
         return result
 
-
+def analyze_dict_get(self, typ: Instance, context: Context) -> Type:
+    key_type = typ.args[0]
+    value_type = typ.args[1]
+    return CallableType(
+        [key_type, value_type],
+        [ARG_POS, ARG_OPT],
+        [None, None],
+        UnionType.make_union([value_type, NoneType()]),
+        self.named_type('builtins.function')
+    )
+    
 def _analyze_member_access(
     name: str, typ: Type, mx: MemberContext, override_info: TypeInfo | None = None
 ) -> Type:

test-data/unit/check-dict-get.test

@@ -0,0 +1,19 @@
+[case testDictGetEmpty]
+def testDictGetEmpty() -> None:
+    x = {}.get("x")
+    reveal_type(x)  # N: Revealed type is "None"
+
+[case testDictGetWithDefault]
+def testDictGetWithDefault() -> None:
+    x = {}.get("x", 42)
+    reveal_type(x)  # N: Revealed type is "int"
+
+[case testDictGetExistingKey]
+def testDictGetExistingKey() -> None:
+    x = {"a": 1}.get("a")
+    reveal_type(x)  # N: Revealed type is "int"
+
+[case testDictGetMissingKey]
+def testDictGetMissingKey() -> None:
+    x = {"a": 1}.get("b")
+    reveal_type(x)  # N: Revealed type is "None"