Infer Null for return type of functions with empty returns.

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/standard_resolution_map.dart';
@@ skipping 4190 matching lines @@
    * Pop a return type off of the return stack.
    *
    * Also record any inferred return type using [setType], unless this node
    * already has a context type. This recorded type will be the least upper
    * bound of all types added with [addReturnOrYieldType].
    */
   void popReturnContext(BlockFunctionBody node) {
     if (_returnStack.isNotEmpty && _inferredReturn.isNotEmpty) {
       DartType context = _returnStack.removeLast() ?? DynamicTypeImpl.instance;
       DartType inferred = _inferredReturn.removeLast();
-      if (inferred.isBottom || inferred.isDartCoreNull) {
-        return;
-      }
 
       if (_typeSystem.isSubtypeOf(inferred, context)) {
         setType(node, inferred);
       }
     } else {
       assert(false);
     }
   }
 
   /**
    * Push a block function body's return type onto the return stack.
    */
   void pushReturnContext(BlockFunctionBody node) {
     _returnStack.add(getContext(node));
-    _inferredReturn.add(BottomTypeImpl.instance);
+    _inferredReturn.add(_typeProvider.nullType);
   }
 
   /**
    * Place an info node into the error stream indicating that a
    * [type] has been inferred as the type of [node].
    */
   void recordInference(Expression node, DartType type) {
     if (!_inferenceHints) {
       return;
     }
@@ skipping 4784 matching lines @@
    * Return the type representing 'Future<dynamic>'.
    */
   InterfaceType get futureDynamicType;
 
   /**
    * Return the type representing 'Future<Null>'.
    */
   InterfaceType get futureNullType;
 
   /**
+   * Return the type representing 'FutureOr<Null>'.
+   */
+  InterfaceType get futureOrNullType;
+
+  /**
    * Return the type representing the built-in type 'FutureOr'.
    */
   InterfaceType get futureOrType;
 
   /**
    * Return the type representing the built-in type 'Future'.
    */
   InterfaceType get futureType;
 
   /**
@@ skipping 173 matching lines @@
    * The type representing 'Future<dynamic>'.
    */
   InterfaceType _futureDynamicType;
 
   /**
    * The type representing 'Future<Null>'.
    */
   InterfaceType _futureNullType;
 
   /**
+   * The type representing 'FutureOr<Null>'.
+   */
+  InterfaceType _futureOrNullType;
+
+  /**
    * The type representing the built-in type 'FutureOr'.
    */
   InterfaceType _futureOrType;
 
   /**
    * The type representing the built-in type 'Future'.
    */
   InterfaceType _futureType;
 
   /**
@@ skipping 115 matching lines @@
   @override
   InterfaceType get functionType => _functionType;
 
   @override
   InterfaceType get futureDynamicType => _futureDynamicType;
 
   @override
   InterfaceType get futureNullType => _futureNullType;
 
   @override
+  InterfaceType get futureOrNullType => _futureOrNullType;
+
+  @override
   InterfaceType get futureOrType => _futureOrType;
 
   @override
   InterfaceType get futureType => _futureType;
 
   @override
   InterfaceType get intType => _intType;
 
   @override
   InterfaceType get iterableDynamicType => _iterableDynamicType;
@@ skipping 84 matching lines @@
     _numType = _getType(coreNamespace, "num");
     _objectType = _getType(coreNamespace, "Object");
     _stackTraceType = _getType(coreNamespace, "StackTrace");
     _streamType = _getType(asyncNamespace, "Stream");
     _stringType = _getType(coreNamespace, "String");
     _symbolType = _getType(coreNamespace, "Symbol");
     _typeType = _getType(coreNamespace, "Type");
     _undefinedType = UndefinedTypeImpl.instance;
     _futureDynamicType = _futureType.instantiate(<DartType>[_dynamicType]);
     _futureNullType = _futureType.instantiate(<DartType>[_nullType]);
+    _futureOrNullType = _futureOrType.instantiate(<DartType>[_nullType]);
     _iterableDynamicType = _iterableType.instantiate(<DartType>[_dynamicType]);
     _streamDynamicType = _streamType.instantiate(<DartType>[_dynamicType]);
     // FutureOr<T> is still fairly new, so if we're analyzing an SDK that
     // doesn't have it yet, create an element for it.
     _futureOrType ??= createPlaceholderFutureOr(_futureType, _objectType);
   }
 
   /**
    * Create an [InterfaceType] that can be used for `FutureOr<T>` if the SDK
    * being analyzed does not contain its own `FutureOr<T>`.  This ensures that
@@ skipping 1376 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }