Add Double::NewCanonical and Mint::NewCanonical so that it is possible to

vm/object.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 552 matching lines @@
   RawFunction* LookupConstructor(const String& name) const;
   RawFunction* LookupFactory(const String& name) const;
   RawFunction* LookupFunction(const String& name) const;
 
   RawField* LookupInstanceField(const String& name) const;
   RawField* LookupStaticField(const String& name) const;
   RawField* LookupField(const String& name) const;
 
   RawLibraryPrefix* LookupLibraryPrefix(const String& name) const;
 
+  void InsertCanonicalConstant(intptr_t index, const Instance& constant) const;
+
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClass));
   }
 
   bool is_interface() const {
     return raw_ptr()->is_interface_;
   }
   void set_is_interface() const;
 
   bool is_finalized() const {
@@ skipping 18 matching lines @@
   }
   static intptr_t num_native_fields_offset() {
     return OFFSET_OF(RawClass, num_native_fields_);
   }
 
   RawCode* allocation_stub() const {
     return raw_ptr()->allocation_stub_;
   }
   void set_allocation_stub(const Code& value) const;
 
+  RawArray* constants() const;
+
   void Finalize() const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
   // Allocate an instance class which has a VM implementation.
   template <class FakeInstance> static RawClass* New(const String& name,
                                                      const Script& script);
 
   // Allocate instance classes and interfaces.
@@ skipping 19 matching lines @@
   static RawClass* GetClass(ObjectKind kind);
 
  private:
   void set_name(const String& value) const;
   void set_script(const Script& value) const;
   void set_signature_function(const Function& value) const;
   void set_signature_type(const AbstractType& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
-  RawArray* constants() const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   void CalculateFieldOffsets() const;
 
   // Check the subtype or assignability relationship.
   bool TestType(TypeTestKind test,
                 const AbstractTypeArguments& type_arguments,
                 const Class& other,
@@ skipping 1687 matching lines @@
   }
 
   virtual bool Equals(const Instance& other) const;
 
   virtual double AsDoubleValue() const;
   virtual int64_t AsInt64Value() const;
 
   virtual int CompareWith(const Integer& other) const;
 
   static RawMint* New(int64_t value, Heap::Space space = Heap::kNew);
+  static RawMint* NewCanonical(int64_t value);
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawMint));
   }
 
  private:
   void set_value(int64_t value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Mint, Integer);
   friend class Class;
@@ skipping 58 matching lines @@
   friend class BigintOperations;
 };
 
 
 class Double : public Number {
  public:
   double value() const {
     return raw_ptr()->value_;
   }
 
+  bool EqualsToDouble(double value) const;
+  virtual bool Equals(const Instance& other) const;
+
   static RawDouble* New(double d, Heap::Space space = Heap::kNew);
 
   static RawDouble* New(const String& str, Heap::Space space = Heap::kNew);
 
+  // Returns a canonical double object allocated in the old gen space.
+  static RawDouble* NewCanonical(double d);
+
+  // Returns a canonical double object (allocated in the old gen space) or
+  // Double::null() if str points to a string that does not convert to a
+  // double value.
+  static RawDouble* NewCanonical(const String& str);
+
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawDouble));
   }
 
   static intptr_t value_offset() { return OFFSET_OF(RawDouble, value_); }
 
  private:
   void set_value(double value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Double, Number);
@@ skipping 839 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_