Generate mock libraries and assert that helpers are non-null.

sdk/lib/_internal/compiler/implementation/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 358 matching lines @@
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
-  // TODO(karlklose): split into findHelperFunction and findHelperClass and
+  // TODO(karlklose): Split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
-  Element findHelper(String name)
-      => jsHelperLibrary.findLocal(name);
-  Element findInterceptor(String name)
-      => interceptorsLibrary.findLocal(name);
+  Element findHelper(String name) => find(jsHelperLibrary, name);
+  Element findInterceptor(String name) => find(interceptorsLibrary, name);
+
+  Element find(LibraryElement library, String name) {
+    Element element = library.findLocal(name);
+    assert(invariant(library, element != null,
+        message: "Element '$name' not found in '${library.canonicalUri}'."));
+    return element;
+  }
 
   bool isForeign(Element element) => element.library == foreignLibrary;
 
   bool isBackendLibrary(LibraryElement library) {
     return library == interceptorsLibrary ||
            library == jsHelperLibrary;
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
@@ skipping 378 matching lines @@
       addInterceptors(jsPlainJavaScriptObjectClass, enqueuer, registry);
     } else if (cls == jsUnknownJavaScriptObjectClass) {
       addInterceptors(jsUnknownJavaScriptObjectClass, enqueuer, registry);
     } else if (Elements.isNativeOrExtendsNative(cls)) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
     } else if (cls == jsIndexingBehaviorInterface) {
       // These two helpers are used by the emitter and the codegen.
       // Because we cannot enqueue elements at the time of emission,
       // we make sure they are always generated.
       enqueue(enqueuer, findHelper('isJsIndexable'), registry);
-      enqueue(enqueuer, findInterceptor('dispatchPropertyName'), registry);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls, enqueuer);
   }
 
   void registerUseInterceptor(Enqueuer enqueuer) {
     assert(!enqueuer.isResolutionQueue);
     if (!enqueuer.nativeEnqueuer.hasInstantiatedNativeClasses()) return;
     Registry registry = compiler.globalDependencies;
     enqueue(enqueuer, getNativeInterceptorMethod, registry);
@@ skipping 133 matching lines @@
   void enableNoSuchMethod(Enqueuer world) {
     enqueue(world, getCreateInvocationMirror(), compiler.globalDependencies);
     world.registerInvocation(compiler.noSuchMethodSelector);
   }
 
   void enableIsolateSupport(Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       for (String name in const [START_ROOT_ISOLATE,
                                  '_currentIsolate',
                                  '_callInIsolate']) {
-        Element element = isolateHelperLibrary.find(name);
+        Element element = find(isolateHelperLibrary, name);
         enqueuer.addToWorkList(element);
         compiler.globalDependencies.registerDependency(element);
       }
     } else {
-      enqueuer.addToWorkList(isolateHelperLibrary.find(START_ROOT_ISOLATE));
+      enqueuer.addToWorkList(find(isolateHelperLibrary, START_ROOT_ISOLATE));
     }
   }
 
   bool isAssertMethod(Element element) => element == assertMethod;
 
   void registerRequiredType(DartType type, Element enclosingElement) {
     // 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,
@@ skipping 565 matching lines @@
     } else if (uri ==  DART_FOREIGN_HELPER) {
       foreignLibrary = library;
     } else if (uri == DART_ISOLATE_HELPER) {
       isolateHelperLibrary = library;
     }
   }
 
   void initializeHelperClasses() {
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
-      ClassElement result = jsHelperLibrary.find(name);
+      ClassElement result = findHelper(name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
       return result;
     }
     jsInvocationMirrorClass = lookupHelperClass('JSInvocationMirror');
     boundClosureClass = lookupHelperClass('BoundClosure');
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
       compiler.internalError(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
   }
 
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     return super.onLibraryScanned(library, loader).then((_) {
       Uri uri = library.canonicalUri;
 
-      // TODO(johnniwinther): Assert that the elements are found.
       VariableElement findVariable(String name) {
-        return library.find(name);
+        return find(library, name);
       }
 
       FunctionElement findMethod(String name) {
-        return library.find(name);
+        return find(library, name);
       }
 
       ClassElement findClass(String name) {
-        return library.find(name);
+        return find(library, name);
       }
 
       if (uri == DART_INTERCEPTORS) {
         getInterceptorMethod = findMethod('getInterceptor');
         interceptedNames = findVariable('interceptedNames');
         mapTypeToInterceptor = findVariable('mapTypeToInterceptor');
         getNativeInterceptorMethod = findMethod('getNativeInterceptor');
 
         List<ClassElement> classes = [
           jsInterceptorClass = findClass('Interceptor'),
@@ skipping 13 matching lines @@
           jsFixedArrayClass = findClass('JSFixedArray'),
           jsExtendableArrayClass = findClass('JSExtendableArray'),
           jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject'),
           jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject'),
         ];
 
         jsIndexableClass = findClass('JSIndexable');
         jsMutableIndexableClass = findClass('JSMutableIndexable');
       } else if (uri == DART_JS_HELPER) {
         initializeHelperClasses();
-        assertMethod = jsHelperLibrary.find('assertHelper');
+        assertMethod = findHelper('assertHelper');
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
         typeVariableClass = findClass('TypeVariable');
 
         jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
 
         noSideEffectsClass = findClass('NoSideEffects');
         noThrowsClass = findClass('NoThrows');
         noInlineClass = findClass('NoInline');
         irRepresentationClass = findClass('IrRepresentation');
 
-        getIsolateAffinityTagMarker = library.find('getIsolateAffinityTag');
+        getIsolateAffinityTagMarker = findMethod('getIsolateAffinityTag');
 
-        requiresPreambleMarker = library.find('requiresPreamble');
+        requiresPreambleMarker = findMethod('requiresPreamble');
       } else if (uri == DART_JS_MIRRORS) {
-        disableTreeShakingMarker = library.find('disableTreeShaking');
-        preserveMetadataMarker = library.find('preserveMetadata');
+        disableTreeShakingMarker = find(library, 'disableTreeShaking');
+        preserveMetadataMarker = find(library, 'preserveMetadata');
       } else if (uri == DART_JS_NAMES) {
-        preserveNamesMarker = library.find('preserveNames');
+        preserveNamesMarker = find(library, 'preserveNames');
       } else if (uri == DART_HTML) {
         htmlLibraryIsLoaded = true;
       }
     });
   }
 
   Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     if (!loadedLibraries.containsKey(Compiler.DART_CORE)) {
       return new Future.value();
     }
 
     assert(loadedLibraries.containsKey(Compiler.DART_CORE));
     assert(loadedLibraries.containsKey(DART_INTERCEPTORS));
     assert(loadedLibraries.containsKey(DART_JS_HELPER));
 
     if (jsInvocationMirrorClass != null) {
       jsInvocationMirrorClass.ensureResolved(compiler);
       invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(INVOKE_ON);
     }
 
     // [LinkedHashMap] is reexported from dart:collection and can therefore not
     // be loaded from dart:core in [onLibraryScanned].
     mapLiteralClass = compiler.coreLibrary.find('LinkedHashMap');
+    assert(invariant(compiler.coreLibrary, mapLiteralClass != null,
+        message: "Element 'LinkedHashMap' not found in 'dart:core'."));
 
     implementationClasses = <ClassElement, ClassElement>{};
     implementationClasses[compiler.intClass] = jsIntClass;
     implementationClasses[compiler.boolClass] = jsBoolClass;
     implementationClasses[compiler.numClass] = jsNumberClass;
     implementationClasses[compiler.doubleClass] = jsDoubleClass;
     implementationClasses[compiler.stringClass] = jsStringClass;
     implementationClasses[compiler.listClass] = jsArrayClass;
     implementationClasses[compiler.nullClass] = jsNullClass;
 
@@ skipping 538 matching lines @@
             backend.getCheckSubtypeOfRuntimeType(), registry);
         if (inCheckedMode) {
           registerBackendStaticInvocation(
               backend.getAssertSubtypeOfRuntimeType(), registry);
         }
       }
       registerBackendInstantiation(backend.compiler.listClass, registry);
     }
     if (type is FunctionType) {
       registerBackendStaticInvocation(
-          backend.findHelper('functionTypeTestMetaHelper'), registry);
+          backend.find(backend.jsHelperLibrary, 'functionTypeTestMetaHelper'),
+          registry);
     }
     if (type.element != null && type.element.isNative) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
       registerBackendStaticInvocation(
-          backend.findHelper('defineProperty'), registry);
+          backend.find(backend.jsHelperLibrary, 'defineProperty'), registry);
     }
   }
 
   void onTypeVariableBoundCheck(Registry registry) {
     assert(registry.isForResolution);
     registerBackendStaticInvocation(backend.getThrowTypeError(), registry);
     registerBackendStaticInvocation(backend.getAssertIsSubtype(), registry);
   }
 
   void onAbstractClassInstantiation(Registry registry) {
@@ skipping 35 matching lines @@
         backend.getCreateInvocationMirror(), registry);
     registerBackendStaticInvocation(
         backend.compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD),
         registry);
     registerBackendInstantiation(backend.compiler.listClass, registry);
   }
 
   void onConstantMap(Registry registry) {
     assert(registry.isForResolution);
     void enqueue(String name) {
-      Element e = backend.findHelper(name);
+      Element e = backend.find(backend.jsHelperLibrary, name);
       registerBackendInstantiation(e, registry);
     }
 
     enqueue(JavaScriptMapConstant.DART_CLASS);
     enqueue(JavaScriptMapConstant.DART_PROTO_CLASS);
     enqueue(JavaScriptMapConstant.DART_STRING_CLASS);
     enqueue(JavaScriptMapConstant.DART_GENERAL_CLASS);
   }
 
   /// Called when resolving the `Symbol` constructor.
   void onSymbolConstructor(Registry registry) {
     assert(registry.isForResolution);
     // Make sure that _internals.Symbol.validated is registered.
     assert(backend.compiler.symbolValidatedConstructor != null);
     registerBackendStaticInvocation(
         backend.compiler.symbolValidatedConstructor, registry);
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }