Lookup functions by name that contains the private key, except for dart_api which allows ignoring t…

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 13 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(const ParsedFunction& parsed_function,
                                    InliningContext* inlining_context)
   : parsed_function_(parsed_function),
     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()
         : 0),
     num_stack_locals_(parsed_function.num_stack_locals()),
     inlining_context_(inlining_context),
@@ skipping 899 matching lines @@
   PushArgumentInstr* push_instantiator = NULL;
   PushArgumentInstr* push_type_args = NULL;
   if (type.IsInstantiated()) {
     push_instantiator = PushArgument(BuildNullValue());
     push_type_args = PushArgument(BuildNullValue());
   } else {
     BuildTypecheckPushArguments(node->token_pos(),
                                 &push_instantiator,
                                 &push_type_args);
   }
-  const String& name = String::ZoneHandle(Symbols::New("_instanceOf"));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(5);
   arguments->Add(push_left);
   arguments->Add(push_instantiator);
   arguments->Add(push_type_args);
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   Value* type_arg = Bind(
       new ConstantInstr(node->right()->AsTypeNode()->type()));
   arguments->Add(PushArgument(type_arg));
   const Bool& negate = (node->kind() == Token::kISNOT) ? Bool::True() :
                                                          Bool::False();
   Value* negate_arg = Bind(new ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
-  InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
-                                                  name,
-                                                  node->kind(),
-                                                  arguments,
-                                                  Array::ZoneHandle(),
-                                                  kNumArgsChecked);
+  InstanceCallInstr* call = new InstanceCallInstr(
+      node->token_pos(),
+      PrivateCoreLibName(Symbols::_instanceOf()),
+      node->kind(),
+      arguments,
+      Array::ZoneHandle(),
+      kNumArgsChecked);
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_value);
@@ skipping 1888 matching lines @@
     AstNode* receiver,
     const String& method_name,
     ArgumentListNode* method_arguments) {
   // Build the graph to allocate an InvocationMirror object by calling
   // the static allocation method.
   const Library& corelib = Library::Handle(Library::CoreLibrary());
   const Class& mirror_class = Class::Handle(
       corelib.LookupClassAllowPrivate(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
-      Resolver::ResolveStaticByName(mirror_class,
-                                    Symbols::AllocateInvocationMirror(),
-                                    Resolver::kIsQualified));
+      Resolver::ResolveStaticByName(
+          mirror_class,
+          PrivateCoreLibName(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());
 
   // Allocate the arguments and pass them into the construction
@@ skipping 73 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,
-                              Symbols::ThrowNew(),
+                              PrivateCoreLibName(Symbols::ThrowNew()),
                               arguments->length(),
                               Array::ZoneHandle(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Array::ZoneHandle(),  // No names.
                              arguments);
 }
 
@@ skipping 106 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