Fix type conversion if annotated argument has None as default.

pekkaklarck · pekkaklarck · commit bf10f62f0a22 · 2018-10-03T08:59:38.000+03:00
Another fix to #2890.
diff --git a/atest/robot/keywords/type_conversion/annotations.robot b/atest/robot/keywords/type_conversion/annotations.robot
@@ -175,6 +175,9 @@ String None is converted to None object
 Return value annotation causes no error
     Check Test Case    ${TESTNAME}
 
+None as default
+    Check Test Case    ${TESTNAME}
+
 Forward references
     [Tags]    require-py3.5
     Check Test Case    ${TESTNAME}
diff --git a/atest/robot/keywords/type_conversion/annotations_with_typing.robot b/atest/robot/keywords/type_conversion/annotations_with_typing.robot
@@ -49,5 +49,8 @@ Set with params
 Invalid Set
     Check Test Case    ${TESTNAME}
 
+None as default
+    Check Test Case    ${TESTNAME}
+
 Forward references
     Check Test Case    ${TESTNAME}
diff --git a/atest/testdata/keywords/type_conversion/Annotations.py b/atest/testdata/keywords/type_conversion/Annotations.py
@@ -145,6 +145,10 @@ def kwonly(*, argument: float, expected=None):
     _validate_type(argument, expected)
 
 
+def none_as_default(argument: list = None, expected=None):
+    _validate_type(argument, expected)
+
+
 def forward_referenced_concrete_type(argument: 'int', expected=None):
     _validate_type(argument, expected)
 
diff --git a/atest/testdata/keywords/type_conversion/AnnotationsWithTyping.py b/atest/testdata/keywords/type_conversion/AnnotationsWithTyping.py
@@ -67,6 +67,10 @@ def mutable_set_with_params(argument: MutableSet[bool], expected=None):
     _validate_type(argument, expected)
 
 
+def none_as_default(argument: List = None, expected=None):
+    _validate_type(argument, expected)
+
+
 def forward_reference(argument: 'List', expected=None):
     _validate_type(argument, expected)
 
diff --git a/atest/testdata/keywords/type_conversion/annotations.robot b/atest/testdata/keywords/type_conversion/annotations.robot
@@ -384,6 +384,10 @@ String None is converted to None object
 Return value annotation causes no error
     Return value annotation                    42    42
 
+None as default
+    None as default
+    None as default                            []    []
+
 Forward references
     [Tags]    require-py3.5
     Forward referenced concrete type           42    42
diff --git a/atest/testdata/keywords/type_conversion/annotations_with_typing.robot b/atest/testdata/keywords/type_conversion/annotations_with_typing.robot
@@ -86,6 +86,10 @@ Invalid Set
     Set                       {}                                               error=Value is dictionary, not set.
     Set                       ooops                                            error=Invalid expression.
 
+None as default
+    None as default
+    None as default           [1, 2, 3, 4]                [1, 2, 3, 4]
+
 Forward references
     Forward reference         [1, 2, 3, 4]                [1, 2, 3, 4]
     Forward ref with params   [1, 2, 3, 4]                [1, 2, 3, 4]
diff --git a/src/robot/running/arguments/argumentparser.py b/src/robot/running/arguments/argumentparser.py
@@ -54,14 +54,15 @@ def parse(self, handler, name=None):
                 = getfullargspec(handler)
         if ismethod(handler) or handler.__name__ == '__init__':
             args = args[1:]  # drop 'self'
+        defaults = self._get_defaults(args, defaults, kwonlydefaults)
         return ArgumentSpec(
             name, self._type,
             positional=args,
             varargs=varargs,
             kwargs=kwargs,
             kwonlyargs=kwonly,
-            defaults=self._get_defaults(args, defaults, kwonlydefaults),
-            types=self._get_types(handler, annotations)
+            defaults=defaults,
+            types=self._get_types(handler, annotations, defaults)
         )
 
     def _get_defaults(self, args, default_values, kwonlydefaults):
@@ -73,17 +74,41 @@ def _get_defaults(self, args, default_values, kwonlydefaults):
             defaults.update(kwonlydefaults)
         return defaults
 
-    def _get_types(self, handler, annotations):
+    def _get_types(self, handler, annotations, defaults):
         types = getattr(handler, 'robot_types', None)
         if types is not None:
             return types
-        if typing:
-            try:
-                return typing.get_type_hints(handler)
-            except Exception:  # Can raise pretty much anything
-                pass
+        types = self._get_type_hints(handler, defaults)
+        if types is not None:
+            return types
         return annotations
 
+    def _get_type_hints(self, handler, defaults):
+        if not typing:
+            return None
+        try:
+            type_hints = typing.get_type_hints(handler)
+        except Exception:  # Can raise pretty much anything
+            return None
+        return self._remove_optional_none(type_hints, defaults)
+
+    def _remove_optional_none(self, type_hints, defaults):
+        # If argument has None as a default, `typing.get_type_hints` adds
+        # optional None to the information it returns. We don't want that.
+        for arg in defaults:
+            if defaults[arg] is None and arg in type_hints:
+                type_ = type_hints[arg]
+                if self._is_union(type_):
+                    types = type_.__args__
+                    if len(types) == 2 and types[1] is type(None):
+                        type_hints[arg] = types[0]
+        return type_hints
+
+    def _is_union(self, type_):
+        if PY_VERSION >= (3, 7) and hasattr(type_, '__origin__'):
+            type_ = type_.__origin__
+        return isinstance(type_, type(typing.Union))
+
 
 class JavaArgumentParser(_ArgumentParser):
 
