Alignments for the ClassMirror interface.

pkg/dartdoc/lib/dartdoc.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.
 
 /**
  * To generate docs for a library, run this script with the path to an
  * entrypoint .dart file, like:
  *
  *     $ dart dartdoc.dart foo.dart
  *
@@ skipping 586 matching lines @@
         typeInfo[KIND] = INTERFACE;
       } else {
         assert(type.isTypedef);
         typeInfo[KIND] = TYPEDEF;
       }
       final List typeMembers = docMembersJson(type.declaredMembers);
       if (!typeMembers.isEmpty) {
         typeInfo[MEMBERS] = typeMembers;
       }
 
-      if (!type.declaration.typeVariables.isEmpty) {
+      if (!type.originalDeclaration.typeVariables.isEmpty) {
         final typeVariables = [];
-        for (final typeVariable in type.declaration.typeVariables) {
+        for (final typeVariable in type.originalDeclaration.typeVariables) {
           typeVariables.add(typeVariable.displayName);
         }
         typeInfo[ARGS] = Strings.join(typeVariables, ', ');
       }
       types.add(typeInfo);
     }
     if (!types.isEmpty) {
       libraryInfo[TYPES] = types;
     }
 
@@ skipping 313 matching lines @@
           typeSpan(supertypes[i]);
           write(' > ');
         }
 
         // Write this class.
         typeSpan(type);
         writeln('</p>');
       }
 
       listTypes(subtypes, 'Subclasses');
-      listTypes(type.interfaces, 'Implements');
+      listTypes(type.superinterfaces, 'Implements');
     } else {
       // Show the default class.
-      if (type.defaultType != null) {
-        listTypes([type.defaultType], 'Default class');
+      if (type.defaultFactory != null) {
+        listTypes([type.defaultFactory], 'Default class');
       }
 
       // List extended interfaces.
-      listTypes(type.interfaces, 'Extends');
+      listTypes(type.superinterfaces, 'Extends');
 
       // List subinterfaces and implementing classes.
       final subinterfaces = [];
       final implementing = [];
 
       for (final subtype in subtypes) {
         if (subtype.isClass) {
           implementing.add(subtype);
         } else {
           subinterfaces.add(subtype);
@@ skipping 649 matching lines @@
 
     // Link to the type.
     if (shouldLinkToPublicApi(type.library)) {
       write('<a href="$API_LOCATION${typeUrl(type)}">${type.simpleName}</a>');
     } else if (shouldIncludeLibrary(type.library)) {
       write(a(typeUrl(type), type.simpleName));
     } else {
       write(type.simpleName);
     }
 
-    if (type.isDeclaration) {
+    if (type.isOriginalDeclaration) {
       // Avoid calling [:typeArguments():] on a declaration.
       return;
     }
 
     // See if it's an instantiation of a generic type.
     final typeArgs = type.typeArguments;
     if (typeArgs.length > 0) {
       write('&lt;');
       bool first = true;
       for (final arg in typeArgs) {
@@ skipping 16 matching lines @@
   typeName(TypeMirror type, {bool showBounds: false}) {
     if (type.isVoid) {
       return 'void';
     }
     if (type is TypeVariableMirror) {
       return type.simpleName;
     }
     assert(type is ClassMirror);
 
     // See if it's a generic type.
-    if (type.isDeclaration) {
+    if (type.isOriginalDeclaration) {
       final typeParams = [];
-      for (final typeParam in type.declaration.typeVariables) {
+      for (final typeParam in type.originalDeclaration.typeVariables) {
         if (showBounds &&
             (typeParam.bound != null) &&
             !typeParam.bound.isObject) {
           final bound = typeName(typeParam.bound, showBounds: true);
           typeParams.add('${typeParam.simpleName} extends $bound');
         } else {
           typeParams.add(typeParam.simpleName);
         }
       }
       if (typeParams.isEmpty) {
         return type.simpleName;
       }
       final params = Strings.join(typeParams, ', ');
       return '${type.simpleName}&lt;$params&gt;';
     }
 
     // See if it's an instantiation of a generic type.
     final typeArgs = type.typeArguments;
     if (typeArgs.length > 0) {
       final args = Strings.join(typeArgs.map((arg) => typeName(arg)), ', ');
-      return '${type.declaration.simpleName}&lt;$args&gt;';
+      return '${type.originalDeclaration.simpleName}&lt;$args&gt;';
     }
 
     // Regular type.
     return type.simpleName;
   }
 
   /**
    * Remove leading indentation to line up with first line.
    */
   unindentCode(SourceLocation span) {
@@ skipping 165 matching lines @@
   final ClassMirror inheritedFrom;
 
   DocComment(this.text, [this.inheritedFrom = null]) {
     assert(text != null && !text.trim().isEmpty);
   }
 
   String get html => md.markdownToHtml(text);
 
   String toString() => text;
 }