Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/fletch_backend.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.
 
 library fletchc.fletch_backend;
 
 import 'dart:async' show
     Future;
 
 import 'dart:collection' show
@@ skipping 32 matching lines @@
     ConstructorElement,
     Element,
     ExecutableElement,
     FieldElement,
     FormalElement,
     FunctionElement,
     FunctionSignature,
     FunctionTypedElement,
     LibraryElement,
     MemberElement,
+    MethodElement,
     Name,
     ParameterElement,
     PublicName;
 
 import 'package:compiler/src/universe/selector.dart' show
     Selector;
 
 import 'package:compiler/src/universe/use.dart' show
     DynamicUse,
     StaticUse,
@@ skipping 396 matching lines @@
     // This class is optional.
     coroutineClass = fletchSystemLibrary.implementation.find("Coroutine");
     if (coroutineClass != null) {
       coroutineClass.ensureResolved(compiler.resolution);
     }
   }
 
   void onElementResolved(Element element, TreeElements elements) {
     if (alwaysEnqueue.contains(element)) {
       var registry = new FletchRegistry(compiler);
-      if (element.isStatic || element.isTopLevel) {
-        registry.registerStaticUse(new StaticUse.foreignUse(element));
-      } else {
-        registry.registerDynamicUse(new Selector.fromElement(element));
-      }
+      registry.registerStaticInvocation(element);
     }
   }
 
   ClassElement get intImplementation => smiClass;
 
   /// Class of annotations to mark patches in patch files.
   ///
   /// The patch parser (pkg/compiler/lib/src/patch_parser.dart). The patch
   /// parser looks for an annotation on the form "@patch", where "patch" is
   /// compile-time constant instance of [patchAnnotationClass].
@@ skipping 440 matching lines @@
       if (!isExactParameterMatch(function.signature, selector.callStructure)) {
         createParameterStubFor(function, selector);
       }
     });
   }
 
   void codegenFunction(
       FunctionElement function,
       TreeElements elements,
       FletchRegistry registry) {
-    registry.registerStaticUse(new StaticUse.foreignUse(fletchSystemEntry));
+    registry.registerStaticInvocation(fletchSystemEntry);
 
     ClosureEnvironment closureEnvironment = createClosureEnvironment(
         function,
         elements);
 
     FletchFunctionBuilder functionBuilder;
 
     if (function.memberContext != function) {
       functionBuilder = internalCreateFletchFunctionBuilder(
           function,
@@ skipping 13 matching lines @@
 
     if (isNative(function)) {
       codegenNativeFunction(function, codegen);
     } else if (isExternal(function)) {
       codegenExternalFunction(function, codegen);
     } else {
       codegen.compile();
     }
 
     if (functionBuilder.isInstanceMember && !function.isGenerativeConstructor) {
+      Name name = function is MethodElement
+          ? function.memberName
+          : new Name(functionBuilder.name, function.library);
       // Inject the function into the method table of the 'holderClass' class.
       // Note that while constructor bodies has a this argument, we don't inject
       // them into the method table.
-      String symbol = context.getSymbolForFunction(
-          functionBuilder.name,
-          function.functionSignature,
-          function.library);
+      String symbol = context.getSymbolForFunction(name,
+          function.functionSignature);
       int id = context.getSymbolId(symbol);
       int arity = function.functionSignature.parameterCount;
       SelectorKind kind = SelectorKind.Method;
       if (function.isGetter) kind = SelectorKind.Getter;
       if (function.isSetter) kind = SelectorKind.Setter;
       int fletchSelector = FletchSelector.encode(id, kind, arity);
       FletchClassBuilder classBuilder =
           systemBuilder.lookupClassBuilder(functionBuilder.memberOf);
       classBuilder.addToMethodTable(fletchSelector, functionBuilder);
       // Inject method into all mixin usages.
@@ skipping 40 matching lines @@
       // The static native method `Coroutine._coroutineNewStack` will invoke
       // the instance method `Coroutine._coroutineStart`.
       if (coroutineClass == null) {
         compiler.reporter.internalError(
             function, "required class [Coroutine] not found");
       }
       FunctionElement coroutineStart =
           coroutineClass.lookupLocalMember("_coroutineStart");
       Selector selector = new Selector.fromElement(coroutineStart);
       new FletchRegistry(compiler)
-          ..registerDynamicUse(selector);
+          ..registerDynamicSelector(selector);
     } else if (name == "Process._spawn") {
       // The native method `Process._spawn` will do a closure invoke with 0, 1,
       // or 2 arguments.
       new FletchRegistry(compiler)
-          ..registerDynamicUse(new Selector.callClosure(0))
-          ..registerDynamicUse(new Selector.callClosure(1))
-          ..registerDynamicUse(new Selector.callClosure(2));
+          ..registerDynamicSelector(new Selector.callClosure(0))
+          ..registerDynamicSelector(new Selector.callClosure(1))
+          ..registerDynamicSelector(new Selector.callClosure(2));
     }
 
     int arity = codegen.assembler.functionArity;
     if (name == "Port.send" ||
         name == "Port._sendList" ||
         name == "Port._sendExit") {
       codegen.assembler.invokeNativeYield(arity, descriptor.index);
     } else {
       codegen.assembler.invokeNative(arity, descriptor.index);
     }
@@ skipping 120 matching lines @@
     });
   }
 
   void markFunctionConstantAsUsed(FunctionConstantValue value) {
     // TODO(ajohnsen): Use registry in CodegenVisitor to register the used
     // constants.
     FunctionElement function = value.element;
     createTearoffClass(createFletchFunctionBuilder(function));
     // Be sure to actually enqueue the function for compilation.
     FletchRegistry registry = new FletchRegistry(compiler);
-    registry.registerStaticUse(new StaticUse.foreignUse(function));
+    registry.registerStaticInvocation(function);
   }
 
   FletchFunctionBase createParameterStubFor(
       FletchFunctionBase function,
       Selector selector) {
     CallStructure callStructure = selector.callStructure;
     assert(callStructure.signatureApplies(function.signature));
     FletchFunctionBase stub = systemBuilder.parameterStubFor(
         function,
         callStructure);
@@ skipping 107 matching lines @@
           ..allocate(constId, tearoffClass.fields)
           ..ret()
           ..methodEnd();
     }
     // If the name is private, we need the library.
     // Invariant: We only generate public stubs, e.g. 'call'.
     LibraryElement library;
     if (function.element != null) {
       library = function.element.library;
     }
-    // TODO(sigurdm): Avoid allocating new name here.
+    // TODO(sigurdm): Avoid allocating new Name and Selector here.
     Name name = new Name(function.name, library);
     int fletchSelector = context.toFletchSelector(
         new Selector.getter(name));
     FletchClassBuilder classBuilder = systemBuilder.lookupClassBuilder(
         function.memberOf);
     classBuilder.addToMethodTable(fletchSelector, getter);
 
     // Inject getter into all mixin usages.
     getMixinApplicationsOfClass(classBuilder).forEach((ClassElement usage) {
       FletchClassBuilder classBuilder =
@@ skipping 351 matching lines @@
     return true;
   }
 
   static FletchBackend newInstance(FletchCompilerImplementation compiler) {
     return new FletchBackend(compiler);
   }
 
   Uri resolvePatchUri(String libraryName, Uri libraryRoot) {
     throw "Not implemented";
   }
-
 }
 
 class FletchImpactTransformer extends ImpactTransformer {
   final FletchBackend backend;
 
   FletchImpactTransformer(this.backend);
 
   @override
   WorldImpact transformResolutionImpact(ResolutionImpact worldImpact) {
     TransformedWorldImpact transformed =
@@ skipping 35 matching lines @@
     return element.memberContext != element;
   }
   return false;
 }
 
 Name memberName(AstElement element) {
   if (isLocalFunction(element)) return null;
   MemberElement member = element;
   return member.memberName;
 }