Fix remaining warnings.

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 1469 matching lines @@
     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);
   }
 
-  Link<Type> getOrCalculateAllSupertypes(ClassElement classElement,
+  Link<Type> getOrCalculateAllSupertypes(ClassElement cls,
                                          [Set<ClassElement> seen]) {
-    Link<Type> allSupertypes = classElement.allSupertypes;
+    Link<Type> allSupertypes = cls.allSupertypes;
     if (allSupertypes !== null) return allSupertypes;
     if (seen === null) {
       seen = new Set<ClassElement>();
     }
-    if (seen.contains(classElement)) {
-      error(classElement.parseNode(compiler),
+    if (seen.contains(cls)) {
+      error(cls.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
-            [classElement.name]);
-      classElement.allSupertypes = const EmptyLink<Type>();
+            [cls.name]);
+      cls.allSupertypes = const EmptyLink<Type>();
     } else {
-      classElement.ensureResolved(compiler);
-      calculateAllSupertypes(classElement, seen);
+      cls.ensureResolved(compiler);
+      calculateAllSupertypes(cls, seen);
     }
-    return classElement.allSupertypes;
+    return cls.allSupertypes;
   }
 
-  void calculateAllSupertypes(ClassElement classElement,
-                              Set<ClassElement> seen) {
+  void calculateAllSupertypes(ClassElement cls, Set<ClassElement> seen) {
     // TODO(karlklose): substitute type variables.
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
-    if (classElement.allSupertypes !== null) return;
-    final Type supertype = classElement.supertype;
-    if (seen.contains(classElement)) {
-      error(classElement.parseNode(compiler),
+    if (cls.allSupertypes !== null) return;
+    final Type supertype = cls.supertype;
+    if (seen.contains(cls)) {
+      error(cls.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
-            [classElement.name]);
-      classElement.allSupertypes = const EmptyLink<Type>();
+            [cls.name]);
+      cls.allSupertypes = const EmptyLink<Type>();
     } else if (supertype != null) {
-      seen.add(classElement);
+      seen.add(cls);
       Link<Type> superSupertypes =
           getOrCalculateAllSupertypes(supertype.element, seen);
       Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
-      for (Link<Type> interfaces = classElement.interfaces;
+      for (Link<Type> interfaces = cls.interfaces;
            !interfaces.isEmpty();
            interfaces = interfaces.tail) {
         Element element = interfaces.head.element;
         Link<Type> interfaceSupertypes =
             getOrCalculateAllSupertypes(element, seen);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
-      seen.remove(classElement);
-      classElement.allSupertypes = supertypes;
+      seen.remove(cls);
+      cls.allSupertypes = supertypes;
     } else {
-      classElement.allSupertypes = const EmptyLink<Type>();
+      cls.allSupertypes = const EmptyLink<Type>();
     }
   }
 
   /**
    * Add a synthetic nullary constructor if there are no other
    * constructors.
    */
   void addDefaultConstructorIfNeeded(ClassElement element) {
     if (element.constructors.length != 0) return;
     SynthesizedConstructorElement constructor =
@@ skipping 304 matching lines @@
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
   abstract Element lookup(SourceString name);
 }
 
 class TypeVariablesScope extends Scope {
   TypeVariablesScope(parent, ClassElement element) : super(parent, element);
-  Element add(Element element) {
+  Element add(Element newElement) {
     throw "Cannot add element to TypeVariableScope";
   }
   Element lookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupTypeParameter(name);
     if (result !== null) return result;
     if (parent !== null) return parent.lookup(name);
   }
 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
     : super(parent, element), this.elements = new Map<SourceString, Element>();
 
   Element lookup(SourceString name) {
-    Element element = elements[name];
-    if (element !== null) return element;
+    Element found = elements[name];
+    if (found !== null) return found;
     return parent.lookup(name);
   }
 
-  Element add(Element element) {
-    if (elements.containsKey(element.name)) return elements[element.name];
-    elements[element.name] = element;
-    return element;
+  Element add(Element newElement) {
+    if (elements.containsKey(newElement.name)) {
+      return elements[newElement.name];
+    }
+    elements[newElement.name] = newElement;
+    return newElement;
   }
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
 }
 
 class ClassScope extends Scope {
   ClassScope(ClassElement element, LibraryElement library)
     : super(new TopScope(library), element);
 
   Element lookup(SourceString name) {
     ClassElement cls = element;
     Element result = cls.lookupLocalMember(name);
     if (result !== null) return result;
     result = cls.lookupTypeParameter(name);
     if (result !== null) return result;
     result = parent.lookup(name);
     if (result != null) return result;
     return cls.lookupSuperMember(name);
   }
 
-  Element add(Element element) {
+  Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
 }
 
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
-  Element add(Element element) {
+  Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }