Annex B.3.3 semantics

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 "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 951 matching lines @@
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
       CheckDecimalLiteralWithLeadingZero(use_counts_, beg_pos,
                                          scanner()->location().end_pos);
     }
     if (ok && is_sloppy(language_mode())) {
       // 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, false, &ok);
     }
     if (ok) {
       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 3366 matching lines @@
         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);
       CheckDecimalLiteralWithLeadingZero(use_counts_, scope->start_position(),
                                          scope->end_position());
     }
-    if (is_sloppy(language_mode)) {
-      InsertSloppyBlockFunctionVarBindings(scope, CHECK_OK);
-    }
     CheckConflictingVarDeclarations(scope, CHECK_OK);
 
     if (body) {
       // If body can be inspected, rewrite queued destructuring assignments
       ParserTraits::RewriteDestructuringAssignments();
     }
     has_duplicate_parameters =
       !formals_classifier.is_valid_formal_parameter_list_without_duplicates();
   }
 
@@ skipping 428 matching lines @@
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(body, inner_block->statements());
     SetLanguageMode(scope_, inner_scope->language_mode());
     Block* init_block = BuildParameterInitializationBlock(parameters, CHECK_OK);
 
+    if (is_sloppy(inner_scope->language_mode())) {
+      InsertSloppyBlockFunctionVarBindings(inner_scope, true, CHECK_OK);
+    }
+
     if (IsAsyncFunction(kind)) {
       init_block = BuildRejectPromiseOnException(init_block);
     }
 
     DCHECK_NOT_NULL(init_block);
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     inner_scope = inner_scope->FinalizeBlockScope();
     if (inner_scope != nullptr) {
       CheckConflictingVarDeclarations(inner_scope, CHECK_OK);
       InsertShadowingVarBindingInitializers(inner_block);
     }
 
     result->Add(init_block, zone());
     result->Add(inner_block, zone());
+  } else {
+    if (is_sloppy(inner_scope->language_mode())) {
+      InsertSloppyBlockFunctionVarBindings(inner_scope, false, CHECK_OK);
+    }
   }
 
   if (function_type == FunctionLiteral::kNamedExpression) {
     // Now that we know the language mode, we can create the const assignment
     // in the previously reserved spot.
     // NOTE: We create a proxy and resolve it here so that in the
     // future we can change the AST to only refer to VariableProxies
     // instead of Variables and Proxies as is the case now.
     VariableMode fvar_mode = is_strict(language_mode()) ? CONST : CONST_LEGACY;
     Variable* fvar = new (zone())
@@ skipping 266 matching lines @@
     VariableProxy* to = inner_scope->NewUnresolved(factory(), name);
     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,
+                                                  bool outer_is_param_scope,
+                                                  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())) {
+
+    bool var_created = false;
+
+    // Write in assignments to var for each block-scoped function declaration
+    auto delegates = static_cast<SloppyBlockFunctionMap::Vector*>(p->value);
+    for (SloppyBlockFunctionStatement* delegate : *delegates) {
+      // If the variable wouldn't conflict with a lexical declaration
+      // or parameter,
+
+      // Check if there's a conflict with a simple parameter
+      if (scope->IsDeclaredParameter(name)) continue;
+
+      Scope* outer_scope = scope->outer_scope();
+
+      /* Check if there's a conflict with a complex parameter.

[adamk, 2016/06/28 20:55:11]

Style nit: please use '//' style comments for consistency.

[bakkot, 2016/06/29 00:25:02]

Done.

+       * This depends on the fact that functions always create a new scope to

[adamk, 2016/06/28 20:55:11]

This comment seems a bit backwards, and it confused me on first reading. We
create a new scope to hold the declarations in the function body, and the
parameters themselves live in the scope that's left outside. I suppose that
amounts to the same thing, but as I said this was confusing as a reader of this
comment.

The use of the name "param_scope" in "outer_scope_is_param_scope" is further
confusing since "param_scope" is the name given to scopes created when a sloppy
eval is used in a complex parameter.

Please consider rewriting in terms that match the usage elsewhere in this file.

[bakkot, 2016/06/29 00:25:02]

Amended the comment slightly, and now we have a complex_params_scope passed in
instead of that flag.

+       * hold complex parameters, and the names local to that scope are
+       * precisely the names of the parameters. IsDeclaredParameter(name) does

[adamk, 2016/06/28 20:55:10]

Does IsDeclaredParameter ever hold in this case? I don't think it does, because
complex parameters are never named.

[bakkot, 2016/06/29 00:25:02]

You're correct; refactored that out. (I thought it might hold for the simple
parameters in a non-simple parameter list, but it does not.)

+       * not necessarily hold for names declared by complex parameters, nor
+       * are those bindings necessarily declared lexically, so we have to
+       * check for them explicitly. outer_is_param_scope holds iff we are in a
+       * function with complex parameters.
+       */
+      if (outer_is_param_scope && outer_scope->LookupLocal(name) != nullptr) {
+        continue;
+      }
+
+      // Check if there's a conflict with a lexical declaration
+      Scope* query_scope = delegate->scope()->outer_scope();

[adamk, 2016/06/28 20:55:10]

Can't everything above here live outside the delegate loop? It doesn't seem to
depend on the delegate at all.

[bakkot, 2016/06/29 00:25:02]

Done.

+      Variable* var = nullptr;
+      bool should_hoist = true;
+      do {

[adamk, 2016/06/28 20:55:10]

Even this loop seems like it should be hoistable with a little help (we
presumably query the same scopes multiple times...). Maybe add a TODO?

[bakkot, 2016/06/29 00:25:02]

Not exactly, but I added a note.

+        var = query_scope->LookupLocal(name);
+        if (var != nullptr && IsLexicalVariableMode(var->mode())) {
+          should_hoist = false;
+          break;
+        }
+        query_scope = query_scope->outer_scope();
+      } while (query_scope != outer_scope);
+
+      if (!should_hoist) continue;
+
       // 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;
+      if (!var_created) {
+        var_created = true;
+        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;
+      }
 
-      // 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);
-        delegate->set_statement(statement);
-      }
+      // 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);
+      delegate->set_statement(statement);
     }
   }
 }
 
 
 // ----------------------------------------------------------------------------
 // Parser support
 
 bool Parser::TargetStackContainsLabel(const AstRawString* label) {
   for (Target* t = target_stack_; t != NULL; t = t->previous()) {
@@ skipping 1824 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8