[es6] Sloppy functions in block

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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 1975 matching lines @@
   // Let/const variables in harmony mode are always added to the immediately
   // enclosing scope.
   return DeclarationScope(mode)->NewUnresolved(
       factory(), name, Variable::NORMAL, scanner()->location().beg_pos,
       scanner()->location().end_pos);
 }
 
 
 Variable* Parser::Declare(Declaration* declaration,
                           DeclarationDescriptor::Kind declaration_kind,
-                          bool resolve, bool* ok) {
+                          bool report_error, bool* ok) {

[arv (Not doing code reviews), 2015/07/10 16:56:33]

Turned out that all callers always passed resolve as true so changing this to
report_error required no changes for the callers =D

   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
   VariableMode mode = declaration->mode();
   Scope* declaration_scope = DeclarationScope(mode);
   Variable* var = NULL;
 
   // If a suitable scope exists, then we can statically declare this
   // variable and also set its mode. In any case, a Declaration node
   // will be added to the scope so that the declaration can be added
@@ skipping 38 matching lines @@
       // the special case
       //
       // function () { let x; { var x; } }
       //
       // because the var declaration is hoisted to the function scope where 'x'
       // is already bound.
       DCHECK(IsDeclaredVariableMode(var->mode()));
       if (is_strict(language_mode()) || allow_harmony_sloppy()) {
         // In harmony we treat re-declarations as early errors. See
         // ES5 16 for a definition of early errors.
-        if (declaration_kind == DeclarationDescriptor::NORMAL) {
-          ParserTraits::ReportMessage(MessageTemplate::kVarRedeclaration, name);
-        } else {
-          ParserTraits::ReportMessage(MessageTemplate::kStrictParamDupe);
+        if (report_error) {
+          if (declaration_kind == DeclarationDescriptor::NORMAL) {
+            ParserTraits::ReportMessage(MessageTemplate::kVarRedeclaration,
+                                        name);
+          } else {
+            ParserTraits::ReportMessage(MessageTemplate::kStrictParamDupe);
+          }
         }
         *ok = false;
         return nullptr;
       }
       Expression* expression = NewThrowSyntaxError(
           MessageTemplate::kVarRedeclaration, name, declaration->position());
       declaration_scope->SetIllegalRedeclaration(expression);
     } else if (mode == VAR) {
       var->set_maybe_assigned();
     }
@@ skipping 12 matching lines @@
   //
   // WARNING: This will lead to multiple declaration nodes for the
   // same variable if it is declared several times. This is not a
   // semantic issue as long as we keep the source order, but it may be
   // a performance issue since it may lead to repeated
   // RuntimeHidden_DeclareLookupSlot calls.
   declaration_scope->AddDeclaration(declaration);
 
   if (mode == CONST_LEGACY && declaration_scope->is_script_scope()) {
     // For global const variables we bind the proxy to a variable.
-    DCHECK(resolve);  // should be set by all callers
     Variable::Kind kind = Variable::NORMAL;
     var = new (zone()) Variable(declaration_scope, name, mode, kind,
                                 kNeedsInitialization, kNotAssigned);
   } else if (declaration_scope->is_eval_scope() &&
              is_sloppy(declaration_scope->language_mode())) {
     // For variable declarations in a sloppy eval scope the proxy is bound
     // to a lookup variable to force a dynamic declaration using the
     // DeclareLookupSlot runtime function.
     Variable::Kind kind = Variable::NORMAL;
     // TODO(sigurds) figure out if kNotAssigned is OK here
     var = new (zone()) Variable(declaration_scope, name, mode, kind,
                                 declaration->initialization(), kNotAssigned);
     var->AllocateTo(VariableLocation::LOOKUP, -1);
-    resolve = true;
   }
 
   // If requested and we have a local variable, bind the proxy to the variable
   // at parse-time. This is used for functions (and consts) declared inside
   // statements: the corresponding function (or const) variable must be in the
   // function scope and not a statement-local scope, e.g. as provided with a
   // 'with' statement:
   //
   //   with (obj) {
   //     function f() {}
   //   }
   //
   // which is translated into:
   //
   //   with (obj) {
   //     // in this case this is not: 'var f; f = function () {};'
   //     var f = function () {};
   //   }
   //
   // Note that if 'f' is accessed from inside the 'with' statement, it
   // will be allocated in the context (because we must be able to look
   // it up dynamically) but it will also be accessed statically, i.e.,
   // with a context slot index and a context chain length for this
   // initialization code. Thus, inside the 'with' statement, we need
   // both access to the static and the dynamic context chain; the
   // runtime needs to provide both.
-  if (resolve && var != NULL) {
+  if (var != NULL) {
     proxy->BindTo(var);
   }
   return var;
 }
 
 
 // Language extension which is only enabled for source files loaded
 // through the API's extension mechanism.  A native function
 // declaration is resolved by looking up the function through a
 // callback provided by the extension.
@@ skipping 67 matching lines @@
           : (is_strict(language_mode()) || allow_harmony_sloppy()) &&
                     !(scope_->is_script_scope() || scope_->is_eval_scope() ||
                       scope_->is_function_scope())
                 ? LET
                 : VAR;
   VariableProxy* proxy = NewUnresolved(name, mode);
   Declaration* declaration =
       factory()->NewFunctionDeclaration(proxy, mode, fun, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   if (names) names->Add(name, zone());
+
+  // For sloppy function in block we also add a var binding that gets assigned
+  // to at the location of the FunctionDeclaration -- but only if introducing
+  // this var binding does not lead to an early error.
+  if (is_sloppy(language_mode()) && scope_->is_block_scope() &&
+      allow_harmony_sloppy()) {
+    VariableProxy* var_proxy = NewUnresolved(name, VAR);
+    Declaration* declaration =
+        factory()->NewVariableDeclaration(var_proxy, VAR, scope_, pos);
+    bool var_ok = true;
+    const bool report_error = false;
+    Declare(declaration, DeclarationDescriptor::NORMAL, report_error, &var_ok);
+    if (!var_ok) {
+      scope_->RemoveUnresolved(var_proxy);
+    } else {
+      // At the location of the FunctionDeclaration we assign to the var
+      // binding.
+      Assignment* assignment = factory()->NewAssignment(
+          Token::ASSIGN, var_proxy, NewUnresolved(name, mode), pos);
+      return factory()->NewExpressionStatement(assignment,
+                                               RelocInfo::kNoPosition);
+    }
+  }
   return factory()->NewEmptyStatement(RelocInfo::kNoPosition);
 }
 
 
 Statement* Parser::ParseClassDeclaration(ZoneList<const AstRawString*>* names,
                                          bool* ok) {
   // ClassDeclaration ::
   //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
   //
   // A ClassDeclaration
@@ skipping 3714 matching lines @@
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 }  // namespace internal
 }  // namespace v8