[Interpreter] Avoid accessing on-heap literal in VisitLiteral.

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 128 matching lines @@
     return type_ == STRING;
   }
 
   bool IsNumber() const {
     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;
+    CHECK_EQ(STRING, type_);
+    return string_;
   }
 
   double AsNumber() const {
     if (type_ == NUMBER || type_ == NUMBER_WITH_DOT)
       return number_;
     if (type_ == SMI)
       return smi_;
     UNREACHABLE();
     return 0;
   }
 
+  Smi* AsSmi() const {
+    CHECK_EQ(SMI, type_);
+    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 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_;
@@ skipping 14 matching lines @@
     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, bool with_dot) {
     if (with_dot) {
       type_ = NUMBER_WITH_DOT;
+      number_ = n;
     } else {
-      type_ = NUMBER;
+      int int_value;
+      if (DoubleToSmiInteger(n, &int_value)) {
+        type_ = SMI;
+        smi_ = int_value;
+      } else {
+        type_ = NUMBER;
+        number_ = n;
+      }
     }
-    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) {
@@ skipping 149 matching lines @@
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_