Fix type inference for TypedDict unpacking in dictionary displays

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -14656,7 +14656,7 @@ export function createTypeEvaluator(
                         );
 
                         tdEntries.knownItems.forEach((entry, name) => {
-                            if (entry.isRequired || entry.isProvided) {
+                            if (!expectedTypedDictEntries || entry.isRequired || entry.isProvided) {
                                 keyTypes.push({
                                     node: entryNode,
                                     type: ClassType.cloneWithLiteral(strObject, name),
@@ -14665,11 +14665,11 @@ export function createTypeEvaluator(
                             }
                         });
 
-                        if (!expectedTypedDictEntries) {
+                        if (tdEntries.extraItems) {
                             keyTypes.push({ node: entryNode, type: ClassType.cloneAsInstance(strObject) });
                             valueTypes.push({
                                 node: entryNode,
-                                type: tdEntries.extraItems?.valueType ?? getObjectType(),
+                                type: tdEntries.extraItems.valueType,
                             });
                         }
 

packages/pyright-internal/src/tests/samples/typedDict28.py

@@ -0,0 +1,39 @@
+# This sample tests dictionary expansion for TypedDicts without an expected
+# TypedDict target type context.
+
+from typing import NotRequired, TypedDict, reveal_type
+
+
+class HomogeneousTD(TypedDict):
+    a: int
+    b: int
+
+
+class HeterogeneousTD(TypedDict):
+    a: int
+    b: str
+
+
+class OptionalTD(TypedDict):
+    a: int
+    b: NotRequired[float]
+
+
+def test_homogeneous(td: HomogeneousTD):
+    res1 = {**td}
+    reveal_type(res1, expected_text="dict[str, int]")
+
+
+def test_heterogeneous(td: HeterogeneousTD):
+    res2 = {**td}
+    reveal_type(res2, expected_text="dict[str, int | str]")
+
+
+def test_optional(td: OptionalTD):
+    res3 = {**td}
+    reveal_type(res3, expected_text="dict[str, int | float]")
+
+
+def test_multiple(td1: HomogeneousTD, td2: HeterogeneousTD, td3: OptionalTD):
+    res4 = {**td1, **td2, **td3}
+    reveal_type(res4, expected_text="dict[str, int | str | float]")

packages/pyright-internal/src/tests/typeEvaluator7.test.ts

@@ -808,6 +808,15 @@ test('TypedDict27', () => {
     TestUtils.validateResults(analysisResults, 7);
 });
 
+test('TypedDict28', () => {
+    const configOptions = new ConfigOptions(Uri.empty());
+    configOptions.diagnosticRuleSet.strictDictionaryInference = true;
+
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['typedDict28.py'], configOptions);
+
+    TestUtils.validateResults(analysisResults, 0);
+});
+
 test('TypedDictInline1', () => {
     const configOptions = new ConfigOptions(Uri.empty());
     configOptions.diagnosticRuleSet.enableExperimentalFeatures = true;