fix typo in future union inference code

pkg/analyzer/lib/src/generated/type_system.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.
 
 library analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 1577 matching lines @@
       //
       // We need to track in `inferGenericFunctionCall` whether we are going up
       // or down. This would also allow for an improved heuristic: if we are
       // doing our final inference, the downward context can take priority.
       if (lowerBound is FutureUnionType) {
         // lowerBound <: T, where lowerBound is Future<A> | A.
         // So we choose lowerBound as LUB(A, Future<A>).
         //
         // This will typically lead to top with the current rules, but it will
         // work with `bottom` or if we remove Future flattening.
-        var f = upperBound as FutureUnionType;
+        var f = lowerBound as FutureUnionType;
         lowerBound = _typeSystem.getLeastUpperBound(
             _typeProvider, f.futureOfType, f.type);
       }
       if (upperBound is FutureUnionType) {
         // T <: upperBound, where upperBound is Future<A> | A.
         // Therefore we need T <: Future<A> or T <: A.
         //
         // This is just an arbitrarily heuristic.
         var f = upperBound as FutureUnionType;
         if (_typeSystem.isSubtypeOf(lowerBound, f.type)) {
@@ skipping 183 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }