diff --git a/pkg/_js_interop_checks/lib/src/transformations/js_util_optimizer.dart b/pkg/_js_interop_checks/lib/src/transformations/js_util_optimizer.dart
index 4159999..c5933d5 100644
--- a/pkg/_js_interop_checks/lib/src/transformations/js_util_optimizer.dart
+++ b/pkg/_js_interop_checks/lib/src/transformations/js_util_optimizer.dart
@@ -14,6 +14,8 @@
   final Procedure _jsTarget;
   final Procedure _callMethodTarget;
   final List<Procedure> _callMethodUncheckedTargets;
+  final Procedure _callConstructorTarget;
+  final List<Procedure> _callConstructorUncheckedTargets;
   final Procedure _getPropertyTarget;
   final Procedure _setPropertyTarget;
   final Procedure _setPropertyUncheckedTarget;
@@ -43,6 +45,12 @@
             5,
             (i) => _coreTypes.index.getTopLevelProcedure(
                 'dart:js_util', '_callMethodUnchecked$i')),
+        _callConstructorTarget = _coreTypes.index
+            .getTopLevelProcedure('dart:js_util', 'callConstructor'),
+        _callConstructorUncheckedTargets = List<Procedure>.generate(
+            5,
+            (i) => _coreTypes.index.getTopLevelProcedure(
+                'dart:js_util', '_callConstructorUnchecked$i')),
         _getPropertyTarget = _coreTypes.index
             .getTopLevelProcedure('dart:js_util', 'getProperty'),
         _setPropertyTarget = _coreTypes.index
@@ -90,6 +98,8 @@
       node = _lowerSetProperty(node);
     } else if (node.target == _callMethodTarget) {
       node = _lowerCallMethod(node);
+    } else if (node.target == _callConstructorTarget) {
+      node = _lowerCallConstructor(node);
     }
     node.transformChildren(this);
     return node;
@@ -147,70 +157,102 @@
     assert(arguments.positional.length == 3);
     assert(arguments.named.isEmpty);
 
-    // Lower List.empty factory call.
-    var argumentsList = arguments.positional.last;
+    return _lowerToCallUnchecked(
+        node, _callMethodUncheckedTargets, arguments.positional.sublist(0, 2));
+  }
+
+  /// Lowers the given js_util `callConstructor` call to `_callConstructorUncheckedN`
+  /// when the additional validation checks on the arguments can be elided.
+  ///
+  /// Calls will be lowered when using a List literal or constant list with 0-4
+  /// elements for the `callConstructor` arguments, or the `List.empty()` factory.
+  /// Removing the checks allows further inlining by the compilers.
+  StaticInvocation _lowerCallConstructor(StaticInvocation node) {
+    Arguments arguments = node.arguments;
+    assert(arguments.types.isEmpty);
+    assert(arguments.positional.length == 2);
+    assert(arguments.named.isEmpty);
+
+    return _lowerToCallUnchecked(
+        node, _callConstructorUncheckedTargets, [arguments.positional.first]);
+  }
+
+  /// Helper to lower the given [node] to the relevant unchecked target in the
+  /// [callUncheckedTargets] based on whether the validation checks on the
+  /// [originalArguments] can be elided.
+  ///
+  /// Calls will be lowered when using a List literal or constant list with 0-4
+  /// arguments, or the `List.empty()` factory. Removing the checks allows further
+  /// inlining by the compilers.
+  StaticInvocation _lowerToCallUnchecked(
+      StaticInvocation node,
+      List<Procedure> callUncheckedTargets,
+      List<Expression> originalArguments) {
+    var argumentsList = node.arguments.positional.last;
+    // Lower arguments in a List.empty factory call.
     if (argumentsList is StaticInvocation &&
         argumentsList.target == _listEmptyFactory) {
-      return _createNewCallMethodNode([], arguments, node.fileOffset);
+      return _createCallUncheckedNode(callUncheckedTargets, [],
+          originalArguments, node.fileOffset, node.arguments.fileOffset);
     }
 
-    // Lower other kinds of Lists.
-    var callMethodArguments;
+    // Lower arguments in other kinds of Lists.
+    var callUncheckedArguments;
     var entryType;
     if (argumentsList is ListLiteral) {
-      if (argumentsList.expressions.length >=
-          _callMethodUncheckedTargets.length) {
+      if (argumentsList.expressions.length >= callUncheckedTargets.length) {
         return node;
       }
-      callMethodArguments = argumentsList.expressions;
+      callUncheckedArguments = argumentsList.expressions;
       entryType = argumentsList.typeArgument;
     } else if (argumentsList is ConstantExpression &&
         argumentsList.constant is ListConstant) {
       var argumentsListConstant = argumentsList.constant as ListConstant;
-      if (argumentsListConstant.entries.length >=
-          _callMethodUncheckedTargets.length) {
+      if (argumentsListConstant.entries.length >= callUncheckedTargets.length) {
         return node;
       }
-      callMethodArguments = argumentsListConstant.entries
+      callUncheckedArguments = argumentsListConstant.entries
           .map((constant) => ConstantExpression(
               constant, constant.getType(_staticTypeContext)))
           .toList();
       entryType = argumentsListConstant.typeArgument;
     } else {
-      // Skip lowering any other type of List.
+      // Skip lowering arguments in any other type of List.
       return node;
     }
 
-    // Check the overall List entry type, then verify each argument if needed.
+    // Check the arguments List type, then verify each argument if needed.
     if (!_allowedInteropType(entryType)) {
-      for (var argument in callMethodArguments) {
+      for (var argument in callUncheckedArguments) {
         if (!_allowedInterop(argument)) {
           return node;
         }
       }
     }
 
-    return _createNewCallMethodNode(
-        callMethodArguments, arguments, node.fileOffset);
+    return _createCallUncheckedNode(
+        callUncheckedTargets,
+        callUncheckedArguments,
+        originalArguments,
+        node.fileOffset,
+        node.arguments.fileOffset);
   }
 
-  /// Creates a new StaticInvocation node for `_callMethodUncheckedN` with the
-  /// given 0-4 arguments.
-  StaticInvocation _createNewCallMethodNode(
-      List<Expression> callMethodArguments,
-      Arguments arguments,
-      int nodeFileOffset) {
-    assert(callMethodArguments.length <= 4);
+  /// Creates a new StaticInvocation node for the relevant unchecked target
+  /// with the given 0-4 arguments.
+  StaticInvocation _createCallUncheckedNode(
+      List<Procedure> callUncheckedTargets,
+      List<Expression> callUncheckedArguments,
+      List<Expression> originalArguments,
+      int nodeFileOffset,
+      int argumentsFileOffset) {
+    assert(callUncheckedArguments.length <= 4);
     return StaticInvocation(
-        _callMethodUncheckedTargets[callMethodArguments.length],
+        callUncheckedTargets[callUncheckedArguments.length],
         Arguments(
-          [
-            arguments.positional[0],
-            arguments.positional[1],
-            ...callMethodArguments
-          ],
+          [...originalArguments, ...callUncheckedArguments],
           types: [],
-        )..fileOffset = arguments.fileOffset)
+        )..fileOffset = argumentsFileOffset)
       ..fileOffset = nodeFileOffset;
   }
 
diff --git a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
index 89f26d4..36bff9b 100644
--- a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
+++ b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
@@ -293,6 +293,8 @@
         // interestingFiles. Prefix a `**/` so that the glob matches nested
         // folders as well.
         .map((glob) => DocumentFilter(scheme: 'file', pattern: '**/$glob'));
+    final pluginTypesExcludingDart =
+        pluginTypes.where((filter) => filter.pattern != '**/*.dart');
 
     final fullySupportedTypes = {dartFiles, ...pluginTypes}.toList();
 
@@ -314,7 +316,7 @@
     final completionSupportedTypesExcludingDart = {
       // Dart is excluded here at it's registered separately with trigger/commit
       // characters.
-      ...pluginTypes,
+      ...pluginTypesExcludingDart,
       pubspecFile,
       analysisOptionsFile,
       fixDataFile,
diff --git a/pkg/analysis_server/test/lsp/initialization_test.dart b/pkg/analysis_server/test/lsp/initialization_test.dart
index 7d1bc71..0a72f10 100644
--- a/pkg/analysis_server/test/lsp/initialization_test.dart
+++ b/pkg/analysis_server/test/lsp/initialization_test.dart
@@ -91,6 +91,51 @@
     expect(nonDartOptions.triggerCharacters, isNull);
   }
 
+  Future<void> test_completionRegistrations_withDartPlugin() async {
+    // This tests for a bug that occurred with an analysis server plugin
+    // that works on Dart files. When computing completion registrations we
+    // usually have seperate registrations for Dart + non-Dart to account for
+    // different trigger characters. However, the plugin types were all being
+    // included in the non-Dart registration even if they included Dart.
+    //
+    // The result was two registrations including Dart, which caused duplicate
+    // requests for Dart completions, which resulted in duplicate items
+    // appearing in the editor.
+
+    // Track all current registrations.
+    final registrations = <Registration>[];
+
+    // Perform normal registration (without plugins) to get the initial set.
+    await monitorDynamicRegistrations(
+      registrations,
+      () => initialize(
+        textDocumentCapabilities:
+            withAllSupportedTextDocumentDynamicRegistrations(
+                emptyTextDocumentClientCapabilities),
+      ),
+    );
+
+    // Expect only a single registration that includes Dart files.
+    expect(
+      registrationsForDart(registrations, Method.textDocument_completion),
+      hasLength(1),
+    );
+
+    // Monitor the unregistration/new registrations during the plugin activation.
+    await monitorDynamicReregistration(registrations, () async {
+      final plugin = configureTestPlugin();
+      plugin.currentSession = PluginSession(plugin)
+        ..interestingFiles = ['*.dart'];
+      pluginManager.pluginsChangedController.add(null);
+    });
+
+    // Expect that there is still only a single registration for Dart.
+    expect(
+      registrationsForDart(registrations, Method.textDocument_completion),
+      hasLength(1),
+    );
+  }
+
   Future<void> test_dynamicRegistration_containsAppropriateSettings() async {
     // Basic check that the server responds with the capabilities we'd expect,
     // for ex including analysis_options.yaml in text synchronization but not
diff --git a/pkg/analysis_server/test/lsp/server_abstract.dart b/pkg/analysis_server/test/lsp/server_abstract.dart
index 45b8b3f..b4d14d7 100644
--- a/pkg/analysis_server/test/lsp/server_abstract.dart
+++ b/pkg/analysis_server/test/lsp/server_abstract.dart
@@ -128,19 +128,35 @@
     return registrations.singleWhereOrNull((r) => r.method == method.toJson());
   }
 
-  /// Finds the registration for a given LSP method with Dart in its
+  /// Finds a single registration for a given LSP method with Dart in its
   /// documentSelector.
+  ///
+  /// Throws if there is not exactly one match.
   Registration registrationForDart(
     List<Registration> registrations,
     Method method,
+  ) =>
+      registrationsForDart(registrations, method).single;
+
+  /// Finds the registrations for a given LSP method with Dart in their
+  /// documentSelector.
+  List<Registration> registrationsForDart(
+    List<Registration> registrations,
+    Method method,
   ) {
-    return registrations.singleWhere((r) =>
-        r.method == method.toJson() &&
-        (TextDocumentRegistrationOptions.fromJson(
-                    r.registerOptions as Map<String, Object?>)
-                .documentSelector
-                ?.any((selector) => selector.language == dartLanguageId) ??
-            false));
+    bool includesDart(Registration r) {
+      final options = TextDocumentRegistrationOptions.fromJson(
+          r.registerOptions as Map<String, Object?>);
+
+      return options.documentSelector?.any((selector) =>
+              selector.language == dartLanguageId ||
+              (selector.pattern?.contains('.dart') ?? false)) ??
+          false;
+    }
+
+    return registrations
+        .where((r) => r.method == method.toJson() && includesDart(r))
+        .toList();
   }
 
   void resetContextBuildCounter() {
@@ -1390,11 +1406,11 @@
 
   /// Watches for `client/registerCapability` requests and updates
   /// `registrations`.
-  Future<ResponseMessage> monitorDynamicRegistrations(
+  Future<T> monitorDynamicRegistrations<T>(
     List<Registration> registrations,
-    Future<ResponseMessage> Function() f,
+    Future<T> Function() f,
   ) {
-    return handleExpectedRequest<ResponseMessage, RegistrationParams, void>(
+    return handleExpectedRequest<T, RegistrationParams, void>(
       Method.client_registerCapability,
       RegistrationParams.fromJson,
       f,
@@ -1405,9 +1421,9 @@
   }
 
   /// Expects both unregistration and reregistration.
-  Future<ResponseMessage> monitorDynamicReregistration(
+  Future<T> monitorDynamicReregistration<T>(
     List<Registration> registrations,
-    Future<ResponseMessage> Function() f,
+    Future<T> Function() f,
   ) =>
       monitorDynamicUnregistrations(
         registrations,
@@ -1416,11 +1432,11 @@
 
   /// Watches for `client/unregisterCapability` requests and updates
   /// `registrations`.
-  Future<ResponseMessage> monitorDynamicUnregistrations(
+  Future<T> monitorDynamicUnregistrations<T>(
     List<Registration> registrations,
-    Future<ResponseMessage> Function() f,
+    Future<T> Function() f,
   ) {
-    return handleExpectedRequest<ResponseMessage, UnregistrationParams, void>(
+    return handleExpectedRequest<T, UnregistrationParams, void>(
       Method.client_unregisterCapability,
       UnregistrationParams.fromJson,
       f,
diff --git a/pkg/compiler/lib/src/commandline_options.dart b/pkg/compiler/lib/src/commandline_options.dart
index 92170e9..7a72775 100644
--- a/pkg/compiler/lib/src/commandline_options.dart
+++ b/pkg/compiler/lib/src/commandline_options.dart
@@ -54,11 +54,6 @@
 
   static const String experimentNewRti = '--experiment-new-rti';
 
-  /// Use the dart2js lowering of late instance variables rather than the CFE
-  /// lowering.
-  static const String experimentLateInstanceVariables =
-      '--experiment-late-instance-variables';
-
   static const String enableLanguageExperiments = '--enable-experiment';
 
   static const String fastStartup = '--fast-startup';
diff --git a/pkg/compiler/lib/src/common_elements.dart b/pkg/compiler/lib/src/common_elements.dart
index 6f2a3bd..d2e5709 100644
--- a/pkg/compiler/lib/src/common_elements.dart
+++ b/pkg/compiler/lib/src/common_elements.dart
@@ -531,6 +531,22 @@
   /// Most foreign helpers are located in the `dart:_foreign_helper` library.
   bool isForeignHelper(MemberEntity member);
 
+  /// Returns `true` if [member] is the `createJsSentinel` function defined in
+  /// dart:_foreign_helper.
+  bool isCreateJsSentinel(MemberEntity member);
+
+  /// Returns `true` if [member] is the `isJsSentinel` function defined in
+  /// dart:_foreign_helper.
+  bool isIsJsSentinel(MemberEntity member);
+
+  /// Returns `true` if [member] is the `_lateReadCheck` function defined in
+  /// dart:_internal.
+  bool isLateReadCheck(MemberEntity member);
+
+  /// Returns `true` if [member] is the `createSentinel` function defined in
+  /// dart:_internal.
+  bool isCreateSentinel(MemberEntity member);
+
   ClassEntity getDefaultSuperclass(
       ClassEntity cls, NativeBasicData nativeBasicData);
 
@@ -644,10 +660,6 @@
 
   bool isForeign(MemberEntity element);
 
-  /// Returns `true` if [member] is the `createSentinel` function defined in
-  /// dart:_internal.
-  bool isCreateSentinel(MemberEntity element);
-
   /// Returns `true` if the implementation of the 'operator ==' [function] is
   /// known to handle `null` as argument.
   bool operatorEqHandlesNullArgument(FunctionEntity function);
@@ -2117,13 +2129,28 @@
         isCreateInvocationMirrorHelper(member);
   }
 
+  bool _isTopLevelFunctionNamed(String name, MemberEntity member) =>
+      member.name == name && member.isFunction && member.isTopLevel;
+
   @override
-  bool isCreateSentinel(MemberEntity member) {
-    return member.isTopLevel &&
-        member.isFunction &&
-        member.library == internalLibrary &&
-        member.name == 'createSentinel';
-  }
+  bool isCreateJsSentinel(MemberEntity member) =>
+      member.library == foreignLibrary &&
+      _isTopLevelFunctionNamed('createJsSentinel', member);
+
+  @override
+  bool isIsJsSentinel(MemberEntity member) =>
+      member.library == foreignLibrary &&
+      _isTopLevelFunctionNamed('isJsSentinel', member);
+
+  @override
+  bool isLateReadCheck(MemberEntity member) =>
+      member.library == lateHelperLibrary &&
+      _isTopLevelFunctionNamed('_lateReadCheck', member);
+
+  @override
+  bool isCreateSentinel(MemberEntity member) =>
+      member.library == internalLibrary &&
+      _isTopLevelFunctionNamed('createSentinel', member);
 
   @override
   bool operatorEqHandlesNullArgument(FunctionEntity function) {
diff --git a/pkg/compiler/lib/src/constants/values.dart b/pkg/compiler/lib/src/constants/values.dart
index 449c2b2..062f0f9 100644
--- a/pkg/compiler/lib/src/constants/values.dart
+++ b/pkg/compiler/lib/src/constants/values.dart
@@ -912,7 +912,7 @@
   }
 
   @override
-  DartType getType(CommonElements types) => types.dynamicType;
+  DartType getType(CommonElements types) => types.dartTypes.neverType();
 
   @override
   ConstantValueKind get kind => ConstantValueKind.LATE_SENTINEL;
diff --git a/pkg/compiler/lib/src/dart2js.dart b/pkg/compiler/lib/src/dart2js.dart
index 4693cbc..8435ff0 100644
--- a/pkg/compiler/lib/src/dart2js.dart
+++ b/pkg/compiler/lib/src/dart2js.dart
@@ -646,7 +646,6 @@
     new OptionHandler(Flags.experimentUnreachableMethodsThrow, passThrough),
     new OptionHandler(Flags.experimentCallInstrumentation, passThrough),
     new OptionHandler(Flags.experimentNewRti, ignoreOption),
-    new OptionHandler(Flags.experimentLateInstanceVariables, passThrough),
     new OptionHandler('${Flags.mergeFragmentsThreshold}=.+', passThrough),
 
     // Wire up feature flags.
diff --git a/pkg/compiler/lib/src/inferrer/abstract_value_domain.dart b/pkg/compiler/lib/src/inferrer/abstract_value_domain.dart
index 93a30d0..d2b10ed 100644
--- a/pkg/compiler/lib/src/inferrer/abstract_value_domain.dart
+++ b/pkg/compiler/lib/src/inferrer/abstract_value_domain.dart
@@ -104,7 +104,11 @@
 
 /// A system that implements an abstraction over runtime values.
 abstract class AbstractValueDomain {
-  /// The [AbstractValue] that represents an unknown runtime value.
+  /// The [AbstractValue] that represents an unknown runtime value. This
+  /// includes values internal to the implementation, such as late sentinels.
+  AbstractValue get internalTopType;
+
+  /// The [AbstractValue] that represents an unknown runtime Dart value.
   AbstractValue get dynamicType;
 
   /// The [AbstractValue] that represents a non-null subtype of `Type` at
@@ -153,6 +157,9 @@
   /// The [AbstractValue] that represents the `null` at runtime.
   AbstractValue get nullType;
 
+  /// The [AbstractValue] that represents a late sentinel value at runtime.
+  AbstractValue get lateSentinelType;
+
   /// The [AbstractValue] that represents a non-null growable JavaScript array
   /// at runtime.
   AbstractValue get growableListType;
@@ -273,6 +280,14 @@
   /// Returns the version of the abstract [value] that includes `null`.
   AbstractValue includeNull(covariant AbstractValue value);
 
+  /// Returns the version of the abstract [value] that excludes the late
+  /// sentinel.
+  AbstractValue excludeLateSentinel(covariant AbstractValue value);
+
+  /// Returns the version of the abstract [value] that includes the late
+  /// sentinel.
+  AbstractValue includeLateSentinel(covariant AbstractValue value);
+
   /// Returns an [AbstractBool] that describes whether [value] contains
   /// instances of [cls] at runtime.
   AbstractBool containsType(covariant AbstractValue value, ClassEntity cls);
@@ -299,10 +314,6 @@
   /// exact class at runtime.
   AbstractBool isExact(covariant AbstractValue value);
 
-  /// Returns an [AbstractBool] that describes whether [value] is an exact class
-  /// or `null` at runtime.
-  AbstractBool isExactOrNull(covariant AbstractValue value);
-
   /// Returns the [ClassEntity] if this [value] is a non-null instance of an
   /// exact class at runtime, and `null` otherwise.
   ClassEntity getExactClass(covariant AbstractValue value);
@@ -311,6 +322,10 @@
   /// runtime.
   AbstractBool isNull(covariant AbstractValue value);
 
+  /// Returns an [AbstractBool] that describes whether [value] is a sentinel for
+  /// an uninitialized late variable at runtime.
+  AbstractBool isLateSentinel(covariant AbstractValue value);
+
   /// Returns an [AbstractBool] that describes whether [value] is a JavaScript
   /// bool, number, string, array or `null` at runtime.
   AbstractBool isPrimitive(covariant AbstractValue value);
@@ -324,10 +339,6 @@
   AbstractBool isPrimitiveBoolean(covariant AbstractValue value);
 
   /// Returns an [AbstractBool] that describes whether [value] is a JavaScript
-  /// array at runtime.
-  AbstractBool isPrimitiveArray(covariant AbstractValue value);
-
-  /// Returns an [AbstractBool] that describes whether [value] is a JavaScript
   /// string, array, native HTML list or `null` at runtime.
   AbstractBool isIndexablePrimitive(covariant AbstractValue value);
 
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index fe3d41c..7429e8d 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -1509,6 +1509,10 @@
       return _inferrer.typeOfNativeBehavior(nativeBehavior);
     } else if (name == Identifiers.JS_STRING_CONCAT) {
       return _types.stringType;
+    } else if (_closedWorld.commonElements.isCreateJsSentinel(function)) {
+      return _types.lateSentinelType;
+    } else if (_closedWorld.commonElements.isIsJsSentinel(function)) {
+      return _types.boolType;
     } else {
       _sideEffectsBuilder.setAllSideEffects();
       return _types.dynamicType;
@@ -1522,29 +1526,18 @@
     Selector selector = _elementMap.getSelector(node);
     if (_closedWorld.commonElements.isForeign(member)) {
       return handleForeignInvoke(node, member, arguments, selector);
-    } else if (!_options.useLegacySubtyping &&
-        _closedWorld.commonElements.isCreateSentinel(member)) {
-      // TODO(fishythefish): Support this for --no-sound-null-safety too.
-      // `T createSentinel<T>()` ostensibly returns a `T` based on its static
-      // type. However, we need to handle this specially for a couple of
-      // reasons:
-      // 1. We do not currently handle type arguments during type inference and
-      //    in the abstract value domain. Without additional tracing, this means
-      //    that we lose all call-site sensitivity and `createSentinel` is seen
-      //    as returning `Object?`, which widens the inferred types of late
-      //    fields, resulting in poor codegen.
-      // 2. The sentinel isn't a real Dart value and doesn't really inhabit any
-      //    Dart type. Nevertheless, we must view it as inhabiting every Dart
-      //    type for the signature of `createSentinel` to make sense, making it
-      //    a bottom value (similar to an expression of type `Never`).  This
-      //    matches the expectation that reading an uninitialized late field
-      //    (that is, one initialized with the sentinel value) throws.
-      // Note that this currently breaks if `--experiment-unreachable-throw` is
-      // used. We'll be able to do something more precise here when more of the
-      // lowering is deferred to SSA and the abstract value domain can better
-      // track sentinel values.
+    } else if (_closedWorld.commonElements.isLateReadCheck(member)) {
+      // `_lateReadCheck` is essentially a narrowing to exclude the sentinel
+      // value. In order to avoid poor inference resulting from a large
+      // fan-in/fan-out, we perform the narrowing directly instead of creating a
+      // [TypeInformation] for this member.
       handleStaticInvoke(node, selector, member, arguments);
-      return _types.nonNullEmptyType;
+      return _types.narrowType(arguments.positional[0],
+          _elementMap.getDartType(node.arguments.types.single),
+          excludeLateSentinel: true);
+    } else if (_closedWorld.commonElements.isCreateSentinel(member)) {
+      handleStaticInvoke(node, selector, member, arguments);
+      return _types.lateSentinelType;
     } else if (member.isConstructor) {
       return handleConstructorInvoke(
           node, node.arguments, selector, member, arguments);
@@ -2384,8 +2377,8 @@
       {isCast: true,
       excludeNull: false}) {
     assert(type != null);
-    type = inferrer.types
-        .narrowType(type, staticType, isCast: isCast, excludeNull: excludeNull);
+    type = inferrer.types.narrowType(type, staticType,
+        isCast: isCast, excludeNull: excludeNull, excludeLateSentinel: true);
 
     FieldEntity field = capturedAndBoxed[local];
     if (field != null) {
diff --git a/pkg/compiler/lib/src/inferrer/powersets/powerset_bits.dart b/pkg/compiler/lib/src/inferrer/powersets/powerset_bits.dart
index 22a900b..9557395 100644
--- a/pkg/compiler/lib/src/inferrer/powersets/powerset_bits.dart
+++ b/pkg/compiler/lib/src/inferrer/powersets/powerset_bits.dart
@@ -203,6 +203,8 @@
 
     // TODO(coam): We could be more precise if we implement a visitor to
     // ConstantValue
+    // TODO(fishythefish): Naively calling `getType` on
+    // [LateSentinelConstantValue] will produce Never.
     return createFromStaticType(value.getType(commonElements), nullable: false);
   }
 
@@ -281,8 +283,6 @@
 
   AbstractBool isIndexablePrimitive(int value) => isOther(value);
 
-  AbstractBool isPrimitiveArray(int value) => isOther(value);
-
   AbstractBool isPrimitiveBoolean(int value) {
     if (isDefinitelyTrue(value) || isDefinitelyFalse(value)) {
       return AbstractBool.True;
@@ -300,7 +300,8 @@
       ? AbstractBool.True
       : (isPotentiallyNull(value) ? AbstractBool.Maybe : AbstractBool.False);
 
-  AbstractBool isExactOrNull(int value) => AbstractBool.Maybe;
+  // TODO(fishythefish): Support tracking late sentinels in the powerset domain.
+  AbstractBool isLateSentinel(int value) => AbstractBool.Maybe;
 
   AbstractBool isExact(int value) => AbstractBool.Maybe;
 
@@ -333,6 +334,12 @@
     return value & ~nullValue;
   }
 
+  // TODO(fishythefish): Support tracking late sentinels in the powerset domain.
+  int includeLateSentinel(int value) => value;
+
+  // TODO(fishythefish): Support tracking late sentinels in the powerset domain.
+  int excludeLateSentinel(int value) => value;
+
   AbstractBool couldBeTypedArray(int value) => isOther(value);
 
   AbstractBool isTypedArray(int value) => AbstractBool.Maybe;
@@ -555,6 +562,8 @@
     return finish(dynamicType, false);
   }
 
+  int get internalTopType => powersetTop;
+
   int get dynamicType => powersetTop;
 
   int get asyncStarStreamType => powersetTop;
@@ -591,6 +600,9 @@
 
   int get nonNullType => powersetTop & ~nullValue;
 
+  // TODO(fishythefish): Support tracking late sentinels in the powerset domain.
+  int get lateSentinelType => powersetBottom;
+
   int _mapType;
   int get mapType =>
       _mapType ??= createNonNullSubtype(commonElements.mapLiteralClass);
diff --git a/pkg/compiler/lib/src/inferrer/powersets/powersets.dart b/pkg/compiler/lib/src/inferrer/powersets/powersets.dart
index fedb435..b313818 100644
--- a/pkg/compiler/lib/src/inferrer/powersets/powersets.dart
+++ b/pkg/compiler/lib/src/inferrer/powersets/powersets.dart
@@ -63,10 +63,13 @@
   PowersetBitsDomain get powersetBitsDomain => _powersetBitsDomain;
 
   @override
-  AbstractValue get dynamicType {
-    AbstractValue abstractValue = _abstractValueDomain.dynamicType;
-    return PowersetValue(abstractValue, _powersetBitsDomain.powersetTop);
-  }
+  AbstractValue get internalTopType => PowersetValue(
+      _abstractValueDomain.internalTopType,
+      _powersetBitsDomain.internalTopType);
+
+  @override
+  AbstractValue get dynamicType => PowersetValue(
+      _abstractValueDomain.dynamicType, _powersetBitsDomain.dynamicType);
 
   //TODO(coam)
   @override
@@ -528,12 +531,6 @@
           _abstractValueDomain.isIndexablePrimitive(value._abstractValue));
 
   @override
-  AbstractBool isPrimitiveArray(covariant PowersetValue value) =>
-      AbstractBool.strengthen(
-          _powersetBitsDomain.isPrimitiveArray(value._powersetBits),
-          _abstractValueDomain.isPrimitiveArray(value._abstractValue));
-
-  @override
   AbstractBool isPrimitiveBoolean(covariant PowersetValue value) =>
       AbstractBool.strengthen(
           _powersetBitsDomain.isPrimitiveBoolean(value._powersetBits),
@@ -557,14 +554,14 @@
       _abstractValueDomain.isNull(value._abstractValue));
 
   @override
-  ClassEntity getExactClass(covariant PowersetValue value) =>
-      _abstractValueDomain.getExactClass(value._abstractValue);
+  AbstractBool isLateSentinel(covariant PowersetValue value) =>
+      AbstractBool.strengthen(
+          _powersetBitsDomain.isLateSentinel(value._powersetBits),
+          _abstractValueDomain.isLateSentinel(value._abstractValue));
 
   @override
-  AbstractBool isExactOrNull(covariant PowersetValue value) =>
-      AbstractBool.strengthen(
-          _powersetBitsDomain.isExactOrNull(value._powersetBits),
-          _abstractValueDomain.isExactOrNull(value._abstractValue));
+  ClassEntity getExactClass(covariant PowersetValue value) =>
+      _abstractValueDomain.getExactClass(value._abstractValue);
 
   @override
   AbstractBool isExact(covariant PowersetValue value) =>
@@ -619,6 +616,24 @@
   }
 
   @override
+  AbstractValue includeLateSentinel(covariant PowersetValue value) {
+    int powersetBits =
+        _powersetBitsDomain.includeLateSentinel(value._powersetBits);
+    AbstractValue abstractValue =
+        _abstractValueDomain.includeLateSentinel(value._abstractValue);
+    return PowersetValue(abstractValue, powersetBits);
+  }
+
+  @override
+  AbstractValue excludeLateSentinel(covariant PowersetValue value) {
+    int powersetBits =
+        _powersetBitsDomain.excludeLateSentinel(value._powersetBits);
+    AbstractValue abstractValue =
+        _abstractValueDomain.excludeLateSentinel(value._abstractValue);
+    return PowersetValue(abstractValue, powersetBits);
+  }
+
+  @override
   AbstractBool couldBeTypedArray(covariant PowersetValue value) =>
       AbstractBool.strengthen(
           _powersetBitsDomain.couldBeTypedArray(value._powersetBits),
@@ -747,6 +762,11 @@
       _abstractValueDomain.nonNullType, _powersetBitsDomain.nonNullType);
 
   @override
+  AbstractValue get lateSentinelType => PowersetValue(
+      _abstractValueDomain.lateSentinelType,
+      _powersetBitsDomain.lateSentinelType);
+
+  @override
   AbstractValue get mapType =>
       PowersetValue(_abstractValueDomain.mapType, _powersetBitsDomain.mapType);
 
diff --git a/pkg/compiler/lib/src/inferrer/powersets/wrapped.dart b/pkg/compiler/lib/src/inferrer/powersets/wrapped.dart
index d60a060..aa3679c 100644
--- a/pkg/compiler/lib/src/inferrer/powersets/wrapped.dart
+++ b/pkg/compiler/lib/src/inferrer/powersets/wrapped.dart
@@ -49,6 +49,10 @@
   const WrappedAbstractValueDomain(this._abstractValueDomain);
 
   @override
+  AbstractValue get internalTopType =>
+      WrappedAbstractValue(_abstractValueDomain.internalTopType);
+
+  @override
   AbstractValue get dynamicType =>
       WrappedAbstractValue(_abstractValueDomain.dynamicType);
 
@@ -383,10 +387,6 @@
       _abstractValueDomain.isIndexablePrimitive(value._abstractValue);
 
   @override
-  AbstractBool isPrimitiveArray(covariant WrappedAbstractValue value) =>
-      _abstractValueDomain.isPrimitiveArray(value._abstractValue);
-
-  @override
   AbstractBool isPrimitiveBoolean(covariant WrappedAbstractValue value) =>
       _abstractValueDomain.isPrimitiveBoolean(value._abstractValue);
 
@@ -403,12 +403,12 @@
       _abstractValueDomain.isNull(value._abstractValue);
 
   @override
-  ClassEntity getExactClass(covariant WrappedAbstractValue value) =>
-      _abstractValueDomain.getExactClass(value._abstractValue);
+  AbstractBool isLateSentinel(covariant WrappedAbstractValue value) =>
+      _abstractValueDomain.isLateSentinel(value._abstractValue);
 
   @override
-  AbstractBool isExactOrNull(covariant WrappedAbstractValue value) =>
-      _abstractValueDomain.isExactOrNull(value._abstractValue);
+  ClassEntity getExactClass(covariant WrappedAbstractValue value) =>
+      _abstractValueDomain.getExactClass(value._abstractValue);
 
   @override
   AbstractBool isExact(covariant WrappedAbstractValue value) =>
@@ -449,6 +449,16 @@
           _abstractValueDomain.excludeNull(value._abstractValue));
 
   @override
+  AbstractValue includeLateSentinel(covariant WrappedAbstractValue value) =>
+      WrappedAbstractValue(
+          _abstractValueDomain.includeLateSentinel(value._abstractValue));
+
+  @override
+  AbstractValue excludeLateSentinel(covariant WrappedAbstractValue value) =>
+      WrappedAbstractValue(
+          _abstractValueDomain.excludeLateSentinel(value._abstractValue));
+
+  @override
   AbstractBool couldBeTypedArray(covariant WrappedAbstractValue value) =>
       _abstractValueDomain.couldBeTypedArray(value._abstractValue);
 
@@ -546,6 +556,10 @@
       WrappedAbstractValue(_abstractValueDomain.nonNullType);
 
   @override
+  AbstractValue get lateSentinelType =>
+      WrappedAbstractValue(_abstractValueDomain.lateSentinelType);
+
+  @override
   AbstractValue get mapType =>
       WrappedAbstractValue(_abstractValueDomain.mapType);
 
diff --git a/pkg/compiler/lib/src/inferrer/trivial.dart b/pkg/compiler/lib/src/inferrer/trivial.dart
index 27e4f12b..3f6fe3a 100644
--- a/pkg/compiler/lib/src/inferrer/trivial.dart
+++ b/pkg/compiler/lib/src/inferrer/trivial.dart
@@ -25,6 +25,9 @@
   const TrivialAbstractValueDomain();
 
   @override
+  AbstractValue get internalTopType => const TrivialAbstractValue();
+
+  @override
   AbstractValue get dynamicType => const TrivialAbstractValue();
 
   @override
@@ -275,9 +278,6 @@
   AbstractBool isIndexablePrimitive(AbstractValue value) => AbstractBool.Maybe;
 
   @override
-  AbstractBool isPrimitiveArray(AbstractValue value) => AbstractBool.Maybe;
-
-  @override
   AbstractBool isPrimitiveBoolean(AbstractValue value) => AbstractBool.Maybe;
 
   @override
@@ -290,10 +290,10 @@
   AbstractBool isNull(AbstractValue value) => AbstractBool.Maybe;
 
   @override
-  ClassEntity getExactClass(AbstractValue value) => null;
+  AbstractBool isLateSentinel(AbstractValue value) => AbstractBool.Maybe;
 
   @override
-  AbstractBool isExactOrNull(AbstractValue value) => AbstractBool.Maybe;
+  ClassEntity getExactClass(AbstractValue value) => null;
 
   @override
   AbstractBool isExact(AbstractValue value) => AbstractBool.Maybe;
@@ -326,6 +326,14 @@
       const TrivialAbstractValue();
 
   @override
+  AbstractValue includeLateSentinel(AbstractValue value) =>
+      const TrivialAbstractValue();
+
+  @override
+  AbstractValue excludeLateSentinel(AbstractValue value) =>
+      const TrivialAbstractValue();
+
+  @override
   AbstractBool couldBeTypedArray(AbstractValue value) => AbstractBool.Maybe;
 
   @override
@@ -405,6 +413,9 @@
   AbstractValue get nonNullType => const TrivialAbstractValue();
 
   @override
+  AbstractValue get lateSentinelType => const TrivialAbstractValue();
+
+  @override
   AbstractValue get mapType => const TrivialAbstractValue();
 
   @override
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
index e4f2604..b388116 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
@@ -466,6 +466,18 @@
               inferrer.closedWorld.nativeData.getNativeMethodBehavior(function))
           .type;
     }
+
+    if (inferrer.commonElements.isIsJsSentinel(function)) {
+      giveUp(inferrer);
+      return inferrer.abstractValueDomain.boolType;
+    }
+
+    if (inferrer.commonElements.isCreateSentinel(function) ||
+        inferrer.commonElements.isCreateJsSentinel(function)) {
+      giveUp(inferrer);
+      return inferrer.abstractValueDomain.lateSentinelType;
+    }
+
     return null;
   }
 
@@ -2276,9 +2288,11 @@
     if (isNullable) {
       otherType = abstractValueDomain.includeNull(otherType);
     }
-    return type == null
-        ? otherType
-        : abstractValueDomain.intersection(type, otherType);
+    if (type == null) return otherType;
+    AbstractValue newType = abstractValueDomain.intersection(type, otherType);
+    return abstractValueDomain.isLateSentinel(type).isPotentiallyTrue
+        ? abstractValueDomain.includeLateSentinel(newType)
+        : newType;
   }
 
   // TODO(joshualitt): FutureOrType, TypeVariableType, and FunctionTypeVariable
diff --git a/pkg/compiler/lib/src/inferrer/type_system.dart b/pkg/compiler/lib/src/inferrer/type_system.dart
index 85f2de5..33bf709 100644
--- a/pkg/compiler/lib/src/inferrer/type_system.dart
+++ b/pkg/compiler/lib/src/inferrer/type_system.dart
@@ -278,6 +278,10 @@
         getConcreteTypeFor(_abstractValueDomain.asyncStarStreamType);
   }
 
+  TypeInformation _lateSentinelType;
+  TypeInformation get lateSentinelType => _lateSentinelType ??=
+      getConcreteTypeFor(_abstractValueDomain.lateSentinelType);
+
   TypeInformation nonNullEmptyType;
 
   TypeInformation stringLiteralType(String value) {
@@ -337,8 +341,13 @@
   ///
   /// If [excludeNull] is true, the intersection excludes `null` even if the
   /// Dart type implies `null`.
+  ///
+  /// [narrowType] will not exclude the late sentinel value by default, only if
+  /// [excludeLateSentinel] is `true`.
   TypeInformation narrowType(TypeInformation type, DartType annotation,
-      {bool isCast: true, bool excludeNull: false}) {
+      {bool isCast: true,
+      bool excludeNull: false,
+      bool excludeLateSentinel: false}) {
     // Avoid refining an input with an exact type. It we are almost always
     // adding a narrowing to a subtype of the same class or a superclass.
     if (_abstractValueDomain.isExact(type.type).isDefinitelyTrue) return type;
@@ -351,6 +360,9 @@
     if (excludeNull) {
       abstractValue = _abstractValueDomain.excludeNull(abstractValue);
     }
+    if (!excludeLateSentinel) {
+      abstractValue = _abstractValueDomain.includeLateSentinel(abstractValue);
+    }
 
     if (_abstractValueDomain.containsAll(abstractValue).isPotentiallyTrue) {
       // Top, or non-nullable Top.
@@ -643,25 +655,29 @@
   }
 
   AbstractValue joinTypeMasks(Iterable<AbstractValue> masks) {
-    var dynamicType = _abstractValueDomain.dynamicType;
+    var topType = _abstractValueDomain.internalTopType;
     // Optimization: we are iterating over masks twice, but because `masks` is a
     // mapped iterable, we save the intermediate results to avoid computing them
     // again.
     var list = [];
-    bool isDynamicIngoringNull = false;
+    bool isTopIgnoringFlags = false;
     bool mayBeNull = false;
+    bool mayBeLateSentinel = false;
     for (AbstractValue mask in masks) {
       // Don't do any work on computing unions if we know that after all that
       // work the result will be `dynamic`.
-      // TODO(sigmund): change to `mask == dynamicType` so we can continue to
-      // track the non-nullable bit.
+      // TODO(sigmund): change to `mask == internalTopType` so we can continue
+      // to track the non-nullable and late sentinel bits.
       if (_abstractValueDomain.containsAll(mask).isPotentiallyTrue) {
-        isDynamicIngoringNull = true;
+        isTopIgnoringFlags = true;
       }
       if (_abstractValueDomain.isNull(mask).isPotentiallyTrue) {
         mayBeNull = true;
       }
-      if (isDynamicIngoringNull && mayBeNull) return dynamicType;
+      if (_abstractValueDomain.isLateSentinel(mask).isPotentiallyTrue) {
+        mayBeLateSentinel = true;
+      }
+      if (isTopIgnoringFlags && mayBeNull && mayBeLateSentinel) return topType;
       list.add(mask);
     }
 
@@ -671,12 +687,15 @@
           newType == null ? mask : _abstractValueDomain.union(newType, mask);
       // Likewise - stop early if we already reach dynamic.
       if (_abstractValueDomain.containsAll(newType).isPotentiallyTrue) {
-        isDynamicIngoringNull = true;
+        isTopIgnoringFlags = true;
       }
       if (_abstractValueDomain.isNull(newType).isPotentiallyTrue) {
         mayBeNull = true;
       }
-      if (isDynamicIngoringNull && mayBeNull) return dynamicType;
+      if (_abstractValueDomain.isLateSentinel(newType).isPotentiallyTrue) {
+        mayBeLateSentinel = true;
+      }
+      if (isTopIgnoringFlags && mayBeNull && mayBeLateSentinel) return topType;
     }
 
     return newType ?? _abstractValueDomain.emptyType;
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/constants.dart b/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
index b562b3c..4c92f07 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
@@ -57,7 +57,7 @@
   @override
   TypeMask visitLateSentinel(
           LateSentinelConstantValue constant, JClosedWorld closedWorld) =>
-      _abstractValueDomain.dynamicType;
+      _abstractValueDomain.lateSentinelType;
 
   @override
   TypeMask visitUnreachable(
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/container_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/container_type_mask.dart
index 188a951..ab14e11 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/container_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/container_type_mask.dart
@@ -27,20 +27,20 @@
   // The length of the container.
   final int length;
 
-  ContainerTypeMask(this.forwardTo, this.allocationNode, this.allocationElement,
-      this.elementType, this.length);
+  const ContainerTypeMask(this.forwardTo, this.allocationNode,
+      this.allocationElement, this.elementType, this.length);
 
   /// Deserializes a [ContainerTypeMask] object from [source].
   factory ContainerTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
-    TypeMask forwardTo = new TypeMask.readFromDataSource(source, domain);
+    TypeMask forwardTo = TypeMask.readFromDataSource(source, domain);
     ir.TreeNode allocationNode = source.readTreeNodeOrNull();
     MemberEntity allocationElement = source.readMemberOrNull();
-    TypeMask elementType = new TypeMask.readFromDataSource(source, domain);
+    TypeMask elementType = TypeMask.readFromDataSource(source, domain);
     int length = source.readIntOrNull();
     source.end(tag);
-    return new ContainerTypeMask(
+    return ContainerTypeMask(
         forwardTo, allocationNode, allocationElement, elementType, length);
   }
 
@@ -58,19 +58,20 @@
   }
 
   @override
-  TypeMask nullable() {
-    return isNullable
-        ? this
-        : new ContainerTypeMask(forwardTo.nullable(), allocationNode,
-            allocationElement, elementType, length);
-  }
-
-  @override
-  TypeMask nonNullable() {
-    return isNullable
-        ? new ContainerTypeMask(forwardTo.nonNullable(), allocationNode,
-            allocationElement, elementType, length)
-        : this;
+  ContainerTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    return ContainerTypeMask(
+        forwardTo.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel),
+        allocationNode,
+        allocationElement,
+        elementType,
+        length);
   }
 
   @override
@@ -79,36 +80,17 @@
   bool get isExact => true;
 
   @override
-  bool equalsDisregardNull(other) {
-    if (other is! ContainerTypeMask) return false;
-    return super.equalsDisregardNull(other) &&
-        allocationNode == other.allocationNode &&
-        elementType == other.elementType &&
-        length == other.length;
-  }
-
-  @override
-  TypeMask intersection(TypeMask other, CommonMasks domain) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
-    if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
-    return forwardIntersection.isNullable ? nullable() : nonNullable();
-  }
-
-  @override
-  TypeMask union(dynamic other, CommonMasks domain) {
-    if (this == other) {
-      return this;
-    } else if (equalsDisregardNull(other)) {
-      return other.isNullable ? other : this;
-    } else if (other.isEmptyOrNull) {
-      return other.isNullable ? this.nullable() : this;
-    } else if (other.isContainer &&
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+      {bool isNullable, bool hasLateSentinel}) {
+    assert(isNullable != null);
+    assert(hasLateSentinel != null);
+    if (other is ContainerTypeMask &&
         elementType != null &&
         other.elementType != null) {
       TypeMask newElementType = elementType.union(other.elementType, domain);
       int newLength = (length == other.length) ? length : null;
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
-      return new ContainerTypeMask(
+      return ContainerTypeMask(
           newForwardTo,
           allocationNode == other.allocationNode ? allocationNode : null,
           allocationElement == other.allocationElement
@@ -116,19 +98,22 @@
               : null,
           newElementType,
           newLength);
-    } else {
-      return forwardTo.union(other, domain);
     }
+    return null;
   }
 
   @override
-  bool operator ==(other) => super == other;
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! ContainerTypeMask) return false;
+    return super == other &&
+        elementType == other.elementType &&
+        length == other.length;
+  }
 
   @override
-  int get hashCode {
-    return computeHashCode(
-        allocationNode, isNullable, elementType, length, forwardTo);
-  }
+  int get hashCode => Hashing.objectHash(
+      length, Hashing.objectHash(elementType, super.hashCode));
 
   @override
   String toString() {
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/dictionary_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/dictionary_type_mask.dart
index cc54437..00eece2 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/dictionary_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/dictionary_type_mask.dart
@@ -16,9 +16,9 @@
   static const String tag = 'dictionary-type-mask';
 
   // The underlying key/value map of this dictionary.
-  final Map<String, AbstractValue> _typeMap;
+  final Map<String, TypeMask> _typeMap;
 
-  DictionaryTypeMask(
+  const DictionaryTypeMask(
       TypeMask forwardTo,
       ir.Node allocationNode,
       MemberEntity allocationElement,
@@ -31,15 +31,15 @@
   factory DictionaryTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
-    TypeMask forwardTo = new TypeMask.readFromDataSource(source, domain);
+    TypeMask forwardTo = TypeMask.readFromDataSource(source, domain);
     ir.TreeNode allocationNode = source.readTreeNodeOrNull();
     MemberEntity allocationElement = source.readMemberOrNull();
-    TypeMask keyType = new TypeMask.readFromDataSource(source, domain);
-    TypeMask valueType = new TypeMask.readFromDataSource(source, domain);
-    Map<String, AbstractValue> typeMap = source
-        .readStringMap(() => new TypeMask.readFromDataSource(source, domain));
+    TypeMask keyType = TypeMask.readFromDataSource(source, domain);
+    TypeMask valueType = TypeMask.readFromDataSource(source, domain);
+    Map<String, TypeMask> typeMap =
+        source.readStringMap(() => TypeMask.readFromDataSource(source, domain));
     source.end(tag);
-    return new DictionaryTypeMask(forwardTo, allocationNode, allocationElement,
+    return DictionaryTypeMask(forwardTo, allocationNode, allocationElement,
         keyType, valueType, typeMap);
   }
 
@@ -53,27 +53,28 @@
     sink.writeMemberOrNull(allocationElement);
     keyType.writeToDataSink(sink);
     valueType.writeToDataSink(sink);
-    sink.writeStringMap(_typeMap, (AbstractValue value) {
-      TypeMask typeMask = value;
+    sink.writeStringMap(_typeMap, (TypeMask typeMask) {
       typeMask.writeToDataSink(sink);
     });
     sink.end(tag);
   }
 
   @override
-  TypeMask nullable() {
-    return isNullable
-        ? this
-        : new DictionaryTypeMask(forwardTo.nullable(), allocationNode,
-            allocationElement, keyType, valueType, _typeMap);
-  }
-
-  @override
-  TypeMask nonNullable() {
-    return isNullable
-        ? new DictionaryTypeMask(forwardTo.nonNullable(), allocationNode,
-            allocationElement, keyType, valueType, _typeMap)
-        : this;
+  DictionaryTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    return DictionaryTypeMask(
+        forwardTo.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel),
+        allocationNode,
+        allocationElement,
+        keyType,
+        valueType,
+        _typeMap);
   }
 
   @override
@@ -86,37 +87,16 @@
   TypeMask getValueForKey(String key) => _typeMap[key];
 
   @override
-  bool equalsDisregardNull(other) {
-    if (other is! DictionaryTypeMask) return false;
-    return allocationNode == other.allocationNode &&
-        keyType == other.keyType &&
-        valueType == other.valueType &&
-        _typeMap.keys.every((k) => other._typeMap.containsKey(k)) &&
-        other._typeMap.keys.every(
-            (k) => _typeMap.containsKey(k) && _typeMap[k] == other._typeMap[k]);
-  }
-
-  @override
-  TypeMask intersection(TypeMask other, CommonMasks domain) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
-    if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
-    return forwardIntersection.isNullable ? nullable() : nonNullable();
-  }
-
-  @override
-  TypeMask union(dynamic other, CommonMasks domain) {
-    if (this == other) {
-      return this;
-    } else if (equalsDisregardNull(other)) {
-      return other.isNullable ? other : this;
-    } else if (other.isEmptyOrNull) {
-      return other.isNullable ? this.nullable() : this;
-    } else if (other.isDictionary) {
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+      {bool isNullable, bool hasLateSentinel}) {
+    assert(isNullable != null);
+    assert(hasLateSentinel != null);
+    if (other is DictionaryTypeMask) {
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
       TypeMask newKeyType = keyType.union(other.keyType, domain);
       TypeMask newValueType = valueType.union(other.valueType, domain);
-      Map<String, TypeMask> mappings = <String, TypeMask>{};
-      _typeMap.forEach((k, dynamic v) {
+      Map<String, TypeMask> mappings = {};
+      _typeMap.forEach((k, v) {
         if (!other._typeMap.containsKey(k)) {
           mappings[k] = v.nullable();
         }
@@ -128,28 +108,32 @@
           mappings[k] = v.nullable();
         }
       });
-      return new DictionaryTypeMask(
+      return DictionaryTypeMask(
           newForwardTo, null, null, newKeyType, newValueType, mappings);
-    } else if (other.isMap &&
+    }
+    if (other is MapTypeMask &&
         (other.keyType != null) &&
         (other.valueType != null)) {
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
       TypeMask newKeyType = keyType.union(other.keyType, domain);
       TypeMask newValueType = valueType.union(other.valueType, domain);
-      return new MapTypeMask(
-          newForwardTo, null, null, newKeyType, newValueType);
-    } else {
-      return forwardTo.union(other, domain);
+      return MapTypeMask(newForwardTo, null, null, newKeyType, newValueType);
     }
+    return null;
   }
 
   @override
-  bool operator ==(other) => super == other;
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! DictionaryTypeMask) return false;
+    return super == other &&
+        _typeMap.keys.every((k) => other._typeMap.containsKey(k)) &&
+        other._typeMap.keys.every(
+            (k) => _typeMap.containsKey(k) && _typeMap[k] == other._typeMap[k]);
+  }
 
   @override
-  int get hashCode {
-    return computeHashCode(allocationNode, isNullable, _typeMap, forwardTo);
-  }
+  int get hashCode => Hashing.objectHash(_typeMap, super.hashCode);
 
   @override
   String toString() {
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/flat_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/flat_type_mask.dart
index 451af33..0aa5b30 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/flat_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/flat_type_mask.dart
@@ -4,74 +4,121 @@
 
 part of masks;
 
+enum _FlatTypeMaskKind { empty, exact, subclass, subtype }
+
 /// A flat type mask is a type mask that has been flattened to contain a
 /// base type.
-class FlatTypeMask implements TypeMask {
+class FlatTypeMask extends TypeMask {
   /// Tag used for identifying serialized [FlatTypeMask] objects in a
   /// debugging data stream.
   static const String tag = 'flat-type-mask';
 
-  static const int EMPTY = 0;
-  static const int EXACT = 1;
-  static const int SUBCLASS = 2;
-  static const int SUBTYPE = 3;
+  static const int _NULL_INDEX = 0;
+  static const int _LATE_SENTINEL_INDEX = 1;
+  static const int _USED_INDICES = 2;
+
+  static const int _NONE_MASK = 0;
+  static const int _NULL_MASK = 1 << _NULL_INDEX;
+  static const int _LATE_SENTINEL_MASK = 1 << _LATE_SENTINEL_INDEX;
+  static const int _ALL_MASK = (1 << _USED_INDICES) - 1;
 
   final ClassEntity base;
   final int flags;
 
-  factory FlatTypeMask.exact(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, EXACT, true, world);
-  factory FlatTypeMask.subclass(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, SUBCLASS, true, world);
-  factory FlatTypeMask.subtype(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, SUBTYPE, true, world);
-
-  const FlatTypeMask.nonNullEmpty()
-      : base = null,
-        flags = 0;
-  const FlatTypeMask.empty()
-      : base = null,
-        flags = 1;
-
-  factory FlatTypeMask.nonNullExact(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, EXACT, false, world);
-  factory FlatTypeMask.nonNullSubclass(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, SUBCLASS, false, world);
-  factory FlatTypeMask.nonNullSubtype(ClassEntity base, JClosedWorld world) =>
-      FlatTypeMask._canonicalize(base, SUBTYPE, false, world);
-
-  factory FlatTypeMask._canonicalize(
-      ClassEntity base, int kind, bool isNullable, JClosedWorld world) {
-    if (base == world.commonElements.nullClass) {
-      return FlatTypeMask.empty();
-    }
-    return FlatTypeMask._(base, (kind << 1) | (isNullable ? 1 : 0));
+  static int _computeFlags(_FlatTypeMaskKind kind,
+      {bool isNullable: false, bool hasLateSentinel: false}) {
+    int mask = _NONE_MASK;
+    if (isNullable) mask |= _NULL_MASK;
+    if (hasLateSentinel) mask |= _LATE_SENTINEL_MASK;
+    return _computeFlagsRaw(kind.index, mask);
   }
 
-  FlatTypeMask._(this.base, this.flags);
+  static int _computeFlagsRaw(int kind, int mask) =>
+      kind << _USED_INDICES | mask;
+
+  static _FlatTypeMaskKind _lookupKind(int flags) =>
+      _FlatTypeMaskKind.values[flags >> _USED_INDICES];
+
+  static bool _hasNullableFlag(int flags) => flags & _NULL_MASK != _NONE_MASK;
+
+  static bool _hasLateSentinelFlag(int flags) =>
+      flags & _LATE_SENTINEL_MASK != _NONE_MASK;
+
+  factory FlatTypeMask.exact(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.exact, world,
+          isNullable: true, hasLateSentinel: hasLateSentinel);
+  factory FlatTypeMask.subclass(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.subclass, world,
+          isNullable: true, hasLateSentinel: hasLateSentinel);
+  factory FlatTypeMask.subtype(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.subtype, world,
+          isNullable: true, hasLateSentinel: hasLateSentinel);
+
+  factory FlatTypeMask.nonNullEmpty({bool hasLateSentinel: false}) =>
+      hasLateSentinel
+          ? const FlatTypeMask._(null, _LATE_SENTINEL_MASK)
+          : const FlatTypeMask._(null, _NONE_MASK);
+
+  factory FlatTypeMask.empty({bool hasLateSentinel: false}) => hasLateSentinel
+      ? const FlatTypeMask._(null, _NULL_MASK | _LATE_SENTINEL_MASK)
+      : const FlatTypeMask._(null, _NULL_MASK);
+
+  factory FlatTypeMask.nonNullExact(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.exact, world,
+          hasLateSentinel: hasLateSentinel);
+  factory FlatTypeMask.nonNullSubclass(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.subclass, world,
+          hasLateSentinel: hasLateSentinel);
+  factory FlatTypeMask.nonNullSubtype(ClassEntity base, JClosedWorld world,
+          {bool hasLateSentinel: false}) =>
+      FlatTypeMask._canonicalize(base, _FlatTypeMaskKind.subtype, world,
+          hasLateSentinel: hasLateSentinel);
+
+  factory FlatTypeMask._canonicalize(
+      ClassEntity base, _FlatTypeMaskKind kind, JClosedWorld world,
+      {bool isNullable: false, bool hasLateSentinel: false}) {
+    if (base == world.commonElements.nullClass) {
+      return FlatTypeMask.empty(hasLateSentinel: hasLateSentinel);
+    }
+    return FlatTypeMask._(
+        base,
+        _computeFlags(kind,
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel));
+  }
+
+  const FlatTypeMask._(this.base, this.flags);
 
   /// Ensures that the generated mask is normalized, i.e., a call to
   /// [TypeMask.assertIsNormalized] with the factory's result returns `true`.
   factory FlatTypeMask.normalized(
       ClassEntity base, int flags, CommonMasks domain) {
+    bool isNullable = _hasNullableFlag(flags);
+    bool hasLateSentinel = _hasLateSentinelFlag(flags);
     if (base == domain.commonElements.nullClass) {
-      return FlatTypeMask.empty();
+      return FlatTypeMask.empty(hasLateSentinel: hasLateSentinel);
     }
-    if ((flags >> 1) == EMPTY || ((flags >> 1) == EXACT)) {
-      return new FlatTypeMask._(base, flags);
+    _FlatTypeMaskKind kind = _lookupKind(flags);
+    if (kind == _FlatTypeMaskKind.empty || kind == _FlatTypeMaskKind.exact) {
+      return FlatTypeMask._(base, flags);
     }
-    if ((flags >> 1) == SUBTYPE) {
+    if (kind == _FlatTypeMaskKind.subtype) {
       if (!domain._closedWorld.classHierarchy.hasAnyStrictSubtype(base) ||
           domain._closedWorld.classHierarchy.hasOnlySubclasses(base)) {
-        flags = (flags & 0x1) | (SUBCLASS << 1);
+        flags = _computeFlags(_FlatTypeMaskKind.subclass,
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
     }
-    if (((flags >> 1) == SUBCLASS) &&
+    if (kind == _FlatTypeMaskKind.subclass &&
         !domain._closedWorld.classHierarchy.hasAnyStrictSubclass(base)) {
-      flags = (flags & 0x1) | (EXACT << 1);
+      flags = _computeFlags(_FlatTypeMaskKind.exact,
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
     }
-    return domain.getCachedMask(
-        base, flags, () => new FlatTypeMask._(base, flags));
+    return domain.getCachedMask(base, flags, () => FlatTypeMask._(base, flags));
   }
 
   /// Deserializes a [FlatTypeMask] object from [source].
@@ -81,8 +128,7 @@
     ClassEntity base = source.readClassOrNull();
     int flags = source.readInt();
     source.end(tag);
-    return domain.getCachedMask(
-        base, flags, () => new FlatTypeMask._(base, flags));
+    return domain.getCachedMask(base, flags, () => FlatTypeMask._(base, flags));
   }
 
   /// Serializes this [FlatTypeMask] to [sink].
@@ -95,20 +141,34 @@
     sink.end(tag);
   }
 
+  _FlatTypeMaskKind get _kind => _lookupKind(flags);
+
+  int get _mask => flags & _ALL_MASK;
+
   ClassQuery get _classQuery => isExact
       ? ClassQuery.EXACT
       : (isSubclass ? ClassQuery.SUBCLASS : ClassQuery.SUBTYPE);
 
   @override
-  bool get isEmpty => isEmptyOrNull && !isNullable;
+  bool get isEmpty => isEmptyOrFlagged && _mask == _NONE_MASK;
   @override
-  bool get isNull => isEmptyOrNull && isNullable;
+  bool get isNull => isEmptyOrFlagged && _mask == _NULL_MASK;
   @override
-  bool get isEmptyOrNull => (flags >> 1) == EMPTY;
+  bool get isEmptyOrFlagged => _kind == _FlatTypeMaskKind.empty;
   @override
-  bool get isExact => (flags >> 1) == EXACT;
+  bool get isExact => _kind == _FlatTypeMaskKind.exact;
   @override
-  bool get isNullable => (flags & 1) != 0;
+  bool get isNullable => _hasNullableFlag(flags);
+  @override
+  bool get hasLateSentinel => _hasLateSentinelFlag(flags);
+  @override
+  AbstractBool get isLateSentinel {
+    if (!hasLateSentinel) return AbstractBool.False;
+    if (isEmptyOrFlagged && _mask == _LATE_SENTINEL_MASK) {
+      return AbstractBool.True;
+    }
+    return AbstractBool.Maybe;
+  }
 
   @override
   bool get isUnion => false;
@@ -128,22 +188,21 @@
   // TODO(kasperl): Get rid of these. They should not be a visible
   // part of the implementation because they make it hard to add
   // proper union types if we ever want to.
-  bool get isSubclass => (flags >> 1) == SUBCLASS;
-  bool get isSubtype => (flags >> 1) == SUBTYPE;
+  bool get isSubclass => _kind == _FlatTypeMaskKind.subclass;
+  bool get isSubtype => _kind == _FlatTypeMaskKind.subtype;
 
   @override
-  TypeMask nullable() {
-    return isNullable ? this : new FlatTypeMask._(base, flags | 1);
-  }
-
-  @override
-  TypeMask nonNullable() {
-    return isNullable ? new FlatTypeMask._(base, flags & ~1) : this;
+  FlatTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    int newFlags = _computeFlags(_kind,
+        isNullable: isNullable ?? this.isNullable,
+        hasLateSentinel: hasLateSentinel ?? this.hasLateSentinel);
+    if (newFlags == flags) return this;
+    return FlatTypeMask._(base, newFlags);
   }
 
   @override
   bool contains(ClassEntity other, JClosedWorld closedWorld) {
-    if (isEmptyOrNull) {
+    if (isEmptyOrFlagged) {
       return false;
     } else if (identical(base, other)) {
       return true;
@@ -184,11 +243,14 @@
 
   @override
   bool isInMask(TypeMask other, JClosedWorld closedWorld) {
-    if (isEmptyOrNull) return isNullable ? other.isNullable : true;
-    // The empty type contains no classes.
-    if (other.isEmptyOrNull) return false;
     // Quick check whether to handle null.
     if (isNullable && !other.isNullable) return false;
+    if (hasLateSentinel && !other.hasLateSentinel) {
+      return false;
+    }
+    // The empty type contains no classes.
+    if (isEmptyOrFlagged) return true;
+    if (other.isEmptyOrFlagged) return false;
     other = TypeMask.nonForwardingMask(other);
     // If other is union, delegate to UnionTypeMask.containsMask.
     if (other is! FlatTypeMask) return other.containsMask(this, closedWorld);
@@ -259,15 +321,16 @@
 
   @override
   bool satisfies(ClassEntity cls, JClosedWorld closedWorld) {
-    if (isEmptyOrNull) return false;
+    if (isEmptyOrFlagged) return false;
     if (closedWorld.classHierarchy.isSubtypeOf(base, cls)) return true;
     return false;
   }
 
   @override
   ClassEntity singleClass(JClosedWorld closedWorld) {
-    if (isEmptyOrNull) return null;
+    if (isEmptyOrFlagged) return null;
     if (isNullable) return null; // It is Null and some other class.
+    if (hasLateSentinel) return null;
     if (isExact) {
       return base;
     } else if (isSubclass) {
@@ -282,7 +345,7 @@
 
   @override
   bool containsAll(JClosedWorld closedWorld) {
-    if (isEmptyOrNull || isExact) return false;
+    if (isEmptyOrFlagged || isExact) return false;
     return identical(base, closedWorld.commonElements.objectClass);
   }
 
@@ -294,10 +357,14 @@
     assert(TypeMask.assertIsNormalized(other, closedWorld));
     if (other is! FlatTypeMask) return other.union(this, domain);
     FlatTypeMask flatOther = other;
-    if (isEmptyOrNull) {
-      return isNullable ? flatOther.nullable() : flatOther;
-    } else if (flatOther.isEmptyOrNull) {
-      return flatOther.isNullable ? nullable() : this;
+    bool isNullable = this.isNullable || flatOther.isNullable;
+    bool hasLateSentinel = this.hasLateSentinel || flatOther.hasLateSentinel;
+    if (isEmptyOrFlagged) {
+      return flatOther.withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
+    } else if (flatOther.isEmptyOrFlagged) {
+      return withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
     } else if (base == flatOther.base) {
       return unionSame(flatOther, domain);
     } else if (closedWorld.classHierarchy.isSubclassOf(flatOther.base, base)) {
@@ -309,9 +376,9 @@
     } else if (closedWorld.classHierarchy.isSubtypeOf(base, flatOther.base)) {
       return flatOther.unionStrictSubtype(this, domain);
     } else {
-      return new UnionTypeMask._internal(
-          <FlatTypeMask>[this.nonNullable(), flatOther.nonNullable()],
-          isNullable || other.isNullable);
+      return UnionTypeMask._internal(
+          <FlatTypeMask>[withoutFlags(), flatOther.withoutFlags()],
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
     }
   }
 
@@ -323,15 +390,14 @@
     // constraining kind (the highest) of the two. If either one of
     // the masks are nullable the result should be nullable too.
     // As both masks are normalized, the result will be, too.
-    int combined = (flags > other.flags)
-        ? flags | (other.flags & 1)
-        : other.flags | (flags & 1);
+    int combined =
+        (flags > other.flags) ? flags | other._mask : other.flags | _mask;
     if (flags == combined) {
       return this;
     } else if (other.flags == combined) {
       return other;
     } else {
-      return new FlatTypeMask.normalized(base, combined, domain);
+      return FlatTypeMask.normalized(base, combined, domain);
     }
   }
 
@@ -346,19 +412,19 @@
       // Since the other mask is a subclass of this mask, we need the
       // resulting union to be a subclass too. If either one of the
       // masks are nullable the result should be nullable too.
-      combined = (SUBCLASS << 1) | ((flags | other.flags) & 1);
+      combined = _computeFlagsRaw(
+          _FlatTypeMaskKind.subclass.index, _mask | other._mask);
     } else {
       // Both masks are at least subclass masks, so we pick the least
       // constraining kind (the highest) of the two. If either one of
       // the masks are nullable the result should be nullable too.
-      combined = (flags > other.flags)
-          ? flags | (other.flags & 1)
-          : other.flags | (flags & 1);
+      combined =
+          (flags > other.flags) ? flags | other._mask : other.flags | _mask;
     }
     // If we weaken the constraint on this type, we have to make sure that
     // the result is normalized.
-    return (flags != combined)
-        ? new FlatTypeMask.normalized(base, combined, domain)
+    return flags != combined
+        ? FlatTypeMask.normalized(base, combined, domain)
         : this;
   }
 
@@ -371,11 +437,12 @@
     // Since the other mask is a subtype of this mask, we need the
     // resulting union to be a subtype too. If either one of the masks
     // are nullable the result should be nullable too.
-    int combined = (SUBTYPE << 1) | ((flags | other.flags) & 1);
+    int combined =
+        _computeFlagsRaw(_FlatTypeMaskKind.subtype.index, _mask | other._mask);
     // We know there is at least one subtype, [other.base], so no need
     // to normalize.
-    return (flags != combined)
-        ? new FlatTypeMask.normalized(base, combined, domain)
+    return flags != combined
+        ? FlatTypeMask.normalized(base, combined, domain)
         : this;
   }
 
@@ -390,11 +457,14 @@
     ClassEntity otherBase = flatOther.base;
 
     bool includeNull = isNullable && flatOther.isNullable;
+    bool includeLateSentinel = hasLateSentinel && flatOther.hasLateSentinel;
 
-    if (isEmptyOrNull) {
-      return includeNull ? this : nonNullable();
-    } else if (flatOther.isEmptyOrNull) {
-      return includeNull ? other : other.nonNullable();
+    if (isEmptyOrFlagged) {
+      return withFlags(
+          isNullable: includeNull, hasLateSentinel: includeLateSentinel);
+    } else if (flatOther.isEmptyOrFlagged) {
+      return other.withFlags(
+          isNullable: includeNull, hasLateSentinel: includeLateSentinel);
     }
 
     SubclassResult result = domain._closedWorld.classHierarchy
@@ -402,43 +472,58 @@
 
     switch (result.kind) {
       case SubclassResultKind.EMPTY:
-        return includeNull ? domain.nullType : domain.emptyType;
+        return includeNull
+            ? TypeMask.empty(hasLateSentinel: includeLateSentinel)
+            : TypeMask.nonNullEmpty(hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.EXACT1:
         assert(isExact);
-        return includeNull ? this : nonNullable();
+        return withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.EXACT2:
         assert(other.isExact);
-        return includeNull ? other : other.nonNullable();
+        return other.withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.SUBCLASS1:
         assert(isSubclass);
-        return includeNull ? this : nonNullable();
+        return withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.SUBCLASS2:
         assert(flatOther.isSubclass);
-        return includeNull ? other : other.nonNullable();
+        return other.withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.SUBTYPE1:
         assert(isSubtype);
-        return includeNull ? this : nonNullable();
+        return withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.SUBTYPE2:
         assert(flatOther.isSubtype);
-        return includeNull ? other : other.nonNullable();
+        return other.withFlags(
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
       case SubclassResultKind.SET:
       default:
         if (result.classes.isEmpty) {
-          return includeNull ? domain.nullType : domain.emptyType;
+          return includeNull
+              ? TypeMask.empty(hasLateSentinel: includeLateSentinel)
+              : TypeMask.nonNullEmpty(hasLateSentinel: includeLateSentinel);
         } else if (result.classes.length == 1) {
           ClassEntity cls = result.classes.first;
           return includeNull
-              ? new TypeMask.subclass(cls, domain._closedWorld)
-              : new TypeMask.nonNullSubclass(cls, domain._closedWorld);
+              ? TypeMask.subclass(cls, domain._closedWorld,
+                  hasLateSentinel: includeLateSentinel)
+              : TypeMask.nonNullSubclass(cls, domain._closedWorld,
+                  hasLateSentinel: includeLateSentinel);
         }
 
         List<FlatTypeMask> masks = List.from(result.classes.map(
             (ClassEntity cls) =>
                 TypeMask.nonNullSubclass(cls, domain._closedWorld)));
         if (masks.length > UnionTypeMask.MAX_UNION_LENGTH) {
-          return UnionTypeMask.flatten(masks, includeNull, domain);
+          return UnionTypeMask.flatten(masks, domain,
+              includeNull: includeNull,
+              includeLateSentinel: includeLateSentinel);
         }
-        return new UnionTypeMask._internal(masks, includeNull);
+        return UnionTypeMask._internal(masks,
+            isNullable: includeNull, hasLateSentinel: includeLateSentinel);
     }
   }
 
@@ -448,7 +533,8 @@
     FlatTypeMask flatOther = other;
 
     if (isNullable && flatOther.isNullable) return false;
-    if (isEmptyOrNull || flatOther.isEmptyOrNull) return true;
+    if (hasLateSentinel && flatOther.hasLateSentinel) return false;
+    if (isEmptyOrFlagged || flatOther.isEmptyOrFlagged) return true;
     if (base == flatOther.base) return false;
     if (isExact && flatOther.isExact) return true;
 
@@ -495,14 +581,14 @@
     // are nullable, will the result be nullable too.
     // The result will be normalized, as the two inputs are normalized, too.
     int combined = (flags < other.flags)
-        ? flags & ((other.flags & 1) | ~1)
-        : other.flags & ((flags & 1) | ~1);
+        ? flags & (other._mask | ~_ALL_MASK)
+        : other.flags & (_mask | ~_ALL_MASK);
     if (flags == combined) {
       return this;
     } else if (other.flags == combined) {
       return other;
     } else {
-      return new FlatTypeMask.normalized(base, combined, domain);
+      return FlatTypeMask.normalized(base, combined, domain);
     }
   }
 
@@ -517,28 +603,29 @@
     // masks are nullable, will the result be nullable too.
     // The result is guaranteed to be normalized, as the other type
     // was normalized.
-    int combined = other.flags & ((flags & 1) | ~1);
+    int combined = other.flags & (_mask | ~_ALL_MASK);
     if (other.flags == combined) {
       return other;
     } else {
-      return new FlatTypeMask.normalized(other.base, combined, domain);
+      return FlatTypeMask.normalized(other.base, combined, domain);
     }
   }
 
   TypeMask intersectionEmpty(FlatTypeMask other) {
-    return isNullable && other.isNullable
-        ? new TypeMask.empty()
-        : new TypeMask.nonNullEmpty();
+    bool isNullable = this.isNullable && other.isNullable;
+    bool hasLateSentinel = this.hasLateSentinel && other.hasLateSentinel;
+    return isNullable
+        ? TypeMask.empty(hasLateSentinel: hasLateSentinel)
+        : TypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
   }
 
   @override
   bool canHit(MemberEntity element, Name name, JClosedWorld closedWorld) {
     CommonElements commonElements = closedWorld.commonElements;
     assert(element.name == name.text);
-    if (isEmpty) return false;
-    if (isNull) {
-      return closedWorld.hasElementIn(
-          commonElements.jsNullClass, name, element);
+    if (isEmptyOrFlagged) {
+      return isNullable &&
+          closedWorld.hasElementIn(commonElements.jsNullClass, name, element);
     }
 
     ClassEntity other = element.enclosingClass;
@@ -572,7 +659,7 @@
       Selector selector, covariant JClosedWorld closedWorld) {
     // A call on an empty type mask is either dead code, or a call on
     // `null`.
-    if (isEmptyOrNull) return false;
+    if (isEmptyOrFlagged) return false;
     // A call on an exact mask for an abstract class is dead code.
     // TODO(johnniwinther): A type mask cannot be abstract. Remove the need
     // for this noise (currently used for super-calls in inference and mirror
@@ -584,7 +671,7 @@
 
   @override
   MemberEntity locateSingleMember(Selector selector, CommonMasks domain) {
-    if (isEmptyOrNull) return null;
+    if (isEmptyOrFlagged) return null;
     JClosedWorld closedWorld = domain._closedWorld;
     if (closedWorld.includesClosureCallInDomain(selector, this, domain))
       return null;
@@ -628,13 +715,16 @@
 
   @override
   String toString() {
-    if (isEmptyOrNull) return isNullable ? '[null]' : '[empty]';
-    StringBuffer buffer = new StringBuffer();
-    if (isNullable) buffer.write('null|');
-    if (isExact) buffer.write('exact=');
-    if (isSubclass) buffer.write('subclass=');
-    if (isSubtype) buffer.write('subtype=');
-    buffer.write(base.name);
-    return "[$buffer]";
+    StringBuffer buffer = StringBuffer('[');
+    buffer.writeAll([
+      if (isEmpty) 'empty',
+      if (isNullable) 'null',
+      if (hasLateSentinel) 'sentinel',
+      if (isExact) 'exact=${base.name}',
+      if (isSubclass) 'subclass=${base.name}',
+      if (isSubtype) 'subtype=${base.name}',
+    ], '|');
+    buffer.write(']');
+    return buffer.toString();
   }
 }
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/forwarding_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/forwarding_type_mask.dart
index ec29cbe..213c62a 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/forwarding_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/forwarding_type_mask.dart
@@ -4,15 +4,15 @@
 
 part of masks;
 
-/// A type mask that wraps an other one, and delegate all its
+/// A type mask that wraps another one, and delegates all its
 /// implementation methods to it.
-abstract class ForwardingTypeMask implements TypeMask {
+abstract class ForwardingTypeMask extends TypeMask {
   TypeMask get forwardTo;
 
-  ForwardingTypeMask();
+  const ForwardingTypeMask();
 
   @override
-  bool get isEmptyOrNull => forwardTo.isEmptyOrNull;
+  bool get isEmptyOrFlagged => forwardTo.isEmptyOrFlagged;
   @override
   bool get isEmpty => forwardTo.isEmpty;
   @override
@@ -20,6 +20,10 @@
   @override
   bool get isNull => forwardTo.isNull;
   @override
+  bool get hasLateSentinel => forwardTo.hasLateSentinel;
+  @override
+  AbstractBool get isLateSentinel => forwardTo.isLateSentinel;
+  @override
   bool get isExact => forwardTo.isExact;
 
   @override
@@ -93,17 +97,29 @@
   }
 
   @override
-  TypeMask union(other, CommonMasks domain) {
+  TypeMask union(TypeMask other, CommonMasks domain) {
     if (this == other) {
       return this;
-    } else if (equalsDisregardNull(other)) {
-      return other.isNullable ? other : this;
-    } else if (other.isEmptyOrNull) {
-      return other.isNullable ? this.nullable() : this;
     }
-    return forwardTo.union(other, domain);
+    bool isNullable = this.isNullable || other.isNullable;
+    bool hasLateSentinel = this.hasLateSentinel || other.hasLateSentinel;
+    if (isEmptyOrFlagged) {
+      return other.withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
+    }
+    if (other.isEmptyOrFlagged) {
+      return withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
+    }
+    return _unionSpecialCases(other, domain,
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel) ??
+        forwardTo.union(other, domain);
   }
 
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+          {bool isNullable, bool hasLateSentinel}) =>
+      null;
+
   @override
   bool isDisjoint(TypeMask other, JClosedWorld closedWorld) {
     return forwardTo.isDisjoint(other, closedWorld);
@@ -111,7 +127,11 @@
 
   @override
   TypeMask intersection(TypeMask other, CommonMasks domain) {
-    return forwardTo.intersection(other, domain);
+    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
+    if (forwardIntersection.isEmptyOrFlagged) return forwardIntersection;
+    return withFlags(
+        isNullable: forwardIntersection.isNullable,
+        hasLateSentinel: forwardIntersection.hasLateSentinel);
   }
 
   @override
@@ -130,28 +150,33 @@
     return forwardTo.locateSingleMember(selector, domain);
   }
 
-  bool equalsDisregardNull(other) {
-    if (other is! ForwardingTypeMask) return false;
-    if (forwardTo.isNullable) {
-      return forwardTo == other.forwardTo.nullable();
-    } else {
-      return forwardTo == other.forwardTo.nonNullable();
-    }
-  }
-
   @override
   bool operator ==(other) {
-    return equalsDisregardNull(other) && isNullable == other.isNullable;
+    if (identical(this, other)) return true;
+    if (other is! ForwardingTypeMask) return false;
+    return forwardTo == other.forwardTo;
   }
 
   @override
-  int get hashCode => throw "Subclass should implement hashCode getter";
+  int get hashCode => forwardTo.hashCode;
 }
 
 abstract class AllocationTypeMask extends ForwardingTypeMask {
+  const AllocationTypeMask();
+
   // The [ir.Node] where this type mask was created.
   ir.Node get allocationNode;
 
   // The [Entity] where this type mask was created.
   MemberEntity get allocationElement;
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! AllocationTypeMask) return false;
+    return super == other && allocationNode == other.allocationNode;
+  }
+
+  @override
+  int get hashCode => Hashing.objectHash(allocationNode, super.hashCode);
 }
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/map_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/map_type_mask.dart
index 556be49..035fa9d 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/map_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/map_type_mask.dart
@@ -27,20 +27,20 @@
   // The key type of this map.
   final TypeMask keyType;
 
-  MapTypeMask(this.forwardTo, this.allocationNode, this.allocationElement,
+  const MapTypeMask(this.forwardTo, this.allocationNode, this.allocationElement,
       this.keyType, this.valueType);
 
   /// Deserializes a [MapTypeMask] object from [source].
   factory MapTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
-    TypeMask forwardTo = new TypeMask.readFromDataSource(source, domain);
+    TypeMask forwardTo = TypeMask.readFromDataSource(source, domain);
     ir.TreeNode allocationNode = source.readTreeNodeOrNull();
     MemberEntity allocationElement = source.readMemberOrNull();
-    TypeMask keyType = new TypeMask.readFromDataSource(source, domain);
-    TypeMask valueType = new TypeMask.readFromDataSource(source, domain);
+    TypeMask keyType = TypeMask.readFromDataSource(source, domain);
+    TypeMask valueType = TypeMask.readFromDataSource(source, domain);
     source.end(tag);
-    return new MapTypeMask(
+    return MapTypeMask(
         forwardTo, allocationNode, allocationElement, keyType, valueType);
   }
 
@@ -58,19 +58,20 @@
   }
 
   @override
-  TypeMask nullable() {
-    return isNullable
-        ? this
-        : new MapTypeMask(forwardTo.nullable(), allocationNode,
-            allocationElement, keyType, valueType);
-  }
-
-  @override
-  TypeMask nonNullable() {
-    return isNullable
-        ? new MapTypeMask(forwardTo.nonNullable(), allocationNode,
-            allocationElement, keyType, valueType)
-        : this;
+  MapTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    return MapTypeMask(
+        forwardTo.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel),
+        allocationNode,
+        allocationElement,
+        keyType,
+        valueType);
   }
 
   @override
@@ -81,30 +82,11 @@
   bool get isExact => true;
 
   @override
-  bool equalsDisregardNull(other) {
-    if (other is! MapTypeMask) return false;
-    return super.equalsDisregardNull(other) &&
-        allocationNode == other.allocationNode &&
-        keyType == other.keyType &&
-        valueType == other.valueType;
-  }
-
-  @override
-  TypeMask intersection(TypeMask other, CommonMasks domain) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
-    if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
-    return forwardIntersection.isNullable ? nullable() : nonNullable();
-  }
-
-  @override
-  TypeMask union(dynamic other, CommonMasks domain) {
-    if (this == other) {
-      return this;
-    } else if (equalsDisregardNull(other)) {
-      return other.isNullable ? other : this;
-    } else if (other.isEmptyOrNull) {
-      return other.isNullable ? this.nullable() : this;
-    } else if (other.isMap &&
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+      {bool isNullable, bool hasLateSentinel}) {
+    assert(isNullable != null);
+    assert(hasLateSentinel != null);
+    if (other is MapTypeMask &&
         keyType != null &&
         other.keyType != null &&
         valueType != null &&
@@ -112,19 +94,19 @@
       TypeMask newKeyType = keyType.union(other.keyType, domain);
       TypeMask newValueType = valueType.union(other.valueType, domain);
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
-      return new MapTypeMask(
-          newForwardTo, null, null, newKeyType, newValueType);
-    } else if (other.isDictionary) {
+      return MapTypeMask(newForwardTo, null, null, newKeyType, newValueType);
+    }
+    if (other is DictionaryTypeMask) {
       // TODO(johnniwinther): Find another way to check this invariant that
       // doesn't need the compiler.
       assert(other.keyType ==
-          new TypeMask.nonNullExact(
+          TypeMask.nonNullExact(
               domain.commonElements.jsStringClass, domain._closedWorld));
       TypeMask newKeyType = keyType.union(other.keyType, domain);
       TypeMask newValueType =
-          other.typeMap.values.fold(keyType, (p, n) => p.union(n, domain));
+          other._typeMap.values.fold(keyType, (p, n) => p.union(n, domain));
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
-      MapTypeMask newMapTypeMask = new MapTypeMask(
+      MapTypeMask newMapTypeMask = MapTypeMask(
           newForwardTo,
           allocationNode == other.allocationNode ? allocationNode : null,
           allocationElement == other.allocationElement
@@ -133,19 +115,22 @@
           newKeyType,
           newValueType);
       return newMapTypeMask;
-    } else {
-      return forwardTo.union(other, domain);
     }
+    return null;
   }
 
   @override
-  bool operator ==(other) => super == other;
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! MapTypeMask) return false;
+    return super == other &&
+        keyType == other.keyType &&
+        valueType == other.valueType;
+  }
 
   @override
-  int get hashCode {
-    return computeHashCode(
-        allocationNode, isNullable, keyType, valueType, forwardTo);
-  }
+  int get hashCode => Hashing.objectHash(
+      valueType, Hashing.objectHash(keyType, super.hashCode));
 
   @override
   String toString() {
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/masks.dart b/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
index 2ac07ca..999d317 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/masks.dart
@@ -45,6 +45,7 @@
   CommonElements get commonElements => _closedWorld.commonElements;
   DartTypes get dartTypes => _closedWorld.dartTypes;
 
+  TypeMask _internalTopType;
   TypeMask _dynamicType;
   TypeMask _nonNullType;
   TypeMask _nullType;
@@ -75,10 +76,10 @@
   TypeMask _unmodifiableArrayType;
   TypeMask _interceptorType;
 
-  /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
+  /// Cache of [FlatTypeMask]s grouped by the possible values of the
   /// `FlatTypeMask.flags` property.
-  final List<Map<ClassEntity, TypeMask>> _canonicalizedTypeMasks =
-      new List<Map<ClassEntity, TypeMask>>.filled(8, null);
+  final List<Map<ClassEntity, TypeMask>> _canonicalizedTypeMasks = List.filled(
+      _FlatTypeMaskKind.values.length << FlatTypeMask._USED_INDICES, null);
 
   /// Return the cached mask for [base] with the given flags, or
   /// calls [createMask] to create the mask and cache it.
@@ -89,126 +90,129 @@
   }
 
   @override
-  TypeMask get dynamicType => _dynamicType ??= new TypeMask.subclass(
-      _closedWorld.commonElements.objectClass, _closedWorld);
+  TypeMask get internalTopType => _internalTopType ??= TypeMask.subclass(
+      _closedWorld.commonElements.objectClass, _closedWorld,
+      hasLateSentinel: true);
 
   @override
-  TypeMask get nonNullType => _nonNullType ??= new TypeMask.nonNullSubclass(
+  TypeMask get dynamicType => _dynamicType ??=
+      TypeMask.subclass(_closedWorld.commonElements.objectClass, _closedWorld);
+
+  @override
+  TypeMask get nonNullType => _nonNullType ??= TypeMask.nonNullSubclass(
       _closedWorld.commonElements.objectClass, _closedWorld);
 
   @override
   TypeMask get intType => _intType ??=
-      new TypeMask.nonNullSubclass(commonElements.jsIntClass, _closedWorld);
+      TypeMask.nonNullSubclass(commonElements.jsIntClass, _closedWorld);
 
   @override
   TypeMask get uint32Type => _uint32Type ??=
-      new TypeMask.nonNullSubclass(commonElements.jsUInt32Class, _closedWorld);
+      TypeMask.nonNullSubclass(commonElements.jsUInt32Class, _closedWorld);
 
   @override
   TypeMask get uint31Type => _uint31Type ??=
-      new TypeMask.nonNullExact(commonElements.jsUInt31Class, _closedWorld);
+      TypeMask.nonNullExact(commonElements.jsUInt31Class, _closedWorld);
 
   @override
-  TypeMask get positiveIntType =>
-      _positiveIntType ??= new TypeMask.nonNullSubclass(
-          commonElements.jsPositiveIntClass, _closedWorld);
+  TypeMask get positiveIntType => _positiveIntType ??=
+      TypeMask.nonNullSubclass(commonElements.jsPositiveIntClass, _closedWorld);
 
   @override
   TypeMask get numNotIntType => _numNotIntType ??=
-      new TypeMask.nonNullExact(commonElements.jsNumNotIntClass, _closedWorld);
+      TypeMask.nonNullExact(commonElements.jsNumNotIntClass, _closedWorld);
 
   @override
   TypeMask get numType => _numType ??=
-      new TypeMask.nonNullSubclass(commonElements.jsNumberClass, _closedWorld);
+      TypeMask.nonNullSubclass(commonElements.jsNumberClass, _closedWorld);
 
   @override
   TypeMask get boolType => _boolType ??=
-      new TypeMask.nonNullExact(commonElements.jsBoolClass, _closedWorld);
+      TypeMask.nonNullExact(commonElements.jsBoolClass, _closedWorld);
 
   @override
   TypeMask get functionType => _functionType ??=
-      new TypeMask.nonNullSubtype(commonElements.functionClass, _closedWorld);
+      TypeMask.nonNullSubtype(commonElements.functionClass, _closedWorld);
 
   @override
   TypeMask get listType => _listType ??=
-      new TypeMask.nonNullSubtype(commonElements.jsArrayClass, _closedWorld);
+      TypeMask.nonNullSubtype(commonElements.jsArrayClass, _closedWorld);
 
   @override
-  TypeMask get constListType => _constListType ??= new TypeMask.nonNullExact(
+  TypeMask get constListType => _constListType ??= TypeMask.nonNullExact(
       commonElements.jsUnmodifiableArrayClass, _closedWorld);
 
   @override
   TypeMask get fixedListType => _fixedListType ??=
-      new TypeMask.nonNullExact(commonElements.jsFixedArrayClass, _closedWorld);
+      TypeMask.nonNullExact(commonElements.jsFixedArrayClass, _closedWorld);
 
   @override
-  TypeMask get growableListType =>
-      _growableListType ??= new TypeMask.nonNullExact(
-          commonElements.jsExtendableArrayClass, _closedWorld);
+  TypeMask get growableListType => _growableListType ??= TypeMask.nonNullExact(
+      commonElements.jsExtendableArrayClass, _closedWorld);
 
   @override
   TypeMask get setType => _setType ??=
-      new TypeMask.nonNullSubtype(commonElements.setLiteralClass, _closedWorld);
+      TypeMask.nonNullSubtype(commonElements.setLiteralClass, _closedWorld);
 
   @override
-  TypeMask get constSetType => _constSetType ??= new TypeMask.nonNullSubtype(
+  TypeMask get constSetType => _constSetType ??= TypeMask.nonNullSubtype(
       commonElements.constSetLiteralClass, _closedWorld);
 
   @override
   TypeMask get mapType => _mapType ??=
-      new TypeMask.nonNullSubtype(commonElements.mapLiteralClass, _closedWorld);
+      TypeMask.nonNullSubtype(commonElements.mapLiteralClass, _closedWorld);
 
   @override
-  TypeMask get constMapType => _constMapType ??= new TypeMask.nonNullSubtype(
+  TypeMask get constMapType => _constMapType ??= TypeMask.nonNullSubtype(
       commonElements.constMapLiteralClass, _closedWorld);
 
   @override
   TypeMask get stringType => _stringType ??=
-      new TypeMask.nonNullExact(commonElements.jsStringClass, _closedWorld);
+      TypeMask.nonNullExact(commonElements.jsStringClass, _closedWorld);
 
   @override
   TypeMask get typeType => _typeType ??=
-      new TypeMask.nonNullExact(commonElements.typeLiteralClass, _closedWorld);
+      TypeMask.nonNullExact(commonElements.typeLiteralClass, _closedWorld);
 
   @override
   TypeMask get syncStarIterableType => _syncStarIterableType ??=
-      new TypeMask.nonNullExact(commonElements.syncStarIterable, _closedWorld);
+      TypeMask.nonNullExact(commonElements.syncStarIterable, _closedWorld);
 
   @override
-  TypeMask get asyncFutureType =>
-      _asyncFutureType ??= new TypeMask.nonNullExact(
-          commonElements.futureImplementation, _closedWorld);
+  TypeMask get asyncFutureType => _asyncFutureType ??=
+      TypeMask.nonNullExact(commonElements.futureImplementation, _closedWorld);
 
   @override
   TypeMask get asyncStarStreamType => _asyncStarStreamType ??=
-      new TypeMask.nonNullExact(commonElements.controllerStream, _closedWorld);
+      TypeMask.nonNullExact(commonElements.controllerStream, _closedWorld);
 
   // TODO(johnniwinther): Assert that the null type has been resolved.
   @override
-  TypeMask get nullType => _nullType ??= const TypeMask.empty();
+  TypeMask get nullType => _nullType ??= TypeMask.empty();
 
   @override
-  TypeMask get emptyType => const TypeMask.nonNullEmpty();
+  TypeMask get lateSentinelType => TypeMask.nonNullEmpty(hasLateSentinel: true);
 
-  TypeMask get indexablePrimitiveType =>
-      _indexablePrimitiveType ??= new TypeMask.nonNullSubtype(
-          commonElements.jsIndexableClass, _closedWorld);
+  @override
+  TypeMask get emptyType => TypeMask.nonNullEmpty();
+
+  TypeMask get indexablePrimitiveType => _indexablePrimitiveType ??=
+      TypeMask.nonNullSubtype(commonElements.jsIndexableClass, _closedWorld);
 
   TypeMask get readableArrayType => _readableArrayType ??=
-      new TypeMask.nonNullSubclass(commonElements.jsArrayClass, _closedWorld);
+      TypeMask.nonNullSubclass(commonElements.jsArrayClass, _closedWorld);
 
   @override
   TypeMask get mutableArrayType =>
-      _mutableArrayType ??= new TypeMask.nonNullSubclass(
+      _mutableArrayType ??= TypeMask.nonNullSubclass(
           commonElements.jsMutableArrayClass, _closedWorld);
 
   TypeMask get unmodifiableArrayType =>
-      _unmodifiableArrayType ??= new TypeMask.nonNullExact(
+      _unmodifiableArrayType ??= TypeMask.nonNullExact(
           commonElements.jsUnmodifiableArrayClass, _closedWorld);
 
-  TypeMask get interceptorType =>
-      _interceptorType ??= new TypeMask.nonNullSubclass(
-          commonElements.jsInterceptorClass, _closedWorld);
+  TypeMask get interceptorType => _interceptorType ??=
+      TypeMask.nonNullSubclass(commonElements.jsInterceptorClass, _closedWorld);
 
   @override
   AbstractBool isTypedArray(TypeMask mask) {
@@ -232,37 +236,37 @@
     ClassEntity typedDataClass = _closedWorld.commonElements.typedDataClass;
     return AbstractBool.maybeOrFalse(typedDataClass != null &&
         _closedWorld.classHierarchy.isInstantiated(typedDataClass) &&
-        intersects(mask, new TypeMask.subtype(typedDataClass, _closedWorld)) &&
+        intersects(mask, TypeMask.subtype(typedDataClass, _closedWorld)) &&
         intersects(
             mask,
-            new TypeMask.subtype(
+            TypeMask.subtype(
                 _closedWorld.commonElements.jsIndexingBehaviorInterface,
                 _closedWorld)));
   }
 
   @override
   TypeMask createNonNullExact(ClassEntity cls) {
-    return new TypeMask.nonNullExact(cls, _closedWorld);
+    return TypeMask.nonNullExact(cls, _closedWorld);
   }
 
   @override
   TypeMask createNullableExact(ClassEntity cls) {
-    return new TypeMask.exact(cls, _closedWorld);
+    return TypeMask.exact(cls, _closedWorld);
   }
 
   @override
   TypeMask createNonNullSubclass(ClassEntity cls) {
-    return new TypeMask.nonNullSubclass(cls, _closedWorld);
+    return TypeMask.nonNullSubclass(cls, _closedWorld);
   }
 
   @override
   TypeMask createNonNullSubtype(ClassEntity cls) {
-    return new TypeMask.nonNullSubtype(cls, _closedWorld);
+    return TypeMask.nonNullSubtype(cls, _closedWorld);
   }
 
   @override
   TypeMask createNullableSubtype(ClassEntity cls) {
-    return new TypeMask.subtype(cls, _closedWorld);
+    return TypeMask.subtype(cls, _closedWorld);
   }
 
   @override
@@ -395,6 +399,14 @@
   TypeMask includeNull(TypeMask mask) => mask.nullable();
 
   @override
+  TypeMask excludeLateSentinel(TypeMask mask) =>
+      mask.withFlags(hasLateSentinel: false);
+
+  @override
+  TypeMask includeLateSentinel(TypeMask mask) =>
+      mask.withFlags(hasLateSentinel: true);
+
+  @override
   AbstractBool containsType(TypeMask typeMask, ClassEntity cls) {
     return AbstractBool.trueOrFalse(_containsType(typeMask, cls));
   }
@@ -443,12 +455,8 @@
       AbstractBool.trueOrMaybe(value.isEmpty);
 
   @override
-  AbstractBool isExact(TypeMask value) =>
-      AbstractBool.trueOrMaybe(value.isExact && !value.isNullable);
-
-  @override
-  AbstractBool isExactOrNull(TypeMask value) =>
-      AbstractBool.trueOrMaybe(value.isExact || _isNull(value));
+  AbstractBool isExact(TypeMask value) => AbstractBool.trueOrMaybe(
+      value.isExact && !value.isNullable && !value.hasLateSentinel);
 
   @override
   ClassEntity getExactClass(TypeMask mask) {
@@ -470,7 +478,7 @@
   @override
   AbstractValue createPrimitiveValue(
       covariant TypeMask originalValue, PrimitiveConstantValue value) {
-    return new ValueTypeMask(originalValue, value);
+    return ValueTypeMask(originalValue, value);
   }
 
   @override
@@ -484,7 +492,8 @@
     }
   }
 
-  bool _isNull(TypeMask value) => value.isNull;
+  @override
+  AbstractBool isLateSentinel(TypeMask value) => value.isLateSentinel;
 
   @override
   AbstractBool isPrimitive(TypeMask value) {
@@ -492,7 +501,7 @@
         _canBePrimitiveArray(value) ||
         _canBePrimitiveBoolean(value) ||
         _canBePrimitiveString(value) ||
-        _isNull(value));
+        value.isNull);
   }
 
   @override
@@ -518,10 +527,6 @@
     return _containsType(value, commonElements.jsBoolClass);
   }
 
-  @override
-  AbstractBool isPrimitiveArray(TypeMask value) =>
-      AbstractBool.maybeOrFalse(_canBePrimitiveArray(value));
-
   bool _canBePrimitiveArray(TypeMask value) {
     return _containsType(value, commonElements.jsArrayClass) ||
         _containsType(value, commonElements.jsFixedArrayClass) ||
@@ -580,25 +585,29 @@
 
   @override
   AbstractBool isInteger(TypeMask value) {
-    return AbstractBool.trueOrMaybe(
-        value.containsOnlyInt(_closedWorld) && !value.isNullable);
+    return AbstractBool.trueOrMaybe(value.containsOnlyInt(_closedWorld) &&
+        !value.isNullable &&
+        !value.hasLateSentinel);
   }
 
   @override
   AbstractBool isUInt32(TypeMask value) {
     return AbstractBool.trueOrMaybe(!value.isNullable &&
+        !value.hasLateSentinel &&
         _isInstanceOfOrNull(value, commonElements.jsUInt32Class));
   }
 
   @override
   AbstractBool isUInt31(TypeMask value) {
     return AbstractBool.trueOrMaybe(!value.isNullable &&
+        !value.hasLateSentinel &&
         _isInstanceOfOrNull(value, commonElements.jsUInt31Class));
   }
 
   @override
   AbstractBool isPositiveInteger(TypeMask value) {
     return AbstractBool.trueOrMaybe(!value.isNullable &&
+        !value.hasLateSentinel &&
         _isInstanceOfOrNull(value, commonElements.jsPositiveIntClass));
   }
 
@@ -615,8 +624,9 @@
 
   @override
   AbstractBool isNumber(TypeMask value) {
-    return AbstractBool.trueOrMaybe(
-        value.containsOnlyNum(_closedWorld) && !value.isNullable);
+    return AbstractBool.trueOrMaybe(value.containsOnlyNum(_closedWorld) &&
+        !value.isNullable &&
+        !value.hasLateSentinel);
   }
 
   @override
@@ -629,8 +639,9 @@
 
   @override
   AbstractBool isBoolean(TypeMask value) {
-    return AbstractBool.trueOrMaybe(
-        value.containsOnlyBool(_closedWorld) && !value.isNullable);
+    return AbstractBool.trueOrMaybe(value.containsOnlyBool(_closedWorld) &&
+        !value.isNullable &&
+        !value.hasLateSentinel);
   }
 
   @override
@@ -643,7 +654,7 @@
 
   @override
   AbstractBool isTruthy(TypeMask value) {
-    if (value is ValueTypeMask && !value.isNullable) {
+    if (value is ValueTypeMask && !value.isNullable && !value.hasLateSentinel) {
       PrimitiveConstantValue constant = value.value;
       if (constant is BoolConstantValue) {
         return constant.boolValue ? AbstractBool.True : AbstractBool.False;
@@ -655,8 +666,9 @@
 
   @override
   AbstractBool isString(TypeMask value) {
-    return AbstractBool.trueOrMaybe(
-        value.containsOnlyString(_closedWorld) && !value.isNullable);
+    return AbstractBool.trueOrMaybe(value.containsOnlyString(_closedWorld) &&
+        !value.isNullable &&
+        !value.hasLateSentinel);
   }
 
   @override
@@ -672,7 +684,7 @@
     return _isIndexablePrimitive(value) ||
         _isNumberOrNull(value) ||
         _isBooleanOrNull(value) ||
-        _isNull(value);
+        value.isNull;
   }
 
   @override
@@ -731,13 +743,13 @@
       MemberEntity allocationElement,
       AbstractValue elementType,
       int length) {
-    return new ContainerTypeMask(
+    return ContainerTypeMask(
         forwardTo, allocationNode, allocationElement, elementType, length);
   }
 
   @override
   AbstractValue unionOfMany(Iterable<AbstractValue> values) {
-    TypeMask result = const TypeMask.nonNullEmpty();
+    TypeMask result = TypeMask.nonNullEmpty();
     for (TypeMask value in values) {
       result = result.union(value, this);
     }
@@ -748,18 +760,18 @@
   AbstractValue computeReceiver(Iterable<MemberEntity> members) {
     assert(_closedWorld.classHierarchy
         .hasAnyStrictSubclass(_closedWorld.commonElements.objectClass));
-    return new TypeMask.unionOf(
+    return TypeMask.unionOf(
         members.expand((MemberEntity element) {
           ClassEntity cls = element.enclosingClass;
           return [cls]..addAll(_closedWorld.mixinUsesOf(cls));
         }).map((cls) {
           if (_closedWorld.commonElements.jsNullClass == cls) {
-            return const TypeMask.empty();
+            return TypeMask.empty();
           } else if (_closedWorld.classHierarchy.isInstantiated(cls)) {
-            return new TypeMask.nonNullSubclass(cls, _closedWorld);
+            return TypeMask.nonNullSubclass(cls, _closedWorld);
           } else {
             // TODO(johnniwinther): Avoid the need for this case.
-            return const TypeMask.empty();
+            return TypeMask.empty();
           }
         }),
         this);
@@ -880,7 +892,7 @@
   @override
   AbstractValue createMapValue(AbstractValue forwardTo, Object allocationNode,
       MemberEntity allocationElement, AbstractValue key, AbstractValue value) {
-    return new MapTypeMask(
+    return MapTypeMask(
         forwardTo, allocationNode, allocationElement, key, value);
   }
 
@@ -892,14 +904,14 @@
       AbstractValue key,
       AbstractValue value,
       Map<String, AbstractValue> mappings) {
-    return new DictionaryTypeMask(
-        forwardTo, allocationNode, allocationElement, key, value, mappings);
+    return DictionaryTypeMask(forwardTo, allocationNode, allocationElement, key,
+        value, Map.from(mappings));
   }
 
   @override
   AbstractValue createSetValue(AbstractValue forwardTo, Object allocationNode,
       MemberEntity allocationElement, AbstractValue elementType) {
-    return new SetTypeMask(
+    return SetTypeMask(
         forwardTo, allocationNode, allocationElement, elementType);
   }
 
@@ -963,8 +975,8 @@
 
   @override
   TypeMask readAbstractValueFromDataSource(DataSource source) {
-    return source.readCached<TypeMask>(
-        () => new TypeMask.readFromDataSource(source, this));
+    return source
+        .readCached<TypeMask>(() => TypeMask.readFromDataSource(source, this));
   }
 
   @override
@@ -985,14 +997,21 @@
     //     can be really long and mess up the layout.
     // Capitalize Null to emphasize that it's the null type mask and not
     // a null value we accidentally printed out.
-    if (type.isEmptyOrNull) return type.isNullable ? 'Null' : 'Empty';
+    if (type.isEmpty) return 'Empty';
+    if (type.isEmptyOrFlagged) {
+      return [
+        if (type.isNullable) 'Null',
+        if (type.hasLateSentinel) '\$',
+      ].join('');
+    }
     String nullFlag = type.isNullable ? '?' : '';
     String subFlag = type.isExact
         ? ''
         : type.isSubclass
             ? '+'
             : '*';
-    return '${type.base.name}$nullFlag$subFlag';
+    String sentinelFlag = type.hasLateSentinel ? '\$' : '';
+    return '${type.base.name}$nullFlag$subFlag$sentinelFlag';
   }
   if (type is UnionTypeMask) {
     return type.disjointMasks.map((m) => formatType(dartTypes, m)).join(' | ');
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/set_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/set_type_mask.dart
index cfe96da..bfa9098 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/set_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/set_type_mask.dart
@@ -24,19 +24,19 @@
   // The element type of this set.
   final TypeMask elementType;
 
-  SetTypeMask(this.forwardTo, this.allocationNode, this.allocationElement,
+  const SetTypeMask(this.forwardTo, this.allocationNode, this.allocationElement,
       this.elementType);
 
   /// Deserializes a [SetTypeMask] object from [source].
   factory SetTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
-    TypeMask forwardTo = new TypeMask.readFromDataSource(source, domain);
+    TypeMask forwardTo = TypeMask.readFromDataSource(source, domain);
     ir.TreeNode allocationNode = source.readTreeNodeOrNull();
     MemberEntity allocationElement = source.readMemberOrNull();
-    TypeMask elementType = new TypeMask.readFromDataSource(source, domain);
+    TypeMask elementType = TypeMask.readFromDataSource(source, domain);
     source.end(tag);
-    return new SetTypeMask(
+    return SetTypeMask(
         forwardTo, allocationNode, allocationElement, elementType);
   }
 
@@ -53,16 +53,20 @@
   }
 
   @override
-  TypeMask nullable() => isNullable
-      ? this
-      : new SetTypeMask(
-          forwardTo.nullable(), allocationNode, allocationElement, elementType);
-
-  @override
-  TypeMask nonNullable() => isNullable
-      ? new SetTypeMask(forwardTo.nonNullable(), allocationNode,
-          allocationElement, elementType)
-      : this;
+  SetTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    return SetTypeMask(
+        forwardTo.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel),
+        allocationNode,
+        allocationElement,
+        elementType);
+  }
 
   @override
   bool get isSet => true;
@@ -71,45 +75,29 @@
   bool get isExact => true;
 
   @override
-  bool equalsDisregardNull(other) {
-    if (other is! SetTypeMask) return false;
-    return super.equalsDisregardNull(other) &&
-        allocationNode == other.allocationNode &&
-        elementType == other.elementType;
-  }
-
-  @override
-  TypeMask intersection(TypeMask other, CommonMasks domain) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
-    if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
-    return forwardIntersection.isNullable ? nullable() : nonNullable();
-  }
-
-  @override
-  TypeMask union(dynamic other, CommonMasks domain) {
-    if (this == other) {
-      return this;
-    } else if (equalsDisregardNull(other)) {
-      return other.isNullable ? other : this;
-    } else if (other.isEmptyOrNull) {
-      return other.isNullable ? this.nullable() : this;
-    } else if (other.isSet &&
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+      {bool isNullable, bool hasLateSentinel}) {
+    assert(isNullable != null);
+    assert(hasLateSentinel != null);
+    if (other is SetTypeMask &&
         elementType != null &&
         other.elementType != null) {
       TypeMask newElementType = elementType.union(other.elementType, domain);
       TypeMask newForwardTo = forwardTo.union(other.forwardTo, domain);
-      return new SetTypeMask(newForwardTo, null, null, newElementType);
-    } else {
-      return forwardTo.union(other, domain);
+      return SetTypeMask(newForwardTo, null, null, newElementType);
     }
+    return null;
   }
 
   @override
-  bool operator ==(other) => super == other;
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! SetTypeMask) return false;
+    return super == other && elementType == other.elementType;
+  }
 
   @override
-  int get hashCode =>
-      computeHashCode(allocationNode, isNullable, elementType, forwardTo);
+  int get hashCode => Hashing.objectHash(elementType, super.hashCode);
 
   @override
   String toString() => 'Set($forwardTo, element: $elementType)';
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart
index 7fd62a8..7b62f9c 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart
@@ -25,7 +25,7 @@
   bool needsNoSuchMethodHandling(Selector selector, JClosedWorld world) {
     if (isAll) {
       TypeMask mask =
-          new TypeMask.subclass(world.commonElements.objectClass, world);
+          TypeMask.subclass(world.commonElements.objectClass, world);
       return mask.needsNoSuchMethodHandling(selector, world);
     }
     for (TypeMask mask in _masks) {
@@ -44,7 +44,7 @@
       _masks = null;
       return true;
     }
-    _masks ??= new Set<TypeMask>();
+    _masks ??= {};
     return _masks.add(mask);
   }
 
@@ -65,12 +65,12 @@
 
   @override
   AbstractValueDomain createDomain(JClosedWorld closedWorld) {
-    return new CommonMasks(closedWorld);
+    return CommonMasks(closedWorld);
   }
 
   @override
   SelectorConstraintsStrategy createSelectorStrategy() {
-    return new TypeMaskSelectorStrategy();
+    return TypeMaskSelectorStrategy();
   }
 }
 
@@ -80,8 +80,7 @@
   @override
   UniverseSelectorConstraints createSelectorConstraints(
       Selector selector, Object initialConstraint) {
-    return new IncreasingTypeMaskSet()
-      ..addReceiverConstraint(initialConstraint);
+    return IncreasingTypeMaskSet()..addReceiverConstraint(initialConstraint);
   }
 
   @override
@@ -109,31 +108,34 @@
 /// operations on it are not guaranteed to be precise and they may
 /// yield conservative answers that contain too many classes.
 abstract class TypeMask implements AbstractValue {
-  factory TypeMask(
-      ClassEntity base, int kind, bool isNullable, CommonMasks domain) {
-    return new FlatTypeMask.normalized(
-        base, (kind << 1) | (isNullable ? 1 : 0), domain);
-  }
+  const TypeMask();
 
-  const factory TypeMask.empty() = FlatTypeMask.empty;
+  factory TypeMask.empty({bool hasLateSentinel: false}) =>
+      FlatTypeMask.empty(hasLateSentinel: hasLateSentinel);
 
-  factory TypeMask.exact(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.exact(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     assert(
         closedWorld.classHierarchy.isInstantiated(base),
         failedAt(
             base ?? CURRENT_ELEMENT_SPANNABLE,
             "Cannot create exact type mask for uninstantiated "
             "class $base.\n${closedWorld.classHierarchy.dump(base)}"));
-    return new FlatTypeMask.exact(base, closedWorld);
+    return FlatTypeMask.exact(base, closedWorld,
+        hasLateSentinel: hasLateSentinel);
   }
 
-  factory TypeMask.exactOrEmpty(ClassEntity base, JClosedWorld closedWorld) {
-    if (closedWorld.classHierarchy.isInstantiated(base))
-      return new FlatTypeMask.exact(base, closedWorld);
-    return const TypeMask.empty();
+  factory TypeMask.exactOrEmpty(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
+    if (closedWorld.classHierarchy.isInstantiated(base)) {
+      return FlatTypeMask.exact(base, closedWorld,
+          hasLateSentinel: hasLateSentinel);
+    }
+    return TypeMask.empty(hasLateSentinel: hasLateSentinel);
   }
 
-  factory TypeMask.subclass(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.subclass(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     assert(
         closedWorld.classHierarchy.isInstantiated(base),
         failedAt(
@@ -142,50 +144,62 @@
             "class $base.\n${closedWorld.classHierarchy.dump(base)}"));
     ClassEntity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
-      return new TypeMask.empty();
+      return TypeMask.empty(hasLateSentinel: hasLateSentinel);
     } else if (closedWorld.classHierarchy.hasAnyStrictSubclass(topmost)) {
-      return new FlatTypeMask.subclass(topmost, closedWorld);
+      return FlatTypeMask.subclass(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     } else {
-      return new TypeMask.exact(topmost, closedWorld);
+      return TypeMask.exact(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
   }
 
-  factory TypeMask.subtype(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.subtype(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     ClassEntity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
     if (topmost == null) {
-      return new TypeMask.empty();
+      return TypeMask.empty(hasLateSentinel: hasLateSentinel);
     }
     if (closedWorld.classHierarchy.hasOnlySubclasses(topmost)) {
-      return new TypeMask.subclass(topmost, closedWorld);
+      return TypeMask.subclass(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
     if (closedWorld.classHierarchy.hasAnyStrictSubtype(topmost)) {
-      return new FlatTypeMask.subtype(topmost, closedWorld);
+      return FlatTypeMask.subtype(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     } else {
-      return new TypeMask.exact(topmost, closedWorld);
+      return TypeMask.exact(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
   }
 
-  const factory TypeMask.nonNullEmpty() = FlatTypeMask.nonNullEmpty;
+  factory TypeMask.nonNullEmpty({bool hasLateSentinel: false}) =>
+      FlatTypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
 
-  factory TypeMask.nonNullExact(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.nonNullExact(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     assert(
         closedWorld.classHierarchy.isInstantiated(base),
         failedAt(
             base ?? CURRENT_ELEMENT_SPANNABLE,
             "Cannot create exact type mask for uninstantiated "
             "class $base.\n${closedWorld.classHierarchy.dump(base)}"));
-    return new FlatTypeMask.nonNullExact(base, closedWorld);
+    return FlatTypeMask.nonNullExact(base, closedWorld,
+        hasLateSentinel: hasLateSentinel);
   }
 
   factory TypeMask.nonNullExactOrEmpty(
-      ClassEntity base, JClosedWorld closedWorld) {
+      ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     if (closedWorld.classHierarchy.isInstantiated(base)) {
-      return new FlatTypeMask.nonNullExact(base, closedWorld);
+      return FlatTypeMask.nonNullExact(base, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
-    return const TypeMask.nonNullEmpty();
+    return TypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
   }
 
-  factory TypeMask.nonNullSubclass(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.nonNullSubclass(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     assert(
         closedWorld.classHierarchy.isInstantiated(base),
         failedAt(
@@ -194,26 +208,32 @@
             "class $base.\n${closedWorld.classHierarchy.dump(base)}"));
     ClassEntity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
-      return new TypeMask.nonNullEmpty();
+      return TypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
     } else if (closedWorld.classHierarchy.hasAnyStrictSubclass(topmost)) {
-      return new FlatTypeMask.nonNullSubclass(topmost, closedWorld);
+      return FlatTypeMask.nonNullSubclass(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     } else {
-      return new TypeMask.nonNullExact(topmost, closedWorld);
+      return TypeMask.nonNullExact(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
   }
 
-  factory TypeMask.nonNullSubtype(ClassEntity base, JClosedWorld closedWorld) {
+  factory TypeMask.nonNullSubtype(ClassEntity base, JClosedWorld closedWorld,
+      {bool hasLateSentinel: false}) {
     ClassEntity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
     if (topmost == null) {
-      return new TypeMask.nonNullEmpty();
+      return TypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
     }
     if (closedWorld.classHierarchy.hasOnlySubclasses(topmost)) {
-      return new TypeMask.nonNullSubclass(topmost, closedWorld);
+      return TypeMask.nonNullSubclass(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
     if (closedWorld.classHierarchy.hasAnyStrictSubtype(topmost)) {
-      return new FlatTypeMask.nonNullSubtype(topmost, closedWorld);
+      return FlatTypeMask.nonNullSubtype(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     } else {
-      return new TypeMask.nonNullExact(topmost, closedWorld);
+      return TypeMask.nonNullExact(topmost, closedWorld,
+          hasLateSentinel: hasLateSentinel);
     }
   }
 
@@ -226,21 +246,21 @@
     TypeMaskKind kind = source.readEnum(TypeMaskKind.values);
     switch (kind) {
       case TypeMaskKind.flat:
-        return new FlatTypeMask.readFromDataSource(source, domain);
+        return FlatTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.union:
-        return new UnionTypeMask.readFromDataSource(source, domain);
+        return UnionTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.container:
-        return new ContainerTypeMask.readFromDataSource(source, domain);
+        return ContainerTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.set:
-        return new SetTypeMask.readFromDataSource(source, domain);
+        return SetTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.map:
-        return new MapTypeMask.readFromDataSource(source, domain);
+        return MapTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.dictionary:
-        return new DictionaryTypeMask.readFromDataSource(source, domain);
+        return DictionaryTypeMask.readFromDataSource(source, domain);
       case TypeMaskKind.value:
-        return new ValueTypeMask.readFromDataSource(source, domain);
+        return ValueTypeMask.readFromDataSource(source, domain);
     }
-    throw new UnsupportedError("Unexpected TypeMaskKind $kind.");
+    throw UnsupportedError("Unexpected TypeMaskKind $kind.");
   }
 
   /// Serializes this [TypeMask] to [sink].
@@ -271,7 +291,7 @@
       TypeMask mask, JClosedWorld closedWorld) {
     mask = nonForwardingMask(mask);
     if (mask is FlatTypeMask) {
-      if (mask.isEmptyOrNull) return null;
+      if (mask.isEmptyOrFlagged) return null;
       if (mask.base == closedWorld.commonElements.nullClass) {
         return 'The class ${mask.base} is not canonicalized.';
       }
@@ -308,10 +328,17 @@
   }
 
   /// Returns a nullable variant of [this] type mask.
-  TypeMask nullable();
+  TypeMask nullable() => withFlags(isNullable: true);
 
   /// Returns a non-nullable variant of [this] type mask.
-  TypeMask nonNullable();
+  TypeMask nonNullable() => withFlags(isNullable: false);
+
+  /// Returns a variant of [this] type mask whose value is neither `null` nor
+  /// the late sentinel.
+  TypeMask withoutFlags() =>
+      withFlags(isNullable: false, hasLateSentinel: false);
+
+  TypeMask withFlags({bool isNullable, bool hasLateSentinel});
 
   /// Whether nothing matches this mask, not even null.
   bool get isEmpty;
@@ -322,8 +349,15 @@
   /// Whether the only possible value in this mask is Null.
   bool get isNull;
 
-  /// Whether [isEmpty] or [isNull] is true.
-  bool get isEmptyOrNull;
+  /// Whether [this] is a sentinel for an uninitialized late variable.
+  AbstractBool get isLateSentinel;
+
+  /// Whether a late sentinel is a valid value of this mask.
+  bool get hasLateSentinel => isLateSentinel.isPotentiallyTrue;
+
+  /// Whether [this] mask is empty or only represents values tracked by flags
+  /// (i.e. `null` and the late sentinel).
+  bool get isEmptyOrFlagged;
 
   /// Whether this mask only includes instances of an exact class, and none of
   /// it's subclasses or subtypes.
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/union_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/union_type_mask.dart
index dddd0ed..3a647ea 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/union_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/union_type_mask.dart
@@ -4,7 +4,7 @@
 
 part of masks;
 
-class UnionTypeMask implements TypeMask {
+class UnionTypeMask extends TypeMask {
   /// Tag used for identifying serialized [UnionTypeMask] objects in a
   /// debugging data stream.
   static const String tag = 'union-type-mask';
@@ -22,21 +22,32 @@
   @override
   final bool isNullable;
 
-  UnionTypeMask._internal(this.disjointMasks, this.isNullable) {
-    assert(disjointMasks.length > 1);
-    assert(disjointMasks.every((TypeMask mask) => !mask.isUnion));
-    assert(disjointMasks.every((TypeMask mask) => !mask.isNullable));
-  }
+  @override
+  final bool hasLateSentinel;
+
+  @override
+  AbstractBool get isLateSentinel => AbstractBool.maybeOrFalse(hasLateSentinel);
+
+  UnionTypeMask._internal(this.disjointMasks,
+      {this.isNullable, this.hasLateSentinel})
+      : assert(isNullable != null),
+        assert(hasLateSentinel != null),
+        assert(disjointMasks.length > 1),
+        assert(disjointMasks.every((TypeMask mask) => !mask.isUnion)),
+        assert(disjointMasks.every((TypeMask mask) => !mask.isNullable)),
+        assert(disjointMasks.every((TypeMask mask) => !mask.hasLateSentinel));
 
   /// Deserializes a [UnionTypeMask] object from [source].
   factory UnionTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
     List<FlatTypeMask> disjointMasks =
-        source.readList(() => new TypeMask.readFromDataSource(source, domain));
+        source.readList(() => TypeMask.readFromDataSource(source, domain));
     bool isNullable = source.readBool();
+    bool hasLateSentinel = source.readBool();
     source.end(tag);
-    return new UnionTypeMask._internal(disjointMasks, isNullable);
+    return UnionTypeMask._internal(disjointMasks,
+        isNullable: isNullable, hasLateSentinel: hasLateSentinel);
   }
 
   /// Serializes this [UnionTypeMask] to [sink].
@@ -47,6 +58,7 @@
     sink.writeList(
         disjointMasks, (FlatTypeMask mask) => mask.writeToDataSink(sink));
     sink.writeBool(isNullable);
+    sink.writeBool(hasLateSentinel);
     sink.end(tag);
   }
 
@@ -55,15 +67,21 @@
         (mask) => TypeMask.assertIsNormalized(mask, domain._closedWorld)));
     List<FlatTypeMask> disjoint = <FlatTypeMask>[];
     bool isNullable = masks.any((TypeMask mask) => mask.isNullable);
+    bool hasLateSentinel = masks.any((TypeMask mask) => mask.hasLateSentinel);
     unionOfHelper(masks, disjoint, domain);
     if (disjoint.isEmpty)
-      return isNullable ? TypeMask.empty() : TypeMask.nonNullEmpty();
+      return isNullable
+          ? TypeMask.empty(hasLateSentinel: hasLateSentinel)
+          : TypeMask.nonNullEmpty(hasLateSentinel: hasLateSentinel);
     if (disjoint.length > MAX_UNION_LENGTH) {
-      return flatten(disjoint, isNullable, domain);
+      return flatten(disjoint, domain,
+          includeNull: isNullable, includeLateSentinel: hasLateSentinel);
     }
     if (disjoint.length == 1)
-      return isNullable ? disjoint[0].nullable() : disjoint[0];
-    UnionTypeMask union = new UnionTypeMask._internal(disjoint, isNullable);
+      return disjoint.single
+          .withFlags(isNullable: isNullable, hasLateSentinel: hasLateSentinel);
+    UnionTypeMask union = UnionTypeMask._internal(disjoint,
+        isNullable: isNullable, hasLateSentinel: hasLateSentinel);
     assert(TypeMask.assertIsNormalized(union, domain._closedWorld));
     return union;
   }
@@ -73,7 +91,7 @@
     // TODO(johnniwinther): Impose an order on the mask to ensure subclass masks
     // are preferred to subtype masks.
     for (TypeMask mask in masks) {
-      mask = TypeMask.nonForwardingMask(mask).nonNullable();
+      mask = TypeMask.nonForwardingMask(mask).withoutFlags();
       if (mask.isUnion) {
         UnionTypeMask union = mask;
         unionOfHelper(union.disjointMasks, disjoint, domain);
@@ -121,8 +139,11 @@
     }
   }
 
-  static TypeMask flatten(
-      List<FlatTypeMask> masks, bool includeNull, CommonMasks domain) {
+  static TypeMask flatten(List<FlatTypeMask> masks, CommonMasks domain,
+      {bool includeNull, bool includeLateSentinel}) {
+    assert(includeNull != null);
+    assert(includeLateSentinel != null);
+
     // TODO(johnniwinther): Move this computation to [ClosedWorld] and use the
     // class set structures.
     if (masks.isEmpty) throw ArgumentError.value(masks, 'masks');
@@ -136,7 +157,7 @@
 
     // Compute the best candidate and its kind.
     ClassEntity bestElement;
-    int bestKind;
+    _FlatTypeMaskKind bestKind;
     int bestSize;
     for (ClassEntity candidate in candidates) {
       bool isInstantiatedStrictSubclass(cls) =>
@@ -145,13 +166,13 @@
           domain._closedWorld.classHierarchy.isSubclassOf(cls, candidate);
 
       int size;
-      int kind;
+      _FlatTypeMaskKind kind;
       if (useSubclass && masksBases.every(isInstantiatedStrictSubclass)) {
         // If both [this] and [other] are subclasses of the supertype,
         // then we prefer to construct a subclass type mask because it
         // will always be at least as small as the corresponding
         // subtype type mask.
-        kind = FlatTypeMask.SUBCLASS;
+        kind = _FlatTypeMaskKind.subclass;
         // TODO(sigmund, johnniwinther): computing length here (and below) is
         // expensive. If we can't prevent `flatten` from being called a lot, it
         // might be worth caching results.
@@ -160,7 +181,7 @@
         assert(size <=
             domain._closedWorld.classHierarchy.strictSubtypeCount(candidate));
       } else {
-        kind = FlatTypeMask.SUBTYPE;
+        kind = _FlatTypeMaskKind.subtype;
         size = domain._closedWorld.classHierarchy.strictSubtypeCount(candidate);
       }
       // Update the best candidate if the new one is better.
@@ -170,56 +191,67 @@
         bestKind = kind;
       }
     }
-    return new TypeMask(bestElement, bestKind, includeNull, domain);
+    int flags = FlatTypeMask._computeFlags(bestKind,
+        isNullable: includeNull, hasLateSentinel: includeLateSentinel);
+    return FlatTypeMask.normalized(bestElement, flags, domain);
   }
 
   @override
-  TypeMask union(dynamic other, CommonMasks domain) {
+  TypeMask union(TypeMask other, CommonMasks domain) {
     other = TypeMask.nonForwardingMask(other);
+    bool isNullable = this.isNullable || other.isNullable;
+    bool hasLateSentinel = this.hasLateSentinel || other.hasLateSentinel;
     if (other is UnionTypeMask) {
-      if (_containsNonNullableUnion(other)) {
-        return other.isNullable ? nullable() : this;
+      if (_containsDisjointMasks(other)) {
+        return withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
-      if (other._containsNonNullableUnion(this)) {
-        return isNullable ? other.nullable() : other;
+      if (other._containsDisjointMasks(this)) {
+        return other.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
     } else {
-      if (disjointMasks.contains(other.nonNullable())) {
-        return other.isNullable ? nullable() : this;
+      if (disjointMasks.contains(other.withoutFlags())) {
+        return withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
     }
 
-    List<FlatTypeMask> newList = new List<FlatTypeMask>.of(disjointMasks);
-    if (!other.isUnion) {
-      newList.add(other);
-    } else {
-      assert(other is UnionTypeMask);
+    List<FlatTypeMask> newList = List<FlatTypeMask>.of(disjointMasks);
+    if (other is UnionTypeMask) {
       newList.addAll(other.disjointMasks);
+    } else {
+      newList.add(other);
     }
-    TypeMask newMask = new TypeMask.unionOf(newList, domain);
-    return isNullable || other.isNullable ? newMask.nullable() : newMask;
+    TypeMask newMask = TypeMask.unionOf(newList, domain);
+    return newMask.withFlags(
+        isNullable: isNullable, hasLateSentinel: hasLateSentinel);
   }
 
   @override
-  TypeMask intersection(dynamic other, CommonMasks domain) {
+  TypeMask intersection(TypeMask other, CommonMasks domain) {
     other = TypeMask.nonForwardingMask(other);
+    bool isNullable = this.isNullable && other.isNullable;
+    bool hasLateSentinel = this.hasLateSentinel && other.hasLateSentinel;
     if (other is UnionTypeMask) {
-      if (_containsNonNullableUnion(other)) {
-        return isNullable ? other : other.nonNullable();
+      if (_containsDisjointMasks(other)) {
+        return other.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
-      if (other._containsNonNullableUnion(this)) {
-        return other.isNullable ? this : nonNullable();
+      if (other._containsDisjointMasks(this)) {
+        return withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
     } else {
-      TypeMask otherNonNullable = other.nonNullable();
-      if (disjointMasks.contains(otherNonNullable)) {
-        return isNullable ? other : otherNonNullable;
+      if (disjointMasks.contains(other.withoutFlags())) {
+        return other.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       }
     }
 
     List<TypeMask> intersections = <TypeMask>[];
     for (TypeMask current in disjointMasks) {
-      if (other.isUnion) {
+      if (other is UnionTypeMask) {
         if (other.disjointMasks.contains(current)) {
           intersections.add(current);
         } else {
@@ -232,12 +264,14 @@
       }
     }
     TypeMask newMask = TypeMask.unionOf(intersections, domain);
-    return isNullable && other.isNullable ? newMask.nullable() : newMask;
+    return newMask.withFlags(
+        isNullable: isNullable, hasLateSentinel: hasLateSentinel);
   }
 
   @override
   bool isDisjoint(TypeMask other, JClosedWorld closedWorld) {
     if (isNullable && other.isNullable) return false;
+    if (hasLateSentinel && other.hasLateSentinel) return false;
     for (var current in disjointMasks) {
       if (!current.isDisjoint(other, closedWorld)) return false;
     }
@@ -245,21 +279,20 @@
   }
 
   @override
-  TypeMask nullable() {
-    if (isNullable) return this;
-    List<FlatTypeMask> newList = new List<FlatTypeMask>.of(disjointMasks);
-    return new UnionTypeMask._internal(newList, true);
+  UnionTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    List<FlatTypeMask> newList = List<FlatTypeMask>.of(disjointMasks);
+    return UnionTypeMask._internal(newList,
+        isNullable: isNullable, hasLateSentinel: hasLateSentinel);
   }
 
   @override
-  TypeMask nonNullable() {
-    if (!isNullable) return this;
-    List<FlatTypeMask> newList = new List<FlatTypeMask>.of(disjointMasks);
-    return new UnionTypeMask._internal(newList, false);
-  }
-
-  @override
-  bool get isEmptyOrNull => false;
+  bool get isEmptyOrFlagged => false;
   @override
   bool get isEmpty => false;
   @override
@@ -292,7 +325,8 @@
     assert(!other.isUnion);
     // Likewise, nullness should be covered.
     assert(isNullable || !other.isNullable);
-    other = other.nonNullable();
+    assert(hasLateSentinel || !other.hasLateSentinel);
+    other = other.withoutFlags();
     // Ensure the cheap test fails.
     assert(!disjointMasks.any((mask) => mask.containsMask(other, closedWorld)));
     // If we cover object, we should never get here.
@@ -321,6 +355,7 @@
   bool isInMask(TypeMask other, JClosedWorld closedWorld) {
     other = TypeMask.nonForwardingMask(other);
     if (isNullable && !other.isNullable) return false;
+    if (hasLateSentinel && !other.hasLateSentinel) return false;
     if (other.isUnion) {
       UnionTypeMask union = other;
       return disjointMasks.every((FlatTypeMask disjointMask) {
@@ -341,8 +376,9 @@
   bool containsMask(TypeMask other, JClosedWorld closedWorld) {
     other = TypeMask.nonForwardingMask(other);
     if (other.isNullable && !isNullable) return false;
+    if (other.hasLateSentinel && !hasLateSentinel) return false;
     if (other.isUnion) return other.isInMask(this, closedWorld);
-    other = other.nonNullable();
+    other = other.withoutFlags();
     bool contained =
         disjointMasks.any((mask) => mask.containsMask(other, closedWorld));
     if (PERFORM_EXTRA_CONTAINS_CHECK &&
@@ -419,7 +455,8 @@
   MemberEntity locateSingleMember(Selector selector, CommonMasks domain) {
     MemberEntity candidate;
     for (FlatTypeMask mask in disjointMasks) {
-      if (isNullable) mask = mask.nullable();
+      mask = mask.withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
       MemberEntity current = mask.locateSingleMember(selector, domain);
       if (current == null) {
         return null;
@@ -436,6 +473,7 @@
   String toString() {
     String masksString = [
       if (isNullable) 'null',
+      if (hasLateSentinel) 'sentinel',
       ...disjointMasks.map((TypeMask mask) => mask.toString()).toList()..sort(),
     ].join(", ");
     return 'Union($masksString)';
@@ -447,21 +485,19 @@
 
     return other is UnionTypeMask &&
         other.isNullable == isNullable &&
+        other.hasLateSentinel == hasLateSentinel &&
         other.disjointMasks.length == disjointMasks.length &&
-        _containsNonNullableUnion(other);
+        _containsDisjointMasks(other);
   }
 
   @override
   int get hashCode {
-    int hashCode = isNullable ? 86 : 43;
     // The order of the masks in [disjointMasks] must not affect the
     // hashCode.
-    for (var mask in disjointMasks) {
-      hashCode = (hashCode ^ mask.hashCode) & 0x3fffffff;
-    }
-    return hashCode;
+    return Hashing.setHash(
+        disjointMasks, Hashing.objectsHash(isNullable, hasLateSentinel));
   }
 
-  bool _containsNonNullableUnion(UnionTypeMask other) =>
+  bool _containsDisjointMasks(UnionTypeMask other) =>
       other.disjointMasks.every((e) => disjointMasks.contains(e));
 }
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/value_type_mask.dart b/pkg/compiler/lib/src/inferrer/typemasks/value_type_mask.dart
index 38486ab..62b6747 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/value_type_mask.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/value_type_mask.dart
@@ -13,16 +13,16 @@
   final TypeMask forwardTo;
   final PrimitiveConstantValue value;
 
-  ValueTypeMask(this.forwardTo, this.value);
+  const ValueTypeMask(this.forwardTo, this.value);
 
   /// Deserializes a [ValueTypeMask] object from [source].
   factory ValueTypeMask.readFromDataSource(
       DataSource source, CommonMasks domain) {
     source.begin(tag);
-    TypeMask forwardTo = new TypeMask.readFromDataSource(source, domain);
+    TypeMask forwardTo = TypeMask.readFromDataSource(source, domain);
     ConstantValue constant = source.readConstant();
     source.end(tag);
-    return new ValueTypeMask(forwardTo, constant);
+    return ValueTypeMask(forwardTo, constant);
   }
 
   /// Serializes this [ValueTypeMask] to [sink].
@@ -36,40 +36,45 @@
   }
 
   @override
-  TypeMask nullable() {
-    return isNullable ? this : new ValueTypeMask(forwardTo.nullable(), value);
-  }
-
-  @override
-  TypeMask nonNullable() {
-    return isNullable
-        ? new ValueTypeMask(forwardTo.nonNullable(), value)
-        : this;
+  ValueTypeMask withFlags({bool isNullable, bool hasLateSentinel}) {
+    isNullable ??= this.isNullable;
+    hasLateSentinel ??= this.hasLateSentinel;
+    if (isNullable == this.isNullable &&
+        hasLateSentinel == this.hasLateSentinel) {
+      return this;
+    }
+    return ValueTypeMask(
+        forwardTo.withFlags(
+            isNullable: isNullable, hasLateSentinel: hasLateSentinel),
+        value);
   }
 
   @override
   bool get isValue => true;
 
   @override
-  bool equalsDisregardNull(other) {
+  TypeMask _unionSpecialCases(TypeMask other, CommonMasks domain,
+      {bool isNullable, bool hasLateSentinel}) {
+    assert(isNullable != null);
+    assert(hasLateSentinel != null);
+    if (other is ValueTypeMask &&
+        forwardTo.withoutFlags() == other.forwardTo.withoutFlags() &&
+        value == other.value) {
+      return withFlags(
+          isNullable: isNullable, hasLateSentinel: hasLateSentinel);
+    }
+    return null;
+  }
+
+  @override
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
     if (other is! ValueTypeMask) return false;
-    return super.equalsDisregardNull(other) && value == other.value;
+    return super == other && value == other.value;
   }
 
   @override
-  TypeMask intersection(TypeMask other, CommonMasks domain) {
-    TypeMask forwardIntersection = forwardTo.intersection(other, domain);
-    if (forwardIntersection.isEmptyOrNull) return forwardIntersection;
-    return forwardIntersection.isNullable ? nullable() : nonNullable();
-  }
-
-  @override
-  bool operator ==(other) => super == other;
-
-  @override
-  int get hashCode {
-    return computeHashCode(value, isNullable, forwardTo);
-  }
+  int get hashCode => Hashing.objectHash(value, super.hashCode);
 
   @override
   String toString() {
diff --git a/pkg/compiler/lib/src/kernel/dart2js_target.dart b/pkg/compiler/lib/src/kernel/dart2js_target.dart
index 312fad7..326253f 100644
--- a/pkg/compiler/lib/src/kernel/dart2js_target.dart
+++ b/pkg/compiler/lib/src/kernel/dart2js_target.dart
@@ -62,19 +62,6 @@
   return allowedNativeTest(uri) || allowedDartLibrary();
 }
 
-int _foldLateLowerings(List<int> lowerings) =>
-    lowerings.fold(LateLowering.none, (a, b) => a | b);
-
-/// Late lowerings which the frontend performs for dart2js.
-const List<int> _allEnabledLateLowerings = [
-  LateLowering.uninitializedNonFinalInstanceField,
-  LateLowering.uninitializedFinalInstanceField,
-  LateLowering.initializedNonFinalInstanceField,
-  LateLowering.initializedFinalInstanceField,
-];
-
-final int _enabledLateLowerings = _foldLateLowerings(_allEnabledLateLowerings);
-
 /// A kernel [Target] to configure the Dart Front End for dart2js.
 class Dart2jsTarget extends Target {
   @override
@@ -90,10 +77,7 @@
   bool get enableNoSuchMethodForwarders => true;
 
   @override
-  int get enabledLateLowerings =>
-      (options != null && options!.experimentLateInstanceVariables)
-          ? LateLowering.none
-          : _enabledLateLowerings;
+  int get enabledLateLowerings => LateLowering.none;
 
   @override
   bool get supportsLateLoweringSentinel => true;
diff --git a/pkg/compiler/lib/src/kernel/transformations/late_lowering.dart b/pkg/compiler/lib/src/kernel/transformations/late_lowering.dart
index 212aac6..d2b3a00 100644
--- a/pkg/compiler/lib/src/kernel/transformations/late_lowering.dart
+++ b/pkg/compiler/lib/src/kernel/transformations/late_lowering.dart
@@ -24,7 +24,6 @@
   final CoreTypes _coreTypes;
 
   final bool _omitLateNames;
-  final bool _lowerInstanceVariables;
 
   final _Reader _readLocal;
   final _Reader _readField;
@@ -51,8 +50,6 @@
 
   LateLowering(this._coreTypes, CompilerOptions? _options)
       : _omitLateNames = _options?.omitLateNames ?? false,
-        _lowerInstanceVariables =
-            _options?.experimentLateInstanceVariables ?? false,
         _readLocal = _Reader(_coreTypes.cellReadLocal),
         _readField = _Reader(_coreTypes.cellReadField),
         _readInitialized = _Reader(_coreTypes.initializedCellRead),
@@ -72,7 +69,7 @@
       field.isLate && field.isStatic && field.initializer == null;
 
   bool _shouldLowerInstanceField(Field field) =>
-      field.isLate && !field.isStatic && _lowerInstanceVariables;
+      field.isLate && !field.isStatic;
 
   String _mangleFieldName(Field field) {
     assert(_shouldLowerInstanceField(field));
diff --git a/pkg/compiler/lib/src/options.dart b/pkg/compiler/lib/src/options.dart
index a4097df..9000dab 100644
--- a/pkg/compiler/lib/src/options.dart
+++ b/pkg/compiler/lib/src/options.dart
@@ -491,10 +491,6 @@
   /// called.
   bool experimentCallInstrumentation = false;
 
-  /// Use the dart2js lowering of late instance variables rather than the CFE
-  /// lowering.
-  bool experimentLateInstanceVariables = false;
-
   /// When null-safety is enabled, whether the compiler should emit code with
   /// unsound or sound semantics.
   ///
@@ -619,8 +615,6 @@
           _hasOption(options, Flags.experimentUnreachableMethodsThrow)
       ..experimentCallInstrumentation =
           _hasOption(options, Flags.experimentCallInstrumentation)
-      ..experimentLateInstanceVariables =
-          _hasOption(options, Flags.experimentLateInstanceVariables)
       ..generateSourceMap = !_hasOption(options, Flags.noSourceMaps)
       ..outputUri = _extractUriOption(options, '--out=')
       ..platformBinaries = platformBinaries
diff --git a/pkg/compiler/lib/src/ssa/nodes.dart b/pkg/compiler/lib/src/ssa/nodes.dart
index 47298de..ef0a3fa 100644
--- a/pkg/compiler/lib/src/ssa/nodes.dart
+++ b/pkg/compiler/lib/src/ssa/nodes.dart
@@ -1147,6 +1147,9 @@
   AbstractBool isNull(AbstractValueDomain domain) =>
       domain.isNull(instructionType);
 
+  AbstractBool isLateSentinel(AbstractValueDomain domain) =>
+      domain.isLateSentinel(instructionType);
+
   AbstractBool isConflicting(AbstractValueDomain domain) =>
       domain.isEmpty(instructionType);
 
@@ -1159,9 +1162,6 @@
   AbstractBool isPrimitiveBoolean(AbstractValueDomain domain) =>
       domain.isPrimitiveBoolean(instructionType);
 
-  AbstractBool isPrimitiveArray(AbstractValueDomain domain) =>
-      domain.isPrimitiveArray(instructionType);
-
   AbstractBool isIndexablePrimitive(AbstractValueDomain domain) =>
       domain.isIndexablePrimitive(instructionType);
 
diff --git a/pkg/compiler/lib/src/ssa/optimize.dart b/pkg/compiler/lib/src/ssa/optimize.dart
index 9faff8ee..bf83ffc 100644
--- a/pkg/compiler/lib/src/ssa/optimize.dart
+++ b/pkg/compiler/lib/src/ssa/optimize.dart
@@ -447,7 +447,8 @@
 
   ConstantValue getConstantFromType(HInstruction node) {
     if (node.isValue(_abstractValueDomain) &&
-        node.isNull(_abstractValueDomain).isDefinitelyFalse) {
+        node.isNull(_abstractValueDomain).isDefinitelyFalse &&
+        node.isLateSentinel(_abstractValueDomain).isDefinitelyFalse) {
       ConstantValue value =
           _abstractValueDomain.getPrimitiveValue(node.instructionType);
       if (value.isBool) {
@@ -1167,14 +1168,13 @@
   @override
   HInstruction visitIsLateSentinel(HIsLateSentinel node) {
     HInstruction value = node.inputs[0];
-    if (value is HConstant) {
-      return _graph.addConstantBool(
-          value.constant is LateSentinelConstantValue, _closedWorld);
+    AbstractBool isLateSentinel = value.isLateSentinel(_abstractValueDomain);
+    if (isLateSentinel.isDefinitelyTrue) {
+      return _graph.addConstantBool(true, _closedWorld);
+    } else if (isLateSentinel.isDefinitelyFalse) {
+      return _graph.addConstantBool(false, _closedWorld);
     }
 
-    // TODO(fishythefish): Simplify to `false` when the input cannot evalute to
-    // the sentinel. This can be implemented in the powerset domain.
-
     return super.visitIsLateSentinel(node);
   }
 
diff --git a/pkg/compiler/lib/src/ssa/type_builder.dart b/pkg/compiler/lib/src/ssa/type_builder.dart
index 39140be..84a46b6 100644
--- a/pkg/compiler/lib/src/ssa/type_builder.dart
+++ b/pkg/compiler/lib/src/ssa/type_builder.dart
@@ -49,7 +49,7 @@
 
   /// Create a type mask for 'trusting' a DartType. Returns `null` if there is
   /// no approximating type mask (i.e. the type mask would be `dynamic`).
-  AbstractValue trustTypeMask(DartType type) {
+  AbstractValue trustTypeMask(DartType type, {bool hasLateSentinel: false}) {
     if (type == null) return null;
     type = builder.localsHandler.substInContext(type);
     if (_closedWorld.dartTypes.isTopType(type)) return null;
@@ -59,15 +59,20 @@
     if (type is! InterfaceType) return null;
     // The type element is either a class or the void element.
     ClassEntity element = (type as InterfaceType).element;
-    return includeNull
+    AbstractValue mask = includeNull
         ? _abstractValueDomain.createNullableSubtype(element)
         : _abstractValueDomain.createNonNullSubtype(element);
+    if (hasLateSentinel) mask = _abstractValueDomain.includeLateSentinel(mask);
+    return mask;
   }
 
   /// Create an instruction to simply trust the provided type.
   HInstruction _trustType(HInstruction original, DartType type) {
     assert(type != null);
-    AbstractValue mask = trustTypeMask(type);
+    bool hasLateSentinel = _abstractValueDomain
+        .isLateSentinel(original.instructionType)
+        .isPotentiallyTrue;
+    AbstractValue mask = trustTypeMask(type, hasLateSentinel: hasLateSentinel);
     if (mask == null) return original;
     return new HTypeKnown.pinned(mask, original);
   }
diff --git a/pkg/compiler/lib/src/util/util.dart b/pkg/compiler/lib/src/util/util.dart
index 6a7894f..7c5f50b 100644
--- a/pkg/compiler/lib/src/util/util.dart
+++ b/pkg/compiler/lib/src/util/util.dart
@@ -233,15 +233,6 @@
   buffer.write(string);
 }
 
-int computeHashCode(part1, [part2, part3, part4, part5]) {
-  return (part1.hashCode ^
-          part2.hashCode ^
-          part3.hashCode ^
-          part4.hashCode ^
-          part5.hashCode) &
-      0x3fffffff;
-}
-
 class Pair<A, B> {
   final A a;
   final B b;
diff --git a/pkg/compiler/test/analyses/dart2js_allowed.json b/pkg/compiler/test/analyses/dart2js_allowed.json
index 242faa0..d9943f4 100644
--- a/pkg/compiler/test/analyses/dart2js_allowed.json
+++ b/pkg/compiler/test/analyses/dart2js_allowed.json
@@ -47,66 +47,10 @@
     "Dynamic access of 'memberContext'.": 1,
     "Dynamic access of 'name'.": 1
   },
-  "pkg/compiler/lib/src/inferrer/typemasks/container_type_mask.dart": {
-    "Dynamic access of 'isNullable'.": 2,
-    "Dynamic access of 'isEmptyOrNull'.": 1,
-    "Dynamic access of 'isContainer'.": 1,
-    "Dynamic access of 'elementType'.": 2,
-    "Dynamic access of 'length'.": 1,
-    "Dynamic access of 'forwardTo'.": 1,
-    "Dynamic access of 'allocationNode'.": 1,
-    "Dynamic access of 'allocationElement'.": 1
-  },
-  "pkg/compiler/lib/src/inferrer/typemasks/dictionary_type_mask.dart": {
-    "Dynamic access of 'isNullable'.": 2,
-    "Dynamic access of 'isEmptyOrNull'.": 1,
-    "Dynamic access of 'isDictionary'.": 1,
-    "Dynamic access of 'forwardTo'.": 2,
-    "Dynamic access of 'keyType'.": 3,
-    "Dynamic access of 'valueType'.": 3,
-    "Dynamic access of 'masks::_typeMap'.": 2,
-    "Dynamic invocation of 'containsKey'.": 1,
-    "Dynamic invocation of 'nullable'.": 2,
-    "Dynamic invocation of 'union'.": 1,
-    "Dynamic invocation of 'forEach'.": 1,
-    "Dynamic access of 'isMap'.": 1
-  },
-  "pkg/compiler/lib/src/inferrer/typemasks/forwarding_type_mask.dart": {
-    "Dynamic access of 'isNullable'.": 1
-  },
-  "pkg/compiler/lib/src/inferrer/typemasks/map_type_mask.dart": {
-    "Dynamic access of 'isNullable'.": 2,
-    "Dynamic access of 'isEmptyOrNull'.": 1,
-    "Dynamic access of 'isMap'.": 1,
-    "Dynamic access of 'keyType'.": 4,
-    "Dynamic access of 'valueType'.": 2,
-    "Dynamic access of 'forwardTo'.": 2,
-    "Dynamic access of 'isDictionary'.": 1,
-    "Dynamic invocation of 'union'.": 1,
-    "Dynamic access of 'typeMap'.": 1,
-    "Dynamic access of 'values'.": 1,
-    "Dynamic invocation of 'fold'.": 1,
-    "Dynamic access of 'allocationNode'.": 1,
-    "Dynamic access of 'allocationElement'.": 1
-  },
-  "pkg/compiler/lib/src/inferrer/typemasks/set_type_mask.dart": {
-    "Dynamic access of 'isNullable'.": 2,
-    "Dynamic access of 'isEmptyOrNull'.": 1,
-    "Dynamic access of 'isSet'.": 1,
-    "Dynamic access of 'elementType'.": 2,
-    "Dynamic access of 'forwardTo'.": 1
-  },
   "pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart": {
     "Dynamic access of 'isForwarding'.": 1,
     "Dynamic access of 'forwardTo'.": 1
   },
-  "pkg/compiler/lib/src/inferrer/typemasks/union_type_mask.dart": {
-    "Dynamic invocation of 'nonNullable'.": 2,
-    "Dynamic access of 'isNullable'.": 3,
-    "Dynamic access of 'isUnion'.": 2,
-    "Dynamic access of 'disjointMasks'.": 3,
-    "Dynamic invocation of 'contains'.": 1
-  },
   "pkg/compiler/lib/src/helpers/expensive_map.dart": {
     "Dynamic access of 'length'.": 1,
     "Dynamic access of 'isEmpty'.": 1,
diff --git a/pkg/compiler/test/inference/type_combination_test.dart b/pkg/compiler/test/inference/type_combination_test.dart
index 517ac76..0588216 100644
--- a/pkg/compiler/test/inference/type_combination_test.dart
+++ b/pkg/compiler/test/inference/type_combination_test.dart
@@ -69,19 +69,23 @@
 class RuleSet {
   final name;
   final operate;
-  final Set typesSeen = new Set();
-  final Set pairsSeen = new Set();
+  final Set typesSeen = {};
+  final Set pairsSeen = {};
 
   RuleSet(this.name, this.operate);
 
   void rule(type1, type2, result) {
-    typesSeen..add(type1)..add(type2);
-    var pair1 = new Pair(type1, type2);
-    var pair2 = new Pair(type2, type1);
+    typesSeen
+      ..add(type1)
+      ..add(type2);
+    var pair1 = Pair(type1, type2);
+    var pair2 = Pair(type2, type1);
     if (pairsSeen.contains(pair1)) {
       Expect.isFalse(true, 'Redundant rule ($type1, $type2, ...)');
     }
-    pairsSeen..add(pair1)..add(pair2);
+    pairsSeen
+      ..add(pair1)
+      ..add(pair2);
 
     var r1 = operate(type1, type2);
     var r2 = operate(type2, type1);
@@ -90,8 +94,10 @@
   }
 
   void check(type1, type2, predicate) {
-    typesSeen..add(type1)..add(type2);
-    var pair = new Pair(type1, type2);
+    typesSeen
+      ..add(type1)
+      ..add(type2);
+    var pair = Pair(type1, type2);
     pairsSeen..add(pair);
     var result = operate(type1, type2);
     Expect.isTrue(predicate(result));
@@ -100,7 +106,7 @@
   void validateCoverage() {
     for (var type1 in typesSeen) {
       for (var type2 in typesSeen) {
-        var pair = new Pair(type1, type2);
+        var pair = Pair(type1, type2);
         if (!pairsSeen.contains(pair)) {
           Expect.isTrue(false, 'Missing rule: $name($type1, $type2)');
         }
@@ -111,7 +117,7 @@
 
 void testUnion(JClosedWorld closedWorld) {
   AbstractValueDomain commonMasks = closedWorld.abstractValueDomain;
-  RuleSet ruleSet = new RuleSet(
+  RuleSet ruleSet = RuleSet(
       'union', (t1, t2) => simplify(t1.union(t2, commonMasks), commonMasks));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
   check(type1, type2, predicate) => ruleSet.check(type1, type2, predicate);
@@ -422,7 +428,7 @@
 }
 
 void testIntersection(JClosedWorld closedWorld) {
-  RuleSet ruleSet = new RuleSet('intersection',
+  RuleSet ruleSet = RuleSet('intersection',
       (t1, t2) => t1.intersection(t2, closedWorld.abstractValueDomain));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
 
@@ -566,12 +572,12 @@
   rule(
       jsIndexable,
       potentialArray,
-      new TypeMask.nonNullSubtype(
+      TypeMask.nonNullSubtype(
           closedWorld.commonElements.jsArrayClass, closedWorld));
   rule(
       jsIndexable,
       potentialString,
-      new TypeMask.nonNullSubtype(
+      TypeMask.nonNullSubtype(
           closedWorld.commonElements.jsStringClass, closedWorld));
   rule(jsIndexable, jsBooleanOrNull, emptyType);
   rule(jsIndexable, jsNumberOrNull, emptyType);
@@ -738,7 +744,7 @@
 
 void testRegressions(JClosedWorld closedWorld) {
   TypeMask nonNullPotentialString =
-      new TypeMask.nonNullSubtype(patternClass, closedWorld);
+      TypeMask.nonNullSubtype(patternClass, closedWorld);
   Expect.equals(
       potentialString,
       jsStringOrNull.union(
@@ -776,67 +782,67 @@
   LibraryEntity coreLibrary = commonElements.coreLibrary;
   patternClass = elementEnvironment.lookupClass(coreLibrary, 'Pattern');
 
-  nonPrimitive1 = new TypeMask.nonNullSubtype(
-      closedWorld.commonElements.mapClass, closedWorld);
-  nonPrimitive2 = new TypeMask.nonNullSubtype(
+  nonPrimitive1 =
+      TypeMask.nonNullSubtype(closedWorld.commonElements.mapClass, closedWorld);
+  nonPrimitive2 = TypeMask.nonNullSubtype(
       closedWorld.commonElements.functionClass, closedWorld);
   potentialArray =
-      new TypeMask.subtype(closedWorld.commonElements.listClass, closedWorld);
-  potentialString = new TypeMask.subtype(patternClass, closedWorld);
-  jsInterceptor = new TypeMask.nonNullSubclass(
+      TypeMask.subtype(closedWorld.commonElements.listClass, closedWorld);
+  potentialString = TypeMask.subtype(patternClass, closedWorld);
+  jsInterceptor = TypeMask.nonNullSubclass(
       closedWorld.commonElements.jsInterceptorClass, closedWorld);
-  jsArrayOrNull = new TypeMask.subclass(
+  jsArrayOrNull =
+      TypeMask.subclass(closedWorld.commonElements.jsArrayClass, closedWorld);
+  jsReadableArray = TypeMask.nonNullSubclass(
       closedWorld.commonElements.jsArrayClass, closedWorld);
-  jsReadableArray = new TypeMask.nonNullSubclass(
-      closedWorld.commonElements.jsArrayClass, closedWorld);
-  jsMutableArrayOrNull = new TypeMask.subclass(
+  jsMutableArrayOrNull = TypeMask.subclass(
       closedWorld.commonElements.jsMutableArrayClass, closedWorld);
-  jsMutableArray = new TypeMask.nonNullSubclass(
+  jsMutableArray = TypeMask.nonNullSubclass(
       closedWorld.commonElements.jsMutableArrayClass, closedWorld);
-  jsFixedArrayOrNull = new TypeMask.exact(
+  jsFixedArrayOrNull =
+      TypeMask.exact(closedWorld.commonElements.jsFixedArrayClass, closedWorld);
+  jsFixedArray = TypeMask.nonNullExact(
       closedWorld.commonElements.jsFixedArrayClass, closedWorld);
-  jsFixedArray = new TypeMask.nonNullExact(
-      closedWorld.commonElements.jsFixedArrayClass, closedWorld);
-  jsExtendableArrayOrNull = new TypeMask.exact(
+  jsExtendableArrayOrNull = TypeMask.exact(
       closedWorld.commonElements.jsExtendableArrayClass, closedWorld);
-  jsExtendableArray = new TypeMask.nonNullExact(
+  jsExtendableArray = TypeMask.nonNullExact(
       closedWorld.commonElements.jsExtendableArrayClass, closedWorld);
-  jsUnmodifiableArrayOrNull = new TypeMask.exact(
+  jsUnmodifiableArrayOrNull = TypeMask.exact(
       closedWorld.commonElements.jsUnmodifiableArrayClass, closedWorld);
-  jsUnmodifiableArray = new TypeMask.nonNullExact(
+  jsUnmodifiableArray = TypeMask.nonNullExact(
       closedWorld.commonElements.jsUnmodifiableArrayClass, closedWorld);
-  jsIndexableOrNull = new TypeMask.subtype(
+  jsIndexableOrNull = TypeMask.subtype(
       closedWorld.commonElements.jsIndexableClass, closedWorld);
-  jsIndexable = new TypeMask.nonNullSubtype(
+  jsIndexable = TypeMask.nonNullSubtype(
       closedWorld.commonElements.jsIndexableClass, closedWorld);
-  jsInterceptorOrNull = new TypeMask.subclass(
+  jsInterceptorOrNull = TypeMask.subclass(
       closedWorld.commonElements.jsInterceptorClass, closedWorld);
   jsStringOrNull =
-      new TypeMask.exact(closedWorld.commonElements.jsStringClass, closedWorld);
-  jsString = new TypeMask.nonNullExact(
+      TypeMask.exact(closedWorld.commonElements.jsStringClass, closedWorld);
+  jsString = TypeMask.nonNullExact(
       closedWorld.commonElements.jsStringClass, closedWorld);
-  jsBoolean = new TypeMask.nonNullExact(
+  jsBoolean = TypeMask.nonNullExact(
       closedWorld.commonElements.jsBoolClass, closedWorld);
-  jsNumber = new TypeMask.nonNullSubclass(
+  jsNumber = TypeMask.nonNullSubclass(
       closedWorld.commonElements.jsNumberClass, closedWorld);
-  jsInteger = new TypeMask.nonNullExact(
-      closedWorld.commonElements.jsIntClass, closedWorld);
-  jsNumNotInt = new TypeMask.nonNullExact(
+  jsInteger =
+      TypeMask.nonNullExact(closedWorld.commonElements.jsIntClass, closedWorld);
+  jsNumNotInt = TypeMask.nonNullExact(
       closedWorld.commonElements.jsNumNotIntClass, closedWorld);
   jsBooleanOrNull =
-      new TypeMask.exact(closedWorld.commonElements.jsBoolClass, closedWorld);
-  jsNumberOrNull = new TypeMask.subclass(
-      closedWorld.commonElements.jsNumberClass, closedWorld);
+      TypeMask.exact(closedWorld.commonElements.jsBoolClass, closedWorld);
+  jsNumberOrNull =
+      TypeMask.subclass(closedWorld.commonElements.jsNumberClass, closedWorld);
   jsIntegerOrNull =
-      new TypeMask.exact(closedWorld.commonElements.jsIntClass, closedWorld);
-  jsNumNotIntOrNull = new TypeMask.exact(
-      closedWorld.commonElements.jsNumNotIntClass, closedWorld);
-  nullType = const TypeMask.empty();
-  objectType = new TypeMask.nonNullSubclass(
+      TypeMask.exact(closedWorld.commonElements.jsIntClass, closedWorld);
+  jsNumNotIntOrNull =
+      TypeMask.exact(closedWorld.commonElements.jsNumNotIntClass, closedWorld);
+  nullType = TypeMask.empty();
+  objectType = TypeMask.nonNullSubclass(
       closedWorld.commonElements.objectClass, closedWorld);
-  emptyType = const TypeMask.nonNullEmpty();
-  dynamicType = new TypeMask.subclass(
-      closedWorld.commonElements.objectClass, closedWorld);
+  emptyType = TypeMask.nonNullEmpty();
+  dynamicType =
+      TypeMask.subclass(closedWorld.commonElements.objectClass, closedWorld);
 
   jsInterceptorOrComparable =
       interceptorOrComparable(closedWorld, nullable: false);
diff --git a/pkg/compiler/test/inference/type_mask2_test.dart b/pkg/compiler/test/inference/type_mask2_test.dart
index e5056f8..5fcc9b1 100644
--- a/pkg/compiler/test/inference/type_mask2_test.dart
+++ b/pkg/compiler/test/inference/type_mask2_test.dart
@@ -35,18 +35,20 @@
     List<ClassEntity> containedClasses}) {
   AbstractValueDomain commonMasks = closedWorld.abstractValueDomain;
   bool isNullable = masks.any((FlatTypeMask mask) => mask.isNullable);
+  bool hasLateSentinel = masks.any((FlatTypeMask mask) => mask.hasLateSentinel);
   List<FlatTypeMask> disjoint = <FlatTypeMask>[];
   UnionTypeMask.unionOfHelper(masks, disjoint, commonMasks);
   Expect.listEquals(disjointMasks, disjoint,
       'Unexpected disjoint masks: $disjoint, expected $disjointMasks.');
   if (flattened == null) {
     Expect.throws(
-        () => UnionTypeMask.flatten(disjoint, isNullable, commonMasks),
+        () => UnionTypeMask.flatten(disjoint, commonMasks,
+            includeNull: isNullable, includeLateSentinel: hasLateSentinel),
         (e) => e is ArgumentError,
         'Expect argument error on flattening of $disjoint.');
   } else {
-    TypeMask flattenResult =
-        UnionTypeMask.flatten(disjoint, isNullable, commonMasks);
+    TypeMask flattenResult = UnionTypeMask.flatten(disjoint, commonMasks,
+        includeNull: isNullable, includeLateSentinel: hasLateSentinel);
     Expect.equals(
         flattened,
         flattenResult,
@@ -120,16 +122,25 @@
         containedClasses: containedClasses);
   }
 
-  TypeMask empty = const TypeMask.nonNullEmpty();
-  TypeMask subclassObject = new TypeMask.nonNullSubclass(Object_, closedWorld);
-  TypeMask exactA = new TypeMask.nonNullExact(A, closedWorld);
-  TypeMask subclassA = new TypeMask.nonNullSubclass(A, closedWorld);
-  TypeMask subtypeA = new TypeMask.nonNullSubtype(A, closedWorld);
-  TypeMask exactB = new TypeMask.nonNullExact(B, closedWorld);
-  TypeMask subclassB = new TypeMask.nonNullSubclass(B, closedWorld);
-  TypeMask exactC = new TypeMask.nonNullExact(C, closedWorld);
-  TypeMask exactD = new TypeMask.nonNullExact(D, closedWorld);
-  TypeMask exactE = new TypeMask.nonNullExact(E, closedWorld);
+  TypeMask empty = TypeMask.nonNullEmpty();
+  TypeMask sentinel = TypeMask.nonNullEmpty(hasLateSentinel: true);
+  TypeMask subclassObject = TypeMask.nonNullSubclass(Object_, closedWorld);
+  TypeMask subclassObjectOrSentinel =
+      TypeMask.nonNullSubclass(Object_, closedWorld, hasLateSentinel: true);
+  TypeMask exactA = TypeMask.nonNullExact(A, closedWorld);
+  TypeMask exactAOrSentinel =
+      TypeMask.nonNullExact(A, closedWorld, hasLateSentinel: true);
+  TypeMask subclassA = TypeMask.nonNullSubclass(A, closedWorld);
+  TypeMask subtypeA = TypeMask.nonNullSubtype(A, closedWorld);
+  TypeMask subtypeAOrSentinel =
+      TypeMask.nonNullSubtype(A, closedWorld, hasLateSentinel: true);
+  TypeMask exactB = TypeMask.nonNullExact(B, closedWorld);
+  TypeMask exactBOrSentinel =
+      TypeMask.nonNullExact(B, closedWorld, hasLateSentinel: true);
+  TypeMask subclassB = TypeMask.nonNullSubclass(B, closedWorld);
+  TypeMask exactC = TypeMask.nonNullExact(C, closedWorld);
+  TypeMask exactD = TypeMask.nonNullExact(D, closedWorld);
+  TypeMask exactE = TypeMask.nonNullExact(E, closedWorld);
 
   check([],
       result: empty,
@@ -213,6 +224,52 @@
       disjointMasks: [subclassB, exactA],
       flattened: subclassObject,
       containedClasses: [A, B, E]);
+
+  check([sentinel],
+      result: sentinel,
+      disjointMasks: const [],
+      flattened: null,
+      containedClasses: const []);
+
+  check([sentinel, sentinel],
+      result: sentinel,
+      disjointMasks: const [],
+      flattened: null,
+      containedClasses: const []);
+
+  check([empty, sentinel],
+      result: sentinel,
+      disjointMasks: const [],
+      flattened: null,
+      containedClasses: const []);
+
+  check([sentinel, empty],
+      result: sentinel,
+      disjointMasks: const [],
+      flattened: null,
+      containedClasses: const []);
+
+  check([exactAOrSentinel],
+      result: exactAOrSentinel,
+      disjointMasks: [exactA],
+      flattened: subtypeAOrSentinel, // TODO(37602): Imprecise.
+      containedClasses: [A]);
+
+  check([exactA, exactAOrSentinel],
+      result: exactAOrSentinel,
+      disjointMasks: [exactA],
+      flattened: subtypeAOrSentinel, // TODO(37602): Imprecise.
+      containedClasses: [A]);
+
+  check([exactAOrSentinel, exactB],
+      disjointMasks: [exactA, exactB],
+      flattened: subclassObjectOrSentinel,
+      containedClasses: [A, B]);
+
+  check([exactAOrSentinel, exactBOrSentinel],
+      disjointMasks: [exactA, exactB],
+      flattened: subclassObjectOrSentinel,
+      containedClasses: [A, B]);
 }
 
 Future testStringSubtypes() async {
@@ -241,11 +298,10 @@
   Expect.isFalse(closedWorld.classHierarchy.isIndirectlyInstantiated(JSString));
   Expect.isTrue(closedWorld.classHierarchy.isInstantiated(JSString));
 
-  TypeMask subtypeString = new TypeMask.nonNullSubtype(String_, closedWorld);
-  TypeMask exactJSString = new TypeMask.nonNullExact(JSString, closedWorld);
-  TypeMask subtypeJSString = new TypeMask.nonNullSubtype(JSString, closedWorld);
-  TypeMask subclassJSString =
-      new TypeMask.nonNullSubclass(JSString, closedWorld);
+  TypeMask subtypeString = TypeMask.nonNullSubtype(String_, closedWorld);
+  TypeMask exactJSString = TypeMask.nonNullExact(JSString, closedWorld);
+  TypeMask subtypeJSString = TypeMask.nonNullSubtype(JSString, closedWorld);
+  TypeMask subclassJSString = TypeMask.nonNullSubclass(JSString, closedWorld);
 
   Expect.equals(exactJSString, subtypeString);
   Expect.equals(exactJSString, subtypeJSString);
diff --git a/pkg/compiler/test/inference/type_mask_test_helper.dart b/pkg/compiler/test/inference/type_mask_test_helper.dart
index ba29b08..8eb0171 100644
--- a/pkg/compiler/test/inference/type_mask_test_helper.dart
+++ b/pkg/compiler/test/inference/type_mask_test_helper.dart
@@ -16,7 +16,9 @@
   if (value is ForwardingTypeMask) {
     return simplify(value.forwardTo, domain);
   } else if (value is UnionTypeMask) {
-    return UnionTypeMask.flatten(value.disjointMasks, value.isNullable, domain);
+    return UnionTypeMask.flatten(value.disjointMasks, domain,
+        includeNull: value.isNullable,
+        includeLateSentinel: value.hasLateSentinel);
   } else {
     return value;
   }
diff --git a/pkg/front_end/testcases/dart2js/late_fields.dart.strong.expect b/pkg/front_end/testcases/dart2js/late_fields.dart.strong.expect
index 02d73bd..a546427 100644
--- a/pkg/front_end/testcases/dart2js/late_fields.dart.strong.expect
+++ b/pkg/front_end/testcases/dart2js/late_fields.dart.strong.expect
@@ -1,33 +1,15 @@
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 class C extends core::Object {
-  field core::int? _#C#a = null;
-  field core::int? _#C#b = null;
-  field core::int? _#C#c = null;
-  field core::int? _#C#d = null;
+  late field core::int a;
+  late final [setter] field core::int b;
+  late field core::int c = 1.{core::int::unary-}(){() → core::int};
+  late final field core::int d = 1.{core::int::unary-}(){() → core::int};
   synthetic constructor •() → self::C
     : super core::Object::•()
     ;
-  get a() → core::int
-    return let final core::int? #t1 = this.{self::C::_#C#a}{core::int?} in #t1 == null ?{core::int} throw new _in::LateError::fieldNI("a") : #t1{core::int};
-  set a(core::int #t2) → void
-    this.{self::C::_#C#a} = #t2;
-  get b() → core::int
-    return let final core::int? #t3 = this.{self::C::_#C#b}{core::int?} in #t3 == null ?{core::int} throw new _in::LateError::fieldNI("b") : #t3{core::int};
-  set b(core::int #t4) → void
-    if(this.{self::C::_#C#b}{core::int?} == null)
-      this.{self::C::_#C#b} = #t4;
-    else
-      throw new _in::LateError::fieldAI("b");
-  get c() → core::int
-    return let final core::int? #t5 = this.{self::C::_#C#c}{core::int?} in #t5 == null ?{core::int} this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int} : #t5{core::int};
-  set c(core::int #t6) → void
-    this.{self::C::_#C#c} = #t6;
-  get d() → core::int
-    return let final core::int? #t7 = this.{self::C::_#C#d}{core::int?} in #t7 == null ?{core::int} let final core::int #t8 = 1.{core::int::unary-}(){() → core::int} in this.{self::C::_#C#d}{core::int?} == null ?{core::int} this.{self::C::_#C#d} = #t8 : throw new _in::LateError::fieldADI("d") : #t7{core::int};
   static method _#new#tearOff() → self::C
     return new self::C::•();
 }
diff --git a/pkg/front_end/testcases/dart2js/late_fields.dart.strong.transformed.expect b/pkg/front_end/testcases/dart2js/late_fields.dart.strong.transformed.expect
index bf9c284..4b80ddd 100644
--- a/pkg/front_end/testcases/dart2js/late_fields.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/dart2js/late_fields.dart.strong.transformed.expect
@@ -1,35 +1,46 @@
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;
+import "dart:_late_helper" as _la;
 import "dart:_internal" as _in;
 
 class C extends core::Object {
-  field core::int? _#C#a = null;
-  field core::int? _#C#b = null;
-  field core::int? _#C#c = null;
-  field core::int? _#C#d = null;
+  field core::int _#C#a = _in::createSentinel<core::int>();
+  field core::int _#C#b = _in::createSentinel<core::int>();
+  field core::int _#C#c = _in::createSentinel<core::int>();
+  field core::int _#C#d = _in::createSentinel<core::int>();
   synthetic constructor •() → self::C
     : super core::Object::•()
     ;
-  get a() → core::int
-    return let final core::int? #t1 = this.{self::C::_#C#a}{core::int?} in #t1 == null ?{core::int} throw new _in::LateError::fieldNI("a") : #t1{core::int};
-  set a(core::int #t2) → void
-    this.{self::C::_#C#a} = #t2;
-  get b() → core::int
-    return let final core::int? #t3 = this.{self::C::_#C#b}{core::int?} in #t3 == null ?{core::int} throw new _in::LateError::fieldNI("b") : #t3{core::int};
-  set b(core::int #t4) → void
-    if(this.{self::C::_#C#b}{core::int?} == null)
-      this.{self::C::_#C#b} = #t4;
-    else
-      throw new _in::LateError::fieldAI("b");
-  get c() → core::int
-    return let final core::int? #t5 = this.{self::C::_#C#c}{core::int?} in #t5 == null ?{core::int} this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int} : #t5{core::int};
-  set c(core::int #t6) → void
-    this.{self::C::_#C#c} = #t6;
-  get d() → core::int
-    return let final core::int? #t7 = this.{self::C::_#C#d}{core::int?} in #t7 == null ?{core::int} let final core::int #t8 = 1.{core::int::unary-}(){() → core::int} in this.{self::C::_#C#d}{core::int?} == null ?{core::int} this.{self::C::_#C#d} = #t8 : throw new _in::LateError::fieldADI("d") : #t7{core::int};
   static method _#new#tearOff() → self::C
     return new self::C::•();
+  get a() → core::int
+    return _la::_lateReadCheck<core::int>(this.{self::C::_#C#a}{core::int}, "a");
+  set a(core::int value) → void
+    this.{self::C::_#C#a} = value;
+  get b() → core::int
+    return _la::_lateReadCheck<core::int>(this.{self::C::_#C#b}{core::int}, "b");
+  set b(core::int value) → void {
+    _la::_lateWriteOnceCheck(this.{self::C::_#C#b}{core::int}, "b");
+    this.{self::C::_#C#b} = value;
+  }
+  get c() → core::int {
+    core::int value = this.{self::C::_#C#c}{core::int};
+    if(_in::isSentinel(value))
+      value = this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int};
+    return value;
+  }
+  set c(core::int value) → void
+    this.{self::C::_#C#c} = value;
+  get d() → core::int {
+    core::int value = this.{self::C::_#C#d}{core::int};
+    if(_in::isSentinel(value)) {
+      final core::int result = 1.{core::int::unary-}(){() → core::int};
+      _la::_lateInitializeOnceCheck(this.{self::C::_#C#d}{core::int}, "d");
+      value = this.{self::C::_#C#d} = result;
+    }
+    return value;
+  }
 }
 static field self::C c = new self::C::•();
 static method main() → void {
@@ -61,5 +72,4 @@
 Extra constant evaluation status:
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///late_fields.dart:15:16 -> DoubleConstant(-1.0)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///late_fields.dart:16:22 -> DoubleConstant(-1.0)
-Evaluated: VariableGet @ org-dartlang-testcase:///late_fields.dart:16:18 -> DoubleConstant(-1.0)
-Extra constant evaluation: evaluated: 93, effectively constant: 3
+Extra constant evaluation: evaluated: 77, effectively constant: 2
diff --git a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.expect b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.expect
index 95a7e38..a546427 100644
--- a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.expect
+++ b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.expect
@@ -1,33 +1,15 @@
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 class C extends core::Object {
-  field core::int? _#C#a = _in::createSentinel<core::int>();
-  field core::int? _#C#b = _in::createSentinel<core::int>();
-  field core::int? _#C#c = _in::createSentinel<core::int>();
-  field core::int? _#C#d = _in::createSentinel<core::int>();
+  late field core::int a;
+  late final [setter] field core::int b;
+  late field core::int c = 1.{core::int::unary-}(){() → core::int};
+  late final field core::int d = 1.{core::int::unary-}(){() → core::int};
   synthetic constructor •() → self::C
     : super core::Object::•()
     ;
-  get a() → core::int
-    return let final core::int? #t1 = this.{self::C::_#C#a}{core::int?} in _in::isSentinel(#t1) ?{core::int} throw new _in::LateError::fieldNI("a") : #t1{core::int};
-  set a(core::int #t2) → void
-    this.{self::C::_#C#a} = #t2;
-  get b() → core::int
-    return let final core::int? #t3 = this.{self::C::_#C#b}{core::int?} in _in::isSentinel(#t3) ?{core::int} throw new _in::LateError::fieldNI("b") : #t3{core::int};
-  set b(core::int #t4) → void
-    if(_in::isSentinel(this.{self::C::_#C#b}{core::int?}))
-      this.{self::C::_#C#b} = #t4;
-    else
-      throw new _in::LateError::fieldAI("b");
-  get c() → core::int
-    return let final core::int? #t5 = this.{self::C::_#C#c}{core::int?} in _in::isSentinel(#t5) ?{core::int} this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int} : #t5{core::int};
-  set c(core::int #t6) → void
-    this.{self::C::_#C#c} = #t6;
-  get d() → core::int
-    return let final core::int #t7 = this.{self::C::_#C#d}{core::int?} in _in::isSentinel(#t7) ?{core::int} let final core::int #t8 = 1.{core::int::unary-}(){() → core::int} in _in::isSentinel(this.{self::C::_#C#d}{core::int?}) ?{core::int} this.{self::C::_#C#d} = #t8 : throw new _in::LateError::fieldADI("d") : #t7;
   static method _#new#tearOff() → self::C
     return new self::C::•();
 }
diff --git a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.outline.expect b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.outline.expect
index 57eb7ff..7c10260 100644
--- a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.outline.expect
@@ -3,19 +3,12 @@
 import "dart:core" as core;
 
 class C extends core::Object {
-  field core::int? _#C#a;
-  field core::int? _#C#b;
-  field core::int? _#C#c;
-  field core::int? _#C#d;
+  late field core::int a;
+  late final [setter] field core::int b;
+  late field core::int c;
+  late final field core::int d;
   synthetic constructor •() → self::C
     ;
-  get a() → core::int;
-  set a(core::int #t1) → void;
-  get b() → core::int;
-  set b(core::int #t2) → void;
-  get c() → core::int;
-  set c(core::int #t3) → void;
-  get d() → core::int;
   static method _#new#tearOff() → self::C
     return new self::C::•();
 }
diff --git a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.transformed.expect b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.transformed.expect
index 15df6e5..4b80ddd 100644
--- a/pkg/front_end/testcases/dart2js/late_fields.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/dart2js/late_fields.dart.weak.transformed.expect
@@ -1,35 +1,46 @@
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;
+import "dart:_late_helper" as _la;
 import "dart:_internal" as _in;
 
 class C extends core::Object {
-  field core::int? _#C#a = _in::createSentinel<core::int>();
-  field core::int? _#C#b = _in::createSentinel<core::int>();
-  field core::int? _#C#c = _in::createSentinel<core::int>();
-  field core::int? _#C#d = _in::createSentinel<core::int>();
+  field core::int _#C#a = _in::createSentinel<core::int>();
+  field core::int _#C#b = _in::createSentinel<core::int>();
+  field core::int _#C#c = _in::createSentinel<core::int>();
+  field core::int _#C#d = _in::createSentinel<core::int>();
   synthetic constructor •() → self::C
     : super core::Object::•()
     ;
-  get a() → core::int
-    return let final core::int? #t1 = this.{self::C::_#C#a}{core::int?} in _in::isSentinel(#t1) ?{core::int} throw new _in::LateError::fieldNI("a") : #t1{core::int};
-  set a(core::int #t2) → void
-    this.{self::C::_#C#a} = #t2;
-  get b() → core::int
-    return let final core::int? #t3 = this.{self::C::_#C#b}{core::int?} in _in::isSentinel(#t3) ?{core::int} throw new _in::LateError::fieldNI("b") : #t3{core::int};
-  set b(core::int #t4) → void
-    if(_in::isSentinel(this.{self::C::_#C#b}{core::int?}))
-      this.{self::C::_#C#b} = #t4;
-    else
-      throw new _in::LateError::fieldAI("b");
-  get c() → core::int
-    return let final core::int? #t5 = this.{self::C::_#C#c}{core::int?} in _in::isSentinel(#t5) ?{core::int} this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int} : #t5{core::int};
-  set c(core::int #t6) → void
-    this.{self::C::_#C#c} = #t6;
-  get d() → core::int
-    return let final core::int #t7 = this.{self::C::_#C#d}{core::int?} in _in::isSentinel(#t7) ?{core::int} let final core::int #t8 = 1.{core::int::unary-}(){() → core::int} in _in::isSentinel(this.{self::C::_#C#d}{core::int?}) ?{core::int} this.{self::C::_#C#d} = #t8 : throw new _in::LateError::fieldADI("d") : #t7;
   static method _#new#tearOff() → self::C
     return new self::C::•();
+  get a() → core::int
+    return _la::_lateReadCheck<core::int>(this.{self::C::_#C#a}{core::int}, "a");
+  set a(core::int value) → void
+    this.{self::C::_#C#a} = value;
+  get b() → core::int
+    return _la::_lateReadCheck<core::int>(this.{self::C::_#C#b}{core::int}, "b");
+  set b(core::int value) → void {
+    _la::_lateWriteOnceCheck(this.{self::C::_#C#b}{core::int}, "b");
+    this.{self::C::_#C#b} = value;
+  }
+  get c() → core::int {
+    core::int value = this.{self::C::_#C#c}{core::int};
+    if(_in::isSentinel(value))
+      value = this.{self::C::_#C#c} = 1.{core::int::unary-}(){() → core::int};
+    return value;
+  }
+  set c(core::int value) → void
+    this.{self::C::_#C#c} = value;
+  get d() → core::int {
+    core::int value = this.{self::C::_#C#d}{core::int};
+    if(_in::isSentinel(value)) {
+      final core::int result = 1.{core::int::unary-}(){() → core::int};
+      _la::_lateInitializeOnceCheck(this.{self::C::_#C#d}{core::int}, "d");
+      value = this.{self::C::_#C#d} = result;
+    }
+    return value;
+  }
 }
 static field self::C c = new self::C::•();
 static method main() → void {
@@ -61,5 +72,4 @@
 Extra constant evaluation status:
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///late_fields.dart:15:16 -> DoubleConstant(-1.0)
 Evaluated: InstanceInvocation @ org-dartlang-testcase:///late_fields.dart:16:22 -> DoubleConstant(-1.0)
-Evaluated: VariableGet @ org-dartlang-testcase:///late_fields.dart:16:18 -> DoubleConstant(-1.0)
-Extra constant evaluation: evaluated: 97, effectively constant: 3
+Extra constant evaluation: evaluated: 77, effectively constant: 2
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index 6cd7640..c0e53d5 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -782,6 +782,7 @@
 }
 
 void Precompiler::CollectCallbackFields() {
+  PRECOMPILER_TIMER_SCOPE(this, CollectCallbackFields);
   HANDLESCOPE(T);
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
@@ -883,6 +884,7 @@
 }
 
 void Precompiler::AddCalleesOf(const Function& function, intptr_t gop_offset) {
+  PRECOMPILER_TIMER_SCOPE(this, AddCalleesOf);
   ASSERT(function.HasCode());
 
   const Code& code = Code::Handle(Z, function.CurrentCode());
@@ -987,6 +989,12 @@
 void Precompiler::AddCalleesOfHelper(const Object& entry,
                                      String* temp_selector,
                                      Class* temp_cls) {
+  const intptr_t cid = entry.GetClassId();
+  if ((cid == kOneByteStringCid) || (cid == kNullCid)) {
+    // Skip common leaf constants early in order to
+    // process object pools faster.
+    return;
+  }
   if (entry.IsUnlinkedCall()) {
     const auto& call_site = UnlinkedCall::Cast(entry);
     // A dynamic call.
@@ -1603,6 +1611,7 @@
 }
 
 void Precompiler::CheckForNewDynamicFunctions() {
+  PRECOMPILER_TIMER_SCOPE(this, CheckForNewDynamicFunctions);
   HANDLESCOPE(T);
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
diff --git a/runtime/vm/compiler/backend/inliner.cc b/runtime/vm/compiler/backend/inliner.cc
index 09359cc..d4748c4 100644
--- a/runtime/vm/compiler/backend/inliner.cc
+++ b/runtime/vm/compiler/backend/inliner.cc
@@ -2310,6 +2310,9 @@
 }
 
 bool FlowGraphInliner::FunctionHasPreferInlinePragma(const Function& function) {
+  if (!function.has_pragma()) {
+    return false;
+  }
   Thread* thread = dart::Thread::Current();
   COMPILER_TIMINGS_TIMER_SCOPE(thread, CheckForPragma);
   Object& options = Object::Handle();
@@ -2319,6 +2322,9 @@
 }
 
 bool FlowGraphInliner::FunctionHasNeverInlinePragma(const Function& function) {
+  if (!function.has_pragma()) {
+    return false;
+  }
   Thread* thread = dart::Thread::Current();
   COMPILER_TIMINGS_TIMER_SCOPE(thread, CheckForPragma);
   Object& options = Object::Handle();
diff --git a/runtime/vm/compiler/compiler_timings.h b/runtime/vm/compiler/compiler_timings.h
index 6f9b31b..2f63f78 100644
--- a/runtime/vm/compiler/compiler_timings.h
+++ b/runtime/vm/compiler/compiler_timings.h
@@ -20,6 +20,9 @@
   V(CompileAll)                                                                \
   V(Iterate)                                                                   \
   V(CompileFunction)                                                           \
+  V(AddCalleesOf)                                                              \
+  V(CheckForNewDynamicFunctions)                                               \
+  V(CollectCallbackFields)                                                     \
   V(PrecompileConstructors)                                                    \
   V(AttachOptimizedTypeTestingStub)                                            \
   V(TraceForRetainedFunctions)                                                 \
diff --git a/sdk/lib/_internal/js_runtime/lib/native_helper.dart b/sdk/lib/_internal/js_runtime/lib/native_helper.dart
index 4c404e0..8634929 100644
--- a/sdk/lib/_internal/js_runtime/lib/native_helper.dart
+++ b/sdk/lib/_internal/js_runtime/lib/native_helper.dart
@@ -260,7 +260,8 @@
 }
 
 String constructorNameFallback(object) {
-  return JS('String', '#(#)', _constructorNameFallback, object);
+  return JS('returns:String;effects:none;depends:none', '#(#)',
+      _constructorNameFallback, object);
 }
 
 var initNativeDispatchFlag; // null or true
diff --git a/sdk/lib/js_util/js_util.dart b/sdk/lib/js_util/js_util.dart
index ee3dd0f..bfe6cf3 100644
--- a/sdk/lib/js_util/js_util.dart
+++ b/sdk/lib/js_util/js_util.dart
@@ -195,6 +195,38 @@
   //     return _wrapToDart(jsObj);
 }
 
+/// Unchecked version for 0 arguments, only used in a CFE transformation.
+@pragma('dart2js:tryInline')
+dynamic _callConstructorUnchecked0(Object constr) {
+  return JS('Object', 'new #()', constr);
+}
+
+/// Unchecked version for 1 argument, only used in a CFE transformation.
+@pragma('dart2js:tryInline')
+dynamic _callConstructorUnchecked1(Object constr, Object? arg1) {
+  return JS('Object', 'new #(#)', constr, arg1);
+}
+
+/// Unchecked version for 2 arguments, only used in a CFE transformation.
+@pragma('dart2js:tryInline')
+dynamic _callConstructorUnchecked2(Object constr, Object? arg1, Object? arg2) {
+  return JS('Object', 'new #(#, #)', constr, arg1, arg2);
+}
+
+/// Unchecked version for 3 arguments, only used in a CFE transformation.
+@pragma('dart2js:tryInline')
+dynamic _callConstructorUnchecked3(
+    Object constr, Object? arg1, Object? arg2, Object? arg3) {
+  return JS('Object', 'new #(#, #, #)', constr, arg1, arg2, arg3);
+}
+
+/// Unchecked version for 4 arguments, only used in a CFE transformation.
+@pragma('dart2js:tryInline')
+dynamic _callConstructorUnchecked4(
+    Object constr, Object? arg1, Object? arg2, Object? arg3, Object? arg4) {
+  return JS('Object', 'new #(#, #, #, #)', constr, arg1, arg2, arg3, arg4);
+}
+
 /// Exception for when the promise is rejected with a `null` or `undefined`
 /// value.
 ///
diff --git a/tests/lib/js/js_util/properties_test.dart b/tests/lib/js/js_util/properties_test.dart
index 326de20..84a09c8 100644
--- a/tests/lib/js/js_util/properties_test.dart
+++ b/tests/lib/js/js_util/properties_test.dart
@@ -85,6 +85,19 @@
   external five(a, b, c, d, e);
 }
 
+@JS()
+external get Zero;
+@JS()
+external get One;
+@JS()
+external get Two;
+@JS()
+external get Three;
+@JS()
+external get Four;
+@JS()
+external get Five;
+
 main() {
   eval(r"""
     function Foo(a) {
@@ -157,6 +170,25 @@
     CallMethodTest.prototype.five = function(a, b, c, d, e) {
       return 'five';
     }
+
+    function Zero() {
+      this.count = 0;
+    }
+    function One(a) {
+      this.count = 1;
+    }
+    function Two(a, b) {
+      this.count = 2;
+    }
+    function Three(a, b, c) {
+      this.count = 3;
+    }
+    function Four(a, b, c, d) {
+      this.count = 4;
+    }
+    function Five(a, b, c, d, e) {
+      this.count = 5;
+    }
     """);
 
   group('newObject', () {
@@ -543,8 +575,131 @@
 
   group('callConstructor', () {
     test('typed object', () {
-      Foo f = js_util.callConstructor(JSFooType, [42]);
+      var f = js_util.callConstructor(JSFooType, [42]);
       expect(f.a, equals(42));
+
+      var f2 =
+          js_util.callConstructor(js_util.getProperty(f, 'constructor'), [5]);
+      expect(f2.a, equals(5));
+    });
+
+    test('typed literal', () {
+      ExampleTypedLiteral literal = js_util.callConstructor(
+          js_util.getProperty(ExampleTypedLiteral(), 'constructor'), []);
+      expect(literal.a, equals(null));
+    });
+
+    test('callConstructor with List edge cases', () {
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Zero, List.empty()), 'count'),
+          equals(0));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Zero, List<int>.empty()), 'count'),
+          equals(0));
+
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, List<int>.filled(2, 0)), 'count'),
+          equals(2));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Three, List<int>.generate(3, (i) => i)),
+              'count'),
+          equals(3));
+
+      Iterable<String> iterableStrings = <String>['foo', 'bar'];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, List.of(iterableStrings)), 'count'),
+          equals(2));
+
+      const l1 = [1, 2];
+      const l2 = [3, 4];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, List.from(l1)..addAll(l2)),
+              'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(js_util.callConstructor(Four, l1 + l2), 'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, List.unmodifiable([1, 2, 3, 4])),
+              'count'),
+          equals(4));
+
+      var setElements = {1, 2};
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, setElements.toList()), 'count'),
+          equals(2));
+
+      var spreadList = [1, 2, 3];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [1, ...spreadList]), 'count'),
+          equals(4));
+    });
+
+    test('edge cases for lowering to _callConstructorUncheckedN', () {
+      expect(js_util.getProperty(js_util.callConstructor(Zero, []), 'count'),
+          equals(0));
+      expect(js_util.getProperty(js_util.callConstructor(One, [1]), 'count'),
+          equals(1));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [1, 2, 3, 4]), 'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Five, [1, 2, 3, 4, 5]), 'count'),
+          equals(5));
+
+      // List with a type declaration, short circuits element checking
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, <int>[1, 2]), 'count'),
+          equals(2));
+
+      // List as a variable instead of a List Literal or constant
+      var list = [1, 2];
+      expect(js_util.getProperty(js_util.callConstructor(Two, list), 'count'),
+          equals(2));
+
+      // Mixed types of elements to check in the given list.
+      var x = 4;
+      var str = 'cat';
+      var b = false;
+      var evens = [2, 4, 6];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [x, str, b, evens]), 'count'),
+          equals(4));
+      var obj = Object();
+      expect(js_util.getProperty(js_util.callConstructor(One, [obj]), 'count'),
+          equals(1));
+      var nullElement = null;
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(One, [nullElement]), 'count'),
+          equals(1));
+
+      // const lists.
+      expect(
+          js_util.getProperty(js_util.callConstructor(One, const [3]), 'count'),
+          equals(1));
+      const constList = [10, 20, 30];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Three, constList), 'count'),
+          equals(3));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(One, DartClass.staticConstList), 'count'),
+          equals(1));
     });
   });
 }
diff --git a/tests/lib_2/js/js_util/properties_test.dart b/tests/lib_2/js/js_util/properties_test.dart
index 8479414..c19fe14 100644
--- a/tests/lib_2/js/js_util/properties_test.dart
+++ b/tests/lib_2/js/js_util/properties_test.dart
@@ -87,6 +87,19 @@
   external five(a, b, c, d, e);
 }
 
+@JS()
+external get Zero;
+@JS()
+external get One;
+@JS()
+external get Two;
+@JS()
+external get Three;
+@JS()
+external get Four;
+@JS()
+external get Five;
+
 main() {
   eval(r"""
     function Foo(a) {
@@ -159,6 +172,25 @@
     CallMethodTest.prototype.five = function(a, b, c, d, e) {
       return 'five';
     }
+
+    function Zero() {
+      this.count = 0;
+    }
+    function One(a) {
+      this.count = 1;
+    }
+    function Two(a, b) {
+      this.count = 2;
+    }
+    function Three(a, b, c) {
+      this.count = 3;
+    }
+    function Four(a, b, c, d) {
+      this.count = 4;
+    }
+    function Five(a, b, c, d, e) {
+      this.count = 5;
+    }
     """);
 
   group('newObject', () {
@@ -547,8 +579,138 @@
 
   group('callConstructor', () {
     test('typed object', () {
-      Foo f = js_util.callConstructor(JSFooType, [42]);
+      var f = js_util.callConstructor(JSFooType, [42]);
       expect(f.a, equals(42));
+
+      var f2 =
+          js_util.callConstructor(js_util.getProperty(f, 'constructor'), [5]);
+      expect(f2.a, equals(5));
+    });
+
+    test('typed literal', () {
+      ExampleTypedLiteral literal = js_util.callConstructor(
+          js_util.getProperty(ExampleTypedLiteral(), 'constructor'), []);
+      expect(literal.a, equals(null));
+    });
+
+    test('callConstructor with List edge cases', () {
+      expect(
+          js_util.getProperty(js_util.callConstructor(Zero, List()), 'count'),
+          equals(0));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Zero, List<int>()), 'count'),
+          equals(0));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Zero, List.empty()), 'count'),
+          equals(0));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Zero, List<int>.empty()), 'count'),
+          equals(0));
+
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, List<int>.filled(2, 0)), 'count'),
+          equals(2));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Three, List<int>.generate(3, (i) => i)),
+              'count'),
+          equals(3));
+
+      Iterable<String> iterableStrings = <String>['foo', 'bar'];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, List.of(iterableStrings)), 'count'),
+          equals(2));
+
+      const l1 = [1, 2];
+      const l2 = [3, 4];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, List.from(l1)..addAll(l2)),
+              'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(js_util.callConstructor(Four, l1 + l2), 'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, List.unmodifiable([1, 2, 3, 4])),
+              'count'),
+          equals(4));
+
+      var setElements = {1, 2};
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, setElements.toList()), 'count'),
+          equals(2));
+
+      var spreadList = [1, 2, 3];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [1, ...spreadList]), 'count'),
+          equals(4));
+    });
+
+    test('edge cases for lowering to _callConstructorUncheckedN', () {
+      expect(js_util.getProperty(js_util.callConstructor(Zero, []), 'count'),
+          equals(0));
+      expect(js_util.getProperty(js_util.callConstructor(One, [1]), 'count'),
+          equals(1));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [1, 2, 3, 4]), 'count'),
+          equals(4));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Five, [1, 2, 3, 4, 5]), 'count'),
+          equals(5));
+
+      // List with a type declaration, short circuits element checking
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Two, <int>[1, 2]), 'count'),
+          equals(2));
+
+      // List as a variable instead of a List Literal or constant
+      var list = [1, 2];
+      expect(js_util.getProperty(js_util.callConstructor(Two, list), 'count'),
+          equals(2));
+
+      // Mixed types of elements to check in the given list.
+      var x = 4;
+      var str = 'cat';
+      var b = false;
+      var evens = [2, 4, 6];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Four, [x, str, b, evens]), 'count'),
+          equals(4));
+      var obj = Object();
+      expect(js_util.getProperty(js_util.callConstructor(One, [obj]), 'count'),
+          equals(1));
+      var nullElement = null;
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(One, [nullElement]), 'count'),
+          equals(1));
+
+      // const lists.
+      expect(
+          js_util.getProperty(js_util.callConstructor(One, const [3]), 'count'),
+          equals(1));
+      const constList = [10, 20, 30];
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(Three, constList), 'count'),
+          equals(3));
+      expect(
+          js_util.getProperty(
+              js_util.callConstructor(One, DartClass.staticConstList), 'count'),
+          equals(1));
     });
   });
 }
diff --git a/tests/web/late_narrowing_test.dart b/tests/web/late_narrowing_test.dart
new file mode 100644
index 0000000..d7dcc11
--- /dev/null
+++ b/tests/web/late_narrowing_test.dart
@@ -0,0 +1,23 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+// Tests to ensure that narrowing type information does not discard late
+// sentinel values unintentionally.
+
+class Foo<T> {
+  // Since `List<T>` contains a free type variable, any access of [x] will be
+  // immediately followed by a narrowing to the appropriate instantiation of
+  // `List<T>`. This narrowing should not exclude the late sentinel value from
+  // the abstract value.
+  late final List<T> x;
+}
+
+void main() {
+  Foo<int> foo = Foo();
+  Expect.throws(() => foo.x);
+  foo.x = const [];
+  Expect.isTrue(foo.x.isEmpty);
+}
diff --git a/tests/web/regress/192964907a_test.dart b/tests/web/regress/192964907a_test.dart
new file mode 100644
index 0000000..c92e8f8
--- /dev/null
+++ b/tests/web/regress/192964907a_test.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+class Foo {
+  late final bool x;
+
+  Foo() {
+    build();
+  }
+
+  void build() {
+    x = true;
+  }
+}
+
+void main() {
+  final foo = Foo();
+  Expect.isTrue(foo.x);
+}
diff --git a/tests/web/regress/192964907b_test.dart b/tests/web/regress/192964907b_test.dart
new file mode 100644
index 0000000..7046686
--- /dev/null
+++ b/tests/web/regress/192964907b_test.dart
@@ -0,0 +1,18 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+
+class Foo {
+  late final bool? field;
+
+  void build() {
+    field = true;
+    Expect.isTrue(field!);
+  }
+}
+
+void main() {
+  (Foo().build)();
+}
diff --git a/tools/VERSION b/tools/VERSION
index d226819..783443a 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 102
+PRERELEASE 103
 PRERELEASE_PATCH 0
\ No newline at end of file