fix #27259, implement covariance checking for strong mode and DDC

pkg/dev_compiler/lib/src/compiler/type_utilities.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet, LinkedHashMap;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 
 import '../js_ast/js_ast.dart' as JS;
@@ skipping 133 matching lines @@
     var temp = _names[type];
     if (temp == null) {
       _names[type] = temp = chooseTypeName(type);
       _defs[type] = typeRep;
     }
     return js.call('#()', [temp]);
   }
 }
 
 class TypeTable {
-  /// Cache variable names for types emitted in place.
-  final _cacheNames = new _CacheTable();
-
-  /// Cache variable names for definite function types emitted in place.
-  final _definiteCacheNames = new _CacheTable();
-
   /// Generator variable names for hoisted types.
   final _GeneratorTable _generators;
 
   /// Generator variable names for hoisted definite function types.
   final _GeneratorTable _definiteGenerators;
 
   /// 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 =
       new HashMap<TypeParameterElement, List<DartType>>();
 
   TypeTable(JS.Identifier runtime)
       : _generators = new _GeneratorTable(runtime),
         _definiteGenerators = new _GeneratorTable(runtime);
 
   /// 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.Statement> discharge([List<TypeParameterElement> formals]) {
     var filter = formals?.expand((p) => _scopeDependencies[p] ?? <DartType>[]);
-    var stmts = [
-      _cacheNames,
-      _definiteCacheNames,
-      _generators,
-      _definiteGenerators
-    ].expand((c) => c.discharge(filter)).toList();
+    var stmts = [_generators, _definiteGenerators]
+        .expand((c) => c.discharge(filter))
+        .toList();
     formals?.forEach(_scopeDependencies.remove);
     return stmts;
   }
 
   /// Record the dependencies of the type on its free variables
   bool recordScopeDependencies(DartType type) {
     var fvs = freeTypeParameters(type);
     // TODO(leafp): This is a hack to avoid trying to hoist out of
     // generic functions and generic function types.  This often degrades
     // readability to little or no benefit.  It would be good to do this
@@ skipping 28 matching lines @@
   /// initializer expression will be emitted in place.  The generated code
   /// for dart.is(x, type) in this case ends up as:
   ///   let generator = () => (generator = dart.constFn(type))()
   ///   ....
   ///   dart.is(x, generator())
   ///
   /// The boolean parameter [definite] distinguishes between definite function
   /// types and other types (since the same DartType may have different
   /// representations as definite and indefinite function types).
   JS.Expression nameType(DartType type, JS.Expression typeRep,
-      {bool hoistType, bool definite: false}) {
-    assert(hoistType != null);
-    var table = hoistType
-        ? (definite ? _definiteGenerators : _generators)
-        : (definite ? _definiteCacheNames : _cacheNames);
+      {bool definite: false}) {
+    var table = definite ? _definiteGenerators : _generators;
     if (!table.isNamed(type)) {
       if (recordScopeDependencies(type)) return typeRep;
     }
     return table.nameType(type, typeRep);
   }
 }