Allow Symbols in switch and maps

runtime/vm/object_store.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/object_store.h"
 
 #include "vm/exceptions.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 20 matching lines @@
     bigint_class_(Class::null()),
     double_class_(Class::null()),
     double_type_(Type::null()),
     float32x4_type_(Type::null()),
     int32x4_type_(Type::null()),
     float64x2_type_(Type::null()),
     string_type_(Type::null()),
     future_class_(Class::null()),
     completer_class_(Class::null()),
     stream_iterator_class_(Class::null()),
+    symbol_class_(Class::null()),
     one_byte_string_class_(Class::null()),
     two_byte_string_class_(Class::null()),
     external_one_byte_string_class_(Class::null()),
     external_two_byte_string_class_(Class::null()),
     bool_type_(Type::null()),
     bool_class_(Class::null()),
     array_class_(Class::null()),
     array_type_(Type::null()),
     immutable_array_class_(Class::null()),
     growable_object_array_class_(Class::null()),
@@ skipping 112 matching lines @@
       Stacktrace::Handle(Stacktrace::New(code_array, pc_offset_array));
   // Expansion of inlined functions requires additional memory at run time,
   // avoid it.
   stack_trace.set_expand_inlined(false);
   set_preallocated_stack_trace(stack_trace);
 
   return true;
 }
 
 
-void ObjectStore::InitAsyncObjects() {
+void ObjectStore::InitKnownObjects() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL && isolate->object_store() == this);
 
   const Library& async_lib = Library::Handle(async_library());
   ASSERT(!async_lib.IsNull());
   Class& cls = Class::Handle(isolate);
   cls = async_lib.LookupClass(Symbols::Future());
   ASSERT(!cls.IsNull());
   set_future_class(cls);
   cls = async_lib.LookupClass(Symbols::Completer());
   ASSERT(!cls.IsNull());
   set_completer_class(cls);
   cls = async_lib.LookupClass(Symbols::StreamIterator());
   ASSERT(!cls.IsNull());
   set_stream_iterator_class(cls);
+
+  const Library& internal_lib = Library::Handle(internal_library());
+  cls = internal_lib.LookupClass(Symbols::Symbol());
+  set_symbol_class(cls);

[regis, 2014/12/09 21:58:55]

There are many other "known objects" that are looked up and stored in the object
store, e.g. class ClassID. Is class Symbol special?

Doing it here is fine with me, but why not handle all such objects in the same
location?

[hausner, 2014/12/10 00:23:27]

The only reason I'm aware of to do it here is that the objects initialized here
are not allocated programmatically by the VM, since they don't have a
corresponding C++ class. I introduced this for objects from the async library,
but now there's also class Symbol from the internal core library.

We could change this code so the objects are allocated on demand only when the
VM accesses them. I would do this as a separate change.

 }
 
 }  // namespace dart