[Parser] Track ContainsDot for SMI values.

src/ast/ast-value-factory.h

 // Copyright 2014 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 136 matching lines @@
 
 // AstValue is either a string, a number, a string array, a boolean, or a
 // special value (null, undefined, the hole).
 class AstValue : public ZoneObject {
  public:
   bool IsString() const {
     return type_ == STRING;
   }
 
   bool IsNumber() const {
-    return type_ == NUMBER || type_ == NUMBER_WITH_DOT || type_ == SMI;
+    return type_ == NUMBER || type_ == NUMBER_WITH_DOT || type_ == SMI ||
+           type_ == SMI_WITH_DOT;
   }
 
-  bool ContainsDot() const { return type_ == NUMBER_WITH_DOT; }
+  bool ContainsDot() const {
+    return type_ == NUMBER_WITH_DOT || type_ == SMI_WITH_DOT;
+  }
 
   const AstRawString* AsString() const {
     CHECK_EQ(STRING, type_);
     return string_;
   }
 
   double AsNumber() const {
     if (type_ == NUMBER || type_ == NUMBER_WITH_DOT)
       return number_;
-    if (type_ == SMI)
+    if (type_ == SMI || type_ == SMI_WITH_DOT)
       return smi_;
     UNREACHABLE();
     return 0;
   }
 
   Smi* AsSmi() const {
-    CHECK_EQ(SMI, type_);
+    CHECK(type_ == SMI || type_ == SMI_WITH_DOT);
     return Smi::FromInt(smi_);
   }
 
   bool EqualsString(const AstRawString* string) const {
     return type_ == STRING && string_ == string;
   }
 
   bool IsPropertyName() const;
 
   bool BooleanValue() const;
 
-  bool IsSmi() const { return type_ == SMI; }
+  bool IsSmi() const { return type_ == SMI || type_ == SMI_WITH_DOT; }
   bool IsFalse() const { return type_ == BOOLEAN && !bool_; }
   bool IsTrue() const { return type_ == BOOLEAN && bool_; }
   bool IsUndefined() const { return type_ == UNDEFINED; }
   bool IsTheHole() const { return type_ == THE_HOLE; }
   bool IsNull() const { return type_ == NULL_TYPE; }
 
   void Internalize(Isolate* isolate);
 
   // Can be called after Internalize has been called.
   V8_INLINE Handle<Object> value() const {
     if (type_ == STRING) {
       return string_->string();
     }
     DCHECK(!value_.is_null());
     return value_;
   }
   AstValue* next() const { return next_; }
   void set_next(AstValue* next) { next_ = next; }
 
  private:
   friend class AstValueFactory;
 
   enum Type {
     STRING,
     SYMBOL,
     NUMBER,
     NUMBER_WITH_DOT,
     SMI,
+    SMI_WITH_DOT,
     BOOLEAN,
     NULL_TYPE,
     UNDEFINED,
     THE_HOLE
   };
 
   explicit AstValue(const AstRawString* s) : type_(STRING), next_(nullptr) {
     string_ = s;
   }
 
   explicit AstValue(const char* name) : type_(SYMBOL), next_(nullptr) {
     symbol_name_ = name;
   }
 
   explicit AstValue(double n, bool with_dot) : next_(nullptr) {
-    if (with_dot) {
-      type_ = NUMBER_WITH_DOT;
+    int int_value;
+    if (DoubleToSmiInteger(n, &int_value)) {
+      type_ = with_dot ? SMI_WITH_DOT : SMI;
+      smi_ = int_value;
+    } else {
+      type_ = with_dot ? NUMBER_WITH_DOT : NUMBER;
       number_ = n;
-    } else {
-      int int_value;
-      if (DoubleToSmiInteger(n, &int_value)) {
-        type_ = SMI;
-        smi_ = int_value;
-      } else {
-        type_ = NUMBER;
-        number_ = n;
-      }
     }
   }
 
   AstValue(Type t, int i) : type_(t), next_(nullptr) {
     DCHECK(type_ == SMI);
     smi_ = i;
   }
 
   explicit AstValue(bool b) : type_(BOOLEAN), next_(nullptr) { bool_ = b; }
 
@@ skipping 179 matching lines @@
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_