Throw when calling an undefined function

src/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/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 1053 matching lines @@
     scope->set_end_position(scanner()->peek_location().beg_pos);
 
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
     }
     if (ok && is_sloppy(language_mode()) && allow_harmony_sloppy_function()) {
       // TODO(littledan): Function bindings on the global object that modify
       // pre-existing bindings should be made writable, enumerable and
       // nonconfigurable if possible, whereas this code will leave attributes
       // unchanged if the property already exists.
-      InsertSloppyBlockFunctionVarBindings(scope, &ok);
+      InsertSloppyBlockFunctionVarBindings(scope, body, &ok);
     }
     if (ok && (is_strict(language_mode()) || allow_harmony_sloppy())) {
       CheckConflictingVarDeclarations(scope_, &ok);
     }
 
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
@@ skipping 3223 matching lines @@
     const bool allow_duplicate_parameters =
         is_sloppy(language_mode) && formals.is_simple && !IsConciseMethod(kind);
     ValidateFormalParameters(&formals_classifier, language_mode,
                              allow_duplicate_parameters, CHECK_OK);
 
     if (is_strict(language_mode)) {
       CheckStrictOctalLiteral(scope->start_position(), scope->end_position(),
                               CHECK_OK);
     }
     if (is_sloppy(language_mode) && allow_harmony_sloppy_function()) {
-      InsertSloppyBlockFunctionVarBindings(scope, CHECK_OK);
+      InsertSloppyBlockFunctionVarBindings(scope, body, CHECK_OK);
     }
     if (is_strict(language_mode) || allow_harmony_sloppy()) {
       CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
   }
 
   bool has_duplicate_parameters =
       !formals_classifier.is_valid_formal_parameter_list_without_duplicates();
   FunctionLiteral::ParameterFlag duplicate_parameters =
       has_duplicate_parameters ? FunctionLiteral::kHasDuplicateParameters
@@ skipping 667 matching lines @@
     VariableProxy* from = factory()->NewVariableProxy(parameter);
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, to, from, RelocInfo::kNoPosition);
     Statement* statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     inner_block->statements()->InsertAt(0, statement, zone());
   }
 }
 
 
-void Parser::InsertSloppyBlockFunctionVarBindings(Scope* scope, bool* ok) {
+void Parser::InsertSloppyBlockFunctionVarBindings(Scope* scope, ZoneList<Statement*>* body, bool* ok) {
   // For each variable which is used as a function declaration in a sloppy
   // block,
   DCHECK(scope->is_declaration_scope());
   SloppyBlockFunctionMap* map = scope->sloppy_block_function_map();
   for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
     AstRawString* name = static_cast<AstRawString*>(p->key);
     // If the variable wouldn't conflict with a lexical declaration,
     Variable* var = scope->LookupLocal(name);
     if (var == nullptr || !IsLexicalVariableMode(var->mode())) {
       // Declare a var-style binding for the function in the outer scope
       VariableProxy* proxy = scope->NewUnresolved(factory(), name);
       Declaration* declaration = factory()->NewVariableDeclaration(
           proxy, VAR, scope, RelocInfo::kNoPosition);
       Declare(declaration, DeclarationDescriptor::NORMAL, true, ok, scope);
       DCHECK(ok);  // Based on the preceding check, this should not fail
       if (!ok) return;
 
+      // For testing, insert an initializing assignment to the function
+      // setting it to "throwLittleDan".
+      VariableProxy* littledanVariable = scope_->NewUnresolved(
+              factory(), ast_value_factory()->throwLittleDan_string(), Variable::NORMAL,
+              RelocInfo::kNoPosition, RelocInfo::kNoPosition);
+      Assignment* littledanAssignment = factory()->NewAssignment(
+          Token::ASSIGN, proxy, littledanVariable, RelocInfo::kNoPosition);
+      Statement* littledanStatement = factory()->NewExpressionStatement(
+            littledanAssignment, RelocInfo::kNoPosition);
+      body->InsertAt(0, littledanStatement, zone());
+
       // Write in assignments to var for each block-scoped function declaration
       auto delegates = static_cast<SloppyBlockFunctionMap::Vector*>(p->value);
       for (SloppyBlockFunctionStatement* delegate : *delegates) {
         // Read from the local lexical scope and write to the function scope
         VariableProxy* to = scope->NewUnresolved(factory(), name);
         VariableProxy* from = delegate->scope()->NewUnresolved(factory(), name);
         Expression* assignment = factory()->NewAssignment(
             Token::ASSIGN, to, from, RelocInfo::kNoPosition);
         Statement* statement = factory()->NewExpressionStatement(
             assignment, RelocInfo::kNoPosition);
@@ skipping 1308 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
 }
 }  // namespace internal
 }  // namespace v8