Compute and check members for serialization

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 '../compiler.dart' show Compiler;
@@ skipping 806 matching lines @@
   /// When [classMembers] and [interfaceMembers] have not been fully computed
   /// [computedMembersNames] holds the names for which members have already been
   /// computed.
   ///
   /// If [computedMemberNames], [classMembers] and [interfaceMembers] are `null`
   /// no members have been computed, if only [computedMemberNames] is `null` all
   /// members have been computed. A non-null [computedMemberNames] implicitly
   /// includes `call`.
   Iterable<String> computedMemberNames;
 
+  bool _interfaceMembersAreClassMembers;
+
+  /// Compute value of the [_interfaceMembersAreClassMembers] for this class
+  /// and its superclasses.
+  void _ensureInterfaceMembersAreClassMembers(Resolution resolution) {

[Siggi Cherem (dart-lang), 2016/05/31 16:28:31]

rename: change `ensure` to `compute`?

the current name suggest that you are trying to assert/ensure that all members
of this class are class members.

[Johnni Winther, 2016/06/02 09:02:51]

Done.

+    if (_interfaceMembersAreClassMembers == null) {
+      ensureResolved(resolution);
+      ClassMemberMixin superclass = this.superclass;
+      if (superclass != null) {
+        superclass._ensureInterfaceMembersAreClassMembers(resolution);
+      }
+      if ((superclass != null &&
+              (!superclass.interfaceMembersAreClassMembers ||
+                  superclass.isMixinApplication)) ||
+          !interfaces.isEmpty) {
+        _interfaceMembersAreClassMembers = false;
+      } else {
+        _interfaceMembersAreClassMembers = true;
+      }
+    }
+  }
+
   /// If `true` interface members are the non-static class member.
-  bool interfaceMembersAreClassMembers = true;
+  bool get interfaceMembersAreClassMembers => _interfaceMembersAreClassMembers;
 
   Map<Name, Member> classMembers;
   Map<Name, MemberSignature> interfaceMembers;
 
   /// Creates the necessary maps and [MembersCreator] for compute members of
   /// this class.
   MembersCreator _prepareCreator(Resolution resolution) {
     if (classMembers == null) {
-      ensureResolved(resolution);
+      _ensureInterfaceMembersAreClassMembers(resolution);
       classMembers = new Map<Name, Member>();
-
-      if (interfaceMembersAreClassMembers) {
-        ClassMemberMixin superclass = this.superclass;
-        if ((superclass != null &&
-                (!superclass.interfaceMembersAreClassMembers ||
-                    superclass.isMixinApplication)) ||
-            !interfaces.isEmpty) {
-          interfaceMembersAreClassMembers = false;
-        }
-      }
       if (!interfaceMembersAreClassMembers) {
         interfaceMembers = new Map<Name, MemberSignature>();
       }
     }
     return interfaceMembersAreClassMembers
         ? new ClassMembersCreator(
             resolution, this, computedMemberNames, classMembers)
         : new InterfaceMembersCreator(resolution, this, computedMemberNames,
             classMembers, interfaceMembers);
   }
@@ skipping 75 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));
     }
   }
 }