[analyzer] Use Impl types in ElementsTypesMixin.

Change the methods in `ElementsTypesMixin` so that their return types
are all "Impl" types rather than analyzer public API types.

This doesn't change the analyzer public API because
`ElementsTypesMixin` is only used in tests internal to
`package:analyzer`.

This change allows `type_constraint_gatherer_test.dart` to represent
all its types using `TypeImpl` rather than `DartType` without using
type casts, which will in turn pave the way for switching the shared
type constraint gathering code to using `TypeImpl` rather than
`DartType`.

This is part of a larger arc of work to change the analyzer's use of
the shared code so that the type parameters it supplies are not part
of the analyzer public API (See
#59763).

Change-Id: I9d15e9dd77f73271166b8e12de4d6f0a104cbb19
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/403926
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -10959,7 +10959,7 @@ class TypeAliasElementImpl extends _ExistingElementImpl
   }
 
   @override
-  DartType instantiate({
+  TypeImpl instantiate({
     required List<DartType> typeArguments,
     required NullabilitySuffix nullabilitySuffix,
   }) {

pkg/analyzer/test/generated/elements_types_mixin.dart

@@ -9,12 +9,12 @@ import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/source/source.dart';
 import 'package:analyzer/src/dart/analysis/session.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/generated/engine.dart';
@@ -23,99 +23,99 @@ import 'package:analyzer/src/summary2/reference.dart';
 import 'package:test/test.dart';
 
 mixin ElementsTypesMixin {
-  InterfaceType get boolNone {
+  InterfaceTypeImpl get boolNone {
     var element = typeProvider.boolElement;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get boolQuestion {
+  InterfaceTypeImpl get boolQuestion {
     var element = typeProvider.boolElement;
     return interfaceTypeQuestion(element);
   }
 
-  InterfaceType get doubleNone {
+  InterfaceTypeImpl get doubleNone {
     var element = typeProvider.doubleType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get doubleQuestion {
+  InterfaceTypeImpl get doubleQuestion {
     var element = typeProvider.doubleType.element;
     return interfaceTypeQuestion(element);
   }
 
-  DartType get dynamicType => DynamicTypeImpl.instance;
+  TypeImpl get dynamicType => DynamicTypeImpl.instance;
 
-  InterfaceType get functionNone {
+  InterfaceTypeImpl get functionNone {
     var element = typeProvider.functionType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get functionQuestion {
+  InterfaceTypeImpl get functionQuestion {
     var element = typeProvider.functionType.element;
     return interfaceTypeQuestion(element);
   }
 
-  InterfaceType get intNone {
+  InterfaceTypeImpl get intNone {
     var element = typeProvider.intType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get intQuestion {
+  InterfaceTypeImpl get intQuestion {
     var element = typeProvider.intType.element;
     return interfaceTypeQuestion(element);
   }
 
-  DartType get invalidType => InvalidTypeImpl.instance;
+  TypeImpl get invalidType => InvalidTypeImpl.instance;
 
   NeverTypeImpl get neverNone => NeverTypeImpl.instance;
 
   NeverTypeImpl get neverQuestion => NeverTypeImpl.instanceNullable;
 
   InterfaceTypeImpl get nullNone {
     var element = typeProvider.nullType.element;
-    return interfaceTypeNone(element) as InterfaceTypeImpl;
+    return interfaceTypeNone(element);
   }
 
-  InterfaceType get numNone {
+  InterfaceTypeImpl get numNone {
     var element = typeProvider.numType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get numQuestion {
+  InterfaceTypeImpl get numQuestion {
     var element = typeProvider.numType.element;
     return interfaceTypeQuestion(element);
   }
 
-  InterfaceType get objectNone {
+  InterfaceTypeImpl get objectNone {
     var element = typeProvider.objectType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get objectQuestion {
+  InterfaceTypeImpl get objectQuestion {
     var element = typeProvider.objectType.element;
     return interfaceTypeQuestion(element);
   }
 
-  InterfaceType get recordNone {
+  InterfaceTypeImpl get recordNone {
     var element = typeProvider.recordElement;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get stringNone {
+  InterfaceTypeImpl get stringNone {
     var element = typeProvider.stringType.element;
     return interfaceTypeNone(element);
   }
 
-  InterfaceType get stringQuestion {
+  InterfaceTypeImpl get stringQuestion {
     var element = typeProvider.stringType.element;
     return interfaceTypeQuestion(element);
   }
 
   LibraryElementImpl get testLibrary => throw UnimplementedError();
 
-  TypeProvider get typeProvider;
+  TypeProviderImpl get typeProvider;
 
-  DartType get unknownInferredType => UnknownInferredType.instance;
+  TypeImpl get unknownInferredType => UnknownInferredType.instance;
 
   VoidTypeImpl get voidNone => VoidTypeImpl.instance;
 
@@ -149,7 +149,7 @@ mixin ElementsTypesMixin {
     return fragment;
   }
 
-  InterfaceType comparableNone(DartType type) {
+  InterfaceTypeImpl comparableNone(DartType type) {
     var coreLibrary = typeProvider.intElement.library;
     var element = coreLibrary.getClass('Comparable')!;
     return element.instantiate(
@@ -158,7 +158,7 @@ mixin ElementsTypesMixin {
     );
   }
 
-  InterfaceType comparableQuestion(DartType type) {
+  InterfaceTypeImpl comparableQuestion(DartType type) {
     var coreLibrary = typeProvider.intElement.library;
     var element = coreLibrary.getClass('Comparable')!;
     return element.instantiate(
@@ -271,32 +271,32 @@ mixin ElementsTypesMixin {
     return typeProvider.futureElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.none,
-    ) as InterfaceTypeImpl;
+    );
   }
 
   InterfaceTypeImpl futureOrNone(DartType type) {
     return typeProvider.futureOrElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.none,
-    ) as InterfaceTypeImpl;
+    );
   }
 
   InterfaceTypeImpl futureOrQuestion(DartType type) {
     return typeProvider.futureOrElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.question,
-    ) as InterfaceTypeImpl;
+    );
   }
 
   InterfaceTypeImpl futureQuestion(DartType type) {
     return typeProvider.futureElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.question,
-    ) as InterfaceTypeImpl;
+    );
   }
 
-  InterfaceType interfaceType(
-    InterfaceElement element, {
+  InterfaceTypeImpl interfaceType(
+    InterfaceElementImpl element, {
     List<DartType> typeArguments = const [],
     required NullabilitySuffix nullabilitySuffix,
   }) {
@@ -306,8 +306,8 @@ mixin ElementsTypesMixin {
     );
   }
 
-  InterfaceType interfaceTypeNone(
-    InterfaceElement element, {
+  InterfaceTypeImpl interfaceTypeNone(
+    InterfaceElementImpl element, {
     List<DartType> typeArguments = const [],
   }) {
     return element.instantiate(
@@ -316,8 +316,8 @@ mixin ElementsTypesMixin {
     );
   }
 
-  InterfaceType interfaceTypeQuestion(
-    InterfaceElement element, {
+  InterfaceTypeImpl interfaceTypeQuestion(
+    InterfaceElementImpl element, {
     List<DartType> typeArguments = const [],
   }) {
     return element.instantiate(
@@ -326,14 +326,14 @@ mixin ElementsTypesMixin {
     );
   }
 
-  InterfaceType iterableNone(DartType type) {
+  InterfaceTypeImpl iterableNone(DartType type) {
     return typeProvider.iterableElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.none,
     );
   }
 
-  InterfaceType iterableQuestion(DartType type) {
+  InterfaceTypeImpl iterableQuestion(DartType type) {
     return typeProvider.iterableElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.question,
@@ -371,28 +371,28 @@ mixin ElementsTypesMixin {
     return library;
   }
 
-  InterfaceType listNone(DartType type) {
+  InterfaceTypeImpl listNone(DartType type) {
     return typeProvider.listElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.none,
     );
   }
 
-  InterfaceType listQuestion(DartType type) {
+  InterfaceTypeImpl listQuestion(DartType type) {
     return typeProvider.listElement.instantiate(
       typeArguments: [type],
       nullabilitySuffix: NullabilitySuffix.question,
     );
   }
 
-  InterfaceType mapNone(DartType key, DartType value) {
+  InterfaceTypeImpl mapNone(DartType key, DartType value) {
     return typeProvider.mapElement.instantiate(
       typeArguments: [key, value],
       nullabilitySuffix: NullabilitySuffix.none,
     );
   }
 
-  InterfaceType mapQuestion(DartType key, DartType value) {
+  InterfaceTypeImpl mapQuestion(DartType key, DartType value) {
     return typeProvider.mapElement.instantiate(
       typeArguments: [key, value],
       nullabilitySuffix: NullabilitySuffix.question,
@@ -451,7 +451,7 @@ mixin ElementsTypesMixin {
     return parameter;
   }
 
-  ParameterElement namedRequiredParameter({
+  ParameterElementImpl namedRequiredParameter({
     required String name,
     required DartType type,
     bool isCovariant = false,
@@ -590,8 +590,8 @@ mixin ElementsTypesMixin {
     return fragment;
   }
 
-  DartType typeAliasTypeNone(
-    TypeAliasElement element, {
+  TypeImpl typeAliasTypeNone(
+    TypeAliasElementImpl element, {
     List<DartType> typeArguments = const [],
   }) {
     return element.instantiate(

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

@@ -1116,7 +1116,10 @@ class InterfaceTypeImplTest extends AbstractTypeSystemTest with StringTypes {
       nullabilitySuffix: NullabilitySuffix.none,
     );
 
-    var B = class_(name: 'B', interfaces: [AofC],);
+    var B = class_(
+      name: 'B',
+      interfaces: [AofC],
+    );
     var targetType = interfaceTypeNone(B);
     var result = targetType.asInstanceOf(A);
     expect(result, AofC);
@@ -1540,7 +1543,7 @@ A<int>?
   }
 
   void test_hashCode() {
-    ClassElement classA = class_(name: 'A');
+    var classA = class_(name: 'A');
     InterfaceType typeA = interfaceTypeNone(classA);
     expect(0 == typeA.hashCode, isFalse);
   }

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

@@ -4,8 +4,8 @@
 
 import 'package:_fe_analyzer_shared/src/flow_analysis/factory_type_test_helper.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/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:test/test.dart' as test;
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -22,7 +22,7 @@ main() {
 @reflectiveTest
 class FactorTypeTest with FactorTypeTestMixin<DartType>, ElementsTypesMixin {
   @override
-  late final TypeProvider typeProvider;
+  late final TypeProviderImpl typeProvider;
 
   late final TypeSystemImpl typeSystem;
 

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

@@ -4,7 +4,6 @@
 
 // ignore_for_file: analyzer_use_new_elements
 
-import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/least_upper_bound.dart';
@@ -157,13 +156,10 @@ class PathToObjectTest extends AbstractTypeSystemTest {
     //    \ /
     //     E
     //
-    ClassElement classA = class_(name: "A");
-    ClassElement classB =
-        class_(name: "B", superType: interfaceTypeNone(classA));
-    ClassElement classC =
-        class_(name: "C", superType: interfaceTypeNone(classA));
-    ClassElement classD =
-        class_(name: "D", superType: interfaceTypeNone(classC));
+    var classA = class_(name: "A");
+    var classB = class_(name: "B", superType: interfaceTypeNone(classA));
+    var classC = class_(name: "C", superType: interfaceTypeNone(classA));
+    var classD = class_(name: "D", superType: interfaceTypeNone(classC));
     ClassElementImpl classE =
         class_(name: "E", superType: interfaceTypeNone(classB));
     classE.interfaces = <InterfaceType>[interfaceTypeNone(classD)];
@@ -225,11 +221,9 @@ class PathToObjectTest extends AbstractTypeSystemTest {
     //     |
     //     C
     //
-    ClassElement classA = class_(name: "A");
-    ClassElement classB =
-        class_(name: "B", superType: interfaceTypeNone(classA));
-    ClassElement classC =
-        class_(name: "C", superType: interfaceTypeNone(classB));
+    var classA = class_(name: "A");
+    var classB = class_(name: "B", superType: interfaceTypeNone(classA));
+    var classC = class_(name: "C", superType: interfaceTypeNone(classB));
     expect(_toElement(classA), 2);
     expect(_toElement(classB), 3);
     expect(_toElement(classC), 4);
@@ -355,7 +349,7 @@ class PathToObjectTest extends AbstractTypeSystemTest {
     expect(_toElement(M), 4);
   }
 
-  int _toElement(InterfaceElement element) {
+  int _toElement(InterfaceElementImpl element) {
     var type = interfaceTypeNone(element);
     return _toType(type);
   }