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

vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 492 matching lines @@
          (function.kind() == RawFunction::kConstImplicitGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsConstructor()) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
-      const String& dst_name = String::ZoneHandle(Symbols::FunctionResult());
       return_value = BuildAssignableValue(node->value()->token_pos(),
                                           return_value,
                                           dst_type,
-                                          dst_name);
+                                          Symbols::FunctionResult());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
@@ skipping 1073 matching lines @@
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
   ReturnDefinition(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
-  if (node->function().name() == Symbols::Identical()) {
+  if (node->function().name() == Symbols::Identical().raw()) {
     // Attempt to replace top level defined 'identical' from the core
     // library with strict equal early on.
     // TODO(hausner): Evaluate if this can happen at AST building time.
     const Class& cls = Class::Handle(node->function().Owner());
     if (cls.IsTopLevel()) {
       const Library& core_lib = Library::Handle(Library::CoreLibrary());
       if (cls.library() == core_lib.raw()) {
         ASSERT(node->arguments()->length() == 2);
         ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
         node->arguments()->NodeAt(0)->Visit(&for_left_value);
@@ skipping 130 matching lines @@
   const Library& lib = Library::Handle(clazz.library());
 
   const String& expected_class_name =
       String::Handle(lib.PrivateName(expected));
   if (!String::Handle(clazz.Name()).Equals(expected_class_name)) {
     return false;
   }
 
   const String& function_name = String::Handle(function.name());
   const String& expected_function_name = String::Handle(
-      String::Concat(expected_class_name, Symbols::DotHandle()));
+      String::Concat(expected_class_name, Symbols::Dot()));
   return function_name.Equals(expected_function_name);
 }
 
 
 static intptr_t GetResultCidOfConstructor(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
 
   if (function_class.library() != core_lib.raw()) {
     return kDynamicCid;
   }
 
   if (node->constructor().IsFactory()) {
-    if ((function_class.Name() == Symbols::List()) &&
-        (function.name() == Symbols::ListFactory())) {
+    if ((function_class.Name() == Symbols::List().raw()) &&
+        (function.name() == Symbols::ListFactory().raw())) {
       // If there are no arguments then the result is guaranteed to be a
       // GrowableObjectArray. However if there is an argument the result
       // is not guaranteed to be a fixed size array because the argument
       // can be null.
       if (node->arguments()->length() == 0) {
         return kGrowableObjectArrayCid;
       }
     } else {
-      if (IsRecognizedConstructor(function,
-                                  String::Handle(Symbols::ObjectArray())) &&
+      if (IsRecognizedConstructor(function, Symbols::ObjectArray()) &&
           (node->arguments()->length() == 1)) {
         return kArrayCid;
       } else if (IsRecognizedConstructor(function,
-                     String::Handle(Symbols::GrowableObjectArray())) &&
+                                         Symbols::GrowableObjectArray()) &&
                  (node->arguments()->length() == 0)) {
         return kGrowableObjectArrayCid;
       }
     }
   }
   return kDynamicCid;   // Result cid not known.
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
@@ skipping 586 matching lines @@
   ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   Function* super_function = NULL;
   if (node->IsSuperLoad()) {
     // Resolve the load indexed operator in the super class.
     super_function = &Function::ZoneHandle(
           Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                          Symbols::IndexTokenHandle()));
+                                          Symbols::IndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
-                                      Symbols::IndexTokenHandle(),
+                                      Symbols::IndexToken(),
                                       arguments);
       ReturnDefinition(call);
       return;
     }
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index(), loop_depth());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
   ValueGraphVisitor for_index(owner(), temp_index(), loop_depth());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new StaticCallInstr(node->token_pos(),
                                                 *super_function,
                                                 Array::ZoneHandle(),
                                                 arguments);
     ReturnDefinition(load);
   } else {
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
     InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
-                                                    Symbols::IndexTokenHandle(),
+                                                    Symbols::IndexToken(),
                                                     Token::kINDEX,
                                                     arguments,
                                                     Array::ZoneHandle(),
                                                     checked_argument_count);
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
   if (node->IsSuperStore()) {
     // Resolve the store indexed operator in the super class.
     super_function = &Function::ZoneHandle(
         Resolver::ResolveDynamicAnyArgs(node->super_class(),
-                                        Symbols::AssignIndexTokenHandle()));
+                                        Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       if (result_is_needed) {
         // Even though noSuchMethod most likely does not return,
         // we save the stored value if the result is needed.
         ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
         node->value()->Visit(&for_value);
         Append(for_value);
         Bind(BuildStoreExprTemp(for_value.value()));
       }
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       arguments->Add(node->value());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
-                                      Symbols::AssignIndexTokenHandle(),
+                                      Symbols::AssignIndexToken(),
                                       arguments);
       if (result_is_needed) {
         Do(call);
         return BuildLoadExprTemp();
       } else {
         return call;
       }
     }
   }
 
@@ skipping 313 matching lines @@
 
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
     AstNode* receiver,
     const String& method_name,
     ArgumentListNode* method_arguments) {
   // Build the graph to allocate an InvocationMirror object by calling
   // the static allocation method.
-  const String& mirror_name = String::Handle(Symbols::InvocationMirror());
   const Library& corelib = Library::Handle(Library::CoreLibrary());
   const Class& mirror_class = Class::Handle(
-      corelib.LookupClassAllowPrivate(mirror_name));
+      corelib.LookupClassAllowPrivate(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
-  const String& function_name = String::Handle(
-      Symbols::AllocateInvocationMirror());
   const Function& allocation_function = Function::ZoneHandle(
       Resolver::ResolveStaticByName(mirror_class,
-                                    function_name,
+                                    Symbols::AllocateInvocationMirror(),
                                     Resolver::kIsQualified));
   ASSERT(!allocation_function.IsNull());
 
   // Evaluate the receiver before the arguments. This will be used
   // as an argument to the noSuchMethod call.
   ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
   receiver->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
 
@@ skipping 19 matching lines @@
   ZoneGrowableArray<PushArgumentInstr*>* allocation_args =
       new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
   BuildPushArguments(*arguments, allocation_args);
   StaticCallInstr* allocation = new StaticCallInstr(args_pos,
                                                     allocation_function,
                                                     Array::ZoneHandle(),
                                                     allocation_args);
   Value* invocation_mirror = Bind(allocation);
   PushArgumentInstr* push_invocation_mirror = PushArgument(invocation_mirror);
   // Lookup noSuchMethod and call it with the receiver and the InvocationMirror.
-  const String& no_such_method_name =
-      String::ZoneHandle(Symbols::NoSuchMethod());
   const Function& no_such_method_func = Function::ZoneHandle(
-      Resolver::ResolveDynamicAnyArgs(target_class, no_such_method_name));
+      Resolver::ResolveDynamicAnyArgs(target_class, Symbols::NoSuchMethod()));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* args =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   args->Add(push_receiver);
   args->Add(push_invocation_mirror);
   return new StaticCallInstr(args_pos,
                              no_such_method_func,
                              Array::ZoneHandle(),
                              args);
@@ skipping 27 matching lines @@
   arguments->Add(PushArgument(arguments_value));
   // List argumentNames.
   Value* argument_names_value =
       Bind(new ConstantInstr(Array::ZoneHandle()));
   arguments->Add(PushArgument(argument_names_value));
   // List existingArgumentNames.
   Value* existing_argument_names_value =
       Bind(new ConstantInstr(Array::ZoneHandle()));
   arguments->Add(PushArgument(existing_argument_names_value));
   // Resolve and call NoSuchMethodError._throwNew.
-  const String& cls_name = String::Handle(Symbols::NoSuchMethodError());
-  const String& func_name = String::Handle(Symbols::ThrowNew());
+  const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::Handle(
-      Library::Handle(Library::CoreLibrary()).LookupClass(cls_name));
+      core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
-                              func_name,
+                              Symbols::ThrowNew(),
                               arguments->length(),
                               Array::ZoneHandle(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Array::ZoneHandle(),  // No names.
                              arguments);
 }
 
@@ skipping 112 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart