Compute function types together with the parameters.

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 482 matching lines @@
     // the compilation unit of the abstract element.
     if (getter !== null && getter.enclosingElement === enclosingElement) {
       return getter.position();
     } else if (setter != null) {
       // TODO(ahe): checking for null should not be necessary.
       return setter.position();
     }
   }
 }
 
-class FunctionParameters {
+class FunctionSignature {
   Link<Element> requiredParameters;
   Link<Element> optionalParameters;
+  Link<Type> parameterTypes;

[ngeoffray, 2012/05/07 08:36:09]

As discussed, we can avoid having this Link object being created. The creation
of the function type can just run through the two Link<Element> declared above.

[karlklose, 2012/05/07 09:08:29]

Done.

+  Type returnType;
   int requiredParameterCount;
   int optionalParameterCount;
-  FunctionParameters(this.requiredParameters,
-                     this.optionalParameters,
-                     this.requiredParameterCount,
-                     this.optionalParameterCount);
+  FunctionSignature(this.requiredParameters,
+                    this.optionalParameters,
+                    this.requiredParameterCount,
+                    this.optionalParameterCount,
+                    this.parameterTypes,
+                    this.returnType);
 
   void forEachParameter(void function(Element parameter)) {
     for (Link<Element> link = requiredParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
     for (Link<Element> link = optionalParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
   }
 
   int get parameterCount() => requiredParameterCount + optionalParameterCount;
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
 
-  FunctionParameters functionParameters;
+  FunctionSignature functionSignature;
 
   /**
    * If this is an interface constructor, [defaultImplementation] will
    * changed by the resolver to point to the default
    * implementation. Otherwise, [:defaultImplementation === this:].
    */
   FunctionElement defaultImplementation;
 
   FunctionElement(SourceString name,
                   ElementKind kind,
                   Modifiers modifiers,
                   Element enclosing)
     : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
                        ElementKind kind,
                        Modifiers modifiers,
                        Element enclosing)
     : this.tooMuchOverloading(name, node, kind, modifiers, enclosing, null);
 
   FunctionElement.from(SourceString name,
                        FunctionElement other,
                        Element enclosing)
     : this.tooMuchOverloading(name, other.cachedNode, other.kind,
                               other.modifiers, enclosing,
-                              other.functionParameters);
+                              other.functionSignature);
 
   FunctionElement.tooMuchOverloading(SourceString name,
                                      FunctionExpression this.cachedNode,
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
-                                     FunctionParameters this.functionParameters)
+                                     FunctionSignature this.functionSignature)
     : super(name, kind, enclosing)
   {
     defaultImplementation = this;
   }
 
   bool isInstanceMember() {
     return isMember()
            && kind != ElementKind.GENERATIVE_CONSTRUCTOR
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
-  FunctionParameters computeParameters(Compiler compiler) {
-    if (functionParameters !== null) return functionParameters;
-    functionParameters = compiler.resolveSignature(this);
-    return functionParameters;
+  FunctionSignature computeSignature(Compiler compiler) {
+    if (functionSignature !== null) return functionSignature;
+    compiler.withCurrentElement(this, () {
+      functionSignature = compiler.resolveSignature(this);
+    });
+    return functionSignature;
   }
 
   int requiredParameterCount(Compiler compiler) {
-    return computeParameters(compiler).requiredParameterCount;
+    return computeSignature(compiler).requiredParameterCount;
   }
 
   int optionalParameterCount(Compiler compiler) {
-    return computeParameters(compiler).optionalParameterCount;
+    return computeSignature(compiler).optionalParameterCount;
   }
 
   int parameterCount(Compiler compiler) {
-    return computeParameters(compiler).parameterCount;
+    return computeSignature(compiler).parameterCount;
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
-    return compiler.withCurrentElement(this, () {
-      FunctionParameters parameters = computeParameters(compiler);
-      Types types = compiler.types;
-      FunctionExpression node =
-          compiler.parser.measure(() => parseNode(compiler));
-      Type returnType = compiler.resolveTypeAnnotation(this, node.returnType);
-
-      LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
-      for (Link<Element> link = parameters.requiredParameters;
-           !link.isEmpty();
-           link = link.tail) {
-        parameterTypes.addLast(link.head.computeType(compiler));
-      }
-      type = new FunctionType(returnType, parameterTypes.toLink(), this);
-      return type;
-    });
+    FunctionSignature signature = computeSignature(compiler);
+    // TODO(karlklose): optional parameters.
+    type = new FunctionType(signature.returnType,
+                            signature.parameterTypes,
+                            this);
+    return type;
   }
 
   Node parseNode(DiagnosticListener listener) => cachedNode;
 
   Token position() => cachedNode.getBeginToken();
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               null,
               constructor.enclosingElement) {
-    functionParameters = constructor.functionParameters;
+    functionSignature = constructor.functionSignature;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) { unreachable(); }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode !== null);
@@ skipping 377 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()}";
 }