Elements. Migrate FunctionTypeBuilder.
Change-Id: I9fc6acd85170a328c99b624da29d8e6fd7ffb769
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/407162
Reviewed-by: Samuel Rawlins <srawlins@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 93d71c5..044fcce 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -4654,6 +4654,10 @@
// TODO(augmentations): Implement the merge of formal parameters.
TypeImpl get type => wrappedElement.type;
+ set type(TypeImpl value) {
+ wrappedElement.type = value;
+ }
+
@override
// TODO(augmentations): Implement the merge of formal parameters.
List<TypeParameterElement2> get typeParameters2 => const [];
diff --git a/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart b/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
index 6a53a8d..8d7e789 100644
--- a/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
@@ -55,20 +55,20 @@
DartType? createFunctionTypeBuilder({
required FunctionTypeBuilder type,
- required List<TypeParameterElement2>? newTypeParameters,
- required List<FormalParameterElement>? newParameters,
+ required List<TypeParameterElementImpl2>? newTypeParameters,
+ required List<FormalParameterElementImpl>? newFormalParameters,
required TypeImpl? newReturnType,
required NullabilitySuffix? newNullability,
}) {
if (newNullability == null &&
newReturnType == null &&
- newParameters == null) {
+ newFormalParameters == null) {
return null;
}
return FunctionTypeBuilder.v2(
typeParameters: newTypeParameters ?? type.typeParameters,
- formalParameters: newParameters ?? type.formalParameters,
+ formalParameters: newFormalParameters ?? type.formalParameters,
returnType: newReturnType ?? type.returnType,
nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
);
@@ -330,7 +330,7 @@
changeVariance();
- List<FormalParameterElement>? newParameters;
+ List<FormalParameterElementImpl>? newFormalParameters;
for (var i = 0; i < node.formalParameters.length; i++) {
var parameter = node.formalParameters[i];
@@ -341,8 +341,8 @@
var newKind = visitParameterKind(kind);
if (newType != null || newKind != null) {
- newParameters ??= node.formalParameters.toList(growable: false);
- newParameters[i] = parameter.copyWith(
+ newFormalParameters ??= node.formalParameters.toList(growable: false);
+ newFormalParameters[i] = parameter.copyWith(
type: newType,
kind: newKind,
);
@@ -354,7 +354,7 @@
return createFunctionTypeBuilder(
type: node,
newTypeParameters: newTypeParameters,
- newParameters: newParameters,
+ newFormalParameters: newFormalParameters,
newReturnType: newReturnType,
newNullability: newNullability,
);
diff --git a/pkg/analyzer/lib/src/dart/element/type_algebra.dart b/pkg/analyzer/lib/src/dart/element/type_algebra.dart
index 8a570df..63d631b 100644
--- a/pkg/analyzer/lib/src/dart/element/type_algebra.dart
+++ b/pkg/analyzer/lib/src/dart/element/type_algebra.dart
@@ -544,18 +544,21 @@
int before = useCounter;
var inner = this;
- var typeFormals = type.typeFormals;
- if (typeFormals.isNotEmpty) {
+ var typeParameters = type.typeParameters;
+ if (typeParameters.isNotEmpty) {
inner = newInnerEnvironment();
- typeFormals = inner.freshTypeParameters(typeFormals);
+ typeParameters = inner
+ .freshTypeParameters(typeParameters.map((e) => e.asElement).toList())
+ .map((e) => e.asElement2 as TypeParameterElementImpl2)
+ .toList();
}
// Invert the variance when translating parameters.
inner.invertVariance();
- var parameters = type.parameters.map((parameter) {
- var type = parameter.type.accept(inner);
- return parameter.copyWith(type: type);
+ var formalParameters = type.formalParameters.map((formalParameter) {
+ var type = formalParameter.type.accept(inner);
+ return formalParameter.copyWith(type: type);
}).toList();
inner.invertVariance();
@@ -567,8 +570,8 @@
if (useCounter == before) return type;
return FunctionTypeBuilder(
- typeFormals,
- parameters,
+ typeParameters,
+ formalParameters,
returnType,
type.nullabilitySuffix,
);
diff --git a/pkg/analyzer/lib/src/summary2/function_type_builder.dart b/pkg/analyzer/lib/src/summary2/function_type_builder.dart
index 6022817..91197df 100644
--- a/pkg/analyzer/lib/src/summary2/function_type_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/function_type_builder.dart
@@ -2,10 +2,6 @@
// 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.
-// ignore_for_file: analyzer_use_new_elements
-
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/element2.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/dart/element/type_visitor.dart';
@@ -17,14 +13,13 @@
import 'package:analyzer/src/dart/element/type_visitor.dart';
import 'package:analyzer/src/summary2/type_builder.dart';
import 'package:analyzer/src/utilities/extensions/collection.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
/// The type builder for a [GenericFunctionType].
class FunctionTypeBuilder extends TypeBuilder {
static DynamicTypeImpl get _dynamicType => DynamicTypeImpl.instance;
- final List<TypeParameterElement> typeFormals;
- final List<ParameterElement> parameters;
+ final List<TypeParameterElementImpl2> typeParameters;
+ final List<FormalParameterElementImpl> formalParameters;
final TypeImpl returnType;
@override
@@ -42,8 +37,8 @@
FunctionTypeImpl? _type;
FunctionTypeBuilder(
- this.typeFormals,
- this.parameters,
+ this.typeParameters,
+ this.formalParameters,
this.returnType,
this.nullabilitySuffix, {
this.node,
@@ -63,29 +58,21 @@
}
factory FunctionTypeBuilder.v2({
- required List<TypeParameterElement2> typeParameters,
- required List<FormalParameterElement> formalParameters,
+ required List<TypeParameterElementImpl2> typeParameters,
+ required List<FormalParameterElementImpl> formalParameters,
required TypeImpl returnType,
required NullabilitySuffix nullabilitySuffix,
GenericFunctionTypeImpl? node,
}) {
return FunctionTypeBuilder(
- typeParameters.map((e) => e.asElement).toList(),
- formalParameters.map((e) => e.asElement).toList(),
+ typeParameters,
+ formalParameters,
returnType,
nullabilitySuffix,
node: node,
);
}
- List<FormalParameterElementMixin> get formalParameters {
- return parameters.map((p) => p.asElement2).toList(growable: false);
- }
-
- List<TypeParameterElementImpl2> get typeParameters => typeFormals
- .map((fragment) => fragment.asElement2 as TypeParameterElementImpl2)
- .toList();
-
@override
R accept<R>(TypeVisitor<R> visitor) {
if (visitor is LinkingTypeVisitor<R>) {
@@ -103,27 +90,26 @@
return type;
}
- for (var typeParameter in typeFormals) {
- var typeParameterImpl = typeParameter as TypeParameterElementImpl;
- var bound = typeParameterImpl.bound;
+ for (var typeParameter in typeParameters) {
+ var bound = typeParameter.bound;
if (bound != null) {
- typeParameterImpl.bound = _buildType(bound);
+ typeParameter.bound = _buildType(bound);
}
}
- for (var parameter in parameters) {
- (parameter as ParameterElementImpl).type = _buildType(parameter.type);
+ for (var formalParameter in formalParameters) {
+ formalParameter.type = _buildType(formalParameter.type);
}
var builtReturnType = _buildType(returnType);
- type = FunctionTypeImpl(
- typeFormals: typeFormals,
- parameters: parameters,
+ type = FunctionTypeImpl.v2(
+ typeParameters: typeParameters,
+ formalParameters: formalParameters,
returnType: builtReturnType,
nullabilitySuffix: nullabilitySuffix,
);
- var fresh = getFreshTypeParameters(typeFormals);
+ var fresh = getFreshTypeParameters2(typeParameters);
type = fresh.applyToFunctionType(type);
_type = type;
@@ -135,14 +121,14 @@
String toString() {
var buffer = StringBuffer();
- if (typeFormals.isNotEmpty) {
+ if (typeParameters.isNotEmpty) {
buffer.write('<');
- buffer.write(typeFormals.join(', '));
+ buffer.write(typeParameters.join(', '));
buffer.write('>');
}
buffer.write('(');
- buffer.write(parameters.join(', '));
+ buffer.write(formalParameters.join(', '));
buffer.write(')');
buffer.write(' → ');
@@ -158,19 +144,19 @@
}
return FunctionTypeBuilder(
- typeFormals,
- parameters,
+ typeParameters,
+ formalParameters,
returnType,
nullabilitySuffix,
node: node,
);
}
- static List<ParameterElementImpl> getParameters(
- FormalParameterList node,
+ static List<FormalParameterElementImpl> getParameters(
+ FormalParameterListImpl node,
) {
- return node.parameters.asImpl.map((parameter) {
- return ParameterElementImpl.synthetic(
+ return node.parameters.map((parameter) {
+ return FormalParameterElementImpl.synthetic(
parameter.name?.lexeme ?? '',
_getParameterType(parameter),
parameter.kind,
@@ -197,12 +183,12 @@
}
/// Return the type of the [node] as is, possibly a [TypeBuilder].
- static DartType _getParameterType(FormalParameter node) {
- if (node is DefaultFormalParameter) {
+ static DartType _getParameterType(FormalParameterImpl node) {
+ if (node is DefaultFormalParameterImpl) {
return _getParameterType(node.parameter);
- } else if (node is SimpleFormalParameter) {
+ } else if (node is SimpleFormalParameterImpl) {
return _getNodeType(node.type);
- } else if (node is FunctionTypedFormalParameter) {
+ } else if (node is FunctionTypedFormalParameterImpl) {
NullabilitySuffix nullabilitySuffix;
if (node.question != null) {
nullabilitySuffix = NullabilitySuffix.question;
@@ -221,10 +207,12 @@
}
}
- static List<TypeParameterElement> _getTypeParameters(
- TypeParameterList? node,
+ static List<TypeParameterElementImpl2> _getTypeParameters(
+ TypeParameterListImpl? node,
) {
if (node == null) return const [];
- return node.typeParameters.map((n) => n.declaredElement!).toFixedList();
+ return node.typeParameters.map((node) {
+ return node.declaredFragment!.element;
+ }).toFixedList();
}
}
diff --git a/pkg/analyzer/lib/src/summary2/variance_builder.dart b/pkg/analyzer/lib/src/summary2/variance_builder.dart
index 4ac7a70..454d666 100644
--- a/pkg/analyzer/lib/src/summary2/variance_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/variance_builder.dart
@@ -104,8 +104,8 @@
return _computeFunctionType(
variable,
returnType: type.returnType,
- typeFormals: type.typeFormals,
- parameters: type.parameters,
+ typeFormals: type.typeParameters.map((e) => e.asElement).toList(),
+ parameters: type.formalParameters.map((e) => e.asElement).toList(),
);
} else if (type is RecordTypeBuilder) {
var result = Variance.unrelated;
@@ -153,7 +153,7 @@
return result;
}
- void _functionTypeAlias(FunctionTypeAlias node) {
+ void _functionTypeAlias(FunctionTypeAliasImpl node) {
var parameterList = node.typeParameters;
if (parameterList == null) {
return;
@@ -179,7 +179,9 @@
parameter.declaredElement!,
returnType: node.returnType?.type,
typeFormals: null,
- parameters: FunctionTypeBuilder.getParameters(node.parameters),
+ parameters: FunctionTypeBuilder.getParameters(node.parameters)
+ .map((e) => e.asElement)
+ .toList(),
);
_setVariance(parameter, variance);
}
@@ -231,9 +233,9 @@
var node = _linker.getLinkingNode(element);
if (node == null) {
// Not linking.
- } else if (node is GenericTypeAlias) {
+ } else if (node is GenericTypeAliasImpl) {
_genericTypeAlias(node);
- } else if (node is FunctionTypeAlias) {
+ } else if (node is FunctionTypeAliasImpl) {
_functionTypeAlias(node);
} else {
throw UnimplementedError('(${node.runtimeType}) $node');
