dart2dart

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);
 }
 
@@ skipping 681 matching lines @@
     nestingLevel--;
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
 class TypeResolver {
   final Compiler compiler;
   TypeResolver(this.compiler);
 
-  Element resolveTypeName(Scope context, TypeAnnotation node) {
-    Identifier typeName = node.typeName.asIdentifier();
-    Send send = node.typeName.asSend();
+  Element resolveTypeName(Scope context, Node typeNode) {
+    Identifier typeName = typeNode.asIdentifier();
+    Send send = typeNode.asSend();
     if (send !== null) {
       typeName = send.selector;
     }
     if (typeName.source.stringValue === 'void') {
       return compiler.types.voidType.element;
     } else 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;
@@ skipping 22 matching lines @@
     if (inClass !== null) {
       inContext = new ClassScope(inClass, inClass.getLibrary());
     }
     if (inContext === null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
     return resolveTypeAnnotationInContext(inContext, node, onFailure,
                                           whenResolved);
   }
 
+  Type resolveTypeVariableInContext(Scope context, TypeVariable node,
+                                    onFailure) {
+    Element element = resolveTypeName(context, node.name);
+    Type type;
+    if (element === null) {
+      onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.name]);
+    } else if (!element.impliesType()) {
+      onFailure(node, MessageKind.NOT_A_TYPE, [node.name]);
+    } else if (element.isTypeVariable()) {
+      type = element.computeType(compiler);

[ahe, 2012/08/02 18:56:15]

I cannot rule out that this won't lead to an infinite loop.

+    } else {
+      compiler.cancel("unexpected element kind ${element.kind}",
+                      node: node);
+    }
+    return type;
+  }
+
   Type resolveTypeAnnotationInContext(Scope context, TypeAnnotation node,
                                       onFailure, whenResolved) {
-    Element element = resolveTypeName(context, node);
+    Element element = resolveTypeName(context, node.typeName);
     Type type;
     if (element === null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (element === compiler.types.voidType.element ||
           element === compiler.types.dynamicType.element) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         if (!cls.isResolved) compiler.resolveClass(cls);
         LinkBuilder<Type> arguments = new LinkBuilder<Type>();
         if (node.typeArguments !== null) {
           int index = 0;
           for (Link<Node> typeArguments = node.typeArguments.nodes;
                !typeArguments.isEmpty();
                typeArguments = typeArguments.tail) {
             if (++index > cls.typeParameters.length) {
               onFailure(typeArguments.head,
                         MessageKind.ADDITIONAL_TYPE_ARGUMENT);
             }
-            Type argType = resolveTypeAnnotationInContext(context,

[ahe, 2012/08/02 18:56:15]

The original code is probably broken as well and may cause infinite loops.

-                                                          typeArguments.head,
-                                                          onFailure,
-                                                          whenResolved);
+            // TypeVariable may happen in default clause of an interface.

[ahe, 2012/08/02 18:56:15]

This is a hack. The problem is that the default clause should not be resolved
through this code.

+            Type argType;
+            if (typeArguments.head is TypeVariable) {
+              argType = resolveTypeVariableInContext(
+                  new ClassScope(cls, cls.getLibrary()), typeArguments.head,
+                  onFailure);
+            } else {
+              argType = resolveTypeAnnotationInContext(context,
+                  typeArguments.head, onFailure, whenResolved);
+            }
             arguments.addLast(argType);
           }
           if (index < cls.typeParameters.length) {
             onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
           }
         }
         if (cls.typeParameters.length == 0) {
           // Return the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
@@ skipping 1426 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }