Rename InterfaceMirror to ClassMirror

pkg/dartdoc/lib/src/mirrors/dart2js_mirror.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.
 
 library mirrors_dart2js;
 
 import 'dart:io';
 import 'dart:uri';
 
 import '../../../../../lib/compiler/compiler.dart' as diagnostics;
@@ skipping 456 matching lines @@
 }
 
 abstract class Dart2JsObjectMirror extends Dart2JsElementMirror
     implements ObjectMirror {
   Dart2JsObjectMirror(Dart2JsMirrorSystem system, Element element)
       : super(system, element);
 }
 
 class Dart2JsLibraryMirror extends Dart2JsObjectMirror
     implements LibraryMirror {
-  Map<String, InterfaceMirror> _types;
+  Map<String, ClassMirror> _types;
   Map<String, MemberMirror> _members;
 
   Dart2JsLibraryMirror(Dart2JsMirrorSystem system, LibraryElement library)
       : super(system, library);
 
   LibraryElement get _library => _element;
 
   Uri get uri => _library.uri;
 
   LibraryMirror library() => this;
@@ skipping 16 matching lines @@
       // Use the file name as script name.
       String path = _library.uri.path;
       return path.substring(path.lastIndexOf('/') + 1);
     }
   }
 
   String get qualifiedName => simpleName;
 
   void _ensureTypes() {
     if (_types == null) {
-      _types = <String, InterfaceMirror>{};
+      _types = <String, ClassMirror>{};
       _library.forEachLocalMember((Element e) {
         if (e.isClass()) {
           e.ensureResolved(system.compiler);
-          var type = new Dart2JsInterfaceMirror.fromLibrary(this, e);
+          var type = new Dart2JsClassMirror.fromLibrary(this, e);
           assert(invariant(_library, !_types.containsKey(type.simpleName),
               message: "Type name '${type.simpleName}' "
                        "is not unique in $_library."));
           _types[type.simpleName] = type;
         } else if (e.isTypedef()) {
           var type = new Dart2JsTypedefMirror.fromLibrary(this,
               e.computeType(system.compiler));
           assert(invariant(_library, !_types.containsKey(type.simpleName),
               message: "Type name '${type.simpleName}' "
                        "is not unique in $_library."));
@@ skipping 15 matching lines @@
         }
       });
     }
   }
 
   Map<String, MemberMirror> get declaredMembers {
     _ensureMembers();
     return new ImmutableMapWrapper<String, MemberMirror>(_members);
   }
 
-  Map<String, InterfaceMirror> get types {
+  Map<String, ClassMirror> get types {
     _ensureTypes();
-    return new ImmutableMapWrapper<String, InterfaceMirror>(_types);
+    return new ImmutableMapWrapper<String, ClassMirror>(_types);
   }
 
   Location get location {
     var script = _library.getCompilationUnit().script;
     return new Dart2JsLocation(
         script,
         new SourceSpan(script.uri, 0, script.text.length));
   }
 }
 
@@ skipping 93 matching lines @@
 
   bool get isInitializingFormal => true;
 
   FieldMirror get initializedField => new Dart2JsFieldMirror(
       _method.surroundingDeclaration, _fieldParameterElement.fieldElement);
 }
 
 //------------------------------------------------------------------------------
 // Declarations
 //------------------------------------------------------------------------------
-class Dart2JsInterfaceMirror extends Dart2JsObjectMirror
-    implements Dart2JsTypeMirror, InterfaceMirror {
+class Dart2JsClassMirror extends Dart2JsObjectMirror
+    implements Dart2JsTypeMirror, ClassMirror {
   final Dart2JsLibraryMirror library;
   Map<String, Dart2JsMemberMirror> _members;
   List<TypeVariableMirror> _typeVariables;
 
-  Dart2JsInterfaceMirror(Dart2JsMirrorSystem system, ClassElement _class)
+  Dart2JsClassMirror(Dart2JsMirrorSystem system, ClassElement _class)
       : this.library = system.getLibrary(_class.getLibrary()),
         super(system, _class);
 
   ClassElement get _class => _element;
 
-  Dart2JsInterfaceMirror.fromLibrary(Dart2JsLibraryMirror library,
+  Dart2JsClassMirror.fromLibrary(Dart2JsLibraryMirror library,
                                  ClassElement _class)
       : this.library = library,
         super(library.system, _class);
 
   String get qualifiedName => '${library.qualifiedName}.${simpleName}';
 
   Location get location {
     if (_class is PartialClassElement) {
       var node = _class.parseNode(system.compiler);
       if (node !== null) {
@@ skipping 27 matching lines @@
   bool get isDynamic => false;
 
   bool get isVoid => false;
 
   bool get isTypeVariable => false;
 
   bool get isTypedef => false;
 
   bool get isFunction => false;
 
-  InterfaceMirror get declaration => this;
+  ClassMirror get declaration => this;
 
-  InterfaceMirror get superclass {
+  ClassMirror get superclass {
     if (_class.supertype != null) {
       return new Dart2JsInterfaceTypeMirror(system, _class.supertype);
     }
     return null;
   }
 
-  List<InterfaceMirror> get interfaces {
-    var list = <InterfaceMirror>[];
+  List<ClassMirror> get interfaces {
+    var list = <ClassMirror>[];
     Link<DartType> link = _class.interfaces;
     while (!link.isEmpty) {
       var type = _convertTypeToTypeMirror(system, link.head,
                                           system.compiler.types.dynamicType);
       list.add(type);
       link = link.tail;
     }
     return list;
   }
 
@@ skipping 26 matching lines @@
 
   Map<String, MethodMirror> get constructors {
     _ensureMembers();
     return new AsFilteredImmutableMap<String, MemberMirror, MethodMirror>(
         _members, (m) => m.isConstructor ? m : null);
   }
 
   /**
    * Returns the default type for this interface.
    */
-  InterfaceMirror get defaultType {
+  ClassMirror get defaultType {
     if (_class.defaultClass != null) {
       return new Dart2JsInterfaceTypeMirror(system, _class.defaultClass);
     }
     return null;
   }
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
-    if (other is! InterfaceMirror) {
+    if (other is! ClassMirror) {
       return false;
     }
     if (library != other.library) {
       return false;
     }
     if (isDeclaration !== other.isDeclaration) {
       return false;
     }
     return qualifiedName == other.qualifiedName;
   }
@@ skipping 57 matching lines @@
           _typedef.element.alias,
           system.compiler.types.dynamicType,
           _typedef.element.functionSignature);
     }
     return _definition;
   }
 
   Map<String, MemberMirror> get declaredMembers =>
       const <String, MemberMirror>{};
 
-  InterfaceMirror get declaration => this;
+  ClassMirror get declaration => this;
 
   // TODO(johnniwinther): How should a typedef respond to these?
-  InterfaceMirror get superclass => null;
+  ClassMirror get superclass => null;
 
-  List<InterfaceMirror> get interfaces => const <InterfaceMirror>[];
+  List<ClassMirror> get interfaces => const <ClassMirror>[];
 
   bool get isClass => false;
 
   bool get isInterface => false;
 
   bool get isPrivate => _isPrivate(simpleName);
 
   bool get isDeclaration => true;
 
   bool get isAbstract => false;
 
   Map<String, MethodMirror> get constructors =>
       const <String, MethodMirror>{};
 
-  InterfaceMirror get defaultType => null;
+  ClassMirror get defaultType => null;
 }
 
 class Dart2JsTypeVariableMirror extends Dart2JsTypeElementMirror
     implements TypeVariableMirror {
   final TypeVariableType _typeVariableType;
-  InterfaceMirror _declarer;
+  ClassMirror _declarer;
 
   Dart2JsTypeVariableMirror(Dart2JsMirrorSystem system,
                             TypeVariableType typeVariableType)
     : this._typeVariableType = typeVariableType,
       super(system, typeVariableType) {
       assert(_typeVariableType !== null);
   }
 
 
   String get qualifiedName => '${declarer.qualifiedName}.${simpleName}';
 
-  InterfaceMirror get declarer {
+  ClassMirror get declarer {
     if (_declarer === null) {
       if (_typeVariableType.element.enclosingElement.isClass()) {
-        _declarer = new Dart2JsInterfaceMirror(system,
+        _declarer = new Dart2JsClassMirror(system,
             _typeVariableType.element.enclosingElement);
       } else if (_typeVariableType.element.enclosingElement.isTypedef()) {
         _declarer = new Dart2JsTypedefMirror(system,
             _typeVariableType.element.enclosingElement.computeType(
                 system.compiler));
       }
     }
     return _declarer;
   }
 
@@ skipping 53 matching lines @@
   bool get isTypeVariable => false;
 
   bool get isTypedef => false;
 
   bool get isFunction => false;
 
   String toString() => _type.element.toString();
 }
 
 class Dart2JsInterfaceTypeMirror extends Dart2JsTypeElementMirror
-    implements InterfaceMirror {
+    implements ClassMirror {
   List<TypeMirror> _typeArguments;
 
   Dart2JsInterfaceTypeMirror(Dart2JsMirrorSystem system,
                              InterfaceType interfaceType)
       : super(system, interfaceType);
 
   InterfaceType get _interfaceType => _type;
 
   String get qualifiedName => declaration.qualifiedName;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   Map<String, MemberMirror> get declaredMembers => declaration.declaredMembers;
 
   bool get isObject => system.compiler.objectClass == _type.element;
 
   bool get isDynamic => system.compiler.dynamicClass == _type.element;
 
-  InterfaceMirror get declaration
-      => new Dart2JsInterfaceMirror(system, _type.element);
+  ClassMirror get declaration
+      => new Dart2JsClassMirror(system, _type.element);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  InterfaceMirror get superclass => declaration.superclass;
+  ClassMirror get superclass => declaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  List<InterfaceMirror> get interfaces => declaration.interfaces;
+  List<ClassMirror> get interfaces => declaration.interfaces;
 
   bool get isClass => declaration.isClass;
 
   bool get isInterface => declaration.isInterface;
 
   bool get isAbstract => declaration.isAbstract;
 
   bool get isPrivate => declaration.isPrivate;
 
   bool get isDeclaration => false;
@@ skipping 10 matching lines @@
     }
     return _typeArguments;
   }
 
   List<TypeVariableMirror> get typeVariables => declaration.typeVariables;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   Map<String, MethodMirror> get constructors => declaration.constructors;
 
   // TODO(johnniwinther): Substitute type arguments for type variables?
-  InterfaceMirror get defaultType => declaration.defaultType;
+  ClassMirror get defaultType => declaration.defaultType;
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
-    if (other is! InterfaceMirror) {
+    if (other is! ClassMirror) {
       return false;
     }
     if (other.isDeclaration) {
       return false;
     }
     if (declaration != other.declaration) {
       return false;
     }
     var thisTypeArguments = typeArguments.iterator();
     var otherTypeArguments = other.typeArguments.iterator();
@@ skipping 36 matching lines @@
     }
     return declaration.declaredMembers;
   }
 
   bool get isFunction => true;
 
   MethodMirror get callMethod => _convertElementMethodToMethodMirror(
       system.getLibrary(_functionType.element.getLibrary()),
       _functionType.element);
 
-  InterfaceMirror get declaration
-      => new Dart2JsInterfaceMirror(system, system.compiler.functionClass);
+  ClassMirror get declaration
+      => new Dart2JsClassMirror(system, system.compiler.functionClass);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  InterfaceMirror get superclass => declaration.superclass;
+  ClassMirror get superclass => declaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  List<InterfaceMirror> get interfaces => declaration.interfaces;
+  List<ClassMirror> get interfaces => declaration.interfaces;
 
   bool get isClass => declaration.isClass;
 
   bool get isInterface => declaration.isInterface;
 
   bool get isPrivate => declaration.isPrivate;
 
   bool get isDeclaration => false;
 
   bool get isAbstract => false;
 
   List<TypeMirror> get typeArguments => const <TypeMirror>[];
 
   List<TypeVariableMirror> get typeVariables => declaration.typeVariables;
 
   Map<String, MethodMirror> get constructors => <String, MethodMirror>{};
 
-  InterfaceMirror get defaultType => null;
+  ClassMirror get defaultType => null;
 
   TypeMirror get returnType {
     return _convertTypeToTypeMirror(system, _functionType.returnType,
                                     system.compiler.types.dynamicType);
   }
 
   List<ParameterMirror> get parameters {
     if (_parameters === null) {
       _parameters = _parametersFromFunctionSignature(system, callMethod,
                                                      _functionSignature);
@@ skipping 245 matching lines @@
     if (node !== null) {
       var span = system.compiler.spanFromNode(node, script.uri);
       return new Dart2JsLocation(script, span);
     } else {
       var span = system.compiler.spanFromElement(_variable);
       return new Dart2JsLocation(script, span);
     }
   }
 }