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;

[ahe, 2012/04/12 15:05:23]

This field seems redundant.

-  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);

[ahe, 2012/04/12 15:05:23]

Add argument: ', '

+      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));
+     dynamicType = new SimpleType(VOID, new ClassElement(DYNAMIC, library));

[ahe, 2012/04/12 15:05:23]

VOID?

 
   Type lookup(SourceString s) {
     if (VOID == s) {
       return voidType;
     } else if (DYNAMIC == s || s.stringValue === 'var') {
       return dynamicType;
     }
     return null;
   }
 
@@ skipping 48 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;
 
   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 507 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     fail(node);
   }
 
   visitTypedef(Typedef node) {
     fail(node);
   }
 }