Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/enqueuer_mixin.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 // TODO(ahe): Get rid of this file. Perhaps by having [FletchEnqueuer] extend
 // [CodegenEnqueuer].
 part of fletchc.fletch_enqueuer;
 
 get notImplemented => throw "not implemented";
 
-class EnqueuerMixin {
+class EnqueuerMixin implements CodegenEnqueuer {

[ahe, 2015/11/17 16:44:09]

Not sure about this.

[sigurdm, 2015/11/19 14:33:47]

Ok, lets discuss it.
My idea was to get warnings if CodegenEnqueuer adds more methods that we want to
implement

   String get name => notImplemented;
 
   Compiler get compiler => notImplemented;
 
   ItemCompilationContextCreator get itemCompilationContextCreator
       => notImplemented;
 
   Map<String, Set<Element>> get instanceMembersByName => notImplemented;
 
   Map<String, Set<Element>> get instanceFunctionsByName => notImplemented;
@@ skipping 23 matching lines @@
   bool get isResolutionQueue => notImplemented;
 
   QueueFilter get filter => notImplemented;
 
   Queue get queue => notImplemented;
 
   get generatedCode => notImplemented;
 
   Set<Element> get newlyEnqueuedElements => notImplemented;
 
-  Set<UniverseSelector> get newlySeenSelectors => notImplemented;
+  Set<DynamicUse> get newlySeenSelectors => notImplemented;
 
   bool get enabledNoSuchMethod => notImplemented;
   set enabledNoSuchMethod(bool value) => notImplemented;
 
   bool isProcessed(Element member) => notImplemented;
 
   void addToWorkList(Element element) => notImplemented;
 
   bool internalAddToWorkList(Element element) => notImplemented;
 
   void applyImpact(Element element, WorldImpact worldImpact) => notImplemented;
 
   void registerInstantiatedType(
       InterfaceType type,
-      Registry registry,
       {bool mirrorUsage: false}) => notImplemented;
 
   bool checkNoEnqueuedInvokedInstanceMethods() => notImplemented;
 
   void processInstantiatedClassMembers(ClassElement cls) => notImplemented;
 
   void processInstantiatedClassMember(
       ClassElement cls,
       Element member) => notImplemented;
 
   void registerNoSuchMethod(Element noSuchMethod) => notImplemented;
 
   void enableIsolateSupport() => notImplemented;
 
   void processInstantiatedClass(ClassElement cls) => notImplemented;
 
-  void registerInvocation(UniverseSelector selector) => notImplemented;
+  void registerInvocation(DynamicUse use) => notImplemented;
 
-  void registerInvokedGetter(UniverseSelector selector) => notImplemented;
+  void registerInvokedGetter(DynamicUse use) => notImplemented;
 
-  void registerInvokedSetter(UniverseSelector selector) => notImplemented;
+  void registerInvokedSetter(DynamicUse use) => notImplemented;
 
   bool shouldIncludeElementDueToMirrors(
       Element element,
       {bool includedEnclosing}) => notImplemented;
 
   void logEnqueueReflectiveAction(action, [msg = ""]) => notImplemented;
 
   void enqueueReflectiveConstructor(
       ConstructorElement ctor,
       bool enclosingWasIncluded) => notImplemented;
@@ skipping 22 matching lines @@
   void processSet(
       Map<String, Set<Element>> map,
       String memberName,
       bool f(Element e)) => notImplemented;
 
   processInstanceMembers(String n, bool f(Element e)) => notImplemented;
 
   processInstanceFunctions(String n, bool f(Element e)) => notImplemented;
 
   void handleUnseenSelector(
-      UniverseSelector universeSelector) => notImplemented;
+      DynamicUse use) => notImplemented;
 
-  void registerStaticUse(Element element) => notImplemented;
+  void registerStaticUse(StaticUse element) => notImplemented;
 
   void registerGetOfStaticFunction(FunctionElement element) => notImplemented;
 
-  void registerDynamicInvocation(UniverseSelector selector) => notImplemented;
+  void registerDynamicInvocation(DynamicUse use) => notImplemented;
 
-  void registerSelectorUse(UniverseSelector universeSelector) => notImplemented;
+  void registerSelectorUse(DynamicUse use) => notImplemented;
 
-  void registerDynamicGetter(UniverseSelector selector) => notImplemented;
+  void registerDynamicGetter(DynamicUse use) => notImplemented;
 
-  void registerDynamicSetter(UniverseSelector selector) => notImplemented;
+  void registerDynamicSetter(DynamicUse use) => notImplemented;
 
   void registerGetterForSuperMethod(Element element) => notImplemented;
 
   void registerFieldGetter(Element element) => notImplemented;
 
   void registerFieldSetter(Element element) => notImplemented;
 
   void registerIsCheck(DartType type) => notImplemented;
 
   void registerCallMethodWithFreeTypeVariables(
-      Element element,
-      Registry registry) => notImplemented;
+      Element element) => notImplemented;
 
   void registerClosurizedMember(
-      TypedElement element,
-      Registry registry) => notImplemented;
+      TypedElement element) => notImplemented;
 
   void registerClosureIfFreeTypeVariables(
-      TypedElement element,
-      Registry registry) => notImplemented;
+      TypedElement element) => notImplemented;
 
   void registerClosure(
-      LocalFunctionElement element,
-      Registry registry) => notImplemented;
+      LocalFunctionElement element) => notImplemented;
 
   void forEach(void f(WorkItem work)) => notImplemented;
 
   bool onQueueEmpty(Iterable<ClassElement> recentClasses) => notImplemented;
 
   void logSummary(log(message)) => notImplemented;
 
   void forgetElement(Element element) => notImplemented;
+
+  @override

[ahe, 2015/11/17 16:44:09]

Please don't use @override, or use it consistently.

[sigurdm, 2015/11/19 14:33:47]

I tried to use it consistently in the code I added.
This CL is already very big, and it is supposed to be the smallest sensible
change that makes the roll work.

That said I'm happy to add it to the rest of the methods.

+  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;
 }