diff --git a/CHANGELOG.md b/CHANGELOG.md
index dd63681..d316f79 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## 2.7.1 - 2020-01-32
+
+This is a patch release that improves dart2js compile-time (issue [40217][]).
+
+[40217]: https://github.com/dart-lang/sdk/issues/40217
+
+**Breaking Change**:
+The Dart SDK for macOS is now only available for x64 (issue [39810][]).
+
+[39810]: https://github.com/dart-lang/sdk/issues/39810
+
 ## 2.7.0 - 2019-12-11
 
 ### Language
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index 48e3b92..9a003bd 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -339,9 +339,8 @@
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = new Selector(SelectorKind.CALL, constructor.memberName,
         _elementMap.getCallStructure(node.arguments));
-    AbstractValue mask = _memberData.typeOfSend(node);
     handleConstructorInvoke(
-        node, node.arguments, selector, mask, constructor, arguments);
+        node, node.arguments, selector, constructor, arguments);
 
     _inferrer.analyze(constructor);
     if (_inferrer.checkIfExposesThis(constructor)) {
@@ -356,9 +355,8 @@
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = new Selector(SelectorKind.CALL, constructor.memberName,
         _elementMap.getCallStructure(node.arguments));
-    AbstractValue mask = _memberData.typeOfSend(node);
     handleConstructorInvoke(
-        node, node.arguments, selector, mask, constructor, arguments);
+        node, node.arguments, selector, constructor, arguments);
 
     _inferrer.analyze(constructor);
     if (_inferrer.checkIfExposesThis(constructor)) {
@@ -391,7 +389,8 @@
 
     if (_closedWorld.nativeData.isNativeMember(_analyzedMember)) {
       // Native methods do not have a body, and we currently just say
-      // they return dynamic.
+      // they return dynamic and may contain all side-effects.
+      _sideEffectsBuilder.setAllSideEffectsAndDependsOnSomething();
       return _types.dynamicType;
     }
 
@@ -850,10 +849,32 @@
     return new ArgumentsTypes(positional, named);
   }
 
+  AbstractValue _typeOfReceiver(ir.TreeNode node, ir.TreeNode receiver) {
+    KernelGlobalTypeInferenceElementData data = _memberData;
+    AbstractValue mask = data.typeOfReceiver(node);
+    if (mask != null) return mask;
+    // TODO(sigmund): ensure that this is only called once per node.
+    DartType staticType = _getStaticType(receiver);
+    // TODO(sigmund): this needs to be adjusted when we enable non-nullable
+    // types to handle legacy and nullable wrappers.
+    if (staticType is InterfaceType) {
+      ClassEntity cls = staticType.element;
+      if (receiver is ir.ThisExpression && !_closedWorld.isUsedAsMixin(cls)) {
+        mask = _closedWorld.abstractValueDomain.createNonNullSubclass(cls);
+      } else {
+        mask = _closedWorld.abstractValueDomain.createNullableSubtype(cls);
+      }
+      data.setReceiverTypeMask(node, mask);
+      return mask;
+    }
+    // TODO(sigmund): consider also extracting the bound of type parameters.
+    return null;
+  }
+
   @override
   TypeInformation visitMethodInvocation(ir.MethodInvocation node) {
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
+    AbstractValue mask = _typeOfReceiver(node, node.receiver);
 
     ir.TreeNode receiver = node.receiver;
     if (receiver is ir.VariableGet &&
@@ -867,7 +888,7 @@
       }
 
       TypeInformation type =
-          handleStaticInvoke(node, selector, mask, info.callMethod, arguments);
+          handleStaticInvoke(node, selector, info.callMethod, arguments);
       FunctionType functionType =
           _elementMap.elementEnvironment.getFunctionType(info.callMethod);
       if (functionType.returnType.containsFreeTypeVariables) {
@@ -1028,8 +1049,8 @@
           _closedWorld.commonElements.streamIteratorConstructor;
 
       /// Synthesize a call to the [StreamIterator] constructor.
-      iteratorType = handleStaticInvoke(node, null, null, constructor,
-          new ArgumentsTypes([expressionType], null));
+      iteratorType = handleStaticInvoke(
+          node, null, constructor, new ArgumentsTypes([expressionType], null));
     } else {
       TypeInformation expressionType = visit(node.iterable);
       Selector iteratorSelector = Selectors.iterator;
@@ -1118,9 +1139,8 @@
     ConstructorEntity constructor = _elementMap.getConstructor(node.target);
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
     return handleConstructorInvoke(
-        node, node.arguments, selector, mask, constructor, arguments);
+        node, node.arguments, selector, constructor, arguments);
   }
 
   /// Try to find the length given to a fixed array constructor call.
@@ -1176,11 +1196,10 @@
       ir.Node node,
       ir.Arguments arguments,
       Selector selector,
-      AbstractValue mask,
       ConstructorEntity constructor,
       ArgumentsTypes argumentsTypes) {
     TypeInformation returnType =
-        handleStaticInvoke(node, selector, mask, constructor, argumentsTypes);
+        handleStaticInvoke(node, selector, constructor, argumentsTypes);
     if (_elementMap.commonElements.isUnnamedListConstructor(constructor)) {
       // We have `new List(...)`.
       if (arguments.positional.isEmpty && arguments.named.isEmpty) {
@@ -1227,17 +1246,16 @@
   }
 
   TypeInformation handleStaticInvoke(ir.Node node, Selector selector,
-      AbstractValue mask, MemberEntity element, ArgumentsTypes arguments) {
-    return _inferrer.registerCalledMember(node, selector, mask, _analyzedMember,
+      MemberEntity element, ArgumentsTypes arguments) {
+    return _inferrer.registerCalledMember(node, selector, _analyzedMember,
         element, arguments, _sideEffectsBuilder, inLoop);
   }
 
   TypeInformation handleClosureCall(ir.Node node, Selector selector,
-      AbstractValue mask, MemberEntity member, ArgumentsTypes arguments) {
+      MemberEntity member, ArgumentsTypes arguments) {
     return _inferrer.registerCalledClosure(
         node,
         selector,
-        mask,
         _inferrer.typeOfMember(member),
         _analyzedMember,
         arguments,
@@ -1245,14 +1263,10 @@
         inLoop: inLoop);
   }
 
-  TypeInformation handleForeignInvoke(
-      ir.StaticInvocation node,
-      FunctionEntity function,
-      ArgumentsTypes arguments,
-      Selector selector,
-      AbstractValue mask) {
+  TypeInformation handleForeignInvoke(ir.StaticInvocation node,
+      FunctionEntity function, ArgumentsTypes arguments, Selector selector) {
     String name = function.name;
-    handleStaticInvoke(node, selector, mask, function, arguments);
+    handleStaticInvoke(node, selector, function, arguments);
     if (name == Identifiers.JS) {
       NativeBehavior nativeBehavior =
           _elementMap.getNativeBehaviorForJsCall(node);
@@ -1281,16 +1295,15 @@
     MemberEntity member = _elementMap.getMember(node.target);
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
     if (_closedWorld.commonElements.isForeign(member)) {
-      return handleForeignInvoke(node, member, arguments, selector, mask);
+      return handleForeignInvoke(node, member, arguments, selector);
     } else if (member.isConstructor) {
       return handleConstructorInvoke(
-          node, node.arguments, selector, mask, member, arguments);
+          node, node.arguments, selector, member, arguments);
     } else {
       assert(member.isFunction, "Unexpected static invocation target: $member");
       TypeInformation type =
-          handleStaticInvoke(node, selector, mask, member, arguments);
+          handleStaticInvoke(node, selector, member, arguments);
       FunctionType functionType =
           _elementMap.elementEnvironment.getFunctionType(member);
       if (functionType.returnType.containsFreeTypeVariables) {
@@ -1310,16 +1323,14 @@
 
   @override
   TypeInformation visitStaticGet(ir.StaticGet node) {
-    AbstractValue mask = _memberData.typeOfSend(node);
-    assert(mask == null);
-    return createStaticGetTypeInformation(node, node.target, mask: mask);
+    return createStaticGetTypeInformation(node, node.target);
   }
 
-  TypeInformation createStaticGetTypeInformation(ir.Node node, ir.Member target,
-      {AbstractValue mask}) {
+  TypeInformation createStaticGetTypeInformation(
+      ir.Node node, ir.Member target) {
     MemberEntity member = _elementMap.getMember(target);
     return handleStaticInvoke(
-        node, new Selector.getter(member.memberName), mask, member, null);
+        node, new Selector.getter(member.memberName), member, null);
   }
 
   @override
@@ -1329,17 +1340,16 @@
       _state.markThisAsExposed();
     }
     MemberEntity member = _elementMap.getMember(node.target);
-    AbstractValue mask = _memberData.typeOfSend(node);
-    handleStaticInvoke(node, new Selector.setter(member.memberName), mask,
-        member, new ArgumentsTypes([rhsType], null));
+    handleStaticInvoke(node, new Selector.setter(member.memberName), member,
+        new ArgumentsTypes([rhsType], null));
     return rhsType;
   }
 
-  TypeInformation handlePropertyGet(
-      ir.TreeNode node, TypeInformation receiverType, ir.Member interfaceTarget,
+  TypeInformation handlePropertyGet(ir.TreeNode node, ir.TreeNode receiver,
+      TypeInformation receiverType, ir.Member interfaceTarget,
       {bool isThis}) {
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
+    AbstractValue mask = _typeOfReceiver(node, receiver);
     if (isThis) {
       _checkIfExposesThis(
           selector, _types.newTypedSelector(receiverType, mask));
@@ -1362,21 +1372,23 @@
   @override
   TypeInformation visitPropertyGet(ir.PropertyGet node) {
     TypeInformation receiverType = visit(node.receiver);
-    return handlePropertyGet(node, receiverType, node.interfaceTarget,
+    return handlePropertyGet(
+        node, node.receiver, receiverType, node.interfaceTarget,
         isThis: node.receiver is ir.ThisExpression);
   }
 
   @override
   TypeInformation visitDirectPropertyGet(ir.DirectPropertyGet node) {
     TypeInformation receiverType = thisType;
-    return handlePropertyGet(node, receiverType, node.target, isThis: true);
+    return handlePropertyGet(node, node.receiver, receiverType, node.target,
+        isThis: true);
   }
 
   @override
   TypeInformation visitPropertySet(ir.PropertySet node) {
     TypeInformation receiverType = visit(node.receiver);
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
+    AbstractValue mask = _typeOfReceiver(node, node.receiver);
 
     TypeInformation rhsType = visit(node.value);
     if (node.value is ir.ThisExpression) {
@@ -1729,13 +1741,13 @@
     return _types.nonNullEmpty();
   }
 
-  TypeInformation handleSuperNoSuchMethod(ir.Node node, Selector selector,
-      AbstractValue mask, ArgumentsTypes arguments) {
+  TypeInformation handleSuperNoSuchMethod(
+      ir.Node node, Selector selector, ArgumentsTypes arguments) {
     // Ensure we create a node, to make explicit the call to the
     // `noSuchMethod` handler.
     FunctionEntity noSuchMethod =
         _elementMap.getSuperNoSuchMethod(_analyzedMember.enclosingClass);
-    return handleStaticInvoke(node, selector, mask, noSuchMethod, arguments);
+    return handleStaticInvoke(node, selector, noSuchMethod, arguments);
   }
 
   @override
@@ -1747,10 +1759,8 @@
     MemberEntity member =
         _elementMap.getSuperMember(_analyzedMember, node.name);
     assert(member != null, "No member found for super property get: $node");
-    AbstractValue mask = _memberData.typeOfSend(node);
     Selector selector = new Selector.getter(_elementMap.getName(node.name));
-    TypeInformation type =
-        handleStaticInvoke(node, selector, mask, member, null);
+    TypeInformation type = handleStaticInvoke(node, selector, member, null);
     if (member.isGetter) {
       FunctionType functionType =
           _elementMap.elementEnvironment.getFunctionType(member);
@@ -1780,10 +1790,9 @@
     MemberEntity member =
         _elementMap.getSuperMember(_analyzedMember, node.name, setter: true);
     assert(member != null, "No member found for super property set: $node");
-    AbstractValue mask = _memberData.typeOfSend(node);
     Selector selector = new Selector.setter(_elementMap.getName(node.name));
     ArgumentsTypes arguments = new ArgumentsTypes([rhsType], null);
-    handleStaticInvoke(node, selector, mask, member, arguments);
+    handleStaticInvoke(node, selector, member, arguments);
     return rhsType;
   }
 
@@ -1797,17 +1806,16 @@
         _elementMap.getSuperMember(_analyzedMember, node.name);
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = _elementMap.getSelector(node);
-    AbstractValue mask = _memberData.typeOfSend(node);
     if (member == null) {
       // TODO(johnniwinther): This shouldn't be necessary.
-      return handleSuperNoSuchMethod(node, selector, mask, arguments);
+      return handleSuperNoSuchMethod(node, selector, arguments);
     } else {
       assert(member.isFunction, "Unexpected super invocation target: $member");
       if (isIncompatibleInvoke(member, arguments)) {
-        return handleSuperNoSuchMethod(node, selector, mask, arguments);
+        return handleSuperNoSuchMethod(node, selector, arguments);
       } else {
         TypeInformation type =
-            handleStaticInvoke(node, selector, mask, member, arguments);
+            handleStaticInvoke(node, selector, member, arguments);
         FunctionType functionType =
             _elementMap.elementEnvironment.getFunctionType(member);
         if (functionType.returnType.containsFreeTypeVariables) {
diff --git a/pkg/compiler/lib/src/inferrer/closure_tracer.dart b/pkg/compiler/lib/src/inferrer/closure_tracer.dart
index 3ee6a53..0a01c9b 100644
--- a/pkg/compiler/lib/src/inferrer/closure_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/closure_tracer.dart
@@ -7,7 +7,6 @@
 import '../common/names.dart' show Identifiers, Names;
 import '../elements/entities.dart';
 import '../universe/selector.dart' show Selector;
-import 'abstract_value_domain.dart';
 import 'debug.dart' as debug;
 import 'inferrer_engine.dart';
 import 'node_tracer.dart';
@@ -56,14 +55,13 @@
 
   void _analyzeCall(CallSiteTypeInformation info) {
     Selector selector = info.selector;
-    AbstractValue mask = info.mask;
     tracedElements.forEach((FunctionEntity functionElement) {
       if (!selector.callStructure
           .signatureApplies(functionElement.parameterStructure)) {
         return;
       }
-      inferrer.updateParameterAssignments(
-          info, functionElement, info.arguments, selector, mask,
+      inferrer.updateParameterInputs(
+          info, functionElement, info.arguments, selector,
           remove: false, addToQueue: false);
     });
   }
diff --git a/pkg/compiler/lib/src/inferrer/inferrer_engine.dart b/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
index 98c43b2..a510d20 100644
--- a/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
+++ b/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
@@ -43,7 +43,7 @@
 /// An inferencing engine that computes a call graph of [TypeInformation] nodes
 /// by visiting the AST of the application, and then does the inferencing on the
 /// graph.
-abstract class InferrerEngine {
+class InferrerEngine {
   /// A set of selector names that [List] implements, that we know return their
   /// element type.
   final Set<Selector> returnsListElementTypeSet =
@@ -58,11 +58,45 @@
     new Selector.call(const PublicName('removeLast'), CallStructure.NO_ARGS)
   ]);
 
-  CompilerOptions get options;
-
   /// The [JClosedWorld] on which inference reasoning is based.
-  JClosedWorld get closedWorld;
-  DiagnosticReporter get reporter;
+  final JsClosedWorld closedWorld;
+
+  final TypeSystem types;
+  final Map<ir.TreeNode, TypeInformation> concreteTypes = {};
+  final InferredDataBuilder inferredDataBuilder;
+
+  final FunctionEntity mainElement;
+
+  final Map<Local, TypeInformation> _defaultTypeOfParameter =
+      new Map<Local, TypeInformation>();
+
+  final WorkQueue _workQueue = new WorkQueue();
+
+  final Set<MemberEntity> _analyzedElements = new Set<MemberEntity>();
+
+  /// The maximum number of times we allow a node in the graph to
+  /// change types. If a node reaches that limit, we give up
+  /// inferencing on it and give it the dynamic type.
+  final int _MAX_CHANGE_COUNT = 6;
+
+  int _overallRefineCount = 0;
+  int _addedInGraph = 0;
+
+  final CompilerOptions _options;
+  final Progress _progress;
+  final DiagnosticReporter _reporter;
+  final CompilerOutput _compilerOutput;
+
+  final Set<ConstructorEntity> _generativeConstructorsExposingThis =
+      new Set<ConstructorEntity>();
+
+  /// Data computed internally within elements, like the type-mask of a send a
+  /// list allocation, or a for-in loop.
+  final Map<MemberEntity, GlobalTypeInferenceElementData> _memberData =
+      new Map<MemberEntity, GlobalTypeInferenceElementData>();
+
+  ElementEnvironment get _elementEnvironment => closedWorld.elementEnvironment;
+
   AbstractValueDomain get abstractValueDomain =>
       closedWorld.abstractValueDomain;
   CommonElements get commonElements => closedWorld.commonElements;
@@ -71,255 +105,19 @@
   // [ClosureWorldRefiner].
   NoSuchMethodData get noSuchMethodData => closedWorld.noSuchMethodData;
 
-  TypeSystem get types;
-  Map<ir.TreeNode, TypeInformation> get concreteTypes;
-  InferredDataBuilder get inferredDataBuilder;
-
-  FunctionEntity get mainElement;
-
-  void runOverAllElements();
-
-  void analyze(MemberEntity member);
-  void analyzeListAndEnqueue(ListTypeInformation info);
-  void analyzeSetAndEnqueue(SetTypeInformation info);
-  void analyzeMapAndEnqueue(MapTypeInformation info);
-
-  /// Notifies to the inferrer that [analyzedElement] can have return type
-  /// [newType]. [currentType] is the type the inference has currently found.
-  ///
-  /// Returns the new type for [analyzedElement].
-  TypeInformation addReturnTypeForMethod(
-      FunctionEntity element, TypeInformation unused, TypeInformation newType);
-
-  /// Applies [f] to all elements in the universe that match [selector] and
-  /// [mask]. If [f] returns false, aborts the iteration.
-  void forEachElementMatching(
-      Selector selector, AbstractValue mask, bool f(MemberEntity element));
-
-  /// Returns the [TypeInformation] node for the default value of a parameter.
-  /// If this is queried before it is set by [setDefaultTypeOfParameter], a
-  /// [PlaceholderTypeInformation] is returned, which will later be replaced
-  /// by the actual node when [setDefaultTypeOfParameter] is called.
-  ///
-  /// Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
-  /// should be present and a default type for each parameter should exist.
-  TypeInformation getDefaultTypeOfParameter(Local parameter);
-
-  /// This helper breaks abstractions but is currently required to work around
-  /// the wrong modeling of default values of optional parameters of
-  /// synthetic constructors.
-  ///
-  /// TODO(johnniwinther): Remove once default values of synthetic parameters
-  /// are fixed.
-  bool hasAlreadyComputedTypeOfParameterDefault(Local parameter);
-
-  /// Sets the type of a parameter's default value to [type]. If the global
-  /// mapping in [defaultTypeOfParameter] already contains a type, it must be
-  /// a [PlaceholderTypeInformation], which will be replaced. All its uses are
-  /// updated.
-  void setDefaultTypeOfParameter(Local parameter, TypeInformation type,
-      {bool isInstanceMember});
-
-  Iterable<MemberEntity> getCallersOfForTesting(MemberEntity element);
-
-  // TODO(johnniwinther): Make this private again.
-  GlobalTypeInferenceElementData dataOfMember(MemberEntity element);
-
-  bool checkIfExposesThis(ConstructorEntity element);
-
-  void recordExposesThis(ConstructorEntity element, bool exposesThis);
-
-  /// Records that the return type [element] is of type [type].
-  void recordReturnType(FunctionEntity element, TypeInformation type);
-
-  /// Records that [element] is of type [type].
-  void recordTypeOfField(FieldEntity element, TypeInformation type);
-
-  /// Registers a call to await with an expression of type [argumentType] as
-  /// argument.
-  TypeInformation registerAwait(ir.Node node, TypeInformation argument);
-
-  /// Registers a call to yield with an expression of type [argumentType] as
-  /// argument.
-  TypeInformation registerYield(ir.Node node, TypeInformation argument);
-
-  /// Registers that [caller] calls [closure] with [arguments].
-  ///
-  /// [sideEffectsBuilder] will be updated to incorporate the potential callees'
-  /// side effects.
-  ///
-  /// [inLoop] tells whether the call happens in a loop.
-  TypeInformation registerCalledClosure(
-      ir.Node node,
-      Selector selector,
-      AbstractValue mask,
-      TypeInformation closure,
-      MemberEntity caller,
-      ArgumentsTypes arguments,
-      SideEffectsBuilder sideEffectsBuilder,
-      {bool inLoop});
-
-  /// Registers that [caller] calls [callee] at location [node], with
-  /// [selector], and [arguments]. Note that [selector] is null for forwarding
-  /// constructors.
-  ///
-  /// [sideEffectsBuilder] will be updated to incorporate [callee]'s side
-  /// effects.
-  ///
-  /// [inLoop] tells whether the call happens in a loop.
-  TypeInformation registerCalledMember(
-      Object node,
-      Selector selector,
-      AbstractValue mask,
-      MemberEntity caller,
-      MemberEntity callee,
-      ArgumentsTypes arguments,
-      SideEffectsBuilder sideEffectsBuilder,
-      bool inLoop);
-
-  /// Registers that [caller] calls [selector] with [receiverType] as receiver,
-  /// and [arguments].
-  ///
-  /// [sideEffectsBuilder] will be updated to incorporate the potential callees'
-  /// side effects.
-  ///
-  /// [inLoop] tells whether the call happens in a loop.
-  TypeInformation registerCalledSelector(
-      CallType callType,
-      ir.Node node,
-      Selector selector,
-      AbstractValue mask,
-      TypeInformation receiverType,
-      MemberEntity caller,
-      ArgumentsTypes arguments,
-      SideEffectsBuilder sideEffectsBuilder,
-      {bool inLoop,
-      bool isConditional});
-
-  /// Update the assignments to parameters in the graph. [remove] tells whether
-  /// assignments must be added or removed. If [init] is false, parameters are
-  /// added to the work queue.
-  void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
-      ArgumentsTypes arguments, Selector selector, AbstractValue mask,
-      {bool remove, bool addToQueue: true});
-
-  void updateSelectorInMember(MemberEntity owner, CallType callType,
-      ir.Node node, Selector selector, AbstractValue mask);
-
-  /// Returns the return type of [element].
-  TypeInformation returnTypeOfMember(MemberEntity element);
-
-  /// Returns the type of [element] when being called with [selector].
-  TypeInformation typeOfMemberWithSelector(
-      MemberEntity element, Selector selector);
-
-  /// Returns the type of [element].
-  TypeInformation typeOfMember(MemberEntity element);
-
-  /// Returns the type of [element].
-  TypeInformation typeOfParameter(Local element);
-
-  /// Returns the type for [nativeBehavior]. See documentation on
-  /// [NativeBehavior].
-  TypeInformation typeOfNativeBehavior(NativeBehavior nativeBehavior);
-
-  /// For a given selector, return a shared dynamic call site that will be used
-  /// to combine the results of multiple dynamic calls in the program via
-  /// [IndirectDynamicCallSiteTypeInformation].
-  ///
-  /// This is used only for scalability reasons: if there are too many targets
-  /// and call sites, we may have a quadratic number of edges in the graph, so
-  /// we add a level of indirection to merge the information and keep the graph
-  /// smaller.
-  DynamicCallSiteTypeInformation typeOfSharedDynamicCall(
-      Selector selector, CallStructure structure);
-
-  bool returnsListElementType(Selector selector, AbstractValue mask);
-
-  bool returnsMapValueType(Selector selector, AbstractValue mask);
-
-  void close();
-
-  void clear();
-
-  /// Returns true if global optimizations such as type inferencing can apply to
-  /// the field [element].
-  ///
-  /// One category of elements that do not apply is runtime helpers that the
-  /// backend calls, but the optimizations don't see those calls.
-  bool canFieldBeUsedForGlobalOptimizations(FieldEntity element);
-
-  /// Returns true if global optimizations such as type inferencing can apply to
-  /// the parameter [element].
-  ///
-  /// One category of elements that do not apply is runtime helpers that the
-  /// backend calls, but the optimizations don't see those calls.
-  bool canFunctionParametersBeUsedForGlobalOptimizations(
-      FunctionEntity function);
-
-  /// Returns `true` if inference of parameter types is disabled for [member].
-  bool assumeDynamic(MemberEntity member);
-}
-
-class InferrerEngineImpl extends InferrerEngine {
-  final Map<Local, TypeInformation> defaultTypeOfParameter =
-      new Map<Local, TypeInformation>();
-  final WorkQueue workQueue = new WorkQueue();
-  @override
-  final FunctionEntity mainElement;
-  final Set<MemberEntity> analyzedElements = new Set<MemberEntity>();
-
-  /// The maximum number of times we allow a node in the graph to
-  /// change types. If a node reaches that limit, we give up
-  /// inferencing on it and give it the dynamic type.
-  final int MAX_CHANGE_COUNT = 6;
-
-  int overallRefineCount = 0;
-  int addedInGraph = 0;
-
-  @override
-  final CompilerOptions options;
-  final Progress progress;
-  @override
-  final DiagnosticReporter reporter;
-  final CompilerOutput _compilerOutput;
-
-  @override
-  final JsClosedWorld closedWorld;
-  @override
-  final InferredDataBuilder inferredDataBuilder;
-
-  @override
-  final TypeSystem types;
-  @override
-  final Map<ir.TreeNode, TypeInformation> concreteTypes =
-      new Map<ir.TreeNode, TypeInformation>();
-
-  final Set<ConstructorEntity> generativeConstructorsExposingThis =
-      new Set<ConstructorEntity>();
-
-  /// Data computed internally within elements, like the type-mask of a send a
-  /// list allocation, or a for-in loop.
-  final Map<MemberEntity, GlobalTypeInferenceElementData> _memberData =
-      new Map<MemberEntity, GlobalTypeInferenceElementData>();
-
-  final NoSuchMethodRegistry noSuchMethodRegistry;
-
-  InferrerEngineImpl(
-      this.options,
-      this.progress,
-      this.reporter,
+  InferrerEngine(
+      this._options,
+      this._progress,
+      this._reporter,
       this._compilerOutput,
       this.closedWorld,
-      this.noSuchMethodRegistry,
       this.mainElement,
       this.inferredDataBuilder)
       : this.types = new TypeSystem(
             closedWorld, new KernelTypeSystemStrategy(closedWorld));
 
-  ElementEnvironment get _elementEnvironment => closedWorld.elementEnvironment;
-
-  @override
+  /// Applies [f] to all elements in the universe that match [selector] and
+  /// [mask]. If [f] returns false, aborts the iteration.
   void forEachElementMatching(
       Selector selector, AbstractValue mask, bool f(MemberEntity element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
@@ -329,13 +127,12 @@
   }
 
   // TODO(johnniwinther): Make this private again.
-  @override
   GlobalTypeInferenceElementData dataOfMember(MemberEntity element) =>
       _memberData[element] ??= new KernelGlobalTypeInferenceElementData();
 
   /// Update [sideEffects] with the side effects of [callee] being
   /// called with [selector].
-  void updateSideEffects(SideEffectsBuilder sideEffectsBuilder,
+  void _updateSideEffects(SideEffectsBuilder sideEffectsBuilder,
       Selector selector, MemberEntity callee) {
     if (callee.isField) {
       if (callee.isInstanceMember) {
@@ -363,7 +160,8 @@
     }
   }
 
-  @override
+  /// Returns the type for [nativeBehavior]. See documentation on
+  /// [NativeBehavior].
   TypeInformation typeOfNativeBehavior(NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return types.dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
@@ -404,14 +202,13 @@
     return returnType;
   }
 
-  @override
   void updateSelectorInMember(MemberEntity owner, CallType callType,
       ir.Node node, Selector selector, AbstractValue mask) {
     KernelGlobalTypeInferenceElementData data = dataOfMember(owner);
     assert(validCallType(callType, node, selector));
     switch (callType) {
       case CallType.access:
-        data.setTypeMask(node, mask);
+        data.setReceiverTypeMask(node, mask);
         break;
       case CallType.indirectAccess:
         // indirect access is not diretly recorded in the result data.
@@ -429,31 +226,26 @@
     }
   }
 
-  @override
   bool checkIfExposesThis(ConstructorEntity element) {
-    return generativeConstructorsExposingThis.contains(element);
+    return _generativeConstructorsExposingThis.contains(element);
   }
 
-  @override
   void recordExposesThis(ConstructorEntity element, bool exposesThis) {
     if (exposesThis) {
-      generativeConstructorsExposingThis.add(element);
+      _generativeConstructorsExposingThis.add(element);
     }
   }
 
-  @override
   bool returnsListElementType(Selector selector, AbstractValue mask) {
     return mask != null &&
         abstractValueDomain.isContainer(mask) &&
         returnsListElementTypeSet.contains(selector);
   }
 
-  @override
   bool returnsMapValueType(Selector selector, AbstractValue mask) {
     return mask != null && abstractValueDomain.isMap(mask) && selector.isIndex;
   }
 
-  @override
   void analyzeListAndEnqueue(ListTypeInformation info) {
     if (info.analyzed) return;
     info.analyzed = true;
@@ -468,13 +260,12 @@
         info.originalType, abstractValueDomain.fixedListType)) {
       info.checksGrowable = tracer.callsGrowableMethod;
     }
-    tracer.assignments.forEach(info.elementType.addAssignment);
+    tracer.inputs.forEach(info.elementType.addInput);
     // Enqueue the list for later refinement
-    workQueue.add(info);
-    workQueue.add(info.elementType);
+    _workQueue.add(info);
+    _workQueue.add(info.elementType);
   }
 
-  @override
   void analyzeSetAndEnqueue(SetTypeInformation info) {
     if (info.analyzed) return;
     info.analyzed = true;
@@ -486,13 +277,12 @@
     info.bailedOut = false;
     info.elementType.inferred = true;
 
-    tracer.assignments.forEach(info.elementType.addAssignment);
+    tracer.inputs.forEach(info.elementType.addInput);
     // Enqueue the set for later refinement.
-    workQueue.add(info);
-    workQueue.add(info.elementType);
+    _workQueue.add(info);
+    _workQueue.add(info.elementType);
   }
 
-  @override
   void analyzeMapAndEnqueue(MapTypeInformation info) {
     if (info.analyzed) return;
     info.analyzed = true;
@@ -502,31 +292,30 @@
     if (!succeeded) return;
 
     info.bailedOut = false;
-    for (int i = 0; i < tracer.keyAssignments.length; ++i) {
-      TypeInformation newType = info.addEntryAssignment(abstractValueDomain,
-          tracer.keyAssignments[i], tracer.valueAssignments[i]);
-      if (newType != null) workQueue.add(newType);
+    for (int i = 0; i < tracer.keyInputs.length; ++i) {
+      TypeInformation newType = info.addEntryInput(
+          abstractValueDomain, tracer.keyInputs[i], tracer.valueInputs[i]);
+      if (newType != null) _workQueue.add(newType);
     }
-    for (TypeInformation map in tracer.mapAssignments) {
-      workQueue.addAll(info.addMapAssignment(abstractValueDomain, map));
+    for (TypeInformation map in tracer.mapInputs) {
+      _workQueue.addAll(info.addMapInput(abstractValueDomain, map));
     }
 
     info.markAsInferred();
-    workQueue.add(info.keyType);
-    workQueue.add(info.valueType);
-    workQueue.addAll(info.typeInfoMap.values);
-    workQueue.add(info);
+    _workQueue.add(info.keyType);
+    _workQueue.add(info.valueType);
+    _workQueue.addAll(info.typeInfoMap.values);
+    _workQueue.add(info);
   }
 
-  @override
   void runOverAllElements() {
-    analyzeAllElements();
+    _analyzeAllElements();
     TypeGraphDump dump =
         debug.PRINT_GRAPH ? new TypeGraphDump(_compilerOutput, this) : null;
 
     dump?.beforeAnalysis();
-    buildWorkQueue();
-    refine();
+    _buildWorkQueue();
+    _refine();
 
     // Try to infer element types of lists and compute their escape information.
     types.allocatedLists.values.forEach((TypeInformation info) {
@@ -560,7 +349,7 @@
             types.strategy.forEachParameter(element, (Local parameter) {
               types
                   .getInferredTypeOfParameter(parameter)
-                  .giveUp(this, clearAssignments: false);
+                  .giveUp(this, clearInputs: false);
             });
           });
           bailedOutOn.addAll(elements);
@@ -573,7 +362,7 @@
             ParameterTypeInformation info =
                 types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
-            workQueue.add(info);
+            _workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
             inferredDataBuilder.registerMightBePassedToApply(element);
@@ -598,7 +387,7 @@
           assert(calledElement is ConstructorEntity &&
               calledElement.isGenerativeConstructor);
           ClassEntity cls = calledElement.enclosingClass;
-          FunctionEntity callMethod = lookupCallMethod(cls);
+          FunctionEntity callMethod = _lookupCallMethod(cls);
           assert(callMethod != null, failedAt(cls));
           Iterable<FunctionEntity> elements = [callMethod];
           trace(elements, new ClosureTracerVisitor(elements, info, this));
@@ -625,17 +414,17 @@
     // as nodes that use elements fetched from these lists/maps. The
     // workset for a new run of the analysis will be these nodes.
     Set<TypeInformation> seenTypes = new Set<TypeInformation>();
-    while (!workQueue.isEmpty) {
-      TypeInformation info = workQueue.remove();
+    while (!_workQueue.isEmpty) {
+      TypeInformation info = _workQueue.remove();
       if (seenTypes.contains(info)) continue;
       // If the node cannot be reset, we do not need to update its users either.
       if (!info.reset(this)) continue;
       seenTypes.add(info);
-      workQueue.addAll(info.users);
+      _workQueue.addAll(info.users);
     }
 
-    workQueue.addAll(seenTypes);
-    refine();
+    _workQueue.addAll(seenTypes);
+    _refine();
 
     if (debug.PRINT_SUMMARY) {
       types.allocatedLists.values.forEach((_info) {
@@ -681,42 +470,42 @@
           }
         } else if (info is StaticCallSiteTypeInformation) {
           ClassEntity cls = info.calledElement.enclosingClass;
-          FunctionEntity callMethod = lookupCallMethod(cls);
+          FunctionEntity callMethod = _lookupCallMethod(cls);
           print('${types.getInferredSignatureOfMethod(callMethod)} for ${cls}');
         } else {
           print('${info.type} for some unknown kind of closure');
         }
       });
-      analyzedElements.forEach((MemberEntity elem) {
+      _analyzedElements.forEach((MemberEntity elem) {
         TypeInformation type = types.getInferredTypeOfMember(elem);
-        print('${elem} :: ${type} from ${type.assignments} ');
+        print('${elem} :: ${type} from ${type.inputs} ');
       });
     }
     dump?.afterAnalysis();
 
-    reporter.log('Inferred $overallRefineCount types.');
+    _reporter.log('Inferred $_overallRefineCount types.');
 
-    processLoopInformation();
+    _processLoopInformation();
   }
 
   /// Call [analyze] for all live members.
-  void analyzeAllElements() {
+  void _analyzeAllElements() {
     Iterable<MemberEntity> processedMembers = closedWorld.processedMembers
         .where((MemberEntity member) => !member.isAbstract);
 
-    progress.startPhase();
+    _progress.startPhase();
     processedMembers.forEach((MemberEntity member) {
-      progress.showProgress(
-          'Added ', addedInGraph, ' elements in inferencing graph.');
+      _progress.showProgress(
+          'Added ', _addedInGraph, ' elements in inferencing graph.');
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
       types.withMember(member, () => analyze(member));
     });
-    reporter.log('Added $addedInGraph elements in inferencing graph.');
+    _reporter.log('Added $_addedInGraph elements in inferencing graph.');
   }
 
   /// Returns the body node for [member].
-  ir.Node computeMemberBody(MemberEntity member) {
+  ir.Node _computeMemberBody(MemberEntity member) {
     MemberDefinition definition =
         closedWorld.elementMap.getMemberDefinition(member);
     switch (definition.kind) {
@@ -752,7 +541,7 @@
 
   /// Returns the `call` method on [cls] or the `noSuchMethod` if [cls] doesn't
   /// implement `call`.
-  FunctionEntity lookupCallMethod(ClassEntity cls) {
+  FunctionEntity _lookupCallMethod(ClassEntity cls) {
     FunctionEntity function =
         _elementEnvironment.lookupClassMember(cls, Identifiers.call);
     if (function == null || function.isAbstract) {
@@ -762,18 +551,17 @@
     return function;
   }
 
-  @override
   void analyze(MemberEntity element) {
-    if (analyzedElements.contains(element)) return;
-    analyzedElements.add(element);
+    if (_analyzedElements.contains(element)) return;
+    _analyzedElements.add(element);
 
-    ir.Node body = computeMemberBody(element);
+    ir.Node body = _computeMemberBody(element);
 
     TypeInformation type;
-    reporter.withCurrentElement(element, () {
-      type = computeMemberTypeInformation(element, body);
+    _reporter.withCurrentElement(element, () {
+      type = _computeMemberTypeInformation(element, body);
     });
-    addedInGraph++;
+    _addedInGraph++;
 
     if (element.isField) {
       FieldEntity field = element;
@@ -784,7 +572,7 @@
           if (type is! ListTypeInformation && type is! MapTypeInformation) {
             // For non-container types, the constant handler does
             // constant folding that could give more precise results.
-            ConstantValue value = getFieldConstant(field);
+            ConstantValue value = _getFieldConstant(field);
             if (value != null) {
               if (value.isFunction) {
                 FunctionConstantValue functionConstant = value;
@@ -818,7 +606,7 @@
       if ((element.isStatic || element.isTopLevel) &&
           body != null &&
           !element.isConst) {
-        if (isFieldInitializerPotentiallyNull(element, body)) {
+        if (_isFieldInitializerPotentiallyNull(element, body)) {
           recordTypeOfField(field, types.nullType);
         }
       }
@@ -829,10 +617,10 @@
   }
 
   /// Visits [body] to compute the [TypeInformation] node for [member].
-  TypeInformation computeMemberTypeInformation(
+  TypeInformation _computeMemberTypeInformation(
       MemberEntity member, ir.Node body) {
     KernelTypeGraphBuilder visitor = new KernelTypeGraphBuilder(
-        options,
+        _options,
         closedWorld,
         this,
         member,
@@ -844,7 +632,7 @@
 
   /// Returns `true` if the [initializer] of the non-const static or top-level
   /// [field] is potentially `null`.
-  bool isFieldInitializerPotentiallyNull(
+  bool _isFieldInitializerPotentiallyNull(
       FieldEntity field, ir.Node initializer) {
     // TODO(13429): We could do better here by using the
     // constant handler to figure out if it's a lazy field or not.
@@ -866,18 +654,18 @@
 
   /// Returns the [ConstantValue] for the initial value of [field], or
   /// `null` if the initializer is not a constant value.
-  ConstantValue getFieldConstant(FieldEntity field) {
+  ConstantValue _getFieldConstant(FieldEntity field) {
     return closedWorld.fieldAnalysis.getFieldData(field).initialValue;
   }
 
   /// Returns `true` if [cls] has a 'call' method.
-  bool hasCallType(ClassEntity cls) {
+  bool _hasCallType(ClassEntity cls) {
     return closedWorld.elementMap.types
             .getCallType(closedWorld.elementEnvironment.getThisType(cls)) !=
         null;
   }
 
-  void processLoopInformation() {
+  void _processLoopInformation() {
     types.allocatedCalls.forEach((CallSiteTypeInformation info) {
       if (!info.inLoop) return;
       // We can't compute the callees of closures, no new information to add.
@@ -887,7 +675,8 @@
       if (info is StaticCallSiteTypeInformation) {
         MemberEntity member = info.calledElement;
         inferredDataBuilder.addFunctionCalledInLoop(member);
-      } else if (info.mask != null &&
+      } else if (info is DynamicCallSiteTypeInformation &&
+          info.mask != null &&
           abstractValueDomain.containsAll(info.mask).isDefinitelyFalse) {
         // For instance methods, we only register a selector called in a
         // loop if it is a typed selector, to avoid marking too many
@@ -900,20 +689,20 @@
     });
   }
 
-  void refine() {
-    progress.startPhase();
-    while (!workQueue.isEmpty) {
-      progress.showProgress('Inferred ', overallRefineCount, ' types.');
-      TypeInformation info = workQueue.remove();
+  void _refine() {
+    _progress.startPhase();
+    while (!_workQueue.isEmpty) {
+      _progress.showProgress('Inferred ', _overallRefineCount, ' types.');
+      TypeInformation info = _workQueue.remove();
       AbstractValue oldType = info.type;
       AbstractValue newType = info.refine(this);
       // Check that refinement has not accidentally changed the type.
       assert(oldType == info.type);
       if (info.abandonInferencing) info.doNotEnqueue = true;
       if ((info.type = newType) != oldType) {
-        overallRefineCount++;
+        _overallRefineCount++;
         info.refineCount++;
-        if (info.refineCount > MAX_CHANGE_COUNT) {
+        if (info.refineCount > _MAX_CHANGE_COUNT) {
           if (debug.ANOMALY_WARN) {
             print("ANOMALY WARNING: max refinement reached for $info");
           }
@@ -921,7 +710,7 @@
           info.type = info.refine(this);
           info.doNotEnqueue = true;
         }
-        workQueue.addAll(info.users);
+        _workQueue.addAll(info.users);
         if (info.hasStableType(this)) {
           info.stabilize(this);
         }
@@ -929,27 +718,29 @@
     }
   }
 
-  void buildWorkQueue() {
-    workQueue.addAll(types.orderedTypeInformations);
-    workQueue.addAll(types.allocatedTypes);
-    workQueue.addAll(types.allocatedClosures);
-    workQueue.addAll(types.allocatedCalls);
+  void _buildWorkQueue() {
+    _workQueue.addAll(types.orderedTypeInformations);
+    _workQueue.addAll(types.allocatedTypes);
+    _workQueue.addAll(types.allocatedClosures);
+    _workQueue.addAll(types.allocatedCalls);
   }
 
-  @override
-  void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
-      ArgumentsTypes arguments, Selector selector, AbstractValue mask,
+  /// Update the inputs to parameters in the graph. [remove] tells whether
+  /// inputs must be added or removed. If [init] is false, parameters are
+  /// added to the work queue.
+  void updateParameterInputs(TypeInformation caller, MemberEntity callee,
+      ArgumentsTypes arguments, Selector selector,
       {bool remove, bool addToQueue: true}) {
     if (callee.name == Identifiers.noSuchMethod_) return;
     if (callee.isField) {
       if (selector.isSetter) {
         ElementTypeInformation info = types.getInferredTypeOfMember(callee);
         if (remove) {
-          info.removeAssignment(arguments.positional[0]);
+          info.removeInput(arguments.positional[0]);
         } else {
-          info.addAssignment(arguments.positional[0]);
+          info.addInput(arguments.positional[0]);
         }
-        if (addToQueue) workQueue.add(info);
+        if (addToQueue) _workQueue.add(info);
       }
     } else if (callee.isGetter) {
       return;
@@ -972,7 +763,7 @@
           ParameterTypeInformation info =
               types.getInferredTypeOfParameter(parameter);
           info.tagAsTearOffClosureParameter(this);
-          if (addToQueue) workQueue.add(info);
+          if (addToQueue) _workQueue.add(info);
         });
       }
     } else {
@@ -991,34 +782,37 @@
         if (type == null) type = getDefaultTypeOfParameter(parameter);
         TypeInformation info = types.getInferredTypeOfParameter(parameter);
         if (remove) {
-          info.removeAssignment(type);
+          info.removeInput(type);
         } else {
-          info.addAssignment(type);
+          info.addInput(type);
         }
         parameterIndex++;
-        if (addToQueue) workQueue.add(info);
+        if (addToQueue) _workQueue.add(info);
       });
     }
   }
 
-  @override
+  /// Sets the type of a parameter's default value to [type]. If the global
+  /// mapping in `_defaultTypeOfParameter` already contains a type, it must be
+  /// a [PlaceholderTypeInformation], which will be replaced. All its uses are
+  /// updated.
   void setDefaultTypeOfParameter(Local parameter, TypeInformation type,
       {bool isInstanceMember}) {
     assert(
         type != null, failedAt(parameter, "No default type for $parameter."));
-    TypeInformation existing = defaultTypeOfParameter[parameter];
-    defaultTypeOfParameter[parameter] = type;
+    TypeInformation existing = _defaultTypeOfParameter[parameter];
+    _defaultTypeOfParameter[parameter] = type;
     TypeInformation info = types.getInferredTypeOfParameter(parameter);
     if (existing != null && existing is PlaceholderTypeInformation) {
       // Replace references to [existing] to use [type] instead.
       if (isInstanceMember) {
-        ParameterAssignments assignments = info.assignments;
-        assignments.replace(existing, type);
+        ParameterInputs inputs = info.inputs;
+        inputs.replace(existing, type);
       } else {
-        List<TypeInformation> assignments = info.assignments;
-        for (int i = 0; i < assignments.length; i++) {
-          if (assignments[i] == existing) {
-            assignments[i] = type;
+        List<TypeInformation> inputs = info.inputs;
+        for (int i = 0; i < inputs.length; i++) {
+          if (inputs[i] == existing) {
+            inputs[i] = type;
           }
         }
       }
@@ -1029,56 +823,59 @@
     }
   }
 
-  @override
+  /// Returns the [TypeInformation] node for the default value of a parameter.
+  /// If this is queried before it is set by [setDefaultTypeOfParameter], a
+  /// [PlaceholderTypeInformation] is returned, which will later be replaced
+  /// by the actual node when [setDefaultTypeOfParameter] is called.
+  ///
+  /// Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
+  /// should be present and a default type for each parameter should exist.
   TypeInformation getDefaultTypeOfParameter(Local parameter) {
-    return defaultTypeOfParameter.putIfAbsent(parameter, () {
+    return _defaultTypeOfParameter.putIfAbsent(parameter, () {
       return new PlaceholderTypeInformation(
           abstractValueDomain, types.currentMember);
     });
   }
 
-  @override
-  bool hasAlreadyComputedTypeOfParameterDefault(Local parameter) {
-    TypeInformation seen = defaultTypeOfParameter[parameter];
-    return (seen != null && seen is! PlaceholderTypeInformation);
-  }
-
-  @override
+  /// Returns the type of [element].
   TypeInformation typeOfParameter(Local element) {
     return types.getInferredTypeOfParameter(element);
   }
 
-  @override
+  /// Returns the type of [element].
   TypeInformation typeOfMember(MemberEntity element) {
     if (element is FunctionEntity) return types.functionType;
     return types.getInferredTypeOfMember(element);
   }
 
-  @override
+  /// Returns the return type of [element].
   TypeInformation returnTypeOfMember(MemberEntity element) {
     if (element is! FunctionEntity) return types.dynamicType;
     return types.getInferredTypeOfMember(element);
   }
 
-  @override
+  /// Records that [element] is of type [type].
   void recordTypeOfField(FieldEntity element, TypeInformation type) {
-    types.getInferredTypeOfMember(element).addAssignment(type);
+    types.getInferredTypeOfMember(element).addInput(type);
   }
 
-  @override
+  /// Records that the return type [element] is of type [type].
   void recordReturnType(FunctionEntity element, TypeInformation type) {
     TypeInformation info = types.getInferredTypeOfMember(element);
     if (element.name == '==') {
       // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
-      info.addAssignment(types.boolType);
+      info.addInput(types.boolType);
     }
     // TODO(ngeoffray): Clean up. We do these checks because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (type == null) return;
-    if (info.assignments.isEmpty) info.addAssignment(type);
+    if (info.inputs.isEmpty) info.addInput(type);
   }
 
-  @override
+  /// Notifies to the inferrer that [analyzedElement] can have return type
+  /// [newType]. [currentType] is the type the inference has currently found.
+  ///
+  /// Returns the new type for [analyzedElement].
   TypeInformation addReturnTypeForMethod(
       FunctionEntity element, TypeInformation unused, TypeInformation newType) {
     TypeInformation type = types.getInferredTypeOfMember(element);
@@ -1087,15 +884,21 @@
     if (element is ConstructorEntity && element.isGenerativeConstructor) {
       return type;
     }
-    type.addAssignment(newType);
+    type.addInput(newType);
     return type;
   }
 
-  @override
+  /// Registers that [caller] calls [callee] at location [node], with
+  /// [selector], and [arguments]. Note that [selector] is null for forwarding
+  /// constructors.
+  ///
+  /// [sideEffectsBuilder] will be updated to incorporate [callee]'s side
+  /// effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledMember(
       Object node,
       Selector selector,
-      AbstractValue mask,
       MemberEntity caller,
       MemberEntity callee,
       ArgumentsTypes arguments,
@@ -1108,7 +911,6 @@
         caller,
         callee,
         selector,
-        mask,
         arguments,
         inLoop);
     // If this class has a 'call' method then we have essentially created a
@@ -1121,17 +923,23 @@
         callee is ConstructorEntity &&
         callee.isGenerativeConstructor) {
       ClassEntity cls = callee.enclosingClass;
-      if (hasCallType(cls)) {
+      if (_hasCallType(cls)) {
         types.allocatedClosures.add(info);
       }
     }
     info.addToGraph(this);
     types.allocatedCalls.add(info);
-    updateSideEffects(sideEffectsBuilder, selector, callee);
+    _updateSideEffects(sideEffectsBuilder, selector, callee);
     return info;
   }
 
-  @override
+  /// Registers that [caller] calls [selector] with [receiverType] as receiver,
+  /// and [arguments].
+  ///
+  /// [sideEffectsBuilder] will be updated to incorporate the potential callees'
+  /// side effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledSelector(
       CallType callType,
       ir.Node node,
@@ -1144,80 +952,65 @@
       {bool inLoop,
       bool isConditional}) {
     if (selector.isClosureCall) {
-      return registerCalledClosure(node, selector, mask, receiverType, caller,
-          arguments, sideEffectsBuilder,
+      return registerCalledClosure(
+          node, selector, receiverType, caller, arguments, sideEffectsBuilder,
           inLoop: inLoop);
     }
 
     if (closedWorld.includesClosureCall(selector, mask)) {
       sideEffectsBuilder.setAllSideEffectsAndDependsOnSomething();
     }
+
     closedWorld.locateMembers(selector, mask).forEach((callee) {
-      updateSideEffects(sideEffectsBuilder, selector, callee);
+      _updateSideEffects(sideEffectsBuilder, selector, callee);
     });
 
-    CallSiteTypeInformation info;
-
-    // We force using indirection for `==` because it is a very common dynamic
-    // call site on many apps.
-    // TODO(sigmund): it would be even better if we could automatically detect
-    // when dynamic calls are growing too big and add the indirection at that
-    // point.
-    if (selector.name == '==') {
-      info = new IndirectDynamicCallSiteTypeInformation(
-          abstractValueDomain,
-          types.currentMember,
-          node,
-          typeOfSharedDynamicCall(selector, CallStructure.ONE_ARG),
-          caller,
-          selector,
-          mask,
-          receiverType,
-          arguments,
-          inLoop,
-          isConditional);
-    } else {
-      info = new DynamicCallSiteTypeInformation(
-          abstractValueDomain,
-          types.currentMember,
-          callType,
-          node,
-          caller,
-          selector,
-          mask,
-          receiverType,
-          arguments,
-          inLoop,
-          isConditional);
-    }
+    CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
+        abstractValueDomain,
+        types.currentMember,
+        callType,
+        node,
+        caller,
+        selector,
+        mask,
+        receiverType,
+        arguments,
+        inLoop,
+        isConditional);
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     return info;
   }
 
-  @override
+  /// Registers a call to await with an expression of type [argumentType] as
+  /// argument.
   TypeInformation registerAwait(ir.Node node, TypeInformation argument) {
     AwaitTypeInformation info = new AwaitTypeInformation(
         abstractValueDomain, types.currentMember, node);
-    info.addAssignment(argument);
+    info.addInput(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
-  @override
+  /// Registers a call to yield with an expression of type [argumentType] as
+  /// argument.
   TypeInformation registerYield(ir.Node node, TypeInformation argument) {
     YieldTypeInformation info = new YieldTypeInformation(
         abstractValueDomain, types.currentMember, node);
-    info.addAssignment(argument);
+    info.addInput(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
-  @override
+  /// Registers that [caller] calls [closure] with [arguments].
+  ///
+  /// [sideEffectsBuilder] will be updated to incorporate the potential callees'
+  /// side effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledClosure(
       ir.Node node,
       Selector selector,
-      AbstractValue mask,
       TypeInformation closure,
       MemberEntity caller,
       ArgumentsTypes arguments,
@@ -1230,7 +1023,6 @@
         node,
         caller,
         selector,
-        mask,
         closure,
         arguments,
         inLoop);
@@ -1239,7 +1031,6 @@
     return info;
   }
 
-  @override
   void close() {
     for (MemberTypeInformation typeInformation
         in types.memberTypeInformations.values) {
@@ -1247,7 +1038,6 @@
     }
   }
 
-  @override
   void clear() {
     if (retainDataForTesting) return;
 
@@ -1258,7 +1048,7 @@
     types.allocatedCalls.forEach(cleanup);
     types.allocatedCalls.clear();
 
-    defaultTypeOfParameter.clear();
+    _defaultTypeOfParameter.clear();
 
     types.parameterTypeInformations.values.forEach(cleanup);
     types.memberTypeInformations.values.forEach(cleanup);
@@ -1271,8 +1061,8 @@
     types.allocatedClosures.forEach(cleanup);
     types.allocatedClosures.clear();
 
-    analyzedElements.clear();
-    generativeConstructorsExposingThis.clear();
+    _analyzedElements.clear();
+    _generativeConstructorsExposingThis.clear();
 
     types.allocatedMaps.values.forEach(cleanup);
     types.allocatedSets.values.forEach(cleanup);
@@ -1281,13 +1071,12 @@
     _memberData.clear();
   }
 
-  @override
   Iterable<MemberEntity> getCallersOfForTesting(MemberEntity element) {
     MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callersForTesting;
   }
 
-  @override
+  /// Returns the type of [element] when being called with [selector].
   TypeInformation typeOfMemberWithSelector(
       MemberEntity element, Selector selector) {
     if (element.name == Identifiers.noSuchMethod_ &&
@@ -1321,8 +1110,17 @@
   /// cache holds that shared dynamic call node for a given selector.
   Map<Selector, DynamicCallSiteTypeInformation> _sharedCalls = {};
 
-  @override
-  DynamicCallSiteTypeInformation typeOfSharedDynamicCall(
+  /// For a given selector, return a shared dynamic call site that will be used
+  /// to combine the results of multiple dynamic calls in the program via
+  /// [IndirectDynamicCallSiteTypeInformation].
+  ///
+  /// This is used only for scalability reasons: if there are too many targets
+  /// and call sites, we may have a quadratic number of edges in the graph, so
+  /// we add a level of indirection to merge the information and keep the graph
+  /// smaller.
+  // TODO(sigmund): start using or delete indirection logic.
+  // ignore: unused_element
+  DynamicCallSiteTypeInformation _typeOfSharedDynamicCall(
       Selector selector, CallStructure structure) {
     DynamicCallSiteTypeInformation info = _sharedCalls[selector];
     if (info != null) return info;
@@ -1359,7 +1157,11 @@
     return info;
   }
 
-  @override
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the field [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
   bool canFieldBeUsedForGlobalOptimizations(FieldEntity element) {
     if (closedWorld.backendUsage.isFieldUsedByBackend(element)) {
       return false;
@@ -1370,13 +1172,17 @@
     return true;
   }
 
-  @override
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the parameter [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
   bool canFunctionParametersBeUsedForGlobalOptimizations(
       FunctionEntity function) {
     return !closedWorld.backendUsage.isFunctionUsedByBackend(function);
   }
 
-  @override
+  /// Returns `true` if inference of parameter types is disabled for [member].
   bool assumeDynamic(MemberEntity member) {
     return closedWorld.annotationsData.hasAssumeDynamic(member);
   }
@@ -1451,7 +1257,7 @@
           parameter,
           type,
           member,
-          new ParameterAssignments());
+          new ParameterInputs());
     } else {
       return new ParameterTypeInformation.static(
           abstractValueDomain, memberTypeInformation, parameter, type, member);
@@ -1496,8 +1302,7 @@
   /// objects in a debugging data stream.
   static const String tag = 'global-type-inference-element-data';
 
-  // TODO(johnniwinther): Rename this together with [typeOfSend].
-  Map<ir.TreeNode, AbstractValue> _sendMap;
+  Map<ir.TreeNode, AbstractValue> _receiverMap;
 
   Map<ir.ForInStatement, AbstractValue> _iteratorMap;
   Map<ir.ForInStatement, AbstractValue> _currentMap;
@@ -1505,8 +1310,8 @@
 
   KernelGlobalTypeInferenceElementData();
 
-  KernelGlobalTypeInferenceElementData.internal(
-      this._sendMap, this._iteratorMap, this._currentMap, this._moveNextMap);
+  KernelGlobalTypeInferenceElementData.internal(this._receiverMap,
+      this._iteratorMap, this._currentMap, this._moveNextMap);
 
   /// Deserializes a [GlobalTypeInferenceElementData] object from [source].
   factory KernelGlobalTypeInferenceElementData.readFromDataSource(
@@ -1542,7 +1347,7 @@
     sink.inMemberContext(context, () {
       sink.begin(tag);
       sink.writeTreeNodeMapInContext(
-          _sendMap,
+          _receiverMap,
           (AbstractValue value) =>
               abstractValueDomain.writeAbstractValueToDataSink(sink, value),
           allowNull: true);
@@ -1567,10 +1372,10 @@
 
   @override
   GlobalTypeInferenceElementData compress() {
-    if (_sendMap != null) {
-      _sendMap.removeWhere(_mapsToNull);
-      if (_sendMap.isEmpty) {
-        _sendMap = null;
+    if (_receiverMap != null) {
+      _receiverMap.removeWhere(_mapsToNull);
+      if (_receiverMap.isEmpty) {
+        _receiverMap = null;
       }
     }
     if (_iteratorMap != null) {
@@ -1591,7 +1396,7 @@
         _moveNextMap = null;
       }
     }
-    if (_sendMap == null &&
+    if (_receiverMap == null &&
         _iteratorMap == null &&
         _currentMap == null &&
         _moveNextMap == null) {
@@ -1601,9 +1406,9 @@
   }
 
   @override
-  AbstractValue typeOfSend(ir.TreeNode node) {
-    if (_sendMap == null) return null;
-    return _sendMap[node];
+  AbstractValue typeOfReceiver(ir.TreeNode node) {
+    if (_receiverMap == null) return null;
+    return _receiverMap[node];
   }
 
   void setCurrentTypeMask(ir.ForInStatement node, AbstractValue mask) {
@@ -1639,15 +1444,9 @@
     return _iteratorMap[node];
   }
 
-  void setTypeMask(ir.TreeNode node, AbstractValue mask) {
-    _sendMap ??= <ir.TreeNode, AbstractValue>{};
-    _sendMap[node] = mask;
-  }
-
-  @override
-  AbstractValue typeOfGetter(ir.TreeNode node) {
-    if (_sendMap == null) return null;
-    return _sendMap[node];
+  void setReceiverTypeMask(ir.TreeNode node, AbstractValue mask) {
+    _receiverMap ??= <ir.TreeNode, AbstractValue>{};
+    _receiverMap[node] = mask;
   }
 }
 
diff --git a/pkg/compiler/lib/src/inferrer/list_tracer.dart b/pkg/compiler/lib/src/inferrer/list_tracer.dart
index aaa69e4..db86752 100644
--- a/pkg/compiler/lib/src/inferrer/list_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/list_tracer.dart
@@ -130,13 +130,13 @@
 
 class ListTracerVisitor extends TracerVisitor {
   // The [Set] of found assignments to the list.
-  Set<TypeInformation> assignments = new Setlet<TypeInformation>();
+  Set<TypeInformation> inputs = new Setlet<TypeInformation>();
   bool callsGrowableMethod = false;
 
   ListTracerVisitor(tracedType, inferrer) : super(tracedType, inferrer);
 
   /// Returns [true] if the analysis completed successfully, [false] if it
-  /// bailed out. In the former case, [assignments] holds a list of
+  /// bailed out. In the former case, [inputs] holds a list of
   /// [TypeInformation] nodes that flow into the element type of this list.
   bool run() {
     analyze();
@@ -149,7 +149,7 @@
       return true;
     } else {
       callsGrowableMethod = true;
-      assignments = null;
+      inputs = null;
       return false;
     }
   }
@@ -180,18 +180,18 @@
           int positionalLength = info.arguments.positional.length;
           if (selectorName == 'add') {
             if (positionalLength == 1) {
-              assignments.add(info.arguments.positional[0]);
+              inputs.add(info.arguments.positional[0]);
             }
           } else if (selectorName == 'insert') {
             if (positionalLength == 2) {
-              assignments.add(info.arguments.positional[1]);
+              inputs.add(info.arguments.positional[1]);
             }
           } else {
             bailout('Used in a not-ok selector');
             return;
           }
         } else if (selector.isIndexSet) {
-          assignments.add(info.arguments.positional[1]);
+          inputs.add(info.arguments.positional[1]);
         } else if (!selector.isIndex) {
           bailout('Used in a not-ok selector');
           return;
@@ -202,7 +202,7 @@
       }
       if (selectorName == 'length' && selector.isSetter) {
         callsGrowableMethod = true;
-        assignments.add(inferrer.types.nullType);
+        inputs.add(inferrer.types.nullType);
       }
     } else if (selector.isCall &&
         (info.hasClosureCallTargets ||
diff --git a/pkg/compiler/lib/src/inferrer/map_tracer.dart b/pkg/compiler/lib/src/inferrer/map_tracer.dart
index f21fd15..3f29c0c 100644
--- a/pkg/compiler/lib/src/inferrer/map_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/map_tracer.dart
@@ -35,17 +35,17 @@
   // These lists are used to keep track of newly discovered assignments to
   // the map. Note that elements at corresponding indices are expected to
   // belong to the same assignment operation.
-  List<TypeInformation> keyAssignments = <TypeInformation>[];
-  List<TypeInformation> valueAssignments = <TypeInformation>[];
+  List<TypeInformation> keyInputs = <TypeInformation>[];
+  List<TypeInformation> valueInputs = <TypeInformation>[];
   // This list is used to keep track of assignments of entire maps to
   // this map.
-  List<MapTypeInformation> mapAssignments = <MapTypeInformation>[];
+  List<MapTypeInformation> mapInputs = <MapTypeInformation>[];
 
   MapTracerVisitor(tracedType, inferrer) : super(tracedType, inferrer);
 
   /// Returns [true] if the analysis completed successfully, [false]
-  /// if it bailed out. In the former case, [keyAssignments] and
-  /// [valueAssignments] hold a list of [TypeInformation] nodes that
+  /// if it bailed out. In the former case, [keyInputs] and
+  /// [valueInputs] hold a list of [TypeInformation] nodes that
   /// flow into the key and value types of this map.
   bool run() {
     analyze();
@@ -54,7 +54,7 @@
       map.addFlowsIntoTargets(flowsInto);
       return true;
     }
-    keyAssignments = valueAssignments = mapAssignments = null;
+    keyInputs = valueInputs = mapInputs = null;
     return false;
   }
 
@@ -87,7 +87,7 @@
             TypeInformation map = info.arguments.positional[0];
             if (map is MapTypeInformation) {
               inferrer.analyzeMapAndEnqueue(map);
-              mapAssignments.add(map);
+              mapInputs.add(map);
             } else {
               // If we could select a component from a [TypeInformation],
               // like the keytype or valuetype in this case, we could
@@ -103,8 +103,8 @@
             // to go to dynamic.
             // TODO(herhut,16507): Use return type of closure in
             // Map.putIfAbsent.
-            keyAssignments.add(info.arguments.positional[0]);
-            valueAssignments.add(inferrer.types.dynamicType);
+            keyInputs.add(info.arguments.positional[0]);
+            valueInputs.add(inferrer.types.dynamicType);
           } else {
             // It would be nice to handle [Map.keys] and [Map.values], too.
             // However, currently those calls do not trigger the creation
@@ -115,8 +115,8 @@
             return;
           }
         } else if (selector.isIndexSet) {
-          keyAssignments.add(info.arguments.positional[0]);
-          valueAssignments.add(info.arguments.positional[1]);
+          keyInputs.add(info.arguments.positional[0]);
+          valueInputs.add(info.arguments.positional[1]);
         } else if (!selector.isIndex) {
           bailout('Map used in a not-ok selector [$selectorName]');
           return;
diff --git a/pkg/compiler/lib/src/inferrer/set_tracer.dart b/pkg/compiler/lib/src/inferrer/set_tracer.dart
index 72cf043..8a98719 100644
--- a/pkg/compiler/lib/src/inferrer/set_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/set_tracer.dart
@@ -65,12 +65,12 @@
 ]);
 
 class SetTracerVisitor extends TracerVisitor {
-  List<TypeInformation> assignments = <TypeInformation>[];
+  List<TypeInformation> inputs = <TypeInformation>[];
 
   SetTracerVisitor(tracedType, inferrer) : super(tracedType, inferrer);
 
   /// Returns [true] if the analysis completed successfully, [false] if it
-  /// bailed out. In the former case, [assignments] holds a list of
+  /// bailed out. In the former case, [inputs] holds a list of
   /// [TypeInformation] nodes that flow into the element type of this set.
   bool run() {
     analyze();
@@ -79,7 +79,7 @@
       set.addFlowsIntoTargets(flowsInto);
       return true;
     }
-    assignments = null;
+    inputs = null;
     return false;
   }
 
@@ -108,7 +108,7 @@
         if (selector.isCall) {
           switch (selectorName) {
             case 'add':
-              assignments.add(info.arguments.positional[0]);
+              inputs.add(info.arguments.positional[0]);
               break;
             case 'addAll':
               // TODO(fishythefish): Extract type argument from type
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_dump.dart b/pkg/compiler/lib/src/inferrer/type_graph_dump.dart
index a4ed3e3..c215ca1 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_dump.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_dump.dart
@@ -44,7 +44,7 @@
   /// during the analysis.
   void beforeAnalysis() {
     for (TypeInformation node in inferrer.types.allTypes) {
-      Set<TypeInformation> copy = node.assignments.toSet();
+      Set<TypeInformation> copy = node.inputs.toSet();
       if (!copy.isEmpty) {
         assignmentsBeforeAnalysis[node] = copy;
       }
@@ -54,7 +54,7 @@
   /// Like [beforeAnalysis], takes a copy of the assignment sets.
   void beforeTracing() {
     for (TypeInformation node in inferrer.types.allTypes) {
-      Set<TypeInformation> copy = node.assignments.toSet();
+      Set<TypeInformation> copy = node.inputs.toSet();
       if (!copy.isEmpty) {
         assignmentsBeforeTracing[node] = copy;
       }
@@ -266,7 +266,7 @@
   /// Creates a node for [node] displaying the given [text] in its box.
   ///
   /// [inputs] specify named inputs to the node. If omitted, edges will be
-  /// based on [node.assignments].
+  /// based on [node.inputs].
   void addNode(TypeInformation node, String text,
       {String color: defaultNodeColor, Map<String, TypeInformation> inputs}) {
     seen.add(node);
@@ -290,7 +290,7 @@
       // added, removed, temporary, or unchanged.
       dynamic originalSet = global.assignmentsBeforeAnalysis[node] ?? const [];
       var tracerSet = global.assignmentsBeforeTracing[node] ?? const [];
-      var currentSet = node.assignments.toSet();
+      var currentSet = node.inputs.toSet();
       for (TypeInformation assignment in currentSet) {
         String color =
             originalSet.contains(assignment) ? unchangedEdge : addedEdge;
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart b/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
index a1e7c15..2de18dc 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_inferrer.dart
@@ -70,13 +70,12 @@
   }
 
   InferrerEngine createInferrerEngineFor(FunctionEntity main) {
-    return new InferrerEngineImpl(
+    return InferrerEngine(
         _compiler.options,
         _compiler.progress,
         _compiler.reporter,
         _compiler.outputProvider,
         closedWorld,
-        _compiler.frontendStrategy.noSuchMethodRegistry,
         main,
         _inferredDataBuilder);
   }
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
index af0410d..622b6fb 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
@@ -31,13 +31,13 @@
 /// - Containers (for lists)
 /// - Type of the element in a container
 ///
-/// A node has a set of assignments and users. Assignments are used to
+/// A node has a set of inputs and users. Inputs are used to
 /// compute the type of the node ([TypeInformation.computeType]). Users are
 /// added to the inferrer's work queue when the type of the node
 /// changes.
 abstract class TypeInformation {
   Set<TypeInformation> users;
-  var /* List|ParameterAssignments */ _assignments;
+  var /* List|ParameterInputs */ _inputs;
 
   /// The type the inferrer has found for this [TypeInformation].
   /// Initially empty.
@@ -49,15 +49,14 @@
   /// The element this [TypeInformation] node belongs to.
   MemberEntity get contextMember => context == null ? null : context.member;
 
-  Iterable<TypeInformation> get assignments => _assignments;
+  Iterable<TypeInformation> get inputs => _inputs;
 
   /// We abandon inference in certain cases (complex cyclic flow, native
   /// behaviours, etc.). In some case, we might resume inference in the
-  /// closure tracer, which is handled by checking whether [assignments] has
-  /// been set to [STOP_TRACKING_ASSIGNMENTS_MARKER].
+  /// closure tracer, which is handled by checking whether [inputs] has
+  /// been set to [STOP_TRACKING_INPUTS_MARKER].
   bool abandonInferencing = false;
-  bool get mightResume =>
-      !identical(assignments, STOP_TRACKING_ASSIGNMENTS_MARKER);
+  bool get mightResume => !identical(inputs, STOP_TRACKING_INPUTS_MARKER);
 
   /// Number of times this [TypeInformation] has changed type.
   int refineCount = 0;
@@ -85,19 +84,19 @@
   bool get isConcrete => false;
 
   TypeInformation(this.type, this.context)
-      : _assignments = <TypeInformation>[],
+      : _inputs = <TypeInformation>[],
         users = new Setlet<TypeInformation>();
 
-  TypeInformation.noAssignments(this.type, this.context)
-      : _assignments = const <TypeInformation>[],
+  TypeInformation.noInputs(this.type, this.context)
+      : _inputs = const <TypeInformation>[],
         users = new Setlet<TypeInformation>();
 
   TypeInformation.untracked(this.type)
-      : _assignments = const <TypeInformation>[],
+      : _inputs = const <TypeInformation>[],
         users = const ImmutableEmptySet(),
         context = null;
 
-  TypeInformation.withAssignments(this.type, this.context, this._assignments)
+  TypeInformation.withInputs(this.type, this.context, this._inputs)
       : users = new Setlet<TypeInformation>();
 
   void addUser(TypeInformation user) {
@@ -116,31 +115,31 @@
 
   // The below is not a compile time constant to make it differentiable
   // from other empty lists of [TypeInformation].
-  static final STOP_TRACKING_ASSIGNMENTS_MARKER = new List<TypeInformation>(0);
+  static final STOP_TRACKING_INPUTS_MARKER = new List<TypeInformation>(0);
 
-  bool areAssignmentsTracked() {
-    return assignments != STOP_TRACKING_ASSIGNMENTS_MARKER;
+  bool areInputsTracked() {
+    return inputs != STOP_TRACKING_INPUTS_MARKER;
   }
 
-  void addAssignment(TypeInformation assignment) {
+  void addInput(TypeInformation input) {
     // Cheap one-level cycle detection.
-    if (assignment == this) return;
-    if (areAssignmentsTracked()) {
-      _assignments.add(assignment);
+    if (input == this) return;
+    if (areInputsTracked()) {
+      _inputs.add(input);
     }
     // Even if we abandon inferencing on this [TypeInformation] we
     // need to collect the users, so that phases that track where
     // elements flow in still work.
-    assignment.addUser(this);
+    input.addUser(this);
   }
 
-  void removeAssignment(TypeInformation assignment) {
+  void removeInput(TypeInformation input) {
     if (!abandonInferencing || mightResume) {
-      _assignments.remove(assignment);
+      _inputs.remove(input);
     }
-    // We can have multiple assignments of the same [TypeInformation].
-    if (!assignments.contains(assignment)) {
-      assignment.removeUser(this);
+    // We can have multiple inputs of the same [TypeInformation].
+    if (!inputs.contains(input)) {
+      input.removeUser(this);
     }
   }
 
@@ -158,18 +157,18 @@
     return inferrer.types.dynamicType.type;
   }
 
-  void giveUp(InferrerEngine inferrer, {bool clearAssignments: true}) {
+  void giveUp(InferrerEngine inferrer, {bool clearInputs: true}) {
     abandonInferencing = true;
-    // Do not remove [this] as a user of nodes in [assignments],
+    // Do not remove [this] as a user of nodes in [inputs],
     // because our tracing analysis could be interested in tracing
     // this node.
-    if (clearAssignments) _assignments = STOP_TRACKING_ASSIGNMENTS_MARKER;
+    if (clearInputs) _inputs = STOP_TRACKING_INPUTS_MARKER;
     // Do not remove users because our tracing analysis could be
     // interested in tracing the users of this node.
   }
 
   void clear() {
-    _assignments = STOP_TRACKING_ASSIGNMENTS_MARKER;
+    _inputs = STOP_TRACKING_INPUTS_MARKER;
     users = const ImmutableEmptySet();
   }
 
@@ -192,11 +191,11 @@
   /// Returns whether the type cannot change after it has been
   /// inferred.
   bool hasStableType(InferrerEngine inferrer) {
-    return !mightResume && assignments.every((e) => e.isStable);
+    return !mightResume && inputs.every((e) => e.isStable);
   }
 
   void removeAndClearReferences(InferrerEngine inferrer) {
-    assignments.forEach((info) {
+    inputs.forEach((info) {
       info.removeUser(this);
     });
   }
@@ -205,7 +204,7 @@
     removeAndClearReferences(inferrer);
     // Do not remove users because the tracing analysis could be interested
     // in tracing the users of this node.
-    _assignments = STOP_TRACKING_ASSIGNMENTS_MARKER;
+    _inputs = STOP_TRACKING_INPUTS_MARKER;
     abandonInferencing = true;
     isStable = true;
   }
@@ -219,7 +218,7 @@
   /// Destroys information not needed after type inference.
   void cleanup() {
     users = null;
-    _assignments = null;
+    _inputs = null;
   }
 
   String toStructuredText(String indent) {
@@ -264,52 +263,52 @@
 }
 
 /// Parameters of instance functions behave differently than other
-/// elements because the inferrer may remove assignments. This happens
+/// elements because the inferrer may remove inputs. This happens
 /// when the receiver of a dynamic call site can be refined
 /// to a type where we know more about which instance method is being
 /// called.
-class ParameterAssignments extends IterableBase<TypeInformation> {
-  final Map<TypeInformation, int> assignments = new Map<TypeInformation, int>();
+class ParameterInputs extends IterableBase<TypeInformation> {
+  final Map<TypeInformation, int> _inputs = new Map<TypeInformation, int>();
 
   void remove(TypeInformation info) {
-    int existing = assignments[info];
+    int existing = _inputs[info];
     if (existing == null) return;
     if (existing == 1) {
-      assignments.remove(info);
+      _inputs.remove(info);
     } else {
-      assignments[info] = existing - 1;
+      _inputs[info] = existing - 1;
     }
   }
 
   void add(TypeInformation info) {
-    int existing = assignments[info];
+    int existing = _inputs[info];
     if (existing == null) {
-      assignments[info] = 1;
+      _inputs[info] = 1;
     } else {
-      assignments[info] = existing + 1;
+      _inputs[info] = existing + 1;
     }
   }
 
   void replace(TypeInformation old, TypeInformation replacement) {
-    int existing = assignments[old];
+    int existing = _inputs[old];
     if (existing != null) {
-      int other = assignments[replacement];
+      int other = _inputs[replacement];
       if (other != null) existing += other;
-      assignments[replacement] = existing;
-      assignments.remove(old);
+      _inputs[replacement] = existing;
+      _inputs.remove(old);
     }
   }
 
   @override
-  Iterator<TypeInformation> get iterator => assignments.keys.iterator;
+  Iterator<TypeInformation> get iterator => _inputs.keys.iterator;
   @override
-  Iterable<TypeInformation> where(Function f) => assignments.keys.where(f);
+  Iterable<TypeInformation> where(Function f) => _inputs.keys.where(f);
 
   @override
-  bool contains(Object info) => assignments.containsKey(info);
+  bool contains(Object info) => _inputs.containsKey(info);
 
   @override
-  String toString() => assignments.keys.toList().toString();
+  String toString() => _inputs.keys.toList().toString();
 }
 
 /// A node representing a resolved element of the component. The kind of
@@ -344,12 +343,9 @@
   ElementTypeInformation._internal(
       AbstractValueDomain abstractValueDomain, MemberTypeInformation context)
       : super(abstractValueDomain.emptyType, context);
-  ElementTypeInformation._withAssignments(
-      AbstractValueDomain abstractValueDomain,
-      MemberTypeInformation context,
-      ParameterAssignments assignments)
-      : super.withAssignments(
-            abstractValueDomain.emptyType, context, assignments);
+  ElementTypeInformation._withInputs(AbstractValueDomain abstractValueDomain,
+      MemberTypeInformation context, ParameterInputs inputs)
+      : super.withInputs(abstractValueDomain.emptyType, context, inputs);
 
   String getInferredSignature(TypeSystem types);
 
@@ -485,7 +481,7 @@
     AbstractValue special = handleSpecialCases(inferrer);
     if (special != null) return potentiallyNarrowType(special, inferrer);
     return potentiallyNarrowType(
-        inferrer.types.computeTypeMask(assignments), inferrer);
+        inferrer.types.computeTypeMask(inputs), inferrer);
   }
 
   @override
@@ -552,7 +548,7 @@
 
   @override
   bool hasStableType(InferrerEngine inferrer) {
-    // The number of assignments of non-final fields is
+    // The number of inputs of non-final fields is
     // not stable. Therefore such a field cannot be stable.
     if (!_field.isAssignable) {
       return false;
@@ -728,11 +724,11 @@
       this._parameter,
       this._type,
       this._method,
-      ParameterAssignments assignments)
+      ParameterInputs inputs)
       : _isInstanceMemberParameter = true,
         _isClosureParameter = false,
         _isInitializingFormal = false,
-        super._withAssignments(abstractValueDomain, context, assignments);
+        super._withInputs(abstractValueDomain, context, inputs);
 
   FunctionEntity get method => _method;
 
@@ -770,9 +766,9 @@
     if ((_isTearOffClosureParameter || _isClosureParameter) &&
         disableInferenceForClosures) {
       // Do not infer types for parameters of closures. We do not
-      // clear the assignments in case the closure is successfully
+      // clear the inputs in case the closure is successfully
       // traced.
-      giveUp(inferrer, clearAssignments: false);
+      giveUp(inferrer, clearInputs: false);
       return safeType(inferrer);
     }
     if (_isInstanceMemberParameter &&
@@ -845,7 +841,7 @@
     AbstractValue special = handleSpecialCases(inferrer);
     if (special != null) return special;
     return potentiallyNarrowType(
-        inferrer.types.computeTypeMask(assignments), inferrer);
+        inferrer.types.computeTypeMask(inputs), inferrer);
   }
 
   @override
@@ -855,7 +851,7 @@
 
   @override
   bool hasStableType(InferrerEngine inferrer) {
-    // The number of assignments of parameters of instance methods is
+    // The number of inputs of parameters of instance methods is
     // not stable. Therefore such a parameter cannot be stable.
     if (_isInstanceMemberParameter) {
       return false;
@@ -888,7 +884,7 @@
 
   @override
   AbstractValue computeType(InferrerEngine inferrer) =>
-      inferrer.types.computeTypeMask(assignments);
+      inferrer.types.computeTypeMask(inputs);
 
   @override
   accept(TypeInformationVisitor visitor) {
@@ -930,7 +926,6 @@
   final Object _call;
   final MemberEntity caller;
   final Selector selector;
-  final AbstractValue mask;
   final ArgumentsTypes arguments;
   final bool inLoop;
 
@@ -940,10 +935,9 @@
       this._call,
       this.caller,
       this.selector,
-      this.mask,
       this.arguments,
       this.inLoop)
-      : super.noAssignments(abstractValueDomain.emptyType, context) {
+      : super.noInputs(abstractValueDomain.emptyType, context) {
     assert(_call is ir.Node || (_call == null && selector.name == '=='));
   }
 
@@ -969,10 +963,9 @@
       MemberEntity enclosing,
       this.calledElement,
       Selector selector,
-      AbstractValue mask,
       ArgumentsTypes arguments,
       bool inLoop)
-      : super(abstractValueDomain, context, call, enclosing, selector, mask,
+      : super(abstractValueDomain, context, call, enclosing, selector,
             arguments, inLoop);
 
   MemberTypeInformation _getCalledTypeInfo(InferrerEngine inferrer) {
@@ -987,8 +980,7 @@
     if (arguments != null) {
       arguments.forEach((info) => info.addUser(this));
     }
-    inferrer.updateParameterAssignments(
-        this, calledElement, arguments, selector, mask,
+    inferrer.updateParameterInputs(this, calledElement, arguments, selector,
         remove: false, addToQueue: false);
   }
 
@@ -1056,6 +1048,7 @@
   final DynamicCallSiteTypeInformation dynamicCall;
   final bool isConditional;
   final TypeInformation receiver;
+  final AbstractValue mask;
 
   IndirectDynamicCallSiteTypeInformation(
       AbstractValueDomain abstractValueDomain,
@@ -1064,25 +1057,25 @@
       this.dynamicCall,
       MemberEntity enclosing,
       Selector selector,
-      AbstractValue mask,
+      this.mask,
       this.receiver,
       ArgumentsTypes arguments,
       bool inLoop,
       this.isConditional)
-      : super(abstractValueDomain, context, call, enclosing, selector, mask,
+      : super(abstractValueDomain, context, call, enclosing, selector,
             arguments, inLoop);
 
   @override
   void addToGraph(InferrerEngine inferrer) {
     receiver.addUser(this);
-    dynamicCall.receiver.addAssignment(receiver);
+    dynamicCall.receiver.addInput(receiver);
     List<TypeInformation> positional = arguments.positional;
     for (int i = 0; i < positional.length; i++) {
       positional[i].addUser(this);
-      dynamicCall.arguments.positional[i].addAssignment(positional[i]);
+      dynamicCall.arguments.positional[i].addInput(positional[i]);
     }
     arguments.named.forEach((name, namedInfo) {
-      dynamicCall.arguments.named[name].addAssignment(namedInfo);
+      dynamicCall.arguments.named[name].addInput(namedInfo);
     });
     dynamicCall.addUser(this);
   }
@@ -1113,12 +1106,12 @@
   }
 
   @override
-  void giveUp(InferrerEngine inferrer, {bool clearAssignments: true}) {
+  void giveUp(InferrerEngine inferrer, {bool clearInputs: true}) {
     if (!abandonInferencing) {
       inferrer.updateSelectorInMember(
           caller, CallType.access, _call, selector, mask);
     }
-    super.giveUp(inferrer, clearAssignments: clearAssignments);
+    super.giveUp(inferrer, clearInputs: clearInputs);
   }
 
   @override
@@ -1147,6 +1140,7 @@
 class DynamicCallSiteTypeInformation<T> extends CallSiteTypeInformation {
   final CallType _callType;
   final TypeInformation receiver;
+  final AbstractValue mask;
   final bool isConditional;
   bool _hasClosureCallTargets;
 
@@ -1160,12 +1154,12 @@
       T call,
       MemberEntity enclosing,
       Selector selector,
-      AbstractValue mask,
+      this.mask,
       this.receiver,
       ArgumentsTypes arguments,
       bool inLoop,
       this.isConditional)
-      : super(abstractValueDomain, context, call, enclosing, selector, mask,
+      : super(abstractValueDomain, context, call, enclosing, selector,
             arguments, inLoop) {
     assert(validCallType(_callType, _call, selector));
   }
@@ -1200,8 +1194,7 @@
           inferrer.types.getInferredTypeOfMember(element);
       _addCall(callee);
       callee.addUser(this);
-      inferrer.updateParameterAssignments(
-          this, element, arguments, selector, typeMask,
+      inferrer.updateParameterInputs(this, element, arguments, selector,
           remove: false, addToQueue: false);
     }
   }
@@ -1364,8 +1357,7 @@
             inferrer.types.getInferredTypeOfMember(element);
         _addCall(callee);
         callee.addUser(this);
-        inferrer.updateParameterAssignments(
-            this, element, arguments, selector, typeMask,
+        inferrer.updateParameterInputs(this, element, arguments, selector,
             remove: false, addToQueue: true);
       });
 
@@ -1377,8 +1369,7 @@
             inferrer.types.getInferredTypeOfMember(element);
         _removeCall(callee);
         callee.removeUser(this);
-        inferrer.updateParameterAssignments(
-            this, element, arguments, selector, typeMask,
+        inferrer.updateParameterInputs(this, element, arguments, selector,
             remove: true, addToQueue: true);
       });
     }
@@ -1440,7 +1431,7 @@
   }
 
   @override
-  void giveUp(InferrerEngine inferrer, {bool clearAssignments: true}) {
+  void giveUp(InferrerEngine inferrer, {bool clearInputs: true}) {
     if (!abandonInferencing) {
       inferrer.updateSelectorInMember(caller, _callType, _call, selector, mask);
       Iterable<MemberEntity> oldTargets = _concreteTargets;
@@ -1452,13 +1443,12 @@
           MemberTypeInformation callee =
               inferrer.types.getInferredTypeOfMember(element);
           callee.addCall(caller, _call);
-          inferrer.updateParameterAssignments(
-              this, element, arguments, selector, mask,
+          inferrer.updateParameterInputs(this, element, arguments, selector,
               remove: false, addToQueue: true);
         }
       }
     }
-    super.giveUp(inferrer, clearAssignments: clearAssignments);
+    super.giveUp(inferrer, clearInputs: clearInputs);
   }
 
   @override
@@ -1501,11 +1491,10 @@
       Object call,
       MemberEntity enclosing,
       Selector selector,
-      AbstractValue mask,
       this.closure,
       ArgumentsTypes arguments,
       bool inLoop)
-      : super(abstractValueDomain, context, call, enclosing, selector, mask,
+      : super(abstractValueDomain, context, call, enclosing, selector,
             arguments, inLoop);
 
   @override
@@ -1574,12 +1563,12 @@
   void removeUser(TypeInformation user) {}
 
   @override
-  void addAssignment(TypeInformation assignment) {
+  void addInput(TypeInformation assignment) {
     throw "Not supported";
   }
 
   @override
-  void removeAssignment(TypeInformation assignment) {
+  void removeInput(TypeInformation assignment) {
     throw "Not supported";
   }
 
@@ -1661,19 +1650,19 @@
   NarrowTypeInformation(AbstractValueDomain abstractValueDomain,
       TypeInformation narrowedType, this.typeAnnotation)
       : super(abstractValueDomain.emptyType, narrowedType.context) {
-    addAssignment(narrowedType);
+    addInput(narrowedType);
   }
 
   @override
-  addAssignment(TypeInformation info) {
-    super.addAssignment(info);
-    assert(assignments.length == 1);
+  addInput(TypeInformation info) {
+    super.addInput(info);
+    assert(inputs.length == 1);
   }
 
   @override
   AbstractValue computeType(InferrerEngine inferrer) {
     AbstractValueDomain abstractValueDomain = inferrer.abstractValueDomain;
-    AbstractValue input = assignments.first.type;
+    AbstractValue input = inputs.first.type;
     AbstractValue intersection =
         abstractValueDomain.intersection(input, typeAnnotation);
     if (debug.ANOMALY_WARN) {
@@ -1702,7 +1691,7 @@
 /// An [InferredTypeInformation] is a [TypeInformation] that
 /// defaults to the dynamic type until it is marked as being
 /// inferred, at which point it computes its type based on
-/// its assignments.
+/// its inputs.
 abstract class InferredTypeInformation extends TypeInformation {
   /// Whether the element type in that container has been inferred.
   bool inferred = false;
@@ -1710,13 +1699,13 @@
   InferredTypeInformation(AbstractValueDomain abstractValueDomain,
       MemberTypeInformation context, TypeInformation parentType)
       : super(abstractValueDomain.emptyType, context) {
-    if (parentType != null) addAssignment(parentType);
+    if (parentType != null) addInput(parentType);
   }
 
   @override
   AbstractValue computeType(InferrerEngine inferrer) {
     if (!inferred) return safeType(inferrer);
-    return inferrer.types.computeTypeMask(assignments);
+    return inferrer.types.computeTypeMask(inputs);
   }
 
   @override
@@ -1901,7 +1890,7 @@
     valueType.addUser(this);
   }
 
-  TypeInformation addEntryAssignment(AbstractValueDomain abstractValueDomain,
+  TypeInformation addEntryInput(AbstractValueDomain abstractValueDomain,
       TypeInformation key, TypeInformation value,
       [bool nonNull = false]) {
     TypeInformation newInfo = null;
@@ -1912,19 +1901,19 @@
             abstractValueDomain, context, null, nonNull);
         return newInfo;
       });
-      typeInfoMap[keyString].addAssignment(value);
+      typeInfoMap[keyString].addInput(value);
     } else {
       _allKeysAreStrings = false;
       typeInfoMap.clear();
     }
-    keyType.addAssignment(key);
-    valueType.addAssignment(value);
+    keyType.addInput(key);
+    valueType.addInput(value);
     if (newInfo != null) newInfo.addUser(this);
 
     return newInfo;
   }
 
-  List<TypeInformation> addMapAssignment(
+  List<TypeInformation> addMapInput(
       AbstractValueDomain abstractValueDomain, MapTypeInformation other) {
     List<TypeInformation> newInfos = <TypeInformation>[];
     if (_allKeysAreStrings && other.inDictionaryMode) {
@@ -1935,14 +1924,14 @@
           newInfos.add(newInfo);
           return newInfo;
         });
-        typeInfoMap[keyString].addAssignment(value);
+        typeInfoMap[keyString].addInput(value);
       });
     } else {
       _allKeysAreStrings = false;
       typeInfoMap.clear();
     }
-    keyType.addAssignment(other.keyType);
-    valueType.addAssignment(other.valueType);
+    keyType.addInput(other.keyType);
+    valueType.addInput(other.valueType);
 
     return newInfos;
   }
@@ -1953,7 +1942,7 @@
   }
 
   @override
-  addAssignment(TypeInformation other) {
+  addInput(TypeInformation other) {
     throw "not supported";
   }
 
@@ -2103,7 +2092,7 @@
 
   @override
   AbstractValue computeType(InferrerEngine inferrer) {
-    return inferrer.types.computeTypeMask(assignments);
+    return inferrer.types.computeTypeMask(inputs);
   }
 
   @override
@@ -2114,7 +2103,7 @@
       StringBuffer sb, String indent, Set<TypeInformation> seen) {
     if (seen.add(this)) {
       sb.write('${toString()} [');
-      for (TypeInformation assignment in assignments) {
+      for (TypeInformation assignment in inputs) {
         sb.write('\n$indent  ');
         assignment._toStructuredText(sb, '$indent  ', seen);
       }
diff --git a/pkg/compiler/lib/src/inferrer/type_system.dart b/pkg/compiler/lib/src/inferrer/type_system.dart
index 2e05bac..6d5622e 100644
--- a/pkg/compiler/lib/src/inferrer/type_system.dart
+++ b/pkg/compiler/lib/src/inferrer/type_system.dart
@@ -536,7 +536,7 @@
         new MapTypeInformation(currentMember, mask, keyTypeInfo, valueTypeInfo);
 
     for (int i = 0; i < keyTypes.length; ++i) {
-      TypeInformation newType = map.addEntryAssignment(
+      TypeInformation newType = map.addEntryInput(
           _abstractValueDomain, keyTypes[i], valueTypes[i], true);
       if (newType != null) allocatedTypes.add(newType);
     }
@@ -562,8 +562,8 @@
     PhiElementTypeInformation result = new PhiElementTypeInformation(
         _abstractValueDomain, currentMember, null, null,
         isTry: false);
-    result.addAssignment(firstInput);
-    result.addAssignment(secondInput);
+    result.addInput(firstInput);
+    result.addInput(secondInput);
     allocatedTypes.add(result);
     return result;
   }
@@ -574,7 +574,7 @@
         _abstractValueDomain, currentMember, node, variable,
         isTry: isTry);
     allocatedTypes.add(result);
-    result.addAssignment(inputType);
+    result.addInput(inputType);
     return result;
   }
 
@@ -614,14 +614,14 @@
   TypeInformation simplifyPhi(
       ir.Node node, Local variable, PhiElementTypeInformation phiType) {
     assert(phiType.branchNode == node);
-    if (phiType.assignments.length == 1) return phiType.assignments.first;
+    if (phiType.inputs.length == 1) return phiType.inputs.first;
     return phiType;
   }
 
   /// Adds [newType] as an input of [phiType].
   PhiElementTypeInformation addPhiInput(Local variable,
       PhiElementTypeInformation phiType, TypeInformation newType) {
-    phiType.addAssignment(newType);
+    phiType.addInput(newType);
     return phiType;
   }
 
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/masks.dart b/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
index d7717bf..4f94658 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
@@ -756,10 +756,28 @@
 
   @override
   AbstractBool isInterceptor(TypeMask value) {
+    // TODO(39874): Remove cache when [TypeMask.isDisjoint] is faster.
+    var result = _isInterceptorCache[value];
+    if (result == null) {
+      result = _isInterceptorCacheSecondChance[value] ?? _isInterceptor(value);
+      if (_isInterceptorCache.length >= _kIsInterceptorCacheLimit) {
+        _isInterceptorCacheSecondChance = _isInterceptorCache;
+        _isInterceptorCache = {};
+      }
+      _isInterceptorCache[value] = result;
+    }
+    return result;
+  }
+
+  AbstractBool _isInterceptor(TypeMask value) {
     return AbstractBool.maybeOrFalse(
         !interceptorType.isDisjoint(value, _closedWorld));
   }
 
+  static const _kIsInterceptorCacheLimit = 500;
+  Map<TypeMask, AbstractBool> _isInterceptorCache = {};
+  Map<TypeMask, AbstractBool> _isInterceptorCacheSecondChance = {};
+
   @override
   bool isMap(TypeMask value) {
     return value.isMap;
diff --git a/pkg/compiler/lib/src/inferrer/types.dart b/pkg/compiler/lib/src/inferrer/types.dart
index 374f01a..5c5c4f1 100644
--- a/pkg/compiler/lib/src/inferrer/types.dart
+++ b/pkg/compiler/lib/src/inferrer/types.dart
@@ -52,13 +52,9 @@
   /// The inferred return type when this result belongs to a function element.
   AbstractValue get returnType;
 
-  /// Returns the type of a send [node].
-  // TODO(johnniwinther): Rename this.
-  AbstractValue typeOfSend(ir.TreeNode node);
-
-  /// Returns the type of the getter in a complex send-set [node], for example,
-  /// the type of the `a.f` getter in `a.f += b`.
-  AbstractValue typeOfGetter(ir.TreeNode node);
+  /// Returns the receiver type of a node that is a property get, set, or method
+  /// invocation.
+  AbstractValue typeOfReceiver(ir.TreeNode node);
 
   /// Returns the type of the iterator in a [loop].
   AbstractValue typeOfIterator(ir.TreeNode node);
@@ -88,8 +84,7 @@
   GlobalTypeInferenceElementData compress();
 
   // TODO(johnniwinther): Remove this. Maybe split by access/invoke.
-  AbstractValue typeOfSend(ir.TreeNode node);
-  AbstractValue typeOfGetter(ir.TreeNode node);
+  AbstractValue typeOfReceiver(ir.TreeNode node);
 
   AbstractValue typeOfIterator(ir.TreeNode node);
 
@@ -443,9 +438,7 @@
   }
 
   @override
-  AbstractValue typeOfSend(ir.Node node) => _data?.typeOfSend(node);
-  @override
-  AbstractValue typeOfGetter(ir.Node node) => _data?.typeOfGetter(node);
+  AbstractValue typeOfReceiver(ir.Node node) => _data?.typeOfReceiver(node);
   @override
   AbstractValue typeOfIterator(ir.Node node) => _data?.typeOfIterator(node);
   @override
@@ -524,10 +517,7 @@
   AbstractValue typeOfIterator(ir.Node node) => null;
 
   @override
-  AbstractValue typeOfGetter(ir.Node node) => null;
-
-  @override
-  AbstractValue typeOfSend(ir.Node node) => null;
+  AbstractValue typeOfReceiver(ir.Node node) => null;
 
   @override
   bool get isCalledOnce => false;
@@ -568,10 +558,7 @@
   AbstractValue typeOfIterator(ir.Node node) => null;
 
   @override
-  AbstractValue typeOfGetter(ir.Node node) => null;
-
-  @override
-  AbstractValue typeOfSend(ir.Node node) => null;
+  AbstractValue typeOfReceiver(ir.Node node) => null;
 
   @override
   bool get isCalledOnce => false;
@@ -612,10 +599,7 @@
   AbstractValue typeOfIterator(ir.Node node) => null;
 
   @override
-  AbstractValue typeOfGetter(ir.Node node) => null;
-
-  @override
-  AbstractValue typeOfSend(ir.Node node) => null;
+  AbstractValue typeOfReceiver(ir.Node node) => null;
 
   @override
   bool get isCalledOnce => false;
diff --git a/pkg/compiler/lib/src/js_model/js_strategy.dart b/pkg/compiler/lib/src/js_model/js_strategy.dart
index 822be8c..c313b19 100644
--- a/pkg/compiler/lib/src/js_model/js_strategy.dart
+++ b/pkg/compiler/lib/src/js_model/js_strategy.dart
@@ -539,23 +539,23 @@
   @override
   AbstractValue receiverTypeOfInvocation(
       ir.MethodInvocation node, AbstractValueDomain abstractValueDomain) {
-    return _targetResults.typeOfSend(node);
+    return _targetResults.typeOfReceiver(node);
   }
 
   @override
   AbstractValue receiverTypeOfGet(ir.PropertyGet node) {
-    return _targetResults.typeOfSend(node);
+    return _targetResults.typeOfReceiver(node);
   }
 
   @override
   AbstractValue receiverTypeOfDirectGet(ir.DirectPropertyGet node) {
-    return _targetResults.typeOfSend(node);
+    return _targetResults.typeOfReceiver(node);
   }
 
   @override
   AbstractValue receiverTypeOfSet(
       ir.PropertySet node, AbstractValueDomain abstractValueDomain) {
-    return _targetResults.typeOfSend(node);
+    return _targetResults.typeOfReceiver(node);
   }
 
   @override
diff --git a/pkg/compiler/lib/src/ssa/nodes.dart b/pkg/compiler/lib/src/ssa/nodes.dart
index edbcb67..32396ae 100644
--- a/pkg/compiler/lib/src/ssa/nodes.dart
+++ b/pkg/compiler/lib/src/ssa/nodes.dart
@@ -2894,15 +2894,28 @@
 }
 
 class HParameterValue extends HLocalValue {
+  bool _potentiallyUsedAsVariable = true;
+
   HParameterValue(Entity variable, AbstractValue type) : super(variable, type);
 
   // [HParameterValue]s are either the value of the parameter (in fully SSA
   // converted code), or the mutable variable containing the value (in
   // incompletely SSA converted code, e.g. methods containing exceptions).
   bool usedAsVariable() {
-    for (HInstruction user in usedBy) {
-      if (user is HLocalGet) return true;
-      if (user is HLocalSet && user.local == this) return true;
+    if (_potentiallyUsedAsVariable) {
+      // If the HParameterValue is used as a variable, all of the uses should be
+      // HLocalGet or HLocalSet, so this loop exits fast.
+      for (HInstruction user in usedBy) {
+        if (user is HLocalGet) return true;
+        if (user is HLocalSet && user.local == this) return true;
+      }
+      // An 'ssa-conversion' optimization can make the HParameterValue change
+      // from a variable to a value, but there is no transformation that
+      // re-introduces the variable.
+      // TODO(sra): The builder knows that most parameters are not variables to
+      // begin with, so could initialize [_potentiallyUsedAsVariable] to
+      // `false`.
+      _potentiallyUsedAsVariable = false;
     }
     return false;
   }
diff --git a/tests/compiler/dart2js/inference/data/closurization_instance_call.dart b/tests/compiler/dart2js/inference/data/closurization_instance_call.dart
index 4f785bf..d5eabac 100644
--- a/tests/compiler/dart2js/inference/data/closurization_instance_call.dart
+++ b/tests/compiler/dart2js/inference/data/closurization_instance_call.dart
@@ -24,7 +24,7 @@
 /*member: closurizedCallToString:[exact=JSString]*/
 closurizedCallToString() {
   var c = new Class();
-  c.call(); // Make `Class.call` live.
+  c. /*invoke: [null|exact=Class]*/ call(); // Make `Class.call` live.
   var local = c. /*[exact=Class]*/ method;
   local. /*invoke: [subclass=Closure]*/ toString();
   local();
diff --git a/tests/compiler/dart2js/inference/data/closurization_local_call.dart b/tests/compiler/dart2js/inference/data/closurization_local_call.dart
index 65439e1..19c5758 100644
--- a/tests/compiler/dart2js/inference/data/closurization_local_call.dart
+++ b/tests/compiler/dart2js/inference/data/closurization_local_call.dart
@@ -21,7 +21,7 @@
 /*member: closurizedCallToString:[exact=JSString]*/
 closurizedCallToString() {
   var c = new Class();
-  c.call(); // Make `Class.call` live.
+  c. /*invoke: [null|exact=Class]*/ call(); // Make `Class.call` live.
   var local = /*[exact=JSUInt31]*/ () => 42;
   local. /*invoke: [subclass=Closure]*/ toString();
   local();
diff --git a/tests/compiler/dart2js/inference/data/closurization_static_call.dart b/tests/compiler/dart2js/inference/data/closurization_static_call.dart
index a29e594..575f68d 100644
--- a/tests/compiler/dart2js/inference/data/closurization_static_call.dart
+++ b/tests/compiler/dart2js/inference/data/closurization_static_call.dart
@@ -24,7 +24,7 @@
 /*member: closurizedCallToString:[exact=JSString]*/
 closurizedCallToString() {
   var c = new Class();
-  c.call(); // Make `Class.call` live.
+  c. /*invoke: [null|exact=Class]*/ call(); // Make `Class.call` live.
   var local = method;
   local. /*invoke: [subclass=Closure]*/ toString();
   local();
diff --git a/tests/compiler/dart2js/inference/data/do.dart b/tests/compiler/dart2js/inference/data/do.dart
index 549d826..d9dae617 100644
--- a/tests/compiler/dart2js/inference/data/do.dart
+++ b/tests/compiler/dart2js/inference/data/do.dart
@@ -47,7 +47,7 @@
   var o = '';
   do {
     o = o. /*invoke: [exact=JSString]*/ toString();
-  } while (o != null);
+  } while (o /*invoke: [null|exact=JSString]*/ != null);
   return o;
 }
 
@@ -60,7 +60,7 @@
   var o = '';
   do {
     o = o. /*invoke: [exact=JSString]*/ toString();
-  } while (o == null);
+  } while (o /*invoke: [null|exact=JSString]*/ == null);
   return o;
 }
 
diff --git a/tests/compiler/dart2js/inference/data/for.dart b/tests/compiler/dart2js/inference/data/for.dart
index b3829b7..9bc55db 100644
--- a/tests/compiler/dart2js/inference/data/for.dart
+++ b/tests/compiler/dart2js/inference/data/for.dart
@@ -47,7 +47,9 @@
 /*member: forNotNull:[null|exact=JSString]*/
 forNotNull() {
   var local;
-  for (var o = ''; o != null; o = o. /*invoke: [exact=JSString]*/ toString()) {
+  for (var o = '';
+      o /*invoke: [null|exact=JSString]*/ != null;
+      o = o. /*invoke: [exact=JSString]*/ toString()) {
     local = o;
   }
   return local;
@@ -60,7 +62,9 @@
 /*member: forNullFalse:[null]*/
 forNullFalse() {
   var local;
-  for (var o = ''; o == null; o = o. /*invoke: [null]*/ toString()) {
+  for (var o = '';
+      o /*invoke: [null|exact=JSString]*/ == null;
+      o = o. /*invoke: [null]*/ toString()) {
     local = o;
   }
   return local;
diff --git a/tests/compiler/dart2js/inference/data/general.dart b/tests/compiler/dart2js/inference/data/general.dart
index beb067d..f3d814f 100644
--- a/tests/compiler/dart2js/inference/data/general.dart
+++ b/tests/compiler/dart2js/inference/data/general.dart
@@ -675,7 +675,8 @@
   A.generative();
 
   /*member: A.==:[exact=JSBool]*/
-  operator ==(/*[null|subclass=Object]*/ other) => 42 as dynamic;
+  operator ==(/*Union([exact=JSString], [exact=JSUInt31])*/ other) =>
+      42 as dynamic;
 
   /*member: A.myField:[exact=JSUInt31]*/
   get myField => 42;
@@ -892,7 +893,7 @@
   testDoWhile2();
   testDoWhile3();
   testDoWhile4();
-  new A() == null;
+  new A() /*invoke: [null|subclass=A]*/ == null;
   new A()
     .. /*invoke: [exact=A]*/ returnInt1()
     .. /*invoke: [exact=A]*/ returnInt2()
diff --git a/tests/compiler/dart2js/inference/data/narrowing.dart b/tests/compiler/dart2js/inference/data/narrowing.dart
index ba26c79..27c041d 100644
--- a/tests/compiler/dart2js/inference/data/narrowing.dart
+++ b/tests/compiler/dart2js/inference/data/narrowing.dart
@@ -13,7 +13,7 @@
 /*member: nonNull1:[null]*/
 void nonNull1() {
   var x = 1;
-  if (x == null) return;
+  if (x /*invoke: [null|subclass=JSInt]*/ == null) return;
   argIsNonNull1(x);
 }
 
@@ -25,7 +25,9 @@
 /*member: nonNull2:[null]*/
 void nonNull2() {
   var x = 1;
-  if ((x == null) /*invoke: [exact=JSBool]*/ == true) return;
+  if ((x /*invoke: [null|subclass=JSInt]*/ ==
+          null) /*invoke: [exact=JSBool]*/ ==
+      true) return;
   argIsNonNull2(x);
 }
 
@@ -37,7 +39,9 @@
 /*member: nonNull3:[null]*/
 void nonNull3() {
   var x = 1;
-  if ((x == null) /*invoke: [exact=JSBool]*/ != false) return;
+  if ((x /*invoke: [null|subclass=JSInt]*/ ==
+          null) /*invoke: [exact=JSBool]*/ !=
+      false) return;
   argIsNonNull3(x);
 }
 
@@ -52,7 +56,7 @@
 /*member: nonNull4:[null]*/
 void nonNull4() {
   var x = 1;
-  if (discard(x != null)) return;
+  if (discard(x /*invoke: [null|subclass=JSInt]*/ != null)) return;
   argIsNonNull4(x);
 }
 
@@ -64,7 +68,7 @@
 /*member: nonNull5:[null]*/
 void nonNull5() {
   var x = 1;
-  if (x != null ? false : false) return;
+  if (x /*invoke: [null|subclass=JSInt]*/ != null ? false : false) return;
   argIsNonNull5(x);
 }
 
@@ -76,8 +80,8 @@
 /*member: nonNull6:[null]*/
 void nonNull6() {
   var x = 1;
-  if ((/*[exact=JSBool]*/ (/*[exact=JSBool]*/ y) => y && false)(x != null))
-    return;
+  if ((/*[exact=JSBool]*/ (/*[exact=JSBool]*/ y) =>
+      y && false)(x /*invoke: [null|subclass=JSInt]*/ != null)) return;
   argIsNonNull6(x);
 }
 
@@ -90,7 +94,7 @@
 void nonNull7() {
   var f = false;
   var x = 1;
-  if (f ? (throw x != null) : false) return;
+  if (f ? (throw x /*invoke: [null|subclass=JSInt]*/ != null) : false) return;
   argIsNonNull7(x);
 }
 
@@ -103,7 +107,7 @@
 void nonNull8() {
   var f = false;
   var x = 1;
-  if (f ?? (x != null)) return;
+  if (f ?? (x /*invoke: [null|subclass=JSInt]*/ != null)) return;
   argIsNonNull8(x);
 }
 
diff --git a/tests/compiler/dart2js/inference/data/null.dart b/tests/compiler/dart2js/inference/data/null.dart
index 9e53378..05fd76b 100644
--- a/tests/compiler/dart2js/inference/data/null.dart
+++ b/tests/compiler/dart2js/inference/data/null.dart
@@ -24,7 +24,7 @@
 
 /*member: ifThenNullCheck:[exact=JSUInt31]*/
 ifThenNullCheck(int /*[null|exact=JSUInt31]*/ value) {
-  if (value == null) {
+  if (value /*invoke: [null|subclass=JSInt]*/ == null) {
     return 0;
   }
   return value;
@@ -32,7 +32,7 @@
 
 /*member: ifThenElseNullCheck:[exact=JSUInt31]*/
 ifThenElseNullCheck(int /*[null|exact=JSUInt31]*/ value) {
-  if (value == null) {
+  if (value /*invoke: [null|subclass=JSInt]*/ == null) {
     return 0;
   } else {
     return value;
@@ -41,7 +41,7 @@
 
 /*member: ifNotThenNullCheck:[exact=JSUInt31]*/
 ifNotThenNullCheck(int /*[null|exact=JSUInt31]*/ value) {
-  if (value != null) {
+  if (value /*invoke: [null|subclass=JSInt]*/ != null) {
     return value;
   }
   return 0;
@@ -49,7 +49,7 @@
 
 /*member: ifNotThenElseNullCheck:[exact=JSUInt31]*/
 ifNotThenElseNullCheck(int /*[null|exact=JSUInt31]*/ value) {
-  if (value != null) {
+  if (value /*invoke: [null|subclass=JSInt]*/ != null) {
     return value;
   } else {
     return 0;
@@ -59,7 +59,8 @@
 /*member: ifThenNotNullComplexCheck:[exact=JSUInt31]*/
 ifThenNotNullComplexCheck(
     int /*[null|exact=JSUInt31]*/ a, int /*[null|exact=JSUInt31]*/ b) {
-  if (a != null && a /*invoke: [exact=JSUInt31]*/ != b) {
+  if (a /*invoke: [null|subclass=JSInt]*/ != null &&
+      a /*invoke: [exact=JSUInt31]*/ != b) {
     return a;
   }
   return 0;
@@ -68,7 +69,8 @@
 /*member: ifThenElseNotNullComplexCheck:[null|exact=JSUInt31]*/
 ifThenElseNotNullComplexCheck(
     int /*[null|exact=JSUInt31]*/ a, int /*[null|exact=JSUInt31]*/ b) {
-  if (a != null && a /*invoke: [exact=JSUInt31]*/ != b) {
+  if (a /*invoke: [null|subclass=JSInt]*/ != null &&
+      a /*invoke: [exact=JSUInt31]*/ != b) {
     return a;
   }
   return a;
@@ -78,7 +80,7 @@
 ifThenNotNullGradualCheck1(
     int /*[null|exact=JSUInt31]*/ a, int /*[exact=JSUInt31]*/ b) {
   if (a /*invoke: [null|exact=JSUInt31]*/ != b) {
-    if (a != null) {
+    if (a /*invoke: [null|subclass=JSInt]*/ != null) {
       return a;
     }
   }
@@ -88,7 +90,7 @@
 /*member: ifThenNotNullGradualCheck2:[exact=JSUInt31]*/
 ifThenNotNullGradualCheck2(
     int /*[null|exact=JSUInt31]*/ a, int /*[exact=JSUInt31]*/ b) {
-  if (a != null) {
+  if (a /*invoke: [null|subclass=JSInt]*/ != null) {
     if (a /*invoke: [exact=JSUInt31]*/ != b) {
       return a;
     }
diff --git a/tests/compiler/dart2js/inference/data/while.dart b/tests/compiler/dart2js/inference/data/while.dart
index a6f7373..ddafecf 100644
--- a/tests/compiler/dart2js/inference/data/while.dart
+++ b/tests/compiler/dart2js/inference/data/while.dart
@@ -49,7 +49,7 @@
 /*member: whileNotNull:[exact=JSString]*/
 whileNotNull() {
   var o = '';
-  while (o != null) {
+  while (o /*invoke: [null|exact=JSString]*/ != null) {
     o = o. /*invoke: [exact=JSString]*/ toString();
   }
   return o;
@@ -62,7 +62,7 @@
 /*member: whileNullUnreachable:[exact=JSString]*/
 whileNullUnreachable() {
   var o = '';
-  while (o == null) {
+  while (o /*invoke: [null|exact=JSString]*/ == null) {
     o = o. /*invoke: [null]*/ toString();
   }
   return o;
diff --git a/tests/compiler/dart2js/inference/inference_data/called_in_loop.dart b/tests/compiler/dart2js/inference/inference_data/called_in_loop.dart
index d984418..884773e 100644
--- a/tests/compiler/dart2js/inference/inference_data/called_in_loop.dart
+++ b/tests/compiler/dart2js/inference/inference_data/called_in_loop.dart
@@ -84,7 +84,7 @@
   Class.constructorNotCalledInForLoop();
 
   // TODO(johnniwinther): Should we track instance calls in loops?
-  /*member: Class.instanceCalledInForLoop:*/
+  /*member: Class.instanceCalledInForLoop:loop*/
   instanceCalledInForLoop() {}
 
   /*member: Class.instanceNotCalledInForLoop:*/
diff --git a/tests/compiler/dart2js/inference/inference_data_test.dart b/tests/compiler/dart2js/inference/inference_data_test.dart
index 9041fc7..3aeb592 100644
--- a/tests/compiler/dart2js/inference/inference_data_test.dart
+++ b/tests/compiler/dart2js/inference/inference_data_test.dart
@@ -24,6 +24,7 @@
     await checkTests(dataDir, const InferenceDataComputer(),
         args: args,
         testedConfigs: [strongConfig],
+        supportedMarkers: [strongMarker],
         options: [stopAfterTypeInference]);
   });
 }
diff --git a/tests/compiler/dart2js/inference/inference_test_helper.dart b/tests/compiler/dart2js/inference/inference_test_helper.dart
index 06da02c..d0b6caa 100644
--- a/tests/compiler/dart2js/inference/inference_test_helper.dart
+++ b/tests/compiler/dart2js/inference/inference_test_helper.dart
@@ -146,11 +146,11 @@
       ClosureRepresentationInfo info = _closureDataLookup.getClosureInfo(node);
       return getMemberValue(info.callMethod);
     } else if (node is ir.MethodInvocation) {
-      return getTypeMaskValue(result.typeOfSend(node));
+      return getTypeMaskValue(result.typeOfReceiver(node));
     } else if (node is ir.PropertyGet) {
-      return getTypeMaskValue(result.typeOfGetter(node));
+      return getTypeMaskValue(result.typeOfReceiver(node));
     } else if (node is ir.PropertySet) {
-      return getTypeMaskValue(result.typeOfSend(node));
+      return getTypeMaskValue(result.typeOfReceiver(node));
     } else if (node is ir.ForInStatement) {
       if (id.kind == IdKind.iterator) {
         return getTypeMaskValue(result.typeOfIterator(node));
diff --git a/tools/VERSION b/tools/VERSION
index 9c854ec..42b0140 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -32,7 +32,7 @@
 CHANNEL stable
 MAJOR 2
 MINOR 7
-PATCH 0
+PATCH 1
 PRERELEASE 0
 PRERELEASE_PATCH 0
 ABI_VERSION 24
diff --git a/tools/apps/update_homebrew/lib/src/impl.dart b/tools/apps/update_homebrew/lib/src/impl.dart
index 4d4cf86..3c1acab 100644
--- a/tools/apps/update_homebrew/lib/src/impl.dart
+++ b/tools/apps/update_homebrew/lib/src/impl.dart
@@ -12,7 +12,6 @@
   'linux-arm': 'sdk/dartsdk-linux-arm64-release.zip',
 };
 const _ia32Files = {
-  'mac': 'sdk/dartsdk-macos-ia32-release.zip',
   'linux': 'sdk/dartsdk-linux-ia32-release.zip',
   'linux-arm': 'sdk/dartsdk-linux-arm-release.zip',
 };
@@ -93,13 +92,8 @@
 
   version "$stableVersion"
   if OS.mac?
-    if Hardware::CPU.is_64_bit?
-      url "$_urlBase/stable/release/${revisions['stable']}/${_x64Files['mac']}"
-      sha256 "${hashes['stable'][_x64Files['mac']]}"
-    else
-      url "$_urlBase/stable/release/${revisions['stable']}/${_ia32Files['mac']}"
-      sha256 "${hashes['stable'][_ia32Files['mac']]}"
-    end
+    url "$_urlBase/stable/release/${revisions['stable']}/${_x64Files['mac']}"
+    sha256 "${hashes['stable'][_x64Files['mac']]}"
   elsif OS.linux? && Hardware::CPU.intel?
     if Hardware::CPU.is_64_bit?
       url "$_urlBase/stable/release/${revisions['stable']}/${_x64Files['linux']}"
@@ -121,13 +115,8 @@
   devel do
     version "$devVersion"
     if OS.mac?
-      if Hardware::CPU.is_64_bit?
-        url "$_urlBase/dev/release/${revisions['dev']}/${_x64Files['mac']}"
-        sha256 "${hashes['dev'][_x64Files['mac']]}"
-      else
-        url "$_urlBase/dev/release/${revisions['dev']}/${_ia32Files['mac']}"
-        sha256 "${hashes['dev'][_ia32Files['mac']]}"
-      end
+      url "$_urlBase/dev/release/${revisions['dev']}/${_x64Files['mac']}"
+      sha256 "${hashes['dev'][_x64Files['mac']]}"
     elsif OS.linux? && Hardware::CPU.intel?
       if Hardware::CPU.is_64_bit?
         url "$_urlBase/dev/release/${revisions['dev']}/${_x64Files['linux']}"
diff --git a/tools/bots/dart_sdk.py b/tools/bots/dart_sdk.py
index a545a97..2bfc0b9 100755
--- a/tools/bots/dart_sdk.py
+++ b/tools/bots/dart_sdk.py
@@ -25,6 +25,8 @@
 def BuildArchitectures():
     if BUILD_OS == 'linux':
         return ['ia32', 'x64', 'arm', 'arm64']
+    elif BUILD_OS == 'macos':
+        return ['x64']
     else:
         return ['ia32', 'x64']
 
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index 8854609..0cc2796 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -2041,7 +2041,7 @@
         {
           "name": "build dart",
           "script": "tools/build.py",
-          "arguments": ["--arch=ia32,x64",
+          "arguments": ["--arch=x64",
                         "--mode=release", "create_sdk"]
         },
         {