Access NativeData only through ClosedWorld

pkg/compiler/lib/src/js_backend/native_data.dart

 // Copyright (c) 2016, 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 js_backend.native_data;
 
 import '../common.dart';
 import '../common_elements.dart' show ElementEnvironment;
 import '../elements/entities.dart';
 import '../native/behavior.dart' show NativeBehavior;
@@ skipping 128 matching lines @@
   void setJsInteropLibraryName(LibraryEntity element, String name);
 
   /// Marks [element] as having an `@Anonymous` annotation.
   void markJsInteropClassAsAnonymous(ClassEntity element);
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name);
 
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name);
+
+  /// Closes this builder and creates the resulting [NativeData] object.
+  NativeData close();
 }
 
 class NativeBasicDataBuilderImpl implements NativeBasicDataBuilder {
   /// Tag info for native JavaScript classes names. See
   /// [setNativeClassTagInfo].
   Map<ClassEntity, NativeClassTag> nativeClassTagInfo =
       <ClassEntity, NativeClassTag>{};
 
   /// The JavaScript libraries implemented via typed JavaScript interop.
   Set<LibraryEntity> jsInteropLibraries = new Set<LibraryEntity>();
@@ skipping 85 matching lines @@
   /// Returns `true` if [element] or any of its superclasses is native.
   bool isNativeOrExtendsNative(ClassEntity element) {
     if (element == null) return false;
     if (isNativeClass(element) || isJsInteropClass(element)) {
       return true;
     }
     return isNativeOrExtendsNative(_env.getSuperClass(element));
   }
 }
 
-class NativeDataImpl implements NativeDataBuilder, NativeData {
-  /// Prefix used to escape JS names that are not valid Dart names
-  /// when using JSInterop.
-  static const String _jsInteropEscapePrefix = r'JS$';
-
+class NativeDataBuilderImpl implements NativeDataBuilder {
   final NativeBasicData _nativeBasicData;
 
   /// The JavaScript names for native JavaScript elements implemented.
   Map<MemberEntity, String> nativeMemberName = <MemberEntity, String>{};
 
   /// Cache for [NativeBehavior]s for calling native methods.
   Map<FunctionEntity, NativeBehavior> nativeMethodBehavior =
       <FunctionEntity, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for reading from native fields.
   Map<MemberEntity, NativeBehavior> nativeFieldLoadBehavior =
       <FieldEntity, NativeBehavior>{};
 
   /// Cache for [NativeBehavior]s for writing to native fields.
   Map<MemberEntity, NativeBehavior> nativeFieldStoreBehavior =
       <FieldEntity, NativeBehavior>{};
 
-  /// The JavaScript names for elements implemented via typed JavaScript
+  /// The JavaScript names for libraries implemented via typed JavaScript
   /// interop.
   Map<LibraryEntity, String> jsInteropLibraryNames = <LibraryEntity, String>{};
+
+  /// JavaScript interop classes annotated with `@anonymous`
   Set<ClassEntity> anonymousJsInteropClasses = new Set<ClassEntity>();
+
+  /// The JavaScript names for classes implemented via typed JavaScript
+  /// interop.
   Map<ClassEntity, String> jsInteropClassNames = <ClassEntity, String>{};
 
-  /// The JavaScript names for elements implemented via typed JavaScript
+  /// The JavaScript names for members implemented via typed JavaScript
   /// interop.
   Map<MemberEntity, String> jsInteropMemberNames = <MemberEntity, String>{};
 
-  NativeDataImpl(this._nativeBasicData);
+  NativeDataBuilderImpl(this._nativeBasicData);
 
   /// Sets the native [name] for the member [element]. This name is used for
   /// [element] in the generated JavaScript.
   void setNativeMemberName(MemberEntity element, String name) {
     // TODO(johnniwinther): Avoid setting this more than once. The enqueuer
     // might enqueue [element] several times (before processing it) and computes
     // name on each call to `internalAddToWorkList`.
     assert(invariant(element,
         nativeMemberName[element] == null || nativeMemberName[element] == name,
         message: "Native member name set inconsistently on $element: "
@@ skipping 19 matching lines @@
 
   /// Sets the explicit js interop [name] for the library [element].
   void setJsInteropLibraryName(LibraryEntity element, String name) {
     assert(invariant(element, _nativeBasicData.isJsInteropLibrary(element),
         message:
             'Library $element is not js interop but given a js interop name.'));
     jsInteropLibraryNames[element] = name;
   }
 
   @override
-  bool isAnonymousJsInteropClass(ClassEntity element) {
-    return anonymousJsInteropClasses.contains(element);
-  }
-
-  @override
   void markJsInteropClassAsAnonymous(ClassEntity element) {
     anonymousJsInteropClasses.add(element);
   }
 
   /// Sets the explicit js interop [name] for the class [element].
   void setJsInteropClassName(ClassEntity element, String name) {
     assert(invariant(element, _nativeBasicData.isJsInteropClass(element),
         message:
             'Class $element is not js interop but given a js interop name.'));
     jsInteropClassNames[element] = name;
   }
 
   @override
   void markAsJsInteropMember(MemberEntity element) {
     jsInteropMemberNames[element] = null;
   }
 
-  /// Returns `true` if [element] is explicitly marked as part of JsInterop.
-  bool _isJsInteropMember(MemberEntity element) {
-    return jsInteropMemberNames.containsKey(element);
-  }
-
   /// Sets the explicit js interop [name] for the member [element].
   void setJsInteropMemberName(MemberEntity element, String name) {
-    assert(invariant(element, _isJsInteropMember(element),
+    assert(invariant(element, jsInteropMemberNames.containsKey(element),
         message:
             'Member $element is not js interop but given a js interop name.'));
     jsInteropMemberNames[element] = name;
   }
 
+  @override
+  NativeData close() => new NativeDataImpl(
+      _nativeBasicData,
+      nativeMemberName,
+      nativeMethodBehavior,
+      nativeFieldLoadBehavior,
+      nativeFieldStoreBehavior,
+      jsInteropLibraryNames,
+      anonymousJsInteropClasses,
+      jsInteropClassNames,
+      jsInteropMemberNames);
+}
+
+class NativeDataImpl implements NativeData {
+  /// Prefix used to escape JS names that are not valid Dart names
+  /// when using JSInterop.
+  static const String _jsInteropEscapePrefix = r'JS$';
+
+  final NativeBasicData _nativeBasicData;
+
+  /// The JavaScript names for native JavaScript elements implemented.
+  final Map<MemberEntity, String> nativeMemberName;
+
+  /// Cache for [NativeBehavior]s for calling native methods.
+  final Map<FunctionEntity, NativeBehavior> nativeMethodBehavior;
+
+  /// Cache for [NativeBehavior]s for reading from native fields.
+  final Map<MemberEntity, NativeBehavior> nativeFieldLoadBehavior;
+
+  /// Cache for [NativeBehavior]s for writing to native fields.
+  final Map<MemberEntity, NativeBehavior> nativeFieldStoreBehavior;
+
+  /// The JavaScript names for libraries implemented via typed JavaScript
+  /// interop.
+  final Map<LibraryEntity, String> jsInteropLibraryNames;
+
+  /// JavaScript interop classes annotated with `@anonymous`
+  final Set<ClassEntity> anonymousJsInteropClasses;
+
+  /// The JavaScript names for classes implemented via typed JavaScript
+  /// interop.
+  final Map<ClassEntity, String> jsInteropClassNames;
+
+  /// The JavaScript names for members implemented via typed JavaScript
+  /// interop.
+  final Map<MemberEntity, String> jsInteropMemberNames;
+
+  NativeDataImpl(
+      this._nativeBasicData,
+      this.nativeMemberName,
+      this.nativeMethodBehavior,
+      this.nativeFieldLoadBehavior,
+      this.nativeFieldStoreBehavior,
+      this.jsInteropLibraryNames,
+      this.anonymousJsInteropClasses,
+      this.jsInteropClassNames,
+      this.jsInteropMemberNames);
+
+  @override
+  bool isAnonymousJsInteropClass(ClassEntity element) {
+    return anonymousJsInteropClasses.contains(element);
+  }
+
   /// Returns `true` if [cls] is a native class.
   bool isNativeClass(ClassEntity element) =>
       _nativeBasicData.isNativeClass(element);
 
   /// Returns the list of non-directive native tag words for [cls].
   List<String> getNativeTagsOfClass(ClassEntity cls) =>
       _nativeBasicData.getNativeTagsOfClass(cls);
 
   /// Returns `true` if [cls] has a `!nonleaf` tag word.
   bool hasNativeTagsForcedNonLeaf(ClassEntity cls) =>
@@ skipping 21 matching lines @@
   /// Returns the explicit js interop name for class [element].
   String getJsInteropClassName(ClassEntity element) {
     return jsInteropClassNames[element];
   }
 
   /// Returns the explicit js interop name for member [element].
   String getJsInteropMemberName(MemberEntity element) {
     return jsInteropMemberNames[element];
   }
 
+  /// Returns `true` if [element] is explicitly marked as part of JsInterop.
+  bool _isJsInteropMember(MemberEntity element) {
+    return jsInteropMemberNames.containsKey(element);
+  }
+
   /// Returns `true` if [element] is a JsInterop method.
   bool isJsInteropMember(MemberEntity element) {
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
       FunctionEntity function = element;
       if (!function.isExternal) return false;
 
       if (_isJsInteropMember(function)) return true;
@@ skipping 146 matching lines @@
   int get hashCode => Hashing.listHash(names, isNonLeaf.hashCode);
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! NativeClassTag) return false;
     return equalElements(names, other.names) && isNonLeaf == other.isNonLeaf;
   }
 
   String toString() => text;
 }