Add TypeSystemImpl.futureOrBase (), stop using iterable/mapForSetMapDisambiguation.

Change-Id: I44e2888751d4a60fd79468cd184d218f16279637
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155724
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/element/type_provider.dart

@@ -96,9 +96,6 @@ class TypeProviderImpl extends TypeProviderBase {
 
   InterfaceTypeImpl _nullStar;
 
-  InterfaceType _iterableForSetMapDisambiguation;
-  InterfaceType _mapForSetMapDisambiguation;
-
   Set<ClassElement> _nonSubtypableClasses;
 
   /// Initialize a newly created type provider to provide the types defined in
@@ -258,25 +255,6 @@ class TypeProviderImpl extends TypeProviderBase {
     return _iterableElement ??= _getClassElement(_coreLibrary, 'Iterable');
   }
 
-  /// Return the type that should be used during disambiguation between `Set`
-  /// and `Map` literals. If NNBD enabled, use `Iterable<Object?, Object?>`,
-  /// otherwise use `Iterable<Object*, Object*>*`.
-  InterfaceType get iterableForSetMapDisambiguation {
-    if (_iterableForSetMapDisambiguation == null) {
-      var objectType = objectElement.instantiate(
-        typeArguments: const [],
-        nullabilitySuffix: _questionOrStarSuffix,
-      );
-      _iterableForSetMapDisambiguation = iterableElement.instantiate(
-        typeArguments: [
-          objectType,
-        ],
-        nullabilitySuffix: _questionOrStarSuffix,
-      );
-    }
-    return _iterableForSetMapDisambiguation;
-  }
-
   @override
   InterfaceType get iterableObjectType {
     _iterableObjectType ??= InterfaceTypeImpl(
@@ -309,26 +287,6 @@ class TypeProviderImpl extends TypeProviderBase {
     return _mapElement ??= _getClassElement(_coreLibrary, 'Map');
   }
 
-  /// Return the type that should be used during disambiguation between `Set`
-  /// and `Map` literals. If NNBD enabled, use `Map<Object?, Object?>`,
-  /// otherwise use `Map<Object*, Object*>*`.
-  InterfaceType get mapForSetMapDisambiguation {
-    if (_mapForSetMapDisambiguation == null) {
-      var objectType = objectElement.instantiate(
-        typeArguments: const [],
-        nullabilitySuffix: _questionOrStarSuffix,
-      );
-      _mapForSetMapDisambiguation = mapElement.instantiate(
-        typeArguments: [
-          objectType,
-          objectType,
-        ],
-        nullabilitySuffix: _questionOrStarSuffix,
-      );
-    }
-    return _mapForSetMapDisambiguation;
-  }
-
   @override
   InterfaceType get mapObjectObjectType {
     _mapObjectObjectType ??= InterfaceTypeImpl(
@@ -491,12 +449,6 @@ class TypeProviderImpl extends TypeProviderBase {
     }
   }
 
-  NullabilitySuffix get _questionOrStarSuffix {
-    return isNonNullableByDefault
-        ? NullabilitySuffix.question
-        : NullabilitySuffix.star;
-  }
-
   @override
   InterfaceType futureOrType2(DartType valueType) {
     return futureOrElement.instantiate(

pkg/analyzer/lib/src/dart/element/type_system.dart

@@ -90,6 +90,19 @@ abstract class TypeSystem implements public.TypeSystem {
     return type;
   }
 
+  DartType futureOrBase(DartType type) {
+    // If `T` is `FutureOr<S>` for some `S`,
+    // then `futureOrBase(T)` = `futureOrBase(S)`
+    if (type is InterfaceType && type.isDartAsyncFutureOr) {
+      return futureOrBase(
+        type.typeArguments[0],
+      );
+    }
+
+    // Otherwise `futureOrBase(T)` = `T`.
+    return type;
+  }
+
   List<InterfaceType> gatherMixinSupertypeConstraintsForInference(
       ClassElement mixinElement) {
     List<InterfaceType> candidates;

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

@@ -12,7 +12,6 @@ import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_provider.dart';
-import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ -267,39 +266,42 @@ class TypedLiteralResolver {
     return _LiteralResolution(_LiteralResolutionKind.ambiguous, null);
   }
 
-  /// If [contextType] is defined and is a subtype of `Iterable<Object>` and
-  /// [contextType] is not a subtype of `Map<Object, Object>`, then *e* is a set
+  /// If [contextType] implements `Iterable`, but not `Map`, then *e* is a set
   /// literal.
   ///
-  /// If [contextType] is defined and is a subtype of `Map<Object, Object>` and
-  /// [contextType] is not a subtype of `Iterable<Object>` then *e* is a map
+  /// If [contextType] implements `Map`, but not `Iterable`, then *e* is a map
   /// literal.
   _LiteralResolution _fromContextType(DartType contextType) {
     if (contextType != null) {
-      DartType unwrap(DartType type) {
-        if (type is InterfaceType &&
-            type.isDartAsyncFutureOr &&
-            type.typeArguments.length == 1) {
-          return unwrap(type.typeArguments[0]);
-        }
-        return type;
-      }
-
-      DartType unwrappedContextType = unwrap(contextType);
+      var unwrappedContextType = _typeSystem.futureOrBase(contextType);
       // TODO(brianwilkerson) Find out what the "greatest closure" is and use that
       // where [unwrappedContextType] is used below.
-      bool isIterable = _typeSystem.isSubtypeOf2(
-          unwrappedContextType, _typeProvider.iterableForSetMapDisambiguation);
-      bool isMap = _typeSystem.isSubtypeOf2(
-          unwrappedContextType, _typeProvider.mapForSetMapDisambiguation);
+      var iterableType = unwrappedContextType.asInstanceOf(
+        _typeProvider.iterableElement,
+      );
+      var mapType = unwrappedContextType.asInstanceOf(
+        _typeProvider.mapElement,
+      );
+      var isIterable = iterableType != null;
+      var isMap = mapType != null;
+
+      // When `S` implements `Iterable` but not `Map`, `e` is a set literal.
       if (isIterable && !isMap) {
         return _LiteralResolution(
-            _LiteralResolutionKind.set, unwrappedContextType);
-      } else if (isMap && !isIterable) {
+          _LiteralResolutionKind.set,
+          unwrappedContextType,
+        );
+      }
+
+      // When `S` implements `Map` but not `Iterable`, `e` is a map literal.
+      if (isMap && !isIterable) {
         return _LiteralResolution(
-            _LiteralResolutionKind.map, unwrappedContextType);
+          _LiteralResolutionKind.map,
+          unwrappedContextType,
+        );
       }
     }
+
     return _LiteralResolution(_LiteralResolutionKind.ambiguous, null);
   }
 
@@ -513,38 +515,54 @@ class TypedLiteralResolver {
     } else if (canBeAMap && mustBeAMap) {
       return _toMapType(literal, contextType, inferredTypes);
     }
+
     // Note: according to the spec, the following computations should be based
     // on the greatest closure of the context type (unless the context type is
     // `_`).  In practice, we can just use the context type directly, because
     // the only way the greatest closure of the context type could possibly have
     // a different subtype relationship to `Iterable<Object>` and
     // `Map<Object, Object>` is if the context type is `_`.
-    bool contextProvidesAmbiguityResolutionClues =
-        contextType != null && contextType is! UnknownInferredType;
-    bool contextIsIterable = contextProvidesAmbiguityResolutionClues &&
-        _typeSystem.isSubtypeOf2(
-            contextType, _typeProvider.iterableForSetMapDisambiguation);
-    bool contextIsMap = contextProvidesAmbiguityResolutionClues &&
-        _typeSystem.isSubtypeOf2(
-            contextType, _typeProvider.mapForSetMapDisambiguation);
-    if (contextIsIterable && !contextIsMap) {
-      return _toSetType(literal, contextType, inferredTypes);
-    } else if ((contextIsMap && !contextIsIterable) || elements.isEmpty) {
-      return _toMapType(literal, contextType, inferredTypes);
-    } else {
-      // Ambiguous.  We're not going to get any more information to resolve the
-      // ambiguity.  We don't want to make an arbitrary decision at this point
-      // because it will interfere with future type inference (see
-      // dartbug.com/36210), so we return a type of `dynamic`.
-      if (mustBeAMap && mustBeASet) {
-        _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.AMBIGUOUS_SET_OR_MAP_LITERAL_BOTH, literal);
-      } else {
-        _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.AMBIGUOUS_SET_OR_MAP_LITERAL_EITHER, literal);
+    if (contextType != null) {
+      var contextIterableType = contextType.asInstanceOf(
+        _typeProvider.iterableElement,
+      );
+      var contextMapType = contextType.asInstanceOf(
+        _typeProvider.mapElement,
+      );
+      var contextIsIterable = contextIterableType != null;
+      var contextIsMap = contextMapType != null;
+
+      // When `S` implements `Iterable` but not `Map`, `e` is a set literal.
+      if (contextIsIterable && !contextIsMap) {
+        return _toSetType(literal, contextType, inferredTypes);
       }
-      return _typeProvider.dynamicType;
+
+      // When `S` implements `Map` but not `Iterable`, `e` is a map literal.
+      if (contextIsMap && !contextIsIterable) {
+        return _toMapType(literal, contextType, inferredTypes);
+      }
+    }
+
+    // When `e` is of the form `{}` and `S` is undefined, `e` is a map literal.
+    if (elements.isEmpty && contextType == null) {
+      return _typeProvider.mapType2(
+        DynamicTypeImpl.instance,
+        DynamicTypeImpl.instance,
+      );
+    }
+
+    // Ambiguous.  We're not going to get any more information to resolve the
+    // ambiguity.  We don't want to make an arbitrary decision at this point
+    // because it will interfere with future type inference (see
+    // dartbug.com/36210), so we return a type of `dynamic`.
+    if (mustBeAMap && mustBeASet) {
+      _errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.AMBIGUOUS_SET_OR_MAP_LITERAL_BOTH, literal);
+    } else {
+      _errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.AMBIGUOUS_SET_OR_MAP_LITERAL_EITHER, literal);
     }
+    return _typeProvider.dynamicType;
   }
 
   DartType _inferSetTypeDownwards(SetOrMapLiteral node, DartType contextType) {

pkg/analyzer/test/src/dart/element/future_or_base_test.dart

@@ -0,0 +1,66 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/element/type.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../generated/type_system_test.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FutureOrBaseTest);
+  });
+}
+
+@reflectiveTest
+class FutureOrBaseTest extends AbstractTypeSystemNullSafetyTest {
+  test_dynamic() {
+    _check(dynamicNone, 'dynamic');
+  }
+
+  test_futureOr() {
+    void check(DartType S, String expected) {
+      _check(futureOrNone(S), expected);
+    }
+
+    check(intNone, 'int');
+    check(intQuestion, 'int?');
+    check(intStar, 'int*');
+
+    check(dynamicNone, 'dynamic');
+    check(voidNone, 'void');
+
+    check(neverNone, 'Never');
+    check(neverQuestion, 'Never?');
+    check(neverStar, 'Never*');
+
+    check(objectNone, 'Object');
+    check(objectQuestion, 'Object?');
+    check(objectStar, 'Object*');
+  }
+
+  test_other() {
+    _check(intNone, 'int');
+    _check(intQuestion, 'int?');
+    _check(intStar, 'int*');
+
+    _check(objectNone, 'Object');
+    _check(objectQuestion, 'Object?');
+    _check(objectStar, 'Object*');
+  }
+
+  /// futureValueType(`void`) = `void`.
+  test_void() {
+    _check(voidNone, 'void');
+  }
+
+  void _check(DartType T, String expected) {
+    var result = typeSystem.futureOrBase(T);
+    expect(
+      result.getDisplayString(withNullability: true),
+      expected,
+    );
+  }
+}

pkg/analyzer/test/src/dart/element/test_all.dart

@@ -9,6 +9,7 @@ import 'element_test.dart' as element;
 import 'factor_type_test.dart' as factor_type;
 import 'flatten_type_test.dart' as flatten_type;
 import 'function_type_test.dart' as function_type;
+import 'future_or_base_test.dart' as future_or_base;
 import 'future_value_type_test.dart' as future_value_type;
 import 'generic_inferrer_test.dart' as generic_inferrer;
 import 'inheritance_manager3_test.dart' as inheritance_manager3;
@@ -33,6 +34,7 @@ main() {
     factor_type.main();
     flatten_type.main();
     function_type.main();
+    future_or_base.main();
     future_value_type.main();
     generic_inferrer.main();
     inheritance_manager3.main();

pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart

@@ -40,6 +40,17 @@ Map<int, int> a = {1 : 2};
     assertType(setOrMapLiteral('{'), 'Map<int, int>');
   }
 
+  test_context_noTypeArgs_noElements_futureOr() async {
+    await resolveTestCode('''
+import 'dart:async';
+
+FutureOr<Map<int, String>> f() {
+  return {};
+}
+''');
+    assertType(setOrMapLiteral('{};'), 'Map<int, String>');
+  }
+
   test_context_noTypeArgs_noEntries() async {
     await assertNoErrorsInCode('''
 Map<String, String> a = {};

pkg/analyzer/test/src/dart/resolution/type_inference/set_literal_test.dart

@@ -40,6 +40,17 @@ Set<String> a = {};
     assertType(setLiteral('{'), 'Set<String>');
   }
 
+  test_context_noTypeArgs_noElements_futureOr() async {
+    await resolveTestCode('''
+import 'dart:async';
+
+FutureOr<Set<int>> f() {
+  return {};
+}
+''');
+    assertType(setLiteral('{};'), 'Set<int>');
+  }
+
   test_context_noTypeArgs_noElements_typeParameter() async {
     await resolveTestCode('''
 class A<E extends Set<int>> {
@@ -276,7 +287,6 @@ void f<T extends num>(T a) {
     assertType(setLiteral('{...'), 'dynamic');
   }
 
-
   test_noContext_typeArgs_expression_conflict() async {
     await resolveTestCode('''
 var a = <String>{1};