Throw a TypeError when calling "next" method of a newly created generator with a value

src/ia32/full-codegen-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1932 matching lines @@
       __ jmp(&suspend);
 
       __ bind(&continuation);
       __ jmp(&resume);
 
       __ bind(&suspend);
       VisitForAccumulatorValue(expr->generator_object());
       ASSERT(continuation.pos() > 0 && Smi::IsValid(continuation.pos()));
       __ mov(FieldOperand(eax, JSGeneratorObject::kContinuationOffset),
              Immediate(Smi::FromInt(continuation.pos())));
+      if (expr->yield_kind() == Yield::INITIAL) {
+        __ mov(FieldOperand(eax, JSGeneratorObject::kSuspendedStartOffset),
+               Immediate(Smi::FromInt(continuation.pos())));
+      }
       __ mov(FieldOperand(eax, JSGeneratorObject::kContextOffset), esi);
       __ mov(ecx, esi);
       __ RecordWriteField(eax, JSGeneratorObject::kContextOffset, ecx, edx,
                           kDontSaveFPRegs);
       __ lea(ebx, Operand(ebp, StandardFrameConstants::kExpressionsOffset));
       __ cmp(esp, ebx);
       __ j(equal, &post_runtime);
       __ push(eax);  // generator object
       __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
       __ mov(context_register(),
              Operand(ebp, StandardFrameConstants::kContextOffset));
       __ bind(&post_runtime);
       __ pop(result_register());
       EmitReturnSequence();
 
       __ bind(&resume);

[wingo, 2014/02/11 08:59:21]

Instead of storing the initial suspend offset in the generator object, could we
not insert code at the resume point of the initial yield that throws unless the
"next" value is undefined?  That would save a word in each generator object.

WDYT?

[yusukesuzuki, 2014/02/11 11:46:59]

Yeah, saving a word in each generator object is important. However, an error is
needed to be raised from Generator.prototype.next(), not from generator's code.
So we need to raise an error in the Generator.prototype.next context.

So I've changed the code. Instead of storing initial suspend offset, when a
value is passed to an unborn generator, yield returns the hole value as a
marker. On the caller (Generator.prototype.next) side, the caller checks the
result and if the result value is the hole value, the caller throws an error.

What do you think about this implementation?

       context()->Plug(result_register());
       break;
     }
 
     case Yield::FINAL: {
       VisitForAccumulatorValue(expr->generator_object());
       __ mov(FieldOperand(result_register(),
                           JSGeneratorObject::kContinuationOffset),
              Immediate(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
       // Pop value from top-of-stack slot, box result into result register.
@@ skipping 96 matching lines @@
     JSGeneratorObject::ResumeMode resume_mode) {
   // The value stays in eax, and is ultimately read by the resumed generator, as
   // if the CallRuntime(Runtime::kSuspendJSGeneratorObject) returned it. Or it
   // is read to throw the value when the resumed generator is already closed.
   // ebx will hold the generator object until the activation has been resumed.
   VisitForStackValue(generator);
   VisitForAccumulatorValue(value);
   __ pop(ebx);
 
   // Check generator state.
-  Label wrong_state, closed_state, done;
+  Label wrong_state, closed_state, suspended_start_state, resume_state, done;
   STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
   STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
-  __ cmp(FieldOperand(ebx, JSGeneratorObject::kContinuationOffset),
-         Immediate(Smi::FromInt(0)));
+  __ mov(esi, FieldOperand(ebx, JSGeneratorObject::kContinuationOffset));
+  __ cmp(esi, Immediate(Smi::FromInt(0)));
   __ j(equal, &closed_state);
   __ j(less, &wrong_state);
+  __ cmp(esi, FieldOperand(ebx, JSGeneratorObject::kSuspendedStartOffset));
+  __ j(equal, &suspended_start_state);
+
+  __ bind(&resume_state);
 
   // Load suspended function and context.
   __ mov(esi, FieldOperand(ebx, JSGeneratorObject::kContextOffset));
   __ mov(edi, FieldOperand(ebx, JSGeneratorObject::kFunctionOffset));
 
   // Push receiver.
   __ push(FieldOperand(ebx, JSGeneratorObject::kReceiverOffset));
 
   // Push holes for arguments to generator function.
   __ mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
@@ skipping 49 matching lines @@
   __ push(ecx);
   __ jmp(&push_operand_holes);
   __ bind(&call_resume);
   __ push(ebx);
   __ push(result_register());
   __ Push(Smi::FromInt(resume_mode));
   __ CallRuntime(Runtime::kResumeJSGeneratorObject, 3);
   // Not reached: the runtime call returns elsewhere.
   __ Abort(kGeneratorFailedToResume);
 
+  // Throw the provided value.
+  Label throw_provided_value;
+  __ bind(&throw_provided_value);
+  if (resume_mode != JSGeneratorObject::NEXT) {
+    __ push(eax);
+    __ CallRuntime(Runtime::kThrow, 1);
+    __ jmp(&done);
+  }
+
+  // Reach here when calling initial resume to a generator.
+  __ bind(&suspended_start_state);
+  if (resume_mode == JSGeneratorObject::NEXT) {
+    // When value is provided and it is not undefined, throw error.
+    __ CompareRoot(eax, Heap::kUndefinedValueRootIndex);
+    __ j(equal, &resume_state);
+    __ CallRuntime(Runtime::kThrowGeneratorStartError, 0);
+    __ jmp(&done);
+  } else {
+    // Make generator's state to "closed".
+    __ mov(FieldOperand(ebx, JSGeneratorObject::kContinuationOffset),
+           Immediate(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
+    __ jmp(&throw_provided_value);
+  }
+
   // Reach here when generator is closed.
   __ bind(&closed_state);
   if (resume_mode == JSGeneratorObject::NEXT) {
     // Return completed iterator result when generator is closed.
     __ push(Immediate(isolate()->factory()->undefined_value()));
     // Pop value from top-of-stack slot; box result into result register.
     EmitCreateIteratorResult(true);
+    __ jmp(&done);
   } else {
-    // Throw the provided value.
-    __ push(eax);
-    __ CallRuntime(Runtime::kThrow, 1);
+    __ jmp(&throw_provided_value);
   }
-  __ jmp(&done);
 
   // Throw error if we attempt to operate on a running generator.
   __ bind(&wrong_state);
   __ push(ebx);
   __ CallRuntime(Runtime::kThrowGeneratorStateError, 1);
 
   __ bind(&done);
   context()->Plug(result_register());
 }
 
@@ skipping 2714 matching lines @@
 
   ASSERT_EQ(isolate->builtins()->OsrAfterStackCheck()->entry(),
             Assembler::target_address_at(call_target_address));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32