Alignments for the ClassMirror interface.

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 747 matching lines @@
   bool get isDynamic => false;
 
   bool get isVoid => false;
 
   bool get isTypeVariable => false;
 
   bool get isTypedef => false;
 
   bool get isFunction => false;
 
-  ClassMirror get declaration => this;
+  ClassMirror get originalDeclaration => this;
 
   ClassMirror get superclass {
     if (_class.supertype != null) {
       return new Dart2JsInterfaceTypeMirror(system, _class.supertype);
     }
     return null;
   }
 
-  List<ClassMirror> get interfaces {
+  List<ClassMirror> get superinterfaces {
     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;
   }
 
   bool get isClass => !_class.isInterface();
 
   bool get isInterface => _class.isInterface();
 
   bool get isAbstract => _class.modifiers.isAbstract();
 
-  bool get isDeclaration => true;
+  bool get isOriginalDeclaration => true;
 
   List<TypeMirror> get typeArguments {
     throw new UnsupportedError(
         'Declarations do not have type arguments');
   }
 
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       _typeVariables = <TypeVariableMirror>[];
       _class.ensureResolved(system.compiler);
       for (TypeVariableType typeVariable in _class.typeVariables) {
         _typeVariables.add(
             new Dart2JsTypeVariableMirror(system, typeVariable));
       }
     }
     return _typeVariables;
   }
 
   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.
    */
-  ClassMirror get defaultType {
+  ClassMirror get defaultFactory {
     if (_class.defaultClass != null) {
       return new Dart2JsInterfaceTypeMirror(system, _class.defaultClass);
     }
     return null;
   }
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
     if (other is! ClassMirror) {
       return false;
     }
     if (library != other.library) {
       return false;
     }
-    if (isDeclaration !== other.isDeclaration) {
+    if (isOriginalDeclaration !== other.isOriginalDeclaration) {
       return false;
     }
     return qualifiedName == other.qualifiedName;
   }
 }
 
 class Dart2JsTypedefMirror extends Dart2JsTypeElementMirror
     implements Dart2JsTypeMirror, TypedefMirror {
   final Dart2JsLibraryMirror _library;
   List<TypeVariableMirror> _typeVariables;
@@ skipping 51 matching lines @@
           _typedef.element.alias,
           system.compiler.types.dynamicType,
           _typedef.element.functionSignature);
     }
     return _definition;
   }
 
   Map<String, MemberMirror> get declaredMembers =>
       const <String, MemberMirror>{};
 
-  ClassMirror get declaration => this;
+  ClassMirror get originalDeclaration => this;
 
   // TODO(johnniwinther): How should a typedef respond to these?
   ClassMirror get superclass => null;
 
-  List<ClassMirror> get interfaces => const <ClassMirror>[];
+  List<ClassMirror> get superinterfaces => const <ClassMirror>[];
 
   bool get isClass => false;
 
   bool get isInterface => false;
 
-  bool get isDeclaration => true;
+  bool get isOriginalDeclaration => true;
 
   bool get isAbstract => false;
 
   Map<String, MethodMirror> get constructors =>
       const <String, MethodMirror>{};
 
-  ClassMirror get defaultType => null;
+  ClassMirror get defaultFactory => null;
 }
 
 class Dart2JsTypeVariableMirror extends Dart2JsTypeElementMirror
     implements TypeVariableMirror {
   final TypeVariableType _typeVariableType;
   ClassMirror _declarer;
 
   Dart2JsTypeVariableMirror(Dart2JsMirrorSystem system,
                             TypeVariableType typeVariableType)
     : this._typeVariableType = typeVariableType,
@@ skipping 85 matching lines @@
 class Dart2JsInterfaceTypeMirror extends Dart2JsTypeElementMirror
     implements ClassMirror {
   List<TypeMirror> _typeArguments;
 
   Dart2JsInterfaceTypeMirror(Dart2JsMirrorSystem system,
                              InterfaceType interfaceType)
       : super(system, interfaceType);
 
   InterfaceType get _interfaceType => _type;
 
-  String get qualifiedName => declaration.qualifiedName;
+  String get qualifiedName => originalDeclaration.qualifiedName;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  Map<String, MemberMirror> get declaredMembers => declaration.declaredMembers;
+  Map<String, MemberMirror> get declaredMembers =>
+      originalDeclaration.declaredMembers;
 
   bool get isObject => system.compiler.objectClass == _type.element;
 
   bool get isDynamic => system.compiler.dynamicClass == _type.element;
 
-  ClassMirror get declaration
+  ClassMirror get originalDeclaration
       => new Dart2JsClassMirror(system, _type.element);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  ClassMirror get superclass => declaration.superclass;
+  ClassMirror get superclass => originalDeclaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  List<ClassMirror> get interfaces => declaration.interfaces;
+  List<ClassMirror> get superinterfaces => originalDeclaration.superinterfaces;
 
-  bool get isClass => declaration.isClass;
+  bool get isClass => originalDeclaration.isClass;
 
-  bool get isInterface => declaration.isInterface;
+  bool get isInterface => originalDeclaration.isInterface;
 
-  bool get isAbstract => declaration.isAbstract;
+  bool get isAbstract => originalDeclaration.isAbstract;
 
-  bool get isPrivate => declaration.isPrivate;
+  bool get isPrivate => originalDeclaration.isPrivate;
 
-  bool get isDeclaration => false;
+  bool get isOriginalDeclaration => false;
 
   List<TypeMirror> get typeArguments {
     if (_typeArguments == null) {
       _typeArguments = <TypeMirror>[];
       Link<DartType> type = _interfaceType.arguments;
       while (type != null && type.head != null) {
         _typeArguments.add(_convertTypeToTypeMirror(system, type.head,
             system.compiler.types.dynamicType));
         type = type.tail;
       }
     }
     return _typeArguments;
   }
 
-  List<TypeVariableMirror> get typeVariables => declaration.typeVariables;
+  List<TypeVariableMirror> get typeVariables =>
+      originalDeclaration.typeVariables;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  Map<String, MethodMirror> get constructors => declaration.constructors;
+  Map<String, MethodMirror> get constructors =>
+      originalDeclaration.constructors;
 
   // TODO(johnniwinther): Substitute type arguments for type variables?
-  ClassMirror get defaultType => declaration.defaultType;
+  ClassMirror get defaultFactory => originalDeclaration.defaultFactory;
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
     if (other is! ClassMirror) {
       return false;
     }
-    if (other.isDeclaration) {
+    if (other.isOriginalDeclaration) {
       return false;
     }
-    if (declaration != other.declaration) {
+    if (originalDeclaration != other.originalDeclaration) {
       return false;
     }
     var thisTypeArguments = typeArguments.iterator();
     var otherTypeArguments = other.typeArguments.iterator();
     while (thisTypeArguments.hasNext && otherTypeArguments.hasNext) {
       if (thisTypeArguments.next() != otherTypeArguments.next()) {
         return false;
       }
     }
     return !thisTypeArguments.hasNext && !otherTypeArguments.hasNext;
   }
 }
 
 
 class Dart2JsFunctionTypeMirror extends Dart2JsTypeElementMirror
     implements FunctionTypeMirror {
   final FunctionSignature _functionSignature;
   List<ParameterMirror> _parameters;
 
   Dart2JsFunctionTypeMirror(Dart2JsMirrorSystem system,
                              FunctionType functionType, this._functionSignature)
       : super(system, functionType) {
     assert (_functionSignature !== null);
   }
 
   FunctionType get _functionType => _type;
 
   // TODO(johnniwinther): Is this the qualified name of a function type?
-  String get qualifiedName => declaration.qualifiedName;
+  String get qualifiedName => originalDeclaration.qualifiedName;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   Map<String, MemberMirror> get declaredMembers {
     var method = callMethod;
     if (method !== null) {
       var map = new Map<String, MemberMirror>.from(
-          declaration.declaredMembers);
+          originalDeclaration.declaredMembers);
       var name = method.qualifiedName;
       assert(!map.containsKey(name));
       map[name] = method;
       return new ImmutableMapWrapper<String, MemberMirror>(map);
     }
-    return declaration.declaredMembers;
+    return originalDeclaration.declaredMembers;
   }
 
   bool get isFunction => true;
 
   MethodMirror get callMethod => _convertElementMethodToMethodMirror(
       system.getLibrary(_functionType.element.getLibrary()),
       _functionType.element);
 
-  ClassMirror get declaration
+  ClassMirror get originalDeclaration
       => new Dart2JsClassMirror(system, system.compiler.functionClass);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  ClassMirror get superclass => declaration.superclass;
+  ClassMirror get superclass => originalDeclaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
-  List<ClassMirror> get interfaces => declaration.interfaces;
+  List<ClassMirror> get superinterfaces => originalDeclaration.superinterfaces;
 
-  bool get isClass => declaration.isClass;
+  bool get isClass => originalDeclaration.isClass;
 
-  bool get isInterface => declaration.isInterface;
+  bool get isInterface => originalDeclaration.isInterface;
 
-  bool get isPrivate => declaration.isPrivate;
+  bool get isPrivate => originalDeclaration.isPrivate;
 
-  bool get isDeclaration => false;
+  bool get isOriginalDeclaration => false;
 
   bool get isAbstract => false;
 
   List<TypeMirror> get typeArguments => const <TypeMirror>[];
 
-  List<TypeVariableMirror> get typeVariables => declaration.typeVariables;
+  List<TypeVariableMirror> get typeVariables =>
+      originalDeclaration.typeVariables;
 
   Map<String, MethodMirror> get constructors => <String, MethodMirror>{};
 
-  ClassMirror get defaultType => null;
+  ClassMirror get defaultFactory => 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 243 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);
     }
   }
 }