Move generator-close on exception from the generator function to the GeneratorResume builtin.

src/builtins/builtins-generator-gen.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 29 matching lines @@
   Node* receiver_continuation =
       LoadObjectField(receiver, JSGeneratorObject::kContinuationOffset);
   Label if_receiverisclosed(this, Label::kDeferred),
       if_receiverisrunning(this, Label::kDeferred);
   GotoIf(SmiEqual(receiver_continuation, closed), &if_receiverisclosed);
   DCHECK_LT(JSGeneratorObject::kGeneratorExecuting,
             JSGeneratorObject::kGeneratorClosed);
   GotoIf(SmiLessThan(receiver_continuation, closed), &if_receiverisrunning);
 
   // Resume the {receiver} using our trampoline.
+  VARIABLE(var_exception, MachineRepresentation::kTagged, UndefinedConstant());
+  Label if_exception(this, Label::kDeferred);
   Node* result =
       CallStub(CodeFactory::ResumeGenerator(isolate()), context, value,
                receiver, SmiConstant(resume_mode),
                SmiConstant(static_cast<int>(SuspendFlags::kGeneratorYield)));
+  // Make sure we close the generator if there was an exception.
+  GotoIfException(result, &if_exception, &var_exception);

[caitp, 2017/06/03 23:14:00]

also, given what I said in the top-level comment, I think you also need to
handle normal returns here, too.

If, after this stub call, the generator state is still "Executing", you can set
the state to complete before returning the value.

Another thing: we could shrink the bytecode by creating the IteratorResult in
the resume stub at this point, rather than in bytecode. (`{ value:
stubReturnValue, done: generator state ==JSGeneratorObject::kExecuting }`).

[Jarin, 2017/06/04 08:49:39]

At the moment normal returns are handled in BytecodeGenerator, so it should not
be wrong. 

I agree that having all the closing logic in one place sounds better, but this
somehow breaks modules.  
Done. 

[Jarin, 2017/06/04 08:56:47]

Note that we can only do this for normal returns because yields coming from
yield* must preserve the identity of the IteratorResult. It would be against the
spec to unwrap and wrap the value from yield*.

   Return(result);
 
   BIND(&if_receiverisincompatible);
   {
     // The {receiver} is not a valid JSGeneratorObject.
     CallRuntime(Runtime::kThrowIncompatibleMethodReceiver, context,
                 HeapConstant(
                     factory()->NewStringFromAsciiChecked(method_name, TENURED)),
                 receiver);
     Unreachable();
@@ skipping 20 matching lines @@
         break;
     }
     Return(result);
   }
 
   BIND(&if_receiverisrunning);
   {
     CallRuntime(Runtime::kThrowGeneratorRunning, context);
     Unreachable();
   }
+
+  BIND(&if_exception);
+  {
+    StoreObjectFieldNoWriteBarrier(
+        receiver, JSGeneratorObject::kContinuationOffset, closed);
+    CallRuntime(Runtime::kReThrow, context, var_exception.value());
+    Unreachable();
+  }
 }
 
 // ES6 #sec-generator.prototype.next
 TF_BUILTIN(GeneratorPrototypeNext, GeneratorBuiltinsAssembler) {
   Node* receiver = Parameter(Descriptor::kReceiver);
   Node* value = Parameter(Descriptor::kValue);
   Node* context = Parameter(Descriptor::kContext);
   GeneratorPrototypeResume(receiver, value, context, JSGeneratorObject::kNext,
                            "[Generator].prototype.next");
 }
@@ skipping 12 matching lines @@
   Node* receiver = Parameter(Descriptor::kReceiver);
   Node* exception = Parameter(Descriptor::kException);
   Node* context = Parameter(Descriptor::kContext);
   GeneratorPrototypeResume(receiver, exception, context,
                            JSGeneratorObject::kThrow,
                            "[Generator].prototype.throw");
 }
 
 }  // namespace internal
 }  // namespace v8