Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/codegen_visitor.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.codegen_visitor;
 
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 
 import 'package:compiler/src/resolution/operators.dart' show
     AssignmentOperator,
     BinaryOperator,
     IncDecOperator,
     UnaryOperator;
 
 import 'package:compiler/src/constants/expressions.dart' show
     BoolFromEnvironmentConstantExpression,
     IntFromEnvironmentConstantExpression,
     StringFromEnvironmentConstantExpression,
     ConstantExpression,
     ConstructedConstantExpression,
     TypeConstantExpression;
 
-import 'package:compiler/src/dart2jslib.dart' show
-    MessageKind,
-    Registry;
+import 'package:compiler/src/resolution/tree_elements.dart' show
+    TreeElements;
 
 import 'package:compiler/src/util/util.dart' show
     Link;
 
+import 'package:compiler/src/common/names.dart' show
+    Names,
+    Selectors;
+
+import 'package:compiler/src/universe/use.dart' show DynamicUse, StaticUse;
+
 import 'package:compiler/src/elements/elements.dart';
-import 'package:compiler/src/resolution/resolution.dart';
 import 'package:compiler/src/tree/tree.dart';
-import 'package:compiler/src/universe/universe.dart';
-import 'package:compiler/src/util/util.dart' show Spannable;
+import 'package:compiler/src/universe/call_structure.dart' show
+    CallStructure;
+import 'package:compiler/src/universe/selector.dart' show
+    Selector;
+import 'package:compiler/src/diagnostics/spannable.dart' show
+    Spannable;
 import 'package:compiler/src/dart_types.dart';
 
 import 'fletch_context.dart';
 
 import 'fletch_backend.dart';
 
 import 'fletch_constants.dart' show
-    FletchFunctionBuilderConstant,
     FletchClassConstant,
     FletchClassInstanceConstant;
 
 import 'fletch_function_builder.dart' show
     FletchFunctionBuilder;
 
 import 'fletch_class_builder.dart' show
     FletchClassBuilder;
 
 import 'fletch_selector.dart';
@@ skipping 150 matching lines @@
          BinaryBulkMixin,
          PrefixBulkMixin,
          PostfixBulkMixin,
          NewBulkMixin,
          VariableBulkMixin,
          ParameterBulkMixin,
          FunctionBulkMixin,
          ConstructorBulkMixin,
          InitializerBulkMixin,
          BaseImplementationOfStaticsMixin,
-         BaseImplementationOfLocalsMixin
+         BaseImplementationOfLocalsMixin,
+         SetIfNullBulkMixin
     implements SemanticSendVisitor, SemanticDeclarationVisitor {
   // A literal int can have up to 31 bits of information (32 minus sign).
   static const int LITERAL_INT_MAX = 0x3FFFFFFF;
   static const int MAX_INT64 = (1 << 63) - 1;
   static const int MIN_INT64 = -(1 << 63);
 
   final FletchContext context;
 
   final ClosureEnvironment closureEnvironment;
 
   final ExecutableElement element;
 
-  final MemberElement member;
-
   final FletchFunctionBuilder functionBuilder;
 
   final Map<Element, LocalValue> scope = <Element, LocalValue>{};
 
   final Map<Node, JumpInfo> jumpInfo = <Node, JumpInfo>{};
 
   // Stack of try blocks (inner-most first), in the lexical scope.
   Link<TryBlock> tryBlockStack = const Link<TryBlock>();
 
   VisitState visitState;
@@ skipping 122 matching lines @@
   }
 
   void pushVariableDeclaration(LocalValue value) {
     scope[value.element] = value;
   }
 
   void popVariableDeclaration(Element local) {
     scope.remove(local);
   }
 
-  void registerDynamicInvocation(Selector selector);
+  void registerDynamicUse(Selector selector);
 
-  void registerDynamicGetter(Selector selector);
-
-  void registerDynamicSetter(Selector selector);
-
-  void registerStaticInvocation(FunctionElement function);
+  void registerStaticUse(StaticUse use);

[ahe, 2015/12/01 10:12:12]

StaticUse (like DynamicUse) is problematic to use here for the same reason as
DynamicUse: we construct these objects just to throw them away again
immediately.

[sigurdm, 2015/12/03 14:48:09]

Done.

 
   void registerInstantiatedClass(ClassElement klass);
 
   void registerIsCheck(DartType type);
 
   void registerLocalInvoke(LocalElement element, Selector selector);
 
   /// Register that [element] is a closure. This can happen for a tear-off, or
   /// for local functions. See [ClosureKind] for more information about the
   /// various kinds of implicit or explicit closurizations that can occur.
   void registerClosurization(FunctionElement element, ClosureKind kind);
 
   int compileLazyFieldInitializer(FieldElement field);
 
   void invokeMethod(Node node, Selector selector) {
-    registerDynamicInvocation(selector);
+    registerDynamicUse(selector);
     String symbol = context.getSymbolFromSelector(selector);
     int id = context.getSymbolId(symbol);
     int arity = selector.argumentCount;
     int fletchSelector = FletchSelector.encodeMethod(id, arity);
     assembler.invokeMethod(fletchSelector, arity, selector.name);
   }
 
-  void invokeGetter(Node node, Selector selector) {
-    registerDynamicGetter(selector);
-    String symbol = context.getSymbolFromSelector(selector);
+  void invokeGetter(Node node, Name name) {
+    registerDynamicUse(new Selector.getter(name));

[ahe, 2015/12/01 10:12:12]

This shouldn't create new objects.

[sigurdm, 2015/12/03 14:48:09]

Done.

+    String symbol = context.mangleName(name);
     int id = context.getSymbolId(symbol);
     int fletchSelector = FletchSelector.encodeGetter(id);
     assembler.invokeMethod(fletchSelector, 0);
   }
 
-  void invokeSetter(Node node, Selector selector) {
-    registerDynamicSetter(selector);
-    String symbol = context.getSymbolFromSelector(selector);
+  void invokeSetter(Node node, Name name) {
+    registerDynamicUse(new Selector.setter(name));

[ahe, 2015/12/01 10:12:12]

Ditto.

[sigurdm, 2015/12/03 14:48:09]

Done.

+    String symbol = context.mangleName(name);
     int id = context.getSymbolId(symbol);
     int fletchSelector = FletchSelector.encodeSetter(id);
     assembler.invokeMethod(fletchSelector, 1);
   }
 
   void invokeFactory(Node node, int constId, int arity) {
     assembler.invokeFactory(constId, arity);
   }
 
   void invokeStatic(Node node, int constId, int arity) {
@@ skipping 21 matching lines @@
     int constId = allocateConstantFromNode(caseMatch.expression);
     assembler.loadConst(constId);
     // For debugging, ignore the equality checks in connection
     // with case matches by not associating the calls with
     // any node.
     invokeMethod(null, new Selector.binaryOperator('=='));
     assembler.branchIfTrue(ifTrue);
   }
 
   FletchFunctionBase requireFunction(FunctionElement element) {
-    registerStaticInvocation(element);
+    // TODO(johnniwinther): More precise use.
+    registerStaticUse(new StaticUse.foreignUse(element));

[ahe, 2015/12/01 10:12:12]

Ditto.

[sigurdm, 2015/12/03 14:48:09]

Done.

     return context.backend.getFunctionForElement(element);
   }
 
   FletchFunctionBase requireConstructorInitializer(
       ConstructorElement constructor) {
     assert(constructor.isGenerativeConstructor);
     registerInstantiatedClass(constructor.enclosingClass);
-    registerStaticInvocation(constructor);
+    registerStaticUse(new StaticUse.foreignUse(constructor));

[ahe, 2015/12/01 10:12:12]

Ditto.

[sigurdm, 2015/12/03 14:48:09]

Done.

     return context.backend.getConstructorInitializerFunction(constructor);
   }
 
   void doStaticFunctionInvoke(
       Node node,
       FletchFunctionBase function,
       NodeList arguments,
       CallStructure callStructure,
       {bool factoryInvoke: false}) {
     if (function.isInstanceMember) loadThis();
@@ skipping 431 matching lines @@
       assembler.loadLiteralTrue();
       return;
     }
 
     if (type.isTypedef) {
       // TODO(ajohnsen): This only matches with the number of arguments, not
       // the actual argument types.
       TypedefType typedefType = type;
       int arity = typedefType.element.functionSignature.parameterCount;
       int fletchSelector = context.toFletchIsSelector(
-          context.backend.compiler.functionClass, arity);
+          context.backend.compiler.coreClasses.functionClass, arity);
       assembler.invokeTest(fletchSelector, 0);
       return;
     }
 
     if (!type.isInterfaceType) {
       assembler.pop();
       generateUnimplementedError(
           diagnosticLocation, "Unhandled type test for $type.");
       return;
     }
@@ skipping 71 matching lines @@
     FletchClassBuilder classBuilder =
         context.backend.createTearoffClass(target);
     assert(classBuilder.fields == 0);
     int constId = allocateConstantClassInstance(classBuilder.classId);
     assembler.loadConst(constId);
     applyVisitState();
   }
 
   void doMainCall(Send node, NodeList arguments) {
     FunctionElement function = context.compiler.mainFunction;
-    if (function.isErroneous) {
+    if (function.isMalformed) {
       doCompileError();
       return;
     }
     if (context.compiler.libraryLoader.libraries.any(checkCompileError)) return;
 
     // Load up to 'parameterCount' arguments, padding with nulls.
     int parameterCount = function.functionSignature.parameterCount;
     int argumentCount = 0;
     for (Node argument in arguments) {
       if (argumentCount == parameterCount) break;
@@ skipping 53 matching lines @@
       Send node,
       MethodElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     doStaticallyBoundInvoke(node, element, arguments, callStructure);
     applyVisitState();
   }
 
   void doSuperCall(Node node, FunctionElement function) {
-    registerStaticInvocation(function);
+    registerStaticUse(new StaticUse.foreignUse(function));

[ahe, 2015/12/01 10:12:12]

Ditto.

[sigurdm, 2015/12/03 14:48:09]

Done.

     int arity = function.functionSignature.parameterCount + 1;
     FletchFunctionBase base = requireFunction(function);
     int constId = functionBuilder.allocateConstantFromFunction(base.functionId);
     invokeStatic(node, constId, arity);
   }
 
   void visitSuperGetterGet(
       Send node,
       FunctionElement getter,
       _) {
@@ skipping 196 matching lines @@
     invokeMethod(node, callStructure.callSelector);
     applyVisitState();
   }
 
   void visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       _) {
-    if (selector == null) {
-      // TODO(ajohnsen): Remove hack - dart2js has a problem with generating
-      // selectors in initializer bodies.
-      selector = new Selector.call(
-          node.selector.asIdentifier().source,
-          element.library,
-          arguments.slowLength());
-    }
     visitForValue(receiver);
     for (Node argument in arguments) {
       visitForValue(argument);
     }
     invokeMethod(node, selector);
     applyVisitState();
   }
 
+  void visitIfNull(
+      Send node,
+      Node left,
+      Node right,
+      _) {
+    BytecodeLabel end = new BytecodeLabel();
+    visitForValue(left);
+    assembler.dup();
+    assembler.loadLiteralNull();
+    assembler.identicalNonNumeric();
+    assembler.branchIfFalse(end);
+    assembler.pop();
+    visitForValue(right);
+    assembler.bind(end);
+    applyVisitState();
+  }
+
   void doIfNotNull(Node receiver, void ifNotNull()) {
     BytecodeLabel end = new BytecodeLabel();
     visitForValue(receiver);
     assembler.dup();
     assembler.loadLiteralNull();
     assembler.identicalNonNumeric();
     assembler.branchIfTrue(end);
     ifNotNull();
     assembler.bind(end);
   }
@@ skipping 10 matching lines @@
       }
       invokeMethod(node, selector);
     });
     applyVisitState();
   }
 
   void visitExpressionInvoke(
       Send node,
       Expression receiver,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       _) {
     visitForValue(receiver);
     for (Node argument in arguments) {
       visitForValue(argument);
     }
-    invokeMethod(node, selector);
+    invokeMethod(node, new Selector.call(Names.call, callStructure));
     applyVisitState();
   }
 
   void visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       _) {
     loadThis();
 
     // If the property is statically known to be a field, instead invoke the
     // getter and then invoke 'call(...)' on the value.
     // TODO(ajohnsen): This is a fix that only works when the field is
     // statically known - that is not always the case. Implement VM support?
     Element target = elements[node];
     if (target != null && target.isField) {
-      invokeGetter(node, new Selector.getter(target.name, element.library));
+      invokeGetter(node, new Name(target.name, element.library));
       selector = new Selector.callClosureFrom(selector);
     }
     for (Node argument in arguments) {
       visitForValue(argument);
     }
     invokeMethod(node, selector);
     applyVisitState();
   }
 
   void visitThisInvoke(
@@ skipping 14 matching lines @@
       ConstantExpression constant,
       _) {
     generateUnimplementedError(
         node, "[visitClassTypeLiteralGet] isn't implemented.");
     applyVisitState();
   }
 
   void visitDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       _) {
-    if (selector == null) {
-      // TODO(ajohnsen): Remove hack - dart2js has a problem with generating
-      // selectors in initializer bodies.
-      selector = new Selector.getter(
-          node.selector.asIdentifier().source,
-          element.library);
-    }
-    if (selector.name == "runtimeType") {
+    if (name.text == "runtimeType") {
       // TODO(ahe): Implement runtimeType.
       generateUnimplementedError(
           node,
           "'runtimeType' isn't supported in Fletch. See https://goo.gl/ELH6Zc");
       applyVisitState();
       return;
     }
     visitForValue(receiver);
-    invokeGetter(node, selector);
+    invokeGetter(node, name);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       _) {
     doIfNotNull(receiver, () {
-      invokeGetter(node, selector);
+      invokeGetter(node, name);
     });
     applyVisitState();
   }
 
   void visitThisPropertyGet(
       Send node,
-      Selector selector,
+      Name name,
       _) {
     loadThis();
-    invokeGetter(node, selector);
+    invokeGetter(node, name);
     applyVisitState();
   }
 
   void visitThisPropertySet(
       Send node,
-      Selector selector,
+      Name name,
       Node rhs,
       _) {
     loadThis();
     visitForValue(rhs);
-    invokeSetter(node, selector);
+    invokeSetter(node, name);
     applyVisitState();
   }
 
   void doStaticFieldGet(FieldElement field) {
     if (checkCompileError(field)) return;
     if (field.isConst) {
       int constId = allocateConstantFromNode(
           field.initializer,
           elements: field.resolvedAst.elements);
       assembler.loadConst(constId);
     } else {
       int index = compileLazyFieldInitializer(field);
       if (field.initializer != null) {
         assembler.loadStaticInit(index);
       } else {
         assembler.loadStatic(index);
       }
     }
   }
 
   void handleStaticFieldGet(
       Send node,
       FieldElement field,
       _) {
     doStaticFieldGet(field);
     applyVisitState();
   }
 
-  void visitAssert(Send node, Node expression, _) {
+  void visitAssert(Assert node) {
     // TODO(ajohnsen): Emit assert in checked mode.
   }
 
   void visitDynamicPropertySet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       _) {
     visitForValue(receiver);
     visitForValue(rhs);
-    invokeSetter(node, selector);
+    invokeSetter(node, name);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       _) {
     doIfNotNull(receiver, () {
       visitForValue(rhs);
-      invokeSetter(node, selector);
+      invokeSetter(node, name);
     });
     applyVisitState();
   }
 
-  void doStaticFieldSet(FieldElement field) {
+  void doStaticFieldSet(

[ahe, 2015/12/01 10:12:12]

Why this change?

[sigurdm, 2015/12/03 14:48:09]

Not sure - reverted.

+      FieldElement field) {
     int index = context.getStaticFieldIndex(field, element);
     assembler.storeStatic(index);
   }
 
   void handleStaticFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       _) {
     visitForValue(rhs);
     doStaticFieldSet(field);
     applyVisitState();
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     // TODO(ajohnsen): This could probably be optimized to string constants in
     // some cases.
     visitForValue(node.first);
     visitForValue(node.second);
     // TODO(ajohnsen): Cache these in context/backend.
     Selector concat = new Selector.binaryOperator('+');
     invokeMethod(node, concat);
     applyVisitState();
   }
 
   void visitStringInterpolation(StringInterpolation node) {
-    // TODO(ajohnsen): Cache these in context/backend.
-    Selector toString = new Selector.call('toString', null, 0);
+    // TODO(ajohnsen): Cache this in context/backend.
     Selector concat = new Selector.binaryOperator('+');
     visitForValueNoDebugInfo(node.string);
     for (StringInterpolationPart part in node.parts) {
       visitForValue(part.expression);
-      invokeMethod(part.expression, toString);
+      invokeMethod(part.expression, Selectors.toString_);
       LiteralString string = part.string;
       if (string.dartString.isNotEmpty) {
         visitForValueNoDebugInfo(string);
         invokeMethod(null, concat);
       }
       invokeMethod(null, concat);
     }
     applyVisitState();
   }
 
   void visitLiteralNull(LiteralNull node) {
     if (visitState == VisitState.Value) {
       assembler.loadLiteralNull();
     } else if (visitState == VisitState.Test) {
-      assembler.branch(falseLabel);
+      if (falseLabel != null) assembler.branch(falseLabel);
     }
   }
 
   void visitLiteralSymbol(LiteralSymbol node) {
     int constId = allocateConstantFromNode(node);
     assembler.loadConst(constId);
     applyVisitState();
   }
 
   void visitLiteralBool(LiteralBool node) {
@@ skipping 26 matching lines @@
               node,
               'Program compiled without support for big integers');
         } else {
           int constId = allocateConstantFromNode(node);
           assembler.loadConst(constId);
         }
       } else {
         assembler.loadLiteral(value);
       }
     } else if (visitState == VisitState.Test) {
-      assembler.branch(falseLabel);
+      if (falseLabel != null) assembler.branch(falseLabel);
     }
   }
 
   void visitLiteral(Literal node) {
     if (visitState == VisitState.Value) {
       assembler.loadConst(allocateConstantFromNode(node));
     } else if (visitState == VisitState.Test) {
-      assembler.branch(falseLabel);
+      if (falseLabel != null) assembler.branch(falseLabel);
     }
   }
 
   void visitLiteralList(LiteralList node) {
     if (node.isConst) {
       int constId = allocateConstantFromNode(node);
       assembler.loadConst(constId);
       applyVisitState();
       return;
     }
     ClassElement literalClass = context.backend.growableListClass;
     ConstructorElement constructor = literalClass.lookupDefaultConstructor();
     if (constructor == null) {
       internalError(node, "Failed to lookup default list constructor");
     }
     // Call with empty arguments, as we call the default constructor.
     callConstructor(
         node, constructor, new NodeList.empty(), CallStructure.NO_ARGS);
-    Selector add = new Selector.call('add', null, 1);
+    Selector add = new Selector.call(new Name('add', null),
+        CallStructure.ONE_ARG);
     for (Node element in node.elements) {
       assembler.dup();
       visitForValue(element);
       invokeMethod(node, add);
       assembler.pop();
     }
     applyVisitState();
   }
 
   void visitLiteralMap(LiteralMap node) {
     if (node.isConst) {
       int constId = allocateConstantFromNode(node);
       assembler.loadConst(constId);
       applyVisitState();
       return;
     }
-    ClassElement literalClass = context.backend.mapImplementation;
-    ConstructorElement constructor = literalClass.lookupDefaultConstructor();
+    ClassElement literalClass =
+        context.backend.mapImplementation.implementation;
+    ConstructorElement constructor = literalClass.lookupConstructor("");
     if (constructor == null) {
       internalError(literalClass, "Failed to lookup default map constructor");
       return;
     }
     // The default constructor is a redirecting factory constructor. Follow it.
     constructor = constructor.effectiveTarget;
     FletchFunctionBase function = requireFunction(constructor.declaration);
     doStaticFunctionInvoke(
         node,
         function,
@@ skipping 224 matching lines @@
       Send node,
       FieldElement field,
       IncDecOperator operator,
       _) {
     doStaticFieldPrefix(node, field, operator);
     applyVisitState();
   }
 
   void doDynamicPropertyCompound(
       Node node,
+      Name name,
       AssignmentOperator operator,
-      Node rhs,
-      Selector getterSelector,
-      Selector setterSelector) {
+      Node rhs) {
     // Dup receiver for setter.
     assembler.dup();
-    invokeGetter(node, getterSelector);
+    invokeGetter(node, name);
     visitForValue(rhs);
     invokeMethod(node, getAssignmentSelector(operator));
-    invokeSetter(node, setterSelector);
+    invokeSetter(node, name);
   }
 
   void visitDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     visitForValue(receiver);
     doDynamicPropertyCompound(
         node,
+        name,
         operator,
-        rhs,
-        getterSelector,
-        setterSelector);
+        rhs);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     doIfNotNull(receiver, () {
       doDynamicPropertyCompound(
           node,
+          name,
           operator,
-          rhs,
-          getterSelector,
-          setterSelector);
+          rhs);
     });
     applyVisitState();
   }
 
   void visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     loadThis();
     doDynamicPropertyCompound(
         node,
+        name,
         operator,
-        rhs,
-        getterSelector,
-        setterSelector);
+        rhs);
     applyVisitState();
   }
 
   void doDynamicPrefix(
       Node node,
-      IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector) {
+      Name name,
+      IncDecOperator operator) {
     assembler.dup();
-    invokeGetter(node, getterSelector);
+    invokeGetter(node, name);
     assembler.loadLiteral(1);
     invokeMethod(node, getIncDecSelector(operator));
-    invokeSetter(node, setterSelector);
+    invokeSetter(node, name);
   }
 
   void doIndexPrefix(
       SendSet node,
       Node receiver,
       Node index,
       IncDecOperator operator) {
     visitForValue(receiver);
     visitForValue(index);
     // Load already evaluated receiver and index for '[]' call.
@@ skipping 60 matching lines @@
     invokeMethod(node, new Selector.index());
     visitForValue(rhs);
     invokeMethod(node, getAssignmentSelector(operator));
     // Use existing evaluated receiver and index for '[]=' call.
     invokeMethod(node, new Selector.indexSet());
     applyVisitState();
   }
 
   void visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     loadThis();
-    doDynamicPrefix(node, operator, getterSelector, setterSelector);
+    doDynamicPrefix(node, name, operator);
     applyVisitState();
   }
 
   void visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     // If visitState is for effect, we can ignore the return value, thus always
     // generate code for the simpler 'prefix' case.
     if (visitState == VisitState.Effect) {
       loadThis();
-      doDynamicPrefix(node, operator, getterSelector, setterSelector);
+      doDynamicPrefix(node, name, operator);
       applyVisitState();
       return;
     }
 
     loadThis();
-    invokeGetter(node, getterSelector);
+    invokeGetter(node, name);
     // For postfix, keep local, unmodified version, to 'return' after store.
     assembler.dup();
     assembler.loadLiteral(1);
     invokeMethod(node, getIncDecSelector(operator));
     loadThis();
     assembler.loadLocal(1);
-    invokeSetter(node, setterSelector);
+    invokeSetter(node, name);
     assembler.popMany(2);
     applyVisitState();
   }
 
   void visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     visitForValue(receiver);
-    doDynamicPrefix(node, operator, getterSelector, setterSelector);
+    doDynamicPrefix(node, name, operator);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     doIfNotNull(receiver, () {
-      doDynamicPrefix(node, operator, getterSelector, setterSelector);
+      doDynamicPrefix(node, name, operator);
     });
     applyVisitState();
   }
 
   void doDynamicPostfix(
       Send node,
       Node receiver,
-      IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector) {
+      Name name,
+      IncDecOperator operator) {
     int receiverSlot = assembler.stackSize - 1;
     assembler.loadSlot(receiverSlot);
-    invokeGetter(node, getterSelector);
+    invokeGetter(node, name);
     // For postfix, keep local, unmodified version, to 'return' after store.
     assembler.dup();
     assembler.loadLiteral(1);
     invokeMethod(node, getIncDecSelector(operator));
     assembler.loadSlot(receiverSlot);
     assembler.loadLocal(1);
-    invokeSetter(node, setterSelector);
+    invokeSetter(node, name);
     assembler.popMany(2);
     assembler.storeLocal(1);
     // Pop receiver.
     assembler.pop();
   }
 
   void visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     // If visitState is for effect, we can ignore the return value, thus always
     // generate code for the simpler 'prefix' case.
     if (visitState == VisitState.Effect) {
       visitForValue(receiver);
-      doDynamicPrefix(node, operator, getterSelector, setterSelector);
+      doDynamicPrefix(node, name, operator);
       applyVisitState();
       return;
     }
 
     visitForValue(receiver);
-    doDynamicPostfix(node, receiver, operator, getterSelector, setterSelector);
+    doDynamicPostfix(node, receiver, name, operator);
     applyVisitState();
   }
 
   void visitIfNotNullDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       _) {
     doIfNotNull(receiver, () {
       doDynamicPostfix(
-          node,receiver, operator, getterSelector, setterSelector);
+          node, receiver, name, operator);
     });
     applyVisitState();
   }
 
   void visitThrow(Throw node) {
     visitForValue(node.expression);
     assembler.emitThrow();
     // TODO(ahe): It seems suboptimal that each throw is followed by a pop.
     applyVisitState();
   }
@@ skipping 575 matching lines @@
   void visitSyncForIn(SyncForIn node) {
     visitForIn(node);
   }
 
   void visitForIn(ForIn node) {
     BytecodeLabel start = new BytecodeLabel();
     BytecodeLabel end = new BytecodeLabel();
 
     // Evalutate expression and iterator.
     visitForValue(node.expression);
-    invokeGetter(node.expression, new Selector.getter('iterator', null));
+    invokeGetter(node.expression, Names.iterator);
 
     jumpInfo[node] = new JumpInfo(assembler.stackSize, start, end);
 
     assembler.bind(start);
 
     assembler.dup();
-    invokeMethod(node, new Selector.call('moveNext', null, 0));
+    invokeMethod(node, Selectors.moveNext);
     assembler.branchIfFalse(end);
 
     bool isVariableDeclaration = node.declaredIdentifier.asSend() == null;
     Element element = elements[node];
     if (isVariableDeclaration) {
       // Create local value and load the current element to it.
       LocalValue value = createLocalValueFor(element);
       assembler.dup();
-      invokeGetter(node, new Selector.getter('current', null));
+      invokeGetter(node, Names.current);
       value.initialize(assembler);
       pushVariableDeclaration(value);
     } else {
       if (element == null || element.isInstanceMember) {
         loadThis();
         assembler.loadLocal(1);
-        invokeGetter(node, new Selector.getter('current', null));
+        invokeGetter(node, Names.current);
         Selector selector = elements.getSelector(node.declaredIdentifier);
-        invokeSetter(node, selector);
+        invokeSetter(node, selector.memberName);
       } else {
         assembler.dup();
-        invokeGetter(node, new Selector.getter('current', null));
+        invokeGetter(node, Names.current);
         if (element.isLocal) {
           scope[element].store(assembler);
         } else if (element.isField) {
           doStaticFieldSet(element);
-        } else if (element.isErroneous) {
+        } else if (element.isMalformed) {
           doUnresolved(element.name);
           assembler.pop();
         } else {
           internalError(node, "Unhandled store in for-in");
         }
       }
       assembler.pop();
     }
 
     doScopedStatement(node.body);
@@ skipping 291 matching lines @@
       NodeList arguments,
       CallStructure callStructure,
       _) {
     if (!checkCompileError(function)) {
       doUnresolved(function.name);
     }
     applyVisitState();
   }
 
   void internalError(Spannable spannable, String reason) {
-    context.compiler.internalError(spannable, reason);
+    context.compiler.reporter.internalError(spannable, reason);
   }
 
   void generateUnimplementedError(Spannable spannable, String reason) {
     context.backend.generateUnimplementedError(
         spannable,
         reason,
         functionBuilder);
   }
 
   String toString() => "FunctionCompiler(${element.name})";
@@ skipping 51 matching lines @@
   void handleStaticFunctionSet(
       SendSet node,
       MethodElement function,
       Node rhs,
       _) {
     generateUnimplementedError(
         node, "[handleStaticFunctionSet] isn't implemented.");
     applyVisitState();
   }
 
+  @override
+  void bulkHandleSetIfNull(Node node, _) {
+    generateUnimplementedError(
+        node, "[bulkHandleSetIfNull] isn't implemented.");
+    applyVisitState();
+  }
+
   void previsitDeferredAccess(Send node, PrefixElement prefix, _) {
     // We don't support deferred access, so nothing to do for now.
   }
 
   void bulkHandleNode(Node node, String msg, _) {
     generateUnimplementedError(node, msg.replaceAll('#', node.toString()));
     applyVisitState();
   }
 
   void visitNode(Node node) {
@@ skipping 10 matching lines @@
 
   void applyParameters(NodeList parameters, _) {
     internalError(parameters, "[applyParameters] isn't implemented.");
   }
 }
 
 abstract class FletchRegistryMixin {
   FletchRegistry get registry;
   FletchContext get context;
 
-  void registerDynamicInvocation(Selector selector) {
-    registry.registerDynamicInvocation(new UniverseSelector(selector, null));
+  void registerDynamicUse(Selector selector) {
+    registry.registerDynamicUse(selector);
   }
 
-  void registerDynamicGetter(Selector selector) {
-    registry.registerDynamicGetter(new UniverseSelector(selector, null));
-  }
-
-  void registerDynamicSetter(Selector selector) {
-    registry.registerDynamicSetter(new UniverseSelector(selector, null));
-  }
-
-  void registerStaticInvocation(FunctionElement function) {
-    registry.registerStaticInvocation(function);
+  void registerStaticUse(StaticUse staticUse) {
+    registry.registerStaticUse(staticUse);
   }
 
   void registerInstantiatedClass(ClassElement klass) {
     registry.registerInstantiatedClass(klass);
   }
 
   void registerIsCheck(DartType type) {
     registry.registerIsCheck(type);
   }
 
   void registerLocalInvoke(LocalElement element, Selector selector) {
     registry.registerLocalInvoke(element, selector);
   }
 
   void registerClosurization(FunctionElement element, ClosureKind kind) {
     if (kind == ClosureKind.localFunction) {
-      // TODO(ahe): Get rid of the call to [registerStaticInvocation]. It is
+      // TODO(ahe): Get rid of the call to [registerStaticUse]. It is
       // currently needed to ensure that local function expression closures are
       // compiled correctly. For example, `[() {}].last()`, notice that `last`
       // is a getter. This happens for both named and unnamed.
-      registerStaticInvocation(element);
+      registerStaticUse(new StaticUse.foreignUse(element));
     }
     registry.registerClosurization(element, kind);
   }
 
   int compileLazyFieldInitializer(FieldElement field) {
     return context.backend.compileLazyFieldInitializer(field, registry);
   }
 }