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 333 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 286 matching lines @@
       typeVariableHandler.registerClassWithTypeVariables(cls);
     }
 
     // Register any helper that will be needed by the backend.
     if (enqueuer.isResolutionQueue) {
       if (cls == compiler.intClass
           || cls == compiler.doubleClass
           || 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) {
         // The backend will use a literal list to initialize the entries
         // of the map.
         enqueueClass(enqueuer, compiler.listClass, registry);
         enqueueClass(enqueuer, mapLiteralClass, registry);
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(mapLiteralClass, cls);
@@ skipping 21 matching lines @@
                   "  ${mapLiteralClass.constructors}");
             });
         }
         mapLiteralConstructor = getFactory('_literal', 1);
         mapLiteralConstructorEmpty = getFactory('_empty', 0);
         enqueueInResolution(mapLiteralConstructor, registry);
         enqueueInResolution(mapLiteralConstructorEmpty, registry);
       }
     }
     if (cls == closureClass) {
-      enqueue(enqueuer, findHelper('closureFromTearOff'), registry);
+      enqueue(enqueuer, find(jsHelperLibrary, 'closureFromTearOff'), registry);
     }
     ClassElement result = null;
     if (cls == compiler.stringClass || cls == jsStringClass) {
       addInterceptors(jsStringClass, enqueuer, registry);
     } else if (cls == compiler.listClass ||
                cls == jsArrayClass ||
                cls == jsFixedArrayClass ||
                cls == jsExtendableArrayClass) {
       addInterceptors(jsArrayClass, enqueuer, registry);
       addInterceptors(jsMutableArrayClass, enqueuer, registry);
@@ skipping 22 matching lines @@
     } else if (cls == jsPlainJavaScriptObjectClass) {
       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);
+      enqueue(enqueuer, find(jsHelperLibrary, 'isJsIndexable'), 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 10 matching lines @@
     assert(interceptorsLibrary != null);
     // TODO(ngeoffray): Not enqueuing those two classes currently make
     // the compiler potentially crash. However, any reasonable program
     // will instantiate those two classes.
     addInterceptors(jsBoolClass, world, registry);
     addInterceptors(jsNullClass, world, registry);
     if (compiler.enableTypeAssertions) {
       // 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);
     }
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() => rti.computeClassesNeedingRti();
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueInResolution(getGetRuntimeTypeArgument(), registry);
@@ skipping 70 matching lines @@
         enqueue(world, helper.getElement(compiler), registry);
       }
     }
     if (!type.treatAsRaw || type.containsTypeVariables) {
       enqueueClass(world, compiler.listClass, 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.
-      enqueue(world, findHelper('defineProperty'), registry);
+      enqueue(world, find(jsHelperLibrary, 'defineProperty'), registry);
     }
   }
 
   void registerTypeVariableBoundsSubtypeCheck(DartType typeArgument,
                                               DartType bound) {
     rti.registerTypeVariableBoundsSubtypeCheck(typeArgument, bound);
   }
 
   void registerCheckDeferredIsLoaded(Registry registry) {
     enqueueInResolution(getCheckDeferredIsLoaded(), registry);
     // Also register the types of the arguments passed to this method.
     enqueueClass(compiler.enqueuer.resolution, compiler.stringClass, registry);
   }
 
   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 346 matching lines @@
         element == compiler.numClass ||
         element == compiler.intClass ||
         element == compiler.doubleClass ||
         element == jsArrayClass ||
         element == jsMutableArrayClass ||
         element == jsExtendableArrayClass ||
         element == jsFixedArrayClass;
   }
 
   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) {
     return cls == jsNullClass;
   }
 
   ClassElement get intImplementation => jsIntClass;
   ClassElement get uint32Implementation => jsUInt32Class;
   ClassElement get uint31Implementation => jsUInt31Class;
   ClassElement get positiveIntImplementation => jsPositiveIntClass;
@@ skipping 18 matching lines @@
     } else if (element == preserveNamesMarker) {
       mustPreserveNames = true;
     } else if (element == preserveMetadataMarker) {
       mustRetainMetadata = true;
     } else if (element == getIsolateAffinityTagMarker) {
       needToInitializeIsolateAffinityTag = true;
     } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (compiler.loadLibraryFunction == null) {
         compiler.loadLibraryFunction =
-            findHelper("_loadLibraryWrapper");
+            find(jsHelperLibrary, "_loadLibraryWrapper");
         enqueueInResolution(compiler.loadLibraryFunction,
                             compiler.globalDependencies);
       }
     }
     customElementsAnalysis.registerStaticUse(element, enqueuer);
   }
 
   /// Called when [:const Symbol(name):] is seen.
   void registerConstSymbol(String name, Registry registry) {
     symbolsUsed.add(name);
@@ skipping 43 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 = find(jsHelperLibrary, 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 = find(jsHelperLibrary, '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 = 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');
       }
     });
   }
 
   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 150 matching lines @@
                                        jsAst.Expression use2) {
     String dispatchPropertyName = 'init.dispatchPropertyName';
 
     // We pass the dispatch property record to the isJsIndexable
     // helper rather than reading it inside the helper to increase the
     // chance of making the dispatch record access monomorphic.
     jsAst.PropertyAccess record = new jsAst.PropertyAccess(
         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);
   }
 
   bool isTypedArray(TypeMask mask) {
     // Just checking for [:TypedData:] is not sufficient, as it is an
     // abstract class any user-defined class can implement. So we also
     // check for the interface [JavaScriptIndexingBehavior].
     return compiler.typedDataClass != null
         && mask.satisfies(compiler.typedDataClass, compiler)
@@ skipping 236 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);
 }