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

sdk/lib/_internal/compiler/implementation/js_backend/backend.dart

Index: sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
diff --git a/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart b/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
index dd9a80ca73d2606b22414a5a0d675100eeecb51e..0300b8e83a9d7384f35eee88f8216efd30401a24 100644
--- a/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
+++ b/sdk/lib/_internal/compiler/implementation/js_backend/backend.dart
@@ -351,12 +351,17 @@ class JavaScriptBackend extends Backend {
     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;
 
@@ -663,13 +668,13 @@ class JavaScriptBackend extends Backend {
           || cls == compiler.numClass) {
         // The backend will try to optimize number operations and use the
         // `iae` helper directly.
-        enqueue(enqueuer, findHelper('iae'), registry);
+        enqueue(enqueuer, find(jsHelperLibrary, 'iae'), registry);

[karlklose, 2014/07/03 08:31:15]

Why did you change all the calls to findHelper? I think it reads nicer.

[Johnni Winther, 2014/07/03 09:23:25]

Changed to findHelper.

       } else if (cls == compiler.listClass
                  || cls == compiler.stringClass) {
         // The backend will try to optimize array and string access and use the
         // `ioore` and `iae` helpers directly.
-        enqueue(enqueuer, findHelper('ioore'), registry);
-        enqueue(enqueuer, findHelper('iae'), registry);
+        enqueue(enqueuer, find(jsHelperLibrary, 'ioore'), registry);
+        enqueue(enqueuer, find(jsHelperLibrary, 'iae'), registry);
       } else if (cls == compiler.functionClass) {
         enqueueClass(enqueuer, closureClass, registry);
       } else if (cls == compiler.mapClass) {
@@ -711,7 +716,7 @@ class JavaScriptBackend extends Backend {
       }
     }
     if (cls == closureClass) {
-      enqueue(enqueuer, findHelper('closureFromTearOff'), registry);
+      enqueue(enqueuer, find(jsHelperLibrary, 'closureFromTearOff'), registry);
     }
     ClassElement result = null;
     if (cls == compiler.stringClass || cls == jsStringClass) {
@@ -754,8 +759,7 @@ class JavaScriptBackend extends Backend {
       // 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);
+      enqueue(enqueuer, find(jsHelperLibrary, 'isJsIndexable'), registry);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls, enqueuer);
@@ -786,11 +790,11 @@ class JavaScriptBackend extends Backend {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
-      Element e = findHelper('boolConversionCheck');
+      Element e = find(jsHelperLibrary, 'boolConversionCheck');
       if (e != null) enqueue(world, e, registry);
     }
     if (TRACE_CALLS) {
-      traceHelper = findHelper('traceHelper');
+      traceHelper = find(jsHelperLibrary, 'traceHelper');
       assert(traceHelper != null);
       enqueueInResolution(traceHelper, registry);
     }
@@ -881,7 +885,7 @@ class JavaScriptBackend extends Backend {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
-      enqueue(world, findHelper('defineProperty'), registry);
+      enqueue(world, find(jsHelperLibrary, 'defineProperty'), registry);
     }
   }
 
@@ -906,12 +910,12 @@ class JavaScriptBackend extends Backend {
       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));
     }
   }
 
@@ -1278,115 +1282,115 @@ class JavaScriptBackend extends Backend {
   }
 
   Element getExceptionUnwrapper() {
-    return findHelper('unwrapException');
+    return find(jsHelperLibrary, 'unwrapException');
   }
 
   Element getThrowRuntimeError() {
-    return findHelper('throwRuntimeError');
+    return find(jsHelperLibrary, 'throwRuntimeError');
   }
 
   Element getThrowTypeError() {
-    return findHelper('throwTypeError');
+    return find(jsHelperLibrary, 'throwTypeError');
   }
 
   Element getThrowAbstractClassInstantiationError() {
-    return findHelper('throwAbstractClassInstantiationError');
+    return find(jsHelperLibrary, 'throwAbstractClassInstantiationError');
   }
 
   Element getStringInterpolationHelper() {
-    return findHelper('S');
+    return find(jsHelperLibrary, 'S');
   }
 
   Element getWrapExceptionHelper() {
-    return findHelper(r'wrapException');
+    return find(jsHelperLibrary, r'wrapException');
   }
 
   Element getThrowExpressionHelper() {
-    return findHelper('throwExpression');
+    return find(jsHelperLibrary, 'throwExpression');
   }
 
   Element getClosureConverter() {
-    return findHelper('convertDartClosureToJS');
+    return find(jsHelperLibrary, 'convertDartClosureToJS');
   }
 
   Element getTraceFromException() {
-    return findHelper('getTraceFromException');
+    return find(jsHelperLibrary, 'getTraceFromException');
   }
 
   Element getSetRuntimeTypeInfo() {
-    return findHelper('setRuntimeTypeInfo');
+    return find(jsHelperLibrary, 'setRuntimeTypeInfo');
   }
 
   Element getGetRuntimeTypeInfo() {
-    return findHelper('getRuntimeTypeInfo');
+    return find(jsHelperLibrary, 'getRuntimeTypeInfo');
   }
 
   Element getGetTypeArgumentByIndex() {
-    return findHelper('getTypeArgumentByIndex');
+    return find(jsHelperLibrary, 'getTypeArgumentByIndex');
   }
 
   Element getCopyTypeArguments() {
-    return findHelper('copyTypeArguments');
+    return find(jsHelperLibrary, 'copyTypeArguments');
   }
 
   Element getComputeSignature() {
-    return findHelper('computeSignature');
+    return find(jsHelperLibrary, 'computeSignature');
   }
 
   Element getGetRuntimeTypeArguments() {
-    return findHelper('getRuntimeTypeArguments');
+    return find(jsHelperLibrary, 'getRuntimeTypeArguments');
   }
 
   Element getGetRuntimeTypeArgument() {
-    return findHelper('getRuntimeTypeArgument');
+    return find(jsHelperLibrary, 'getRuntimeTypeArgument');
   }
 
   Element getRuntimeTypeToString() {
-    return findHelper('runtimeTypeToString');
+    return find(jsHelperLibrary, 'runtimeTypeToString');
   }
 
   Element getAssertIsSubtype() {
-    return findHelper('assertIsSubtype');
+    return find(jsHelperLibrary, 'assertIsSubtype');
   }
 
   Element getCheckSubtype() {
-    return findHelper('checkSubtype');
+    return find(jsHelperLibrary, 'checkSubtype');
   }
 
   Element getAssertSubtype() {
-    return findHelper('assertSubtype');
+    return find(jsHelperLibrary, 'assertSubtype');
   }
 
   Element getCheckSubtypeOfRuntimeType() {
-    return findHelper('checkSubtypeOfRuntimeType');
+    return find(jsHelperLibrary, 'checkSubtypeOfRuntimeType');
   }
 
   Element getCheckDeferredIsLoaded() {
-    return findHelper('checkDeferredIsLoaded');
+    return find(jsHelperLibrary, 'checkDeferredIsLoaded');
   }
 
   Element getAssertSubtypeOfRuntimeType() {
-    return findHelper('assertSubtypeOfRuntimeType');
+    return find(jsHelperLibrary, 'assertSubtypeOfRuntimeType');
   }
 
   Element getThrowNoSuchMethod() {
-    return findHelper('throwNoSuchMethod');
+    return find(jsHelperLibrary, 'throwNoSuchMethod');
   }
 
   Element getCreateRuntimeType() {
-    return findHelper('createRuntimeType');
+    return find(jsHelperLibrary, 'createRuntimeType');
   }
 
   Element getFallThroughError() {
-    return findHelper("getFallThroughError");
+    return find(jsHelperLibrary, "getFallThroughError");
   }
 
   Element getCreateInvocationMirror() {
-    return findHelper(Compiler.CREATE_INVOCATION_MIRROR);
+    return find(jsHelperLibrary, Compiler.CREATE_INVOCATION_MIRROR);
   }
 
   Element getCyclicThrowHelper() {
-    return findHelper("throwCyclicInit");
+    return find(jsHelperLibrary, "throwCyclicInit");
   }
 
   bool isNullImplementation(ClassElement cls) {
@@ -1425,7 +1429,7 @@ class JavaScriptBackend extends Backend {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (compiler.loadLibraryFunction == null) {
         compiler.loadLibraryFunction =
-            findHelper("_loadLibraryWrapper");
+            find(jsHelperLibrary, "_loadLibraryWrapper");
         enqueueInResolution(compiler.loadLibraryFunction,
                             compiler.globalDependencies);
       }
@@ -1489,7 +1493,7 @@ class JavaScriptBackend extends Backend {
   void initializeHelperClasses() {
     final List missingHelperClasses = [];
     ClassElement lookupHelperClass(String name) {
-      ClassElement result = jsHelperLibrary.find(name);
+      ClassElement result = find(jsHelperLibrary, name);
       if (result == null) {
         missingHelperClasses.add(name);
       }
@@ -1511,15 +1515,15 @@ class JavaScriptBackend extends Backend {
 
       // 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) {
@@ -1553,7 +1557,7 @@ class JavaScriptBackend extends Backend {
         jsMutableIndexableClass = findClass('JSMutableIndexable');
       } else if (uri == DART_JS_HELPER) {
         initializeHelperClasses();
-        assertMethod = jsHelperLibrary.find('assertHelper');
+        assertMethod = find(jsHelperLibrary, 'assertHelper');
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
@@ -1566,12 +1570,12 @@ class JavaScriptBackend extends Backend {
         noInlineClass = findClass('NoInline');
         irRepresentationClass = findClass('IrRepresentation');
 
-        getIsolateAffinityTagMarker = library.find('getIsolateAffinityTag');
+        getIsolateAffinityTagMarker = find(library, 'getIsolateAffinityTag');
       } 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');
       }
     });
   }
@@ -1593,6 +1597,8 @@ class JavaScriptBackend extends Backend {
     // [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;
@@ -1763,7 +1769,7 @@ class JavaScriptBackend extends Backend {
         use2, js(dispatchPropertyName));
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
-    FunctionElement helper = findHelper('isJsIndexable');
+    FunctionElement helper = find(jsHelperLibrary, 'isJsIndexable');
     jsAst.Expression helperExpression = namer.elementAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
@@ -2020,14 +2026,15 @@ class JavaScriptionResolutionCallbacks extends ResolutionCallbacks {
     }
     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);
     }
   }
 
@@ -2083,7 +2090,7 @@ class JavaScriptionResolutionCallbacks extends ResolutionCallbacks {
   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);
     }