Parameters with function types supported + Added features in mirrors implementation

lib/compiler/implementation/elements/elements.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('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 198 matching lines @@
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isMember() || e.isTopLevel()) {
         return e;
       }
     }
     return null;
   }
 
   String toString() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
-    // invariant for all element types.
+    // invariant for all element types?
+    var nameText = name !== null ? name.slowToString() : '?';
     if (enclosingElement !== null && !isTopLevel()) {
-      String holderName = enclosingElement.name.slowToString();
-      return '$kind($holderName#${name.slowToString()})';
+      String holderName = enclosingElement.name !== null
+          ? enclosingElement.name.slowToString()
+          : '${enclosingElement.kind}?';
+      return '$kind($holderName#${nameText})';
     } else {
-      return '$kind(${name.slowToString()})';
+      return '$kind(${nameText})';
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
 
   FunctionElement asFunctionElement() => null;
 }
 
@@ skipping 258 matching lines @@
 
 // This element represents a list of variable or field declaration.
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElement extends Element {
   VariableDefinitions cachedNode;
   Type type;
   final Modifiers modifiers;
 
+  /**
+   * Function signature for a variable with a function type. The signature is
+   * kept to provide full information about parameter names through the the
+   * mirror system.
+   */
+  FunctionSignature functionSignature;

[ahe, 2012/08/02 19:20:25]

We plan to turn this into a type, right?

+
   VariableListElement(ElementKind kind,
                       Modifiers this.modifiers,
                       Element enclosing)
     : super(null, kind, enclosing);
 
   VariableListElement.node(VariableDefinitions node,
                            ElementKind kind,
                            Element enclosing)
     : super(null, kind, enclosing),
       this.cachedNode = node,
       this.modifiers = node.modifiers;
 
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
   Type computeType(Compiler compiler) {
     if (type != null) return type;
-    type = compiler.resolveTypeAnnotation(this, parseNode(compiler).type);
+    VariableDefinitions node = parseNode(compiler);
+    if (node.type !== null) {
+      type = compiler.resolveTypeAnnotation(this, node.type);
+    } else {

[ahe, 2012/08/02 19:20:25]

We are already changing this, right? This looks scary and a potential for
infinite recursion.

+      // Is node.definitions exactly one FunctionExpression?
+      Link<Node> link = node.definitions.nodes;
+      if (!link.isEmpty() &&
+          link.head.asFunctionExpression() !== null &&
+          link.tail.isEmpty()) {
+        FunctionExpression functionExpression = link.head;
+        // We found exactly one FunctionExpression
+        compiler.withCurrentElement(this, () {
+          functionSignature =
+              compiler.resolveFunctionExpression(this, functionExpression);
+        });
+        type = compiler.computeFunctionType(compiler.functionClass,
+                                            functionSignature);
+      } else {
+        type = compiler.types.dynamicType;
+      }
+    }
+    assert(type != null);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name, ContainerElement enclosingElement)
     : super(name, ElementKind.FOREIGN, enclosingElement);
 
@@ skipping 620 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }