Implement interface types.

lib/compiler/implementation/typechecker.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.
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name() => "Type checker";
 
   static final bool LOG_FAILURES = false;
 
@@ skipping 15 matching lines @@
 
 interface Type {
   SourceString get name();
   Element get element();
 }
 
 class TypeVariableType implements Type {
   final SourceString name;
   Element element;
   TypeVariableType(this.name, [this.element]);
+
+  toString() => name.toString();
 }
 
 /**
  * A statement type tracks whether a statement returns or may return.
  */
 class StatementType implements Type {
   final String stringName;
   Element get element() => null;
 
   SourceString get name() => new SourceString(stringName);
 
   const StatementType(this.stringName);
 
   static final RETURNING = const StatementType('<returning>');
   static final NOT_RETURNING = const StatementType('<not returning>');
   static final MAYBE_RETURNING = const StatementType('<maybe returning>');
 
   /** Combine the information about two control-flow edges that are joined. */
   StatementType join(StatementType other) {
     return (this === other) ? this : MAYBE_RETURNING;
   }
 
   String toString() => stringName;
 }
 
-class SimpleType implements Type {
+class InterfaceType implements Type {
   final SourceString name;
-  final Element element;
+  final ClassElement element;
+  final Link<Type> arguments;
 
-  const SimpleType(SourceString this.name, Element this.element);
+  const InterfaceType(this.name, this.element, this.arguments);
 
+  toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.add(name.slowToString());
+    if (!arguments.isEmpty()) {
+      sb.add('<');
+      arguments.printOn(sb);
+      sb.add('>');
+    }
+    return sb.toString();
+  }
+}
+
+// TODO(karlklose): merge into InterfaceType as a named constructor.
+class SimpleType extends InterfaceType {
+  const SimpleType(SourceString name, Element element)
+    : super(name, element, const EmptyLink<Type>());
   String toString() => name.slowToString();
 }
 
 class FunctionType implements Type {
   final Element element;
   final Type returnType;
   final Link<Type> parameterTypes;
 
   const FunctionType(Type this.returnType, Link<Type> this.parameterTypes,
                      Element this.element);
@@ skipping 17 matching lines @@
   static final DYNAMIC = const SourceString('Dynamic');
   static final STRING = const SourceString('String');
   static final BOOL = const SourceString('bool');
   static final OBJECT = const SourceString('Object');
   static final LIST = const SourceString('List');
 
   final SimpleType voidType;
   final SimpleType dynamicType;
 
   Types() : this.with(new LibraryElement(new Script(null, null)));
+
   Types.with(LibraryElement library)
     : voidType = new SimpleType(VOID, new ClassElement(VOID, library)),
       dynamicType = new SimpleType(DYNAMIC, new ClassElement(DYNAMIC, library));
 
   Type lookup(SourceString s) {
     if (VOID == s) {
       return voidType;
     } else if (DYNAMIC == s || s.stringValue === 'var') {
       return dynamicType;
     }
@@ skipping 51 matching lines @@
   Element element = compiler.coreLibrary.find(name);
   if (element !== null && element.kind === ElementKind.CLASS) {
     return element.computeType(compiler);
   }
   return null;
 }
 
 class TypeCheckerVisitor implements Visitor<Type> {
   final Compiler compiler;
   final TreeElements elements;
-  Node lastSeenNode;
   final Types types;
 
+  Node lastSeenNode;
   Type expectedReturnType;
   ClassElement currentClass;
 
   Link<Type> cascadeTypes = const EmptyLink<Type>();
 
   Type intType;
   Type doubleType;
   Type boolType;
   Type stringType;
   Type objectType;
   Type listType;
 
-  TypeCheckerVisitor(Compiler this.compiler, TreeElements this.elements,
-                     Types this.types) {
+  TypeCheckerVisitor(this.compiler, this.elements, this.types) {
     intType = lookupType(Types.INT, compiler, types);
     doubleType = lookupType(Types.DOUBLE, compiler, types);
     boolType = lookupType(Types.BOOL, compiler, types);
     stringType = lookupType(Types.STRING, compiler, types);
     objectType = lookupType(Types.OBJECT, compiler, types);
     listType = lookupType(Types.LIST, compiler, types);
   }
 
   Type fail(node, [reason]) {
     String message = 'cannot type-check';
@@ skipping 247 matching lines @@
       if (element === null) fail(node.selector, 'unresolved property');
       return computeType(element);
 
     } else if (node.isFunctionObjectInvocation) {
       fail(node.receiver, 'function object invocation unimplemented');
 
     } else {
       FunctionType computeFunType() {
         if (node.receiver !== null) {
           Type receiverType = analyze(node.receiver);
-          if (receiverType === types.dynamicType) return null;
-            if (receiverType === null) {
-              fail(node.receiver, 'receivertype is null');
-            }
-            if (receiverType.element.kind !== ElementKind.CLASS) {
-              fail(node.receiver, 'receivertype is not a class');
-            }
-            ClassElement classElement = receiverType.element;
-            // TODO(karlklose): substitute type arguments.
-            Type memberType =
-              lookupMethodType(selector, classElement, selector.source);
-            if (memberType === types.dynamicType) return null;
-            return memberType;
+          if (receiverType.element == compiler.dynamicClass) return null;
+          if (receiverType === null) {
+            fail(node.receiver, 'receivertype is null');
+          }
+          if (receiverType.element.kind !== ElementKind.CLASS) {
+            fail(node.receiver, 'receivertype is not a class');
+          }
+          ClassElement classElement = receiverType.element;
+          // TODO(karlklose): substitute type arguments.
+          Type memberType =
+            lookupMethodType(selector, classElement, selector.source);
+          if (memberType.element === compiler.dynamicClass) return null;
+          return memberType;
         } else {
           Element element = elements[node];
           if (element === null) {
             fail(node, 'unresolved ${node.selector}');
           } else if (element.kind === ElementKind.FUNCTION) {
             return computeType(element);
           } else if (element.kind === ElementKind.FOREIGN) {
             return null;
           } else {
             fail(node, 'unexpected element kind ${element.kind}');
@@ skipping 248 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     fail(node);
   }
 
   visitTypedef(Typedef node) {
     fail(node);
   }
 }