Dartdoc and Apidoc updated to use dart2js through the mirror system.

tests/compiler/dart2js/mirrors_test.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.
 
 #import("../../../lib/dartdoc/mirrors/mirrors.dart");
 #import("../../../lib/dartdoc/mirrors/mirrors_util.dart");
 
 #import('dart:io');
 
 int count(Iterable iterable) {
@@ skipping 81 matching lines @@
 
   Expect.isTrue(fooClass.isClass, "Class is not class");
   Expect.isFalse(fooClass.isInterface, "Class is interface");
   Expect.isFalse(fooClass.isPrivate, "Class is private");
 
   var objectType = fooClass.superclass();
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(fooClass,
-                             computeSubdeclarations(system, objectType)),
+                             computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var fooInterfaces = fooClass.interfaces();
   Expect.isNotNull(fooInterfaces, "Interfaces map is null");
   Expect.isTrue(fooInterfaces.isEmpty(), "Interfaces map is not empty");
 
-  var fooSubdeclarations = computeSubdeclarations(system, fooClass);
+  var fooSubdeclarations = computeSubdeclarations(fooClass);
   Expect.equals(1, count(fooSubdeclarations), "Unexpected subtype count");
   for (var fooSubdeclaration in fooSubdeclarations) {
     Expect.equals(fooClass, fooSubdeclaration.superclass().declaration,
                   "Class is not superclass of subclass");
   }
 
   Expect.throws(() => fooClass.typeArguments(),
                 (exception) => true,
                 "Class has type arguments");
   var fooClassTypeVariables = fooClass.typeVariables();
@@ skipping 45 matching lines @@
 
   Expect.isFalse(barInterface.isClass, "Interface is class");
   Expect.isTrue(barInterface.isInterface, "Interface is not interface");
   Expect.isFalse(barInterface.isPrivate, "Interface is private");
 
   var objectType = barInterface.superclass();
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(barInterface,
-                             computeSubdeclarations(system, objectType)),
+                             computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var barInterfaces = barInterface.interfaces();
   Expect.isNotNull(barInterfaces, "Interfaces map is null");
   Expect.isTrue(barInterfaces.isEmpty(), "Interfaces map is not empty");
 
-  var barSubdeclarations = computeSubdeclarations(system, barInterface);
+  var barSubdeclarations = computeSubdeclarations(barInterface);
   Expect.equals(1, count(barSubdeclarations), "Unexpected subtype count");
   for (var barSubdeclaration in barSubdeclarations) {
     Expect.isTrue(containsType(barInterface,
                                barSubdeclaration.interfaces().getValues()),
                   "Interface is not superinterface of subclass");
   }
 
   Expect.throws(() => barInterface.typeArguments(),
               (exception) => true,
               "Interface has type arguments");
@@ skipping 62 matching lines @@
 
   Expect.isTrue(bazClass.isClass, "Class is not class");
   Expect.isFalse(bazClass.isInterface, "Class is interface");
   Expect.isFalse(bazClass.isPrivate, "Class is private");
 
   var objectType = bazClass.superclass();
   Expect.isNotNull(objectType, "Superclass is null");
   Expect.isTrue(objectType.isObject, "Object is not Object");
   Expect.isFalse(objectType.isDeclaration, "Object type is declaration");
   Expect.isTrue(containsType(bazClass,
-                             computeSubdeclarations(system, objectType)),
+                             computeSubdeclarations(objectType)),
                 "Class is not subclass of superclass");
 
   var bazInterfaces = bazClass.interfaces();
   Expect.isNotNull(bazInterfaces, "Interfaces map is null");
   Expect.isTrue(!bazInterfaces.isEmpty(), "Interfaces map is empty");
   for (var bazInterface in bazInterfaces.getValues()) {
     Expect.isTrue(containsType(bazClass,
-                               computeSubdeclarations(system, objectType)),
+                               computeSubdeclarations(objectType)),
                   "Class is not subclass of superinterface");
   }
 
-  var bazSubdeclarations = computeSubdeclarations(system, bazClass);
+  var bazSubdeclarations = computeSubdeclarations(bazClass);
   Expect.equals(0, count(bazSubdeclarations), "Unexpected subtype count");
 
   var barInterface = findMirror(bazInterfaces, "Bar");
   Expect.isNotNull(barInterface, "Interface bar is missing");
   Expect.isFalse(barInterface.isDeclaration, "Interface type is declaration");
   var barInterfaceTypeArguments = barInterface.typeArguments();
   Expect.isNotNull(barInterfaceTypeArguments, "Type arguments are missing");
   // TODO(johnniwinther): Ensure type arguments on supertypes. Expected result
   // should have been 1:
   Expect.equals(0, barInterfaceTypeArguments.length,
@@ skipping 326 matching lines @@
   Expect.stringEquals('negate', operator_negate.operatorName,
                       "Unexpected operatorName");
 
 
   var bazClassConstructors = bazClass.constructors();
   Expect.isNotNull(bazClassConstructors, "Constructors map is null");
   Expect.equals(3, bazClassConstructors.length,
                 "Unexpected number of constructors");
   // TODO(johnniwinther): Add tests of constructors.
 }