fix #27155, do not push down dynamic as context type

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 4945 matching lines @@
       return t.types;
     }
     return <DartType>[t];
   }
 
   /**
    * Attach contextual type information [type] to [node] for use during
    * inference.
    */
   static void setType(AstNode node, DartType type) {
-    node?.setProperty(_typeProperty, type);
+    if (type == null || type.isDynamic) {
+      clearType(node);
+    } else {
+      node?.setProperty(_typeProperty, type);
+    }
   }
 
   /**
    * Attach contextual type information [type] to [node] for use during
    * inference.
    */
   static void setTypeFromNode(AstNode innerNode, AstNode outerNode) {
     setType(innerNode, getContext(outerNode));
   }
 }
@@ skipping 1641 matching lines @@
             if (isFutureThen(node.staticParameterElement?.enclosingElement)) {
               var futureThenType =
                   InferenceContext.getContext(node.parent) as FunctionType;
 
               // Pretend the return type of Future<T>.then<S> first parameter is
               //
               //     T -> (S | Future<S>)
               //
               // We can't represent this in Dart so we populate it here during
               // inference.
-              returnType = FutureUnionType.from(
-                  futureThenType.returnType, typeProvider, typeSystem);
+              var typeParamS =
+                  futureThenType.returnType.flattenFutures(typeSystem);
+              returnType =
+                    FutureUnionType.from(typeParamS, typeProvider, typeSystem);
             } else {
               returnType = _computeReturnOrYieldType(functionType.returnType);
             }
 
             InferenceContext.setType(node.body, returnType);
           }
         }
         super.visitFunctionExpression(node);
       } finally {
         _overrideManager.exitScope();
@@ skipping 538 matching lines @@
         // If it's async* we expect Stream<T>
         InterfaceType rawType = isAsynchronous
             ? typeProvider.streamDynamicType
             : typeProvider.iterableDynamicType;
         // Match the types to instantiate the type arguments if possible
         List<DartType> typeArgs =
             inferenceContext.matchTypes(rawType, declaredType);
         return (typeArgs?.length == 1) ? typeArgs[0] : null;
       }
       // async functions expect `Future<T> | T`
-      return new FutureUnionType(declaredType, typeProvider, typeSystem);
+      var futureTypeParam = declaredType.flattenFutures(typeSystem);
+      return FutureUnionType.from(futureTypeParam, typeProvider, typeSystem);
     }
     return declaredType;
   }
 
   /**
    * The given expression is the expression used to compute the iterator for a
    * for-each statement. Attempt to compute the type of objects that will be
    * assigned to the loop variable and return that type. Return `null` if the
    * type could not be determined. The [iteratorExpression] is the expression
    * that will return the Iterable being iterated over.
@@ skipping 3972 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }