diff --git a/pkg/analyzer/lib/src/dart/resolver/yield_statement_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/yield_statement_resolver.dart
index f810900..9928a16 100644
--- a/pkg/analyzer/lib/src/dart/resolver/yield_statement_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/yield_statement_resolver.dart
@@ -17,11 +17,6 @@
 class YieldStatementResolver {
   final ResolverVisitor _resolver;
 
-  /// The element type required by the declared return type of the enclosing
-  /// function. Note, that for function expressions the declared return type
-  /// can be obtained by means of type inference.
-  DartType _elementType;
-
   YieldStatementResolver({
     @required ResolverVisitor resolver,
   }) : _resolver = resolver;
@@ -75,66 +70,62 @@
   ///
   /// This method should only be called in generator functions.
   void _checkForYieldOfInvalidType(YieldStatement node, bool isYieldEach) {
-    var expressionType = node.expression.staticType;
+    var declaredReturnType = _enclosingFunction.returnType;
 
-    if (node.star == null) {
-      if (!_typeSystem.isAssignableTo2(expressionType, _elementType)) {
-        _errorReporter.reportErrorForNode(
-          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-          node.expression,
-          [expressionType, _elementType],
-        );
-      }
-      return;
+    var expression = node.expression;
+    var expressionType = expression.staticType;
+
+    DartType impliedReturnType;
+    if (isYieldEach) {
+      impliedReturnType = expressionType;
+    } else if (_enclosingFunction.isSynchronous) {
+      impliedReturnType = _typeProvider.iterableType2(expressionType);
+    } else {
+      impliedReturnType = _typeProvider.streamType2(expressionType);
     }
 
-    DartType yieldElementType;
-    if (expressionType is InterfaceTypeImpl) {
-      var sequenceType = expressionType.asInstanceOf(
-        _typeProvider.iterableElement,
-      );
-      sequenceType ??= expressionType.asInstanceOf(
-        _typeProvider.streamElement,
-      );
-      if (sequenceType != null) {
-        yieldElementType = sequenceType.typeArguments[0];
-      }
-    }
-
-    if (yieldElementType == null) {
-      if (_typeSystem.isTop(expressionType) || expressionType.isDartCoreNull) {
-        yieldElementType = DynamicTypeImpl.instance;
-      } else {
+    if (declaredReturnType != null) {
+      if (!_typeSystem.isAssignableTo2(impliedReturnType, declaredReturnType)) {
         _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-          node.expression,
-          [expressionType, _elementType],
+          expression,
+          [impliedReturnType, declaredReturnType],
         );
         return;
       }
     }
 
-    if (!_typeSystem.isAssignableTo2(yieldElementType, _elementType)) {
-      _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-        node.expression,
-        [yieldElementType, _elementType],
-      );
+    if (isYieldEach) {
+      // Since the declared return type might have been "dynamic", we need to
+      // also check that the implied return type is assignable to generic
+      // Iterable/Stream.
+      DartType requiredReturnType;
+      if (_enclosingFunction.isSynchronous) {
+        requiredReturnType = _typeProvider.iterableDynamicType;
+      } else {
+        requiredReturnType = _typeProvider.streamDynamicType;
+      }
+
+      if (!_typeSystem.isAssignableTo2(impliedReturnType, requiredReturnType)) {
+        _errorReporter.reportErrorForNode(
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          expression,
+          [impliedReturnType, requiredReturnType],
+        );
+      }
     }
   }
 
   void _computeElementType(YieldStatement node) {
-    _elementType = _resolver.inferenceContext.returnContext;
-    if (_elementType != null) {
-      var contextType = _elementType;
+    var elementType = _resolver.inferenceContext.returnContext;
+    if (elementType != null) {
+      var contextType = elementType;
       if (node.star != null) {
         contextType = _enclosingFunction.isSynchronous
-            ? _typeProvider.iterableType2(_elementType)
-            : _typeProvider.streamType2(_elementType);
+            ? _typeProvider.iterableType2(elementType)
+            : _typeProvider.streamType2(elementType);
       }
       InferenceContext.setType(node.expression, contextType);
-    } else {
-      _elementType ??= DynamicTypeImpl.instance;
     }
   }
 
diff --git a/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart b/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
index 7892e62..8963c73 100644
--- a/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/yield_of_invalid_type_test.dart
@@ -19,14 +19,18 @@
 @reflectiveTest
 class YieldOfInvalidTypeTest extends DriverResolutionTest {
   test_none_asyncStar_dynamic_to_streamInt() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode(
+        '''
 import 'dart:async';
 
 Stream<int> f() async* {
   dynamic a = 0;
   yield a;
 }
-''');
+''',
+        expectedErrorsByNullability(nullable: [
+          error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 72, 1),
+        ], legacy: []));
   }
 
   test_none_asyncStar_int_to_basic() async {
@@ -36,6 +40,7 @@
 }
 ''', [
       error(StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, 0, 3),
+      error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 25, 1),
     ]);
   }
 
@@ -99,12 +104,16 @@
   }
 
   test_none_syncStar_dynamic_to_iterableInt() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode(
+        '''
 Iterable<int> f() sync* {
   dynamic a = 0;
   yield a;
 }
-''');
+''',
+        expectedErrorsByNullability(nullable: [
+          error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 51, 1),
+        ], legacy: []));
   }
 
   test_none_syncStar_int_to_basic() async {
@@ -114,6 +123,7 @@
 }
 ''', [
       error(StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, 0, 3),
+      error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 24, 1),
     ]);
   }
 
@@ -217,23 +227,27 @@
   }
 
   test_star_asyncStar_iterableInt_to_dynamic() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 f() async* {
   var a = <int>[];
   yield* a;
 }
-''');
+''', [
+      error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 41, 1),
+    ]);
   }
 
   test_star_asyncStar_iterableInt_to_streamInt() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 import 'dart:async';
 
 Stream<int> f() async* {
   var a = <int>[];
   yield* a;
 }
-''');
+''', [
+      error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 75, 1),
+    ]);
   }
 
   test_star_asyncStar_iterableString_to_streamInt() async {
@@ -262,7 +276,8 @@
   }
 
   test_star_asyncStar_streamDynamic_to_streamInt() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode(
+        '''
 import 'dart:async';
 
 Stream<int> f() async* {
@@ -270,7 +285,10 @@
 }
 
 Stream g() => throw 0;
-''');
+''',
+        expectedErrorsByNullability(nullable: [
+          error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 56, 3),
+        ], legacy: []));
   }
 
   test_star_asyncStar_streamInt_to_dynamic() async {
@@ -375,13 +393,17 @@
   }
 
   test_star_syncStar_iterableDynamic_to_iterableInt() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode(
+        '''
 Iterable<int> f() sync* {
   yield* g();
 }
 
 Iterable g() => throw 0;
-''');
+''',
+        expectedErrorsByNullability(nullable: [
+          error(StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, 35, 3),
+        ], legacy: []));
   }
 
   test_star_syncStar_iterableInt_to_dynamic() async {
@@ -423,4 +445,7 @@
   AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
     ..contextFeatures = FeatureSet.forTesting(
         sdkVersion: '2.7.0', additionalFeatures: [Feature.non_nullable]);
+
+  @override
+  bool get typeToStringWithNullability => true;
 }