Support factory methods.

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 11 matching lines @@
 class ElementKind {
   final String id;
 
   const ElementKind(String this.id);
 
   static final ElementKind VARIABLE = const ElementKind('variable');
   static final ElementKind PARAMETER = const ElementKind('parameter');
   static final ElementKind FUNCTION = const ElementKind('function');
   static final ElementKind CLASS = const ElementKind('class');
   static final ElementKind FOREIGN = const ElementKind('foreign');
-  static final ElementKind CONSTRUCTOR = const ElementKind('constructor');
+  static final ElementKind GENERATIVE_CONSTRUCTOR =
+      const ElementKind('generative_constructor');
   static final ElementKind FIELD = const ElementKind('field');
   static final ElementKind VARIABLE_LIST = const ElementKind('variable_list');
   static final ElementKind FIELD_LIST = const ElementKind('field_list');
-  static final ElementKind CONSTRUCTOR_BODY =
-      const ElementKind('constructor_body');
+  static final ElementKind GENERATIVE_CONSTRUCTOR_BODY =
+      const ElementKind('generative_constructor_body');
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   abstract Node parseNode(Canceler canceler, Logger logger);
   abstract Type computeType(Compiler compiler, Types types);
@@ skipping 113 matching lines @@
     : super(name, kind, enclosing);
   FunctionElement.node(FunctionExpression node,
                        ElementKind kind,
                        Modifiers this.modifiers,
                        Element enclosing)
     : super(node.name.asIdentifier().source, kind, enclosing),
       this.node = node;
 
   bool isInstanceMember() {
     return isMember()
-           && kind != ElementKind.CONSTRUCTOR
+           && kind != ElementKind.GENERATIVE_CONSTRUCTOR
+           && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
   FunctionType computeType(Compiler compiler, types) {
     if (type != null) return type;
     if (parameters == null) compiler.resolveSignature(this);
     FunctionExpression node =
         compiler.parser.measure(() => parseNode(compiler, compiler));
     Type returnType = getType(node.returnType, compiler, types);
-    if (returnType === null) compiler.cancel('unknown type ${node.returnType}');
+    if (returnType === null) returnType = types.dynamicType;
 
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
     for (Link<Element> link = parameters; !link.isEmpty(); link = link.tail) {
       parameterTypes.addLast(link.head.computeType(compiler, types));
     }
     type = new FunctionType(returnType, parameterTypes.toLink(), this);
     return type;
   }
 
   Node parseNode(Canceler canceler, Logger logger) => node;
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
-              ElementKind.CONSTRUCTOR_BODY,
+              ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               null,
               constructor.enclosingElement) {
     assert(constructor.node !== null);
     this.parameters = constructor.parameters;
     this.node = constructor.node;
     this.type = constructor.type;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler, types) { unreachable(); }
   Node parseNode(Canceler canceler, Logger logger) { unreachable(); }
 }
 
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
-    : super(enclosing.name, ElementKind.CONSTRUCTOR, null, enclosing) {
+    : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
+            null, enclosing) {
     parameters = const EmptyLink<Element>();
   }
 
   FunctionType computeType(Compiler compiler, types) {
     if (type != null) return type;
     type = new FunctionType(types.voidType, const EmptyLink<Type>(), this);
     return type;
   }
 
   Node parseNode(Canceler canceler, Logger logger) {
@@ skipping 47 matching lines @@
          link = link.tail) {
       Element element = link.head;
       if (matches(element)) return element;
     }
     return null;
   }
 
   Element lookupLocalMember(SourceString name) {
     bool matches(Element element) {
       return element.name == name
-             && element.kind != ElementKind.CONSTRUCTOR;
+             && element.kind != ElementKind.GENERATIVE_CONSTRUCTOR;
     }
     return lookupLocalElement(name, matches);
   }
 
   Element lookupConstructor(SourceString name) {
     bool matches(Element element) {
       return element.name == name
-             && element.kind == ElementKind.CONSTRUCTOR;
+             && (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR
+                 || element.modifiers.isFactory());
     }
     return lookupLocalElement(name, matches);
   }
 
   // TODO(ngeoffray): Implement these.
   bool canHaveDefaultConstructor() => true;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
@@ skipping 26 matching lines @@
            && !element.isInstanceMember()
            && (element.kind === ElementKind.FIELD);
   }
 
   static bool isInstanceMethod(Element element) {
     return (element != null)
            && element.isInstanceMember()
            && (element.kind === ElementKind.FUNCTION);
   }
 }