Add expression_type_or_unknown() method to UnpackResult

Author: charliermarsh

crates/ty_python_semantic/src/types/class/static_literal.rs

@@ -2154,11 +2154,7 @@ impl<'db> StaticClassLiteral<'db> {
                             //     [.., self.name, ..] = <value>
 
                             let unpacked = infer_unpack_types(db, unpack);
-                            Some(
-                                unpacked
-                                    .try_expression_type(assign.target(&module))
-                                    .unwrap_or_else(Type::unknown),
-                            )
+                            Some(unpacked.expression_type_or_unknown(assign.target(&module)))
                         }
                         TargetKind::Single => {
                             // We found an un-annotated attribute assignment of the form:
@@ -2179,11 +2175,7 @@ impl<'db> StaticClassLiteral<'db> {
                             //     for .., self.name, .. in <iterable>:
 
                             let unpacked = infer_unpack_types(db, unpack);
-                            Some(
-                                unpacked
-                                    .try_expression_type(for_stmt.target(&module))
-                                    .unwrap_or_else(Type::unknown),
-                            )
+                            Some(unpacked.expression_type_or_unknown(for_stmt.target(&module)))
                         }
                         TargetKind::Single => {
                             // We found an attribute assignment like:
@@ -2206,11 +2198,7 @@ impl<'db> StaticClassLiteral<'db> {
                             //     with <context_manager> as .., self.name, ..:
 
                             let unpacked = infer_unpack_types(db, unpack);
-                            Some(
-                                unpacked
-                                    .try_expression_type(with_item.target(&module))
-                                    .unwrap_or_else(Type::unknown),
-                            )
+                            Some(unpacked.expression_type_or_unknown(with_item.target(&module)))
                         }
                         TargetKind::Single => {
                             // We found an attribute assignment like:
@@ -2239,8 +2227,7 @@ impl<'db> StaticClassLiteral<'db> {
                                 let unpacked = infer_unpack_types(db, unpack);
                                 Some(
                                     unpacked
-                                        .try_expression_type(comprehension.target(&module))
-                                        .unwrap_or_else(Type::unknown),
+                                        .expression_type_or_unknown(comprehension.target(&module)),
                                 )
                             }
                             TargetKind::Single => {

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -1617,9 +1617,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 if unpack_position == UnpackPosition::First {
                     self.context.extend(unpacked.diagnostics());
                 }
-                unpacked
-                    .try_expression_type(target)
-                    .unwrap_or_else(Type::unknown)
+                unpacked.expression_type_or_unknown(target)
             }
             TargetKind::Single => {
                 let context_expr_ty =
@@ -3160,9 +3158,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     self.context.extend(unpacked.diagnostics());
                 }
 
-                unpacked
-                    .try_expression_type(target)
-                    .unwrap_or_else(Type::unknown)
+                unpacked.expression_type_or_unknown(target)
             }
             TargetKind::Single => {
                 // This could be an implicit type alias (OptionalList = list[T] | None). Use the definition
@@ -4335,9 +4331,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     self.context.extend(unpacked.diagnostics());
                 }
 
-                unpacked
-                    .try_expression_type(target)
-                    .unwrap_or_else(Type::unknown)
+                unpacked.expression_type_or_unknown(target)
             }
             TargetKind::Single => {
                 let iterable_type =
@@ -6424,9 +6418,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     self.context.extend(unpacked.diagnostics());
                 }
 
-                unpacked
-                    .try_expression_type(target)
-                    .unwrap_or_else(Type::unknown)
+                unpacked.expression_type_or_unknown(target)
             }
             TargetKind::Single => {
                 let iterable_type = infer_iterable_type();

crates/ty_python_semantic/src/types/unpacker.rs

@@ -291,6 +291,16 @@ impl<'db> UnpackResult<'db> {
             .or(self.cycle_recovery)
     }
 
+    /// Returns the type of the given expression, or `Unknown` if no type was recorded.
+    ///
+    /// This can happen for malformed unpack targets created by error recovery.
+    pub(crate) fn expression_type_or_unknown(
+        &self,
+        expr: impl Into<ExpressionNodeKey>,
+    ) -> Type<'db> {
+        self.try_expression_type(expr).unwrap_or_else(Type::unknown)
+    }
+
     /// Returns the diagnostics in this unpacking assignment.
     pub(crate) fn diagnostics(&self) -> &TypeCheckDiagnostics {
         &self.diagnostics