Cleanups, refactoring in anticipation of new string interpolation nodes. Removed unnecessary code.

runtime/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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
@@ skipping 17 matching lines @@
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DEFINE_FLAG(bool, print_flow_graph_optimized, false,
             "Print the IR flow graph when optimizing.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 DECLARE_FLAG(bool, enable_type_checks);
 
 
-static const String& PrivateCoreLibName(const String& str) {
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
-  const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
-  return private_name;
-}
-
-
 FlowGraphBuilder::FlowGraphBuilder(ParsedFunction* parsed_function,
                                    const Array& ic_data_array,
                                    InlineExitCollector* exit_collector,
                                    intptr_t osr_id)
   : parsed_function_(parsed_function),
     ic_data_array_(ic_data_array),
     num_copied_params_(parsed_function->num_copied_params()),
     // All parameters are copied if any parameter is.
     num_non_copied_params_((num_copied_params_ == 0)
         ? parsed_function->function().num_fixed_parameters()
@@ skipping 1011 matching lines @@
     }
     ReturnDefinition(BuildLoadExprTemp());
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 static const String& BinaryOpAndMaskName(BinaryOpNode* node) {
   if (node->kind() == Token::kSHL) {
-    return PrivateCoreLibName(Symbols::_leftShiftWithMask32());
+    return Library::PrivateCoreLibName(Symbols::_leftShiftWithMask32());
   }
   UNIMPLEMENTED();
   return String::ZoneHandle();
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression>
 //                            mask32: constant }
@@ skipping 198 matching lines @@
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   Value* type_arg = Bind(
       new ConstantInstr(node->right()->AsTypeNode()->type()));
   arguments->Add(PushArgument(type_arg));
   const Bool& negate = Bool::Get(node->kind() == Token::kISNOT);
   Value* negate_arg = Bind(new ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
-      PrivateCoreLibName(Symbols::_instanceOf()),
+      Library::PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(),
       arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
@@ skipping 49 matching lines @@
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new ZoneGrowableArray<PushArgumentInstr*>(4);
     arguments->Add(push_left);
     arguments->Add(push_instantiator);
     arguments->Add(push_type_args);
     Value* type_arg = Bind(new ConstantInstr(type));
     arguments->Add(PushArgument(type_arg));
     const intptr_t kNumArgsChecked = 1;
     InstanceCallInstr* call = new InstanceCallInstr(
         node->token_pos(),
-        PrivateCoreLibName(Symbols::_as()),
+        Library::PrivateCoreLibName(Symbols::_as()),
         node->kind(),
         arguments,
         Object::null_array(),  // No argument names.
         kNumArgsChecked,
         owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
@@ skipping 2327 matching lines @@
   Value* existing_argument_names_value =
       Bind(new ConstantInstr(Array::ZoneHandle()));
   arguments->Add(PushArgument(existing_argument_names_value));
   // Resolve and call NoSuchMethodError._throwNew.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::Handle(
       core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
-                              PrivateCoreLibName(Symbols::ThrowNew()),
+                              Library::PrivateCoreLibName(Symbols::ThrowNew()),
                               arguments->length(),
                               Object::null_array(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Object::null_array(),  // No names.
                              arguments,
                              owner()->ic_data_array());
 }
@@ skipping 122 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