Remove warnings from dart2js test-suite.

tests/compiler/dart2js/members_test.dart

 // Copyright (c) 2014, 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.
 
 library members_test;
 
 import 'package:expect/expect.dart';
 import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart"
-       show Element, ClassElement, MemberSignature, Name, PublicName;
+       show Element, ClassElement, MemberSignature, Name, PublicName,
+            DeclaredMember, Member;
 import "../../../sdk/lib/_internal/compiler/implementation/resolution/class_members.dart"
-  show SyntheticMember, ErroneousMember;
+  show DeclaredMember, ErroneousMember, SyntheticMember;
 
 void main() {
   testClassMembers();
   testInterfaceMembers();
   testClassVsInterfaceMembers();
   testMixinMembers();
 }
 
 MemberSignature getMember(InterfaceType cls, String name,
                           {bool isSetter: false,
@@ skipping 58 matching lines @@
   Name memberName = member.name;
   if (checkType == ALSO_CLASS_MEMBER) {
     MemberSignature classMember = cls.element.lookupClassMember(memberName);
     Expect.isNotNull(classMember, "No class member '$memberName' in $cls.");
     Expect.equals(member, classMember);
   } else if (checkType == NO_CLASS_MEMBER) {
     Expect.isNull(cls.element.lookupClassMember(memberName));
   }
 
   if (inheritedFrom != null) {
-    MemberSignature inherited = checkType == CHECK_CLASS
+    DeclaredMember inherited = checkType == CHECK_CLASS
         ? inheritedFrom.element.lookupClassMember(memberName)
         : inheritedFrom.element.lookupInterfaceMember(memberName);
     Expect.isNotNull(inherited,
         "No $memberKind member '$memberName' in $inheritedFrom.");
     Expect.equals(inherited.inheritFrom(inheritedFrom), member);
   } else {
     if (erroneousFrom != null || synthesizedFrom != null) {
       Expect.notEquals(checkType, CHECK_CLASS,
           "Arguments 'erroneousFrom' and 'synthesizedFrom' only apply "
           "to interface members.");
       if (synthesizedFrom != null) {
         Expect.isTrue(member is SyntheticMember,
             "Member '$member' is not synthesized.");
       } else {
         Expect.isTrue(member is ErroneousMember,
             "Member '$member' is not erroneous.");
       }
       Set<MemberSignature> members = new Set<MemberSignature>();
       List from = synthesizedFrom != null ? synthesizedFrom : erroneousFrom;
       for (InterfaceType type in from) {
-        MemberSignature inheritedMember =
+        DeclaredMember inheritedMember =
             type.element.lookupInterfaceMember(memberName);
         Expect.isNotNull(inheritedMember);
         members.add(inheritedMember.inheritFrom(type));
       }
       Expect.setEquals(members, member.declarations);
     } else if (declarer != null) {
-      Expect.equals(declarer, member.declarer,
-          "Unexpected declarer '${member.declarer}' of $memberKind member "
+      DeclaredMember declared = member;
+      Expect.equals(declarer, declared.declarer,
+          "Unexpected declarer '${declared.declarer}' of $memberKind member "
           "'$member'. Expected '${declarer}'.");
     } else {
-      Expect.equals(cls.element, member.element.getEnclosingClass());
-      Expect.equals(cls, member.declarer);
+      DeclaredMember declared = member;
+      Expect.equals(cls.element, declared.element.getEnclosingClass());
+      Expect.equals(cls, declared.declarer);
     }
     Expect.equals(isSetter, member.isSetter);
     Expect.equals(isGetter, member.isGetter);
     if (type != null) {
       Expect.equals(type, member.type,
           "Unexpected type of $memberKind member '$member'.");
     }
     if (functionType != null) {
       if (type == null) {
         Expect.equals(member.type, member.functionType,
@@ skipping 534 matching lines @@
     Expect.notEquals(interfaceMember, classMember);
 
     // A: method4(U a)
     // B: --
     // C class: method4(U a) -- inherited from A.
     // C interface: method4(U a) -- inherited from A.
     checkMember(C_this, 'method4', checkType: ALSO_CLASS_MEMBER,
                 inheritedFrom: A_U);
   }));
 }