Cleanup run on DartDoc from Dart Editor.

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
  *
  * This will create a "docs" directory with the docs for your libraries. To
  * create these beautiful docs, dartdoc parses your library and every library
  * it imports (recursively). From each library, it parses all classes and
  * members, finds the associated doc comments and builds crosslinked docs from
  * them.
  */
-#library('dartdoc');
+library dartdoc;
 
-#import('dart:io');
-#import('dart:math');
-#import('dart:uri');
-#import('dart:json');
+import 'dart:io';
+import 'dart:math';
+import 'dart:uri';
+import 'dart:json';
 
 // TODO(rnystrom): Use "package:" URL (#4968).
-#import('mirrors.dart');
-#import('mirrors_util.dart');
-#import('src/mirrors/dart2js_mirror.dart', prefix: 'dart2js');
-#import('classify.dart');
-#import('markdown.dart', prefix: 'md');
-#import('../../../lib/compiler/implementation/scanner/scannerlib.dart',
-        prefix: 'dart2js');
-#import('../../../lib/_internal/libraries.dart');
+import 'mirrors.dart';
+import 'mirrors_util.dart';
+import 'src/mirrors/dart2js_mirror.dart' as dart2js;
+import 'classify.dart';
+import 'markdown.dart' as md;
+import '../../../lib/compiler/implementation/scanner/scannerlib.dart' as dart2js;
+import '../../../lib/_internal/libraries.dart';
 
 // TODO(rnystrom): Use "package:" URL (#4968).
-#source('src/dartdoc/comment_map.dart');
-#source('src/dartdoc/nav.dart');
-#source('src/dartdoc/utils.dart');
+part 'src/dartdoc/comment_map.dart';
+part 'src/dartdoc/nav.dart';
+part 'src/dartdoc/utils.dart';
 
 /**
  * Generates completely static HTML containing everything you need to browse
  * the docs. The only client side behavior is trivial stuff like syntax
  * highlighting code.
  */
 const MODE_STATIC = 0;
 
 /**
  * Generated docs do not include baked HTML navigation. Instead, a single
@@ skipping 996 matching lines @@
     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) {
           if (member.isStatic) return;
           if (!showPrivate && member.isPrivate) return;
 
           bool inherit = true;
-          if (type !== host) {
+          if (type != host) {
             if (member.isPrivate) {
               // Don't inherit private members.
               inherit = false;
             }
             if (member.isConstructor) {
               // Don't inherit constructors.
               inherit = false;
             }
           }
           if (!inherit) return;
@@ skipping 97 matching lines @@
           assert(getter is MethodMirror);
           docProperty(host, getter, null);
         }
       } else if (getter == null) {
         // We only have a setter => Document as a method.
         assert(setter is MethodMirror);
         docMethod(host, setter);
       } else {
         DocComment getterComment = getMemberComment(getter);
         DocComment setterComment = getMemberComment(setter);
-        if (getter.owner !== setter.owner ||
+        if (getter.owner != setter.owner ||
             getterComment != null && setterComment != null) {
           // Both have comments or are not declared in the same class
           // => Documents separately.
           if (getter is FieldMirror) {
             // Document field as a getter (setter is inherited).
             docField(host, getter, asGetter: true);
           } else {
             docMethod(host, getter);
           }
           if (setter is FieldMirror) {
@@ skipping 233 matching lines @@
 
       first = false;
     }
 
     if (inOptionals) write(']');
     write(')');
   }
 
   void docComment(ObjectMirror host, DocComment comment) {
     if (comment != null) {
-      if (comment.inheritedFrom !== 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 108 matching lines @@
 
   /** Gets the anchor id for the document for [member]. */
   String memberAnchor(MemberMirror member) {
     return member.simpleName;
   }
 
   /**
    * Creates a hyperlink. Handles turning the [href] into an appropriate
    * relative path from the current file.
    */
-  String a(String href, String contents, [String css]) {
+  String a(String href, String contents, {String css}) {

[gram, 2012/10/30 22:30:04]

Why use a named parameter here? Usually you would use named parameters where
there are several optional parameters and you don't want to make the user have
to provide all n-1 preceding ones just to specify the nth. I see no benefit here
to not leaving this as just optional.

[Andrei Mouravski, 2012/10/31 15:08:00]

Done.

     // 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,
                TypeMirror type,
                [String paramName = null]) {
     // Don't bother explicitly displaying Dynamic.
     if (type.isDynamic) {
-      if (paramName !== null) write(paramName);
+      if (paramName != null) write(paramName);
       return;
     }
 
     // For parameters, handle non-typedefed function types.
-    if (paramName !== null && type is FunctionTypeMirror) {
+    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);
+    if (paramName != null) write(paramName);
   }
 
   /** Writes a link to a human-friendly string representation for a type. */
   linkToType(ObjectMirror enclosingType, TypeMirror type) {
     if (type.isVoid) {
       // Do not generate links for void.
       // TODO(johnniwinter): Generate span for specific style?
       write('void');
       return;
     }
@@ skipping 260 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;
 }