Support for generic type variables and unresolved types added.

lib/compiler/implementation/dart_backend/placeholder_collector.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 SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
   visitSuperSend(Send node) {}
@@ skipping 133 matching lines @@
       // variable list element twice, better merge this with emitter logic.
       currentElement = element.variables;
       elementNode = currentElement.parseNode(compiler);
       collectFieldDeclarationPlaceholders(element, elementNode);
     } else if (element is ClassElement || element is TypedefElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
     } else {
       assert(false); // Unreachable.
     }
-    elementNode.accept(this);
+    compiler.withCurrentElement(element, () {
+      elementNode.accept(this);
+    });
   }
 
   Type resolveType(TypeAnnotation typeAnnotation) {
     if (treeElements === null) return null;
     var result = treeElements.getType(typeAnnotation);
     // TODO: Have better type resolution.
     if (result === null) {
       result = compiler.resolveTypeAnnotation(currentElement, typeAnnotation);
     }
     return result;
@@ skipping 15 matching lines @@
     assert(element !== null);
     placeholders[node] = new ElementPlaceholder(element);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node !== null);
     placeholders[node] =
         new PrivatePlaceholder(currentElement.getLibrary(), node);
   }
 
+  void makeUnresolvedPlaceholder(Node node) {
+    placeholders[node] = const UnresolvedPlaceholder();
+  }
+
   void internalError(String reason, [Node node]) {
     compiler.cancel(reason: reason, node: node);
   }
 
   visit(Node node) => (node === null) ? null : node.accept(this);
 
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
 
   visitSend(Send send) {
     new SendVisitor(this, treeElements).visitSend(send);
     send.visitChildren(this);
   }
 
   visitSendSet(SendSet send) {
     final element = treeElements[send];
     if (element !== null && element.isInstanceMember()) {
       tryMakePrivateIdentifier(send.selector.asIdentifier());
     }
     send.visitChildren(this);
   }
 
+  static bool isPlainTypeName(TypeAnnotation typeAnnotation) {
+    if (typeAnnotation.typeName is !Identifier) return false;
+    if (typeAnnotation.typeArguments === null) return true;
+    if (typeAnnotation.typeArguments.length === 0) return true;
+    return false;
+  }
+
+  static bool isDynamicType(TypeAnnotation typeAnnotation) {
+    if (!isPlainTypeName(typeAnnotation)) return false;
+    String name = typeAnnotation.typeName.asIdentifier().source.slowToString();
+    return name == 'Dynamic';
+  }
+
   visitTypeAnnotation(TypeAnnotation node) {
+    // Poor man generic variables resolution.
+    // TODO(antonm): get rid of it once resolver can deal with it.
+    if (isPlainTypeName(node)) {
+      String name = node.typeName.source.slowToString();
+      if (currentElement is TypedefElement) {
+        TypedefElement typedefElement = currentElement;
+        NodeList typeParameters = typedefElement.cachedNode.typeParameters;
+        if (typeParameters !== null) {
+          for (TypeVariable typeVariable in typeParameters) {
+            Identifier typeVariableName = typeVariable.name;
+            // If names are equal, then it's a variable and sholdn't be renamed.
+            if (typeVariableName.source.slowToString() == name) return;
+          }
+        }
+      }
+      if (currentElement is ClassElement) {
+        ClassElement classElement = currentElement;
+        String name = node.typeName.source.slowToString();
+        for (TypeVariableType argument in classElement.type.arguments) {
+          // If names are equal, then it's a variable and sholdn't be renamed.
+          if (argument.name.slowToString() == name) return;
+        }
+      }
+    }
     final type = compiler.resolveTypeAnnotation(currentElement, node);
     if (type is !InterfaceType) return null;
     var target = node.typeName;
     if (node.typeName is Send) {
       final element = treeElements[node];
       if (element !== null) {
         final send = node.typeName.asSend();
         final hasPrefix = element.lookupConstructor(
           send.receiver.source, send.selector.source) === null;
         if (!hasPrefix) target = send.receiver;
       }
     }
-    makeTypePlaceholder(target, type);
+    // TODO(antonm): is there a better way to detect unresolved types?
+    if (type !== compiler.types.dynamicType) {
+      makeTypePlaceholder(target, type);
+    } else {
+      if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
+    }
     node.visitChildren(this);
   }
 }