Bubble up the inner expression

mashumaro/core/meta/code/builder.py

@@ -1225,7 +1225,25 @@ def _try_set_value(
     ) -> None:
         with self.lines.indent("try:"):
             self._set_value(field_name, unpacked_value, in_kwargs)
-        with self.lines.indent("except:"):
+        with self.lines.indent("except MissingField as inner:"):
+            self.lines.append(
+                f"path = '{field_name}' + '.' + inner.path if inner.path else '{field_name}'"
+            )
+            self.lines.append(
+                "raise MissingField("
+                "inner.field_name,inner.field_type,"
+                "inner.holder_class,path) from None"
+            )
+        with self.lines.indent("except InvalidFieldValue as inner:"):
+            self.lines.append(
+                f"path = '{field_name}' + '.' + inner.path if inner.path else '{field_name}'"
+            )
+            self.lines.append(
+                "raise InvalidFieldValue("
+                "inner.field_name,inner.field_type,inner.field_value,"
+                "inner.holder_class,inner.msg,path) from None"
+            )
+        with self.lines.indent("except Exception:"):
             self.lines.append(
                 "raise InvalidFieldValue("
                 f"'{field_name}',{field_type_name},value,cls)"

mashumaro/exceptions.py

@@ -4,10 +4,17 @@
 
 
 class MissingField(LookupError):
-    def __init__(self, field_name: str, field_type: Type, holder_class: Type):
+    def __init__(
+        self,
+        field_name: str,
+        field_type: Type,
+        holder_class: Type,
+        path: Optional[str] = None,
+    ):
         self.field_name = field_name
         self.field_type = field_type
         self.holder_class = holder_class
+        self.path = path
 
     @property
     def field_type_name(self) -> str:
@@ -18,8 +25,9 @@ def holder_class_name(self) -> str:
         return type_name(self.holder_class, short=True)
 
     def __str__(self) -> str:
+        path = f' at path "{self.path}"' if self.path else ""
         return (
-            f'Field "{self.field_name}" of type {self.field_type_name}'
+            f'Field "{self.field_name}"{path} of type {self.field_type_name}'
             f" is missing in {self.holder_class_name} instance"
         )
 
@@ -99,12 +107,14 @@ def __init__(
         field_value: Any,
         holder_class: Type,
         msg: Optional[str] = None,
+        path: Optional[str] = None,
     ):
         self.field_name = field_name
         self.field_type = field_type
         self.field_value = field_value
         self.holder_class = holder_class
         self.msg = msg
+        self.path = path
 
     @property
     def field_type_name(self) -> str:
@@ -115,8 +125,9 @@ def holder_class_name(self) -> str:
         return type_name(self.holder_class, short=True)
 
     def __str__(self) -> str:
+        path = f' at path "{self.path}"' if self.path else ""
         s = (
-            f'Field "{self.field_name}" of type {self.field_type_name} '
+            f'Field "{self.field_name}"{path} of type {self.field_type_name} '
             f"in {self.holder_class_name} has invalid value "
             f"{repr(self.field_value)}"
         )

tests/test_data_types.py

@@ -1010,6 +1010,45 @@ class Config(BaseConfig):
         DataClass.from_dict({"x": "bad_value"})
 
 
+@dataclass
+class _InnerDeserializeTest(DataClassDictMixin):
+    x: int
+
+
+@dataclass
+class _MiddleDeserializeTest(DataClassDictMixin):
+    inner: _InnerDeserializeTest
+
+
+def test_invalid_nested_field_value_deserialization():
+    @dataclass
+    class Outer(DataClassDictMixin):
+        middle: _MiddleDeserializeTest
+
+    with pytest.raises(InvalidFieldValue) as exc_info:
+        Outer.from_dict({"middle": {"inner": {"x": "bad_value"}}})
+
+    assert exc_info.value.field_name == "x"
+    assert exc_info.value.field_type is int
+    assert exc_info.value.holder_class == _InnerDeserializeTest
+    assert exc_info.value.field_value == "bad_value"
+    assert exc_info.value.path == "middle.inner"
+
+
+def test_missing_nested_field_value_deserialization():
+    @dataclass
+    class Outer(DataClassDictMixin):
+        middle: _MiddleDeserializeTest
+
+    with pytest.raises(MissingField) as exc_info:
+        Outer.from_dict({"middle": {"inner": {}}})
+
+    assert exc_info.value.field_name == "x"
+    assert exc_info.value.field_type is int
+    assert exc_info.value.holder_class == _InnerDeserializeTest
+    assert exc_info.value.path == "middle.inner"
+
+
 @pytest.mark.parametrize(
     "value_info",
     [