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

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 121 matching lines @@
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver = new InitializerResolver(visitor);
         FunctionElement redirection =
             resolver.resolveInitializers(element, tree);
         if (redirection !== null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
       } else if (tree.initializers != null) {
         error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
       }
-      visitor.visit(tree.body);
+      visitBody(visitor, tree.body);
 
       // Resolve the type annotations encountered in the method.
       while (!toResolve.isEmpty()) {
         ClassElement classElement = toResolve.removeFirst();
         classElement.ensureResolved(compiler);
       }
       if (isConstructor) {
         constructorElements[element] = visitor.mapping;
       }
       return visitor.mapping;
     });
   }
 
+  void visitBody(ResolverVisitor visitor, Statement body) {
+    visitor.visit(body);
+  }
+
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
     if (constructor.defaultImplementation !== constructor) return;
     ClassElement intrface = constructor.enclosingElement;
     if (!intrface.isInterface()) return;
     Type defaultType = intrface.defaultClass;
     if (defaultType === null) {
       error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
     }
     ClassElement defaultClass = defaultType.element;
@@ skipping 1774 matching lines @@
   // The only valid [Send] can be in constructors and must be of the form
   // [:this.x:] (where [:x:] represents an instance field).
   FieldParameterElement visitSend(Send node) {
     FieldParameterElement element;
     if (node.receiver.asIdentifier() === null ||
         !node.receiver.asIdentifier().isThis()) {
       error(node, MessageKind.INVALID_PARAMETER, []);
     } else if (enclosingElement.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
       error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
     } else {
-      if (node.selector.asIdentifier() == null) {
-        cancel(node,
-               'internal error: unimplemented receiver on parameter send');
+      SourceString name;

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

Would it make sense to factor this code (the computation of name) out into a
separate function? 

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

For clarity only. I don't think the computation is needed elsewhere.

+      var identifier = node.selector.asIdentifier();
+      if (identifier !== null) {
+        // Normal parameter: [:Type name:].
+        name = identifier.source;
+      } else {
+        // Function type parameter: [:void name(Type arg):].
+        var functionExpression = node.selector.asFunctionExpression();
+        if (functionExpression !== null &&
+            functionExpression.name.asIdentifier() !== null) {
+          name = functionExpression.name.asIdentifier().source;
+        } else {
+          cancel(node,
+              'internal error: unimplemented receiver on parameter send');
+        }
       }
-      SourceString name = node.selector.asIdentifier().source;
       Element fieldElement = currentClass.lookupLocalMember(name);
       if (fieldElement === null || fieldElement.kind !== ElementKind.FIELD) {
         error(node, MessageKind.NOT_A_FIELD, [name]);
       } else if (!fieldElement.isInstanceMember()) {
         error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
       }
       Element variables = new VariableListElement.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
-      element = new FieldParameterElement(node.selector.asIdentifier().source,
+      element = new FieldParameterElement(name,
           fieldElement, variables, enclosingElement, node);
     }
     return element;
   }
 
   Element visitSendSet(SendSet node) {
     Element element;
     if (node.receiver != null) {
       element = visitSend(node);
     } else if (node.selector.asIdentifier() != null) {
@@ skipping 213 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }