Implement factor() operation from flow analysis.

Change-Id: If2e23c3b850974d9190b90b287b811baf3121739
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138269
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -1799,6 +1799,57 @@ class TypeSystemImpl extends TypeSystem {
     }
   }
 
+  /// Defines the "remainder" of `T` when `S` has been removed from
+  /// consideration by an instance check.  This operation is used for type
+  /// promotion during flow analysis.
+  DartType factor(DartType T, DartType S) {
+    // * If T <: S then Never
+    if (isSubtypeOf2(T, S)) {
+      return NeverTypeImpl.instance;
+    }
+
+    var T_nullability = T.nullabilitySuffix;
+
+    // * Else if T is R? and Null <: S then factor(R, S)
+    // * Else if T is R? then factor(R, S)?
+    if (T_nullability == NullabilitySuffix.question) {
+      var R = (T as TypeImpl).withNullability(NullabilitySuffix.none);
+      var factor_RS = factor(R, S) as TypeImpl;
+      if (isSubtypeOf2(nullNone, S)) {
+        return factor_RS;
+      } else {
+        return factor_RS.withNullability(NullabilitySuffix.question);
+      }
+    }
+
+    // * Else if T is R* and Null <: S then factor(R, S)
+    // * Else if T is R* then factor(R, S)*
+    if (T_nullability == NullabilitySuffix.star) {
+      var R = (T as TypeImpl).withNullability(NullabilitySuffix.none);
+      var factor_RS = factor(R, S) as TypeImpl;
+      if (isSubtypeOf2(nullNone, S)) {
+        return factor_RS;
+      } else {
+        return factor_RS.withNullability(NullabilitySuffix.star);
+      }
+    }
+
+    // * Else if T is FutureOr<R> and Future<R> <: S then factor(R, S)
+    // * Else if T is FutureOr<R> and R <: S then factor(Future<R>, S)
+    if (T is InterfaceType && T.isDartAsyncFutureOr) {
+      var R = T.typeArguments[0];
+      var future_R = typeProvider.futureType2(R);
+      if (isSubtypeOf2(future_R, S)) {
+        return factor(R, S);
+      }
+      if (isSubtypeOf2(R, S)) {
+        return factor(future_R, S);
+      }
+    }
+
+    return T;
+  }
+
   /// Given a type t, if t is an interface type with a call method
   /// defined, return the function type for the call method, otherwise
   /// return null.

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

@@ -0,0 +1,128 @@
+// 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/analysis/features.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/dart/element/type_provider.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/resolver.dart' show TypeSystemImpl;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../../generated/elements_types_mixin.dart';
+import '../../../generated/test_analysis_context.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FactorTypeTest);
+  });
+}
+
+@reflectiveTest
+class FactorTypeTest with ElementsTypesMixin {
+  @override
+  TypeProvider typeProvider;
+
+  TypeSystemImpl typeSystem;
+
+  FeatureSet get testFeatureSet {
+    return FeatureSet.forTesting(
+      additionalFeatures: [Feature.non_nullable],
+    );
+  }
+
+  void setUp() {
+    var analysisContext = TestAnalysisContext(
+      featureSet: testFeatureSet,
+    );
+    typeProvider = analysisContext.typeProviderNonNullableByDefault;
+    typeSystem = analysisContext.typeSystemNonNullableByDefault;
+  }
+
+  void test_futureOr() {
+    _check(futureOrNone(intNone), intNone, 'Future<int>');
+    _check(futureOrNone(intNone), futureNone(intNone), 'int');
+
+    _check(futureOrNone(intQuestion), intNone, 'FutureOr<int?>');
+    _check(futureOrNone(intQuestion), futureNone(intNone), 'FutureOr<int?>');
+    _check(futureOrNone(intQuestion), intQuestion, 'Future<int?>');
+    _check(futureOrNone(intQuestion), futureNone(intQuestion), 'int?');
+    _check(futureOrNone(intQuestion), intStar, 'Future<int?>');
+    _check(futureOrNone(intQuestion), futureNone(intStar), 'int?');
+
+    _check(futureOrNone(intNone), numNone, 'Future<int>');
+    _check(futureOrNone(intNone), futureNone(numNone), 'int');
+  }
+
+  void test_object() {
+    _check(objectNone, objectNone, 'Never');
+    _check(objectNone, objectQuestion, 'Never');
+    _check(objectNone, objectStar, 'Never');
+
+    _check(objectNone, intNone, 'Object');
+    _check(objectNone, intQuestion, 'Object');
+    _check(objectNone, intStar, 'Object');
+
+    _check(objectQuestion, objectNone, 'Never?');
+    _check(objectQuestion, objectQuestion, 'Never');
+    _check(objectQuestion, objectStar, 'Never');
+
+    _check(objectQuestion, intNone, 'Object?');
+    _check(objectQuestion, intQuestion, 'Object');
+    _check(objectQuestion, intStar, 'Object');
+  }
+
+  test_subtype() {
+    _check(intNone, intNone, 'Never');
+    _check(intNone, intQuestion, 'Never');
+    _check(intNone, intStar, 'Never');
+
+    _check(intQuestion, intNone, 'Never?');
+    _check(intQuestion, intQuestion, 'Never');
+    _check(intQuestion, intStar, 'Never');
+
+    _check(intStar, intNone, 'Never');
+    _check(intStar, intQuestion, 'Never');
+    _check(intStar, intStar, 'Never');
+
+    _check(intNone, numNone, 'Never');
+    _check(intNone, numQuestion, 'Never');
+    _check(intNone, numStar, 'Never');
+
+    _check(intQuestion, numNone, 'Never?');
+    _check(intQuestion, numQuestion, 'Never');
+    _check(intQuestion, numStar, 'Never');
+
+    _check(intStar, numNone, 'Never');
+    _check(intStar, numQuestion, 'Never');
+    _check(intStar, numStar, 'Never');
+
+    _check(intNone, nullNone, 'int');
+    _check(intQuestion, nullNone, 'int');
+    _check(intStar, nullNone, 'int');
+
+    _check(intNone, stringNone, 'int');
+    _check(intQuestion, stringNone, 'int?');
+    _check(intStar, stringNone, 'int*');
+
+    _check(intNone, stringQuestion, 'int');
+    _check(intQuestion, stringQuestion, 'int');
+    _check(intStar, stringQuestion, 'int');
+
+    _check(intNone, stringStar, 'int');
+    _check(intQuestion, stringStar, 'int');
+    _check(intStar, stringStar, 'int');
+  }
+
+  void _check(DartType T, DartType S, String expectedStr) {
+    var result = typeSystem.factor(T, S);
+    var resultStr = _typeString(result);
+
+    expect(resultStr, expectedStr);
+  }
+
+  String _typeString(TypeImpl type) {
+    return type.getDisplayString(withNullability: true);
+  }
+}

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

@@ -5,6 +5,7 @@
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'element_test.dart' as element;
+import 'factor_type_test.dart' as factor_type;
 import 'function_type_test.dart' as function_type;
 import 'inheritance_manager3_test.dart' as inheritance_manager3;
 import 'least_upper_bound_helper_test.dart' as least_upper_bound_helper;
@@ -23,6 +24,7 @@ import 'upper_lower_bound_test.dart' as upper_bound;
 main() {
   defineReflectiveSuite(() {
     element.main();
+    factor_type.main();
     function_type.main();
     inheritance_manager3.main();
     least_upper_bound_helper.main();