During metaclass.__init__, super() of the constructed class does not work

Python/compile.c

 /*
  * This file compiles an abstract syntax tree (AST) into Python bytecode.
  *
  * The primary entry point is PyAST_Compile(), which returns a
  * PyCodeObject.  The compiler makes several passes to build the code
  * object:
  *   1. Checks for future statements.  See future.c
  *   2. Builds a symbol table.  See symtable.c.
  *   3. Generate code for basic blocks.  See compiler_mod() in this file.
  *   4. Assemble the basic blocks into final code.  See assemble() in
@@ skipping 161 matching lines @@
 static int compiler_addop_i(struct compiler *, int, Py_ssize_t);
 static int compiler_addop_j(struct compiler *, int, basicblock *, int);
 static int compiler_error(struct compiler *, const char *);
 static int compiler_nameop(struct compiler *, identifier, expr_context_ty);
 
 static PyCodeObject *compiler_mod(struct compiler *, mod_ty);
 static int compiler_visit_stmt(struct compiler *, stmt_ty);
 static int compiler_visit_keyword(struct compiler *, keyword_ty);
 static int compiler_visit_expr(struct compiler *, expr_ty);
 static int compiler_augassign(struct compiler *, stmt_ty);
+static int compiler_annassign(struct compiler *, stmt_ty);
 static int compiler_visit_slice(struct compiler *, slice_ty,
                                 expr_context_ty);
 
 static int compiler_push_fblock(struct compiler *, enum fblocktype,
                                 basicblock *);
 static void compiler_pop_fblock(struct compiler *, enum fblocktype,
                                 basicblock *);
 /* Returns true if there is a loop on the fblock stack. */
 static int compiler_in_loop(struct compiler *);
 
 static int inplace_binop(struct compiler *, operator_ty);
 static int expr_constant(struct compiler *, expr_ty);
 
 static int compiler_with(struct compiler *, stmt_ty, int);
 static int compiler_async_with(struct compiler *, stmt_ty, int);
 static int compiler_async_for(struct compiler *, stmt_ty);
 static int compiler_call_helper(struct compiler *c, int n,
                                 asdl_seq *args,
                                 asdl_seq *keywords);
 static int compiler_try_except(struct compiler *, stmt_ty);
 static int compiler_set_qualname(struct compiler *);
+
+static int compiler_sync_comprehension_generator(
+                                      struct compiler *c,
+                                      asdl_seq *generators, int gen_index,
+                                      expr_ty elt, expr_ty val, int type);
+
+static int compiler_async_comprehension_generator(
+                                      struct compiler *c,
+                                      asdl_seq *generators, int gen_index,
+                                      expr_ty elt, expr_ty val, int type);
 
 static PyCodeObject *assemble(struct compiler *, int addNone);
 static PyObject *__doc__;
 
 #define CAPSULE_NAME "compile.c compiler unit"
 
 PyObject *
 _Py_Mangle(PyObject *privateobj, PyObject *ident)
 {
     /* Name mangling: __private becomes _classname__private.
@@ skipping 256 matching lines @@
     }
     Py_DECREF(sorted_keys);
     return dest;
 }
 
 static void
 compiler_unit_check(struct compiler_unit *u)
 {
     basicblock *block;
     for (block = u->u_blocks; block != NULL; block = block->b_list) {
-        assert((Py_uintptr_t)block != 0xcbcbcbcbU);
-        assert((Py_uintptr_t)block != 0xfbfbfbfbU);
-        assert((Py_uintptr_t)block != 0xdbdbdbdbU);
+        assert((uintptr_t)block != 0xcbcbcbcbU);
+        assert((uintptr_t)block != 0xfbfbfbfbU);
+        assert((uintptr_t)block != 0xdbdbdbdbU);
         if (block->b_instr != NULL) {
             assert(block->b_ialloc > 0);
             assert(block->b_iused > 0);
             assert(block->b_ialloc >= block->b_iused);
         }
         else {
             assert (block->b_iused == 0);
             assert (block->b_ialloc == 0);
         }
     }
@@ skipping 305 matching lines @@
         b->b_ialloc = DEFAULT_BLOCK_SIZE;
         memset((char *)b->b_instr, 0,
                sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
     }
     else if (b->b_iused == b->b_ialloc) {
         struct instr *tmp;
         size_t oldsize, newsize;
         oldsize = b->b_ialloc * sizeof(struct instr);
         newsize = oldsize << 1;
 
-        if (oldsize > (PY_SIZE_MAX >> 1)) {
+        if (oldsize > (SIZE_MAX >> 1)) {
             PyErr_NoMemory();
             return -1;
         }
 
         if (newsize == 0) {
             PyErr_NoMemory();
             return -1;
         }
         b->b_ialloc <<= 1;
         tmp = (struct instr *)PyObject_Realloc(
@@ skipping 108 matching lines @@
         case SETUP_WITH:
             return 7;
         case WITH_CLEANUP_START:
             return 1;
         case WITH_CLEANUP_FINISH:
             return -1; /* XXX Sometimes more */
         case RETURN_VALUE:
             return -1;
         case IMPORT_STAR:
             return -1;
+        case SETUP_ANNOTATIONS:
+            return 0;
         case YIELD_VALUE:
             return 0;
         case YIELD_FROM:
             return -1;
         case POP_BLOCK:
             return 0;
         case POP_EXCEPT:
             return 0;  /* -3 except if bad bytecode */
         case END_FINALLY:
             return -1; /* or -2 or -3 if exception occurred */
@@ skipping 17 matching lines @@
             return -1;
         case DELETE_GLOBAL:
             return 0;
         case LOAD_CONST:
             return 1;
         case LOAD_NAME:
             return 1;
         case BUILD_TUPLE:
         case BUILD_LIST:
         case BUILD_SET:
+        case BUILD_STRING:
             return 1-oparg;
         case BUILD_LIST_UNPACK:
         case BUILD_TUPLE_UNPACK:
+        case BUILD_TUPLE_UNPACK_WITH_CALL:
         case BUILD_SET_UNPACK:
         case BUILD_MAP_UNPACK:
+        case BUILD_MAP_UNPACK_WITH_CALL:
             return 1 - oparg;
-        case BUILD_MAP_UNPACK_WITH_CALL:
-            return 1 - (oparg & 0xFF);
         case BUILD_MAP:
             return 1 - 2*oparg;
         case BUILD_CONST_KEY_MAP:
             return -oparg;
         case LOAD_ATTR:
             return 0;
         case COMPARE_OP:
             return -1;
         case IMPORT_NAME:
             return -1;
@@ skipping 21 matching lines @@
         case SETUP_FINALLY:
             return 6; /* can push 3 values for the new exception
                 + 3 others for the previous exception state */
 
         case LOAD_FAST:
             return 1;
         case STORE_FAST:
             return -1;
         case DELETE_FAST:
             return 0;
+        case STORE_ANNOTATION:
+            return -1;
 
         case RAISE_VARARGS:
             return -oparg;
-#define NARGS(o) (((o) % 256) + 2*(((o) / 256) % 256))
         case CALL_FUNCTION:
-            return -NARGS(oparg);
-        case CALL_FUNCTION_VAR:
+            return -oparg;
         case CALL_FUNCTION_KW:
-            return -NARGS(oparg)-1;
-        case CALL_FUNCTION_VAR_KW:
-            return -NARGS(oparg)-2;
-#undef NARGS
+            return -oparg-1;
+        case CALL_FUNCTION_EX:
+            return - ((oparg & 0x01) != 0) - ((oparg & 0x02) != 0);
         case MAKE_FUNCTION:
             return -1 - ((oparg & 0x01) != 0) - ((oparg & 0x02) != 0) -
                 ((oparg & 0x04) != 0) - ((oparg & 0x08) != 0);
         case BUILD_SLICE:
             if (oparg == 3)
                 return -2;
             else
                 return -1;
 
         case LOAD_CLOSURE:
@@ skipping 306 matching lines @@
     case Ellipsis_kind:
         return Py_Ellipsis;
     case NameConstant_kind:
         return e->v.NameConstant.value;
     default:
         assert(!is_const(e));
         return NULL;
     }
 }
 
-/* Compile a sequence of statements, checking for a docstring. */
+/* Search if variable annotations are present statically in a block. */
+
+static int
+find_ann(asdl_seq *stmts)
+{
+    int i, j, res = 0;
+    stmt_ty st;
+
+    for (i = 0; i < asdl_seq_LEN(stmts); i++) {
+        st = (stmt_ty)asdl_seq_GET(stmts, i);
+        switch (st->kind) {
+        case AnnAssign_kind:
+            return 1;
+        case For_kind:
+            res = find_ann(st->v.For.body) ||
+                  find_ann(st->v.For.orelse);
+            break;
+        case AsyncFor_kind:
+            res = find_ann(st->v.AsyncFor.body) ||
+                  find_ann(st->v.AsyncFor.orelse);
+            break;
+        case While_kind:
+            res = find_ann(st->v.While.body) ||
+                  find_ann(st->v.While.orelse);
+            break;
+        case If_kind:
+            res = find_ann(st->v.If.body) ||
+                  find_ann(st->v.If.orelse);
+            break;
+        case With_kind:
+            res = find_ann(st->v.With.body);
+            break;
+        case AsyncWith_kind:
+            res = find_ann(st->v.AsyncWith.body);
+            break;
+        case Try_kind:
+            for (j = 0; j < asdl_seq_LEN(st->v.Try.handlers); j++) {
+                excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
+                    st->v.Try.handlers, j);
+                if (find_ann(handler->v.ExceptHandler.body)) {
+                    return 1;
+                }
+            }
+            res = find_ann(st->v.Try.body) ||
+                  find_ann(st->v.Try.finalbody) ||
+                  find_ann(st->v.Try.orelse);
+            break;
+        default:
+            res = 0;
+        }
+        if (res) {
+            break;
+        }
+    }
+    return res;
+}
+
+/* Compile a sequence of statements, checking for a docstring
+   and for annotations. */
 
 static int
 compiler_body(struct compiler *c, asdl_seq *stmts)
 {
     int i = 0;
     stmt_ty st;
 
+    /* Set current line number to the line number of first statement.
+       This way line number for SETUP_ANNOTATIONS will always
+       coincide with the line number of first "real" statement in module.
+       If body is empy, then lineno will be set later in assemble. */
+    if (c->u->u_scope_type == COMPILER_SCOPE_MODULE &&
+        !c->u->u_lineno && asdl_seq_LEN(stmts)) {
+        st = (stmt_ty)asdl_seq_GET(stmts, 0);
+        c->u->u_lineno = st->lineno;
+    }
+    /* Every annotated class and module should have __annotations__. */
+    if (find_ann(stmts)) {
+        ADDOP(c, SETUP_ANNOTATIONS);
+    }
     if (!asdl_seq_LEN(stmts))
         return 1;
     st = (stmt_ty)asdl_seq_GET(stmts, 0);
     if (compiler_isdocstring(st) && c->c_optimize < 2) {
         /* don't generate docstrings if -OO */
         i = 1;
         VISIT(c, expr, st->v.Expr.value);
         if (!compiler_nameop(c, __doc__, Store))
             return 0;
     }
@@ skipping 17 matching lines @@
     if (!compiler_enter_scope(c, module, COMPILER_SCOPE_MODULE, mod, 0))
         return NULL;
     switch (mod->kind) {
     case Module_kind:
         if (!compiler_body(c, mod->v.Module.body)) {
             compiler_exit_scope(c);
             return 0;
         }
         break;
     case Interactive_kind:
+        if (find_ann(mod->v.Interactive.body)) {
+            ADDOP(c, SETUP_ANNOTATIONS);
+        }
         c->c_interactive = 1;
         VISIT_SEQ_IN_SCOPE(c, stmt,
                                 mod->v.Interactive.body);
         break;
     case Expression_kind:
         VISIT_IN_SCOPE(c, expr, mod->v.Expression.body);
         addNone = 0;
         break;
     case Suite_kind:
         PyErr_SetString(PyExc_SystemError,
@@ skipping 13 matching lines @@
 /* The test for LOCAL must come before the test for FREE in order to
    handle classes where name is both local and free.  The local var is
    a method and the free var is a free var referenced within a method.
 */
 
 static int
 get_ref_type(struct compiler *c, PyObject *name)
 {
     int scope;
     if (c->u->u_scope_type == COMPILER_SCOPE_CLASS &&
-        !PyUnicode_CompareWithASCIIString(name, "__class__"))
+        _PyUnicode_EqualToASCIIString(name, "__class__"))
         return CELL;
     scope = PyST_GetScope(c->u->u_ste, name);
     if (scope == 0) {
         char buf[350];
         PyOS_snprintf(buf, sizeof(buf),
                       "unknown scope for %.100s in %.100s(%s)\n"
                       "symbols: %s\nlocals: %s\nglobals: %s",
                       PyUnicode_AsUTF8(name),
                       PyUnicode_AsUTF8(c->u->u_name),
                       PyUnicode_AsUTF8(PyObject_Repr(c->u->u_ste->ste_id)),
@@ skipping 350 matching lines @@
     co = assemble(c, 1);
     qualname = c->u->u_qualname;
     Py_INCREF(qualname);
     compiler_exit_scope(c);
     if (co == NULL) {
         Py_XDECREF(qualname);
         Py_XDECREF(co);
         return 0;
     }
 
-    if (is_async)
-        co->co_flags |= CO_COROUTINE;
     compiler_make_closure(c, co, funcflags, qualname);
     Py_DECREF(qualname);
     Py_DECREF(co);
 
     /* decorators */
     for (i = 0; i < asdl_seq_LEN(decos); i++) {
         ADDOP_I(c, CALL_FUNCTION, 1);
     }
 
     return compiler_nameop(c, name, Store);
@@ skipping 54 matching lines @@
             Py_XDECREF(str);
             compiler_exit_scope(c);
             return 0;
         }
         Py_DECREF(str);
         /* compile the body proper */
         if (!compiler_body(c, s->v.ClassDef.body)) {
             compiler_exit_scope(c);
             return 0;
         }
+        /* Return __classcell__ if it is referenced, otherwise return None */
         if (c->u->u_ste->ste_needs_class_closure) {
-            /* store __classcell__ into class namespace */
+            /* Store __classcell__ into class namespace & return it */
             str = PyUnicode_InternFromString("__class__");
             if (str == NULL) {
                 compiler_exit_scope(c);
                 return 0;
             }
             i = compiler_lookup_arg(c->u->u_cellvars, str);
             Py_DECREF(str);
             if (i < 0) {
                 compiler_exit_scope(c);
                 return 0;
             }
             assert(i == 0);
 
             ADDOP_I(c, LOAD_CLOSURE, i);
+            ADDOP(c, DUP_TOP);
             str = PyUnicode_InternFromString("__classcell__");
             if (!str || !compiler_nameop(c, str, Store)) {
                 Py_XDECREF(str);
                 compiler_exit_scope(c);
                 return 0;
             }
             Py_DECREF(str);
         }
         else {
-            /* This happens when nobody references the cell. */
+            /* No methods referenced __class__, so just return None */
             assert(PyDict_Size(c->u->u_cellvars) == 0);
-        }
-        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+            ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        }
         ADDOP_IN_SCOPE(c, RETURN_VALUE);
         /* create the code object */
         co = assemble(c, 1);
     }
     /* leave the new scope */
     compiler_exit_scope(c);
     if (co == NULL)
         return 0;
 
     /* 2. load the 'build_class' function */
@@ skipping 163 matching lines @@
     compiler_pop_fblock(c, LOOP, start);
     VISIT_SEQ(c, stmt, s->v.For.orelse);
     compiler_use_next_block(c, end);
     return 1;
 }
 
 
 static int
 compiler_async_for(struct compiler *c, stmt_ty s)
 {
-    static PyObject *stopiter_error = NULL;
+    _Py_IDENTIFIER(StopAsyncIteration);
+
     basicblock *try, *except, *end, *after_try, *try_cleanup,
                *after_loop, *after_loop_else;
 
-    if (stopiter_error == NULL) {
-        stopiter_error = PyUnicode_InternFromString("StopAsyncIteration");
-        if (stopiter_error == NULL)
-            return 0;
+    PyObject *stop_aiter_error = _PyUnicode_FromId(&PyId_StopAsyncIteration);
+    if (stop_aiter_error == NULL) {
+        return 0;
     }
 
     try = compiler_new_block(c);
     except = compiler_new_block(c);
     end = compiler_new_block(c);
     after_try = compiler_new_block(c);
     try_cleanup = compiler_new_block(c);
     after_loop = compiler_new_block(c);
     after_loop_else = compiler_new_block(c);
 
@@ skipping 21 matching lines @@
     ADDOP_O(c, LOAD_CONST, Py_None, consts);
     ADDOP(c, YIELD_FROM);
     VISIT(c, expr, s->v.AsyncFor.target);
     ADDOP(c, POP_BLOCK);
     compiler_pop_fblock(c, EXCEPT, try);
     ADDOP_JREL(c, JUMP_FORWARD, after_try);
 
 
     compiler_use_next_block(c, except);
     ADDOP(c, DUP_TOP);
-    ADDOP_O(c, LOAD_GLOBAL, stopiter_error, names);
+    ADDOP_O(c, LOAD_GLOBAL, stop_aiter_error, names);
     ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH);
     ADDOP_JABS(c, POP_JUMP_IF_FALSE, try_cleanup);
 
     ADDOP(c, POP_TOP);
     ADDOP(c, POP_TOP);
     ADDOP(c, POP_TOP);
     ADDOP(c, POP_EXCEPT); /* for SETUP_EXCEPT */
     ADDOP(c, POP_BLOCK); /* for SETUP_LOOP */
     ADDOP_JABS(c, JUMP_ABSOLUTE, after_loop_else);
 
@@ skipping 441 matching lines @@
     }
 
     /* build up the names */
     for (i = 0; i < n; i++) {
         alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
         Py_INCREF(alias->name);
         PyTuple_SET_ITEM(names, i, alias->name);
     }
 
     if (s->lineno > c->c_future->ff_lineno && s->v.ImportFrom.module &&
-        !PyUnicode_CompareWithASCIIString(s->v.ImportFrom.module, "__future__")) {
+        _PyUnicode_EqualToASCIIString(s->v.ImportFrom.module, "__future__")) {
         Py_DECREF(level);
         Py_DECREF(names);
         return compiler_error(c, "from __future__ imports must occur "
                               "at the beginning of the file");
     }
 
     ADDOP_O(c, LOAD_CONST, level, consts);
     Py_DECREF(level);
     ADDOP_O(c, LOAD_CONST, names, consts);
     Py_DECREF(names);
@@ skipping 102 matching lines @@
 
     switch (s->kind) {
     case FunctionDef_kind:
         return compiler_function(c, s, 0);
     case ClassDef_kind:
         return compiler_class(c, s);
     case Return_kind:
         if (c->u->u_ste->ste_type != FunctionBlock)
             return compiler_error(c, "'return' outside function");
         if (s->v.Return.value) {
+            if (c->u->u_ste->ste_coroutine && c->u->u_ste->ste_generator)
+                return compiler_error(
+                    c, "'return' with value in async generator");
             VISIT(c, expr, s->v.Return.value);
         }
         else
             ADDOP_O(c, LOAD_CONST, Py_None, consts);
         ADDOP(c, RETURN_VALUE);
         break;
     case Delete_kind:
         VISIT_SEQ(c, expr, s->v.Delete.targets)
         break;
     case Assign_kind:
         n = asdl_seq_LEN(s->v.Assign.targets);
         VISIT(c, expr, s->v.Assign.value);
         for (i = 0; i < n; i++) {
             if (i < n - 1)
                 ADDOP(c, DUP_TOP);
             VISIT(c, expr,
                   (expr_ty)asdl_seq_GET(s->v.Assign.targets, i));
         }
         break;
     case AugAssign_kind:
         return compiler_augassign(c, s);
+    case AnnAssign_kind:
+        return compiler_annassign(c, s);
     case For_kind:
         return compiler_for(c, s);
     case While_kind:
         return compiler_while(c, s);
     case If_kind:
         return compiler_if(c, s);
     case Raise_kind:
         n = 0;
         if (s->v.Raise.exc) {
             VISIT(c, expr, s->v.Raise.exc);
@@ skipping 170 matching lines @@
     enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
 
     PyObject *dict = c->u->u_names;
     PyObject *mangled;
     /* XXX AugStore isn't used anywhere! */
 
     mangled = _Py_Mangle(c->u->u_private, name);
     if (!mangled)
         return 0;
 
-    assert(PyUnicode_CompareWithASCIIString(name, "None") &&
-           PyUnicode_CompareWithASCIIString(name, "True") &&
-           PyUnicode_CompareWithASCIIString(name, "False"));
+    assert(!_PyUnicode_EqualToASCIIString(name, "None") &&
+           !_PyUnicode_EqualToASCIIString(name, "True") &&
+           !_PyUnicode_EqualToASCIIString(name, "False"));
 
     op = 0;
     optype = OP_NAME;
     scope = PyST_GetScope(c->u->u_ste, mangled);
     switch (scope) {
     case FREE:
         dict = c->u->u_freevars;
         optype = OP_DEREF;
         break;
     case CELL:
@@ skipping 360 matching lines @@
 {
     VISIT(c, expr, e->v.Call.func);
     return compiler_call_helper(c, 0,
                                 e->v.Call.args,
                                 e->v.Call.keywords);
 }
 
 static int
 compiler_joined_str(struct compiler *c, expr_ty e)
 {
-    /* Concatenate parts of a string using ''.join(parts). There are
-       probably better ways of doing this.
-
-       This is used for constructs like "'x=' f'{42}'", which have to
-       be evaluated at compile time. */
-
-    static PyObject *empty_string;
-    static PyObject *join_string;
-
-    if (!empty_string) {
-        empty_string = PyUnicode_FromString("");
-        if (!empty_string)
-            return 0;
-    }
-    if (!join_string) {
-        join_string = PyUnicode_FromString("join");
-        if (!join_string)
-            return 0;
-    }
-
-    ADDOP_O(c, LOAD_CONST, empty_string, consts);
-    ADDOP_NAME(c, LOAD_ATTR, join_string, names);
     VISIT_SEQ(c, expr, e->v.JoinedStr.values);
-    ADDOP_I(c, BUILD_LIST, asdl_seq_LEN(e->v.JoinedStr.values));
-    ADDOP_I(c, CALL_FUNCTION, 1);
+    ADDOP_I(c, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values));
     return 1;
 }
 
 /* Used to implement f-strings. Format a single value. */
 static int
 compiler_formatted_value(struct compiler *c, expr_ty e)
 {
     /* Our oparg encodes 2 pieces of information: the conversion
        character, and whether or not a format_spec was provided.
 
@@ skipping 70 matching lines @@
     return 1;
 }
 
 /* shared code between compiler_call and compiler_class */
 static int
 compiler_call_helper(struct compiler *c,
                      int n, /* Args already pushed */
                      asdl_seq *args,
                      asdl_seq *keywords)
 {
-    int code = 0;
-    Py_ssize_t nelts, i, nseen;
-    int nkw;
+    Py_ssize_t i, nseen, nelts, nkwelts;
+    int mustdictunpack = 0;
 
     /* the number of tuples and dictionaries on the stack */
     Py_ssize_t nsubargs = 0, nsubkwargs = 0;
 
-    nkw = 0;
-    nseen = 0;  /* the number of positional arguments on the stack */
     nelts = asdl_seq_LEN(args);
+    nkwelts = asdl_seq_LEN(keywords);
+
+    for (i = 0; i < nkwelts; i++) {
+        keyword_ty kw = asdl_seq_GET(keywords, i);
+        if (kw->arg == NULL) {
+            mustdictunpack = 1;
+            break;
+        }
+    }
+
+    nseen = n;  /* the number of positional arguments on the stack */
     for (i = 0; i < nelts; i++) {
         expr_ty elt = asdl_seq_GET(args, i);
         if (elt->kind == Starred_kind) {
             /* A star-arg. If we've seen positional arguments,
-               pack the positional arguments into a
-               tuple. */
+               pack the positional arguments into a tuple. */
             if (nseen) {
                 ADDOP_I(c, BUILD_TUPLE, nseen);
                 nseen = 0;
                 nsubargs++;
             }
             VISIT(c, expr, elt->v.Starred.value);
             nsubargs++;
         }
-        else if (nsubargs) {
-            /* We've seen star-args already, so we
-               count towards items-to-pack-into-tuple. */
+        else {
             VISIT(c, expr, elt);
             nseen++;
         }
-        else {
-            /* Positional arguments before star-arguments
-               are left on the stack. */
-            VISIT(c, expr, elt);
-            n++;
-        }
-    }
-    if (nseen) {
-        /* Pack up any trailing positional arguments. */
-        ADDOP_I(c, BUILD_TUPLE, nseen);
-        nsubargs++;
-    }
-    if (nsubargs) {
-        code |= 1;
+    }
+
+    /* Same dance again for keyword arguments */
+    if (nsubargs || mustdictunpack) {
+        if (nseen) {
+            /* Pack up any trailing positional arguments. */
+            ADDOP_I(c, BUILD_TUPLE, nseen);
+            nsubargs++;
+        }
         if (nsubargs > 1) {
             /* If we ended up with more than one stararg, we need
                to concatenate them into a single sequence. */
-            ADDOP_I(c, BUILD_LIST_UNPACK, nsubargs);
-        }
-    }
-
-    /* Same dance again for keyword arguments */
-    nseen = 0;  /* the number of keyword arguments on the stack following */
-    nelts = asdl_seq_LEN(keywords);
-    for (i = 0; i < nelts; i++) {
-        keyword_ty kw = asdl_seq_GET(keywords, i);
-        if (kw->arg == NULL) {
-            /* A keyword argument unpacking. */
-            if (nseen) {
-                if (nsubkwargs) {
+            ADDOP_I(c, BUILD_TUPLE_UNPACK_WITH_CALL, nsubargs);
+        }
+        else if (nsubargs == 0) {
+            ADDOP_I(c, BUILD_TUPLE, 0);
+        }
+        nseen = 0;  /* the number of keyword arguments on the stack following */
+        for (i = 0; i < nkwelts; i++) {
+            keyword_ty kw = asdl_seq_GET(keywords, i);
+            if (kw->arg == NULL) {
+                /* A keyword argument unpacking. */
+                if (nseen) {
                     if (!compiler_subkwargs(c, keywords, i - nseen, i))
                         return 0;
                     nsubkwargs++;
+                    nseen = 0;
                 }
-                else {
-                    Py_ssize_t j;
-                    for (j = 0; j < nseen; j++) {
-                        VISIT(c, keyword, asdl_seq_GET(keywords, j));
-                    }
-                    nkw = nseen;
-                }
-                nseen = 0;
+                VISIT(c, expr, kw->value);
+                nsubkwargs++;
             }
-            VISIT(c, expr, kw->value);
-            nsubkwargs++;
-        }
-        else {
-            nseen++;
-        }
-    }
-    if (nseen) {
-        if (nsubkwargs) {
+            else {
+                nseen++;
+            }
+        }
+        if (nseen) {
             /* Pack up any trailing keyword arguments. */
-            if (!compiler_subkwargs(c, keywords, nelts - nseen, nelts))
+            if (!compiler_subkwargs(c, keywords, nkwelts - nseen, nkwelts))
                 return 0;
             nsubkwargs++;
         }
-        else {
-            VISIT_SEQ(c, keyword, keywords);
-            nkw = nseen;
-        }
-    }
-    if (nsubkwargs) {
-        code |= 2;
         if (nsubkwargs > 1) {
             /* Pack it all up */
-            int function_pos = n + (code & 1) + 2 * nkw + 1;
-            ADDOP_I(c, BUILD_MAP_UNPACK_WITH_CALL, nsubkwargs | (function_pos << 8));
-        }
-    }
-    assert(n < 1<<8);
-    assert(nkw < 1<<24);
-    n |= nkw << 8;
-
-    switch (code) {
-    case 0:
-        ADDOP_I(c, CALL_FUNCTION, n);
-        break;
-    case 1:
-        ADDOP_I(c, CALL_FUNCTION_VAR, n);
-        break;
-    case 2:
-        ADDOP_I(c, CALL_FUNCTION_KW, n);
-        break;
-    case 3:
-        ADDOP_I(c, CALL_FUNCTION_VAR_KW, n);
-        break;
-    }
-    return 1;
+            ADDOP_I(c, BUILD_MAP_UNPACK_WITH_CALL, nsubkwargs);
+        }
+        ADDOP_I(c, CALL_FUNCTION_EX, nsubkwargs > 0);
+        return 1;
+    }
+    else if (nkwelts) {
+        PyObject *names;
+        VISIT_SEQ(c, keyword, keywords);
+        names = PyTuple_New(nkwelts);
+        if (names == NULL) {
+            return 0;
+        }
+        for (i = 0; i < nkwelts; i++) {
+            keyword_ty kw = asdl_seq_GET(keywords, i);
+            Py_INCREF(kw->arg);
+            PyTuple_SET_ITEM(names, i, kw->arg);
+        }
+        ADDOP_N(c, LOAD_CONST, names, consts);
+        ADDOP_I(c, CALL_FUNCTION_KW, n + nelts + nkwelts);
+        return 1;
+    }
+    else {
+        ADDOP_I(c, CALL_FUNCTION, n + nelts);
+        return 1;
+    }
 }
 
 
 /* List and set comprehensions and generator expressions work by creating a
   nested function to perform the actual iteration. This means that the
   iteration variables don't leak into the current scope.
   The defined function is called immediately following its definition, with the
   result of that call being the result of the expression.
   The LC/SC version returns the populated container, while the GE version is
   flagged in symtable.c as a generator, so it returns the generator object
   when the function is called.
   This code *knows* that the loop cannot contain break, continue, or return,
   so it cheats and skips the SETUP_LOOP/POP_BLOCK steps used in normal loops.
 
   Possible cleanups:
     - iterate over the generator sequence instead of using recursion
 */
 
+
 static int
 compiler_comprehension_generator(struct compiler *c,
                                  asdl_seq *generators, int gen_index,
                                  expr_ty elt, expr_ty val, int type)
+{
+    comprehension_ty gen;
+    gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
+    if (gen->is_async) {
+        return compiler_async_comprehension_generator(
+            c, generators, gen_index, elt, val, type);
+    } else {
+        return compiler_sync_comprehension_generator(
+            c, generators, gen_index, elt, val, type);
+    }
+}
+
+static int
+compiler_sync_comprehension_generator(struct compiler *c,
+                                      asdl_seq *generators, int gen_index,
+                                      expr_ty elt, expr_ty val, int type)
 {
     /* generate code for the iterator, then each of the ifs,
        and then write to the element */
 
     comprehension_ty gen;
     basicblock *start, *anchor, *skip, *if_cleanup;
     Py_ssize_t i, n;
 
     start = compiler_new_block(c);
     skip = compiler_new_block(c);
@@ skipping 67 matching lines @@
         compiler_use_next_block(c, skip);
     }
     compiler_use_next_block(c, if_cleanup);
     ADDOP_JABS(c, JUMP_ABSOLUTE, start);
     compiler_use_next_block(c, anchor);
 
     return 1;
 }
 
 static int
+compiler_async_comprehension_generator(struct compiler *c,
+                                      asdl_seq *generators, int gen_index,
+                                      expr_ty elt, expr_ty val, int type)
+{
+    _Py_IDENTIFIER(StopAsyncIteration);
+
+    comprehension_ty gen;
+    basicblock *anchor, *skip, *if_cleanup, *try,
+               *after_try, *except, *try_cleanup;
+    Py_ssize_t i, n;
+
+    PyObject *stop_aiter_error = _PyUnicode_FromId(&PyId_StopAsyncIteration);
+    if (stop_aiter_error == NULL) {
+        return 0;
+    }
+
+    try = compiler_new_block(c);
+    after_try = compiler_new_block(c);
+    try_cleanup = compiler_new_block(c);
+    except = compiler_new_block(c);
+    skip = compiler_new_block(c);
+    if_cleanup = compiler_new_block(c);
+    anchor = compiler_new_block(c);
+
+    if (skip == NULL || if_cleanup == NULL || anchor == NULL ||
+            try == NULL || after_try == NULL ||
+            except == NULL || after_try == NULL) {
+        return 0;
+    }
+
+    gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
+
+    if (gen_index == 0) {
+        /* Receive outermost iter as an implicit argument */
+        c->u->u_argcount = 1;
+        ADDOP_I(c, LOAD_FAST, 0);
+    }
+    else {
+        /* Sub-iter - calculate on the fly */
+        VISIT(c, expr, gen->iter);
+        ADDOP(c, GET_AITER);
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP(c, YIELD_FROM);
+    }
+
+    compiler_use_next_block(c, try);
+
+
+    ADDOP_JREL(c, SETUP_EXCEPT, except);
+    if (!compiler_push_fblock(c, EXCEPT, try))
+        return 0;
+
+    ADDOP(c, GET_ANEXT);
+    ADDOP_O(c, LOAD_CONST, Py_None, consts);
+    ADDOP(c, YIELD_FROM);
+    VISIT(c, expr, gen->target);
+    ADDOP(c, POP_BLOCK);
+    compiler_pop_fblock(c, EXCEPT, try);
+    ADDOP_JREL(c, JUMP_FORWARD, after_try);
+
+
+    compiler_use_next_block(c, except);
+    ADDOP(c, DUP_TOP);
+    ADDOP_O(c, LOAD_GLOBAL, stop_aiter_error, names);
+    ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH);
+    ADDOP_JABS(c, POP_JUMP_IF_FALSE, try_cleanup);
+
+    ADDOP(c, POP_TOP);
+    ADDOP(c, POP_TOP);
+    ADDOP(c, POP_TOP);
+    ADDOP(c, POP_EXCEPT); /* for SETUP_EXCEPT */
+    ADDOP_JABS(c, JUMP_ABSOLUTE, anchor);
+
+
+    compiler_use_next_block(c, try_cleanup);
+    ADDOP(c, END_FINALLY);
+
+    compiler_use_next_block(c, after_try);
+
+    n = asdl_seq_LEN(gen->ifs);
+    for (i = 0; i < n; i++) {
+        expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i);
+        VISIT(c, expr, e);
+        ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup);
+        NEXT_BLOCK(c);
+    }
+
+    if (++gen_index < asdl_seq_LEN(generators))
+        if (!compiler_comprehension_generator(c,
+                                              generators, gen_index,
+                                              elt, val, type))
+        return 0;
+
+    /* only append after the last for generator */
+    if (gen_index >= asdl_seq_LEN(generators)) {
+        /* comprehension specific code */
+        switch (type) {
+        case COMP_GENEXP:
+            VISIT(c, expr, elt);
+            ADDOP(c, YIELD_VALUE);
+            ADDOP(c, POP_TOP);
+            break;
+        case COMP_LISTCOMP:
+            VISIT(c, expr, elt);
+            ADDOP_I(c, LIST_APPEND, gen_index + 1);
+            break;
+        case COMP_SETCOMP:
+            VISIT(c, expr, elt);
+            ADDOP_I(c, SET_ADD, gen_index + 1);
+            break;
+        case COMP_DICTCOMP:
+            /* With 'd[k] = v', v is evaluated before k, so we do
+               the same. */
+            VISIT(c, expr, val);
+            VISIT(c, expr, elt);
+            ADDOP_I(c, MAP_ADD, gen_index + 1);
+            break;
+        default:
+            return 0;
+        }
+
+        compiler_use_next_block(c, skip);
+    }
+    compiler_use_next_block(c, if_cleanup);
+    ADDOP_JABS(c, JUMP_ABSOLUTE, try);
+    compiler_use_next_block(c, anchor);
+    ADDOP(c, POP_TOP);
+
+    return 1;
+}
+
+static int
 compiler_comprehension(struct compiler *c, expr_ty e, int type,
                        identifier name, asdl_seq *generators, expr_ty elt,
                        expr_ty val)
 {
     PyCodeObject *co = NULL;
-    expr_ty outermost_iter;
+    comprehension_ty outermost;
     PyObject *qualname = NULL;
-
-    outermost_iter = ((comprehension_ty)
-                      asdl_seq_GET(generators, 0))->iter;
+    int is_async_function = c->u->u_ste->ste_coroutine;
+    int is_async_generator = 0;
+
+    outermost = (comprehension_ty) asdl_seq_GET(generators, 0);
 
     if (!compiler_enter_scope(c, name, COMPILER_SCOPE_COMPREHENSION,
                               (void *)e, e->lineno))
+    {
         goto error;
+    }
+
+    is_async_generator = c->u->u_ste->ste_coroutine;
+
+    if (is_async_generator && !is_async_function) {
+        if (e->lineno > c->u->u_lineno) {
+            c->u->u_lineno = e->lineno;
+            c->u->u_lineno_set = 0;
+        }
+        compiler_error(c, "asynchronous comprehension outside of "
+                          "an asynchronous function");
+        goto error_in_scope;
+    }
 
     if (type != COMP_GENEXP) {
         int op;
         switch (type) {
         case COMP_LISTCOMP:
             op = BUILD_LIST;
             break;
         case COMP_SETCOMP:
             op = BUILD_SET;
             break;
@@ skipping 22 matching lines @@
     Py_INCREF(qualname);
     compiler_exit_scope(c);
     if (co == NULL)
         goto error;
 
     if (!compiler_make_closure(c, co, 0, qualname))
         goto error;
     Py_DECREF(qualname);
     Py_DECREF(co);
 
-    VISIT(c, expr, outermost_iter);
-    ADDOP(c, GET_ITER);
+    VISIT(c, expr, outermost->iter);
+
+    if (outermost->is_async) {
+        ADDOP(c, GET_AITER);
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP(c, YIELD_FROM);
+    } else {
+        ADDOP(c, GET_ITER);
+    }
+
     ADDOP_I(c, CALL_FUNCTION, 1);
+
+    if (is_async_generator && type != COMP_GENEXP) {
+        ADDOP(c, GET_AWAITABLE);
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP(c, YIELD_FROM);
+    }
+
     return 1;
 error_in_scope:
     compiler_exit_scope(c);
 error:
     Py_XDECREF(qualname);
     Py_XDECREF(co);
     return 0;
 }
 
 static int
@@ skipping 54 matching lines @@
     assert(e->kind == DictComp_kind);
     return compiler_comprehension(c, e, COMP_DICTCOMP, name,
                                   e->v.DictComp.generators,
                                   e->v.DictComp.key, e->v.DictComp.value);
 }
 
 
 static int
 compiler_visit_keyword(struct compiler *c, keyword_ty k)
 {
-    ADDOP_O(c, LOAD_CONST, k->arg, consts);
     VISIT(c, expr, k->value);
     return 1;
 }
 
 /* Test whether expression is constant.  For constants, report
    whether they are true or false.
 
    Return values: 1 for true, 0 for false, -1 for non-constant.
  */
 
@@ skipping 244 matching lines @@
         return compiler_genexp(c, e);
     case ListComp_kind:
         return compiler_listcomp(c, e);
     case SetComp_kind:
         return compiler_setcomp(c, e);
     case DictComp_kind:
         return compiler_dictcomp(c, e);
     case Yield_kind:
         if (c->u->u_ste->ste_type != FunctionBlock)
             return compiler_error(c, "'yield' outside function");
-        if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION)
-            return compiler_error(c, "'yield' inside async function");
         if (e->v.Yield.value) {
             VISIT(c, expr, e->v.Yield.value);
         }
         else {
             ADDOP_O(c, LOAD_CONST, Py_None, consts);
         }
         ADDOP(c, YIELD_VALUE);
         break;
     case YieldFrom_kind:
         if (c->u->u_ste->ste_type != FunctionBlock)
             return compiler_error(c, "'yield' outside function");
 
         if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION)
             return compiler_error(c, "'yield from' inside async function");
 
         VISIT(c, expr, e->v.YieldFrom.value);
         ADDOP(c, GET_YIELD_FROM_ITER);
         ADDOP_O(c, LOAD_CONST, Py_None, consts);
         ADDOP(c, YIELD_FROM);
         break;
     case Await_kind:
         if (c->u->u_ste->ste_type != FunctionBlock)
             return compiler_error(c, "'await' outside function");
 
-        if (c->u->u_scope_type == COMPILER_SCOPE_COMPREHENSION)
-            return compiler_error(
-                c, "'await' expressions in comprehensions are not supported");
-
-        if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION)
+        if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION &&
+                c->u->u_scope_type != COMPILER_SCOPE_COMPREHENSION)
             return compiler_error(c, "'await' outside async function");
 
         VISIT(c, expr, e->v.Await.value);
         ADDOP(c, GET_AWAITABLE);
         ADDOP_O(c, LOAD_CONST, Py_None, consts);
         ADDOP(c, YIELD_FROM);
         break;
     case Compare_kind:
         return compiler_compare(c, e);
     case Call_kind:
@@ skipping 138 matching lines @@
     default:
         PyErr_Format(PyExc_SystemError,
             "invalid node type (%d) for augmented assignment",
             e->kind);
         return 0;
     }
     return 1;
 }
 
 static int
+check_ann_expr(struct compiler *c, expr_ty e)
+{
+    VISIT(c, expr, e);
+    ADDOP(c, POP_TOP);
+    return 1;
+}
+
+static int
+check_annotation(struct compiler *c, stmt_ty s)
+{
+    /* Annotations are only evaluated in a module or class. */
+    if (c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
+        c->u->u_scope_type == COMPILER_SCOPE_CLASS) {
+        return check_ann_expr(c, s->v.AnnAssign.annotation);
+    }
+    return 1;
+}
+
+static int
+check_ann_slice(struct compiler *c, slice_ty sl)
+{
+    switch(sl->kind) {
+    case Index_kind:
+        return check_ann_expr(c, sl->v.Index.value);
+    case Slice_kind:
+        if (sl->v.Slice.lower && !check_ann_expr(c, sl->v.Slice.lower)) {
+            return 0;
+        }
+        if (sl->v.Slice.upper && !check_ann_expr(c, sl->v.Slice.upper)) {
+            return 0;
+        }
+        if (sl->v.Slice.step && !check_ann_expr(c, sl->v.Slice.step)) {
+            return 0;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError,
+                        "unexpected slice kind");
+        return 0;
+    }
+    return 1;
+}
+
+static int
+check_ann_subscr(struct compiler *c, slice_ty sl)
+{
+    /* We check that everything in a subscript is defined at runtime. */
+    Py_ssize_t i, n;
+
+    switch (sl->kind) {
+    case Index_kind:
+    case Slice_kind:
+        if (!check_ann_slice(c, sl)) {
+            return 0;
+        }
+        break;
+    case ExtSlice_kind:
+        n = asdl_seq_LEN(sl->v.ExtSlice.dims);
+        for (i = 0; i < n; i++) {
+            slice_ty subsl = (slice_ty)asdl_seq_GET(sl->v.ExtSlice.dims, i);
+            switch (subsl->kind) {
+            case Index_kind:
+            case Slice_kind:
+                if (!check_ann_slice(c, subsl)) {
+                    return 0;
+                }
+                break;
+            case ExtSlice_kind:
+            default:
+                PyErr_SetString(PyExc_SystemError,
+                                "extended slice invalid in nested slice");
+                return 0;
+            }
+        }
+        break;
+    default:
+        PyErr_Format(PyExc_SystemError,
+                     "invalid subscript kind %d", sl->kind);
+        return 0;
+    }
+    return 1;
+}
+
+static int
+compiler_annassign(struct compiler *c, stmt_ty s)
+{
+    expr_ty targ = s->v.AnnAssign.target;
+    PyObject* mangled;
+
+    assert(s->kind == AnnAssign_kind);
+
+    /* We perform the actual assignment first. */
+    if (s->v.AnnAssign.value) {
+        VISIT(c, expr, s->v.AnnAssign.value);
+        VISIT(c, expr, targ);
+    }
+    switch (targ->kind) {
+    case Name_kind:
+        /* If we have a simple name in a module or class, store annotation. */
+        if (s->v.AnnAssign.simple &&
+            (c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
+             c->u->u_scope_type == COMPILER_SCOPE_CLASS)) {
+            mangled = _Py_Mangle(c->u->u_private, targ->v.Name.id);
+            if (!mangled) {
+                return 0;
+            }
+            VISIT(c, expr, s->v.AnnAssign.annotation);
+            /* ADDOP_N decrefs its argument */
+            ADDOP_N(c, STORE_ANNOTATION, mangled, names);
+        }
+        break;
+    case Attribute_kind:
+        if (!s->v.AnnAssign.value &&
+            !check_ann_expr(c, targ->v.Attribute.value)) {
+            return 0;
+        }
+        break;
+    case Subscript_kind:
+        if (!s->v.AnnAssign.value &&
+            (!check_ann_expr(c, targ->v.Subscript.value) ||
+             !check_ann_subscr(c, targ->v.Subscript.slice))) {
+                return 0;
+        }
+        break;
+    default:
+        PyErr_Format(PyExc_SystemError,
+                     "invalid node type (%d) for annotated assignment",
+                     targ->kind);
+            return 0;
+    }
+    /* Annotation is evaluated last. */
+    if (!s->v.AnnAssign.simple && !check_annotation(c, s)) {
+        return 0;
+    }
+    return 1;
+}
+
+static int
 compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
 {
     struct fblockinfo *f;
     if (c->u->u_nfblocks >= CO_MAXBLOCKS) {
         PyErr_SetString(PyExc_SyntaxError,
                         "too many statically nested blocks");
         return 0;
     }
     f = &c->u->u_fblock[c->u->u_nfblocks++];
     f->fb_type = t;
@@ skipping 277 matching lines @@
 assemble_init(struct assembler *a, int nblocks, int firstlineno)
 {
     memset(a, 0, sizeof(struct assembler));
     a->a_lineno = firstlineno;
     a->a_bytecode = PyBytes_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
     if (!a->a_bytecode)
         return 0;
     a->a_lnotab = PyBytes_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
     if (!a->a_lnotab)
         return 0;
-    if ((size_t)nblocks > PY_SIZE_MAX / sizeof(basicblock *)) {
+    if ((size_t)nblocks > SIZE_MAX / sizeof(basicblock *)) {
         PyErr_NoMemory();
         return 0;
     }
     a->a_postorder = (basicblock **)PyObject_Malloc(
                                         sizeof(basicblock *) * nblocks);
     if (!a->a_postorder) {
         PyErr_NoMemory();
         return 0;
     }
     return 1;
@@ skipping 23 matching lines @@
    the instruction's bytecode offset and line number.  See
    Objects/lnotab_notes.txt for the description of the line number table. */
 
 static int
 assemble_lnotab(struct assembler *a, struct instr *i)
 {
     int d_bytecode, d_lineno;
     Py_ssize_t len;
     unsigned char *lnotab;
 
-    d_bytecode = a->a_offset - a->a_lineno_off;
+    d_bytecode = (a->a_offset - a->a_lineno_off) * sizeof(_Py_CODEUNIT);
     d_lineno = i->i_lineno - a->a_lineno;
 
     assert(d_bytecode >= 0);
 
     if(d_bytecode == 0 && d_lineno == 0)
         return 1;
 
     if (d_bytecode > 255) {
         int j, nbytes, ncodes = d_bytecode / 255;
         nbytes = a->a_lnotab_off + 2 * ncodes;
@@ skipping 86 matching lines @@
 /* assemble_emit()
    Extend the bytecode with a new instruction.
    Update lnotab if necessary.
 */
 
 static int
 assemble_emit(struct assembler *a, struct instr *i)
 {
     int size, arg = 0;
     Py_ssize_t len = PyBytes_GET_SIZE(a->a_bytecode);
-    char *code;
+    _Py_CODEUNIT *code;
 
     arg = i->i_oparg;
     size = instrsize(arg);
     if (i->i_lineno && !assemble_lnotab(a, i))
         return 0;
-    if (a->a_offset + size >= len) {
+    if (a->a_offset + size >= len / (int)sizeof(_Py_CODEUNIT)) {
         if (len > PY_SSIZE_T_MAX / 2)
             return 0;
         if (_PyBytes_Resize(&a->a_bytecode, len * 2) < 0)
             return 0;
     }
-    code = PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
+    code = (_Py_CODEUNIT *)PyBytes_AS_STRING(a->a_bytecode) + a->a_offset;
     a->a_offset += size;
-    write_op_arg((unsigned char*)code, i->i_opcode, arg, size);
+    write_op_arg(code, i->i_opcode, arg, size);
     return 1;
 }
 
 static void
 assemble_jump_offsets(struct assembler *a, struct compiler *c)
 {
     basicblock *b;
     int bsize, totsize, extended_arg_recompile;
     int i;
 
@@ skipping 16 matching lines @@
                 /* Relative jumps are computed relative to
                    the instruction pointer after fetching
                    the jump instruction.
                 */
                 bsize += isize;
                 if (instr->i_jabs || instr->i_jrel) {
                     instr->i_oparg = instr->i_target->b_offset;
                     if (instr->i_jrel) {
                         instr->i_oparg -= bsize;
                     }
+                    instr->i_oparg *= sizeof(_Py_CODEUNIT);
                     if (instrsize(instr->i_oparg) != isize) {
                         extended_arg_recompile = 1;
                     }
                 }
             }
         }
 
     /* XXX: This is an awful hack that could hurt performance, but
         on the bright side it should work until we come up
         with a better solution.
@@ skipping 37 matching lines @@
 static int
 compute_code_flags(struct compiler *c)
 {
     PySTEntryObject *ste = c->u->u_ste;
     int flags = 0;
     Py_ssize_t n;
     if (ste->ste_type == FunctionBlock) {
         flags |= CO_NEWLOCALS | CO_OPTIMIZED;
         if (ste->ste_nested)
             flags |= CO_NESTED;
-        if (ste->ste_generator)
+        if (ste->ste_generator && !ste->ste_coroutine)
             flags |= CO_GENERATOR;
+        if (!ste->ste_generator && ste->ste_coroutine)
+            flags |= CO_COROUTINE;
+        if (ste->ste_generator && ste->ste_coroutine)
+            flags |= CO_ASYNC_GENERATOR;
         if (ste->ste_varargs)
             flags |= CO_VARARGS;
         if (ste->ste_varkeywords)
             flags |= CO_VARKEYWORDS;
     }
 
     /* (Only) inherit compilerflags in PyCF_MASK */
     flags |= (c->c_flags->cf_flags & PyCF_MASK);
 
     n = PyDict_Size(c->u->u_freevars);
@@ skipping 140 matching lines @@
 
     nblocks = 0;
     entryblock = NULL;
     for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
         nblocks++;
         entryblock = b;
     }
 
     /* Set firstlineno if it wasn't explicitly set. */
     if (!c->u->u_firstlineno) {
-        if (entryblock && entryblock->b_instr)
+        if (entryblock && entryblock->b_instr && entryblock->b_instr->i_lineno)
             c->u->u_firstlineno = entryblock->b_instr->i_lineno;
         else
             c->u->u_firstlineno = 1;
     }
     if (!assemble_init(&a, nblocks, c->u->u_firstlineno))
         goto error;
     dfs(c, entryblock, &a);
 
     /* Can't modify the bytecode after computing jump offsets. */
     assemble_jump_offsets(&a, c);
 
     /* Emit code in reverse postorder from dfs. */
     for (i = a.a_nblocks - 1; i >= 0; i--) {
         b = a.a_postorder[i];
         for (j = 0; j < b->b_iused; j++)
             if (!assemble_emit(&a, &b->b_instr[j]))
                 goto error;
     }
 
     if (_PyBytes_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
         goto error;
-    if (_PyBytes_Resize(&a.a_bytecode, a.a_offset) < 0)
+    if (_PyBytes_Resize(&a.a_bytecode, a.a_offset * sizeof(_Py_CODEUNIT)) < 0)
         goto error;
 
     co = makecode(c, &a);
  error:
     assemble_free(&a);
     return co;
 }
 
 #undef PyAST_Compile
 PyAPI_FUNC(PyCodeObject *)
 PyAST_Compile(mod_ty mod, const char *filename, PyCompilerFlags *flags,
               PyArena *arena)
 {
     return PyAST_CompileEx(mod, filename, flags, -1, arena);
 }