Make Union deserialization algorithn more robust

benchmark/libs/mashumaro/common.py

@@ -6,17 +6,13 @@
 import pyperf
 
 from benchmark.common import AbstractBenchmark
-from mashumaro import field_options, pass_through
+from mashumaro import field_options
 from mashumaro.codecs import BasicDecoder, BasicEncoder
 from mashumaro.dialect import Dialect
 
 
 class DefaultDialect(Dialect):
     serialize_by_alias = True
-    serialization_strategy = {
-        str: {"deserialize": str, "serialize": pass_through},
-        int: {"serialize": pass_through},
-    }
 
 
 class IssueState(Enum):

mashumaro/core/meta/code/builder.py

@@ -487,7 +487,7 @@ def _add_unpack_method_lines(self, method_name: str) -> None:
                         self.add_type_modules(ftype)
                         metadata = self.metadatas.get(fname, {})
                         field_block = FieldUnpackerCodeBlockBuilder(
-                            self, self.lines.branch_off()
+                            self, CodeLines()
                         ).build(
                             fname=fname,
                             ftype=ftype,

mashumaro/core/meta/code/lines.py

@@ -13,7 +13,8 @@ def append(self, line: str) -> None:
         self._lines.append(f"{self._current_indent}{line}")
 
     def extend(self, lines: "CodeLines") -> None:
-        self._lines.extend(lines._lines)
+        for line in lines._lines:
+            self._lines.append(f"{self._current_indent}{line}")
 
     @contextmanager
     def indent(
@@ -34,8 +35,3 @@ def as_text(self) -> str:
     def reset(self) -> None:
         self._lines = []
         self._current_indent = ""
-
-    def branch_off(self) -> "CodeLines":
-        branch = CodeLines()
-        branch._current_indent = self._current_indent
-        return branch

mashumaro/core/meta/types/common.py

@@ -16,6 +16,7 @@
     Sequence,
     Type,
     TypeVar,
+    Union,
 )
 
 from typing_extensions import ParamSpec, TypeAlias
@@ -39,8 +40,12 @@
     CodeBuilder = Any
 
 
+class TypeMatchEligibleExpression(str):
+    pass
+
+
 NoneType = type(None)
-Expression: TypeAlias = str
+Expression: TypeAlias = Union[str, TypeMatchEligibleExpression]
 
 P = ParamSpec("P")
 T = TypeVar("T")

mashumaro/core/meta/types/unpack.py

@@ -69,6 +69,7 @@
     ExpressionWrapper,
     NoneType,
     Registry,
+    TypeMatchEligibleExpression,
     ValueSpec,
     clean_id,
     ensure_generic_collection,
@@ -170,28 +171,40 @@ def get_method_prefix(self) -> str:
         return "union"
 
     def _add_body(self, spec: ValueSpec, lines: CodeLines) -> None:
-        ambiguous_unpacker_types = []
         unpackers = set()
+        fallback_unpackers = []
         for type_arg in self.union_args:
+            condition = ""
             unpacker = UnpackerRegistry.get(
                 spec.copy(type=type_arg, expression="value")
             )
-            if type_arg in (bool, str) and unpacker == "value":
-                ambiguous_unpacker_types.append(type_arg)
-            if unpacker in unpackers:
+            do_try = unpacker != "value"
+            unpacker_block = CodeLines()
+            if isinstance(unpacker, TypeMatchEligibleExpression):
+                do_try = False
+                condition = f"type(value) is {type_arg.__name__}"
+                if (condition, unpacker) in unpackers:
+                    continue
+                with unpacker_block.indent(f"if {condition}:"):
+                    unpacker_block.append("return value")
+                if (condition, unpacker) not in unpackers:
+                    fallback_unpackers.append(unpacker)
+            elif (condition, unpacker) in unpackers:
                 continue
+            else:
+                unpacker_block.append(f"return {unpacker}")
+
+            if do_try:
+                with lines.indent("try:"):
+                    lines.extend(unpacker_block)
+                lines.append("except Exception: pass")
+            else:
+                lines.extend(unpacker_block)
+            unpackers.add((condition, unpacker))
+        for fallback_unpacker in fallback_unpackers:
             with lines.indent("try:"):
-                lines.append(f"return {unpacker}")
+                lines.append(f"return {fallback_unpacker}")
             lines.append("except Exception: pass")
-            unpackers.add(unpacker)
-        # if len(ambiguous_unpacker_types) >= 2:
-        #     warnings.warn(
-        #         f"{type_name(spec.builder.cls)}.{spec.field_ctx.name} "
-        #         f"({type_name(spec.type)}): "
-        #         "In the next release, data marked with Union type "
-        #         "containing 'str' and 'bool' will be coerced to the value "
-        #         "of the type specified first instead of passing it as is"
-        #     )
         field_type = spec.builder.get_type_name_identifier(
             typ=spec.type,
             resolved_type_params=spec.builder.get_field_resolved_type_params(
@@ -843,13 +856,21 @@ def unpack_special_typing_primitive(spec: ValueSpec) -> Optional[Expression]:
 @register
 def unpack_number(spec: ValueSpec) -> Optional[Expression]:
     if spec.origin_type in (int, float):
-        return f"{type_name(spec.origin_type)}({spec.expression})"
+        return TypeMatchEligibleExpression(
+            f"{type_name(spec.origin_type)}({spec.expression})"
+        )
 
 
 @register
-def unpack_bool_and_none(spec: ValueSpec) -> Optional[Expression]:
-    if spec.origin_type in (bool, NoneType, None):
-        return spec.expression
+def unpack_bool(spec: ValueSpec) -> Optional[Expression]:
+    if spec.origin_type is bool:
+        return TypeMatchEligibleExpression(f"bool({spec.expression})")
+
+
+@register
+def unpack_none(spec: ValueSpec) -> Optional[Expression]:
+    if spec.origin_type in (NoneType, None):
+        return TypeMatchEligibleExpression("None")
 
 
 @register
@@ -1199,7 +1220,7 @@ def inner_expr(
             spec.builder.ensure_object_imported(decodebytes)
             return f"bytearray(decodebytes({spec.expression}.encode()))"
     elif issubclass(spec.origin_type, str):
-        return spec.expression
+        return TypeMatchEligibleExpression(f"str({spec.expression})")
     elif ensure_generic_collection_subclass(spec, List):
         return f"[{inner_expr()} for value in {spec.expression}]"
     elif ensure_generic_collection_subclass(spec, typing.Deque):