Skip to content

Commit 0275121

Browse files
srawlinsCommit Queue
srawlins
authored and
Commit Queue
committed
analyzer: Migrate element model: parts of type_algebra.dart
This one is huge, so I'd like to migrate it in a few steps. * Remove top-level `getFreshTypeParameters` and `substitute` functions. * Remove `Substitution.fromMap` function. * Remove `TypeSystemImpl.instantiateToBounds`, `instantiateTypeFormalsToBounds`, and `typeFormalsAsElements` methods. Change-Id: Ieba5ddc63652776fb233f52f8fc3bf4be2d976dd Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/409382 Reviewed-by: Konstantin Shcheglov <[email protected]> Commit-Queue: Samuel Rawlins <[email protected]>
1 parent 0e9c9f0 commit 0275121

File tree

8 files changed

+52
-227
lines changed

8 files changed

+52
-227
lines changed

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

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import 'package:analyzer/dart/element/type.dart';
1313
import 'package:analyzer/src/dart/element/element.dart';
1414
import 'package:analyzer/src/dart/element/type.dart';
1515
import 'package:analyzer/src/dart/element/type_algebra.dart';
16+
import 'package:analyzer/src/utilities/extensions/element.dart';
1617

1718
/// A class that builds a "display string" for [Element]s and [DartType]s.
1819
class ElementDisplayStringBuilder {
@@ -649,9 +650,9 @@ class ElementDisplayStringBuilder {
649650
namesToAvoid.add(typeParameter.displayName);
650651
}
651652

652-
var newTypeParameters = <TypeParameterElement>[];
653-
for (var typeParameter in type.typeFormals) {
654-
var name = typeParameter.name;
653+
var newTypeParameters = <TypeParameterElement2>[];
654+
for (var typeParameter in type.typeParameters) {
655+
var name = typeParameter.name3!;
655656
for (var counter = 0; !namesToAvoid.add(name); counter++) {
656657
const unicodeSubscriptZero = 0x2080;
657658
const unicodeZero = 0x30;
@@ -660,13 +661,13 @@ class ElementDisplayStringBuilder {
660661
return unicodeSubscriptZero + (n - unicodeZero);
661662
}));
662663

663-
name = typeParameter.name + subscript;
664+
name = typeParameter.name3! + subscript;
664665
}
665666

666667
var newTypeParameter = TypeParameterElementImpl(name, -1);
667668
newTypeParameter.name2 = name;
668669
newTypeParameter.bound = typeParameter.bound;
669-
newTypeParameters.add(newTypeParameter);
670+
newTypeParameters.add(newTypeParameter.asElement2);
670671
}
671672

672673
return replaceTypeParameters(type as FunctionTypeImpl, newTypeParameters);

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

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -247,7 +247,7 @@ class GenericInferrer {
247247
List<DartType>? tryChooseFinalTypes({bool failAtError = true}) {
248248
var inferredTypes = _chooseTypes(preliminary: false);
249249
// Check the inferred types against all of the constraints.
250-
var knownTypes = <TypeParameterElement, TypeImpl>{};
250+
var knownTypes = <TypeParameterElement2, TypeImpl>{};
251251
var hasErrorReported = false;
252252
for (int i = 0; i < _typeFormals.length; i++) {
253253
TypeParameterElementImpl2 parameter = _typeFormals[i];
@@ -331,7 +331,7 @@ class GenericInferrer {
331331
}
332332

333333
if (UnknownInferredType.isKnown(inferred)) {
334-
knownTypes[parameter.firstFragment] = inferred;
334+
knownTypes[parameter] = inferred;
335335
} else if (_strictInference) {
336336
// [typeParam] could not be inferred. A result will still be returned
337337
// by [infer], with [typeParam] filled in as its bounds. This is
@@ -347,10 +347,8 @@ class GenericInferrer {
347347

348348
// Use instantiate to bounds to finish things off.
349349
var hasError = List<bool>.filled(_typeFormals.length, false);
350-
var result = _typeSystem.instantiateTypeFormalsToBounds(
351-
_typeFormals.map((e) => e.firstFragment).toList(),
352-
hasError: hasError,
353-
knownTypes: knownTypes);
350+
var result = _typeSystem.instantiateTypeFormalsToBounds2(_typeFormals,
351+
hasError: hasError, knownTypes: knownTypes);
354352

355353
// Report any errors from instantiateToBounds.
356354
for (int i = 0; i < hasError.length; i++) {

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

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -155,13 +155,13 @@ class ConstructorMember extends ExecutableMember
155155
MapSubstitution substitution;
156156
if (element is ConstructorMember) {
157157
declaration = element._declaration as ConstructorElement;
158-
var map = <TypeParameterElement, DartType>{};
159-
var elementMap = element._substitution.map;
158+
var map = <TypeParameterElement2, DartType>{};
159+
var elementMap = element._substitution.map2;
160160
for (var typeParameter in elementMap.keys) {
161161
var type = elementMap[typeParameter]!;
162162
map[typeParameter] = _substitution.substituteType(type);
163163
}
164-
substitution = Substitution.fromMap(map);
164+
substitution = Substitution.fromMap2(map);
165165
} else {
166166
declaration = element;
167167
substitution = _substitution;
@@ -422,12 +422,12 @@ abstract class ExecutableMember extends Member
422422

423423
augmentationSubstitution = member.augmentationSubstitution;
424424

425-
var map = <TypeParameterElement, DartType>{};
426-
for (var entry in member._substitution.map.entries) {
427-
map[entry.key] = substitution.substituteType(entry.value);
428-
}
429-
map.addAll(substitution.map);
430-
combined = Substitution.fromMap(map);
425+
var map = <TypeParameterElement2, DartType>{
426+
for (var MapEntry(:key, :value) in member._substitution.map2.entries)
427+
key: substitution.substituteType(value),
428+
...substitution.map2,
429+
};
430+
combined = Substitution.fromMap2(map);
431431
}
432432

433433
if (augmentationSubstitution.map.isEmpty && combined.map.isEmpty) {
@@ -1371,12 +1371,12 @@ class ParameterMember extends VariableMember
13711371
var member = element;
13721372
element = member.declaration;
13731373

1374-
var map = <TypeParameterElement, DartType>{};
1375-
for (var entry in member._substitution.map.entries) {
1376-
map[entry.key] = substitution.substituteType(entry.value);
1377-
}
1378-
map.addAll(substitution.map);
1379-
combined = Substitution.fromMap(map);
1374+
var map = <TypeParameterElement2, DartType>{
1375+
for (var MapEntry(:key, :value) in member._substitution.map2.entries)
1376+
key: substitution.substituteType(value),
1377+
...substitution.map2,
1378+
};
1379+
combined = Substitution.fromMap2(map);
13801380
}
13811381

13821382
if (combined.map.isEmpty) {
@@ -1825,9 +1825,9 @@ class _SubstitutedTypeParameters {
18251825

18261826
return _SubstitutedTypeParameters._(
18271827
newElements,
1828-
Substitution.fromMap({
1829-
...substitution.map,
1830-
...substitution2.map,
1828+
Substitution.fromMap2({
1829+
...substitution.map2,
1830+
...substitution2.map2,
18311831
}),
18321832
);
18331833
}

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

Lines changed: 17 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -20,47 +20,6 @@ import 'package:analyzer/src/summary2/record_type_builder.dart';
2020
import 'package:analyzer/src/utilities/extensions/collection.dart';
2121
import 'package:analyzer/src/utilities/extensions/element.dart';
2222

23-
/// Generates a fresh copy of the given type parameters, with their bounds
24-
/// substituted to reference the new parameters.
25-
///
26-
/// The returned object contains the fresh type parameter list as well as a
27-
/// mapping to be used for replacing other types to use the new type parameters.
28-
FreshTypeParameters getFreshTypeParameters(
29-
List<TypeParameterElement> typeParameters) {
30-
var freshParameters = List<TypeParameterElementImpl2>.generate(
31-
typeParameters.length,
32-
(i) => TypeParameterElementImpl(typeParameters[i].name, -1).element,
33-
growable: false,
34-
);
35-
36-
var map = <TypeParameterElement, DartType>{};
37-
for (int i = 0; i < typeParameters.length; ++i) {
38-
map[typeParameters[i]] = TypeParameterTypeImpl(
39-
element: freshParameters[i].firstFragment,
40-
nullabilitySuffix: NullabilitySuffix.none,
41-
);
42-
}
43-
44-
var substitution = Substitution.fromMap(map);
45-
46-
for (int i = 0; i < typeParameters.length; ++i) {
47-
// TODO(kallentu): : Clean up TypeParameterElementImpl casting once
48-
// variance is added to the interface.
49-
var typeParameter = typeParameters[i] as TypeParameterElementImpl;
50-
if (!typeParameter.isLegacyCovariant) {
51-
freshParameters[i].firstFragment.variance = typeParameter.variance;
52-
}
53-
54-
var bound = typeParameter.bound;
55-
if (bound != null) {
56-
var newBound = substitution.substituteType(bound);
57-
freshParameters[i].firstFragment.bound = newBound;
58-
}
59-
}
60-
61-
return FreshTypeParameters(freshParameters, substitution);
62-
}
63-
6423
/// Generates a fresh copy of the given type parameters, with their bounds
6524
/// substituted to reference the new parameters.
6625
///
@@ -107,7 +66,7 @@ FreshTypeParameters getFreshTypeParameters2(
10766
/// the [newTypeParameters] in the formal parameters and return type.
10867
FunctionType replaceTypeParameters(
10968
FunctionTypeImpl type,
110-
List<TypeParameterElement> newTypeParameters,
69+
List<TypeParameterElement2> newTypeParameters,
11170
) {
11271
assert(newTypeParameters.length == type.typeFormals.length);
11372
if (newTypeParameters.isEmpty) {
@@ -119,38 +78,19 @@ FunctionType replaceTypeParameters(
11978
.toList();
12079
var substitution = Substitution.fromPairs(type.typeFormals, typeArguments);
12180

122-
ParameterElement transformParameter(ParameterElement p) {
81+
FormalParameterElement transformParameter(FormalParameterElement p) {
12382
var type = substitution.substituteType(p.type);
12483
return p.copyWith(type: type);
12584
}
12685

127-
return FunctionTypeImpl(
128-
typeFormals: newTypeParameters,
129-
parameters: type.parameters.map(transformParameter).toList(),
86+
return FunctionTypeImpl.v2(
87+
typeParameters: newTypeParameters,
88+
formalParameters: type.formalParameters.map(transformParameter).toList(),
13089
returnType: substitution.substituteType(type.returnType),
13190
nullabilitySuffix: type.nullabilitySuffix,
13291
);
13392
}
13493

135-
/// Returns a type where all occurrences of the given type parameters have been
136-
/// replaced with the corresponding types.
137-
///
138-
/// This will copy only the sub-terms of [type] that contain substituted
139-
/// variables; all other [DartType] objects will be reused.
140-
///
141-
/// In particular, if no type parameters were substituted, this is guaranteed
142-
/// to return the [type] instance (not a copy), so the caller may use
143-
/// [identical] to efficiently check if a distinct type was created.
144-
DartType substitute(
145-
DartType type,
146-
Map<TypeParameterElement, DartType> substitution,
147-
) {
148-
if (substitution.isEmpty) {
149-
return type;
150-
}
151-
return Substitution.fromMap(substitution).substituteType(type);
152-
}
153-
15494
/// Returns a type where all occurrences of the given type parameters have been
15595
/// replaced with the corresponding types.
15696
///
@@ -255,15 +195,7 @@ abstract class Substitution {
255195
if (type.typeArguments.isEmpty) {
256196
return _NullSubstitution.instance;
257197
}
258-
return fromPairs(type.element.typeParameters, type.typeArguments);
259-
}
260-
261-
/// Substitutes each parameter to the type it maps to in [map].
262-
static MapSubstitution fromMap(Map<TypeParameterElement, DartType> map) {
263-
if (map.isEmpty) {
264-
return _NullSubstitution.instance;
265-
}
266-
return _MapSubstitution(map);
198+
return fromPairs2(type.element3.typeParameters2, type.typeArguments);
267199
}
268200

269201
/// Substitutes each parameter to the type it maps to in [map].
@@ -282,16 +214,7 @@ abstract class Substitution {
282214
List<TypeParameterElement> parameters,
283215
List<DartType> types,
284216
) {
285-
assert(parameters.length == types.length);
286-
if (parameters.isEmpty) {
287-
return _NullSubstitution.instance;
288-
}
289-
return fromMap(
290-
Map<TypeParameterElement, DartType>.fromIterables(
291-
parameters,
292-
types,
293-
),
294-
);
217+
return fromPairs2(parameters.map((p) => p.asElement2).toList(), types);
295218
}
296219

297220
/// Substitutes the Nth parameter in [parameters] with the Nth type in
@@ -300,8 +223,16 @@ abstract class Substitution {
300223
List<TypeParameterElement2> parameters,
301224
List<DartType> types,
302225
) {
303-
var fragments = parameters.map((e) => e.asElement).toList();
304-
return fromPairs(fragments, types);
226+
assert(parameters.length == types.length);
227+
if (parameters.isEmpty) {
228+
return _NullSubstitution.instance;
229+
}
230+
return fromMap2(
231+
Map<TypeParameterElement2, DartType>.fromIterables(
232+
parameters,
233+
types,
234+
),
235+
);
305236
}
306237
}
307238

0 commit comments

Comments
 (0)