diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
index c62864d..6b7be5d 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
@@ -199,7 +199,7 @@
   Expression get nonNullAssert => new _NonNullAssert(this);
 
   /// If `this` is an expression `x`, creates the expression `(x)`.
-  Expression get parenthesized => new _WrappedExpression(null, this, null);
+  Expression get parenthesized => new _ParenthesizedExpression(this);
 
   /// If `this` is an expression `x`, creates the statement `x;`.
   Statement get stmt => new _ExpressionStatement(this);
@@ -1225,6 +1225,28 @@
   }
 }
 
+class _ParenthesizedExpression extends Expression {
+  final Expression expr;
+
+  _ParenthesizedExpression(this.expr);
+
+  @override
+  String toString() => '($expr)';
+
+  @override
+  void _preVisit(AssignedVariables<Node, Var> assignedVariables) {
+    expr._preVisit(assignedVariables);
+  }
+
+  @override
+  Type _visit(
+      Harness h, FlowAnalysis<Node, Statement, Expression, Var, Type> flow) {
+    var type = expr._visit(h, flow);
+    flow.parenthesizedExpression(this, expr);
+    return type;
+  }
+}
+
 class _PlaceholderExpression extends Expression {
   final Type type;
 
diff --git a/pkg/dds/CHANGELOG.md b/pkg/dds/CHANGELOG.md
index 953ac0b..c88de17 100644
--- a/pkg/dds/CHANGELOG.md
+++ b/pkg/dds/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 1.6.1
+- Fixed unhandled `StateError` that could be thrown if the VM service disconnected
+  while a request was outstanding.
+
 # 1.6.0
 - Added `errorCode` to `DartDevelopmentServiceException` to communicate the
   underlying reason of the failure.
diff --git a/pkg/dds/lib/src/client.dart b/pkg/dds/lib/src/client.dart
index 2c85aae..9637058 100644
--- a/pkg/dds/lib/src/client.dart
+++ b/pkg/dds/lib/src/client.dart
@@ -240,8 +240,14 @@
 
     // Unless otherwise specified, the request is forwarded to the VM service.
     // NOTE: This must be the last fallback registered.
-    _clientPeer.registerFallback((parameters) async =>
-        await _vmServicePeer.sendRequest(parameters.method, parameters.value));
+    _clientPeer.registerFallback((parameters) async {
+      try {
+        return await _vmServicePeer.sendRequest(
+            parameters.method, parameters.value);
+      } on StateError {
+        await dds.shutdown();
+      }
+    });
   }
 
   static int _idCounter = 0;
diff --git a/pkg/dds/pubspec.yaml b/pkg/dds/pubspec.yaml
index d4132a1..d0e85c6 100644
--- a/pkg/dds/pubspec.yaml
+++ b/pkg/dds/pubspec.yaml
@@ -3,7 +3,7 @@
   A library used to spawn the Dart Developer Service, used to communicate with
   a Dart VM Service instance.
 
-version: 1.6.0
+version: 1.6.1
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/dds
 
diff --git a/pkg/dds/test/handles_client_disconnect_state_error_test.dart b/pkg/dds/test/handles_client_disconnect_state_error_test.dart
index 2bca092..f500711 100644
--- a/pkg/dds/test/handles_client_disconnect_state_error_test.dart
+++ b/pkg/dds/test/handles_client_disconnect_state_error_test.dart
@@ -24,6 +24,11 @@
         // Notify listeners that this client is closed.
         doneCompleter.complete();
         break;
+      case 'foo':
+        completer.completeError(
+          StateError('The client closed with pending request "foo".'),
+        );
+        break;
       default:
         completer.complete(await super.sendRequest(method, args));
     }
@@ -61,4 +66,28 @@
     await client.close();
     await dds.done;
   });
+
+  test('StateError handled by _DartDevelopmentServiceClient request forwarder',
+      () async {
+    final dds = await DartDevelopmentService.startDartDevelopmentService(
+        Uri(scheme: 'http'));
+    final ws = await WebSocketChannel.connect(dds.uri.replace(scheme: 'ws'));
+
+    // Create a VM service client that connects to DDS.
+    final client = json_rpc.Client(ws.cast<String>());
+    unawaited(client.listen());
+
+    // Make a request that causes the VM service peer to close in the middle of
+    // handling a request. This is meant to mimic a device being disconnected
+    // unexpectedly.
+    try {
+      await client.sendRequest('foo');
+    } on StateError {
+      // This state error is expected. This test is ensuring that DDS exits
+      // gracefully even if the VM service disappears.
+    }
+
+    // DDS should shutdown if the VM service peer disconnects.
+    await dds.done;
+  });
 }
diff --git a/pkg/dev_compiler/lib/src/compiler/module_containers.dart b/pkg/dev_compiler/lib/src/compiler/module_containers.dart
new file mode 100644
index 0000000..82f06b4
--- /dev/null
+++ b/pkg/dev_compiler/lib/src/compiler/module_containers.dart
@@ -0,0 +1,259 @@
+// Copyright (c) 2020, 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.
+
+// @dart = 2.9
+
+import '../compiler/js_names.dart' as js_ast;
+import '../js_ast/js_ast.dart' as js_ast;
+import '../js_ast/js_ast.dart' show js;
+
+/// Represents a top-level property hoisted to a top-level object.
+class ModuleItemData {
+  /// The container that holds this module item in the emitted JS.
+  js_ast.Identifier id;
+
+  /// This module item's key in the emitted JS.
+  ///
+  /// A LiteralString if this object is backed by a JS Object/Map.
+  /// A LiteralNumber if this object is backed by a JS Array.
+  js_ast.Literal jsKey;
+
+  /// This module item's value in the emitted JS.
+  js_ast.Expression jsValue;
+
+  ModuleItemData(this.id, this.jsKey, this.jsValue);
+}
+
+/// Holds variables emitted during code gen.
+///
+/// Associates a [K] with a container-unique JS key and arbitrary JS value.
+/// The container is emitted as a single object:
+/// ```
+/// var C = {
+///   jsKey: jsValue,
+///   ...
+/// };
+/// ```
+class ModuleItemContainer<K> {
+  /// Name of the container in the emitted JS.
+  String name;
+
+  /// If null, this container will be automatically renamed based on [name].
+  js_ast.Identifier containerId;
+
+  final Map<K, ModuleItemData> moduleItems = {};
+
+  /// Holds keys that will not be emitted when calling [emit].
+  final Set<K> _noEmit = {};
+
+  ModuleItemContainer._(this.name, this.containerId);
+
+  /// Creates an automatically sharding container backed by JS Objects.
+  factory ModuleItemContainer.asObject(String name,
+      {String Function(K) keyToString}) {
+    return ModuleItemObjectContainer<K>(name, keyToString);
+  }
+
+  /// Creates a container backed by a JS Array.
+  factory ModuleItemContainer.asArray(String name) {
+    return ModuleItemArrayContainer<K>(name);
+  }
+
+  bool get isNotEmpty => moduleItems.isNotEmpty;
+
+  Iterable<K> get keys => moduleItems.keys;
+
+  int get length => moduleItems.keys.length;
+
+  js_ast.Expression operator [](K key) => moduleItems[key]?.jsValue;
+
+  void operator []=(K key, js_ast.Expression value) {
+    if (moduleItems.containsKey(key)) {
+      moduleItems[key].jsValue = value;
+      return;
+    }
+    var fieldString = '$key';
+    // Avoid shadowing common JS properties.
+    if (js_ast.objectProperties.contains(fieldString)) {
+      fieldString += '\$';
+    }
+    moduleItems[key] = ModuleItemData(
+        containerId, js_ast.LiteralString("'$fieldString'"), value);
+  }
+
+  /// Returns the expression that retrieves [key]'s corresponding JS value via
+  /// a property access through its container.
+  js_ast.Expression access(K key) {
+    return js.call('#.#', [containerId, moduleItems[key].jsKey]);
+  }
+
+  /// Emit the container declaration/initializer.
+  ///
+  /// May be multiple statements if the container is automatically sharded.
+  List<js_ast.Statement> emit() {
+    var properties = <js_ast.Property>[];
+    moduleItems.forEach((k, v) {
+      if (!_noEmit.contains(k)) return;
+      properties.add(js_ast.Property(v.jsKey, v.jsValue));
+    });
+    var containerObject =
+        js_ast.ObjectInitializer(properties, multiline: properties.length > 1);
+    return [
+      js.statement('var # = Object.create(#)', [containerId, containerObject])
+    ];
+  }
+
+  bool contains(K key) => moduleItems.containsKey(key);
+
+  bool canEmit(K key) => !_noEmit.contains(key);
+
+  /// Indicates that [K] should be treated as if it weren't hoisted.
+  ///
+  /// Used when we are managing the variable declarations manually (such as
+  /// unhoisting specific symbols for performance reasons).
+  void setNoEmit(K key) {
+    _noEmit.add(key);
+  }
+}
+
+/// Associates a [K] with a container-unique JS key and arbitrary JS value.
+///
+/// Emitted as a series of JS Objects, splitting them into groups of 500 for
+/// JS optimization purposes:
+/// ```
+/// var C = {
+///   jsKey: jsValue,
+///   ...
+/// };
+/// var C$1 = { ... };
+/// ```
+class ModuleItemObjectContainer<K> extends ModuleItemContainer<K> {
+  /// Holds the TemporaryId for the current container shard.
+  js_ast.Identifier _currentContainerId;
+
+  /// Tracks how often JS emitted field names appear.
+  ///
+  /// [keyToString] may resolve multiple unique keys to the same JS string.
+  /// When this occurs, the resolved JS string will automatically be renamed.
+  final Map<String, int> _nameFrequencies = {};
+
+  /// Transforms a [K] into a valid name for a JS object property key.
+  ///
+  /// Non-unique generated strings are automatically renamed.
+  String Function(K) keyToString;
+
+  ModuleItemObjectContainer(String name, this.keyToString)
+      : super._(name, null);
+
+  @override
+  void operator []=(K key, js_ast.Expression value) {
+    if (this.contains(key)) {
+      moduleItems[key].jsValue = value;
+      return;
+    }
+    if (length % 500 == 0) _currentContainerId = js_ast.TemporaryId(name);
+    // Create a unique name for K when emitted as a JS field.
+    var fieldString = keyToString(key);
+    _nameFrequencies.update(fieldString, (v) {
+      fieldString += '\$${v + 1}';
+      return v + 1;
+    }, ifAbsent: () {
+      // Avoid shadowing common JS properties.
+      if (js_ast.objectProperties.contains(fieldString)) {
+        fieldString += '\$';
+      }
+      return 0;
+    });
+    moduleItems[key] = ModuleItemData(
+        _currentContainerId, js_ast.LiteralString("'$fieldString'"), value);
+  }
+
+  @override
+  js_ast.Expression access(K key) {
+    return js.call('#.#', [moduleItems[key].id, moduleItems[key].jsKey]);
+  }
+
+  @override
+  List<js_ast.Statement> emit() {
+    var containersToProperties = <js_ast.Identifier, List<js_ast.Property>>{};
+    moduleItems.forEach((k, v) {
+      if (_noEmit.contains(k)) return;
+      if (!containersToProperties.containsKey(v.id)) {
+        containersToProperties[v.id] = <js_ast.Property>[];
+      }
+      containersToProperties[v.id].add(js_ast.Property(v.jsKey, v.jsValue));
+    });
+
+    var statements = <js_ast.Statement>[];
+    containersToProperties.forEach((containerId, properties) {
+      var containerObject = js_ast.ObjectInitializer(properties,
+          multiline: properties.length > 1);
+      statements.add(js.statement(
+          'var # = Object.create(#)', [containerId, containerObject]));
+    });
+    return statements;
+  }
+}
+
+/// Associates a unique [K] with an arbitrary JS value.
+///
+/// Emitted as a JS Array:
+/// ```
+/// var C = [
+///   jsValue,
+///   ...
+/// ];
+/// ```
+class ModuleItemArrayContainer<K> extends ModuleItemContainer<K> {
+  ModuleItemArrayContainer(String name)
+      : super._(name, js_ast.TemporaryId(name));
+
+  @override
+  void operator []=(K key, js_ast.Expression value) {
+    if (moduleItems.containsKey(key)) {
+      moduleItems[key].jsValue = value;
+      return;
+    }
+    moduleItems[key] =
+        ModuleItemData(containerId, js_ast.LiteralNumber('$length'), value);
+  }
+
+  @override
+  js_ast.Expression access(K key) {
+    return js.call('#[#]', [containerId, moduleItems[key].jsKey]);
+  }
+
+  @override
+  List<js_ast.Statement> emit() {
+    if (moduleItems.isEmpty) return [];
+    var properties = List<js_ast.Expression>(length);
+
+    // If the entire array holds just one value, generate a short initializer.
+    var valueSet = <js_ast.Expression>{};
+    moduleItems.forEach((k, v) {
+      if (_noEmit.contains(k)) return;
+      valueSet.add(v.jsValue);
+      properties[int.parse((v.jsKey as js_ast.LiteralNumber).value)] =
+          v.jsValue;
+    });
+
+    if (valueSet.length == 1 && moduleItems.length > 1) {
+      return [
+        js.statement('var # = Array(#).fill(#)', [
+          containerId,
+          js_ast.LiteralNumber('${properties.length}'),
+          valueSet.first
+        ])
+      ];
+    }
+    // Array containers are not sharded, as we do not expect to hit V8's
+    // dictionary-mode limit of 99999 elements.
+    return [
+      js.statement('var # = #', [
+        containerId,
+        js_ast.ArrayInitializer(properties, multiline: properties.length > 1)
+      ])
+    ];
+  }
+}
diff --git a/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart b/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
index e9527d9..2fcad3e 100644
--- a/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
+++ b/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
@@ -8,6 +8,7 @@
 import 'package:meta/meta.dart';
 
 import '../compiler/js_names.dart' as js_ast;
+import '../compiler/module_containers.dart' show ModuleItemContainer;
 import '../js_ast/js_ast.dart' as js_ast;
 import '../js_ast/js_ast.dart' show js;
 
@@ -25,6 +26,10 @@
   /// Private member names in this module, organized by their library.
   final _privateNames = HashMap<Library, HashMap<String, js_ast.TemporaryId>>();
 
+  /// Holds all top-level JS symbols (used for caching or indexing fields).
+  final _symbolContainer = ModuleItemContainer<js_ast.Identifier>.asObject('S',
+      keyToString: (js_ast.Identifier i) => '${i.name}');
+
   /// Extension member symbols for adding Dart members to JS types.
   ///
   /// These are added to the [extensionSymbolsModule]; see that field for more
@@ -51,11 +56,18 @@
   /// Whether we're currently building the SDK, which may require special
   /// bootstrapping logic.
   ///
-  /// This is initialized by [startModule], which must be called before
+  /// This is initialized by [emitModule], which must be called before
   /// accessing this field.
   @protected
   bool isBuildingSdk;
 
+  /// Whether or not to move top level symbols into top-level containers.
+  ///
+  /// This is set in both [emitModule] and [emitLibrary].
+  /// Depends on [isBuildingSdk].
+  @protected
+  bool containerizeSymbols;
+
   /// The temporary variable that stores named arguments (these are passed via a
   /// JS object literal, to match JS conventions).
   @protected
@@ -250,10 +262,16 @@
       var idName = name.endsWith('=') ? name.replaceAll('=', '_') : name;
       idName = idName.replaceAll(js_ast.invalidCharInIdentifier, '_');
       id ??= js_ast.TemporaryId(idName);
-      // TODO(vsm): Change back to `const`.
-      // See https://github.com/dart-lang/sdk/issues/40380.
-      moduleItems.add(js.statement('var # = #.privateName(#, #)',
-          [id, runtimeModule, emitLibraryName(library), js.string(name)]));
+      addSymbol(
+          id,
+          js.call('#.privateName(#, #)',
+              [runtimeModule, emitLibraryName(library), js.string(name)]));
+      if (!containerizeSymbols) {
+        // TODO(vsm): Change back to `const`.
+        // See https://github.com/dart-lang/sdk/issues/40380.
+        moduleItems.add(js.statement('var # = #.privateName(#, #)',
+            [id, runtimeModule, emitLibraryName(library), js.string(name)]));
+      }
       return id;
     }
 
@@ -338,9 +356,13 @@
     var name = js.escapedString(symbolName, "'");
     js_ast.Expression result;
     if (last.startsWith('_')) {
-      var nativeSymbol = emitPrivateNameSymbol(currentLibrary, last);
-      result = js.call('new #.new(#, #)',
-          [emitConstructorAccess(privateSymbolType), name, nativeSymbol]);
+      var nativeSymbolAccessor =
+          getSymbol(emitPrivateNameSymbol(currentLibrary, last));
+      result = js.call('new #.new(#, #)', [
+        emitConstructorAccess(privateSymbolType),
+        name,
+        nativeSymbolAccessor
+      ]);
     } else {
       result = js.call(
           'new #.new(#)', [emitConstructorAccess(internalSymbolType), name]);
@@ -366,12 +388,11 @@
   /// symbols into the list returned by this method. Finally, [finishModule]
   /// can be called to complete the module and return the resulting JS AST.
   ///
-  /// This also initializes several fields: [isBuildingSdk], [runtimeModule],
-  /// [extensionSymbolsModule], as well as the [_libraries] map needed by
+  /// This also initializes several fields: [runtimeModule],
+  /// [extensionSymbolsModule], and the [_libraries] map needed by
   /// [emitLibraryName].
   @protected
   List<js_ast.ModuleItem> startModule(Iterable<Library> libraries) {
-    isBuildingSdk = libraries.any(isSdkInternalRuntime);
     if (isBuildingSdk) {
       // Don't allow these to be renamed when we're building the SDK.
       // There is JS code in dart:* that depends on their names.
@@ -505,9 +526,13 @@
       if (isBuildingSdk) {
         value = js.call('# = Symbol(#)', [value, js.string('dartx.$name')]);
       }
-      // TODO(vsm): Change back to `const`.
-      // See https://github.com/dart-lang/sdk/issues/40380.
-      items.add(js.statement('var # = #;', [id, value]));
+      if (!_symbolContainer.canEmit(id)) {
+        // Extension symbols marked with noEmit are managed manually.
+        // TODO(vsm): Change back to `const`.
+        // See https://github.com/dart-lang/sdk/issues/40380.
+        items.add(js.statement('var # = #;', [id, value]));
+      }
+      _symbolContainer[id] = value;
     });
   }
 
@@ -534,6 +559,28 @@
         [runtimeModule, js.string(name), module, partMap]));
   }
 
+  /// Returns an accessor for [id] via the symbol container.
+  /// E.g., transforms $sym to S$5.$sym.
+  ///
+  /// A symbol lookup on an id marked no emit omits the symbol accessor.
+  js_ast.Expression getSymbol(js_ast.Identifier id) {
+    return _symbolContainer.canEmit(id) ? _symbolContainer.access(id) : id;
+  }
+
+  /// Returns the raw JS value associated with [id].
+  js_ast.Expression getSymbolValue(js_ast.Identifier id) {
+    return _symbolContainer[id];
+  }
+
+  /// Inserts a symbol into the symbol table.
+  js_ast.Expression addSymbol(js_ast.Identifier id, js_ast.Expression symbol) {
+    _symbolContainer[id] = symbol;
+    if (!containerizeSymbols) {
+      _symbolContainer.setNoEmit(id);
+    }
+    return _symbolContainer[id];
+  }
+
   /// Finishes the module created by [startModule], by combining the preable
   /// [items] with the [moduleItems] that have been emitted.
   ///
@@ -552,6 +599,9 @@
     // code between `startModule` and `finishModule` is very similar in both.
     _emitDebuggerExtensionInfo(moduleName);
 
+    // Emit all top-level JS symbol containers.
+    items.addAll(_symbolContainer.emit());
+
     // Add the module's code (produced by visiting compilation units, above)
     _copyAndFlattenBlocks(items, moduleItems);
     moduleItems.clear();
@@ -582,10 +632,13 @@
   /// handle the many details involved in naming.
   @protected
   js_ast.TemporaryId getExtensionSymbolInternal(String name) {
-    return _extensionSymbols.putIfAbsent(
-        name,
-        () => js_ast.TemporaryId(
-            '\$${js_ast.friendlyNameForDartOperator[name] ?? name}'));
+    if (!_extensionSymbols.containsKey(name)) {
+      var id = js_ast.TemporaryId(
+          '\$${js_ast.friendlyNameForDartOperator[name] ?? name}');
+      _extensionSymbols[name] = id;
+      addSymbol(id, id);
+    }
+    return _extensionSymbols[name];
   }
 
   /// Shorthand for identifier-like property names.
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index db85b79..8800d4c 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -22,6 +22,7 @@
 import '../compiler/js_utils.dart' as js_ast;
 import '../compiler/module_builder.dart'
     show isSdkInternalRuntimeUri, libraryUriToJsIdentifier, pathToJSIdentifier;
+import '../compiler/module_containers.dart' show ModuleItemContainer;
 import '../compiler/shared_command.dart' show SharedCompilerOptions;
 import '../compiler/shared_compiler.dart';
 import '../js_ast/js_ast.dart' as js_ast;
@@ -69,11 +70,14 @@
   /// Let variables collected for the given function.
   List<js_ast.TemporaryId> _letVariables;
 
-  final _constTable = _emitTemporaryId('CT');
+  final _constTable = js_ast.TemporaryId('CT');
 
-  // Constant getters used to populate the constant table.
+  /// Constant getters used to populate the constant table.
   final _constLazyAccessors = <js_ast.Method>[];
 
+  /// Container for holding the results of lazily-evaluated constants.
+  final _constTableCache = ModuleItemContainer<String>.asArray('C');
+
   /// Tracks the index in [moduleItems] where the const table must be inserted.
   /// Required for SDK builds due to internal circular dependencies.
   /// E.g., dart.constList depends on JSArray.
@@ -216,7 +220,7 @@
   final constAliasCache = HashMap<Constant, js_ast.Expression>();
 
   /// Maps uri strings in asserts and elsewhere to hoisted identifiers.
-  final _uriMap = HashMap<String, js_ast.Identifier>();
+  final _uriContainer = ModuleItemContainer<String>.asArray('I');
 
   final Class _jsArrayClass;
   final Class _privateSymbolClass;
@@ -323,7 +327,32 @@
 
     var libraries = component.libraries;
 
-    // Initialize our library variables.
+    // Initialize library variables.
+    isBuildingSdk = libraries.any(isSdkInternalRuntime);
+
+    // For runtime performance reasons, we only containerize SDK symbols in web
+    // libraries. Otherwise, we use a 600-member cutoff before a module is
+    // containerized. This is somewhat arbitrary but works promisingly for the
+    // SDK and Flutter Web.
+    if (!isBuildingSdk) {
+      // The number of DDC top-level symbols scales with the number of
+      // non-static class members across an entire module.
+      var uniqueNames = HashSet<String>();
+      libraries.forEach((Library l) {
+        l.classes.forEach((Class c) {
+          c.members.forEach((m) {
+            var isStatic =
+                m is Field ? m.isStatic : (m is Procedure ? m.isStatic : false);
+            if (isStatic) return;
+            var name = js_ast.toJSIdentifier(
+                m.name.text.replaceAll(js_ast.invalidCharInIdentifier, '_'));
+            uniqueNames.add(name);
+          });
+        });
+      });
+      containerizeSymbols = uniqueNames.length > 600;
+    }
+
     var items = startModule(libraries);
     _nullableInference.allowNotNullDeclarations = isBuildingSdk;
     _typeTable = TypeTable(runtimeModule);
@@ -335,10 +364,12 @@
       _pendingClasses.addAll(l.classes);
     }
 
-    // TODO(markzipan): Don't emit this when compiling the SDK.
-    moduleItems
-        .add(js.statement('const # = Object.create(null);', [_constTable]));
-    _constTableInsertionIndex = moduleItems.length;
+    // Record a safe index after the declaration of type generators and
+    // top-level symbols but before the declaration of any functions.
+    // Various preliminary data structures must be inserted here prior before
+    // referenced by the rest of the module.
+    var safeDeclarationIndex = moduleItems.length;
+    _constTableInsertionIndex = safeDeclarationIndex;
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(_coreTypes.coreLibrary);
@@ -350,22 +381,25 @@
     // This is done by forward declaring items.
     libraries.forEach(_emitLibrary);
 
+    // Emit hoisted assert strings
+    moduleItems.insertAll(safeDeclarationIndex, _uriContainer.emit());
+
+    if (_constTableCache.isNotEmpty) {
+      moduleItems.insertAll(safeDeclarationIndex, _constTableCache.emit());
+    }
+
     // This can cause problems if it's ever true during the SDK build, as it's
     // emitted before dart.defineLazy.
     if (_constLazyAccessors.isNotEmpty) {
+      var constTableDeclaration =
+          js.statement('const # = Object.create(null);', [_constTable]);
       var constTableBody = runtimeStatement(
           'defineLazy(#, { # }, false)', [_constTable, _constLazyAccessors]);
-      moduleItems.insert(_constTableInsertionIndex, constTableBody);
+      moduleItems.insertAll(
+          _constTableInsertionIndex, [constTableDeclaration, constTableBody]);
       _constLazyAccessors.clear();
     }
 
-    // Add assert locations
-    _uriMap.forEach((location, id) {
-      var value = location == null ? 'null' : js.escapedString(location);
-      moduleItems.insert(
-          _constTableInsertionIndex, js.statement('var # = #;', [id, value]));
-    });
-
     moduleItems.addAll(afterClassDefItems);
     afterClassDefItems.clear();
 
@@ -375,9 +409,8 @@
     // Declare imports and extension symbols
     emitImportsAndExtensionSymbols(items);
 
-    // Discharge the type table cache variables and
-    // hoisted definitions.
-    items.addAll(_typeTable.discharge());
+    // Emit the hoisted type table cache variables
+    items.addAll(_typeTable.dischargeBoundTypes());
 
     return finishModule(items, _options.moduleName);
   }
@@ -442,6 +475,10 @@
     _currentLibrary = library;
     _staticTypeContext.enterLibrary(_currentLibrary);
 
+    if (isBuildingSdk) {
+      containerizeSymbols = _isWebLibrary(library.importUri);
+    }
+
     if (isSdkInternalRuntime(library)) {
       // `dart:_runtime` uses a different order for bootstrapping.
       //
@@ -566,10 +603,29 @@
     _classProperties =
         ClassPropertyModel.build(_types, _extensionTypes, _virtualFields, c);
 
+    var body = <js_ast.Statement>[];
+
+    // ClassPropertyModel.build introduces symbols for virtual field accessors.
+    _classProperties.virtualFields.forEach((field, virtualField) {
+      // TODO(vsm): Clean up this logic.
+      //
+      // Typically, [emitClassPrivateNameSymbol] creates a new symbol.  If it
+      // is called multiple times, that symbol is cached.  If the former,
+      // assign directly to [virtualField].  If the latter, copy the old
+      // variable to [virtualField].
+      var symbol = emitClassPrivateNameSymbol(c.enclosingLibrary,
+          getLocalClassName(c), field.name.text, virtualField);
+      if (symbol != virtualField) {
+        addSymbol(virtualField, getSymbolValue(symbol));
+        if (!containerizeSymbols) {
+          body.add(js.statement('const # = #;', [virtualField, symbol]));
+        }
+      }
+    });
+
     var jsCtors = _defineConstructors(c, className);
     var jsMethods = _emitClassMethods(c);
 
-    var body = <js_ast.Statement>[];
     _emitSuperHelperSymbols(body);
     // Deferred supertypes must be evaluated lazily while emitting classes to
     // prevent evaluating a JS expression for a deferred type from influencing
@@ -593,7 +649,6 @@
     // Attach caches on all canonicalized types.
     body.add(runtimeStatement('addTypeCaches(#)', [className]));
 
-    _emitVirtualFieldSymbols(c, body);
     _emitClassSignature(c, className, body);
     _initExtensionSymbols(c);
     if (!c.isMixinDeclaration) {
@@ -644,7 +699,7 @@
 
     var typeConstructor = js.call('(#) => { #; #; return #; }', [
       jsFormals,
-      _typeTable.discharge(formals),
+      _typeTable.dischargeFreeTypes(formals),
       body,
       className ?? _emitIdentifier(name)
     ]);
@@ -1525,7 +1580,13 @@
 
     var body = <js_ast.Statement>[];
     void emitFieldInit(Field f, Expression initializer, TreeNode hoverInfo) {
-      var access = _classProperties.virtualFields[f] ?? _declareMemberName(f);
+      var virtualField = _classProperties.virtualFields[f];
+
+      // Avoid calling getSymbol on _declareMemberName since _declareMemberName
+      // calls _emitMemberName downstream, which already invokes getSymbol.
+      var access = virtualField == null
+          ? _declareMemberName(f)
+          : getSymbol(virtualField);
       var jsInit = _visitInitializer(initializer, f.annotations);
       body.add(jsInit
           .toAssignExpression(js.call('this.#', [access])
@@ -1912,14 +1973,16 @@
   /// wrong behavior if a new field was declared.
   List<js_ast.Method> _emitVirtualFieldAccessor(Field field) {
     var virtualField = _classProperties.virtualFields[field];
+    var virtualFieldSymbol = getSymbol(virtualField);
     var name = _declareMemberName(field);
 
-    var getter = js.fun('function() { return this[#]; }', [virtualField]);
+    var getter = js.fun('function() { return this[#]; }', [virtualFieldSymbol]);
     var jsGetter = js_ast.Method(name, getter, isGetter: true)
       ..sourceInformation = _nodeStart(field);
 
-    var args =
-        field.isFinal ? [js_ast.Super(), name] : [js_ast.This(), virtualField];
+    var args = field.isFinal
+        ? [js_ast.Super(), name]
+        : [js_ast.This(), virtualFieldSymbol];
 
     js_ast.Expression value = _emitIdentifier('value');
     if (!field.isFinal && isCovariantField(field)) {
@@ -2235,13 +2298,13 @@
       var memberLibrary = member?.name?.library ??
           memberClass?.enclosingLibrary ??
           _currentLibrary;
-      return emitPrivateNameSymbol(memberLibrary, name);
+      return getSymbol(emitPrivateNameSymbol(memberLibrary, name));
     }
 
     useExtension ??= _isSymbolizedMember(memberClass, name);
     name = js_ast.memberNameForDartMember(name, _isExternal(member));
     if (useExtension) {
-      return getExtensionSymbolInternal(name);
+      return getSymbol(getExtensionSymbolInternal(name));
     }
     return propertyName(name);
   }
@@ -2858,7 +2921,7 @@
 
       js_ast.Expression addTypeFormalsAsParameters(
           List<js_ast.Expression> elements) {
-        var names = _typeTable.discharge(typeFormals);
+        var names = _typeTable.dischargeFreeTypes(typeFormals);
         return names.isEmpty
             ? js.call('(#) => [#]', [tf, elements])
             : js.call('(#) => {#; return [#];}', [tf, names, elements]);
@@ -3006,9 +3069,8 @@
     // Issue: https://github.com/dart-lang/sdk/issues/43288
     var fun = _emitFunction(functionNode, name);
 
-    var types = _typeTable.discharge();
+    var types = _typeTable?.dischargeFreeTypes();
     var constants = _dischargeConstTable();
-
     var body = js_ast.Block([...?types, ...?constants, ...fun.body.statements]);
     return js_ast.Fun(fun.params, body);
   }
@@ -3102,22 +3164,6 @@
     return result;
   }
 
-  void _emitVirtualFieldSymbols(Class c, List<js_ast.Statement> body) {
-    _classProperties.virtualFields.forEach((field, virtualField) {
-      // TODO(vsm): Clean up this logic.  See comments on the following method.
-      //
-      // Typically, [emitClassPrivateNameSymbol] creates a new symbol.  If it
-      // is called multiple times, that symbol is cached.  If the former,
-      // assign directly to [virtualField].  If the latter, copy the old
-      // variable to [virtualField].
-      var symbol = emitClassPrivateNameSymbol(c.enclosingLibrary,
-          getLocalClassName(c), field.name.text, virtualField);
-      if (symbol != virtualField) {
-        body.add(js.statement('const # = #;', [virtualField, symbol]));
-      }
-    });
-  }
-
   List<js_ast.Identifier> _emitTypeFormals(List<TypeParameter> typeFormals) {
     return typeFormals
         .map((t) => _emitIdentifier(getTypeParameterName(t)))
@@ -3644,14 +3690,11 @@
 
   // Replace a string `uri` literal with a cached top-level variable containing
   // the value to reduce overall code size.
-  js_ast.Identifier _cacheUri(String uri) {
-    var id = _uriMap[uri];
-    if (id == null) {
-      var name = 'L${_uriMap.length}';
-      id = js_ast.TemporaryId(name);
-      _uriMap[uri] = id;
+  js_ast.Expression _cacheUri(String uri) {
+    if (!_uriContainer.contains(uri)) {
+      _uriContainer[uri] = js_ast.LiteralString('"$uri"');
     }
-    return id;
+    return _uriContainer.access(uri);
   }
 
   @override
@@ -5004,7 +5047,7 @@
           return _emitType(firstArg.type);
         }
         if (name == 'extensionSymbol' && firstArg is StringLiteral) {
-          return getExtensionSymbolInternal(firstArg.value);
+          return getSymbol(getExtensionSymbolInternal(firstArg.value));
         }
 
         if (name == 'compileTimeFlag' && firstArg is StringLiteral) {
@@ -5880,19 +5923,19 @@
     }
     var constAliasString = 'C${constAliasCache.length}';
     var constAliasProperty = propertyName(constAliasString);
-    var constAliasId = _emitTemporaryId(constAliasString);
-    var constAccessor =
-        js.call('# || #.#', [constAliasId, _constTable, constAliasProperty]);
+
+    _constTableCache[constAliasString] = js.call('void 0');
+    var constAliasAccessor = _constTableCache.access(constAliasString);
+
+    var constAccessor = js.call(
+        '# || #.#', [constAliasAccessor, _constTable, constAliasProperty]);
     constAliasCache[node] = constAccessor;
     var constJs = super.visitConstant(node);
-    // TODO(vsm): Change back to `let`.
-    // See https://github.com/dart-lang/sdk/issues/40380.
-    moduleItems.add(js.statement('var #;', [constAliasId]));
 
     var func = js_ast.Fun(
         [],
         js_ast.Block([
-          js.statement('return # = #;', [constAliasId, constJs])
+          js.statement('return # = #;', [constAliasAccessor, constJs])
         ]));
     var accessor = js_ast.Method(constAliasProperty, func, isGetter: true);
     _constLazyAccessors.add(accessor);
@@ -5978,8 +6021,8 @@
       // was overridden.
       var symbol = cls.isEnum
           ? _emitMemberName(member.name.text, member: member)
-          : emitClassPrivateNameSymbol(
-              cls.enclosingLibrary, getLocalClassName(cls), member.name.text);
+          : getSymbol(emitClassPrivateNameSymbol(
+              cls.enclosingLibrary, getLocalClassName(cls), member.name.text));
       return js_ast.Property(symbol, constant);
     }
 
diff --git a/pkg/dev_compiler/lib/src/kernel/type_table.dart b/pkg/dev_compiler/lib/src/kernel/type_table.dart
index ddaf27f..b9b73fd 100644
--- a/pkg/dev_compiler/lib/src/kernel/type_table.dart
+++ b/pkg/dev_compiler/lib/src/kernel/type_table.dart
@@ -4,13 +4,17 @@
 
 // @dart = 2.9
 
+import 'dart:collection';
+
 import 'package:kernel/kernel.dart';
 
 import '../compiler/js_names.dart' as js_ast;
+import '../compiler/module_containers.dart' show ModuleItemContainer;
 import '../js_ast/js_ast.dart' as js_ast;
 import '../js_ast/js_ast.dart' show js;
 import 'kernel_helpers.dart';
 
+/// Returns all non-locally defined type parameters referred to by [t].
 Set<TypeParameter> freeTypeParameters(DartType t) {
   assert(isKnownDartTypeImplementor(t));
   var result = <TypeParameter>{};
@@ -36,160 +40,144 @@
   return result;
 }
 
-/// _CacheTable tracks cache variables for variables that
-/// are emitted in place with a hoisted variable for a cache.
-class _CacheTable {
-  /// Mapping from types to their canonical names.
-  // Use a LinkedHashMap to maintain key insertion order so the generated code
-  // is stable under slight perturbation.  (If this is not good enough we could
-  // sort by name to canonicalize order.)
-  final _names = <DartType, js_ast.TemporaryId>{};
-  Iterable<DartType> get keys => _names.keys.toList();
-
-  js_ast.Statement _dischargeType(DartType type) {
-    var name = _names.remove(type);
-    if (name != null) {
-      return js.statement('let #;', [name]);
-    }
-    return null;
+/// A name for a type made of JS identifier safe characters.
+///
+/// 'L' and 'N' are prepended to a type name to represent a legacy or nullable
+/// flavor of a type.
+String _typeString(DartType type, {bool flat = false}) {
+  var nullability = type.declaredNullability == Nullability.legacy
+      ? 'L'
+      : type.declaredNullability == Nullability.nullable
+          ? 'N'
+          : '';
+  assert(isKnownDartTypeImplementor(type));
+  if (type is InterfaceType) {
+    var name = '${type.classNode.name}$nullability';
+    var typeArgs = type.typeArguments;
+    if (typeArgs == null) return name;
+    if (typeArgs.every((p) => p == const DynamicType())) return name;
+    return "${name}Of${typeArgs.map(_typeString).join("\$")}";
   }
-
-  /// Emit a list of statements declaring the cache variables for
-  /// types tracked by this table.  If [typeFilter] is given,
-  /// only emit the types listed in the filter.
-  List<js_ast.Statement> discharge([Iterable<DartType> typeFilter]) {
-    var decls = <js_ast.Statement>[];
-    var types = typeFilter ?? keys;
-    for (var t in types) {
-      var stmt = _dischargeType(t);
-      if (stmt != null) decls.add(stmt);
-    }
-    return decls;
+  if (type is FutureOrType) {
+    var name = 'FutureOr$nullability';
+    if (type.typeArgument == const DynamicType()) return name;
+    return '${name}Of${_typeString(type.typeArgument)}';
   }
-
-  bool isNamed(DartType type) => _names.containsKey(type);
-
-  /// A name for a type made of JS identifier safe characters.
-  ///
-  /// 'L' and 'N' are prepended to a type name to represent a legacy or nullable
-  /// flavor of a type.
-  String _typeString(DartType type, {bool flat = false}) {
-    var nullability = type.declaredNullability == Nullability.legacy
-        ? 'L'
-        : type.declaredNullability == Nullability.nullable
-            ? 'N'
-            : '';
-    assert(isKnownDartTypeImplementor(type));
-    if (type is InterfaceType) {
-      var name = '${type.classNode.name}$nullability';
-      var typeArgs = type.typeArguments;
-      if (typeArgs == null) return name;
-      if (typeArgs.every((p) => p == const DynamicType())) return name;
-      return "${name}Of${typeArgs.map(_typeString).join("\$")}";
-    }
-    if (type is FutureOrType) {
-      var name = 'FutureOr$nullability';
-      if (type.typeArgument == const DynamicType()) return name;
-      return '${name}Of${_typeString(type.typeArgument)}';
-    }
-    if (type is TypedefType) {
-      var name = '${type.typedefNode.name}$nullability';
-      var typeArgs = type.typeArguments;
-      if (typeArgs == null) return name;
-      if (typeArgs.every((p) => p == const DynamicType())) return name;
-      return "${name}Of${typeArgs.map(_typeString).join("\$")}";
-    }
-    if (type is FunctionType) {
-      if (flat) return 'Fn';
-      var rType = _typeString(type.returnType, flat: true);
-      var params = type.positionalParameters
-          .take(3)
-          .map((p) => _typeString(p, flat: true));
-      var paramList = params.join('And');
-      var count = type.positionalParameters.length;
-      if (count > 3 || type.namedParameters.isNotEmpty) {
-        paramList = '${paramList}__';
-      } else if (count == 0) {
-        paramList = 'Void';
-      }
-      return '${paramList}To$nullability$rType';
-    }
-    if (type is TypeParameterType) return '${type.parameter.name}$nullability';
-    if (type is DynamicType) return 'dynamic';
-    if (type is VoidType) return 'void';
-    if (type is NeverType) return 'Never$nullability';
-    if (type is BottomType) return 'bottom';
-    if (type is NullType) return 'Null';
-    return 'invalid';
+  if (type is TypedefType) {
+    var name = '${type.typedefNode.name}$nullability';
+    var typeArgs = type.typeArguments;
+    if (typeArgs == null) return name;
+    if (typeArgs.every((p) => p == const DynamicType())) return name;
+    return "${name}Of${typeArgs.map(_typeString).join("\$")}";
   }
-
-  /// Heuristically choose a good name for the cache and generator
-  /// variables.
-  js_ast.TemporaryId chooseTypeName(DartType type) {
-    return js_ast.TemporaryId(escapeIdentifier(_typeString(type)));
-  }
-}
-
-/// _GeneratorTable tracks types which have been
-/// named and hoisted.
-class _GeneratorTable extends _CacheTable {
-  final _defs = <DartType, js_ast.Expression>{};
-
-  final js_ast.Identifier _runtimeModule;
-
-  _GeneratorTable(this._runtimeModule);
-
-  @override
-  js_ast.Statement _dischargeType(DartType t) {
-    var name = _names.remove(t);
-    if (name != null) {
-      var init = _defs.remove(t);
-      assert(init != null);
-      // TODO(vsm): Change back to `let`.
-      // See https://github.com/dart-lang/sdk/issues/40380.
-      return js.statement('var # = () => ((# = #.constFn(#))());',
-          [name, name, _runtimeModule, init]);
+  if (type is FunctionType) {
+    if (flat) return 'Fn';
+    var rType = _typeString(type.returnType, flat: true);
+    var params = type.positionalParameters
+        .take(3)
+        .map((p) => _typeString(p, flat: true));
+    var paramList = params.join('And');
+    var count = type.positionalParameters.length;
+    if (count > 3 || type.namedParameters.isNotEmpty) {
+      paramList = '${paramList}__';
+    } else if (count == 0) {
+      paramList = 'Void';
     }
-    return null;
+    return '${paramList}To$nullability$rType';
   }
-
-  /// If [type] does not already have a generator name chosen for it,
-  /// assign it one, using [typeRep] as the initializer for it.
-  /// Emit the generator name.
-  js_ast.TemporaryId _nameType(DartType type, js_ast.Expression typeRep) {
-    var temp = _names[type];
-    if (temp == null) {
-      _names[type] = temp = chooseTypeName(type);
-      _defs[type] = typeRep;
-    }
-    return temp;
-  }
+  if (type is TypeParameterType) return '${type.parameter.name}$nullability';
+  if (type is DynamicType) return 'dynamic';
+  if (type is VoidType) return 'void';
+  if (type is NeverType) return 'Never$nullability';
+  if (type is BottomType) return 'bottom';
+  if (type is NullType) return 'Null';
+  return 'invalid';
 }
 
 class TypeTable {
-  /// Generator variable names for hoisted types.
-  final _GeneratorTable _generators;
-
   /// Mapping from type parameters to the types which must have their
   /// cache/generator variables discharged at the binding site for the
   /// type variable since the type definition depends on the type
   /// parameter.
   final _scopeDependencies = <TypeParameter, List<DartType>>{};
 
-  TypeTable(js_ast.Identifier runtime) : _generators = _GeneratorTable(runtime);
+  /// Contains types with any free type parameters and maps them to a unique
+  /// JS identifier.
+  ///
+  /// Used to reference types hoisted to the top of a generic class or generic
+  /// function (as opposed to the top of the entire module).
+  final _unboundTypeIds = HashMap<DartType, js_ast.Identifier>();
 
-  /// Emit a list of statements declaring the cache variables and generator
-  /// definitions tracked by the table.  If [formals] is present, only
-  /// emit the definitions which depend on the formals.
-  List<js_ast.Statement> discharge([List<TypeParameter> formals]) {
-    var filter = formals?.expand((p) => _scopeDependencies[p] ?? <DartType>[]);
-    var stmts = _generators.discharge(filter);
-    formals?.forEach(_scopeDependencies.remove);
-    return stmts;
+  /// Holds JS type generators keyed by their underlying DartType.
+  final typeContainer = ModuleItemContainer<DartType>.asObject('T',
+      keyToString: (DartType t) => escapeIdentifier(_typeString(t)));
+
+  final js_ast.Identifier _runtimeModule;
+
+  TypeTable(this._runtimeModule);
+
+  /// Returns true if [type] is already recorded in the table.
+  bool _isNamed(DartType type) =>
+      typeContainer.contains(type) || _unboundTypeIds.containsKey(type);
+
+  /// Emit the initializer statements for the type container, which contains
+  /// all named types with fully bound type parameters.
+  List<js_ast.Statement> dischargeBoundTypes() {
+    for (var t in typeContainer.keys) {
+      typeContainer[t] = js.call('() => ((# = #.constFn(#))())',
+          [typeContainer.access(t), _runtimeModule, typeContainer[t]]);
+    }
+    return typeContainer.emit();
   }
 
-  /// Record the dependencies of the type on its free variables
+  js_ast.Statement _dischargeFreeType(DartType type) {
+    typeContainer.setNoEmit(type);
+    var init = typeContainer[type];
+    var id = _unboundTypeIds[type];
+    // TODO(vsm): Change back to `let`.
+    // See https://github.com/dart-lang/sdk/issues/40380.
+    return js.statement('var # = () => ((# = #.constFn(#))());',
+        [id, id, _runtimeModule, init]);
+  }
+
+  /// Emit a list of statements declaring the cache variables and generator
+  /// definitions tracked by the table so far.
+  ///
+  /// If [formals] is present, only emit the definitions which depend on the
+  /// formals.
+  List<js_ast.Statement> dischargeFreeTypes([Iterable<TypeParameter> formals]) {
+    var decls = <js_ast.Statement>[];
+    var types = formals == null
+        ? typeContainer.keys.where((p) => freeTypeParameters(p).isNotEmpty)
+        : formals.expand((p) => _scopeDependencies[p] ?? <DartType>[]).toSet();
+
+    for (var t in types) {
+      var stmt = _dischargeFreeType(t);
+      if (stmt != null) decls.add(stmt);
+    }
+    return decls;
+  }
+
+  /// Emit a JS expression that evaluates to the generator for [type].
+  ///
+  /// If [type] does not already have a generator name chosen for it,
+  /// assign it one, using [typeRep] as its initializer.
+  js_ast.Expression _nameType(DartType type, js_ast.Expression typeRep) {
+    if (!typeContainer.contains(type)) {
+      typeContainer[type] = typeRep;
+    }
+    return _unboundTypeIds[type] ?? typeContainer.access(type);
+  }
+
+  /// Record the dependencies of the type on its free variables.
+  ///
+  /// Returns true if [type] is a free type parameter (but not a bound) and so
+  /// is not locally hoisted.
   bool recordScopeDependencies(DartType type) {
+    if (_isNamed(type)) {
+      return false;
+    }
+
     var freeVariables = freeTypeParameters(type);
     // TODO(leafp): This is a hack to avoid trying to hoist out of
     // generic functions and generic function types.  This often degrades
@@ -200,6 +188,17 @@
       return true;
     }
 
+    // This is only reached when [type] is itself a bound that depends on a
+    // free type parameter.
+    // TODO(markzipan): Bounds are locally hoisted to their own JS identifiers,
+    // but we don't do this this for other types that depend on free variables,
+    // resulting in some duplicated runtime code. We may get some performance
+    // wins if we just locally hoist everything.
+    if (freeVariables.isNotEmpty) {
+      _unboundTypeIds[type] =
+          js_ast.TemporaryId(escapeIdentifier(_typeString(type)));
+    }
+
     for (var free in freeVariables) {
       // If `free` is a promoted type parameter, get the original one so we can
       // find it in our map.
@@ -212,10 +211,10 @@
   /// add the type and its representation to the table, returning an
   /// expression which implements the type (but which caches the value).
   js_ast.Expression nameType(DartType type, js_ast.Expression typeRep) {
-    if (!_generators.isNamed(type) && recordScopeDependencies(type)) {
+    if (recordScopeDependencies(type)) {
       return typeRep;
     }
-    var name = _generators._nameType(type, typeRep);
+    var name = _nameType(type, typeRep);
     return js.call('#()', [name]);
   }
 
@@ -228,10 +227,10 @@
   js_ast.Expression nameFunctionType(
       FunctionType type, js_ast.Expression typeRep,
       {bool lazy = false}) {
-    if (!_generators.isNamed(type) && recordScopeDependencies(type)) {
+    if (recordScopeDependencies(type)) {
       return lazy ? js_ast.ArrowFun([], typeRep) : typeRep;
     }
-    var name = _generators._nameType(type, typeRep);
+    var name = _nameType(type, typeRep);
     return lazy ? name : js.call('#()', [name]);
   }
 }
diff --git a/tests/lib/lib_dart2js.status b/tests/lib/lib_dart2js.status
index 14a0a1a..d66a2c8 100644
--- a/tests/lib/lib_dart2js.status
+++ b/tests/lib/lib_dart2js.status
@@ -23,6 +23,8 @@
 html/xhr_test: Slow, Pass
 isolate/*: SkipByDesign # No support for dart:isolate in dart4web (http://dartbug.com/30538)
 mirrors/*: SkipByDesign # Mirrors not supported on web in Dart 2.0.
+typed_data/int64_list_load_store_test: SkipByDesign # No support for Int64List
+typed_data/typed_data_hierarchy_int64_test: SkipByDesign # No support for Int64List
 wasm/*: SkipByDesign # dart:wasm not currently supported on web.
 
 [ $compiler != dart2js ]
diff --git a/tests/lib_2/typed_data/int32x4_arithmetic_test.dart b/tests/lib_2/typed_data/int32x4_arithmetic_test.dart
index 6f08626..f9a740e 100644
--- a/tests/lib_2/typed_data/int32x4_arithmetic_test.dart
+++ b/tests/lib_2/typed_data/int32x4_arithmetic_test.dart
@@ -91,16 +91,35 @@
   Expect.equals(1, o.w);
 }
 
+const int53 = 0x20000000000000; // 2^53.
+final usingJavaScriptNumbers = (int53 + 1) == int53;
+
 testTruncation() {
-  var n = 0xAABBCCDD00000001;
-  var x = new Int32x4(n, 0, 0, 0);
-  Expect.equals(x.x, 1);
+  // Check that various bits from bit 32 and up are masked away.
+  var base = usingJavaScriptNumbers ? 0x1BCCDD00000000 : 0xAABBCCDD00000000;
+  var x1 = new Int32x4(base + 1, 0, 0, 0);
+  Expect.equals(1, x1.x);
+
+  // Check that all even bits up to bit 30 are preserved.
+  var x2 = new Int32x4(base + 0x55555555, 0, 0, 0);
+  Expect.equals(0x55555555, x2.x);
+
+  // Check that the odd bits up to bit 31 are preserved, and that
+  // bit 31 is treated as a sign bit.
+  var x3 = new Int32x4(base + 0xAAAAAAAA, 0, 0, 0);
+  const signExtended = -1431655766; // 0xFFFFFFFFAAAAAAAA or 0x3FFFFFAAAAAAAA.
+  Expect.equals(signExtended, x3.x);
+
+  // Check that all bits from bit 32 and up are masked away.
+  var highBase = 0xFFFFFFFF10000000;
+  var x4 = new Int32x4(highBase, 0, 0, 0);
+  Expect.equals(0x10000000, x4.x);
 }
 
 main() {
   for (int i = 0; i < 20; i++) {
     testAdd();
     testSub();
-    testTruncation(); //   //# int64: ok
+    testTruncation();
   }
 }
diff --git a/tools/VERSION b/tools/VERSION
index 39a0b88..e1df069 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 119
+PRERELEASE 120
 PRERELEASE_PATCH 0
\ No newline at end of file