Convert all symbols accessor to return read only handles so that it is not necessary to create a ne…

vm/code_generator.cc

 // Copyright (c) 2012, 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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 216 matching lines @@
     ASSERT(type_arguments.IsInstantiated());
     Error& malformed_error = Error::Handle();
     if (!type_arguments.IsWithinBoundsOf(cls,
                                          bounds_instantiator,
                                          &malformed_error)) {
       ASSERT(!malformed_error.IsNull());
       // Throw a dynamic type error.
       const intptr_t location = GetCallerLocation();
       String& malformed_error_message =  String::Handle(
           String::New(malformed_error.ToErrorCString()));
-      const String& no_name = String::Handle(Symbols::Empty());
       Exceptions::CreateAndThrowTypeError(
-          location, no_name, no_name, no_name, malformed_error_message);
+          location, Symbols::Empty(), Symbols::Empty(),
+          Symbols::Empty(), malformed_error_message);
       UNREACHABLE();
     }
   }
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
@@ skipping 331 matching lines @@
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
   }
   if (!result.value() && !malformed_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const intptr_t location = GetCallerLocation();
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
-    const String& no_name = String::Handle(Symbols::Empty());
     Exceptions::CreateAndThrowTypeError(
-        location, no_name, no_name, no_name, malformed_error_message);
+        location, Symbols::Empty(), Symbols::Empty(),
+        Symbols::Empty(), malformed_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(instance, type, instantiator,
                       instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
@@ skipping 96 matching lines @@
   ASSERT(arguments.ArgCount() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolType());
   const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
   const String& src_type_name = String::Handle(src_type.UserVisibleName());
   const String& bool_type_name =
       String::Handle(bool_interface.UserVisibleName());
-  const String& expr = String::Handle(Symbols::New("boolean expression"));
   const String& no_malformed_type_error = String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
-                                      expr, no_malformed_type_error);
+                                      Symbols::BooleanExpression(),
+                                      no_malformed_type_error);
   UNREACHABLE();
 }
 
 
 // Report that the type of the type check is malformed.
 // Arg0: src value.
 // Arg1: name of instance being assigned to.
 // Arg2: malformed type error message.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(MalformedTypeError, 3) {
   ASSERT(arguments.ArgCount() ==
       kMalformedTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(arguments.ArgAt(0));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(1));
   const String& malformed_error = String::CheckedHandle(arguments.ArgAt(2));
-  const String& dst_type_name = String::Handle(Symbols::New("malformed"));
   const AbstractType& src_type = AbstractType::Handle(src_value.GetType());
   const String& src_type_name = String::Handle(src_type.UserVisibleName());
   Exceptions::CreateAndThrowTypeError(location, src_type_name,
-                                      dst_type_name, dst_name, malformed_error);
+                                      Symbols::Malformed(),
+                                      dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   ASSERT(arguments.ArgCount() == kThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   Exceptions::Throw(exception);
 }
 
@@ skipping 1054 matching lines @@
     return;
   }
   HeapTrace* heap_trace = Isolate::Current()->heap()->trace();
   heap_trace->TraceStoreIntoObject(RawObject::ToAddr(object),
                                    field_addr,
                                    RawObject::ToAddr(value));
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart