GeneratorFunction() makes generator instances

src/v8natives.js

 // 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 1738 matching lines @@
   // which are non-configurable. It therefore makes no sence to
   // try to redefine these as defined by the spec. The spec says
   // that bind should make these throw a TypeError if get or set
   // is called and make them non-enumerable and non-configurable.
   // To be consistent with our normal functions we leave this as it is.
   // TODO(lrn): Do set these to be thrower.
   return result;
 }
 
 
-function NewFunction(arg1) {  // length == 1
-  var n = %_ArgumentsLength();
-  var p = '';
-  if (n > 1) {
-    p = new InternalArray(n - 1);
-    for (var i = 0; i < n - 1; i++) p[i] = %_Arguments(i);
-    p = Join(p, n - 1, ',', NonStringToString);
+// InternalArray, string, boolean -> Function
+function NewFunction(formals, body, is_generator) {
+  var formals_string = '';
+  if (formals.length > 0) {
+    formals_string = Join(formals, formals.length, ',', NonStringToString);
     // If the formal parameters string include ) - an illegal
     // character - it may make the combined function expression
     // compile. We avoid this problem by checking for this early on.
-    if (p.indexOf(')') != -1) throw MakeSyntaxError('paren_in_arg_string',[]);
+    if (formals_string.indexOf(')') != -1)
+      throw MakeSyntaxError('paren_in_arg_string', []);
     // If the formal parameters include an unbalanced block comment, the
     // function must be rejected. Since JavaScript does not allow nested
     // comments we can include a trailing block comment to catch this.
-    p += '\n/' + '**/';
+    formals_string += '\n/' + '**/';
   }
-  var body = (n > 0) ? ToString(%_Arguments(n - 1)) : '';
-  var source = '(function(' + p + ') {\n' + body + '\n})';
+  var head = is_generator ? '(function*(' : '(function(';
+  var source = head + formals_string + ') {\n' + body + '\n})';
 
   var global_receiver = %GlobalReceiver(global);
   var f = %_CallFunction(global_receiver, %CompileString(source, true));
 
   %FunctionMarkNameShouldPrintAsAnonymous(f);
   return f;
 }
 
 
+function FunctionConstructor(arg1) {  // length == 1
+  var n = %_ArgumentsLength();
+  if (n > 0) {

[Michael Starzinger, 2013/05/14 13:51:31]

We should try to have a fast-path for the case where exactly one argument it
passed. Because that is often used as a replacement of eval() in
performance-critical settings and I would like to keep that fast-path without
any allocation of an InternalArray as before. On the other hand I didn't measure
the impact of this change, so if the impact is negligible, then feel free to
ignore my comment.

+    var formals = new InternalArray(n - 1);
+    for (var i = 0; i < n - 1; i++) formals[i] = %_Arguments(i);
+    return NewFunction(formals, ToString(%_Arguments(n - 1)), false);
+  } else {
+    return NewFunction(new InternalArray(0), '', false);
+  }
+}
+
+
 // ----------------------------------------------------------------------------
 
 function SetUpFunction() {
   %CheckIsBootstrapping();
 
-  %SetCode($Function, NewFunction);
+  %SetCode($Function, FunctionConstructor);
   %SetProperty($Function.prototype, "constructor", $Function, DONT_ENUM);
 
   InstallFunctions($Function.prototype, DONT_ENUM, $Array(
     "bind", FunctionBind,
     "toString", FunctionToString
   ));
 }
 
 SetUpFunction();