Drop "Impl" suffix from local mirror class names.

runtime/lib/mirrors.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 "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 184 matching lines @@
 
     // Arguments 0 (referent) and 2 (owner) are the same for all parameters. See
     // above.
     args.SetAt(1, name);
     args.SetAt(3, pos);
     args.SetAt(4, Bool::Get(i >= index_of_first_optional_param));
     args.SetAt(5, Bool::Get(i >= index_of_first_named_param));
     args.SetAt(6, is_final);
     args.SetAt(7, default_value);
     args.SetAt(8, metadata);
-    param ^= CreateMirror(Symbols::_LocalParameterMirrorImpl(), args);
+    param ^= CreateMirror(Symbols::_LocalParameterMirror(), args);
     results.SetAt(i, param);
   }
   results.MakeImmutable();
   return results.raw();
 }
 
 
 static RawInstance* CreateTypeVariableMirror(const TypeParameter& param,
                                              const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, param);
   args.SetAt(1, String::Handle(param.name()));
   args.SetAt(2, owner_mirror);
-  return CreateMirror(Symbols::_LocalTypeVariableMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalTypeVariableMirror(), args);
 }
 
 
 // We create a list in native code and let Dart code create the type mirror
 // object and the ordered map.
 static RawInstance* CreateTypeVariableList(const Class& cls) {
   const TypeArguments& args = TypeArguments::Handle(cls.type_parameters());
   if (args.IsNull()) {
     return Object::empty_array().raw();
   }
@@ skipping 17 matching lines @@
                                         const AbstractType& type,
                                         const Bool& is_declaration,
                                         const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(6));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
   args.SetAt(2, String::Handle(cls.UserVisibleName()));
   args.SetAt(3, Bool::Get(cls.NumTypeParameters() != 0));
   args.SetAt(4, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
   args.SetAt(5, owner_mirror);
-  return CreateMirror(Symbols::_LocalTypedefMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalTypedefMirror(), args);
 }
 
 
 static RawInstance* CreateFunctionTypeMirror(const Class& cls,
                                              const AbstractType& type) {
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
   args.SetAt(1, type);
-  return CreateMirror(Symbols::_LocalFunctionTypeMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalFunctionTypeMirror(), args);
 }
 
 
 static RawInstance* CreateMethodMirror(const Function& func,
                                        const Instance& owner_mirror) {
   const Array& args = Array::Handle(Array::New(12));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(func)));
 
   String& name = String::Handle(func.name());
   name = String::IdentifierPrettyNameRetainPrivate(name);
   args.SetAt(1, name);
 
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Bool::Get(func.is_static()));
   args.SetAt(4, Bool::Get(func.is_abstract()));
   args.SetAt(5, Bool::Get(func.IsGetterFunction()));
   args.SetAt(6, Bool::Get(func.IsSetterFunction()));
 
   bool isConstructor = (func.kind() == RawFunction::kConstructor);
   args.SetAt(7, Bool::Get(isConstructor));
   args.SetAt(8, Bool::Get(isConstructor && func.is_const()));
   args.SetAt(9, Bool::Get(isConstructor && func.IsConstructor()));
   args.SetAt(10, Bool::Get(isConstructor && func.is_redirecting()));
   args.SetAt(11, Bool::Get(isConstructor && func.IsFactory()));
 
-  return CreateMirror(Symbols::_LocalMethodMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalMethodMirror(), args);
 }
 
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
       MirrorReference::Handle(MirrorReference::New(field));
 
   const String& name = String::Handle(field.name());
 
   const Array& args = Array::Handle(Array::New(7));
   args.SetAt(0, field_ref);
   args.SetAt(1, name);
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Object::null_instance());  // Null for type.
   args.SetAt(4, Bool::Get(field.is_static()));
   args.SetAt(5, Bool::Get(field.is_final()));
   args.SetAt(6, Bool::Get(field.is_const()));
 
-  return CreateMirror(Symbols::_LocalVariableMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalVariableMirror(), args);
 }
 
 static RawFunction* CallMethod(const Class& cls) {
   if (cls.IsSignatureClass()) {
     return cls.signature_function();
   }
 
   Class& lookup_cls = Class::Handle(cls.raw());
   Function& call_function = Function::Handle();
   do {
@@ skipping 33 matching lines @@
   // We do not set the names of anonymous mixin applications because the mirrors
   // use a different naming convention than the VM (lib.S with lib.M and S&M
   // respectively).
   if (!cls.IsAnonymousMixinApplication()) {
     args.SetAt(2, String::Handle(cls.Name()));
   }
   args.SetAt(3, owner_mirror);
   args.SetAt(4, is_generic);
   args.SetAt(5, is_mixin_app_alias);
   args.SetAt(6, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
-  return CreateMirror(Symbols::_LocalClassMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalClassMirror(), args);
 }
 
 
 static RawInstance* CreateLibraryMirror(const Library& lib) {
   const Array& args = Array::Handle(Array::New(3));
   args.SetAt(0, MirrorReference::Handle(MirrorReference::New(lib)));
   String& str = String::Handle();
   str = lib.name();
   args.SetAt(1, str);
   str = lib.url();
   args.SetAt(2, str);
-  return CreateMirror(Symbols::_LocalLibraryMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalLibraryMirror(), args);
 }
 
 
 static RawInstance* CreateTypeMirror(const AbstractType& type) {
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsMalformed());
   if (type.HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type.type_class());
     // Handle void and dynamic types.
     if (cls.IsVoidClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Void());
       // TODO(mlippautz): Create once in the VM isolate and retrieve from there.
-      return CreateMirror(Symbols::_SpecialTypeMirrorImpl(), args);
+      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
     } else if (cls.IsDynamicClass()) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Dynamic());
       // TODO(mlippautz): Create once in the VM isolate and retrieve from there.
-      return CreateMirror(Symbols::_SpecialTypeMirrorImpl(), args);
+      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
     }
     return CreateClassMirror(cls, type, Bool::False(), Object::null_instance());
   } else if (type.IsTypeParameter()) {
     return CreateTypeVariableMirror(TypeParameter::Cast(type),
                                     Object::null_instance());
   } else if (type.IsBoundedType()) {
     AbstractType& actual_type =
         AbstractType::Handle(BoundedType::Cast(type).type());
     return CreateTypeMirror(actual_type);
   }
   UNREACHABLE();
   return Instance::null();
 }
 
 
 static RawInstance* CreateIsolateMirror() {
   Isolate* isolate = Isolate::Current();
   const String& debug_name = String::Handle(String::New(isolate->name()));
   const Library& root_library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   const Instance& root_library_mirror =
       Instance::Handle(CreateLibraryMirror(root_library));
 
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, debug_name);
   args.SetAt(1, root_library_mirror);
-  return CreateMirror(Symbols::_LocalIsolateMirrorImpl(), args);
+  return CreateMirror(Symbols::_LocalIsolateMirror(), args);
 }
 
 
 static RawInstance* CreateMirrorSystem() {
   Isolate* isolate = Isolate::Current();
   const GrowableObjectArray& libraries =
       GrowableObjectArray::Handle(isolate->object_store()->libraries());
 
   const int num_libraries = libraries.Length();
   const Array& library_mirrors = Array::Handle(Array::New(num_libraries));
   Library& library = Library::Handle();
   Instance& library_mirror = Instance::Handle();
 
   for (int i = 0; i < num_libraries; i++) {
     library ^= libraries.At(i);
     library_mirror = CreateLibraryMirror(library);
     library_mirrors.SetAt(i, library_mirror);
   }
 
   const Instance& isolate_mirror = Instance::Handle(CreateIsolateMirror());
 
   const Array& args = Array::Handle(Array::New(2));
   args.SetAt(0, library_mirrors);
   args.SetAt(1, isolate_mirror);
-  return CreateMirror(Symbols::_LocalMirrorSystemImpl(), args);
+  return CreateMirror(Symbols::_LocalMirrorSystem(), args);
 }
 
 
 static RawInstance* ReturnResult(const Object& result) {
   if (result.IsError()) {
     ThrowInvokeError(Error::Cast(result));
     UNREACHABLE();
   }
   if (result.IsInstance()) {
     return Instance::Cast(result).raw();
@@ skipping 1485 matching lines @@
 
 DEFINE_NATIVE_ENTRY(VariableMirror_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Field& field = Field::Handle(ref.GetFieldReferent());
   GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
   const AbstractType& type = AbstractType::Handle(field.type());
   return InstantiateType(type, instantiator);
 }
 
 }  // namespace dart