Remove JavaScriptBackend from ClosedWorldBase

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.
 
 library js_backend.backend;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
@@ skipping 753 matching lines @@
     compiler.elementEnvironment.getThisType(commonElements.jsArrayClass);
     compiler.elementEnvironment
         .getThisType(commonElements.jsExtendableArrayClass);
 
     validateInterceptorImplementsAllObjectMethods(
         commonElements.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(commonElements.jsNullClass);
   }
 
+  void onResolutionEnd() {

[Siggi Cherem (dart-lang), 2017/04/18 15:58:05]

it seems a bit confusing to have two events called "End" and "Complete", looking
at the name it's not clear why they are different.

Since we are here, I actually want to move a way from the onEvent names. I
rather have names that describe what the method is doing. For example:

  onResolutionEnd => split into "buildUsage()" and "buildInterceptorData()"
  onResolutionComplete() => buildAnalysisData()

"Analysis" is a bit general, a better name would be nice :)

Thoughts?

[Johnni Winther, 2017/04/19 09:30:33]

The actually order in which these objects are created is still fluctuating (some
still get a Compiler object and do everything lazily). I'd rather wait until the
order has stabilized to refactor how and what we call these.

Change the name of [onResolutionComplete] to [onResolutionClosedWorld] and added
comments to [onResolutionStart], [onResolutionEnd] and [onResolutionClosedWorld]
to clarify when these are called.

+    _backendUsage = backendUsageBuilder.close();
+    _interceptorData = interceptorDataBuilder.onResolutionComplete();
+  }
+
   void onResolutionComplete(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (MemberEntity entity
         in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
     mirrorsDataBuilder.computeMembersNeededForReflection(
         compiler.enqueuer.resolution.worldBuilder, closedWorld);
-    _backendUsage = backendUsageBuilder.close();
     _rtiNeed = rtiNeedBuilder.computeRuntimeTypesNeed(
         compiler.enqueuer.resolution.worldBuilder,
         closedWorld,
         compiler.types,
         commonElements,
         _backendUsage,
         enableTypeAssertions: compiler.options.enableTypeAssertions);
-    _interceptorData = interceptorDataBuilder.onResolutionComplete(closedWorld);
     _oneShotInterceptorData =
         new OneShotInterceptorData(interceptorData, commonElements);
     mirrorsResolutionAnalysis.onResolutionComplete();
   }
 
   void onTypeInferenceComplete(GlobalTypeInferenceResults results) {
     noSuchMethodRegistry.onTypeInferenceComplete(results);
   }
 
   /// Called when resolving a call to a foreign function.
@@ skipping 692 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }