[esnext] prototype runtime implementation for async functions

src/builtins.cc

Index: src/builtins.cc
diff --git a/src/builtins.cc b/src/builtins.cc
index 3579a5329b14506456a0cee89cd56a34000918d8..de33e5ed15ffe2d07f6599ab67e361c0673a81fc 100644
--- a/src/builtins.cc
+++ b/src/builtins.cc
@@ -2365,9 +2365,11 @@ void Builtins::Generate_MathTrunc(CodeStubAssembler* assembler) {
 
 namespace {
 
+enum class ResumeType { Generator, Async };
+
 void Generate_GeneratorPrototypeResume(

[Benedikt Meurer, 2016/05/02 02:16:47]

Please don't hijack this helper function for async resume. The core
functionality is already isolated in the ResumeGenerator builtin, so all you
need for AsyncFunction prototype is a thin wrapper around that. I'd even suggest
to introduce AsyncFunctionAwaitStub with two modes (Fullfilled, Rejected) and
use them to implement %_AsyncFunctionAwaitFulfilled and
%_AsyncFunctionAwaitRejected in your .js file.

[caitp (gmail), 2016/05/02 14:45:46]

See the comment on this file in one of the earlier patchsets --- it states that
the changes in builtins.h and builtins.cc are unnecessary, and will be pulled
out later :)

I'm not sure if new codestubs are really needed though, since just reusing the
generator functions is plenty. Are you saying you'd actually prefer code stubs
specifically for AsyncFunctionAwait, rather than the current approach of arrow
functions which call GeneratorNext / GeneratorThrow ?

     CodeStubAssembler* assembler, JSGeneratorObject::ResumeMode resume_mode,
-    char const* const method_name) {
+    char const* const method_name, ResumeType type) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
@@ -2379,24 +2381,29 @@ void Generate_GeneratorPrototypeResume(
 
   // Check if the {receiver} is actually a JSGeneratorObject.
   Label if_receiverisincompatible(assembler, Label::kDeferred);
-  assembler->GotoIf(assembler->WordIsSmi(receiver), &if_receiverisincompatible);
-  Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
-  assembler->GotoUnless(assembler->Word32Equal(
-                            receiver_instance_type,
-                            assembler->Int32Constant(JS_GENERATOR_OBJECT_TYPE)),
-                        &if_receiverisincompatible);
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->GotoIf(assembler->WordIsSmi(receiver),
+                      &if_receiverisincompatible);
+    Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
+    assembler->GotoUnless(assembler->Word32Equal(receiver_instance_type,
+                                                 assembler->Int32Constant(
+                                                     JS_GENERATOR_OBJECT_TYPE)),
+                          &if_receiverisincompatible);
+  }
 
   // Check if the {receiver} is running or already closed.
   Node* receiver_continuation = assembler->LoadObjectField(
       receiver, JSGeneratorObject::kContinuationOffset);
   Label if_receiverisclosed(assembler, Label::kDeferred),
       if_receiverisrunning(assembler, Label::kDeferred);
-  assembler->GotoIf(assembler->SmiEqual(receiver_continuation, closed),
-                    &if_receiverisclosed);
-  DCHECK_LT(JSGeneratorObject::kGeneratorExecuting,
-            JSGeneratorObject::kGeneratorClosed);
-  assembler->GotoIf(assembler->SmiLessThan(receiver_continuation, closed),
-                    &if_receiverisrunning);
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->GotoIf(assembler->SmiEqual(receiver_continuation, closed),
+                      &if_receiverisclosed);
+    DCHECK_LT(JSGeneratorObject::kGeneratorExecuting,
+              JSGeneratorObject::kGeneratorClosed);
+    assembler->GotoIf(assembler->SmiLessThan(receiver_continuation, closed),
+                      &if_receiverisrunning);
+  }
 
   // Resume the {receiver} using our trampoline.
   Node* result = assembler->CallStub(
@@ -2405,7 +2412,7 @@ void Generate_GeneratorPrototypeResume(
   assembler->Return(result);
 
   assembler->Bind(&if_receiverisincompatible);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
     // The {receiver} is not a valid JSGeneratorObject.
     Node* result = assembler->CallRuntime(
         Runtime::kThrowIncompatibleMethodReceiver, context,
@@ -2415,8 +2422,8 @@ void Generate_GeneratorPrototypeResume(
     assembler->Return(result);  // Never reached.
   }
 
-  assembler->Bind(&if_receiverisclosed);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->Bind(&if_receiverisclosed);
     // The {receiver} is closed already.
     Node* result = nullptr;
     switch (resume_mode) {
@@ -2437,8 +2444,8 @@ void Generate_GeneratorPrototypeResume(
     assembler->Return(result);
   }
 
-  assembler->Bind(&if_receiverisrunning);
-  {
+  if (type == ResumeType::Generator || FLAG_debug_code) {
+    assembler->Bind(&if_receiverisrunning);
     Node* result =
         assembler->CallRuntime(Runtime::kThrowGeneratorRunning, context);
     assembler->Return(result);  // Never reached.
@@ -2450,19 +2457,32 @@ void Generate_GeneratorPrototypeResume(
 // ES6 section 25.3.1.2 Generator.prototype.next ( value )
 void Builtins::Generate_GeneratorPrototypeNext(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kNext,
-                                    "[Generator].prototype.next");
+                                    "[Generator].prototype.next",
+                                    ResumeType::Generator);
 }
 
 // ES6 section 25.3.1.3 Generator.prototype.return ( value )
 void Builtins::Generate_GeneratorPrototypeReturn(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kReturn,
-                                    "[Generator].prototype.return");
+                                    "[Generator].prototype.return",
+                                    ResumeType::Generator);
 }
 
 // ES6 section 25.3.1.4 Generator.prototype.throw ( exception )
 void Builtins::Generate_GeneratorPrototypeThrow(CodeStubAssembler* assembler) {
   Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kThrow,
-                                    "[Generator].prototype.throw");
+                                    "[Generator].prototype.throw",
+                                    ResumeType::Generator);
+}
+
+void Builtins::Generate_AsyncFunctionNext(CodeStubAssembler* assembler) {
+  Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kNext,
+                                    "[AsyncFunction].next", ResumeType::Async);
+}
+
+void Builtins::Generate_AsyncFunctionThrow(CodeStubAssembler* assembler) {
+  Generate_GeneratorPrototypeResume(assembler, JSGeneratorObject::kThrow,
+                                    "[AsyncFunction].throw", ResumeType::Async);
 }
 
 // -----------------------------------------------------------------------------