Tests for `void`.

pkg/compiler/lib/src/resolution/class_members.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.
 
 library dart2js.resolution.compute_members;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names;
 import '../common/resolution.dart' show Resolution;
+import '../core_types.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         LibraryElement,
         Member,
         MemberElement,
         MemberSignature,
         MixinApplicationElement,
@@ skipping 165 matching lines @@
           classMembers[name] = declared;
           checkValidOverride(declared, inherited);
         }
 
         Name name = new Name(element.name, library);
         if (element.isField) {
           ResolutionDartType type = element.computeType(resolution);
           addDeclaredMember(
               name, type, new ResolutionFunctionType.synthesized(type));
           if (!element.isConst && !element.isFinal) {
+            // TODO(floitsch): would be nice to have the voidType directly
+            // on commonElements.
+            ClassElement objectClass = resolution.commonElements.objectClass;
+            ResolutionVoidType voidType = new ResolutionVoidType(objectClass);
             addDeclaredMember(
                 name.setter,
                 type,
                 new ResolutionFunctionType.synthesized(
-                    const ResolutionVoidType(), <ResolutionDartType>[type]));
+                   voidType, <ResolutionDartType>[type]));
           }
         } else if (element.isGetter) {
           ResolutionFunctionType functionType = element.computeType(resolution);
           ResolutionDartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
         } else if (element.isSetter) {
           ResolutionFunctionType functionType = element.computeType(resolution);
           ResolutionDartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.first;
@@ skipping 641 matching lines @@
       }
     }
   }
 
   /// If `true` interface members are the non-static class member.
   bool get interfaceMembersAreClassMembers => _interfaceMembersAreClassMembers;
 
   Map<Name, Member> classMembers;
   Map<Name, MemberSignature> interfaceMembers;
 
+  CommonElements commonElements;
+
   /// Creates the necessary maps and [MembersCreator] for compute members of
   /// this class.
   MembersCreator _prepareCreator(Resolution resolution) {
     if (classMembers == null) {
       _computeInterfaceMembersAreClassMembers(resolution);
       classMembers = new Map<Name, Member>();
       if (!interfaceMembersAreClassMembers) {
         interfaceMembers = new Map<Name, MemberSignature>();
       }
     }
+    commonElements = resolution.commonElements;
     return interfaceMembersAreClassMembers
         ? new ClassMembersCreator(
             resolution, this, computedMemberNames, classMembers)
         : new InterfaceMembersCreator(resolution, this, computedMemberNames,
             classMembers, interfaceMembers);
   }
 
   static Iterable<String> _EMPTY_MEMBERS_NAMES = const <String>[];
 
   /// Compute the members by the name [name] for this class. [names] collects
@@ skipping 77 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }