Support serialization of WorldImpact

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 486 matching lines @@
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptImpactTransformer impactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   bool enabledNoSuchMethod = false;
 
   SourceInformationStrategy sourceInformationStrategy;
 
+  JavaScriptBackendSerialization serialization;
+
+  final NativeData nativeData = new NativeData();
+
   final BackendHelpers helpers;
   final BackendImpacts impacts;
 
   JavaScriptBackend(Compiler compiler,
                     {bool generateSourceMap: true,
                      bool useStartupEmitter: false,
                      bool useNewSourceInfo: false})
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
@@ skipping 18 matching lines @@
     jsInteropAnalysis = new JsInteropAnalysis(this);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.useCpsIr
          ? new CpsFunctionCompiler(
              compiler, this, sourceInformationStrategy)
          : new SsaFunctionCompiler(this, sourceInformationStrategy);
+    serialization = new JavaScriptBackendSerialization(this);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
@@ skipping 49 matching lines @@
       bool registerUse = false;
       if (element == helpers.streamIteratorConstructor ||
           element == helpers.compiler.symbolConstructor ||
           element == helpers.compiler.symbolValidatedConstructor ||
           element == helpers.syncCompleterConstructor ||
           element == coreClasses.symbolClass ||
           element == helpers.objectNoSuchMethod) {
         // TODO(johnniwinther): These are valid but we could be more precise.
         registerUse = true;
       } else if (element.implementationLibrary.isPatch ||
+                 // Needed to detect deserialized patch elements.
+                 (element.library.isPlatformLibrary &&
+                  element.sourcePosition.uri.path.contains('_internal/js_runtime/lib/')) ||

[Siggi Cherem (dart-lang), 2016/03/16 23:40:14]

nit: 80 (same below)

[Siggi Cherem (dart-lang), 2016/03/16 23:40:14]

do we have guarantees that the uri will contain that?

In particular, if serialization merges the library + the patch, are we picking
the uri from the patch and not the library?

[Johnni Winther, 2016/03/17 10:49:37]

Done.

[Johnni Winther, 2016/03/17 10:49:37]

This is not for patch elements (we must register the declaration element), but
for injected elements, i.e. elements declared in the patch files.

                  element.library == helpers.jsHelperLibrary ||
                  element.library == helpers.interceptorsLibrary ||
                  element.library == helpers.isolateHelperLibrary) {
         // TODO(johnniwinther): We should be more precise about these.
         registerUse = true;
       } else if (element == coreClasses.listClass ||
                  element == helpers.mapLiteralClass ||
                  element == coreClasses.functionClass ||
                  element == coreClasses.stringClass) {
         // TODO(johnniwinther): Avoid these.
         registerUse = true;
       }
       if (!registerUse) {
         assert(invariant(element, false,

[Siggi Cherem (dart-lang), 2016/03/16 23:40:14]

Seems like the `registerUse` logic is mainly for this assertion, should we
change this code to only do this detailed checks in the assertion itself? That
would also make the register method simpler. For example:

  void registerBackendUse(Element element) {
    if (element == null) return;
    assert(invariant(element, _isValidBackendUse(element), ...);
    helpersUsed.add(element.declaration);
    if (element.isClass && element.isPatched) {
      helpersUsed.add(element.implementation);
    }
  }
  
  bool _isValidBackendUse(Element element) =>
      // TODO(johnniwinther): These are valid but we could be more precise.
      element == helpers.streamIteratorConstructor ||
      element == helpers.compiler.symbolConstructor ||
      element == helpers.compiler.symbolValidatedConstructor ||
      element == helpers.syncCompleterConstructor ||
      element == coreClasses.symbolClass ||
      element == helpers.objectNoSuchMethod ||
      // TODO(johnniwinther): We should be more precise about these.
      element.implementationLibrary.isPatch ||
      element.library == helpers.jsHelperLibrary ||
      element.library == helpers.interceptorsLibrary ||
      element.library == helpers.isolateHelperLibrary ||
      // TODO(johnniwinther): Avoid these.
      element == coreClasses.listClass ||
      element == helpers.mapLiteralClass ||
      element == coreClasses.functionClass ||
      element == coreClasses.stringClass;

[Johnni Winther, 2016/03/17 10:49:37]

Good point. Done.

-            message: "Backend use of $element is not allowed."));
+            message: "Backend use of $element is not allowed ${element.sourcePosition}."));
         return element;
       }
       helpersUsed.add(element.declaration);
       if (element.isClass && element.isPatched) {
         // Both declaration and implementation may declare fields, so we
         // add both to the list of helpers.
         helpersUsed.add(element.implementation);
       }
     }
     return element;
@@ skipping 66 matching lines @@
     return !selector.isGetter && !compiler.hasIncrementalSupport;
   }
 
   /**
    * Returns `true` if [member] is called from a subclass via `super`.
    */
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
-  /// The JavaScript names for elements implemented via typed JavaScript
-  /// interop.
-  Map<Element, String> jsInteropNames = <Element, String>{};
-
-  /// The JavaScript names for native JavaScript elements implemented.
-  Map<Element, String> nativeMemberName = <Element, String>{};
-
-  /// Tag info for native JavaScript classes names. See
-  /// [setNativeClassTagInfo].
-  Map<ClassElement, String> nativeClassTagInfo = <ClassElement, String>{};
-
-  /// Returns `true` if [element] is explicitly marked as part of JsInterop.
-  bool _isJsInterop(Element element) {
-    return jsInteropNames.containsKey(element.declaration);
-  }
-
-  /// Returns [element] as an explicit part of JsInterop. The js interop name is
-  /// expected to be computed later.
-  void markAsJsInterop(Element element) {
-    jsInteropNames[element.declaration] = null;
-  }
-
-  /// Sets the explicit js interop [name] for [element].
-  void setJsInteropName(Element element, String name) {
-    assert(invariant(element,
-        isJsInterop(element),
-        message:
-          'Element $element is not js interop but given a js interop name.'));
-    jsInteropNames[element.declaration] = name;
-  }
-
-  /// Returns the explicit js interop name for [element].
-  String getJsInteropName(Element element) {
-    return jsInteropNames[element.declaration];
-  }
-
   /// Returns `true` if [element] is part of JsInterop.
   @override
-  bool isJsInterop(Element element) {
-    // An function is part of JsInterop in the following cases:
-    // * It has a jsInteropName annotation
-    // * It is external member of a class or library tagged as JsInterop.
-    if (element.isFunction || element.isConstructor || element.isAccessor) {
-      FunctionElement function = element;
-      if (!function.isExternal) return false;
-
-      if (_isJsInterop(function)) return true;
-      if (function.isClassMember) return isJsInterop(function.contextClass);
-      if (function.isTopLevel) return isJsInterop(function.library);
-      return false;
-    } else {
-      return _isJsInterop(element);
-    }
-  }
-
-  /// Returns `true` if the name of [element] is fixed for the generated
-  /// JavaScript.
-  bool hasFixedBackendName(Element element) {
-    return isJsInterop(element) ||
-        nativeMemberName.containsKey(element.declaration);
-  }
-
-  String _jsNameHelper(Element element) {
-    String jsInteropName = jsInteropNames[element.declaration];
-    assert(invariant(element,
-        !(_isJsInterop(element) && jsInteropName == null),
-        message:
-            'Element $element is js interop but js interop name has not yet '
-            'been computed.'));
-    if (jsInteropName != null && jsInteropName.isNotEmpty) {
-      return jsInteropName;
-    }
-    return element.isLibrary ? 'self' : element.name;
-  }
-
-  /// Computes the name for [element] to use in the generated JavaScript. This
-  /// is either given through a native annotation or a js interop annotation.
-  String getFixedBackendName(Element element) {
-    String name = nativeMemberName[element.declaration];
-    if (name == null && isJsInterop(element)) {
-      // If an element isJsInterop but _isJsInterop is false that means it is
-      // considered interop as the parent class is interop.
-      name = _jsNameHelper(
-          element.isConstructor ? element.enclosingClass : element);
-      nativeMemberName[element.declaration] = name;
-    }
-    return name;
-  }
+  bool isJsInterop(Element element) => nativeData.isJsInterop(element);
 
   /// Whether [element] corresponds to a native JavaScript construct either
   /// through the native mechanism (`@Native(...)` or the `native` pseudo
   /// keyword) which is only allowed for internal libraries or via the typed
   /// JavaScriptInterop mechanism which is allowed for user libraries.
   @override
-  bool isNative(Element element) {
-    if (isJsInterop(element)) return true;
-    if (element.isClass) {
-      return nativeClassTagInfo.containsKey(element.declaration);
-    } else {
-      return nativeMemberName.containsKey(element.declaration);
-    }
-  }
-
-  /// Sets the native [name] for the member [element]. This name is used for
-  /// [element] in the generated JavaScript.
-  void setNativeMemberName(MemberElement 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.declaration] == null ||
-        nativeMemberName[element.declaration] == name,
-        message:
-          "Native member name set inconsistently on $element: "
-          "Existing name '${nativeMemberName[element.declaration]}', "
-          "new name '$name'."));
-    nativeMemberName[element.declaration] = name;
-  }
-
-  /// Sets the native tag info for [cls].
-  ///
-  /// The tag info string contains comma-separated 'words' which are either
-  /// dispatch tags (having JavaScript identifier syntax) and directives that
-  /// begin with `!`.
-  void setNativeClassTagInfo(ClassElement cls, String tagInfo) {
-    // TODO(johnniwinther): Assert that this is only called once. The memory
-    // compiler copies pre-processed elements into a new compiler through
-    // [Compiler.onLibraryScanned] and thereby causes multiple calls to this
-    // method.
-    assert(invariant(cls,
-        nativeClassTagInfo[cls.declaration] == null ||
-        nativeClassTagInfo[cls.declaration] == tagInfo,
-        message:
-          "Native tag info set inconsistently on $cls: "
-          "Existing tag info '${nativeClassTagInfo[cls.declaration]}', "
-          "new tag info '$tagInfo'."));
-    nativeClassTagInfo[cls.declaration] = tagInfo;
-  }
-
-  /// Returns the list of native tag words for [cls].
-  List<String> getNativeTagsOfClassRaw(ClassElement cls) {
-    String quotedName = nativeClassTagInfo[cls.declaration];
-    return quotedName.substring(1, quotedName.length - 1).split(',');
-  }
-
-  /// Returns the list of non-directive native tag words for [cls].
-  List<String> getNativeTagsOfClass(ClassElement cls) {
-    return getNativeTagsOfClassRaw(cls).where(
-        (s) => !s.startsWith('!')).toList();
-  }
-
-  /// Returns `true` if [cls] has a `!nonleaf` tag word.
-  bool hasNativeTagsForcedNonLeaf(ClassElement cls) {
-    return getNativeTagsOfClassRaw(cls).contains('!nonleaf');
-  }
+  bool isNative(Element element) => nativeData.isNative(element);
 
   bool isNativeOrExtendsNative(ClassElement element) {
     if (element == null) return false;
     if (isNative(element) || isJsInterop(element)) {
       return true;
     }
     assert(element.isResolved);
     return isNativeOrExtendsNative(element.superclass);
   }
 
@@ skipping 122 matching lines @@
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(resolution);
     coreClasses.objectClass.forEachMember((_, Element member) {
       if (member.isGenerativeConstructor) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
-      assert(interceptorMember.enclosingClass == interceptorClass);
+      assert(invariant(
+          interceptorMember,
+          interceptorMember.enclosingClass == interceptorClass,
+          message:
+            "Member ${member.name} not overridden in ${interceptorClass}. "
+            "Found $interceptorMember from "
+            "${interceptorMember.enclosingClass}."));
     });
   }
 
   void addInterceptorsForNativeClassMembers(
       ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
           reporter.reportErrorMessage(
@@ skipping 179 matching lines @@
             compiler.globalDependencies);
         enqueueClass(enqueuer, helpers.jsJavaScriptObjectClass, registry);
         enqueueClass(enqueuer, helpers.jsPlainJavaScriptObjectClass, registry);
         enqueueClass(enqueuer, helpers.jsJavaScriptFunctionClass, registry);
       } else if (cls == helpers.mapLiteralClass) {
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         Element getFactory(String name, int arity) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
-          ClassElement implementation = cls.patch != null ? cls.patch : cls;
+          ClassElement implementation = cls.implementation;
           ConstructorElement ctor = implementation.lookupConstructor(name);
           if (ctor == null ||
               (Name.isPrivateName(name) &&
                ctor.library != helpers.mapLiteralClass.library)) {
             reporter.internalError(
                 helpers.mapLiteralClass,
                 "Map literal class ${helpers.mapLiteralClass} missing "
                 "'$name' constructor"
                 "  ${helpers.mapLiteralClass.constructors}");
           }
           return ctor;
         }
         Element getMember(String name) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
-          ClassElement implementation = cls.patch != null ? cls.patch : cls;
+          ClassElement implementation = cls.implementation;
           Element element = implementation.lookupLocalMember(name);
           if (element == null || !element.isFunction || !element.isStatic) {
             reporter.internalError(helpers.mapLiteralClass,
                 "Map literal class ${helpers.mapLiteralClass} missing "
                 "'$name' static member function");
           }
           return element;
         }
         helpers.mapLiteralConstructor = getFactory('_literal', 1);
         helpers.mapLiteralConstructorEmpty = getFactory('_empty', 0);
@@ skipping 1427 matching lines @@
   @override
   Uri resolvePatchUri(String libraryName, Uri platformConfigUri) {
     String patchLocation = _patchLocations[libraryName];
     if (patchLocation == null) return null;
     return platformConfigUri.resolve(patchLocation);
   }
 
   @override
   ImpactStrategy createImpactStrategy(
       {bool supportDeferredLoad: true,
-       bool supportDumpInfo: true}) {
+       bool supportDumpInfo: true,
+       bool supportSerialization: true}) {
     return new JavaScriptImpactStrategy(
         resolution,
         compiler.dumpInfoTask,
         supportDeferredLoad: supportDeferredLoad,
-        supportDumpInfo: supportDumpInfo);
+        supportDumpInfo: supportDumpInfo,
+        supportSerialization: supportSerialization);
   }
 }
 
 /// Handling of special annotations for tests.
 class Annotations {
   static final Uri PACKAGE_EXPECT =
       new Uri(scheme: 'package', path: 'expect/expect.dart');
 
   final Compiler compiler;
 
@@ skipping 455 matching lines @@
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }
 
 class JavaScriptImpactStrategy extends ImpactStrategy {
   final Resolution resolution;
   final DumpInfoTask dumpInfoTask;
   final bool supportDeferredLoad;
   final bool supportDumpInfo;
+  final bool supportSerialization;
 
   JavaScriptImpactStrategy(this.resolution,
                            this.dumpInfoTask,
                            {this.supportDeferredLoad,
-                            this.supportDumpInfo});
+                            this.supportDumpInfo,
+                            this.supportSerialization});
 
   @override
   void visitImpact(Element element,
                    WorldImpact impact,
                    WorldImpactVisitor visitor,
                    ImpactUseCase impactUse) {
     // TODO(johnniwinther): Compute the application strategy once for each use.
     if (impactUse == ResolutionEnqueuer.IMPACT_USE) {
-      if (supportDeferredLoad) {
+      if (supportDeferredLoad || supportSerialization) {
         impact.apply(visitor);
       } else {
         impact.apply(visitor);
         resolution.uncacheWorldImpact(element);
       }
     } else if (impactUse == DeferredLoadTask.IMPACT_USE) {
       impact.apply(visitor);
       // Impacts are uncached globally in [onImpactUsed].
     } else if (impactUse == DumpInfoTask.IMPACT_USE) {
       impact.apply(visitor);
       dumpInfoTask.unregisterImpact(element);
     } else {
       impact.apply(visitor);
     }
   }
 
   @override
   void onImpactUsed(ImpactUseCase impactUse) {
-    if (impactUse == DeferredLoadTask.IMPACT_USE) {
+    if (impactUse == DeferredLoadTask.IMPACT_USE &&
+        !supportSerialization) {
       resolution.emptyCache();
     }
   }
 }