Implement named constructors and resolving of redirecting constructors and super-initializers.

frog/leg/elements/elements.dart

 // Copyright (c) 2011, 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 191 matching lines @@
     return element.computeType(compiler);
   }
   return types.lookup(name);
 }
 
 class FunctionElement extends Element {
   Link<Element> parameters;
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
+  int cachedParameterCount;
 
   FunctionElement(SourceString name,
                   ElementKind kind,
                   Modifiers this.modifiers,
                   Element enclosing,
                   [Node node])
     : super(name, kind, enclosing), cachedNode = node;
-  FunctionElement.node(FunctionExpression node,
+  FunctionElement.node(SourceString name,
+                       FunctionExpression node,
                        ElementKind kind,
                        Modifiers this.modifiers,
                        Element enclosing)
-    : super(node.name.asIdentifier().source, kind, enclosing),
+    : super(name, kind, enclosing),
       this.cachedNode = node;
 
   bool isInstanceMember() {
     return isMember()
            && kind != ElementKind.GENERATIVE_CONSTRUCTOR
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
+  int parameterCount(Compiler compiler) {
+    if (cachedParameterCount === null) {
+      cachedParameterCount = 0;
+      if (parameters == null) compiler.resolveSignature(this);
+      for (Link l = parameters; !l.isEmpty(); l = l.tail) {
+        cachedParameterCount++;
+      }
+    }
+    return cachedParameterCount;
+  }
+
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     if (parameters == null) compiler.resolveSignature(this);
     Types types = compiler.types;
     FunctionExpression node =
         compiler.parser.measure(() => parseNode(compiler, compiler));
     Type returnType = getType(node.returnType, compiler, types);
     if (returnType === null) returnType = types.dynamicType;
 
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
@@ skipping 53 matching lines @@
         new Block(new NodeList.empty()),
         null, null, null);
     return cachedNode;
   }
 }
 
 class ClassElement extends Element {
   Type type;
   Type supertype;
   Link<Element> members = const EmptyLink<Element>();
+  Map<SourceString, Element> localMembers;
+  Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
   bool isResolved = false;
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
   SynthesizedConstructorElement synthesizedConstructor;
 
   ClassElement(SourceString name, CompilationUnitElement enclosing)
-    : super(name, ElementKind.CLASS, enclosing);
+    : localMembers = new Map<SourceString, Element>(),
+      constructors = new Map<SourceString, Element>(),
+      super(name, ElementKind.CLASS, enclosing);
 
   void addMember(Element element) {
     members = members.prepend(element);
+    if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
+        element.modifiers.isFactory()) {
+      constructors[element.name] = element;
+    } else {
+      localMembers[element.name] = element;
+    }
   }
 
   Type computeType(compiler) {
     if (type === null) {
       type = new SimpleType(name, this);
     }
     return type;
   }
 
   ClassElement resolve(Compiler compiler) {
     if (!isResolved) {
       compiler.resolveType(this);
       isResolved = true;
     }
     return this;
   }
 
-  Element lookupLocalElement(SourceString name, bool matches(Element)) {
-    // TODO(karlklose): replace with more efficient solution.
-    for (Link<Element> link = members;
-         link !== null && !link.isEmpty();
-         link = link.tail) {
-      Element element = link.head;
-      if (matches(element)) return element;
-    }
-    return null;
+  Element lookupLocalMember(SourceString name) {
+    return localMembers[name];
   }
 
-  Element lookupLocalMember(SourceString name) {
-    bool matches(Element element) {
-      return element.name == name
-             && element.kind != ElementKind.GENERATIVE_CONSTRUCTOR;
+  Element lookupConstructor(SourceString className,
+                            [SourceString constructor = const SourceString(''),

[ngeoffray, 2012/01/20 13:54:17]

constructor -> constructorName?

[karlklose, 2012/01/20 14:11:36]

Done.

+                            Element noMatch(Element)]) {
+    // TODO(karlklose): have a map from class names to a map of constructors
+    //                  instead of creating the name here?
+    SourceString name;
+    if (constructor !== const SourceString('')) {
+      name = new SourceString('$className.$constructor');
+    } else {
+      name = className;
     }
-    return lookupLocalElement(name, matches);
+    Element result = constructors[name];
+    if (result === null && noMatch !== null) {
+      result = noMatch(lookupLocalMember(name));

[ngeoffray, 2012/01/20 13:54:17]

Shouldn't you check for constructorName if it is not the unnamed constructor?

[karlklose, 2012/01/20 14:11:36]

Done.

+    }
+    return result;
   }
 
-  Element lookupConstructor(SourceString name) {
-    bool matches(Element element) {
-      return element.name == name
-             && (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR
-                 || element.modifiers.isFactory());
-    }
-    return lookupLocalElement(name, matches);
-  }
-
-  // TODO(ngeoffray): Implement these.
-  bool canHaveDefaultConstructor() => true;
+  bool canHaveDefaultConstructor() => constructors.length == 0;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
     }
     return synthesizedConstructor;
   }
 
   /**
    * Returns the super class, if any.
@@ skipping 29 matching lines @@
     if (send.isPropertyAccess) return false;
     if (send.receiver !== null) return false;
     Element element = elements[send];
     // (o)() or foo()().
     if (element === null && send.selector.asIdentifier() === null) return true;
     if (element === null) return false;
     // foo() with foo a local or a parameter.
     return element.isVariable() || element.isParameter();
   }
 }