[model] Share greatest and lowest closure of type schema

chloestefantsova · Commit Queue · commit 0687036cb9cc · 2025-07-24T05:51:00.000-07:00
The algorithms for computing the greatest and lowest closures of a type schema are shared between the Analyzer and the CFE. As a work-around for the discrepancy between the behavior of the tools, the interface of the greatest closure computation accepts the top type to be used as one of its parameters. Part of #54902 Change-Id: I378c562c39078b20c48015cdf44eb652c8d4c000 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/438660 Reviewed-by: Paul Berry <paulberry@google.com> Commit-Queue: Chloe Stefantsova <cstefantsova@google.com>
diff --git a/pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart b/pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart
@@ -1939,7 +1939,14 @@ mixin TypeAnalyzer<
       //   expressions.
       // - Let `S` be the greatest closure of `K`.
       SharedTypeView? t;
-      SharedTypeView s = operations.greatestClosure(schema);
+      // Note that the `topType` named parameter below is a work-around for the
+      // discrepancy between the Analyzer and the CFE and should be removed when
+      // the discrepancy is resolved. For details, see
+      // https://github.com/dart-lang/language/issues/4466.
+      SharedTypeView s = operations.greatestClosureOfSchema(
+        schema,
+        topType: operations.dynamicType,
+      );
       bool allCasesSatisfyContext = true;
       for (int i = 0; i < numCases; i++) {
         // Stack: (Expression, i * ExpressionCase)
diff --git a/pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer_operations.dart b/pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer_operations.dart
@@ -181,10 +181,6 @@ abstract interface class TypeAnalyzerOperations<
     covariant SharedType type2,
   );
 
-  /// Returns the greatest closure of [schema] with respect to the unknown type
-  /// (`_`).
-  SharedTypeView greatestClosure(SharedTypeSchemaView schema);
-
   /// Computes the greatest closure of a type.
   ///
   /// Computing the greatest closure of a type is described here:
@@ -753,6 +749,26 @@ abstract interface class TypeAnalyzerOperations<
   ///   * `List<_>`,
   ///   * `_ Function(_)`.
   bool isKnownType(SharedTypeSchemaView typeSchema);
+
+  /// Computes the greatest closure of a type schema.
+  ///
+  /// The greatest closure of a type schema is defined in
+  /// https://github.com/dart-lang/language/blob/main/accepted/future-releases/0323-null-aware-elements/feature-specification.md
+  ///
+  /// The [topType] parameter is needed to account for the known discrepancy in
+  /// the implementations between the CFE and the Analyzer. For details, see
+  /// https://github.com/dart-lang/language/issues/4466.
+  //TODO(cstefantsova): Remove [topType] when the discrepancy is resolved.
+  SharedTypeView greatestClosureOfSchema(
+    SharedTypeSchemaView schema, {
+    SharedTypeView? topType,
+  });
+
+  /// Computes the least closure of a type schema.
+  ///
+  /// The least closure of a type schema is defined in
+  /// https://github.com/dart-lang/language/blob/main/accepted/future-releases/0323-null-aware-elements/feature-specification.md
+  SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema);
 }
 
 mixin TypeAnalyzerOperationsMixin<
diff --git a/pkg/_fe_analyzer_shared/test/mini_ast.dart b/pkg/_fe_analyzer_shared/test/mini_ast.dart
@@ -3233,16 +3233,6 @@ class MiniAstOperations
     return _glbs[query] ?? fail('Unknown glb query: $query');
   }
 
-  @override
-  SharedTypeView greatestClosure(SharedTypeSchemaView schema) {
-    return SharedTypeView(
-      schema.unwrapTypeSchemaView<Type>().closureWithRespectToUnknown(
-            covariant: true,
-          ) ??
-          schema.unwrapTypeSchemaView(),
-    );
-  }
-
   @override
   Type greatestClosureOfTypeInternal(
     Type type,
@@ -3699,6 +3689,25 @@ class MiniAstOperations
   PropertyNonPromotabilityReason? whyPropertyIsNotPromotable(
     covariant _PropertyElement property,
   ) => property.whyNotPromotable;
+
+  @override
+  SharedTypeView greatestClosureOfSchema(
+    SharedTypeSchemaView schema, {
+    SharedTypeView? topType,
+  }) {
+    return SharedTypeView(
+      schema.unwrapTypeSchemaView<Type>().closureWithRespectToUnknown(
+            covariant: true,
+          ) ??
+          schema.unwrapTypeSchemaView(),
+    );
+  }
+
+  @override
+  SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema) {
+    // TODO(paulberry): Implement leastClosureOfSchema in mini ast.
+    throw UnimplementedError();
+  }
 }
 
 /// Representation of an expression or statement in the pseudo-Dart language
diff --git a/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart
@@ -328,7 +328,10 @@ class AssignmentExpressionResolver {
       var nonNullT1 = _typeSystem.promoteToNonNull(t1);
       var t = _typeSystem.leastUpperBound(nonNullT1, t2);
       //   - Let `S` be the greatest closure of `K`.
-      var s = _typeSystem.greatestClosureOfSchema(contextType);
+      var s =
+          _resolver.operations
+              .greatestClosureOfSchema(SharedTypeSchemaView(contextType))
+              .unwrapTypeView<TypeImpl>();
       // If `inferenceUpdate3` is not enabled, then the type of `E` is `T`.
       if (!_resolver.definingLibrary.featureSet.isEnabled(
         Feature.inference_update_3,
diff --git a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
@@ -215,7 +215,10 @@ class BinaryExpressionResolver {
     var t = _typeSystem.leastUpperBound(nonNullT1, t2);
 
     // - Let `S` be the greatest closure of `K`.
-    var s = _typeSystem.greatestClosureOfSchema(contextType);
+    var s =
+        _resolver.operations
+            .greatestClosureOfSchema(SharedTypeSchemaView(contextType))
+            .unwrapTypeView<TypeImpl>();
 
     DartType staticType;
     // If `inferenceUpdate3` is not enabled, then the type of `E` is `T`.
diff --git a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
@@ -595,11 +595,12 @@ class TypeSystemOperations
   }
 
   @override
-  SharedTypeView greatestClosure(SharedTypeSchemaView schema) {
+  SharedTypeView greatestClosureOfSchema(
+    SharedTypeSchemaView schema, {
+    SharedTypeView? topType,
+  }) {
     return SharedTypeView(
-      typeSystem.greatestClosureOfSchema(
-        schema.unwrapTypeSchemaView<TypeImpl>(),
-      ),
+      typeSystem.greatestClosureOfSchema(schema.unwrapTypeSchemaView()),
     );
   }
 
@@ -731,6 +732,13 @@ class TypeSystemOperations
     );
   }
 
+  @override
+  SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema) {
+    return SharedTypeView(
+      typeSystem.leastClosureOfSchema(schema.unwrapTypeSchemaView()),
+    );
+  }
+
   @override
   TypeImpl leastClosureOfTypeInternal(
     TypeImpl type,
diff --git a/pkg/analyzer/lib/src/dart/resolver/function_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/function_expression_resolver.dart
@@ -2,6 +2,7 @@
 // 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:_fe_analyzer_shared/src/types/shared_type.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ -105,7 +106,10 @@ class FunctionExpressionResolver {
         // corresponding parameter in the context type schema with type
         // schema `K`, the parameter is given an inferred type `T` where `T`
         // is derived from `K` as follows.
-        inferredType = _typeSystem.greatestClosureOfSchema(inferredType);
+        inferredType =
+            _resolver.operations
+                .greatestClosureOfSchema(SharedTypeSchemaView(inferredType))
+                .unwrapTypeView<TypeImpl>();
 
         // If the greatest closure of `K` is `S` and `S` is a subtype of
         // `Null`, then `T` is `Object?`. Otherwise, `T` is `S`.
diff --git a/pkg/analyzer/lib/src/dart/resolver/record_literal_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/record_literal_resolver.dart
@@ -144,8 +144,10 @@ class RecordLiteralResolver {
 
     // Implicit cast from `dynamic`.
     if (contextType is! UnknownInferredType && staticType is DynamicType) {
-      var greatestClosureOfSchema = _resolver.typeSystem
-          .greatestClosureOfSchema(contextType);
+      var greatestClosureOfSchema =
+          _resolver.operations
+              .greatestClosureOfSchema(SharedTypeSchemaView(contextType))
+              .unwrapTypeView<TypeImpl>();
       if (!_resolver.typeSystem.isSubtypeOf(
         staticType,
         greatestClosureOfSchema,
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -95,7 +95,10 @@ class StaticTypeAnalyzer {
     // - Let `T` be  `UP(T1, T2)`
     var t = _typeSystem.leastUpperBound(t1, t2);
     // - Let `S` be the greatest closure of `K`
-    var s = _typeSystem.greatestClosureOfSchema(contextType);
+    var s =
+        _resolver.operations
+            .greatestClosureOfSchema(SharedTypeSchemaView(contextType))
+            .unwrapTypeView<TypeImpl>();
     DartType staticType;
     // If `inferenceUpdate3` is not enabled, then the type of `E` is `T`.
     if (!_resolver.definingLibrary.featureSet.isEnabled(
diff --git a/pkg/front_end/lib/src/compute_platform_binaries_location.dart b/pkg/front_end/lib/src/compute_platform_binaries_location.dart
@@ -55,7 +55,6 @@ Uri computePlatformBinariesLocation({bool forceBuildDir = false}) {
           new Uri.file(resolvedExecutable ?? Platform.resolvedExecutable))
       .resolve(".");
   if (vmDirectory.path.endsWith("/bin/")) {
-    // Coverage-ignore-block(suite): Not run.
     // Looks like the VM is in a `/bin/` directory, so this is running from a
     // built SDK.
     return vmDirectory.resolve(forceBuildDir ? "../../" : "../lib/_internal/");
diff --git a/pkg/front_end/lib/src/type_inference/inference_visitor_base.dart b/pkg/front_end/lib/src/type_inference/inference_visitor_base.dart
@@ -54,7 +54,6 @@ import 'type_demotion.dart';
 import 'type_inference_engine.dart';
 import 'type_inferrer.dart' show TypeInferrerImpl;
 import 'type_schema.dart' show isKnown, UnknownType;
-import 'type_schema_elimination.dart' show greatestClosure;
 import 'type_schema_environment.dart'
     show
         getNamedParameterType,
@@ -190,11 +189,14 @@ abstract class InferenceVisitorBase implements InferenceVisitor {
   StaticTypeContext get staticTypeContext => _inferrer.staticTypeContext;
 
   DartType computeGreatestClosure(DartType type) {
-    return greatestClosure(type, topType: const DynamicType());
+    return cfeOperations.greatestClosureOfSchema(new SharedTypeSchemaView(type),
+        topType: new SharedTypeView(const DynamicType())) as DartType;
   }
 
   DartType computeGreatestClosure2(DartType type) {
-    return greatestClosure(type, topType: coreTypes.objectNullableRawType);
+    return cfeOperations.greatestClosureOfSchema(new SharedTypeSchemaView(type),
+            topType: new SharedTypeView(coreTypes.objectNullableRawType))
+        as DartType;
   }
 
   DartType computeNullable(DartType type) =>
diff --git a/pkg/front_end/lib/src/type_inference/type_inference_engine.dart b/pkg/front_end/lib/src/type_inference/type_inference_engine.dart
@@ -565,13 +565,6 @@ class OperationsCfe
         typeEnvironment, from.unwrapTypeView(), what.unwrapTypeView()));
   }
 
-  @override
-  SharedTypeView greatestClosure(SharedTypeSchemaView schema) {
-    return new SharedTypeView(type_schema_elimination.greatestClosure(
-        schema.unwrapTypeSchemaView(),
-        topType: const DynamicType()));
-  }
-
   @override
   bool isAlwaysExhaustiveType(SharedTypeView type) {
     return computeIsAlwaysExhaustiveType(
@@ -1041,6 +1034,24 @@ class OperationsCfe
   bool isKnownType(SharedTypeSchemaView typeSchema) {
     return isKnown(typeSchema.unwrapTypeSchemaView());
   }
+
+  @override
+  SharedTypeView greatestClosureOfSchema(SharedTypeSchemaView schema,
+      {SharedTypeView? topType}) {
+    return new SharedTypeView(
+        type_schema_elimination.greatestClosure(schema.unwrapTypeSchemaView(),
+            topType: topType?.unwrapTypeView() ??
+                // Coverage-ignore(suite): Not run.
+                typeEnvironment.coreTypes.objectNullableRawType));
+  }
+
+  @override
+  // Coverage-ignore(suite): Not run.
+  SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema) {
+    return new SharedTypeView(type_schema_elimination.leastClosure(
+        schema.unwrapTypeSchemaView(),
+        coreTypes: typeEnvironment.coreTypes));
+  }
 }
 
 /// Type inference results used for testing.
diff --git a/pkg/front_end/test/coverage_suite_expected.dart b/pkg/front_end/test/coverage_suite_expected.dart
@@ -425,7 +425,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/compute_platform_binaries_location.dart": (
-    hitCount: 45,
+    hitCount: 46,
     missCount: 0,
   ),
   // 100.0%.
@@ -690,7 +690,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/kernel/body_builder.dart": (
-    hitCount: 7228,
+    hitCount: 7238,
     missCount: 0,
   ),
   // 100.0%.
@@ -1101,7 +1101,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/type_inference/inference_visitor_base.dart": (
-    hitCount: 2456,
+    hitCount: 2462,
     missCount: 0,
   ),
   // 100.0%.
@@ -1141,7 +1141,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/type_inference/type_inference_engine.dart": (
-    hitCount: 535,
+    hitCount: 536,
     missCount: 0,
   ),
   // 100.0%.
