Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/enqueuer_mixin.dart

Index: pkg/fletchc/lib/src/enqueuer_mixin.dart
diff --git a/pkg/fletchc/lib/src/enqueuer_mixin.dart b/pkg/fletchc/lib/src/enqueuer_mixin.dart
index c404a8813d3e665416c4d2adc0023e4d9894933b..d5f7289b5f277edd89bd4e5c9fa9a01a619d79d2 100644
--- a/pkg/fletchc/lib/src/enqueuer_mixin.dart
+++ b/pkg/fletchc/lib/src/enqueuer_mixin.dart
@@ -8,172 +8,273 @@ part of fletchc.fletch_enqueuer;
 
 get notImplemented => throw "not implemented";
 
-class EnqueuerMixin {
+class EnqueuerMixin implements CodegenEnqueuer {
+  @override
   String get name => notImplemented;
 
+  @override
   Compiler get compiler => notImplemented;
 
+  @override
   ItemCompilationContextCreator get itemCompilationContextCreator
       => notImplemented;
 
+  @override
   Map<String, Set<Element>> get instanceMembersByName => notImplemented;
 
+  @override
   Map<String, Set<Element>> get instanceFunctionsByName => notImplemented;
 
+  @override
   Set<ClassElement> get recentClasses => notImplemented;
+
+  @override
   set recentClasses(Set<ClassElement> value) => notImplemented;
 
+  @override
   Universe get universe => notImplemented;
 
+  @override
   bool get queueIsClosed => notImplemented;
+
+  @override
   set queueIsClosed(bool value) => notImplemented;
 
+  @override
   EnqueueTask get task => notImplemented;
+
+  @override
   set task(EnqueueTask value) => notImplemented;
 
+  @override
   get nativeEnqueuer => notImplemented;
+
+  @override
   set nativeEnqueuer(value) => notImplemented;
 
+  @override
   bool get hasEnqueuedReflectiveElements => notImplemented;
+
+  @override
   set hasEnqueuedReflectiveElements(bool value) => notImplemented;
 
+  @override
   bool get hasEnqueuedReflectiveStaticFields => notImplemented;
+
+  @override
   set hasEnqueuedReflectiveStaticFields(bool value) => notImplemented;
 
+  @override
   bool get queueIsEmpty => notImplemented;
 
+  @override
   bool get isResolutionQueue => notImplemented;
 
+  @override
   QueueFilter get filter => notImplemented;
 
+  @override
   Queue get queue => notImplemented;
 
+  @override
   get generatedCode => notImplemented;
 
+  @override
   Set<Element> get newlyEnqueuedElements => notImplemented;
 
-  Set<UniverseSelector> get newlySeenSelectors => notImplemented;
+  @override
+  Set<DynamicUse> get newlySeenSelectors => notImplemented;
 
+  @override
   bool get enabledNoSuchMethod => notImplemented;
+
+  @override
   set enabledNoSuchMethod(bool value) => notImplemented;
 
+  @override
   bool isProcessed(Element member) => notImplemented;
 
+  @override
   void addToWorkList(Element element) => notImplemented;
 
+  @override
   bool internalAddToWorkList(Element element) => notImplemented;
 
+  @override
   void applyImpact(Element element, WorldImpact worldImpact) => notImplemented;
 
+  @override
   void registerInstantiatedType(
       InterfaceType type,
-      Registry registry,
       {bool mirrorUsage: false}) => notImplemented;
 
+  @override
   bool checkNoEnqueuedInvokedInstanceMethods() => notImplemented;
 
+  @override
   void processInstantiatedClassMembers(ClassElement cls) => notImplemented;
 
+  @override
   void processInstantiatedClassMember(
       ClassElement cls,
       Element member) => notImplemented;
 
+  @override
   void registerNoSuchMethod(Element noSuchMethod) => notImplemented;
 
+  @override
   void enableIsolateSupport() => notImplemented;
 
+  @override
   void processInstantiatedClass(ClassElement cls) => notImplemented;
 
-  void registerInvocation(UniverseSelector selector) => notImplemented;
+  @override
+  void registerInvocation(DynamicUse use) => notImplemented;
 
-  void registerInvokedGetter(UniverseSelector selector) => notImplemented;
+  @override
+  void registerInvokedGetter(DynamicUse use) => notImplemented;
 
-  void registerInvokedSetter(UniverseSelector selector) => notImplemented;
+  @override
+  void registerInvokedSetter(DynamicUse use) => notImplemented;
 
+  @override
   bool shouldIncludeElementDueToMirrors(
       Element element,
       {bool includedEnclosing}) => notImplemented;
 
+  @override
   void logEnqueueReflectiveAction(action, [msg = ""]) => notImplemented;
 
+  @override
   void enqueueReflectiveConstructor(
       ConstructorElement ctor,
       bool enclosingWasIncluded) => notImplemented;
 
+  @override
   void enqueueReflectiveMember(
       Element element,
       bool enclosingWasIncluded) => notImplemented;
 
+  @override
   void enqueueReflectiveElementsInClass(
       ClassElement cls,
       Iterable<ClassElement> recents,
       bool enclosingWasIncluded) => notImplemented;
 
+  @override
   void enqueueReflectiveSpecialClasses() => notImplemented;
 
+  @override
   void enqueueReflectiveElementsInLibrary(
       LibraryElement lib,
       Iterable<ClassElement> recents) => notImplemented;
 
+  @override
   void enqueueReflectiveElements(
       Iterable<ClassElement> recents) => notImplemented;
 
+  @override
   void enqueueReflectiveStaticFields(
       Iterable<Element> elements) => notImplemented;
 
+  @override
   void processSet(
       Map<String, Set<Element>> map,
       String memberName,
       bool f(Element e)) => notImplemented;
 
+  @override
   processInstanceMembers(String n, bool f(Element e)) => notImplemented;
 
+  @override
   processInstanceFunctions(String n, bool f(Element e)) => notImplemented;
 
+  @override
   void handleUnseenSelector(
-      UniverseSelector universeSelector) => notImplemented;
+      DynamicUse use) => notImplemented;
 
-  void registerStaticUse(Element element) => notImplemented;
+  @override
+  void registerStaticUse(StaticUse element) => notImplemented;
 
+  @override
   void registerGetOfStaticFunction(FunctionElement element) => notImplemented;
 
-  void registerDynamicInvocation(UniverseSelector selector) => notImplemented;
+  @override
+  void registerDynamicInvocation(DynamicUse use) => notImplemented;
 
-  void registerSelectorUse(UniverseSelector universeSelector) => notImplemented;
+  @override
+  void registerSelectorUse(DynamicUse use) => notImplemented;
 
-  void registerDynamicGetter(UniverseSelector selector) => notImplemented;
+  @override
+  void registerDynamicGetter(DynamicUse use) => notImplemented;
 
-  void registerDynamicSetter(UniverseSelector selector) => notImplemented;
+  @override
+  void registerDynamicSetter(DynamicUse use) => notImplemented;
 
+  @override
   void registerGetterForSuperMethod(Element element) => notImplemented;
 
+  @override
   void registerFieldGetter(Element element) => notImplemented;
 
+  @override
   void registerFieldSetter(Element element) => notImplemented;
 
+  @override
   void registerIsCheck(DartType type) => notImplemented;
 
+  @override
   void registerCallMethodWithFreeTypeVariables(
-      Element element,
-      Registry registry) => notImplemented;
+      Element element) => notImplemented;
 
+  @override
   void registerClosurizedMember(
-      TypedElement element,
-      Registry registry) => notImplemented;
+      TypedElement element) => notImplemented;
 
+  @override
   void registerClosureIfFreeTypeVariables(
-      TypedElement element,
-      Registry registry) => notImplemented;
+      TypedElement element) => notImplemented;
 
+  @override
   void registerClosure(
-      LocalFunctionElement element,
-      Registry registry) => notImplemented;
+      LocalFunctionElement element) => notImplemented;
 
+  @override
   void forEach(void f(WorkItem work)) => notImplemented;
 
+  @override
   bool onQueueEmpty(Iterable<ClassElement> recentClasses) => notImplemented;
 
+  @override
   void logSummary(log(message)) => notImplemented;
 
+  @override
   void forgetElement(Element element) => notImplemented;
+
+  @override
+  void handleUnseenSelectorInternal(DynamicUse dynamicUse) => notImplemented;
+
+  @override
+  bool isClassProcessed(ClassElement cls) => notImplemented;
+
+  @override
+  Iterable<ClassElement> get processedClasses => notImplemented;
+
+  @override
+  void registerDynamicUse(DynamicUse dynamicUse) => notImplemented;
+
+  @override
+  void registerStaticUseInternal(StaticUse staticUse) => notImplemented;
+
+  @override
+  void registerTypeUse(TypeUse typeUse) => notImplemented;
+
+  @override
+  DiagnosticReporter get reporter => notImplemented;
+
+  @override
+  Resolution get resolution => notImplemented;
+
+  @override
+  EnqueuerStrategy get strategy => notImplemented;
 }