Handle type variable in static member.

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 const bool LOG_FAILURES = false;
 
   void check(Node tree, TreeElements elements) {
     measure(() {
       Visitor visitor =
           new TypeCheckerVisitor(compiler, elements, compiler.types);
       try {
         tree.accept(visitor);
       } on CancelTypeCheckException catch (e) {
         if (LOG_FAILURES) {
           // Do not warn about unimplemented features; log message instead.
           compiler.log("'${e.node}': ${e.reason}");
         }
       }
     });
   }
 }
 
+class TypeKind {
+  final String id;
+
+  const TypeKind(String this.id);
+
+  static const TypeKind FUNCTION = const TypeKind('function');
+  static const TypeKind INTERFACE = const TypeKind('interface');
+  static const TypeKind STATEMENT = const TypeKind('statement');
+  static const TypeKind TYPEDEF = const TypeKind('typedef');
+  static const TypeKind TYPE_VARIABLE = const TypeKind('type variable');
+  static const TypeKind VOID = const TypeKind('void');

[ahe, 2012/10/26 08:18:40]

How about adding a "toString" mehod?

[Johnni Winther, 2012/10/29 09:20:14]

Done.

+}
+
 abstract class DartType {
   abstract SourceString get name;
 
+  abstract TypeKind get kind;
+
   /**
    * Returns the [Element] which declared this type.
    *
    * This can be [ClassElement] for classes, [TypedefElement] for typedefs,
    * [TypeVariableElement] for type variables and [FunctionElement] for
    * function types.
    *
    * Invariant: [element] must be a declaration element.
    */
   abstract Element get element;
@@ skipping 11 matching lines @@
   abstract DartType unalias(Compiler compiler);
 
   abstract bool operator ==(other);
 }
 
 class TypeVariableType implements DartType {
   final TypeVariableElement element;
 
   TypeVariableType(this.element);
 
+  TypeKind get kind => TypeKind.TYPE_VARIABLE;
+
   SourceString get name => element.name;
 
   DartType unalias(Compiler compiler) => this;
 
   int get hashCode => 17 * element.hashCode;
 
   bool operator ==(other) {
     if (other is !TypeVariableType) return false;
     return identical(other.element, element);
   }
 
   String toString() => name.slowToString();
 }
 
 /**
  * A statement type tracks whether a statement returns or may return.
  */
 class StatementType implements DartType {
   final String stringName;
+
   Element get element => null;
 
+  TypeKind get kind => TypeKind.STATEMENT;
+
   SourceString get name => new SourceString(stringName);
 
   const StatementType(this.stringName);
 
   static const RETURNING = const StatementType('<returning>');
   static const NOT_RETURNING = const StatementType('<not returning>');
   static const MAYBE_RETURNING = const StatementType('<maybe returning>');
 
   /** Combine the information about two control-flow edges that are joined. */
   StatementType join(StatementType other) {
     return (identical(this, other)) ? this : MAYBE_RETURNING;
   }
 
   DartType unalias(Compiler compiler) => this;
 
   int get hashCode => 17 * stringName.hashCode;
 
   bool operator ==(other) {
     if (other is !StatementType) return false;
     return other.stringName == stringName;
   }
 
   String toString() => stringName;
 }
 
 class VoidType implements DartType {
   const VoidType(this.element);
+
+  TypeKind get kind => TypeKind.VOID;
+
   SourceString get name => element.name;
+
   final VoidElement element;
 
   DartType unalias(Compiler compiler) => this;
 
   int get hashCode => 1729;
 
   bool operator ==(other) => other is VoidType;
 
   String toString() => name.slowToString();
 }
 
 class InterfaceType implements DartType {
   final Element element;
   final Link<DartType> arguments;
 
   const InterfaceType(this.element,
                       [this.arguments = const Link<DartType>()]);
 
+  TypeKind get kind => TypeKind.INTERFACE;
+
   SourceString get name => element.name;
 
   DartType unalias(Compiler compiler) => this;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add(name.slowToString());
     if (!arguments.isEmpty()) {
       sb.add('<');
       arguments.printOn(sb, ', ');
@@ skipping 23 matching lines @@
 class FunctionType implements DartType {
   final Element element;
   DartType returnType;
   Link<DartType> parameterTypes;
 
   FunctionType(DartType this.returnType, Link<DartType> this.parameterTypes,
                Element this.element) {
     assert(element == null || invariant(element, element.isDeclaration));
   }
 
+  TypeKind get kind => TypeKind.FUNCTION;
+
   DartType unalias(Compiler compiler) => this;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     bool first = true;
     sb.add('(');
     parameterTypes.printOn(sb, ', ');
     sb.add(') -> ${returnType}');
     return sb.toString();
   }
@@ skipping 30 matching lines @@
   }
 }
 
 class TypedefType implements DartType {
   final TypedefElement element;
   final Link<DartType> typeArguments;
 
   const TypedefType(this.element,
       [this.typeArguments = const Link<DartType>()]);
 
+  TypeKind get kind => TypeKind.TYPEDEF;
+
   SourceString get name => element.name;
 
   DartType unalias(Compiler compiler) {
     // TODO(ahe): This should be [ensureResolved].
     compiler.resolveTypedef(element);
     return element.alias.unalias(compiler);
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
@@ skipping 756 matching lines @@
   }
 
   DartType visitStringNode(StringNode node) {
     compiler.unimplemented('visitNode', node: node);
   }
 
   DartType visitLibraryDependency(LibraryDependency node) {
     compiler.unimplemented('visitNode', node: node);
   }
 }