Big merge from experimental to bleeding edge.

sdk/lib/_internal/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;
 
+import 'dart:async';
 import 'dart:io';
 import 'dart:math';
 import 'dart:uri';
-import 'dart:json';
+import 'dart:json' as json;
 
 import '../../compiler/implementation/mirrors/mirrors.dart';
 import '../../compiler/implementation/mirrors/mirrors_util.dart';
 import '../../compiler/implementation/mirrors/dart2js_mirror.dart' as dart2js;
 import 'classify.dart';
 import 'universe_serializer.dart';
 import 'markdown.dart' as md;
 import 'src/json_serializer.dart' as json_serializer;
 import '../../compiler/implementation/scanner/scannerlib.dart' as dart2js;
 import '../../libraries.dart';
@@ skipping 100 matching lines @@
       'lib/_internal/dartdoc/lib/src/client/client-$clientScript.dart');
   var jsPath = outputDir.append('client-$clientScript.js');
 
   var completer = new Completer<bool>();
   var compilation = new Compilation(dartPath, libPath);
   Future<String> result = compilation.compileToJavaScript();
   result.then((jsCode) {
     writeString(new File.fromPath(jsPath), jsCode);
     completer.complete(true);
   });
-  result.handleException((e) => completer.completeException(e));
+  result.catchError((e) => completer.completeError(e.error, e.stackTrace));
   return completer.future;
 }
 
 class Dartdoc {
 
   /** Set to `false` to not include the source code in the generated docs. */
   bool includeSource = true;
 
   /**
    * Dartdoc can generate docs in a few different ways based on how dynamic you
@@ skipping 175 matching lines @@
   }
 
   void documentLibraries(List<Path> libraryList, Path libPath, Path pkgPath) {
     final compilation = new Compilation.library(libraryList, libPath, pkgPath);
     _document(compilation);
   }
 
   void _document(Compilation compilation) {
     // Sort the libraries by name (not key).
     _sortedLibraries = new List<LibraryMirror>.from(
-        compilation.mirrors.libraries.values.filter(
-            shouldIncludeLibrary));
+        compilation.mirrors.libraries.values.where(shouldIncludeLibrary));
     _sortedLibraries.sort((x, y) {
       return displayName(x).toUpperCase().compareTo(
           displayName(y).toUpperCase());
     });
 
     // Generate the docs.
     if (mode == MODE_LIVE_NAV) {
       docNavigationJson();
     } else {
       docNavigationDart();
     }
 
     docIndex();
     for (final library in _sortedLibraries) {
       docLibrary(library);
     }
 
     if (generateAppCache) {
       generateAppCacheManifest();
     }
 
     startFile("apidoc.json");
-    var libraries = _sortedLibraries.map(
-        (lib) => new LibraryElement(lib.qualifiedName, lib, _comments));
+    var libraries = _sortedLibraries.mappedBy(
+        (lib) => new LibraryElement(lib.qualifiedName, lib, _comments))
+        .toList();
     write(json_serializer.serialize(libraries));
     endFile();
   }
 
   void startFile(String path) {
     _filePath = new Path(path);
     _file = new StringBuffer();
   }
 
   void endFile() {
@@ skipping 162 matching lines @@
   void docIndexLibrary(LibraryMirror library) {
     writeln('<h4>${a(libraryUrl(library), displayName(library))}</h4>');
   }
 
   /**
    * Walks the libraries and creates a JSON object containing the data needed
    * to generate navigation for them.
    */
   void docNavigationJson() {
     startFile('nav.json');
-    writeln(JSON.stringify(createNavigationInfo()));
+    writeln(json.stringify(createNavigationInfo()));
     endFile();
   }
 
   void docNavigationDart() {
     final dir = new Directory.fromPath(tmpPath);
     if (!dir.existsSync()) {
       // TODO(3914): Hack to avoid 'file already exists' exception
       // thrown due to invalid result from dir.existsSync() (probably due to
       // race conditions).
       try {
         dir.createSync();
       } on DirectoryIOException catch (e) {
         // Ignore.
       }
     }
-    String jsonString = JSON.stringify(createNavigationInfo());
+    String jsonString = json.stringify(createNavigationInfo());
     String dartString = jsonString.replaceAll(r"$", r"\$");
     final filePath = tmpPath.append('nav.dart');
     writeString(new File.fromPath(filePath),
         'get json => $dartString;');
   }
 
   Path get tmpPath => dartdocPath.append('tmp');
 
   void cleanup() {
     final dir = new Directory.fromPath(tmpPath);
@@ skipping 323 matching lines @@
   void docInheritance(ClassMirror type) {
     // Don't show the inheritance details for Object. It doesn't have any base
     // class (obviously) and it has too many subclasses to be useful.
     if (type.isObject) return;
 
     // Writes an unordered list of references to types with an optional header.
     listTypes(types, header) {
       if (types == null) return;
 
       // Filter out injected types. (JavaScriptIndexingBehavior)
-      types = new List.from(types.filter((t) => t.library != null));
+      types = new List.from(types.where((t) => t.library != null));
 
       var publicTypes;
       if (showPrivate) {
         publicTypes = types;
       } else {
         // Skip private types.
-        publicTypes = new List.from(types.filter((t) => !t.isPrivate));
+        publicTypes = new List.from(types.where((t) => !t.isPrivate));
       }
       if (publicTypes.length == 0) return;
 
       writeln('<h3>$header</h3>');
       writeln('<p>');
       bool first = true;
       for (final t in publicTypes) {
         if (!first) write(', ');
         typeSpan(t);
         first = false;
@@ skipping 278 matching lines @@
           }
         } else {
           // Document as field.
           docProperty(host, getter, setter);
         }
       }
     }
     writeln('</div>');
   }
 
-  void docMethods(ContainerMirror host, String title, List<MethodMirror> methods,
+  void docMethods(ContainerMirror host, String title, List<Mirror> methods,
                   {bool allInherited}) {
     if (methods.length > 0) {
       writeln('<div${allInherited ? ' class="inherited"' : ''}>');
       writeln('<h3>$title</h3>');
-      for (final method in methods) {
+      for (MethodMirror 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
@@ skipping 435 matching lines @@
     // TODO(rnystrom): Do we need to handle ParameterTypes here like
     // annotation() does?
     return a(typeUrl(type), typeName(type), 'crossref');
   }
 
   /** Generates a human-friendly string representation for a type. */
   typeName(TypeMirror type, {bool showBounds: false}) {
     if (type.isVoid) {
       return 'void';
     }
+    if (type.isDynamic) {
+      return 'dynamic';
+    }
     if (type is TypeVariableMirror) {
       return type.simpleName;
     }
     assert(type is ClassMirror);
 
     // See if it's a generic type.
     if (type.isOriginalDeclaration) {
       final typeParams = [];
       for (final typeParam in type.originalDeclaration.typeVariables) {
         if (showBounds &&
             (typeParam.upperBound != null) &&
             !typeParam.upperBound.isObject) {
           final bound = typeName(typeParam.upperBound, 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)), ', ');
+      final args =
+          Strings.join(typeArgs.mappedBy((arg) => typeName(arg)), ', ');
       return '${type.originalDeclaration.simpleName}&lt;$args&gt;';
     }
 
     // Regular type.
     return type.simpleName;
   }
 
   /**
    * Remove leading indentation to line up with first line.
    */
@@ skipping 167 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;
 }