Implement interface types.

frog/leg/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);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 555 matching lines @@
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         error(node, MessageKind.CANNOT_RESOLVE, [node]);
       }
       return useElement(node, element);
     }
   }
 
-  visitTypeAnnotation(TypeAnnotation node) {
-    SourceString className;
-    if (node.typeName.asSend() !== null) {
-      // In new and const expressions, the type name can be a Send to
-      // denote named constructors or library prefixes.
-      Send send = node.typeName.asSend();
-      className = send.receiver.asIdentifier().source;
-    } else {
-      className = node.typeName.asIdentifier().source;
-    }
-    if (className == const SourceString('var')) return null;
-    if (className == const SourceString('void')) return null;
-    Element element = context.lookup(className);
-    if (element === null) {
-      if (typeRequired) {
-        error(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
-      } else {
-        warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
-      }
-    } else if (element.kind !== ElementKind.CLASS) {
-      if (typeRequired) {
-        error(node, MessageKind.NOT_A_TYPE, [className]);
-      } else {
-        warning(node, MessageKind.NOT_A_TYPE, [className]);
-      }
-    } else {
-      ClassElement cls = element;
-      compiler.resolver.toResolve.add(element);
-      // TODO(ahe): This should be a Type.
-      useElement(node, element);
-    }
-    return element;
+  ClassElement visitTypeAnnotation(TypeAnnotation node) {
+    return resolveTypeAnnotation(node).element;
   }
 
   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]);
@@ skipping 151 matching lines @@
         target = prefix.library.lookupLocalMember(name);
         if (target == null) {
           error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER,
                 [resolvedReceiver.name, name]);
         }
       }
     }
     return target;
   }
 
-  resolveTypeTest(Node argument) {
-    TypeAnnotation node = argument.asTypeAnnotation();
-    if (node == null) {
-      node = argument.asSend().receiver;
-    }
-    resolveTypeRequired(node);
-  }
-
   void handleArguments(Send node) {
     int count = 0;
     List<SourceString> namedArguments = <SourceString>[];
     for (Link<Node> link = node.argumentsNode.nodes;
          !link.isEmpty();
          link = link.tail) {
       count++;
       Expression argument = link.head;
       visit(argument);
       if (argument.asNamedArgument() != null) {
@@ skipping 150 matching lines @@
     SourceString constructorName;
     Node selector = node.send.selector;
     Node typeName = selector.asTypeAnnotation().typeName;
     if (typeName.asSend() !== null) {
       SourceString className = typeName.asSend().receiver.asIdentifier().source;
       SourceString name = typeName.asSend().selector.asIdentifier().source;
       constructorName = Elements.constructConstructorName(className, name);
     } else {
       constructorName = typeName.asIdentifier().source;
     }
-    ClassElement cls = resolveTypeRequired(selector);
+    ClassElement cls = resolveTypeRequired(selector).element;
     if (cls === null) {
       error(selector, MessageKind.CANNOT_RESOLVE_TYPE, [selector]);
       return null;
     }
     cls.resolve(compiler);
     if (cls.isInterface() && (cls.defaultClass === null)) {
       error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
     }
     FunctionElement constructor = cls.lookupConstructor(constructorName);
     if (constructor !== null) return constructor;
     if (constructorName == cls.name && node.send.argumentsNode.isEmpty()) {
       return cls.getSynthesizedConstructor();
     }
     error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
     return null;
   }
 
-  ClassElement resolveTypeRequired(Node node) {
+  Type resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
-    ClassElement cls = visit(node);
+    Type result = resolveTypeAnnotation(node);
     typeRequired = old;
-    return cls;
+    return result;
+  }
+
+  Type resolveTypeTest(Node argument) {
+    TypeAnnotation node = argument.asTypeAnnotation();
+    if (node == null) {

[ahe, 2012/02/29 12:49:15]

Add comment saying this is handling "x is !Foo".

[karlklose, 2012/03/30 11:56:40]

Done.

+      node = argument.asSend().receiver;

[ahe, 2012/02/29 12:49:15]

node = argument.asSend().receiver.asTypeAnnotation();
if (node === null) {
  cancel...
}

[karlklose, 2012/03/30 11:56:40]

Done.

+    }
+    return resolveTypeRequired(node);
+  }
+
+  Type resolveTypeAnnotation(TypeAnnotation node) {
+    SourceString className;
+    if (node.typeName.asSend() !== null) {

[ahe, 2012/02/29 12:49:15]

Please create a visitor.

[karlklose, 2012/03/30 11:56:40]

I moved this code to a function.

+      // In new and const expressions, the type name can be a Send to
+      // denote named constructors or library prefixes.

[ahe, 2012/02/29 12:49:15]

Add:

// TODO(ahe): We assume it is a named constructor, fix that.

[karlklose, 2012/03/30 11:56:40]

Obsolete.

+      Send send = node.typeName.asSend();
+      className = send.receiver.asIdentifier().source;
+    } else {
+      className = node.typeName.asIdentifier().source;
+    }
+    if (className == const SourceString('var') ||
+        className == const SourceString('void')){

[ahe, 2012/02/29 12:49:15]

Move this if-test to right after line 961. In the other case, it is a
compilation error.

[karlklose, 2012/03/30 11:56:40]

Done.

+      return compiler.types.lookup(className);
+    }
+    Element element = context.lookup(className);
+    var report = typeRequired ? error : warning;
+    if (element === null) {
+      report(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
+    } else if (element.kind !== ElementKind.CLASS) {
+      report(node, MessageKind.NOT_A_TYPE, [className]);
+    } else {
+      ClassElement cls = element;
+      // Register class of this type to be resolved and associate it with node.

[ngeoffray, 2012/02/24 13:36:15]

the class ... with the node.

[karlklose, 2012/03/30 11:56:40]

Comment removed.

+      compiler.resolver.toResolve.add(cls);
+      useElement(node, cls);
+      // Resolve type arguments, if any.
+      LinkBuilder<Type> arguments = new LinkBuilder<Type>();
+      Link link = node.typeArguments != null ? node.typeArguments.nodes

[ngeoffray, 2012/02/24 13:36:15]

Link<TypeAnnotation>

[karlklose, 2012/03/30 11:56:40]

Done.

+                                             : const EmptyLink();
+      for (; !link.isEmpty(); link = link.tail) {
+        TypeAnnotation argumentAnnotation = link.head;
+        arguments.addLast(resolveTypeAnnotation(argumentAnnotation));
+      }

[ngeoffray, 2012/02/24 13:36:15]

Do you think you could write a full Dart test or a test in TypeCheckerTest to
make sure that the type arguments are now correctly resolved?

[karlklose, 2012/03/30 11:56:40]

I will add a test to the ResolverTest.

+      // Construct and return resulting type.
+      return new InterfaceType(className, cls, arguments.toLink());
+    }
+    return compiler.types.dynamicType;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     if (node.isConst()) {
       warning(node, MessageKind.GENERIC,
@@ skipping 432 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }