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

lib/dartdoc/mirrors/dart2js_mirror.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.
 
 #library('mirrors.dart2js');
 
 #import('../../compiler/compiler.dart', prefix: 'diagnostics');
 #import('../../compiler/implementation/elements/elements.dart');
 #import('../../compiler/implementation/apiimpl.dart', prefix: 'api');
 #import('../../compiler/implementation/scanner/scannerlib.dart');
@@ skipping 87 matching lines @@
 
 MethodMirror _convertElementMethodToMethodMirror(Dart2jsObjectMirror library,
                                                  Element element) {
   if (element is FunctionElement) {
     return new Dart2jsMethodMirror(library, element);
   } else {
     return null;
   }
 }
 
 class Dart2jsMethodKind {

[kasperl, 2012/07/06 12:40:41]

In general, I think I'd prefer calling these Dart2JsXxx (Js rather than js).

[Johnni Winther, 2012/07/09 14:57:18]

Done.

   static final Dart2jsMethodKind NORMAL = const Dart2jsMethodKind("normal");
   static final Dart2jsMethodKind CONSTRUCTOR
       = const Dart2jsMethodKind("constructor");
   static final Dart2jsMethodKind CONST = const Dart2jsMethodKind("const");
   static final Dart2jsMethodKind FACTORY = const Dart2jsMethodKind("factory");
   static final Dart2jsMethodKind GETTER = const Dart2jsMethodKind("getter");
   static final Dart2jsMethodKind SETTER = const Dart2jsMethodKind("setter");
   static final Dart2jsMethodKind OPERATOR = const Dart2jsMethodKind("operator");
 
   final String text;
@@ skipping 44 matching lines @@
   void cancel([String reason, node, token, instruction, element]) {
     print(reason);
   }
 
   void log(message) {
     print(message);
   }
 }
 
 //------------------------------------------------------------------------------
+// Compiler extension for apidoc

[kasperl, 2012/07/06 12:40:41]

Terminate comment with .

[Johnni Winther, 2012/07/09 14:57:18]

Done.

+//------------------------------------------------------------------------------
+
+/**
+ * Extension of the compiler that enables the analysis of several libraries with
+ * no particular entry point.
+ */
+class LibraryCompiler extends api.Compiler {
+  LibraryCompiler(diagnostics.ReadStringFromUri provider,
+                  diagnostics.DiagnosticHandler handler,
+                  Uri libraryRoot, Uri packageRoot,
+                  List<String> options)
+      : super(provider, handler, libraryRoot, packageRoot, options) {
+    checker = new LibraryTypeCheckerTask(this);
+    resolver = new LibraryResolverTask(this);
+  }
+
+  // TODO(johnniwinther): The following methods are added to enable the analysis
+  // of a collection of libraries to be used for apidoc. Most of the methods
+  // are based on copies of existing methods and could probably be implemented
+  // such that the duplicate code is avoided. Not to affect the correctness and
+  // speed of dart2js as is, the redundancy is accepted temporarily.
+
+  /**
+   * Run the compiler on a list of libraries. No entry point is used.
+   */
+  bool runList(List<Uri> uriList) {
+    bool success = _runList(uriList);
+    for (final task in tasks) {
+      log('${task.name} took ${task.timing}msec');
+    }
+    return success;
+  }
+
+  bool _runList(List<Uri> uriList) {
+    try {
+      runCompilerList(uriList);
+    } catch (CompilerCancelledException exception) {
+      log(exception.toString());
+      log('compilation failed');
+      return false;
+    }
+    tracer.close();
+    log('compilation succeeded');
+    return true;
+  }
+
+  void runCompilerList(List<Uri> uriList) {
+    scanBuiltinLibraries();
+    var elementList = <LibraryElement>[];
+    for (var uri in uriList) {
+      elementList.add(scanner.loadLibrary(uri, null));
+    }
+
+    world.populate(this, libraries.getValues());
+
+    log('Resolving...');
+    phase = Compiler.PHASE_RESOLVING;
+    backend.enqueueHelpers(enqueuer.resolution);
+    processQueueList(enqueuer.resolution, elementList);
+    log('Resolved ${enqueuer.resolution.resolvedElements.length} elements.');
+  }
+
+  void processQueueList(Enqueuer world, List<LibraryElement> elements) {
+    backend.processNativeClasses(world, libraries.getValues());
+    for (var library in elements) {
+      library.elements.forEach((_, element) {
+        world.addToWorkList(element);
+      });
+    }
+    progress.reset();
+    world.forEach((WorkItem work) {
+      withCurrentElement(work.element, () => work.run(this, world));
+    });
+    //world.queueIsClosed = true;
+    assert(world.checkNoEnqueuedInvokedInstanceMethods());
+    world.registerFieldClosureInvocations();
+  }
+
+  String codegen(WorkItem work, Enqueuer world) {
+    return null;
+  }
+}
+
+// TODO(johnniwinther): The source for the apidoc includes calls to methods on
+// for instance [MathPrimitives] which are not resolved by dart2js. Since we
+// do not need to analyse the body of functions to produce the documenation
+// we use a specialized resolver which bypasses method bodies.

[Lasse Reichstein Nielsen, 2012/07/09 10:39:33]

Good choice. I expect to see MathNatives go away fairly soon.

+class LibraryResolverTask extends ResolverTask {
+  LibraryResolverTask(api.Compiler compiler) : super(compiler);
+
+  void visitBody(ResolverVisitor visitor, Statement body) {}
+}
+
+// TODO(johnniwinther): As a side-effect of bypassing method bodies in
+// [LibraryResolveTask] we can not perform the typecheck.
+class LibraryTypeCheckerTask extends TypeCheckerTask {
+  LibraryTypeCheckerTask(api.Compiler compiler) : super(compiler);
+
+  void check(Node tree, TreeElements elements) {}
+}
+
+//------------------------------------------------------------------------------
 // Compilation implementation
 //------------------------------------------------------------------------------
 
 class Dart2jsCompilation implements Compilation {
   api.Compiler _compiler;
   Uri cwd;
   bool isAborting = false;
   Map<String, SourceFile> sourceFiles;
 
   Future<String> provider(Uri uri) {
@@ skipping 40 matching lines @@
     } else {
       packageUri = libraryUri;
     }
     _compiler = new api.Compiler(provider, handler,
         libraryUri, packageUri, <String>[]);
     var scriptUri = cwd.resolve(nativeToUriPath(script));
     // TODO(johnniwinther): Detect file not found
     _compiler.run(scriptUri);
   }
 
+  Dart2jsCompilation.library(List<String> libraries, String libraryRoot,
+                     [String packageRoot, List<String> opts = const []])
+      : cwd = getCurrentDirectory(),
+        sourceFiles = <SourceFile>{}
+  {

[Lasse Reichstein Nielsen, 2012/07/09 10:39:33]

Brace on previous line.

[Johnni Winther, 2012/07/09 14:57:18]

Done.

+    var libraryUri = cwd.resolve(nativeToUriPath(libraryRoot));
+    var packageUri;
+    if (packageRoot !== null) {
+      packageUri = cwd.resolve(nativeToUriPath(packageRoot));
+    } else {
+      packageUri = libraryUri;
+    }
+    _compiler = new LibraryCompiler(provider, handler,
+        libraryUri, packageUri, <String>[]);
+    var librariesUri = <Uri>[];
+    for (var library in libraries) {
+      librariesUri.add(cwd.resolve(nativeToUriPath(library)));
+      // TODO(johnniwinther): Detect file not found
+    }
+    _compiler.runList(librariesUri);
+  }
+
   void addLibrary(String path) {
     var uri = cwd.resolve(nativeToUriPath(path));
     _compiler.scanner.loadLibrary(uri, null);
   }
 
   MirrorSystem mirrors() => new Dart2jsMirrorSystem(_compiler);
 }
 
 
 //------------------------------------------------------------------------------
@@ skipping 25 matching lines @@
     assert (_element !== null);
   }
 
   String simpleName() => _element.name.slowToString();
 
   Location location() => new Dart2jsLocation(
       _element.getCompilationUnit().script,
       system.compiler.spanFromElement(_element));
 
   String toString() => _element.toString();
+
+  int hashCode() => qualifiedName().hashCode();
 }
 
 abstract class Dart2jsProxyMirror implements Dart2jsMirror {
   final Dart2jsMirrorSystem system;
 
   Dart2jsProxyMirror(this.system);
+
+  int hashCode() => qualifiedName().hashCode();
 }
 
 ///////////////////////////////////////////////////////
 // implementation
 ///////////////////////////////////////////////////////
 
 class Dart2jsMirrorSystem implements MirrorSystem, Dart2jsMirror {
   final api.Compiler compiler;
   Map<String, Dart2jsLibraryMirror> _libraries;
   Map<LibraryElement, Dart2jsLibraryMirror> _libraryMap;
@@ skipping 20 matching lines @@
   Dart2jsLibraryMirror getLibrary(LibraryElement element) {
     return _libraryMap[element];
   }
 
   Dart2jsMirrorSystem get system() => this;
 
   String simpleName() => "mirror";
   String qualifiedName() => simpleName();
 
   String get canonicalName() => simpleName();
+
+  // TODO(johnniwinther): Hack! Dart2jsMirrorSystem need not be a Mirror.
+  int hashCode() => qualifiedName().hashCode();
 }
 
 abstract class Dart2jsObjectMirror extends Dart2jsElementMirror
     implements ObjectMirror {
   Dart2jsObjectMirror(Dart2jsMirrorSystem system, Element element)
       : super(system, element);
 }
 
 class Dart2jsLibraryMirror extends Dart2jsObjectMirror
     implements LibraryMirror {
   Map<String, InterfaceMirror> _types;
   Map<String, MemberMirror> _members;
 
   Dart2jsLibraryMirror(Dart2jsMirrorSystem system, LibraryElement library)
       : super(system, library);
 
   LibraryElement get _library() => _element;
 
+  LibraryMirror library() => this;
+
   String get canonicalName() => simpleName();
 
   /**
    * Returns the library name (for libraries with a #library tag) or the script
    * file name (for scripts without a #library tag). The latter case is used to
    * provide a 'library name' for scripts, to use for instance in dartdoc.
    */
   String simpleName() {
     if (_library.libraryTag !== null) {
       return _library.libraryTag.argument.dartString.slowToString();
@@ skipping 827 matching lines @@
     if (node !== null) {
       var span = system.compiler.spanFromNode(node, script.uri);
       return new Dart2jsLocation(script, span);
     } else {
       var span = system.compiler.spanFromElement(_variable);
       return new Dart2jsLocation(script, span);
     }
   }
 }