Issue 28027. Move Null to the bottom in the Analyzer.

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 891 matching lines @@
       }
       // For async, give no hint if the return type does not matter, i.e.
       // dynamic, Future<Null> or Future<dynamic>.
       if (body.isAsynchronous) {
         if (returnTypeType.isDynamic) {
           return;
         }
         if (returnTypeType is InterfaceType &&
             returnTypeType.isDartAsyncFuture) {
           DartType futureArgument = returnTypeType.typeArguments[0];
-          if (futureArgument.isDynamic || futureArgument.isDartCoreNull) {
+          if (futureArgument.isDynamic ||
+              futureArgument.isDartCoreNull ||
+              futureArgument.isObject) {
             return;
           }
         }
       }
       // Check the block for a return statement, if not, create the hint
       if (!ExitDetector.exits(body)) {
         _errorReporter.reportErrorForNode(
             HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
       }
     }
@@ skipping 3257 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) {
+      if (inferred.isBottom || inferred.isDartCoreNull) {
         return;
       }
 
       if (context is FutureUnionType) {
         // Try and match the Future type first.
         if (_typeSystem.isSubtypeOf(inferred, context.futureOfType) ||
             _typeSystem.isSubtypeOf(inferred, context.type)) {
           setType(node, inferred);
         }
       } else if (_typeSystem.isSubtypeOf(inferred, context)) {
@@ skipping 1122 matching lines @@
   DartType overrideVariable(VariableElement element, DartType potentialType,
       bool allowPrecisionLoss) {
     // TODO(scheglov) type propagation for instance/top-level fields
     // was disabled because it depends on the order or visiting.
     // If both field and its client are in the same unit, and we visit
     // the client before the field, then propagated type is not set yet.
     if (element is PropertyInducingElement) {
       return null;
     }
 
-    if (potentialType == null || potentialType.isBottom) {
+    if (potentialType == null ||
+        potentialType.isBottom ||
+        potentialType.isDartCoreNull) {
       return null;
     }
     DartType currentType = _overrideManager.getBestType(element);
 
     if (potentialType == currentType) {
       return null;
     }
 
     // If we aren't allowing precision loss then the third and fourth conditions
     // check that we aren't losing precision.
@@ skipping 37 matching lines @@
    * If the given [type] is valid, strongly more specific than the
    * existing static type of the given [expression], record it as a propagated
    * type of the given [expression]. Otherwise, reset it to `null`.
    *
    * If [hasOldPropagatedType] is `true` then the existing propagated type
    * should also is checked.
    */
   void recordPropagatedTypeIfBetter(Expression expression, DartType type,
       [bool hasOldPropagatedType = false]) {
     // Ensure that propagated type invalid.
-    if (strongMode || type == null || type.isDynamic || type.isBottom) {
+    if (strongMode ||
+        type == null ||
+        type.isBottom ||
+        type.isDynamic ||
+        type.isDartCoreNull) {
       if (!hasOldPropagatedType) {
         expression.propagatedType = null;
       }
       return;
     }
     // Ensure that propagated type is more specific than the static type.
     DartType staticType = expression.staticType;
     if (type == staticType || !type.isMoreSpecificThan(staticType)) {
       expression.propagatedType = null;
       return;
@@ skipping 5420 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }