Refactor BackendHelpers to be reusageable with KernelWorldBuilder

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 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 96 matching lines @@
   // but may be inlined in a loop.
   static const int _mayInlineInLoopMustNotOutside = 1;
   // The function can be inlined in a loop, but not outside.
   static const int _canInlineInLoopMustNotOutside = 2;
   // May-inline means that we know that it can be inlined inside a loop, but
   // don't know about the general case yet.
   static const int _canInlineInLoopMayInlineOutside = 3;
   static const int _canInline = 4;
   static const int _mustInline = 5;
 
-  final Map<FunctionElement, int> _cachedDecisions =
-      new Map<FunctionElement, int>();
+  final Map<MethodElement, int> _cachedDecisions =
+      new Map<MethodElement, int>();
 
   /// Returns the current cache decision. This should only be used for testing.
   int getCurrentCacheDecisionForTesting(Element element) {
     return _cachedDecisions[element];
   }
 
   // Returns `true`/`false` if we have a cached decision.
   // Returns `null` otherwise.
-  bool canInline(FunctionElement element, {bool insideLoop}) {
+  bool canInline(MethodElement element, {bool insideLoop}) {
     int decision = _cachedDecisions[element];
 
     if (decision == null) {
       // These synthetic elements are not yet present when we initially compute
       // this cache from metadata annotations, so look for their parent.
       if (element is ConstructorBodyElement) {
         ConstructorBodyElement body = element;
         decision = _cachedDecisions[body.constructor];
       }
       if (decision == null) {
@@ skipping 34 matching lines @@
         case _canInline:
         case _mustInline:
           return true;
       }
     }
 
     // Quiet static checker.
     return null;
   }
 
-  void markAsInlinable(FunctionElement element, {bool insideLoop}) {
+  void markAsInlinable(MethodElement element, {bool insideLoop}) {
     int oldDecision = _cachedDecisions[element];
 
     if (oldDecision == null) {
       oldDecision = _unknown;
     }
 
     if (insideLoop) {
       switch (oldDecision) {
         case _mustNotInline:
           throw new SpannableAssertionFailure(
@@ skipping 34 matching lines @@
           break;
 
         case _canInline:
         case _mustInline:
           // Do nothing.
           break;
       }
     }
   }
 
-  void markAsNonInlinable(FunctionElement element, {bool insideLoop: true}) {
+  void markAsNonInlinable(MethodElement element, {bool insideLoop: true}) {
     int oldDecision = _cachedDecisions[element];
 
     if (oldDecision == null) {
       oldDecision = _unknown;
     }
 
     if (insideLoop) {
       switch (oldDecision) {
         case _canInlineInLoopMustNotOutside:
         case _canInlineInLoopMayInlineOutside:
@@ skipping 37 matching lines @@
 
         case _mayInlineInLoopMustNotOutside:
         case _canInlineInLoopMustNotOutside:
         case _mustNotInline:
           // Do nothing.
           break;
       }
     }
   }
 
-  void markAsMustInline(FunctionElement element) {
+  void markAsMustInline(MethodElement element) {
     _cachedDecisions[element] = _mustInline;
   }
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
   TYPEVARIABLE_REFERENCE, // Reference to a type in reflection data.
   NAME
 }
@@ skipping 238 matching lines @@
   JavaScriptBackendSerialization serialization;
 
   StagedWorldImpactBuilder constantImpactsForResolution =
       new StagedWorldImpactBuilder();
 
   StagedWorldImpactBuilder constantImpactsForCodegen =
       new StagedWorldImpactBuilder();
 
   final NativeData nativeData = new NativeData();
 
-  final BackendHelpers helpers;
+  BackendHelpers helpers;
   final BackendImpacts impacts;
   BackendClasses backendClasses;
 
   final JSFrontendAccess frontend;
 
   Tracer tracer;
 
   JavaScriptBackend(Compiler compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useNewSourceInfo: false,
       bool useKernel: false})
       : oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new _RuntimeTypes(compiler),
         rtiEncoder = new _RuntimeTypesEncoder(compiler),
         specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
         annotations = new Annotations(compiler),
         this.sourceInformationStrategy = generateSourceMap
             ? (useNewSourceInfo
                 ? new PositionSourceInformationStrategy()
                 : const StartEndSourceInformationStrategy())
             : const JavaScriptSourceInformationStrategy(),
-        helpers = new BackendHelpers(compiler),
         impacts = new BackendImpacts(compiler),
         frontend = new JSFrontendAccess(compiler),
         super(compiler) {
+    helpers =
+        new BackendHelpers(compiler.elementEnvironment, this, commonElements);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     lookupMapAnalysis = new LookupMapAnalysis(this, reporter);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
@@ skipping 73 matching lines @@
     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;
   }
 
   bool _isValidBackendUse(Element element) {
     assert(invariant(element, element.isDeclaration, message: ""));
-    if (element == helpers.streamIteratorConstructor ||
+    if (element is ConstructorElement &&
+        (element == helpers.streamIteratorConstructor ||
         compiler.commonElements.isSymbolConstructor(element) ||
         helpers.isSymbolValidatedConstructor(element) ||
-        element == helpers.syncCompleterConstructor ||
-        element == commonElements.symbolClass ||
+        element == helpers.syncCompleterConstructor)) {
+    // TODO(johnniwinther): These are valid but we could be more precise.
+    return true;
+    } else if (element == commonElements.symbolClass ||
         element == helpers.objectNoSuchMethod) {
       // TODO(johnniwinther): These are valid but we could be more precise.
       return true;
     } else if (element.implementationLibrary.isPatch ||
         // Needed to detect deserialized injected elements, that is
         // element declared in patch files.
         (element.library.isPlatformLibrary &&
             element.sourcePosition.uri.path
                 .contains('_internal/js_runtime/lib/')) ||
         element.library == helpers.jsHelperLibrary ||
@@ skipping 392 matching lines @@
       FunctionConstantValue function = constant;
       impactBuilder
           .registerStaticUse(new StaticUse.staticTearOff(function.element));
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstantValue interceptor = constant;
       ClassElement cls = interceptor.cls;
       computeImpactForInstantiatedConstantType(cls.thisType, impactBuilder);
     } else if (constant.isType) {
       if (isForResolution) {
+        MethodElement helper = helpers.createRuntimeType;
         impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
             // TODO(johnniwinther): Find the right [CallStructure].
-            helpers.createRuntimeType,
+            helper,
             null));
-        registerBackendUse(helpers.createRuntimeType);
+        registerBackendUse(helper);
       }
       impactBuilder
           .registerTypeUse(new TypeUse.instantiation(backendClasses.typeType));
     }
     lookupMapAnalysis.registerConstantKey(constant);
   }
 
   void computeImpactForInstantiatedConstantType(
       DartType type, WorldImpactBuilder impactBuilder) {
     if (type is ResolutionInterfaceType) {
@@ skipping 773 matching lines @@
         metadata.ensureResolved(resolution);
         ConstantValue constant =
             constants.getConstantValueForMetadata(metadata);
         constants.addCompileTimeConstantForEmission(constant);
       }
       return true;
     }
     return false;
   }
 
-  void onLibraryCreated(LibraryElement library) {
-    helpers.onLibraryCreated(library);
-  }
-
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     return super.onLibraryScanned(library, loader).then((_) {
       if (library.isPlatformLibrary &&
           // Don't patch library currently disallowed.
           !library.isSynthesized &&
           !library.isPatched &&
           // Don't patch deserialized libraries.
           !compiler.serialization.isDeserialized(library)) {
         // Apply patch, if any.
         Uri patchUri = compiler.resolvePatchUri(library.canonicalUri.path);
         if (patchUri != null) {
           return compiler.patchParser.patchLibrary(loader, patchUri, library);
         }
       }
     }).then((_) {
-      helpers.onLibraryScanned(library);
       Uri uri = library.canonicalUri;
       if (uri == Uris.dart_html) {
         htmlLibraryIsLoaded = true;
       } else if (uri == LookupMapAnalysis.PACKAGE_LOOKUP_MAP) {
         lookupMapAnalysis.init(library);
       }
       annotations.onLibraryScanned(library);
     });
   }
 
@@ skipping 242 matching lines @@
       for (Element closure in closureMap[null]) {
         if (referencedFromMirrorSystem(closure)) {
           reflectableMembers.add(closure);
           foundClosure = true;
         }
       }
     }
     // As we do not think about closures as classes, yet, we have to make sure
     // their superclasses are available for reflection manually.
     if (foundClosure) {
-      reflectableMembers.add(helpers.closureClass);
+      ClassElement cls = helpers.closureClass;
+      reflectableMembers.add(cls);
     }
     Set<Element> closurizedMembers =
         compiler.resolutionWorldBuilder.closurizedMembers;
     if (closurizedMembers.any(reflectableMembers.contains)) {
-      reflectableMembers.add(helpers.boundClosureClass);
+      ClassElement cls = helpers.boundClosureClass;
+      reflectableMembers.add(cls);
     }
     // Add typedefs.
     reflectableMembers
         .addAll(closedWorld.allTypedefs.where(referencedFromMirrorSystem));
     // Register all symbols of reflectable elements
     for (Element element in reflectableMembers) {
       symbolsUsed.add(element.name);
     }
     _membersNeededForReflection = reflectableMembers;
   }
@@ skipping 303 matching lines @@
     if (hasNoThrows && !hasNoInline) {
       reporter.internalError(
           element, "@NoThrows() should always be combined with @NoInline.");
     }
     if (hasNoSideEffects && !hasNoInline) {
       reporter.internalError(element,
           "@NoSideEffects() should always be combined with @NoInline.");
     }
   }
 
-  FunctionElement helperForBadMain() => helpers.badMain;
+  MethodElement helperForBadMain() => helpers.badMain;
 
-  FunctionElement helperForMissingMain() => helpers.missingMain;
+  MethodElement helperForMissingMain() => helpers.missingMain;
 
-  FunctionElement helperForMainArity() => helpers.mainHasTooManyParameters;
+  MethodElement helperForMainArity() => helpers.mainHasTooManyParameters;
 
   @override
   WorldImpact computeMainImpact(MethodElement mainMethod,
       {bool forResolution}) {
     WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
     if (mainMethod.parameters.isNotEmpty) {
       impactTransformer.registerBackendImpact(
           mainImpact, impacts.mainWithArguments);
       mainImpact.registerStaticUse(
           new StaticUse.staticInvoke(mainMethod, CallStructure.TWO_ARGS));
@@ skipping 481 matching lines @@
           break;
         case BackendFeature.needToInitializeIsolateAffinityTag:
           backend.needToInitializeIsolateAffinityTag = true;
           break;
       }
     }
   }
 
   /// Register [type] as required for the runtime type information system.
   void registerRequiredType(ResolutionDartType type) {
+    if (!type.isInterfaceType) return;
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
     // defined (that is the enclosing class of the current element being
     // resolved) and the class of [type]. If the class of [type] requires RTI,
     // then the class of the type variable does too.
     ClassElement contextClass = Types.getClassContext(type);
     if (contextClass != null) {
       backend.rti.registerRtiDependency(type.element, contextClass);
     }
   }
@@ skipping 261 matching lines @@
   @override
   bool isNativeClass(ClassElement element) {
     return helpers.backend.isNative(element);
   }
 
   @override
   bool isNativeMember(MemberElement element) {
     return helpers.backend.isNative(element);
   }
 }