Allow numeric literals to be checked for a decimal point.

src/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 124 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_ == SMI;
+    return type_ == NUMBER || type_ == NUMBER_WITH_DOT || type_ == SMI;
   }
 
+  bool ContainsDot() const { return type_ == NUMBER_WITH_DOT; }
+
   const AstRawString* AsString() const {
     if (type_ == STRING)
       return string_;
     UNREACHABLE();
     return 0;
   }
 
   double AsNumber() const {
-    if (type_ == NUMBER)
-      return number_;
+    if (type_ == NUMBER || type_ == NUMBER_WITH_DOT) return number_;
     if (type_ == SMI)
       return smi_;
     UNREACHABLE();
     return 0;
   }
 
   bool EqualsString(const AstRawString* string) const {
     return type_ == STRING && string_ == string;
   }
 
@@ skipping 14 matching lines @@
     return value_;
   }
 
  private:
   friend class AstValueFactory;
 
   enum Type {
     STRING,
     SYMBOL,
     NUMBER,
+    NUMBER_WITH_DOT,
     SMI,
     BOOLEAN,
     NULL_TYPE,
     UNDEFINED,
     THE_HOLE
   };
 
   explicit AstValue(const AstRawString* s) : type_(STRING) { string_ = s; }
 
   explicit AstValue(const char* name) : type_(SYMBOL) { symbol_name_ = name; }
 
   explicit AstValue(double n) : type_(NUMBER) { number_ = n; }
 
   AstValue(Type t, int i) : type_(t) {
     DCHECK(type_ == SMI);
     smi_ = i;
   }
 
   explicit AstValue(bool b) : type_(BOOLEAN) { bool_ = b; }
 
   explicit AstValue(Type t) : type_(t) {
     DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
   }
 
+  void MarkWithDot() {
+    DCHECK(type_ == NUMBER);
+    type_ = NUMBER_WITH_DOT;
+  }
+
   Type type_;
 
   // Uninternalized value.
   union {
     const AstRawString* string_;
     double number_;
     int smi_;
     bool bool_;
     ZoneList<const AstRawString*>* strings_;
     const char* symbol_name_;
@@ skipping 101 matching lines @@
                                 static_cast<int>(strlen(data))));       \
     }                                                                   \
     return name##_string_;                                              \
   }
   STRING_CONSTANTS(F)
 #undef F
 
   const AstValue* NewString(const AstRawString* string);
   // A JavaScript symbol (ECMA-262 edition 6).
   const AstValue* NewSymbol(const char* name);
-  const AstValue* NewNumber(double number);
+  const AstValue* NewNumber(double number, bool with_dot = false);
   const AstValue* NewSmi(int number);
   const AstValue* NewBoolean(bool b);
   const AstValue* NewStringList(ZoneList<const AstRawString*>* strings);
   const AstValue* NewNull();
   const AstValue* NewUndefined();
   const AstValue* NewTheHole();
 
  private:
   AstRawString* GetOneByteStringInternal(Vector<const uint8_t> literal);
   AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
@@ skipping 20 matching lines @@
 #define F(name) AstValue* name##_;
   OTHER_CONSTANTS(F)
 #undef F
 };
 } }  // namespace v8::internal
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_VALUE_FACTORY_H_