Implement interface types.

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);
 }
 
 class TreeElementMapping implements TreeElements {
   Map<Node, Element> map;
   Map<Send, Selector> selectors;
+  Map<TypeAnnotation, Type> types;
+
   TreeElementMapping()
     : map = new LinkedHashMap<Node, Element>(),
-      selectors = new LinkedHashMap<Send, Selector>();
+      selectors = new LinkedHashMap<Send, Selector>(),
+      types = new LinkedHashMap<TypeAnnotation, Type>();
 
   operator []=(Node node, Element element) => map[node] = element;
   operator [](Node node) => map[node];
   void remove(Node node) { map.remove(node); }
 
+  void setType(TypeAnnotation annotation, Type type) {
+    types[annotation] = type;
+  }
+
+  Type getType(TypeAnnotation annotation) => types[annotation];
+
   void setSelector(Send send, Selector selector) {
     selectors[send] = selector;
   }
 
   Selector getSelector(Send send) => selectors[send];
 }
 
 class ResolverTask extends CompilerTask {
   Queue<ClassElement> toResolve;
 
@@ skipping 555 matching lines @@
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
-    Send send = node.typeName.asSend();
-    Element element;
-    if (send !== null) {
-      if (typeRequired) {
-        element = resolveSend(send);
-      } else {
-        // Not calling resolveSend as it will emit an error instead of
-        // a warning if the type is bogus.
-        // TODO(ahe): Change resolveSend so it can emit a warning when needed.
-        return null;
-      }
-    } else {
-      element = context.lookup(node.typeName.asIdentifier().source);
-    }
-    if (element === null) {
-      if (typeRequired) {
-        error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
-      } else {
-        warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
-      }
-    } else if (!element.impliesType()) {
-      if (typeRequired) {
-        error(node, MessageKind.NOT_A_TYPE, [node.typeName]);
-      } else {
-        warning(node, MessageKind.NOT_A_TYPE, [node.typeName]);
-      }
-    } else {
-      if (element.isClass()) {
-        // TODO(ngeoffray): Should we also resolve typedef?
-        ClassElement cls = element;
-        compiler.resolver.toResolve.add(element);
-      }
-      // TODO(ahe): This should be a Type.
-      useElement(node, element);
-    }
-    return element;
+    Type type = resolveTypeAnnotation(node);
+    if (type !== null) return type.element;
+    return null;
   }
 
   Element defineElement(Node node, Element element,
                         [bool doAddToScope = true]) {
     compiler.ensure(element !== null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = context.add(element);
       if (existing != element) {
         error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
       }
     }
     return element;
   }
 
   Element useElement(Node node, Element element) {
     if (element === null) return null;
     return mapping[node] = element;
   }
 
+  Type useType(TypeAnnotation annotation, Type type) {
+    if (type !== null) {
+      mapping.setType(annotation, type);
+      useElement(annotation, type.element);
+    }
+    return type;
+  }
+
   void setupFunction(FunctionExpression node, FunctionElement function) {
     context = new MethodScope(context, function);
     // Put the parameters in scope.
     FunctionParameters functionParameters =
         function.computeParameters(compiler);
     Link<Node> parameterNodes = node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
@@ skipping 159 matching lines @@
     } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (target == null) {
         error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER, [prefix.name, name]);
       }
     }
     return target;
   }
 
-  resolveTypeTest(Node argument) {
+  Type resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node == null) {
-      node = argument.asSend().receiver;
+      // node is of the form !Type.
+      node = argument.asSend().receiver.asTypeAnnotation();
+      if (node === null) compiler.cancel("malformed send");
     }
-    resolveTypeRequired(node);
+    return resolveTypeRequired(node);
   }
 
   void handleArguments(Send node) {
     int count = 0;
     List<SourceString> namedArguments = <SourceString>[];
     bool seenNamedArgument = false;
     for (Link<Node> link = node.argumentsNode.nodes;
          !link.isEmpty();
          link = link.tail) {
       count++;
@@ skipping 142 matching lines @@
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     useElement(node.send, constructor);
     return null;
   }
 
+  TypeAnnotation getTypeAnnotationFromSend(Send send) {
+    if (send.selector.asTypeAnnotation() !== null) {
+      return send.selector;
+    } else if (send.selector.asSend() !== null) {
+      Send selector = send.selector;
+      if (selector.receiver.asTypeAnnotation() !== null) {
+        return selector.receiver;
+      }
+    } else {
+      compiler.internalError("malformed send in new expression");
+    }
+  }
+
   FunctionElement resolveConstructor(NewExpression node) {
     FunctionElement constructor =
         node.accept(new ConstructorResolver(compiler, this));
+    TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
+    Type type = resolveTypeRequired(annotation);
     if (constructor === null) {
-      Element resolved = resolveTypeRequired(node.send.selector);
+      Element resolved = (type != null) ? type.element : null;
       if (resolved !== null && resolved.kind === ElementKind.TYPE_VARIABLE) {
-        error(node, WarningKind.TYPE_VARIABLE_AS_CONSTRUCTOR);
+        error(node, MessageKind.TYPE_VARIABLE_AS_CONSTRUCTOR);
         return null;
       } else {
         error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
+        return null;
       }
     }
     return constructor;
   }
 
-  Element resolveTypeRequired(Node node) {
+  Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
-    Element element = visit(node);
+    Type result = resolveTypeAnnotation(node);
     typeRequired = old;
-    return element;
+    return result;
+  }
+
+  Element resolveTypeName(node) {
+    Identifier typeName = node.typeName.asIdentifier();
+    Send send = node.typeName.asSend();
+    if (send !== null) {
+      typeName = send.selector;
+    }
+    if (typeName.source == Types.VOID) return compiler.types.voidType.element;
+    if (typeName.source == Types.DYNAMIC ||
+        typeName.source.stringValue == "var") {
+      return compiler.types.dynamicType.element;
+    }
+    if (send !== null) {
+      Element e = context.lookup(send.receiver.asIdentifier().source);
+      if (e !== null && e.kind === ElementKind.PREFIX) {
+        // The receiver is a prefix. Lookup in the imported members.
+        PrefixElement prefix = e;
+        return prefix.lookupLocalMember(typeName.source);
+      } else if (e !== null && e.kind === ElementKind.CLASS) {
+        // The receiver is the class part of a named constructor.
+        return e;
+      } else {
+        error(send.receiver, MessageKind.CANNOT_RESOLVE);
+      }
+    } else {
+      return context.lookup(typeName.source);
+    }
+  }
+
+  Type resolveTypeAnnotation(TypeAnnotation node) {
+    Element element = resolveTypeName(node);
+    Type type;
+    if (element === null) {
+      if (typeRequired) {
+        error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
+      } else {
+        warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
+      }
+    } else if (!element.impliesType()) {
+      if (typeRequired) {
+        error(node, MessageKind.NOT_A_TYPE, [node.typeName]);
+      } else {
+        warning(node, MessageKind.NOT_A_TYPE, [node.typeName]);
+      }
+    } else {
+      if (element == compiler.types.voidType.element) {
+        type = compiler.types.voidType;
+      } else if (element == compiler.types.dynamicType.element) {
+        type = compiler.types.dynamicType;
+      } else if (element.isClass()) {
+        // TODO(ngeoffray): Should we also resolve typedef?
+        ClassElement cls = element;
+        compiler.resolver.toResolve.add(cls);
+        LinkBuilder<Type> arguments = new LinkBuilder<Type>();
+        if (node.typeArguments !== null) {
+          for (Link<Node> typeArguments = node.typeArguments.nodes;
+               !typeArguments.isEmpty();
+               typeArguments = typeArguments.tail) {
+            arguments.addLast(resolveTypeAnnotation(typeArguments.head));
+          }
+        }
+        type = new InterfaceType(element.name, element, arguments.toLink());
+      } else if (element.isTypedef()) {
+        // TODO(karlklose): implement typedefs. We return a fake type that the
+        // code generator can use to detect typedefs in is-checks.
+        type = new SimpleType(element.name, element);
+      } else {
+        type = element.computeType(compiler);
+      }
+    }
+    return useType(node, type);
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     visit(node.elements);
   }
@@ skipping 605 matching lines @@
 
   // TODO(ahe): This is temporary.
   void resolveExpression(Node node) {
     if (node == null) return;
     node.accept(new ResolverVisitor(compiler, enclosingElement));
   }
 
   // TODO(ahe): This is temporary.
   void resolveType(Node node) {
     if (node == null) return;
-    node.accept(new ResolverVisitor(compiler, enclosingElement));
+    // Find the correct member context to perform the lookup in.
+    Element outer = enclosingElement;
+    Element context = outer;
+    while (outer !== null) {
+      if (outer.isMember()) {
+        context = outer;
+        break;
+      }
+      outer = outer.enclosingElement;
+    }
+    node.accept(new ResolverVisitor(compiler, context));
   }
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
       ? enclosingElement.enclosingElement : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
@@ skipping 146 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }