ObjectMirror => ContainerMirror

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 562 matching lines @@
     final libraryList = [];
     for (final library in _sortedLibraries) {
       docLibraryNavigationJson(library, libraryList);
     }
     return libraryList;
   }
 
   void docLibraryNavigationJson(LibraryMirror library, List libraryList) {
     var libraryInfo = {};
     libraryInfo[NAME] = displayName(library);
-    final List members = docMembersJson(library.declaredMembers);
+    final List members = docMembersJson(library.members);
     if (!members.isEmpty) {
       libraryInfo[MEMBERS] = members;
     }
 
     final types = [];
     for (ClassMirror type in orderByName(library.classes.values)) {
       if (!showPrivate && type.isPrivate) continue;
 
       var typeInfo = {};
       typeInfo[NAME] = type.displayName;
       if (type.isClass) {
         typeInfo[KIND] = CLASS;
       } else if (type.isInterface) {
         typeInfo[KIND] = INTERFACE;
       } else {
         assert(type.isTypedef);
         typeInfo[KIND] = TYPEDEF;
       }
-      final List typeMembers = docMembersJson(type.declaredMembers);
+      final List typeMembers = docMembersJson(type.members);
       if (!typeMembers.isEmpty) {
         typeInfo[MEMBERS] = typeMembers;
       }
 
       if (!type.originalDeclaration.typeVariables.isEmpty) {
         final typeVariables = [];
         for (final typeVariable in type.originalDeclaration.typeVariables) {
           typeVariables.add(typeVariable.displayName);
         }
         typeInfo[ARGS] = Strings.join(typeVariables, ', ');
@@ skipping 392 matching lines @@
 
   static final Map<String, int> operatorOrderMap = (){
     var map = new Map<String, int>();
     var index = 0;
     for (String operator in operatorOrder) {
       map[operator] = index++;
     }
     return map;
   }();
 
-  void docMembers(ObjectMirror host) {
+  void docMembers(ContainerMirror host) {
     // Collect the different kinds of members.
     final staticMethods = [];
     final staticGetters = new Map<String,MemberMirror>();
     final staticSetters = new Map<String,MemberMirror>();
     final memberMap = new Map<String,MemberMirror>();
     final instanceMethods = [];
     final instanceOperators = [];
     final instanceGetters = new Map<String,MemberMirror>();
     final instanceSetters = new Map<String,MemberMirror>();
     final constructors = [];
 
-    host.declaredMembers.forEach((_, MemberMirror member) {
+    host.members.forEach((_, MemberMirror member) {
       if (!showPrivate && member.isPrivate) return;
       if (host is LibraryMirror || member.isStatic) {
         if (member is MethodMirror) {
           if (member.isGetter) {
             staticGetters[member.displayName] = member;
           } else if (member.isSetter) {
             staticSetters[member.displayName] = member;
           } else {
             staticMethods.add(member);
           }
         } else if (member is VariableMirror) {
           staticGetters[member.displayName] = member;
         }
       }
     });
 
     if (host is ClassMirror) {
       var iterable = new HierarchyIterable(host, includeType: true);
       for (ClassMirror type in iterable) {
         if (!host.isObject && !inheritFromObject && type.isObject) continue;
 
-        type.declaredMembers.forEach((_, MemberMirror member) {
+        type.members.forEach((_, MemberMirror member) {
           if (member.isStatic) return;
           if (!showPrivate && member.isPrivate) return;
 
           bool inherit = true;
           if (type !== host) {
             if (member.isPrivate) {
               // Don't inherit private members.
               inherit = false;
             }
             if (member.isConstructor) {
@@ skipping 68 matching lines @@
                   allInherited: allPropertiesInherited);
     docMethods(host, 'Operators', instanceOperators,
                allInherited: allOperatorsInherited);
     docMethods(host, 'Methods', orderByName(instanceMethods),
                allInherited: allMethodsInherited);
   }
 
   /**
    * Documents fields, getters, and setters as properties.
    */
-  void docProperties(ObjectMirror host, String title,
+  void docProperties(ContainerMirror host, String title,
                      Map<String,MemberMirror> getters,
                      Map<String,MemberMirror> setters,
                      {bool allInherited}) {
     if (getters.isEmpty && setters.isEmpty) return;
 
     var nameSet = new Set<String>.from(getters.keys);
     nameSet.addAll(setters.keys);
     var nameList = new List<String>.from(nameSet);
     nameList.sort((String a, String b) {
       return a.toLowerCase().compareTo(b.toLowerCase());
@@ skipping 38 matching lines @@
           }
         } else {
           // Document as field.
           docProperty(host, getter, setter);
         }
       }
     }
     writeln('</div>');
   }
 
-  void docMethods(ObjectMirror host, String title, List<MethodMirror> methods,
+  void docMethods(ContainerMirror host, String title, List<MethodMirror> methods,
                   {bool allInherited}) {
     if (methods.length > 0) {
       writeln('<div${allInherited ? ' class="inherited"' : ''}>');
       writeln('<h3>$title</h3>');
       for (final method in methods) {
         docMethod(host, method);
       }
       writeln('</div>');
     }
   }
 
   /**
    * Documents the [member] declared in [host]. Handles all kinds of members
    * including getters, setters, and constructors. If [member] is a
    * [FieldMirror] it is documented as a getter or setter depending upon the
    * value of [asGetter].
    */
-  void docMethod(ObjectMirror host, MemberMirror member,
+  void docMethod(ContainerMirror host, MemberMirror member,
                  {bool asGetter: false}) {
     _totalMembers++;
     _currentMember = member;
 
     bool isAbstract = false;
     String name = member.displayName;
     if (member is VariableMirror) {
       if (asGetter) {
         // Getter.
         name = 'get $name';
@@ skipping 75 matching lines @@
     writeln('<div class="doc">');
     docComment(host, getMemberComment(member));
     if (showCode) {
       docCode(member.location);
     }
     writeln('</div>');
 
     writeln('</div>');
   }
 
-  void docField(ObjectMirror host, VariableMirror field,
+  void docField(ContainerMirror host, VariableMirror field,
                 {bool asGetter: false, bool asSetter: false}) {
     if (asGetter) {
       docMethod(host, field, asGetter: true);
     } else if (asSetter) {
       docMethod(host, field, asGetter: false);
     } else {
       docProperty(host, field, null);
     }
   }
 
   /**
    * Documents the property defined by [getter] and [setter] of declared in
    * [host]. If [getter] is a [FieldMirror], [setter] must be [:null:].
    * Otherwise, if [getter] is a [MethodMirror], the property is considered
    * final if [setter] is [:null:].
    */
-  void docProperty(ObjectMirror host,
+  void docProperty(ContainerMirror host,
                    MemberMirror getter, MemberMirror setter) {
     assert(getter != null);
     _totalMembers++;
     _currentMember = getter;
 
     bool inherited = host != getter.owner;
 
     writeln('<div class="field${inherited ? ' inherited' : ''}">'
             '<h4 id="${memberAnchor(getter)}">');
 
@@ skipping 47 matching lines @@
     docComment(host, comment);
     docCode(getter.location);
     if (setter != null) {
       docCode(setter.location);
     }
     writeln('</div>');
 
     writeln('</div>');
   }
 
-  void docParamList(ObjectMirror enclosingType,
+  void docParamList(ContainerMirror enclosingType,
                     List<ParameterMirror> parameters) {
     write('(');
     bool first = true;
     bool inOptionals = false;
     for (final parameter in parameters) {
       if (!first) write(', ');
 
       if (!inOptionals && parameter.isOptional) {
         write('[');
         inOptionals = true;
       }
 
       annotateType(enclosingType, parameter.type, parameter.simpleName);
 
       // Show the default value for named optional parameters.
       if (parameter.isOptional && parameter.hasDefaultValue) {
         write(' = ');
         write(parameter.defaultValue);
       }
 
       first = false;
     }
 
     if (inOptionals) write(']');
     write(')');
   }
 
-  void docComment(ObjectMirror host, DocComment comment) {
+  void docComment(ContainerMirror host, DocComment comment) {
     if (comment != null) {
       if (comment.inheritedFrom !== null) {
         writeln('<div class="inherited">');
         writeln(comment.html);
         write('<div class="docs-inherited-from">docs inherited from ');
         annotateType(host, comment.inheritedFrom);
         write('</div>');
         writeln('</div>');
       } else {
         writeln(comment.html);
@@ skipping 40 matching lines @@
    */
   DocComment getMemberComment(MemberMirror member) {
     String comment = _comments.find(member.location);
     ClassMirror inheritedFrom = null;
     if (comment == null) {
       if (member.owner is ClassMirror) {
         var iterable =
             new HierarchyIterable(member.owner,
                                   includeType: false);
         for (ClassMirror type in iterable) {
-          var inheritedMember = type.declaredMembers[member.simpleName];
+          var inheritedMember = type.members[member.simpleName];
           if (inheritedMember is MemberMirror) {
             comment = _comments.find(inheritedMember.location);
             if (comment != null) {
               inheritedFrom = type;
               break;
             }
           }
         }
       }
     }
@@ skipping 22 matching lines @@
     // a scheme to be relative.
     return const RegExp(r'^\w+:').hasMatch(url);
   }
 
   /** Gets the URL to the documentation for [library]. */
   String libraryUrl(LibraryMirror library) {
     return '${sanitize(displayName(library))}.html';
   }
 
   /** Gets the URL for the documentation for [type]. */
-  String typeUrl(ObjectMirror type) {
+  String typeUrl(ContainerMirror type) {
     if (type is LibraryMirror) {
       return '${sanitize(type.simpleName)}.html';
     }
     assert (type is TypeMirror);
     // Always get the generic type to strip off any type parameters or
     // arguments. If the type isn't generic, genericType returns `this`, so it
     // works for non-generic types too.
     return '${sanitize(displayName(type.library))}/'
            '${type.originalDeclaration.simpleName}.html';
   }
@@ skipping 16 matching lines @@
   String a(String href, String contents, [String css]) {
     // Mark outgoing external links, mainly so we can style them.
     final rel = isAbsolute(href) ? ' ref="external"' : '';
     final cssClass = css == null ? '' : ' class="$css"';
     return '<a href="${relativePath(href)}"$cssClass$rel>$contents</a>';
   }
 
   /**
    * Writes a type annotation for the given type and (optional) parameter name.
    */
-  annotateType(ObjectMirror enclosingType,
+  annotateType(ContainerMirror enclosingType,
                TypeMirror type,
                [String paramName = null]) {
     // Don't bother explicitly displaying Dynamic.
     if (type.isDynamic) {
       if (paramName !== null) write(paramName);
       return;
     }
 
     // For parameters, handle non-typedefed function types.
     if (paramName !== null && type is FunctionTypeMirror) {
       annotateType(enclosingType, type.returnType);
       write(paramName);
 
       docParamList(enclosingType, type.parameters);
       return;
     }
 
     linkToType(enclosingType, type);
 
     write(' ');
     if (paramName !== null) write(paramName);
   }
 
   /** Writes a link to a human-friendly string representation for a type. */
-  linkToType(ObjectMirror enclosingType, TypeMirror type) {
+  linkToType(ContainerMirror enclosingType, TypeMirror type) {
     if (type.isVoid) {
       // Do not generate links for void.
       // TODO(johnniwinter): Generate span for specific style?
       write('void');
       return;
     }
     if (type.isDynamic) {
       // Do not generate links for Dynamic.
       write('Dynamic');
       return;
@@ skipping 109 matching lines @@
     return classifySource(code);
   }
 
   /**
    * This will be called whenever a doc comment hits a `[name]` in square
    * brackets. It will try to figure out what the name refers to and link or
    * style it appropriately.
    */
   md.Node resolveNameReference(String name,
                                {MemberMirror currentMember,
-                                ObjectMirror currentType,
+                                ContainerMirror currentType,
                                 LibraryMirror currentLibrary}) {
     makeLink(String href) {
       final anchor = new md.Element.text('a', name);
       anchor.attributes['href'] = relativePath(href);
       anchor.attributes['class'] = 'crossref';
       return anchor;
     }
 
     // See if it's a parameter of the current method.
     if (currentMember is MethodMirror) {
       for (final parameter in currentMember.parameters) {
         if (parameter.simpleName == name) {
           final element = new md.Element.text('span', name);
           element.attributes['class'] = 'param';
           return element;
         }
       }
     }
 
     // See if it's another member of the current type.
     if (currentType != null) {
-      final foundMember = currentType.declaredMembers[name];
+      final foundMember = currentType.members[name];
       if (foundMember != null) {
         return makeLink(memberUrl(foundMember));
       }
     }
 
     // See if it's another type or a member of another type in the current
     // library.
     if (currentLibrary != null) {
       // See if it's a constructor
       final constructorLink = (() {
@@ skipping 11 matching lines @@
         return makeLink(memberUrl(constructor));
       })();
       if (constructorLink != null) return constructorLink;
 
       // See if it's a member of another type
       final foreignMemberLink = (() {
         final match = new RegExp(r'([\w$]+)\.([\w$]+)').firstMatch(name);
         if (match == null) return;
         ClassMirror foundtype = currentLibrary.classes[match[1]];
         if (foundtype == null) return;
-        MemberMirror foundMember = foundtype.declaredMembers[match[2]];
+        MemberMirror foundMember = foundtype.members[match[2]];
         if (foundMember == null) return;
         return makeLink(memberUrl(foundMember));
       })();
       if (foreignMemberLink != null) return foreignMemberLink;
 
       ClassMirror foundType = currentLibrary.classes[name];
       if (foundType != null) {
         return makeLink(typeUrl(foundType));
       }
 
       // See if it's a top-level member in the current library.
-      MemberMirror foundMember = currentLibrary.declaredMembers[name];
+      MemberMirror foundMember = currentLibrary.members[name];
       if (foundMember != null) {
         return makeLink(memberUrl(foundMember));
       }
     }
 
     // TODO(rnystrom): Should also consider:
     // * Names imported by libraries this library imports.
     // * Type parameters of the enclosing type.
 
     return new md.Element.text('code', name);
@@ skipping 60 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;
 }