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 possibleTypeVariable(TypeAnnotation typeAnnotation) {

[Roman, 2012/08/10 10:36:06]

The name and signature of this method do not clearly tell me what it does. can
you please specify return type, and usually this kind of methods are prefixed
with "is"

[Anton Muhin, 2012/08/10 10:49:19]

бу-бу-бу

On 2012/08/10 10:36:06, Roman wrote:

+    if (typeAnnotation.typeName is !Identifier) return false;
+    if (typeAnnotation.typeArguments === null) return true;
+    if (typeAnnotation.typeArguments.length === 0) return true;
+    return false;
+  }
+
   visitTypeAnnotation(TypeAnnotation node) {
+    // print('visitTypeAnnotation(${node.toDebugString()}): currentElement: $currentElement');

[Roman, 2012/08/10 10:36:06]

80 chars, debug stmt?

[Anton Muhin, 2012/08/10 10:49:19]

Done.

+    // Poor man generic variables resolution.

[Roman, 2012/08/10 10:36:06]

Technically you don't resolve them, you skip type variables resolution, is this
correct?

[Anton Muhin, 2012/08/10 10:49:19]

Yes.  I do resolve them, meaning I do understand that this type annotation maps
to type variable.  And in this case we don't have to rename it.

On 2012/08/10 10:36:06, Roman wrote:

+    // TODO(antonm): get rid of it once resolver can deal with it.
+    if (possibleTypeVariable(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 (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) {

[Roman, 2012/08/10 10:36:06]

We probably don't want to rename true "Dynamic" references to something
unresolved. Can you add this check here? I would expect some tests that use
Dynamic fail because of this change.

[Anton Muhin, 2012/08/10 10:49:19]

Done.

+      makeTypePlaceholder(target, type);
+    } else {
+      makeUnresolvedPlaceholder(target);
+    }
     node.visitChildren(this);
   }
 }