Rename InterfaceMirror to ClassMirror

tests/compiler/dart2js/mirrors_test.dart

 // 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.
 
 #import("../../../pkg/dartdoc/lib/mirrors.dart");
 #import("../../../pkg/dartdoc/lib/mirrors_util.dart");
 
 #import('dart:io');
 
 int count(Iterable iterable) {
@@ skipping 60 matching lines @@
 
 // Testing class Foo:
 //
 // class Foo {
 //
 // }
 void testFoo(MirrorSystem system, LibraryMirror helperLibrary,
              Map<String,TypeMirror> types) {
   var fooClass = types["Foo"];
   Expect.isNotNull(fooClass, "Type 'Foo' not found");
-  Expect.isTrue(fooClass is InterfaceMirror,
+  Expect.isTrue(fooClass is ClassMirror,
                 "Unexpected mirror type returned");
   Expect.stringEquals("Foo", fooClass.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Foo", fooClass.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, fooClass.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(fooClass.isObject, "Class is Object");
@@ skipping 52 matching lines @@
 
 // Testing interface Bar:
 //
 // interface Bar<E> {
 //
 // }
 void testBar(MirrorSystem system, LibraryMirror helperLibrary,
              Map<String,TypeMirror> types) {
   var barInterface = types["Bar"];
   Expect.isNotNull(barInterface, "Type 'Bar' not found");
-  Expect.isTrue(barInterface is InterfaceMirror,
+  Expect.isTrue(barInterface is ClassMirror,
                "Unexpected mirror type returned");
   Expect.stringEquals("Bar", barInterface.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Bar", barInterface.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, barInterface.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(barInterface.isObject, "Interface is Object");
@@ skipping 69 matching lines @@
 //   void method2(E e, [F f = null]) {}
 //   Baz<E,F> method3(E func1(F f), Func<E,F> func2) => null;
 //
 //   bool operator==(Object other) => false;
 //   int operator -() => 0;
 // }
 void testBaz(MirrorSystem system, LibraryMirror helperLibrary,
              Map<String,TypeMirror> types) {
   var bazClass = types["Baz"];
   Expect.isNotNull(bazClass, "Type 'Baz' not found");
-  Expect.isTrue(bazClass is InterfaceMirror,
+  Expect.isTrue(bazClass is ClassMirror,
                 "Unexpected mirror type returned");
   Expect.stringEquals("Baz", bazClass.simpleName,
                       "Unexpected type simple name");
   Expect.stringEquals("mirrors_helper.Baz", bazClass.qualifiedName,
                       "Unexpected type qualified name");
 
   Expect.equals(helperLibrary, bazClass.library,
                 "Unexpected library returned from type");
 
   Expect.isFalse(bazClass.isObject, "Class is Object");
@@ skipping 222 matching lines @@
   Expect.isNull(method3.constructorName,
                 "Method constructorName is non-null");
   Expect.isFalse(method3.isGetter, "Method is getter");
   Expect.isFalse(method3.isSetter, "Method is setter");
   Expect.isFalse(method3.isOperator, "Method is operator");
   Expect.isNull(method3.operatorName,
                 "Method operatorName is non-null");
 
   var method3ReturnType = method3.returnType;
   Expect.isNotNull(method3ReturnType, "Return type is null");
-  Expect.isTrue(method3ReturnType is InterfaceMirror,
+  Expect.isTrue(method3ReturnType is ClassMirror,
                 "Return type is not interface");
   Expect.equals(bazClass, method3ReturnType.declaration,
                 "Return type is not Baz");
   // TODO(johnniwinther): Test type arguments of [method3ReturnType].
 
   var method3Parameters = method3.parameters;
   Expect.isNotNull(method3Parameters, "Method parameters is null");
   Expect.equals(2, method3Parameters.length, "Unexpected parameter count");
   var method3Parameter1 = method3Parameters[0];
   Expect.isNotNull(method3Parameter1, "Parameter is null");
@@ skipping 194 matching lines @@
 //   get _privateGetter => _privateField;
 //   void set _privateSetter(value) => _privateField = value;
 //   void _privateMethod() {}
 //   _PrivateClass._privateConstructor();
 //   factory _PrivateClass._privateFactoryConstructor() => new _PrivateClass();
 // }
 void testPrivate(MirrorSystem system, LibraryMirror helperLibrary,
                  Map<String,TypeMirror> types) {
   var privateClass = types['_PrivateClass'];
   Expect.isNotNull(privateClass);
-  Expect.isTrue(privateClass is InterfaceMirror);
+  Expect.isTrue(privateClass is ClassMirror);
   Expect.isTrue(privateClass.isClass);
   Expect.isTrue(privateClass.isPrivate);
 
   var privateField = privateClass.declaredMembers['_privateField'];
   Expect.isNotNull(privateField);
   Expect.isTrue(privateField is FieldMirror);
   Expect.isTrue(privateField.isPrivate);
 
   var privateGetter = privateClass.declaredMembers['_privateGetter'];
   Expect.isNotNull(privateGetter);
@@ skipping 19 matching lines @@
   Expect.isTrue(privateConstructor.isConstructor);
   Expect.isTrue(privateConstructor.isPrivate);
 
   var privateFactoryConstructor =
       privateClass.declaredMembers['_PrivateClass._privateFactoryConstructor'];
   Expect.isNotNull(privateFactoryConstructor);
   Expect.isTrue(privateFactoryConstructor is MethodMirror);
   Expect.isTrue(privateFactoryConstructor.isFactory);
   Expect.isTrue(privateFactoryConstructor.isPrivate);
 }