Implement new Function.prototype.toString and fix CreateDynamicFunction parsing

src/parsing/parser.cc

 // Copyright 2012 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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 568 matching lines @@
                          true),
       scanner_(info->unicode_cache()),
       reusable_preparser_(nullptr),
       original_scope_(nullptr),
       mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
       target_stack_(nullptr),
       compile_options_(info->compile_options()),
       cached_parse_data_(nullptr),
       total_preparse_skipped_(0),
       temp_zoned_(false),
-      log_(nullptr) {
+      log_(nullptr),
+      parameters_end_pos_(info->parameters_end_pos()) {
   // Even though we were passed ParseInfo, we should not store it in
   // Parser - this makes sure that Isolate is not accidentally accessed via
   // ParseInfo during background parsing.
   DCHECK(!info->script().is_null() || info->source_stream() != nullptr ||
          info->character_stream() != nullptr);
   // Determine if functions can be lazily compiled. This is necessary to
   // allow some of our builtin JS files to be lazily compiled. These
   // builtins cannot be handled lazily by the parser, since we have to know
   // if a function uses the special natives syntax, which is something the
   // parser records.
@@ skipping 2559 matching lines @@
     int* expected_property_count, bool* ok) {
   ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
 
   FunctionState function_state(&function_state_, &scope_state_, function_scope);
 
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   ExpressionClassifier formals_classifier(this, &duplicate_finder);
 
   if (IsGeneratorFunction(kind)) PrepareGeneratorVariables(&function_state);
 
+  int expected_parameters_end_pos = parameters_end_pos_;
+  if (expected_parameters_end_pos != kNoSourcePosition) {
+    // This is the first function encountered in an only-single-function eval.

[Dan Ehrenberg, 2016/12/06 00:32:13]

I thought this happens only in the Function constructor

[jwolfe, 2017/01/13 00:28:48]

Updated comment to be more clear.

+    parameters_end_pos_ = kNoSourcePosition;
+    // The function name should have been ignored, giving us null here.
+    DCHECK_NULL(function_name);
+  }
+
   ParserFormalParameters formals(function_scope);
   ParseFormalParameterList(&formals, CHECK_OK);
+  if (expected_parameters_end_pos != kNoSourcePosition) {
+    // Check for '(' or ')' shenanigans in the parameter string for dynamic
+    // functions.
+    if (peek_position() != expected_parameters_end_pos) {
+      ReportMessageAt(Scanner::Location(expected_parameters_end_pos,
+                                        expected_parameters_end_pos + 1),
+                      MessageTemplate::kExpectedEndOfParameters);

[Dan Ehrenberg, 2016/12/06 00:32:13]

Will CreateDynamicFunction always trigger eager compilation? If the function
constructor sometimes does lazy compilation, then this logic should be
implemented in the preparser as well. Otherwise, could we add a DCHECK in
Parser::SkipFunction to ensure that parameters_end_pos_ == kNoSourcePosition to
double-check that this never occurs?

[jwolfe, 2017/01/13 00:28:47]

Done. It looks like it's always eagerly parsed. I have a little difficulty
tracing the eager vs lazy logic, but it looked to me like it was going to be
always eager. I added the DCHECK also, and it didn't trigger anywhere in
bot_default+test262 (I made it a CHECK for that test).

+      *ok = false;
+      return nullptr;
+    }
+  }
   Expect(Token::RPAREN, CHECK_OK);
   int formals_end_position = scanner()->location().end_pos;
   *num_parameters = formals.num_parameters();
   *function_length = formals.function_length;
 
   CheckArityRestrictions(formals.arity, kind, formals.has_rest,
                          function_scope->start_position(), formals_end_position,
                          CHECK_OK);
   Expect(Token::LBRACE, CHECK_OK);
 
@@ skipping 2296 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8