Get empty dict issue

mypy/checkexpr.py

@@ -473,6 +473,30 @@ 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

@@ -14,6 +14,7 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy.messages import MessageBuilder
 from mypy.nodes import (
+    ARG_OPT,
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
@@ -203,6 +204,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 (
@@ -215,6 +221,18 @@ def analyze_member_access(
         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"