Rename Type to DartType to avoid conflicts with the class Type in the core library.

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);
+  DartType getType(TypeAnnotation annotation);
 }
 
 class TreeElementMapping implements TreeElements {
   Map<Node, Element> map;
   Map<Node, Selector> selectors;
-  Map<TypeAnnotation, Type> types;
+  Map<TypeAnnotation, DartType> types;
 
   TreeElementMapping()
     : map = new LinkedHashMap<Node, Element>(),
       selectors = new LinkedHashMap<Node, Selector>(),
-      types = new LinkedHashMap<TypeAnnotation, Type>();
+      types = new LinkedHashMap<TypeAnnotation, DartType>();
 
   operator []=(Node node, Element element) => map[node] = element;
   operator [](Node node) => map[node];
   void remove(Node node) { map.remove(node); }
 
-  void setType(TypeAnnotation annotation, Type type) {
+  void setType(TypeAnnotation annotation, DartType type) {
     types[annotation] = type;
   }
 
-  Type getType(TypeAnnotation annotation) => types[annotation];
+  DartType getType(TypeAnnotation annotation) => types[annotation];
 
   void setSelector(Node node, Selector selector) {
     selectors[node] = selector;
   }
 
   Selector getSelector(Node node) => selectors[node];
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
@@ skipping 103 matching lines @@
 
   void visitBody(ResolverVisitor visitor, Statement body) {
     visitor.visit(body);
   }
 
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
     if (constructor.defaultImplementation !== constructor) return;
     ClassElement intrface = constructor.getEnclosingClass();
     if (!intrface.isInterface()) return;
-    Type defaultType = intrface.defaultClass;
+    DartType defaultType = intrface.defaultClass;
     if (defaultType === null) {
       error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
     }
     ClassElement defaultClass = defaultType.element;
     defaultClass.ensureResolved(compiler);
     assert(defaultClass.resolutionState == STATE_DONE);
     assert(defaultClass.supertypeLoadState == STATE_DONE);
     if (defaultClass.isInterface()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
             [defaultClass.name]);
@@ skipping 33 matching lines @@
   }
 
   TreeElements resolveParameter(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, element.enclosingElement);
     initializerDo(tree, visitor.visit);
     return visitor.mapping;
   }
 
-  Type resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
+  DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     if (annotation === null) return compiler.types.dynamicType;
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
-    Type result = visitor.resolveTypeAnnotation(annotation);
+    DartType result = visitor.resolveTypeAnnotation(annotation);
     if (result === null) {
       // TODO(karklose): warning.
       return compiler.types.dynamicType;
     }
     return result;
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(ClassElement cls, Node from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
           compiler.spanFromNode(from),
           MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
           api.Diagnostic.ERROR);
         cls.supertypeLoadState = STATE_DONE;
-        cls.allSupertypes = const EmptyLink<Type>().prepend(
+        cls.allSupertypes = const EmptyLink<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls.parseNode(compiler).accept(new ClassSupertypeResolver(compiler,
                                                                   cls));
@@ skipping 176 matching lines @@
         visitor.visit(node);
 
         element.isBeingResolved = false;
         element.isResolved = true;
       });
     });
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
-    LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
+    LinkBuilder<DartType> parameterTypes = new LinkBuilder<DartType>();
     for (Link<Element> link = signature.requiredParameters;
          !link.isEmpty();
          link = link.tail) {
        parameterTypes.addLast(link.head.computeType(compiler));
        // TODO(karlklose): optional parameters.
     }
     return new FunctionType(signature.returnType,
                             parameterTypes.toLink(),
                             element);
   }
@@ skipping 394 matching lines @@
       }
     } else {
       return scope.lookup(typeName.source);
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
   // TODO(johnniwinther): Should never return [null] but instead an erroneous
   // type.
-  Type resolveTypeAnnotation(TypeAnnotation node,
-                             [Scope inScope, ClassElement inClass,
-                              onFailure(Node, MessageKind, [List arguments]),
-                              whenResolved(Node, Type)]) {
+  DartType resolveTypeAnnotation(TypeAnnotation node,
+                                 [Scope inScope, ClassElement inClass,
+                                 onFailure(Node, MessageKind, [List arguments]),
+                                 whenResolved(Node, Type)]) {
     if (onFailure === null) {
       onFailure = (n, k, [arguments]) {};
     }
     if (whenResolved === null) {
       whenResolved = (n, t) {};
     }
     if (inClass !== null) {
       inScope = inClass.buildScope();
     }
     if (inScope === null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
     return resolveTypeAnnotationInContext(inScope, node, onFailure,
                                           whenResolved);
   }
 
-  Type resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
-                                      onFailure, whenResolved) {
+  DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
+                                          onFailure, whenResolved) {
     Element element = resolveTypeName(scope, node);
-    Type type;
+    DartType 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;
         cls.ensureResolved(compiler);
-        Link<Type> arguments =
+        Link<DartType> arguments =
             resolveTypeArguments(node, cls.typeVariables, scope,
                                  onFailure, whenResolved);
         if (cls.typeVariables.isEmpty() && arguments.isEmpty()) {
           // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
           type = new InterfaceType(cls, arguments);
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         typdef.computeType(compiler);
-        Link<Type> arguments = resolveTypeArguments(
+        Link<DartType> arguments = resolveTypeArguments(
             node, typdef.typeVariables,
             scope, onFailure, whenResolved);
         if (typdef.typeVariables.isEmpty() && arguments.isEmpty()) {
           // Return the canonical type if it has no type parameters.
           type = typdef.computeType(compiler);
         } else {
           type = new TypedefType(typdef, arguments);
         }
       } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     whenResolved(node, type);
     return type;
   }
 
-  Link<Type> resolveTypeArguments(TypeAnnotation node,
-                                  Link<Type> typeVariables,
-                                  Scope scope, onFailure, whenResolved) {
+  Link<DartType> resolveTypeArguments(TypeAnnotation node,
+                                      Link<DartType> typeVariables,
+                                      Scope scope, onFailure, whenResolved) {
     if (node.typeArguments == null) {
-      return const EmptyLink<Type>();
+      return const EmptyLink<DartType>();
     }
-    var arguments = new LinkBuilder<Type>();
+    var arguments = new LinkBuilder<DartType>();
     for (Link<Node> typeArguments = node.typeArguments.nodes;
          !typeArguments.isEmpty();
          typeArguments = typeArguments.tail) {
       if (typeVariables.isEmpty()) {
         onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
       }
-      Type argType = resolveTypeAnnotationInContext(scope,
+      DartType argType = resolveTypeAnnotationInContext(scope,
                                                     typeArguments.head,
                                                     onFailure,
                                                     whenResolved);
       arguments.addLast(argType);
       if (!typeVariables.isEmpty()) {
         typeVariables = typeVariables.tail;
       }
     }
     if (!typeVariables.isEmpty()) {
       onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
@@ skipping 84 matching lines @@
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
-    Type type = resolveTypeAnnotation(node);
+    DartType type = resolveTypeAnnotation(node);
     if (type !== null) return type.element;
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         [bool doAddToScope = true]) {
     compiler.ensure(element !== null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = scope.add(element);
       if (existing != element) {
         error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
       }
     }
     return element;
   }
 
   Element useElement(Node node, Element element) {
     if (element === null) return null;
     return mapping[node] = element;
   }
 
-  Type useType(TypeAnnotation annotation, Type type) {
+  DartType useType(TypeAnnotation annotation, DartType type) {
     if (type !== null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     scope = new MethodScope(scope, function);
     // Put the parameters in scope.
@@ skipping 169 matching lines @@
     } else if (resolvedReceiver.kind === ElementKind.PREFIX) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (target == null) {
         error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER, [prefix.name, name]);
       }
     }
     return target;
   }
 
-  Type resolveTypeTest(Node argument) {
+  DartType resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node === null) {
       // node is of the form !Type.
       node = argument.asSend().receiver.asTypeAnnotation();
       if (node === null) compiler.cancel("malformed send");
     }
     return resolveTypeRequired(node);
   }
 
   static Selector computeSendSelector(Send node, LibraryElement library) {
@@ skipping 322 matching lines @@
     } else {
       // Resolve and store the type this annotation resolves to. The type
       // is used in the backend, e.g., for creating runtime type information.
       // TODO(karlklose): This will resolve the class element again. Refactor
       // so we can use the TypeResolver.
       resolveTypeRequired(annotation);
     }
     return constructor;
   }
 
-  Type resolveTypeRequired(TypeAnnotation node) {
+  DartType resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
-    Type result = resolveTypeAnnotation(node);
+    DartType result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
-  Type resolveTypeAnnotation(TypeAnnotation node) {
+  DartType resolveTypeAnnotation(TypeAnnotation node) {
     Function report = typeRequired ? error : warning;
     return typeResolver.resolveTypeAnnotation(node, inScope: scope,
                                               onFailure: report,
                                               whenResolved: useType);
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
@@ skipping 244 matching lines @@
     visitIn(node.type, blockScope);
     visitIn(node.formals, blockScope);
     visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
-class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
+class TypeDefinitionVisitor extends CommonResolverVisitor<DartType> {
   Scope scope;
   TypeDeclarationElement element;
   TypeResolver typeResolver;
 
   TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
       : this.element = element,
         scope = element.buildEnclosingScope(),
         typeResolver = new TypeResolver(compiler),
         super(compiler);
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node === null) return;
 
     var nameSet = new Set<SourceString>();
     // Resolve the bounds of type variables.
-    Link<Type> typeLink = element.typeVariables;
+    Link<DartType> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty()) {
       TypeVariableType typeVariable = typeLink.head;
       SourceString typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
         error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound !== null) {
-        Type boundType = typeResolver.resolveTypeAnnotation(
+        DartType boundType = typeResolver.resolveTypeAnnotation(
             typeNode.bound, inScope: scope, onFailure: warning);
         if (boundType !== null && boundType.element == variableElement) {
           // TODO(johnniwinther): Check for more general cycles, like
           // [: <A extends B, B extends C, C extends B> :].
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
                   [variableElement.name]);
         } else if (boundType !== null) {
           variableElement.bound = boundType;
         } else {
           // TODO(johnniwinther): Should be an erroneous type.
@@ skipping 41 matching lines @@
  * resolved, but it cannot call [ResolverTask.resolveClass] directly
  * or indirectly (through [ClassElement.ensureResolved]) for any other
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   ClassElement get element => super.element;
 
   ClassResolverVisitor(Compiler compiler, ClassElement classElement)
     : super(compiler, classElement);
 
-  Type visitClassNode(ClassNode node) {
+  DartType visitClassNode(ClassNode node) {
     compiler.ensure(element !== null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
     // Find super type.
-    Type supertype = visit(node.superclass);
+    DartType supertype = visit(node.superclass);
     if (supertype !== null && supertype.element.isExtendable()) {
       element.supertype = supertype;
       if (isBlackListed(supertype)) {
         error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
       }
     } else if (supertype !== null) {
       error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
     }
     final objectElement = compiler.objectClass;
     if (element !== objectElement && element.supertype === null) {
       if (objectElement === null) {
         compiler.internalError("Internal error: cannot resolve Object",
                                node: node);
       } else {
         objectElement.ensureResolved(compiler);
       }
       // TODO(ahe): This should be objectElement.computeType(...).
       element.supertype = new InterfaceType(objectElement);
     }
     assert(element.interfaces === null);
-    Link<Type> interfaces = const EmptyLink<Type>();
+    Link<DartType> interfaces = const EmptyLink<DartType>();
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
-      Type interfaceType = visit(link.head);
+      DartType interfaceType = visit(link.head);
       if (interfaceType !== null && interfaceType.element.isExtendable()) {
         interfaces = interfaces.prepend(interfaceType);
         if (isBlackListed(interfaceType)) {
           error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
         }
       } else {
         error(link.head, MessageKind.TYPE_NAME_EXPECTED);
       }
     }
     element.interfaces = interfaces;
     calculateAllSupertypes(element);
 
     if (node.defaultClause !== null) {
       element.defaultClass = visit(node.defaultClause);
     }
     addDefaultConstructorIfNeeded(element);
     return element.computeType(compiler);
   }
 
-  Type visitTypeAnnotation(TypeAnnotation node) {
+  DartType visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
-  Type visitIdentifier(Identifier node) {
+  DartType visitIdentifier(Identifier node) {
     Element element = scope.lookup(node.source);
     if (element === null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
       return null;
     } else if (!element.impliesType() && !element.isTypeVariable()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
       return null;
     } else {
       if (element.isTypeVariable()) {
         TypeVariableElement variableElement = element;
         return variableElement.type;
       } else if (element.isTypedef()) {
         compiler.unimplemented('visitIdentifier for typedefs', node: node);
       } else {
         // TODO(ngeoffray): Use type variables.
         return element.computeType(compiler);
       }
     }
     return null;
   }
 
-  Type visitSend(Send node) {
+  DartType visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix === null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
       return null;
     }
     Element element = scope.lookup(prefix.source);
     if (element === null || element.kind !== ElementKind.PREFIX) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
       return null;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e === null || !e.impliesType()) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
       return null;
     }
     return e.computeType(compiler);
   }
 
   void calculateAllSupertypes(ClassElement cls) {
     // TODO(karlklose): substitute type variables.
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
     if (cls.allSupertypes !== null) return;
-    final Type supertype = cls.supertype;
+    final DartType supertype = cls.supertype;
     if (supertype != null) {
       ClassElement superElement = supertype.element;
-      Link<Type> superSupertypes = superElement.allSupertypes;
+      Link<DartType> superSupertypes = superElement.allSupertypes;
       assert(superSupertypes !== null);
-      Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
-      for (Link<Type> interfaces = cls.interfaces;
+      Link<DartType> supertypes =
+          new Link<DartType>(supertype, superSupertypes);
+      for (Link<DartType> interfaces = cls.interfaces;
            !interfaces.isEmpty();
            interfaces = interfaces.tail) {
         ClassElement element = interfaces.head.element;
-        Link<Type> interfaceSupertypes = element.allSupertypes;
+        Link<DartType> interfaceSupertypes = element.allSupertypes;
         assert(interfaceSupertypes !== null);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
       cls.allSupertypes = supertypes;
     } else {
       assert(cls === compiler.objectClass);
-      cls.allSupertypes = const EmptyLink<Type>();
+      cls.allSupertypes = const EmptyLink<DartType>();
     }
   }
 
   /**
    * Add a synthetic nullary constructor if there are no other
    * constructors.
    */
   void addDefaultConstructorIfNeeded(ClassElement element) {
     if (element.hasConstructor) return;
     SynthesizedConstructorElement constructor =
       new SynthesizedConstructorElement(element);
     element.addToScope(constructor, compiler);
-    Type returnType = compiler.types.voidType;
-    constructor.type = new FunctionType(returnType, const EmptyLink<Type>(),
+    DartType returnType = compiler.types.voidType;
+    constructor.type = new FunctionType(returnType, const EmptyLink<DartType>(),
                                         constructor);
     constructor.cachedNode =
       new FunctionExpression(new Identifier(element.position()),
                              new NodeList.empty(),
                              new Block(new NodeList.empty()),
                              null, null, null, null);
   }
 
-  isBlackListed(Type type) {
+  isBlackListed(DartType type) {
     LibraryElement lib = element.getLibrary();
     return
       lib !== compiler.coreLibrary &&
       lib !== compiler.coreImplLibrary &&
       lib !== compiler.jsHelperLibrary &&
       (type.element === compiler.dynamicClass ||
        type.element === compiler.boolClass ||
        type.element === compiler.numClass ||
        type.element === compiler.intClass ||
        type.element === compiler.doubleClass ||
@@ skipping 159 matching lines @@
     return new VariableElement(node.source, variables,
         ElementKind.PARAMETER, enclosingElement, node: node);
   }
 
   SourceString getParameterName(Send node) {
     var identifier = node.selector.asIdentifier();
     if (identifier !== null) {
       // Normal parameter: [:Type name:].
       return identifier.source;
     } else {
-      // Function type parameter: [:void name(Type arg):].
+      // Function type parameter: [:void name(DartType arg):].
       var functionExpression = node.selector.asFunctionExpression();
       if (functionExpression !== null &&
           functionExpression.name.asIdentifier() !== null) {
         return functionExpression.name.asIdentifier().source;
       } else {
         cancel(node,
             'internal error: unimplemented receiver on parameter send');
       }
     }
   }
@@ skipping 88 matching lines @@
                                    MessageKind.EXTRA_FORMALS.error([]),
                                    api.Diagnostic.WARNING);
           }
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
-    Type returnType = compiler.resolveTypeAnnotation(element, returnNode);
+    DartType returnType = compiler.resolveTypeAnnotation(element, returnNode);
     return new FunctionSignature(parameters,
                                  visitor.optionalParameters,
                                  requiredParameterCount,
                                  visitor.optionalParameterCount,
                                  returnType);
   }
 
   // TODO(ahe): This is temporary.
   void resolveExpression(Node node) {
     if (node == null) return;
@@ skipping 140 matching lines @@
   }
 
   /**
    * Looks up [name] within the type variables declared in [element].
    */
   Element lookupTypeVariable(SourceString name) {
     return null;
   }
 
   Element lookup(SourceString name) {
-    Link<Type> typeVariableLink = element.typeVariables;
+    Link<DartType> typeVariableLink = element.typeVariables;
     while (!typeVariableLink.isEmpty()) {
       TypeVariableType typeVariable = typeVariableLink.head;
       if (typeVariable.name == name) {
         return typeVariable.element;
       }
       typeVariableLink = typeVariableLink.tail;
     }
 
     return parent.lookup(name);
   }
@@ skipping 65 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";
   }
   String toString() => '$element';
 }