Parse harmony let declarations.

src/parser.cc

 // Copyright 2011 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 1075 matching lines @@
   }
 
   Isolate* isolate_;
   bool only_simple_this_property_assignments_;
   ZoneStringList* names_;
   ZoneList<int>* assigned_arguments_;
   ZoneObjectList* assigned_constants_;
 };
 
 
+Statement* Parser::ParseSourceElement(ZoneStringList* labels,
+                                      bool* ok) {
+  if (peek() == Token::FUNCTION) {
+    // FunctionDeclaration is only allowed in the context of SourceElements
+    // (Ecma 262 5th Edition, clause 14):
+    // SourceElement:
+    //    Statement
+    //    FunctionDeclaration
+    // Common language extension is to allow function declaration in place
+    // of any statement. This language extension is disabled in strict mode.
+    return ParseFunctionDeclaration(ok);
+  } else if (peek() == Token::LET && harmony_block_scoping_) {
+    return ParseVariableStatement(true, ok);

[Lasse Reichstein, 2011/08/12 08:08:33]

Please use an enum with meaningful names for the first argument. Generally try
to avoid passing booleans as true/false (or other magical constants).

[Steven, 2011/08/16 09:05:32]

Done. See the VariableDeclarationContext enum. Also removed the accept_IN from
ParseVariableDeclarations.

On 2011/08/12 08:08:33, Lasse Reichstein wrote:

+  } else {
+    return ParseStatement(labels, ok);
+  }
+}
+
+
 void* Parser::ParseSourceElements(ZoneList<Statement*>* processor,
                                   int end_token,
                                   bool* ok) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
   // Allocate a target stack to use for this set of source
   // elements. This way, all scripts and functions get their own
   // target stack thus avoiding illegal breaks and continues across
   // functions.
   TargetScope scope(&this->target_stack_);
 
   ASSERT(processor != NULL);
   InitializationBlockFinder block_finder(top_scope_, target_stack_);
   ThisNamedPropertyAssigmentFinder this_property_assignment_finder(isolate());
   bool directive_prologue = true;     // Parsing directive prologue.
 
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
 
     Scanner::Location token_loc = scanner().peek_location();
-
-    Statement* stat;
-    if (peek() == Token::FUNCTION) {
-      // FunctionDeclaration is only allowed in the context of SourceElements
-      // (Ecma 262 5th Edition, clause 14):
-      // SourceElement:
-      //    Statement
-      //    FunctionDeclaration
-      // Common language extension is to allow function declaration in place
-      // of any statement. This language extension is disabled in strict mode.
-      stat = ParseFunctionDeclaration(CHECK_OK);
-    } else {
-      stat = ParseStatement(NULL, CHECK_OK);
-    }
-
+    Statement* stat = ParseSourceElement(NULL, CHECK_OK);
     if (stat == NULL || stat->IsEmpty()) {
       directive_prologue = false;   // End of directive prologue.
       continue;
     }
 
     if (directive_prologue) {
       // A shot at a directive.
       ExpressionStatement *e_stat;
       Literal *literal;
       // Still processing directive prologue?
@@ skipping 67 matching lines @@
 
   // Keep the source position of the statement
   int statement_pos = scanner().peek_location().beg_pos;
   Statement* stmt = NULL;
   switch (peek()) {
     case Token::LBRACE:
       return ParseBlock(labels, ok);
 
     case Token::CONST:  // fall through
     case Token::VAR:
-      stmt = ParseVariableStatement(ok);
+      stmt = ParseVariableStatement(false, ok);
       break;
 
     case Token::SEMICOLON:
       Next();
       return EmptyStatement();
 
     case Token::IF:
       stmt = ParseIfStatement(labels, ok);
       break;
 
@@ skipping 86 matching lines @@
   // is always the function scope.
 
   // If a function 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
   // to the corresponding activation frame at runtime if necessary.
   // For instance declarations inside an eval scope need to be added
   // to the calling function context.
   // Similarly, strict mode eval scope does not leak variable declarations to
   // the caller's scope so we declare all locals, too.
-  Scope* declaration_scope = top_scope_->DeclarationScope();
+
+  Scope* declaration_scope = mode == Variable::LET ? top_scope_
+      : top_scope_->DeclarationScope();
   if (declaration_scope->is_function_scope() ||
-      declaration_scope->is_strict_mode_eval_scope()) {
+      declaration_scope->is_strict_mode_eval_scope() ||
+      declaration_scope->is_block_scope()) {
     // Declare the variable in the function scope.
     var = declaration_scope->LocalLookup(name);
     if (var == NULL) {
       // Declare the name.
       var = declaration_scope->DeclareLocal(name, mode);
     } else {
-      // The name was declared before; check for conflicting
-      // re-declarations. If the previous declaration was a const or the
-      // current declaration is a const then we have a conflict. There is
-      // similar code in runtime.cc in the Declare functions.
-      if ((mode == Variable::CONST) || (var->mode() == Variable::CONST)) {
-        // We only have vars and consts in declarations.
+      // The name was declared before; check for conflicting re-declarations.
+      // We have a conflict if either of the declarations is not a var. There
+      // is similar code in runtime.cc in the Declare functions.
+      if ((mode != Variable::VAR) || (var->mode() != Variable::VAR)) {
+        // We only have vars, consts and lets in declarations.
         ASSERT(var->mode() == Variable::VAR ||
-               var->mode() == Variable::CONST);
-        const char* type = (var->mode() == Variable::VAR) ? "var" : "const";
+               var->mode() == Variable::CONST ||
+               var->mode() == Variable::LET);
+        const char* type = (var->mode() == Variable::VAR) ? "var" :
+                           (var->mode() == Variable::CONST) ? "const" : "let";
         Handle<String> type_string =
             isolate()->factory()->NewStringFromUtf8(CStrVector(type), TENURED);
         Expression* expression =
             NewThrowTypeError(isolate()->factory()->redeclaration_symbol(),
                               type_string, name);
         declaration_scope->SetIllegalRedeclaration(expression);
       }
     }
   }
 
@@ skipping 122 matching lines @@
   Handle<String> name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   FunctionLiteral* fun = ParseFunctionLiteral(name,
                                               is_strict_reserved,
                                               function_token_position,
                                               FunctionLiteral::DECLARATION,
                                               CHECK_OK);
   // Even if we're not at the top-level of the global or a function
   // scope, we treat is as such and introduce the function with it's
   // initial value upon entering the corresponding scope.
-  Declare(name, Variable::VAR, fun, true, CHECK_OK);
+  Variable::Mode mode = harmony_block_scoping_ ? Variable::LET : Variable::VAR;
+  Declare(name, mode, fun, true, CHECK_OK);
   return EmptyStatement();
 }
 
 
 Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) {
   if (harmony_block_scoping_) return ParseScopedBlock(labels, ok);
 
   // Block ::
   //   '{' Statement* '}'
 
@@ skipping 16 matching lines @@
   return result;
 }
 
 
 Block* Parser::ParseScopedBlock(ZoneStringList* labels, bool* ok) {
   // Construct block expecting 16 statements.
   Block* body = new(zone()) Block(isolate(), labels, 16, false);
   Scope* saved_scope = top_scope_;
   Scope* block_scope = NewScope(top_scope_,
                                 Scope::BLOCK_SCOPE,
                                 inside_with());

[Lasse Reichstein, 2011/08/12 08:08:33]

What baseline is this patch based on? I don't see any block-scope in the current
code?

[Steven, 2011/08/16 09:05:32]

It is based on a CL that was still in review. It's committed now.
On 2011/08/12 08:08:33, Lasse Reichstein wrote:

   body->set_block_scope(block_scope);
   block_scope->DeclareLocal(isolate()->factory()->block_scope_symbol(),
                             Variable::VAR);
   if (top_scope_->is_strict_mode()) {
     block_scope->EnableStrictMode();
   }
   top_scope_ = block_scope;
 
   // Parse the statements and collect escaping labels.
   TargetCollector collector;
   Target target(&this->target_stack_, &collector);
   Expect(Token::LBRACE, CHECK_OK);
   {
     Target target_body(&this->target_stack_, body);
     InitializationBlockFinder block_finder(top_scope_, target_stack_);
 
     while (peek() != Token::RBRACE) {
-      Statement* stat = ParseStatement(NULL, CHECK_OK);
+      Statement* stat = ParseSourceElement(NULL, CHECK_OK);

[Lasse Reichstein, 2011/08/12 08:08:33]

Will this enable function declarations inside blocks in strict mode? It's
allowed as a SourceElement but not as a Statement.

[Steven, 2011/08/16 09:05:32]

The proposal allows local function declarations inside blocks, but they
shouldn't be allowed in a statement context that is not a source element
context. This function is not used in ES5 normal or strict mode.
On 2011/08/12 08:08:33, Lasse Reichstein wrote:

       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat);
         block_finder.Update(stat);
       }
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   // Create exit block.
   Block* exit = new(zone()) Block(isolate(), NULL, 1, false);
   exit->AddStatement(new(zone()) ExitContextStatement());
 
   // Create a try-finally statement.
   TryFinallyStatement* try_finally =
       new(zone()) TryFinallyStatement(body, exit);
   try_finally->set_escaping_targets(collector.targets());
   top_scope_ = saved_scope;
 
   // Create a result block.
   Block* result = new(zone()) Block(isolate(), NULL, 1, false);
   result->AddStatement(try_finally);
   return result;
 }
 
 
-Block* Parser::ParseVariableStatement(bool* ok) {
+Block* Parser::ParseVariableStatement(bool accept_LET, bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   Handle<String> ignore;
-  Block* result = ParseVariableDeclarations(true, &ignore, CHECK_OK);
+  Block* result = ParseVariableDeclarations(accept_LET, true,
+                                            &ignore, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }
 
 
 bool Parser::IsEvalOrArguments(Handle<String> string) {
   return string.is_identical_to(isolate()->factory()->eval_symbol()) ||
       string.is_identical_to(isolate()->factory()->arguments_symbol());
 }
 
 
 // If the variable declaration declares exactly one non-const
 // variable, then *var is set to that variable. In all other cases,
 // *var is untouched; in particular, it is the caller's responsibility
 // to initialize it properly. This mechanism is used for the parsing
 // of 'for-in' loops.
-Block* Parser::ParseVariableDeclarations(bool accept_IN,
+Block* Parser::ParseVariableDeclarations(bool accept_LET,
+                                         bool accept_IN,
                                          Handle<String>* out,
                                          bool* ok) {
   // VariableDeclarations ::
   //   ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[',']
 
   Variable::Mode mode = Variable::VAR;
   bool is_const = false;
   Scope* declaration_scope = top_scope_->DeclarationScope();
   if (peek() == Token::VAR) {
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     Consume(Token::CONST);
     if (declaration_scope->is_strict_mode()) {
       ReportMessage("strict_const", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
     mode = Variable::CONST;
     is_const = true;
+  } else if (peek() == Token::LET) {
+    Consume(Token::LET);
+    if (!accept_LET) {
+      ReportMessage("unprotected_let", Vector<const char*>::empty());
+      *ok = false;
+      return NULL;
+    }
+    mode = Variable::LET;
   } else {
     UNREACHABLE();  // by current callers
   }
 
   // The scope of a variable/const declared anywhere inside a function
   // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). Thus we can
   // transform a source-level variable/const declaration into a (Function)
   // Scope declaration, and rewrite the source-level initialization into an
   // assignment statement. We use a block to collect multiple assignments.
   //
@@ skipping 718 matching lines @@
   //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
 
   Statement* init = NULL;
 
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || peek() == Token::CONST) {
       Handle<String> name;
       Block* variable_statement =
-          ParseVariableDeclarations(false, &name, CHECK_OK);
+          ParseVariableDeclarations(true, false, &name, CHECK_OK);
 
       if (peek() == Token::IN && !name.is_null()) {
         VariableProxy* each = top_scope_->NewUnresolved(name, inside_with());
         ForInStatement* loop = new(zone()) ForInStatement(isolate(), labels);
         Target target(&this->target_stack_, loop);
 
         Expect(Token::IN, CHECK_OK);
         Expression* enumerable = ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
 
@@ skipping 626 matching lines @@
                            Vector<const char*>::empty());
     case Token::STRING:
       return ReportMessage("unexpected_token_string",
                            Vector<const char*>::empty());
     case Token::IDENTIFIER:
       return ReportMessage("unexpected_token_identifier",
                            Vector<const char*>::empty());
     case Token::FUTURE_RESERVED_WORD:
       return ReportMessage("unexpected_reserved",
                            Vector<const char*>::empty());
+    case Token::LET:
+      if (harmony_block_scoping_) {
+        const char* name = Token::String(token);
+        ASSERT(name != NULL);
+        return ReportMessage("unexpected_token",
+                             Vector<const char*>(&name, 1));
+      }
+      // FALLTHROUGH
     case Token::FUTURE_STRICT_RESERVED_WORD:
       return ReportMessage(top_scope_->is_strict_mode() ?
                                "unexpected_strict_reserved" :
                                "unexpected_token_identifier",
                            Vector<const char*>::empty());
     default:
       const char* name = Token::String(token);
       ASSERT(name != NULL);
       ReportMessage("unexpected_token", Vector<const char*>(&name, 1));
   }
@@ skipping 42 matching lines @@
       result = new(zone()) Literal(
           isolate(), isolate()->factory()->true_value());
       break;
 
     case Token::FALSE_LITERAL:
       Consume(Token::FALSE_LITERAL);
       result = new(zone()) Literal(
           isolate(), isolate()->factory()->false_value());
       break;
 
+    case Token::LET:
+      if (harmony_block_scoping_) {
+        Token::Value tok = Next();
+        ReportUnexpectedToken(tok);
+        *ok = false;
+        return NULL;
+      }
+      // FALLTHROUGH
     case Token::IDENTIFIER:
     case Token::FUTURE_STRICT_RESERVED_WORD: {
       Handle<String> name = ParseIdentifier(CHECK_OK);
       if (fni_ != NULL) fni_->PushVariableName(name);
       result = top_scope_->NewUnresolved(name,
                                          inside_with(),
                                          scanner().location().beg_pos);
       break;
     }
 
@@ skipping 444 matching lines @@
 
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
 
     Literal* key = NULL;
     Token::Value next = peek();
 
     // Location of the property name token
     Scanner::Location loc = scanner().peek_location();
 
+    if (harmony_block_scoping_ && next == Token::LET) {
+      // Go into FUTURE_STRICT_RESERVED_WORD case where
+      // ParseIdentifierNameOrGetOrSet will handle the LET
+      // token like a FUTURE_STRICT_RESERVED_WORD.
+      next = Token::FUTURE_STRICT_RESERVED_WORD;

[Lasse Reichstein, 2011/08/12 08:08:33]

Why not just add a case for Token::LET next to
Token::FUTURE_STRICT_RESERVED_WORD?
Or not bother, and let it be handled like a keyword? 
Both should work.

[Steven, 2011/08/16 09:05:32]

Now obsolete, since the scanner now produces the correct token based on a flag.
On 2011/08/12 08:08:33, Lasse Reichstein wrote:

+    }
     switch (next) {
       case Token::FUTURE_RESERVED_WORD:
       case Token::FUTURE_STRICT_RESERVED_WORD:
       case Token::IDENTIFIER: {
         bool is_getter = false;
         bool is_setter = false;
         Handle<String> id =
             ParseIdentifierNameOrGetOrSet(&is_getter, &is_setter, CHECK_OK);
         if (fni_ != NULL) fni_->PushLiteralName(id);
 
@@ skipping 167 matching lines @@
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name.is_null();
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = isolate()->factory()->empty_symbol();
   }
 
   int num_parameters = 0;
   // Function declarations are hoisted.
-  Scope* scope = (type == FunctionLiteral::DECLARATION)
+  Scope* scope = (type == FunctionLiteral::DECLARATION &&
+                  !harmony_block_scoping_)

[Lasse Reichstein, 2011/08/12 08:08:33]

If harmony_block_scoping_ is set, function declarations are not hoisted?

[Steven, 2011/08/16 09:05:32]

Yes, function declarations are then also expected to be block scoped.
On 2011/08/12 08:08:33, Lasse Reichstein wrote:

       ? NewScope(top_scope_->DeclarationScope(), Scope::FUNCTION_SCOPE, false)
       : NewScope(top_scope_, Scope::FUNCTION_SCOPE, inside_with());
   ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8);
   int materialized_literal_count;
   int expected_property_count;
   int start_pos;
   int end_pos;
   bool only_simple_this_property_assignments;
   Handle<FixedArray> this_property_assignments;
   bool has_duplicate_parameters = false;
@@ skipping 219 matching lines @@
 
   // We have a valid intrinsics call or a call to a builtin.
   return new(zone()) CallRuntime(isolate(), name, function, args);
 }
 
 
 bool Parser::peek_any_identifier() {
   Token::Value next = peek();
   return next == Token::IDENTIFIER ||
          next == Token::FUTURE_RESERVED_WORD ||
-         next == Token::FUTURE_STRICT_RESERVED_WORD;
+         next == Token::FUTURE_STRICT_RESERVED_WORD ||
+         (next == Token::LET && !harmony_block_scoping_);
 }
 
 
 void Parser::Consume(Token::Value token) {
   Token::Value next = Next();
   USE(next);
   USE(token);
   ASSERT(next == token);
 }
 
@@ skipping 41 matching lines @@
 Literal* Parser::GetLiteralTheHole() {
   return NewLiteral(isolate()->factory()->the_hole_value());
 }
 
 
 Literal* Parser::GetLiteralNumber(double value) {
   return NewNumberLiteral(value);
 }
 
 
 // Parses and identifier that is valid for the current scope, in particular it

[Lasse Reichstein, 2011/08/12 08:08:33]

"and"->"an" while you are here :)

[Steven, 2011/08/16 09:05:32]

Done.

 // fails on strict mode future reserved keywords in a strict scope.
 Handle<String> Parser::ParseIdentifier(bool* ok) {
   if (top_scope_->is_strict_mode()) {
     Expect(Token::IDENTIFIER, ok);
   } else if (!Check(Token::IDENTIFIER)) {
-    Expect(Token::FUTURE_STRICT_RESERVED_WORD, ok);
+    if (harmony_block_scoping_) {
+      Expect(Token::FUTURE_STRICT_RESERVED_WORD, ok);
+    } else if (!Check(Token::FUTURE_STRICT_RESERVED_WORD)) {
+      Expect(Token::LET, ok);
+    }
   }
   if (!*ok) return Handle<String>();
   return GetSymbol(ok);
 }
 
 
 // Parses and identifier or a strict mode future reserved word, and indicate
 // whether it is strict mode future reserved.
 Handle<String> Parser::ParseIdentifierOrStrictReservedWord(
     bool* is_strict_reserved, bool* ok) {
   *is_strict_reserved = false;
   if (!Check(Token::IDENTIFIER)) {
-    Expect(Token::FUTURE_STRICT_RESERVED_WORD, ok);
+    if (harmony_block_scoping_) {
+      Expect(Token::FUTURE_STRICT_RESERVED_WORD, ok);
+    } else if (!Check(Token::FUTURE_STRICT_RESERVED_WORD)) {
+      Expect(Token::LET, ok);
+    }
     *is_strict_reserved = true;
   }
   if (!*ok) return Handle<String>();
   return GetSymbol(ok);
 }
 
 
 Handle<String> Parser::ParseIdentifierName(bool* ok) {
   Token::Value next = Next();
   if (next != Token::IDENTIFIER &&
@@ skipping 1147 matching lines @@
       result = parser.ParseProgram(source,
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal