Speed up parsing of smis

src/preparser.h

 // 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 1670 matching lines @@
 
 
 template<class Traits>
 void ParserBase<Traits>::ReportUnexpectedToken(Token::Value token) {
   Scanner::Location source_location = scanner()->location();
 
   // Four of the tokens are treated specially
   switch (token) {
     case Token::EOS:
       return ReportMessageAt(source_location, "unexpected_eos");
+    case Token::SMI:
     case Token::NUMBER:
       return ReportMessageAt(source_location, "unexpected_token_number");
     case Token::STRING:
       return ReportMessageAt(source_location, "unexpected_token_string");
     case Token::IDENTIFIER:
       return ReportMessageAt(source_location, "unexpected_token_identifier");
     case Token::FUTURE_RESERVED_WORD:
       return ReportMessageAt(source_location, "unexpected_reserved");
     case Token::LET:
     case Token::STATIC:
@@ skipping 166 matching lines @@
     case Token::THIS: {
       Consume(Token::THIS);
       scope_->RecordThisUsage();
       result = this->ThisExpression(scope_, factory(), beg_pos);
       break;
     }
 
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
+    case Token::SMI:
     case Token::NUMBER:
       Next();
       result =
           this->ExpressionFromLiteral(token, beg_pos, scanner(), factory());
       break;
 
     case Token::IDENTIFIER:
     case Token::LET:
     case Token::STATIC:
     case Token::YIELD:
@@ skipping 161 matching lines @@
   //   identifier -> "identifier"
   //
   // This is important because we use the property name as a key in a hash
   // table when we compute constant properties.
   switch (token) {
     case Token::STRING:
       Consume(Token::STRING);
       *name = this->GetSymbol(scanner());
       break;
 
+    case Token::SMI:
+      Consume(Token::SMI);
+      *name = this->GetNumberAsSymbol(scanner());
+      break;
+
     case Token::NUMBER:
       Consume(Token::NUMBER);
       *name = this->GetNumberAsSymbol(scanner());
       break;
 
     case Token::LBRACK:
       if (allow_harmony_computed_property_names_) {
         *is_computed_name = true;
         Consume(Token::LBRACK);
         ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
@@ skipping 994 matching lines @@
 #undef CHECK_OK_CUSTOM
 
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, bool is_static, bool is_generator,
     bool* ok) {
   DCHECK(!is_static);
   DCHECK(!is_generator || type == kMethodProperty);
 
-  if (property == Token::NUMBER) return;
+  if (property == Token::SMI || property == Token::NUMBER) return;
 
   if (type == kValueProperty && IsProto()) {
     if (has_seen_proto_) {
       this->parser()->ReportMessage("duplicate_proto");
       *ok = false;
       return;
     }
     has_seen_proto_ = true;
     return;
   }
 }
 
 
 template <typename Traits>
 void ParserBase<Traits>::ClassLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, bool is_static, bool is_generator,
     bool* ok) {
   DCHECK(type == kMethodProperty || type == kAccessorProperty);
 
-  if (property == Token::NUMBER) return;
+  if (property == Token::SMI || property == Token::NUMBER) return;
 
   if (is_static) {
     if (IsPrototype()) {
       this->parser()->ReportMessage("static_prototype");
       *ok = false;
       return;
     }
   } else if (IsConstructor()) {
     if (is_generator || type == kAccessorProperty) {
       this->parser()->ReportMessage("constructor_special_method");
       *ok = false;
       return;
     }
     if (has_seen_constructor_) {
       this->parser()->ReportMessage("duplicate_constructor");
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H