diff --git a/pkg/analyzer/lib/src/dart/element/generic_inferrer.dart b/pkg/analyzer/lib/src/dart/element/generic_inferrer.dart
index a842f66..48ebefc 100644
--- a/pkg/analyzer/lib/src/dart/element/generic_inferrer.dart
+++ b/pkg/analyzer/lib/src/dart/element/generic_inferrer.dart
@@ -71,6 +71,31 @@
   /// type arguments are allowed to be instantiated with generic function types.
   final bool genericMetadataIsEnabled;
 
+  /// The set of type parameters for which a previous inference phase has
+  /// "fixed" a type; no further constraints will be added for types in this
+  /// list.
+  ///
+  /// Background: sometimes the upwards inference phase of generic type
+  /// inference is capable of assigning a more specific type than the downwards
+  /// inference phase, but we don't want to use the more specific type due to
+  /// Dart's "runtime checked covariant generics" design.  For example, in this
+  /// code:
+  ///
+  ///     List<num> x = [1, 2, 3];
+  ///     x.add(4.0);
+  ///
+  /// Downwards inference provisionally considers the list to be a `List<num>`.
+  /// Without this heuristic, upwards inference would refine the type to
+  /// `List<int>`, leading to a runtime failure.  So what we do is "fix" the
+  /// type parameter to `num` after downwards inference, preventing upwards
+  /// inference from doing any further refinement.
+  ///
+  /// (Note that the heuristic isn't needed for type parameters whose variance
+  /// is explicitly specified using the as-yet-unreleased "variance" feature,
+  /// since type parameters whose variance is explicitly specified don't undergo
+  /// implicit runtime checks).
+  final Set<TypeParameterElement> _fixedTypeParameters = {};
+
   GenericInferrer(this._typeSystem, this._typeFormals,
       {this.errorReporter,
       this.errorNode,
@@ -170,7 +195,7 @@
     if (success) {
       var constraints = gatherer.computeConstraints();
       for (var entry in constraints.entries) {
-        if (!entry.value.isEmpty) {
+        if (!entry.value.isEmpty && !_fixedTypeParameters.contains(entry.key)) {
           var constraint = _constraints[entry.key]!;
           constraint.add(
             _TypeConstraint(origin, entry.key,
@@ -444,12 +469,20 @@
       }
 
       var constraints = _constraints[typeParam]!;
-      inferredTypes[i] = downwardsInferPhase
-          ? _inferTypeParameterFromContext(constraints, extendsClause,
-              isContravariant: typeParam.variance.isContravariant)
-          : _inferTypeParameterFromAll(constraints, extendsClause,
-              isContravariant: typeParam.variance.isContravariant,
-              preferUpwardsInference: !typeParam.isLegacyCovariant);
+      if (downwardsInferPhase) {
+        var inferredType = _inferTypeParameterFromContext(
+            constraints, extendsClause,
+            isContravariant: typeParam.variance.isContravariant);
+        inferredTypes[i] = inferredType;
+        if (typeParam.isLegacyCovariant &&
+            UnknownInferredType.isKnown(inferredTypes[i])) {
+          _fixedTypeParameters.add(typeParam);
+        }
+      } else {
+        inferredTypes[i] = _inferTypeParameterFromAll(
+            constraints, extendsClause,
+            isContravariant: typeParam.variance.isContravariant);
+      }
     }
 
     return inferredTypes;
@@ -493,20 +526,7 @@
 
   DartType _inferTypeParameterFromAll(
       List<_TypeConstraint> constraints, _TypeConstraint? extendsClause,
-      {required bool isContravariant, required bool preferUpwardsInference}) {
-    // See if we already fixed this type from downwards inference.
-    // If so, then we aren't allowed to change it based on argument types unless
-    // [preferUpwardsInference] is true.
-    DartType t = _inferTypeParameterFromContext(
-        constraints.where((c) => c.isDownwards), extendsClause,
-        isContravariant: isContravariant);
-    if (!preferUpwardsInference && UnknownInferredType.isKnown(t)) {
-      // Remove constraints that aren't downward ones; we'll ignore these for
-      // error reporting, because inference already succeeded.
-      constraints.removeWhere((c) => !c.isDownwards);
-      return t;
-    }
-
+      {required bool isContravariant}) {
     if (extendsClause != null) {
       constraints = constraints.toList()..add(extendsClause);
     }
@@ -692,8 +712,6 @@
             element,
             upper: extendsType);
 
-  bool get isDownwards => origin is! _TypeConstraintFromArgument;
-
   bool isSatisfiedBy(TypeSystemImpl ts, DartType type) {
     return ts.isSubtypeOf(lowerBound, type) && ts.isSubtypeOf(type, upperBound);
   }
diff --git a/runtime/bin/process_win.cc b/runtime/bin/process_win.cc
index c34b003..1811456 100644
--- a/runtime/bin/process_win.cc
+++ b/runtime/bin/process_win.cc
@@ -553,6 +553,18 @@
         EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT;
     if (!Process::ModeIsAttached(mode_)) {
       creation_flags |= DETACHED_PROCESS;
+    } else {
+      // Unless we are inherting stdio which means there is some console
+      // associated with the app, we want to ensure no console window pops
+      // up for the spawned child.
+      if (mode_ != kInheritStdio) {
+        // Normally stdout for console dart application is associated with a
+        // console that is launched from, but for gui applications(flutter on
+        // windows) console might be absent, will be created by CreateProcessW
+        // below. When that happens we ensure that console window doesn't
+        // pop up.
+        creation_flags |= CREATE_NO_WINDOW;
+      }
     }
     BOOL result = CreateProcessW(
         NULL,  // ApplicationName
diff --git a/tools/VERSION b/tools/VERSION
index d2dbbe7..3c4f687 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 210
+PRERELEASE 211
 PRERELEASE_PATCH 0
\ No newline at end of file