Implement PEP-563, annotations as strings (GH-3285)

Annotations are now dealt with according to PEP-563 - they are
saved as strings, rather than evaluated as Python objects.
They can/are still be used by Cython for typing.
Previous behaviour for evaluating them as Python objects was
convoluted and has been removed entirely, which hopefully doesn't
break too much.

Cython/Compiler/AutoDocTransforms.py

@@ -5,16 +5,35 @@ from .StringEncoding import EncodedString
 from . import Options
 from . import PyrexTypes, ExprNodes
 from ..CodeWriter import ExpressionWriter
+from .Errors import warning
 
 
 class AnnotationWriter(ExpressionWriter):
+    def __init__(self, description=None):
+        """description is optional. If specified it is used in
+        warning messages for the nodes that don't convert to string properly.
+        If not specified then no messages are generated.
+        """
+        ExpressionWriter.__init__(self)
+        self.description = description
 
     def visit_Node(self, node):
         self.put(u"<???>")
+        if self.description:
+            warning(node.pos,
+                    "Failed to convert code to string representation in {0}".format(
+                        self.description), level=1)
 
     def visit_LambdaNode(self, node):
         # XXX Should we do better?
         self.put("<lambda>")
+        if self.description:
+            warning(node.pos,
+                    "Failed to convert lambda to string representation in {0}".format(
+                        self.description), level=1)
+
+    def visit_AnnotationNode(self, node):
+        self.put(node.string.unicode_value)
 
 
 class EmbedSignature(CythonTransform):

Cython/Compiler/ExprNodes.py

@@ -28,7 +28,7 @@ from .Code import UtilityCode, TempitaUtilityCode
 from . import StringEncoding
 from . import Naming
 from . import Nodes
-from .Nodes import Node, utility_code_for_imports, analyse_type_annotation
+from .Nodes import Node, utility_code_for_imports
 from . import PyrexTypes
 from .PyrexTypes import py_object_type, c_long_type, typecast, error_type, \
     unspecified_type
@@ -1928,15 +1928,15 @@ class NameNode(AtomicExprNode):
             return
 
         annotation = self.annotation
-        if annotation.is_string_literal:
+        if annotation.expr.is_string_literal:
             # name: "description" => not a type, but still a declared variable or attribute
             atype = None
         else:
-            _, atype = analyse_type_annotation(annotation, env)
+            _, atype = annotation.analyse_type_annotation(env)
         if atype is None:
             atype = unspecified_type if as_target and env.directives['infer_types'] != False else py_object_type
         self.entry = env.declare_var(name, atype, self.pos, is_cdef=not as_target)
-        self.entry.annotation = annotation
+        self.entry.annotation = annotation.expr
 
     def analyse_as_module(self, env):
         # Try to interpret this as a reference to a cimported module.
@@ -9221,19 +9221,19 @@ class PyCFunctionNode(ExprNode, ModuleNameMixin):
                 else:
                     default_args.append(arg)
             if arg.annotation:
-                arg.annotation = self.analyse_annotation(env, arg.annotation)
-                annotations.append((arg.pos, arg.name, arg.annotation))
+                arg.annotation = arg.annotation.analyse_types(env)
+                annotations.append((arg.pos, arg.name, arg.annotation.string))
 
         for arg in (self.def_node.star_arg, self.def_node.starstar_arg):
             if arg and arg.annotation:
-                arg.annotation = self.analyse_annotation(env, arg.annotation)
-                annotations.append((arg.pos, arg.name, arg.annotation))
+                arg.annotation = arg.annotation.analyse_types(env)
+                annotations.append((arg.pos, arg.name, arg.annotation.string))
 
         annotation = self.def_node.return_type_annotation
         if annotation:
-            annotation = self.analyse_annotation(env, annotation)
-            self.def_node.return_type_annotation = annotation
-            annotations.append((annotation.pos, StringEncoding.EncodedString("return"), annotation))
+            self.def_node.return_type_annotation = annotation.analyse_types(env)
+            annotations.append((annotation.pos, StringEncoding.EncodedString("return"),
+                                annotation.string))
 
         if nonliteral_objects or nonliteral_other:
             module_scope = env.global_scope()
@@ -9310,20 +9310,6 @@ class PyCFunctionNode(ExprNode, ModuleNameMixin):
                 for pos, name, value in annotations])
             self.annotations_dict = annotations_dict.analyse_types(env)
 
-    def analyse_annotation(self, env, annotation):
-        if annotation is None:
-            return None
-        atype = annotation.analyse_as_type(env)
-        if atype is not None:
-            # Keep parsed types as strings as they might not be Python representable.
-            annotation = UnicodeNode(
-                annotation.pos,
-                value=StringEncoding.EncodedString(atype.declaration_code('', for_display=True)))
-        annotation = annotation.analyse_types(env)
-        if not annotation.type.is_pyobject:
-            annotation = annotation.coerce_to_pyobject(env)
-        return annotation
-
     def may_be_none(self):
         return False
 
@@ -12015,6 +12001,9 @@ class BoolBinopResultNode(ExprNode):
             code.putln("}")
         self.arg.free_temps(code)
 
+    def analyse_types(self, env):
+        return self
+
 
 class CondExprNode(ExprNode):
     #  Short-circuiting conditional expression.
@@ -13330,6 +13319,9 @@ class CoerceToBooleanNode(CoercionNode):
                     self.arg.py_result(),
                     code.error_goto_if_neg(self.result(), self.pos)))
 
+    def analyse_types(self, env):
+        return self
+
 
 class CoerceToComplexNode(CoercionNode):
 
@@ -13355,6 +13347,9 @@ class CoerceToComplexNode(CoercionNode):
     def generate_result_code(self, code):
         pass
 
+    def analyse_types(self, env):
+        return self
+
 class CoerceToTempNode(CoercionNode):
     #  This node is used to force the result of another node
     #  to be stored in a temporary. It is only used if the
@@ -13560,7 +13555,83 @@ class DocstringRefNode(ExprNode):
             code.error_goto_if_null(self.result(), self.pos)))
         code.put_gotref(self.result())
 
+class AnnotationNode(ExprNode):
+    # Deals with the two possible uses of an annotation.
+    # 1. The post PEP-563 use where an annotation is stored
+    #  as a string
+    # 2. The Cython use where the annotation can indicate an
+    #  object type
+    #
+    # doesn't handle the pre PEP-563 version where the
+    # annotation is evaluated into a Python Object
+
+    subexprs = []
+    def __init__(self, pos, expr, string=None):
+        """string is expected to already be a StringNode or None"""
+        ExprNode.__init__(self, pos)
+        if string is None:
+            # import doesn't work at top of file?
+            from .AutoDocTransforms import AnnotationWriter
+            string = StringEncoding.EncodedString(
+                AnnotationWriter(description="annotation").write(expr))
+            string = StringNode(pos, unicode_value=string, value=string.as_utf8_string())
+        self.string = string
+        self.expr = expr
+
+    def analyse_types(self, env):
+        return self # nothing needs doing
 
+    def analyse_as_type(self, env):
+        # for compatibility when used as a return_type_node, have this interface too
+        return self.analyse_type_annotation(env)[1]
+
+    def analyse_type_annotation(self, env, assigned_value=None):
+        annotation = self.expr
+        base_type = None
+        is_ambiguous = False
+        explicit_pytype = explicit_ctype = False
+        if annotation.is_dict_literal:
+            warning(annotation.pos,
+                    "Dicts should no longer be used as type annotations. Use 'cython.int' etc. directly.")
+            for name, value in annotation.key_value_pairs:
+                if not name.is_string_literal:
+                    continue
+                if name.value in ('type', b'type'):
+                    explicit_pytype = True
+                    if not explicit_ctype:
+                        annotation = value
+                elif name.value in ('ctype', b'ctype'):
+                    explicit_ctype = True
+                    annotation = value
+            if explicit_pytype and explicit_ctype:
+                warning(annotation.pos, "Duplicate type declarations found in signature annotation")
+        arg_type = annotation.analyse_as_type(env)
+        if annotation.is_name and not annotation.cython_attribute and annotation.name in ('int', 'long', 'float'):
+            # Map builtin numeric Python types to C types in safe cases.
+            if assigned_value is not None and arg_type is not None and not arg_type.is_pyobject:
+                assigned_type = assigned_value.infer_type(env)
+                if assigned_type and assigned_type.is_pyobject:
+                    # C type seems unsafe, e.g. due to 'None' default value  => ignore annotation type
+                    is_ambiguous = True
+                    arg_type = None
+            # ignore 'int' and require 'cython.int' to avoid unsafe integer declarations
+            if arg_type in (PyrexTypes.c_long_type, PyrexTypes.c_int_type, PyrexTypes.c_float_type):
+                arg_type = PyrexTypes.c_double_type if annotation.name == 'float' else py_object_type
+        elif arg_type is not None and annotation.is_string_literal:
+            warning(annotation.pos,
+                    "Strings should no longer be used for type declarations. Use 'cython.int' etc. directly.",
+                    level=1)
+        if arg_type is not None:
+            if explicit_pytype and not explicit_ctype and not arg_type.is_pyobject:
+                warning(annotation.pos,
+                        "Python type declaration in signature annotation does not refer to a Python type")
+            base_type = Nodes.CAnalysedBaseTypeNode(
+                annotation.pos, type=arg_type, is_arg=True)
+        elif is_ambiguous:
+            warning(annotation.pos, "Ambiguous types in annotation, ignoring")
+        else:
+            warning(annotation.pos, "Unknown type declaration in annotation, ignoring")
+        return base_type, arg_type
 
 #------------------------------------------------------------------------------------
 #

Cython/Compiler/Future.py

@@ -11,5 +11,6 @@ absolute_import = _get_feature("absolute_import")
 nested_scopes = _get_feature("nested_scopes")  # dummy
 generators = _get_feature("generators")  # dummy
 generator_stop = _get_feature("generator_stop")
+annotations = _get_feature("annotations")
 
 del _get_feature

Cython/Compiler/Nodes.py

@@ -68,54 +68,6 @@ def embed_position(pos, docstring):
     doc.encoding = encoding
     return doc
 
-
-def analyse_type_annotation(annotation, env, assigned_value=None):
-    base_type = None
-    is_ambiguous = False
-    explicit_pytype = explicit_ctype = False
-    if annotation.is_dict_literal:
-        warning(annotation.pos,
-                "Dicts should no longer be used as type annotations. Use 'cython.int' etc. directly.")
-        for name, value in annotation.key_value_pairs:
-            if not name.is_string_literal:
-                continue
-            if name.value in ('type', b'type'):
-                explicit_pytype = True
-                if not explicit_ctype:
-                    annotation = value
-            elif name.value in ('ctype', b'ctype'):
-                explicit_ctype = True
-                annotation = value
-        if explicit_pytype and explicit_ctype:
-            warning(annotation.pos, "Duplicate type declarations found in signature annotation")
-    arg_type = annotation.analyse_as_type(env)
-    if annotation.is_name and not annotation.cython_attribute and annotation.name in ('int', 'long', 'float'):
-        # Map builtin numeric Python types to C types in safe cases.
-        if assigned_value is not None and arg_type is not None and not arg_type.is_pyobject:
-            assigned_type = assigned_value.infer_type(env)
-            if assigned_type and assigned_type.is_pyobject:
-                # C type seems unsafe, e.g. due to 'None' default value  => ignore annotation type
-                is_ambiguous = True
-                arg_type = None
-        # ignore 'int' and require 'cython.int' to avoid unsafe integer declarations
-        if arg_type in (PyrexTypes.c_long_type, PyrexTypes.c_int_type, PyrexTypes.c_float_type):
-            arg_type = PyrexTypes.c_double_type if annotation.name == 'float' else py_object_type
-    elif arg_type is not None and annotation.is_string_literal:
-        warning(annotation.pos,
-                "Strings should no longer be used for type declarations. Use 'cython.int' etc. directly.")
-    if arg_type is not None:
-        if explicit_pytype and not explicit_ctype and not arg_type.is_pyobject:
-            warning(annotation.pos,
-                    "Python type declaration in signature annotation does not refer to a Python type")
-        base_type = CAnalysedBaseTypeNode(
-            annotation.pos, type=arg_type, is_arg=True)
-    elif is_ambiguous:
-        warning(annotation.pos, "Ambiguous types in annotation, ignoring")
-    else:
-        warning(annotation.pos, "Unknown type declaration in annotation, ignoring")
-    return base_type, arg_type
-
-
 def write_func_call(func, codewriter_class):
     def f(*args, **kwds):
         if len(args) > 1 and isinstance(args[1], codewriter_class):
@@ -937,7 +889,7 @@ class CArgDeclNode(Node):
         annotation = self.annotation
         if not annotation:
             return None
-        base_type, arg_type = analyse_type_annotation(annotation, env, assigned_value=self.default)
+        base_type, arg_type = annotation.analyse_type_annotation(env, assigned_value=self.default)
         if base_type is not None:
             self.base_type = base_type
         return arg_type
@@ -1685,6 +1637,7 @@ class FuncDefNode(StatNode, BlockNode):
     starstar_arg = None
     is_cyfunction = False
     code_object = None
+    return_type_annotation = None
 
     def analyse_default_values(self, env):
         default_seen = 0
@@ -1702,18 +1655,12 @@ class FuncDefNode(StatNode, BlockNode):
             elif default_seen:
                 error(arg.pos, "Non-default argument following default argument")
 
-    def analyse_annotation(self, env, annotation):
-        # Annotations can not only contain valid Python expressions but arbitrary type references.
-        if annotation is None:
-            return None
-        if not env.directives['annotation_typing'] or annotation.analyse_as_type(env) is None:
-            annotation = annotation.analyse_types(env)
-        return annotation
-
     def analyse_annotations(self, env):
         for arg in self.args:
             if arg.annotation:
-                arg.annotation = self.analyse_annotation(env, arg.annotation)
+                arg.annotation = arg.annotation.analyse_types(env)
+        if self.return_type_annotation:
+            self.return_type_annotation = self.return_type_annotation.analyse_types(env)
 
     def align_argument_type(self, env, arg):
         # @cython.locals()
@@ -2208,7 +2155,7 @@ class FuncDefNode(StatNode, BlockNode):
             error(arg.pos, "Argument type '%s' is incomplete" % arg.type)
         entry = env.declare_arg(arg.name, arg.type, arg.pos)
         if arg.annotation:
-            entry.annotation = arg.annotation
+            entry.annotation = arg.annotation.expr
         return entry
 
     def generate_arg_type_test(self, arg, code):
@@ -2947,7 +2894,7 @@ class DefNode(FuncDefNode):
         # if a signature annotation provides a more specific return object type, use it
         if self.return_type is py_object_type and self.return_type_annotation:
             if env.directives['annotation_typing'] and not self.entry.is_special:
-                _, return_type = analyse_type_annotation(self.return_type_annotation, env)
+                _, return_type = self.return_type_annotation.analyse_type_annotation(env)
                 if return_type and return_type.is_pyobject:
                     self.return_type = return_type
 
@@ -3208,8 +3155,6 @@ class DefNode(FuncDefNode):
         self.local_scope.directives = env.directives
         self.analyse_default_values(env)
         self.analyse_annotations(env)
-        if self.return_type_annotation:
-            self.return_type_annotation = self.analyse_annotation(env, self.return_type_annotation)
 
         if not self.needs_assignment_synthesis(env) and self.decorators:
             for decorator in self.decorators[::-1]:

Cython/Compiler/Parsing.pxd

@@ -196,3 +196,4 @@ cdef dict p_compiler_directive_comments(PyrexScanner s)
 cdef p_template_definition(PyrexScanner s)
 cdef p_cpp_class_definition(PyrexScanner s, pos, ctx)
 cdef p_cpp_class_attribute(PyrexScanner s, ctx)
+cdef p_annotation(PyrexScanner s)

Cython/Compiler/Parsing.py

@@ -1493,7 +1493,7 @@ def p_expression_or_assignment(s):
     expr = p_testlist_star_expr(s)
     if s.sy == ':' and (expr.is_name or expr.is_subscript or expr.is_attribute):
         s.next()
-        expr.annotation = p_test(s)
+        expr.annotation = p_annotation(s)
     if s.sy == '=' and expr.is_starred:
         # This is a common enough error to make when learning Cython to let
         # it fail as early as possible and give a very clear error message.
@@ -3019,7 +3019,7 @@ def p_c_arg_decl(s, ctx, in_pyfunc, cmethod_flag = 0, nonempty = 0,
         not_none = kind == 'not'
     if annotated and s.sy == ':':
         s.next()
-        annotation = p_test(s)
+        annotation = p_annotation(s)
     if s.sy == '=':
         s.next()
         if 'pxd' in ctx.level:
@@ -3406,7 +3406,7 @@ def p_def_statement(s, decorators=None, is_async_def=False):
     return_type_annotation = None
     if s.sy == '->':
         s.next()
-        return_type_annotation = p_test(s)
+        return_type_annotation = p_annotation(s)
         _reject_cdef_modifier_in_py(s, s.systring)
 
     doc, body = p_suite_with_docstring(s, Ctx(level='function'))
@@ -3461,7 +3461,7 @@ def p_py_arg_decl(s, annotated = 1):
     annotation = None
     if annotated and s.sy == ':':
         s.next()
-        annotation = p_test(s)
+        annotation = p_annotation(s)
     return Nodes.PyArgDeclNode(pos, name = name, annotation = annotation)
 
 
@@ -3869,3 +3869,14 @@ def print_parse_tree(f, node, level, key = None):
             f.write("%s]\n" % ind)
             return
     f.write("%s%s\n" % (ind, node))
+
+def p_annotation(s):
+    """An annotation just has the "test" syntax, but also stores the string it came from
+
+    Note that the string is *allowed* to be changed/processed (although isn't here)
+    so may not exactly match the string generated by Python, and if it doesn't
+    then it is not a bug.
+    """
+    pos = s.position()
+    expr = p_test(s)
+    return ExprNodes.AnnotationNode(pos, expr=expr)

Cython/Compiler/PyrexTypes.py

@@ -656,7 +656,8 @@ class MemoryViewSliceType(PyrexType):
         assert not pyrex
         assert not dll_linkage
         from . import MemoryView
-        base_code = str(self) if for_display else MemoryView.memviewslice_cname
+        base_code = StringEncoding.EncodedString(
+                        (str(self)) if for_display else MemoryView.memviewslice_cname)
         return self.base_declaration_code(
                 base_code,
                 entity_code)
@@ -1767,6 +1768,7 @@ class CNumericType(CType):
             base_code = type_name.replace('PY_LONG_LONG', 'long long')
         else:
             base_code = public_decl(type_name, dll_linkage)
+        base_code = StringEncoding.EncodedString(base_code)
         return self.base_declaration_code(base_code, entity_code)
 
     def attributes_known(self):

tests/errors/pep492_badsyntax_async2.pyx

-# mode: error
-# tag: pep492, async
-
-async def foo():
-    def foo(a:await list()):
-        pass
-
-_ERRORS = """
-5:14: 'await' not supported here
-5:14: 'await' not supported here
-"""

tests/run/cyfunction.pyx

@@ -271,13 +271,13 @@ def test_annotations(a: "test", b: "other" = 2, c: 123 = 4) -> "ret":
     >>> isinstance(test_annotations.__annotations__, dict)
     True
     >>> sorted(test_annotations.__annotations__.items())
-    [('a', 'test'), ('b', 'other'), ('c', 123), ('return', 'ret')]
+    [('a', "'test'"), ('b', "'other'"), ('c', '123'), ('return', "'ret'")]
 
     >>> def func_b(): return 42
     >>> def func_c(): return 99
     >>> inner = test_annotations(1, func_b, func_c)
     >>> sorted(inner.__annotations__.items())
-    [('return', 99), ('x', 'banana'), ('y', 42)]
+    [('return', 'c()'), ('x', "'banana'"), ('y', 'b()')]
 
     >>> inner.__annotations__ = {234: 567}
     >>> inner.__annotations__
@@ -293,14 +293,14 @@ def test_annotations(a: "test", b: "other" = 2, c: 123 = 4) -> "ret":
 
     >>> inner = test_annotations(1, func_b, func_c)
     >>> sorted(inner.__annotations__.items())
-    [('return', 99), ('x', 'banana'), ('y', 42)]
+    [('return', 'c()'), ('x', "'banana'"), ('y', 'b()')]
     >>> inner.__annotations__['abc'] = 66
     >>> sorted(inner.__annotations__.items())
-    [('abc', 66), ('return', 99), ('x', 'banana'), ('y', 42)]
+    [('abc', 66), ('return', 'c()'), ('x', "'banana'"), ('y', 'b()')]
 
     >>> inner = test_annotations(1, func_b, func_c)
     >>> sorted(inner.__annotations__.items())
-    [('return', 99), ('x', 'banana'), ('y', 42)]
+    [('return', 'c()'), ('x', "'banana'"), ('y', 'b()')]
     """
     def inner(x: "banana", y: b()) -> c():
         return x,y

tests/run/cython3.pyx

@@ -578,15 +578,15 @@ def annotation_syntax(a: "test new test", b : "other" = 2, *args: "ARGS", **kwar
     >>> len(annotation_syntax.__annotations__)
     5
     >>> print(annotation_syntax.__annotations__['a'])
-    test new test
+    u'test new test'
     >>> print(annotation_syntax.__annotations__['b'])
-    other
+    u'other'
     >>> print(annotation_syntax.__annotations__['args'])
-    ARGS
+    u'ARGS'
     >>> print(annotation_syntax.__annotations__['kwargs'])
-    KWARGS
+    u'KWARGS'
     >>> print(annotation_syntax.__annotations__['return'])
-    ret
+    u'ret'
     """
     result : int = a + b
 
@@ -610,9 +610,9 @@ async def async_def_annotations(x: 'int') -> 'float':
     >>> ret, arg = sorted(async_def_annotations.__annotations__.items())
     >>> print(ret[0]); print(ret[1])
     return
-    float
+    u'float'
     >>> print(arg[0]); print(arg[1])
     x
-    int
+    u'int'
     """
     return float(x)

tests/run/cython3_no_unicode_literals.pyx

@@ -140,6 +140,12 @@ def str_type_is_str():
     cdef str s = 'abc'
     return str, s
 
+def strip_wrapped_string(s):
+    # PEP 563 translates an annotation of "test new test" to '"test new test"'
+    # but choice of string delimiters is a bit arbitrary
+    #  this function handles that
+    assert s[0] == s[-1] # delimiters on either end are the same
+    return s[1:-1] # strip them
 
 def annotation_syntax(a: "test new test", b : "other" = 2, *args: "ARGS", **kwargs: "KWARGS") -> "ret":
     """
@@ -150,15 +156,15 @@ def annotation_syntax(a: "test new test", b : "other" = 2, *args: "ARGS", **kwar
 
     >>> len(annotation_syntax.__annotations__)
     5
-    >>> annotation_syntax.__annotations__['a']
+    >>> strip_wrapped_string(annotation_syntax.__annotations__['a'])
     'test new test'
-    >>> annotation_syntax.__annotations__['b']
+    >>> strip_wrapped_string(annotation_syntax.__annotations__['b'])
     'other'
-    >>> annotation_syntax.__annotations__['args']
+    >>> strip_wrapped_string(annotation_syntax.__annotations__['args'])
     'ARGS'
-    >>> annotation_syntax.__annotations__['kwargs']
+    >>> strip_wrapped_string(annotation_syntax.__annotations__['kwargs'])
     'KWARGS'
-    >>> annotation_syntax.__annotations__['return']
+    >>> strip_wrapped_string(annotation_syntax.__annotations__['return'])
     'ret'
     """
     result : int = a + b

tests/run/embedsignatures.pyx

 #cython: embedsignature=True, annotation_typing=False
 
+# signatures here are a little fragile - when they are
+# generated during the build process gives slightly
+# different (but equivalent) forms - therefore tests
+# may need changing occasionally to reflect behaviour
+# and this isn't necessarily a bug
+
 import sys
 
 if sys.version_info >= (3, 4):
     def funcdoc(f):
-        if not f.__text_signature__:
+        if not getattr(f, "__text_signature__", None):
             return f.__doc__
         doc = '%s%s' % (f.__name__, f.__text_signature__)
         if f.__doc__:
@@ -447,10 +453,10 @@ Foo.m01(self, a: ...) -> Ellipsis
 Foo.m02(self, a: True, b: False) -> bool
 
 >>> print(Foo.m03.__doc__)
-Foo.m03(self, a: 42, b: 42, c: -42) -> int
+Foo.m03(self, a: 42, b: +42, c: -42) -> int
 
 >>> print(Foo.m04.__doc__)
-Foo.m04(self, a: 3.14, b: 3.14, c: -3.14) -> float
+Foo.m04(self, a: 3.14, b: +3.14, c: -3.14) -> float
 
 >>> print(Foo.m05.__doc__)
 Foo.m05(self, a: 1 + 2j, b: +2j, c: -2j) -> complex
@@ -465,7 +471,7 @@ Foo.m07(self, a: [1, 2, 3], b: []) -> list
 Foo.m08(self, a: (1, 2, 3), b: ()) -> tuple
 
 >>> print(Foo.m09.__doc__)
-Foo.m09(self, a: {1, 2, 3}, b: set()) -> set
+Foo.m09(self, a: {1, 2, 3}, b: {i for i in ()}) -> set
 
 >>> print(Foo.m10.__doc__)
 Foo.m10(self, a: {1: 1, 2: 2, 3: 3}, b: {}) -> dict

tests/run/generators_py35.py

@@ -30,10 +30,10 @@ def anno_gen(x: 'int') -> 'float':
     >>> next(gen)
     2.0
     >>> ret, arg = sorted(anno_gen.__annotations__.items())
-    >>> print(ret[0]); print(ret[1])
+    >>> print(ret[0]); print(str(ret[1]).strip("'")) # strip makes it pass with/without PEP563
     return
     float
-    >>> print(arg[0]); print(arg[1])
+    >>> print(arg[0]); print(str(arg[1]).strip("'"))
     x
     int
     """

tests/run/pep563_annotations.py

+# mode: run
+# tag: pep563, pure3.7
+
+from __future__ import annotations
+
+def f(a: 1+2==3, b: list, c: this_cant_evaluate, d: "Hello from inside a string") -> "Return me!":
+    """
+    The absolute exact strings aren't reproducible according to the PEP,
+    so be careful to avoid being too specific
+    >>> stypes = (type(""), type(u"")) # Python 2 is a bit awkward here
+    >>> eval(f.__annotations__['a'])
+    True
+    >>> isinstance(f.__annotations__['a'], stypes)
+    True
+    >>> print(f.__annotations__['b'])
+    list
+    >>> print(f.__annotations__['c'])
+    this_cant_evaluate
+    >>> isinstance(eval(f.__annotations__['d']), stypes)
+    True
+    >>> print(f.__annotations__['return'][1:-1]) # First and last could be either " or '
+    Return me!
+    >>> f.__annotations__['return'][0] == f.__annotations__['return'][-1]
+    True
+    """
+    pass
+

tests/run/test_coroutines_pep492.pyx

@@ -197,9 +197,10 @@ class AsyncBadSyntaxTest(unittest.TestCase):
                 pass
             """,
 
-            """async def foo(a:await something()):
-                pass
-            """,
+            #"""async def foo(a:await something()):
+            #    pass
+            #""", # No longer an error with pep-563 (although still nonsense)
+            # Some other similar tests have also been commented out
 
             """async def foo():
                 def bar():
@@ -397,9 +398,9 @@ class AsyncBadSyntaxTest(unittest.TestCase):
                    pass
             """,
 
-            """async def foo(a:await b):
-                   pass
-            """,
+            #"""async def foo(a:await b):
+            #       pass
+            #""",
 
             """def baz():
                    async def foo(a=await b):
@@ -612,9 +613,9 @@ class AsyncBadSyntaxTest(unittest.TestCase):
                    pass
             """,
 
-            """async def foo(a:await b):
-                   pass
-            """,
+            #"""async def foo(a:await b):
+            #       pass
+            #""",
 
             """def baz():
                    async def foo(a=await b):

tests/run/test_grammar.py

@@ -1112,7 +1112,7 @@ class GrammarTests(unittest.TestCase):
         check_syntax_error(self, "class foo:yield 1")
         check_syntax_error(self, "class foo:yield from ()")
         # Check annotation refleak on SyntaxError
-        check_syntax_error(self, "def g(a:(yield)): pass")
+        #check_syntax_error(self, "def g(a:(yield)): pass") # no longer a syntax error with PEP563
 
     @skip("DeprecationWarning not implemented")
     def test_yield_in_comprehensions(self):