Deprecate DartType.element3, use element instead.
Change-Id: Idef9da09c565a05fa84869f7433df3c24c6fbb5f Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/435521 Reviewed-by: Paul Berry <paulberry@google.com> Reviewed-by: Brian Wilkerson <brianwilkerson@google.com> Reviewed-by: Konstantin Shcheglov <scheglov@google.com> Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
This commit is contained in:
committed by
Commit Queue
parent
0ff6daa3dd
commit
318aeb322b
@@ -186,8 +186,8 @@ class DartInlayHintComputer {
|
||||
InlayHintLabelPart(
|
||||
// Write type without type args or nullability suffix. Type args need
|
||||
// adding as their own parts, and the nullability suffix does after them.
|
||||
value: type.element3?.name3 ?? type.getDisplayString(),
|
||||
location: _locationForElement(type.element3),
|
||||
value: type.element?.name3 ?? type.getDisplayString(),
|
||||
location: _locationForElement(type.element),
|
||||
),
|
||||
);
|
||||
// Call recursively for any nested type arguments.
|
||||
|
||||
@@ -81,7 +81,7 @@ class DartLazyTypeHierarchyComputer {
|
||||
}
|
||||
|
||||
return type is InterfaceType
|
||||
? TypeHierarchyItem.forElement(type.element3)
|
||||
? TypeHierarchyItem.forElement(type.element)
|
||||
: null;
|
||||
}
|
||||
|
||||
@@ -259,28 +259,28 @@ class TypeHierarchyRelatedItem extends TypeHierarchyItem {
|
||||
|
||||
static TypeHierarchyRelatedItem? constrainedTo(InterfaceType type) =>
|
||||
_forElement(
|
||||
type.element3,
|
||||
type.element,
|
||||
relationship: TypeHierarchyItemRelationship.constrainedTo,
|
||||
);
|
||||
|
||||
static TypeHierarchyRelatedItem? extends_(InterfaceType type) => _forElement(
|
||||
type.element3,
|
||||
type.element,
|
||||
relationship: TypeHierarchyItemRelationship.extends_,
|
||||
);
|
||||
|
||||
static TypeHierarchyRelatedItem? implements(InterfaceType type) =>
|
||||
_forElement(
|
||||
type.element3,
|
||||
type.element,
|
||||
relationship: TypeHierarchyItemRelationship.implements,
|
||||
);
|
||||
|
||||
static TypeHierarchyRelatedItem? mixesIn(InterfaceType type) => _forElement(
|
||||
type.element3,
|
||||
type.element,
|
||||
relationship: TypeHierarchyItemRelationship.mixesIn,
|
||||
);
|
||||
|
||||
static TypeHierarchyRelatedItem? unknown(InterfaceType type) => _forElement(
|
||||
type.element3,
|
||||
type.element,
|
||||
relationship: TypeHierarchyItemRelationship.unknown,
|
||||
);
|
||||
|
||||
|
||||
@@ -174,13 +174,13 @@ class _OverriddenElementsFinder {
|
||||
}
|
||||
// interfaces
|
||||
for (var interfaceType in class_.interfaces) {
|
||||
_addInterfaceOverrides(interfaceType.element3, true);
|
||||
_addInterfaceOverrides(interfaceType.element, true);
|
||||
}
|
||||
// super
|
||||
_addInterfaceOverrides(class_.supertype?.element3, checkType);
|
||||
_addInterfaceOverrides(class_.supertype?.element, checkType);
|
||||
if (class_ is MixinElement) {
|
||||
for (var constraint in class_.superclassConstraints) {
|
||||
_addInterfaceOverrides(constraint.element3, true);
|
||||
_addInterfaceOverrides(constraint.element, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -203,13 +203,13 @@ class _OverriddenElementsFinder {
|
||||
}
|
||||
}
|
||||
|
||||
_addSuperOverrides(class_.supertype?.element3);
|
||||
_addSuperOverrides(class_.supertype?.element);
|
||||
for (var mixin_ in class_.mixins) {
|
||||
_addSuperOverrides(mixin_.element3);
|
||||
_addSuperOverrides(mixin_.element);
|
||||
}
|
||||
if (class_ is MixinElement) {
|
||||
for (var constraint in class_.superclassConstraints) {
|
||||
_addSuperOverrides(constraint.element3);
|
||||
_addSuperOverrides(constraint.element);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -136,7 +136,7 @@ class FlutterOutlineComputer {
|
||||
if (type is! InterfaceType || !type.isWidgetType) {
|
||||
return null;
|
||||
}
|
||||
var className = type.element3.displayName;
|
||||
var className = type.element.displayName;
|
||||
|
||||
if (node is InstanceCreationExpression) {
|
||||
var attributes = <protocol.FlutterOutlineAttribute>[];
|
||||
|
||||
+2
-2
@@ -159,8 +159,8 @@ mixin EditableArgumentsMixin {
|
||||
|
||||
/// Returns a list of the constants of an enum constant prefixed with the enum
|
||||
/// name.
|
||||
List<String> getQualifiedEnumConstantNames(EnumElement element3) =>
|
||||
element3.constants2.map(getQualifiedEnumConstantName).nonNulls.toList();
|
||||
List<String> getQualifiedEnumConstantNames(EnumElement element) =>
|
||||
element.constants2.map(getQualifiedEnumConstantName).nonNulls.toList();
|
||||
|
||||
/// Returns the name of an enum constant prefixed with the enum name.
|
||||
static String? getQualifiedEnumConstantName(FieldElement enumConstant) {
|
||||
|
||||
+2
-2
@@ -210,9 +210,9 @@ class EditArgumentHandler extends SharedMessageHandler<EditArgumentParams, Null>
|
||||
),
|
||||
);
|
||||
} else if (parameter.type case InterfaceType(
|
||||
:EnumElement element3,
|
||||
:EnumElement element,
|
||||
) when value is String?) {
|
||||
var allowedValues = getQualifiedEnumConstantNames(element3);
|
||||
var allowedValues = getQualifiedEnumConstantNames(element);
|
||||
if (allowedValues.contains(value)) {
|
||||
return success(value.toString());
|
||||
} else {
|
||||
|
||||
+8
-8
@@ -200,11 +200,11 @@ class EditableArgumentsHandler
|
||||
type = 'string';
|
||||
value = values.argumentValue?.toStringValue();
|
||||
defaultValue = values.parameterValue?.toStringValue();
|
||||
} else if (parameter.type case InterfaceType(:EnumElement element3)) {
|
||||
} else if (parameter.type case InterfaceType(:EnumElement element)) {
|
||||
type = 'enum';
|
||||
options = getQualifiedEnumConstantNames(element3);
|
||||
value = values.argumentValue?.toEnumStringValue(element3);
|
||||
defaultValue = values.parameterValue?.toEnumStringValue(element3);
|
||||
options = getQualifiedEnumConstantNames(element);
|
||||
value = values.argumentValue?.toEnumStringValue(element);
|
||||
defaultValue = values.parameterValue?.toEnumStringValue(element);
|
||||
} else {
|
||||
// TODO(dantup): Determine which parameters we don't include (such as
|
||||
// Widgets) and which we include just without values.
|
||||
@@ -252,14 +252,14 @@ class EditableArgumentsHandler
|
||||
}
|
||||
|
||||
extension on DartObject? {
|
||||
Object? toEnumStringValue(EnumElement element3) {
|
||||
Object? toEnumStringValue(EnumElement element) {
|
||||
var valueObject = this;
|
||||
if (valueObject?.type case InterfaceType(
|
||||
element3: EnumElement valueElement,
|
||||
) when element3 == valueElement) {
|
||||
element: EnumElement valueElement,
|
||||
) when element == valueElement) {
|
||||
var index = valueObject?.getField('index')?.toIntValue();
|
||||
if (index != null) {
|
||||
var enumConstant = element3.constants2.elementAtOrNull(index);
|
||||
var enumConstant = element.constants2.elementAtOrNull(index);
|
||||
if (enumConstant != null) {
|
||||
return EditableArgumentsMixin.getQualifiedEnumConstantName(
|
||||
enumConstant,
|
||||
|
||||
@@ -88,7 +88,7 @@ class _SuperComputer {
|
||||
// For super classes, we use the first fragment (the original declaration).
|
||||
// This differs from methods/getters because we jump to the end of the
|
||||
// augmentation chain for those.
|
||||
return element.supertype?.element3.firstFragment;
|
||||
return element.supertype?.element.firstFragment;
|
||||
}
|
||||
|
||||
Fragment? _findSuperConstructor(ConstructorElement element) {
|
||||
|
||||
@@ -106,9 +106,9 @@ class TypeDefinitionHandler
|
||||
|
||||
analyzer.Element? element;
|
||||
if (type is InterfaceType) {
|
||||
element = type.element3;
|
||||
element = type.element;
|
||||
} else if (type is TypeParameterType) {
|
||||
element = type.element3;
|
||||
element = type.element;
|
||||
}
|
||||
if (element is! analyzer.Element) {
|
||||
return success(_emptyResult);
|
||||
|
||||
@@ -139,19 +139,19 @@ class TypeHierarchyComputer {
|
||||
var superType = classElement.supertype;
|
||||
if (superType != null) {
|
||||
item.superclass = _createSuperItem(
|
||||
superType.element3,
|
||||
superType.element,
|
||||
superType.typeArguments,
|
||||
);
|
||||
}
|
||||
}
|
||||
// mixins
|
||||
for (var type in classElement.mixins) {
|
||||
var id = _createSuperItem(type.element3, type.typeArguments);
|
||||
var id = _createSuperItem(type.element, type.typeArguments);
|
||||
item.mixins.add(id);
|
||||
}
|
||||
// interfaces
|
||||
for (var type in classElement.interfaces) {
|
||||
var id = _createSuperItem(type.element3, type.typeArguments);
|
||||
var id = _createSuperItem(type.element, type.typeArguments);
|
||||
item.interfaces.add(id);
|
||||
}
|
||||
// done
|
||||
@@ -232,7 +232,7 @@ class TypeHierarchyComputerHelper {
|
||||
}
|
||||
// try to find in the class mixin
|
||||
for (var mixin in clazz.mixins.reversed) {
|
||||
var mixinElement = mixin.element3;
|
||||
var mixinElement = mixin.element;
|
||||
if (pivotKind == ElementKind.METHOD) {
|
||||
result = mixinElement.lookUpMethod(
|
||||
name: pivotName,
|
||||
|
||||
@@ -457,7 +457,7 @@ class DeclarationHelper {
|
||||
}) {
|
||||
var extendedType = extension.extendedType;
|
||||
var referencingInterface =
|
||||
(extendedType is InterfaceType) ? extendedType.element3 : null;
|
||||
(extendedType is InterfaceType) ? extendedType.element : null;
|
||||
if (includeMethods) {
|
||||
for (var method in extension.methods) {
|
||||
if (!method.isStatic) {
|
||||
@@ -648,7 +648,7 @@ class DeclarationHelper {
|
||||
if (element is TypeAliasElement) {
|
||||
var aliasedType = element.aliasedType;
|
||||
if (aliasedType is InterfaceType) {
|
||||
element = aliasedType.element3;
|
||||
element = aliasedType.element;
|
||||
}
|
||||
}
|
||||
switch (element) {
|
||||
@@ -1109,8 +1109,8 @@ class DeclarationHelper {
|
||||
var substitution = Substitution.fromInterfaceType(type);
|
||||
var map =
|
||||
onlySuper
|
||||
? type.element3.inheritedConcreteMembers
|
||||
: type.element3.interfaceMembers;
|
||||
? type.element.inheritedConcreteMembers
|
||||
: type.element.interfaceMembers;
|
||||
|
||||
var membersByName = <String, List<ExecutableElement>>{};
|
||||
for (var rawMember in map.values) {
|
||||
@@ -1121,7 +1121,7 @@ class DeclarationHelper {
|
||||
.add(rawMember);
|
||||
}
|
||||
}
|
||||
var referencingInterface = _referencingInterfaceFor(type.element3);
|
||||
var referencingInterface = _referencingInterfaceFor(type.element);
|
||||
for (var entry in membersByName.entries) {
|
||||
var members = entry.value;
|
||||
var rawMember = _bestMember(members);
|
||||
@@ -1722,7 +1722,7 @@ class DeclarationHelper {
|
||||
if (element is InterfaceElement) {
|
||||
return element;
|
||||
} else if (element is InstanceElement) {
|
||||
var thisElement = element.thisType.element3;
|
||||
var thisElement = element.thisType.element;
|
||||
if (thisElement is InterfaceElement) {
|
||||
return thisElement;
|
||||
}
|
||||
|
||||
@@ -478,14 +478,14 @@ class FeatureComputer {
|
||||
return -1;
|
||||
}
|
||||
var minDepth = _inheritanceDistance(
|
||||
subclass.supertype?.element3,
|
||||
subclass.supertype?.element,
|
||||
superclass,
|
||||
visited,
|
||||
);
|
||||
|
||||
void visitTypes(List<InterfaceType> types) {
|
||||
for (var type in types) {
|
||||
var depth = _inheritanceDistance(type.element3, superclass, visited);
|
||||
var depth = _inheritanceDistance(type.element, superclass, visited);
|
||||
if (minDepth < 0 || (depth >= 0 && depth < minDepth)) {
|
||||
minDepth = depth;
|
||||
}
|
||||
@@ -1283,7 +1283,7 @@ parent3: ${node.parent?.parent?.parent}
|
||||
}
|
||||
var declaredElement = field.element2?.library2;
|
||||
var uri = declaredElement?.uri;
|
||||
var member = type.element3.getInterfaceMember(Name(uri, name));
|
||||
var member = type.element.getInterfaceMember(Name(uri, name));
|
||||
if (member is GetterElement) {
|
||||
return member.returnType;
|
||||
} else if (member is MethodElement) {
|
||||
|
||||
@@ -928,7 +928,7 @@ class InScopeCompletionPass extends SimpleAstVisitor<void> {
|
||||
var contextType = _computeContextType(node);
|
||||
if (contextType == null) return;
|
||||
|
||||
var element = contextType.element3;
|
||||
var element = contextType.element;
|
||||
if (element == null) return;
|
||||
|
||||
var parent = node.parent;
|
||||
@@ -2302,7 +2302,7 @@ class InScopeCompletionPass extends SimpleAstVisitor<void> {
|
||||
featureSet.isEnabled(Feature.dot_shorthands)) {
|
||||
var contextType = _computeContextType(node);
|
||||
if (contextType == null) return;
|
||||
element = contextType.element3;
|
||||
element = contextType.element;
|
||||
} else {
|
||||
element = target.element;
|
||||
}
|
||||
|
||||
+1
-1
@@ -425,7 +425,7 @@ class AddDiagnosticPropertyReference extends ResolvedCorrectionProducer {
|
||||
}
|
||||
|
||||
bool _isEnum(DartType type) {
|
||||
return type is InterfaceType && type.element3 is EnumElement;
|
||||
return type is InterfaceType && type.element is EnumElement;
|
||||
}
|
||||
|
||||
bool _isIterable(DartType type) {
|
||||
|
||||
+1
-1
@@ -44,7 +44,7 @@ class AddMissingEnumCaseClauses extends ResolvedCorrectionProducer {
|
||||
|
||||
var expressionType = statement.expression.staticType;
|
||||
if (expressionType is InterfaceType) {
|
||||
var enumElement = expressionType.element3;
|
||||
var enumElement = expressionType.element;
|
||||
if (enumElement is EnumElement) {
|
||||
enumName = enumElement.name3;
|
||||
for (var field in enumElement.fields) {
|
||||
|
||||
+1
-1
@@ -34,7 +34,7 @@ class AddMissingEnumLikeCaseClauses extends ResolvedCorrectionProducer {
|
||||
if (expressionType is! InterfaceType) {
|
||||
return;
|
||||
}
|
||||
var classElement = expressionType.element3;
|
||||
var classElement = expressionType.element;
|
||||
var className = classElement.name3;
|
||||
if (className == null) {
|
||||
return;
|
||||
|
||||
@@ -44,7 +44,7 @@ class AddSuperParameter extends ResolvedCorrectionProducer {
|
||||
|
||||
var classElement = classDeclaration.declaredFragment!.element;
|
||||
var superType = classElement.supertype;
|
||||
var superElement = superType?.element3;
|
||||
var superElement = superType?.element;
|
||||
var superUnnamedConstructor = superElement?.unnamedConstructor2;
|
||||
if (superUnnamedConstructor == null) return;
|
||||
|
||||
|
||||
@@ -604,7 +604,7 @@ class _EnumDescription {
|
||||
// class.
|
||||
if (fieldElement.isConst &&
|
||||
fieldType is InterfaceType &&
|
||||
fieldType.element3 == classElement) {
|
||||
fieldType.element == classElement) {
|
||||
var initializer = field.initializer;
|
||||
if (initializer is InstanceCreationExpression) {
|
||||
var constructorElement = initializer.constructorName.element;
|
||||
@@ -778,13 +778,13 @@ class _NonEnumVisitor extends _BaseVisitor {
|
||||
throw _CannotConvertException('Unresolved');
|
||||
}
|
||||
if (element != classElement) {
|
||||
if (element.supertype?.element3 == classElement) {
|
||||
if (element.supertype?.element == classElement) {
|
||||
throw _CannotConvertException('Class is extended');
|
||||
} else if (element.interfaces
|
||||
.map((e) => e.element3)
|
||||
.map((e) => e.element)
|
||||
.contains(classElement)) {
|
||||
throw _CannotConvertException('Class is implemented');
|
||||
} else if (element.mixins.map((e) => e.element3).contains(classElement)) {
|
||||
} else if (element.mixins.map((e) => e.element).contains(classElement)) {
|
||||
// This case won't occur unless there's an error in the source code, but
|
||||
// it's easier to check for the condition than it is to check for the
|
||||
// diagnostic.
|
||||
|
||||
@@ -52,7 +52,7 @@ class ConvertClassToMixin extends ResolvedCorrectionProducer {
|
||||
var classFragment = classDeclaration.declaredFragment!;
|
||||
var classElement = classFragment.element;
|
||||
for (var type in classElement.mixins) {
|
||||
if (referencedClasses.contains(type.element3)) {
|
||||
if (referencedClasses.contains(type.element)) {
|
||||
superclassConstraints.add(type);
|
||||
} else {
|
||||
interfaces.add(type);
|
||||
|
||||
@@ -60,7 +60,7 @@ class ConvertIntoForIndex extends ResolvedCorrectionProducer {
|
||||
{
|
||||
var iterableType = iterable.staticType;
|
||||
if (iterableType is! InterfaceType ||
|
||||
iterableType.element3 != typeProvider.listElement2) {
|
||||
iterableType.element != typeProvider.listElement2) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -45,7 +45,7 @@ class ConvertToMapLiteral extends ResolvedCorrectionProducer {
|
||||
creation.constructorName.name != null ||
|
||||
creation.argumentList.arguments.isNotEmpty ||
|
||||
type is! InterfaceType ||
|
||||
!_isMapClass(type.element3)) {
|
||||
!_isMapClass(type.element)) {
|
||||
return;
|
||||
}
|
||||
//
|
||||
|
||||
@@ -147,7 +147,7 @@ class ConvertToSetLiteral extends ResolvedCorrectionProducer {
|
||||
}
|
||||
|
||||
// TODO(brianwilkerson): Consider also accepting uses of LinkedHashSet.
|
||||
if (type.element3 != typeProvider.setElement2) {
|
||||
if (type.element != typeProvider.setElement2) {
|
||||
return null;
|
||||
}
|
||||
return creation;
|
||||
@@ -199,15 +199,14 @@ class ConvertToSetLiteral extends ResolvedCorrectionProducer {
|
||||
var parent2 = parent.parent;
|
||||
if (parent2 is VariableDeclarationList) {
|
||||
var type = parent2.type?.type;
|
||||
if (type is InterfaceType &&
|
||||
type.element3 == typeProvider.setElement2) {
|
||||
if (type is InterfaceType && type.element == typeProvider.setElement2) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} else if (parent.parent is InvocationExpression) {
|
||||
var parameterElement = creation.correspondingParameter;
|
||||
var type = parameterElement?.type;
|
||||
if (type is InterfaceType && type.element3 == typeProvider.setElement2) {
|
||||
if (type is InterfaceType && type.element == typeProvider.setElement2) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -86,7 +86,7 @@ class CreateConstructor extends ResolvedCorrectionProducer {
|
||||
}
|
||||
|
||||
// prepare target ClassDeclaration
|
||||
var targetElement = targetType.element3;
|
||||
var targetElement = targetType.element;
|
||||
var targetFragment = targetElement.firstFragment;
|
||||
var targetResult = await sessionHelper.getFragmentDeclaration(
|
||||
targetFragment,
|
||||
|
||||
@@ -219,7 +219,7 @@ class CreateExtensionOperator extends _CreateExtensionMember {
|
||||
|
||||
switch (node) {
|
||||
case IndexExpression(:var parent):
|
||||
if (node.target?.staticType?.element3.declaresIndex ?? true) {
|
||||
if (node.target?.staticType?.element.declaresIndex ?? true) {
|
||||
return;
|
||||
}
|
||||
target = node.target;
|
||||
@@ -519,7 +519,7 @@ extension on List<DartType?> {
|
||||
List<TypeParameterElement> get typeParameters =>
|
||||
{
|
||||
for (var type in whereType<TypeParameterType>()) ...[
|
||||
type.element3,
|
||||
type.element,
|
||||
...[type.bound].typeParameters,
|
||||
],
|
||||
for (var type in whereType<InterfaceType>())
|
||||
|
||||
@@ -77,7 +77,7 @@ abstract class CreateFieldOrGetter extends ResolvedCorrectionProducer {
|
||||
|
||||
await addForObjectPattern(
|
||||
builder: builder,
|
||||
targetElement: matchedType.element3,
|
||||
targetElement: matchedType.element,
|
||||
fieldName: effectiveName,
|
||||
fieldType: fieldType,
|
||||
);
|
||||
@@ -154,7 +154,7 @@ class CreateGetter extends CreateFieldOrGetter {
|
||||
if (targetType is! InterfaceType) {
|
||||
return;
|
||||
}
|
||||
targetElement = targetType.element3;
|
||||
targetElement = targetType.element;
|
||||
// maybe static
|
||||
if (target is Identifier) {
|
||||
var targetIdentifier = target;
|
||||
|
||||
@@ -46,7 +46,7 @@ class CreateMethodOrFunction extends ResolvedCorrectionProducer {
|
||||
if (target != null) {
|
||||
var targetType = target.staticType;
|
||||
if (targetType is InterfaceType) {
|
||||
targetElement = targetType.element3;
|
||||
targetElement = targetType.element;
|
||||
argument = target.parent as Expression;
|
||||
} else if (target case SimpleIdentifier(
|
||||
:InterfaceElement? element,
|
||||
|
||||
@@ -61,7 +61,7 @@ class CreateSetter extends ResolvedCorrectionProducer {
|
||||
if (targetType is! InterfaceType) {
|
||||
return;
|
||||
}
|
||||
targetElement = targetType.element3;
|
||||
targetElement = targetType.element;
|
||||
// maybe static
|
||||
if (target is Identifier) {
|
||||
var targetIdentifier = target;
|
||||
|
||||
+1
-1
@@ -88,7 +88,7 @@ class DestructureLocalVariableAssignment extends ResolvedCorrectionProducer {
|
||||
|
||||
await builder.addDartFileEdit(file, (builder) {
|
||||
builder.addReplacement(range.entity(node.name), (builder) {
|
||||
builder.write('${type.element3.name3}(');
|
||||
builder.write('${type.element.name3}(');
|
||||
if (varMap.isEmpty) {
|
||||
builder.selectHere();
|
||||
} else {
|
||||
|
||||
+4
-4
@@ -269,11 +269,11 @@ class FlutterConvertToStatelessWidget extends ResolvedCorrectionProducer {
|
||||
|
||||
var firstArgument = type.typeArguments.singleOrNull;
|
||||
if (firstArgument is! InterfaceType ||
|
||||
firstArgument.element3 != widgetClassElement) {
|
||||
firstArgument.element != widgetClassElement) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var classElement = type.element3;
|
||||
var classElement = type.element;
|
||||
return classElement is ClassElement && classElement.isExactState;
|
||||
}
|
||||
}
|
||||
@@ -412,7 +412,7 @@ class _StateUsageVisitor extends RecursiveAstVisitor<void> {
|
||||
void visitInstanceCreationExpression(InstanceCreationExpression node) {
|
||||
super.visitInstanceCreationExpression(node);
|
||||
var type = node.staticType;
|
||||
if (type is! InterfaceType || type.element3 != stateClassElement) {
|
||||
if (type is! InterfaceType || type.element != stateClassElement) {
|
||||
return;
|
||||
}
|
||||
var methodDeclaration = node.thisOrAncestorOfType<MethodDeclaration>();
|
||||
@@ -431,7 +431,7 @@ class _StateUsageVisitor extends RecursiveAstVisitor<void> {
|
||||
if (type is InterfaceType &&
|
||||
node.methodName.name == 'createState' &&
|
||||
(FlutterConvertToStatelessWidget._isState(widgetClassElement, type) ||
|
||||
type.element3 == stateClassElement)) {
|
||||
type.element == stateClassElement)) {
|
||||
used = true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -441,6 +441,6 @@ extension on Expression {
|
||||
extension on DartType? {
|
||||
bool get isWidgetFlexType {
|
||||
var self = this;
|
||||
return self is InterfaceType && self.element3.isFlexWidget;
|
||||
return self is InterfaceType && self.element.isFlexWidget;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -41,7 +41,7 @@ class MoveTypeArgumentsToClass extends ResolvedCorrectionProducer {
|
||||
|
||||
var type = namedType.typeOrThrow;
|
||||
if (type is InterfaceTypeImpl) {
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
if (element.typeParameters2.length == typeArguments.arguments.length) {
|
||||
await builder.addDartFileEdit(file, (builder) {
|
||||
var argumentText = utils.getNodeText(typeArguments);
|
||||
|
||||
+1
-1
@@ -131,7 +131,7 @@ class _UseDifferentDivisionOperator extends ResolvedCorrectionProducer {
|
||||
|
||||
extension on DartType {
|
||||
Set<_DivisionOperator> get divisionOperators {
|
||||
switch (element3) {
|
||||
switch (element) {
|
||||
case InterfaceElement element:
|
||||
return {
|
||||
for (var method in element.methods)
|
||||
|
||||
+2
-2
@@ -152,11 +152,11 @@ class ElementDescriptor {
|
||||
return true;
|
||||
}
|
||||
if (type is InterfaceType) {
|
||||
if (components[1] == type.element3.name3) {
|
||||
if (components[1] == type.element.name3) {
|
||||
return true;
|
||||
}
|
||||
for (var supertype in type.allSupertypes) {
|
||||
if (components[1] == supertype.element3.name3) {
|
||||
if (components[1] == supertype.element.name3) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
+4
-4
@@ -96,7 +96,7 @@ class ElementMatcher {
|
||||
if (element is! InterfaceElement) {
|
||||
return false;
|
||||
}
|
||||
var types = element.allSupertypes.map((e) => e.element3.name3);
|
||||
var types = element.allSupertypes.map((e) => e.element.name3);
|
||||
for (var t in types) {
|
||||
if (elementComponents.contains(t)) {
|
||||
return true;
|
||||
@@ -445,7 +445,7 @@ class _MatcherBuilder {
|
||||
var targetType = node.prefix.staticType;
|
||||
if (targetType is InterfaceType) {
|
||||
_addMatcher(
|
||||
components: [node.identifier.name, targetType.element3.name3!],
|
||||
components: [node.identifier.name, targetType.element.name3!],
|
||||
kinds: const [
|
||||
ElementKind.constantKind,
|
||||
ElementKind.fieldKind,
|
||||
@@ -610,7 +610,7 @@ class _MatcherBuilder {
|
||||
var type = target.staticType;
|
||||
if (type != null) {
|
||||
if (type is InterfaceType) {
|
||||
return type.element3.name3;
|
||||
return type.element.name3;
|
||||
} else if (type is DynamicType) {
|
||||
// The name is likely to be undefined.
|
||||
return target.name;
|
||||
@@ -621,7 +621,7 @@ class _MatcherBuilder {
|
||||
} else if (target != null) {
|
||||
var type = target.staticType;
|
||||
if (type is InterfaceType) {
|
||||
return type.element3.name3;
|
||||
return type.element.name3;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -72,7 +72,7 @@ List<String> getVariableNameSuggestionsForExpression(
|
||||
} else if (expectedType.isDartCoreString) {
|
||||
_addSingleCharacterName(excluded, res, 0x73);
|
||||
} else if (expectedType is InterfaceType) {
|
||||
var className = expectedType.element3.name3;
|
||||
var className = expectedType.element.name3;
|
||||
if (className != null) {
|
||||
_addAll(excluded, res, getCamelWordCombinations(className));
|
||||
}
|
||||
|
||||
@@ -53,7 +53,7 @@ class ClassDescriptionRegistry {
|
||||
/// Return `true` if properties should be created for instances of [type].
|
||||
bool hasNestedProperties(DartType type) {
|
||||
if (type is InterfaceType) {
|
||||
return _isOptedInClass(type.element3);
|
||||
return _isOptedInClass(type.element);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -388,7 +388,7 @@ class _WidgetDescriptionComputer {
|
||||
} else if (valueExpression == null) {
|
||||
var type = parameter.type;
|
||||
if (type is InterfaceType) {
|
||||
var classDescription = classRegistry.get(type.element3);
|
||||
var classDescription = classRegistry.get(type.element);
|
||||
if (classDescription != null) {
|
||||
_addProperties(
|
||||
properties: propertyDescription.children,
|
||||
@@ -450,7 +450,7 @@ class _WidgetDescriptionComputer {
|
||||
);
|
||||
}
|
||||
if (type is InterfaceType) {
|
||||
var classElement = type.element3;
|
||||
var classElement = type.element;
|
||||
if (classElement is EnumElement) {
|
||||
return protocol.FlutterWidgetPropertyEditor(
|
||||
protocol.FlutterWidgetPropertyEditorKind.ENUM,
|
||||
|
||||
@@ -1034,7 +1034,7 @@ final class ExtractMethodRefactoringImpl extends RefactoringImpl
|
||||
_variableType = _getTypeCode(returnTypeObj);
|
||||
if (_hasAwait) {
|
||||
if (returnTypeObj is InterfaceType &&
|
||||
returnTypeObj.element3 != typeProvider.futureElement2) {
|
||||
returnTypeObj.element != typeProvider.futureElement2) {
|
||||
returnType = _getTypeCode(typeProvider.futureType(returnTypeObj));
|
||||
}
|
||||
} else {
|
||||
@@ -1822,7 +1822,7 @@ extension on LibraryElement {
|
||||
if (type is InterfaceType) {
|
||||
return _getTypeCodeElementArguments(
|
||||
librariesToImport: librariesToImport,
|
||||
element: type.element3,
|
||||
element: type.element,
|
||||
isNullable: type.nullabilitySuffix == NullabilitySuffix.question,
|
||||
typeArguments: type.typeArguments,
|
||||
);
|
||||
|
||||
@@ -672,7 +672,7 @@ class _ParametersCollector extends RecursiveAstVisitor<void> {
|
||||
var enclosingClasses =
|
||||
this.enclosingClasses ??= <InterfaceElement>[
|
||||
enclosingClass,
|
||||
...enclosingClass.allSupertypes.map((t) => t.element3),
|
||||
...enclosingClass.allSupertypes.map((t) => t.element),
|
||||
];
|
||||
return enclosingClasses.contains(element.enclosingElement);
|
||||
}
|
||||
|
||||
@@ -192,7 +192,7 @@ Set<String> _getNamesConflictingAt(AstNode node) {
|
||||
var enclosingInterfaceElement = node.enclosingInterfaceElement;
|
||||
if (enclosingInterfaceElement != null) {
|
||||
var elements = [
|
||||
...enclosingInterfaceElement.allSupertypes.map((type) => type.element3),
|
||||
...enclosingInterfaceElement.allSupertypes.map((type) => type.element),
|
||||
enclosingInterfaceElement,
|
||||
];
|
||||
for (var interfaceElement in elements) {
|
||||
|
||||
@@ -253,7 +253,7 @@ class _BaseClassMemberValidator {
|
||||
required Set<InterfaceElement> subClasses,
|
||||
}) async {
|
||||
var superClasses =
|
||||
interfaceElement.allSupertypes.map((e) => e.element3).toSet();
|
||||
interfaceElement.allSupertypes.map((e) => e.element).toSet();
|
||||
// check shadowing in the hierarchy
|
||||
var declarations = await searchEngine.searchMemberDeclarations(name);
|
||||
for (var declaration in declarations) {
|
||||
|
||||
@@ -132,7 +132,7 @@ getHierarchyMembersAndParameters(
|
||||
|
||||
var superElementsToSearch =
|
||||
enclosingElement.allSupertypes
|
||||
.map((superType) => superType.element3)
|
||||
.map((superType) => superType.element)
|
||||
.where((interface) {
|
||||
return member2.isPublic || interface.library2 == member2.library2;
|
||||
})
|
||||
@@ -253,7 +253,7 @@ Future<List<FormalParameterElement>> getHierarchyPositionalParameters(
|
||||
///
|
||||
/// Excludes: constructors and synthetic elements.
|
||||
List<Element> getMembers(InterfaceElement clazz) {
|
||||
var classElements = [...clazz.allSupertypes.map((e) => e.element3), clazz];
|
||||
var classElements = [...clazz.allSupertypes.map((e) => e.element), clazz];
|
||||
var members = <Element>[];
|
||||
for (var superClass in classElements) {
|
||||
members.addAll(getClassMembers(superClass));
|
||||
|
||||
@@ -75,7 +75,7 @@ class SelectionCoverageTest {
|
||||
var implementsClause = declaration.implementsClause;
|
||||
if (implementsClause != null) {
|
||||
for (var type in implementsClause.interfaces) {
|
||||
var element = type.type?.element3;
|
||||
var element = type.type?.element;
|
||||
if (element is ClassElement && element.name3 == interfaceName) {
|
||||
data.instantiableInterfaces.add(element);
|
||||
}
|
||||
@@ -97,7 +97,7 @@ class SelectionCoverageTest {
|
||||
var implementsClause = declaration.implementsClause;
|
||||
if (implementsClause != null) {
|
||||
for (var supertype in implementsClause.interfaces) {
|
||||
var supertypeElement = supertype.type?.element3;
|
||||
var supertypeElement = supertype.type?.element;
|
||||
if (supertypeElement is ClassElement) {
|
||||
data.supertypes
|
||||
.putIfAbsent(subtypeElement, () => [])
|
||||
@@ -143,7 +143,7 @@ class SelectionCoverageTest {
|
||||
.declaredFragment
|
||||
?.element
|
||||
.type
|
||||
.element3;
|
||||
.element;
|
||||
if (visitedClass is ClassElement) {
|
||||
var visitor = VisitMethodVisitor();
|
||||
member.body.accept(visitor);
|
||||
|
||||
@@ -35,7 +35,7 @@ class BulkFixDetails {
|
||||
var classElement = classDecl.declaredFragment?.element;
|
||||
if (classElement != null &&
|
||||
classElement.allSupertypes.any(
|
||||
(element) => element.element3.name3 == 'CorrectionProducer',
|
||||
(element) => element.element.name3 == 'CorrectionProducer',
|
||||
)) {
|
||||
var correctionName = classDecl.name.lexeme;
|
||||
|
||||
|
||||
@@ -1801,7 +1801,7 @@ class RelevanceDataCollector extends RecursiveAstVisitor<void> {
|
||||
return;
|
||||
}
|
||||
if (targetType is InterfaceType) {
|
||||
var targetClass = targetType.element3;
|
||||
var targetClass = targetType.element;
|
||||
var extension = member.thisOrAncestorOfType2<ExtensionElement>();
|
||||
if (extension != null) {
|
||||
_recordDistance('member (extension)', 0);
|
||||
@@ -1823,12 +1823,12 @@ class RelevanceDataCollector extends RecursiveAstVisitor<void> {
|
||||
}
|
||||
for (var mixin in currentClass.mixins.reversed) {
|
||||
depth++;
|
||||
if (mixin.element3 == memberClass) {
|
||||
if (mixin.element == memberClass) {
|
||||
return depth;
|
||||
}
|
||||
}
|
||||
depth++;
|
||||
currentClass = currentClass.supertype?.element3;
|
||||
currentClass = currentClass.supertype?.element;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -1840,7 +1840,7 @@ class RelevanceDataCollector extends RecursiveAstVisitor<void> {
|
||||
InterfaceElement? currentClass = targetClass;
|
||||
while (currentClass != null) {
|
||||
depth += currentClass.mixins.length + 1;
|
||||
currentClass = currentClass.supertype?.element3;
|
||||
currentClass = currentClass.supertype?.element;
|
||||
}
|
||||
return depth;
|
||||
}
|
||||
@@ -2072,16 +2072,16 @@ class RelevanceDataCollector extends RecursiveAstVisitor<void> {
|
||||
argumentType is InterfaceType &&
|
||||
parameterType is InterfaceType) {
|
||||
int distance;
|
||||
if (parameterType.element3 == typeProvider.futureOrElement2) {
|
||||
if (parameterType.element == typeProvider.futureOrElement2) {
|
||||
var typeArgument = parameterType.typeArguments[0];
|
||||
distance = featureComputer.inheritanceDistance(
|
||||
argumentType.element3,
|
||||
argumentType.element,
|
||||
typeProvider.futureElement2,
|
||||
);
|
||||
if (typeArgument is InterfaceType) {
|
||||
var argDistance = featureComputer.inheritanceDistance(
|
||||
argumentType.element3,
|
||||
typeArgument.element3,
|
||||
argumentType.element,
|
||||
typeArgument.element,
|
||||
);
|
||||
if (distance < 0 || (argDistance >= 0 && argDistance < distance)) {
|
||||
distance = argDistance;
|
||||
@@ -2089,8 +2089,8 @@ class RelevanceDataCollector extends RecursiveAstVisitor<void> {
|
||||
}
|
||||
} else {
|
||||
distance = featureComputer.inheritanceDistance(
|
||||
argumentType.element3,
|
||||
parameterType.element3,
|
||||
argumentType.element,
|
||||
parameterType.element,
|
||||
);
|
||||
}
|
||||
data.recordDistance('Subtype of context type ($descriptor)', distance);
|
||||
|
||||
@@ -482,7 +482,7 @@ abstract class ResolvedCorrectionProducer
|
||||
InterfaceElement? getTargetInterfaceElement(Expression target) {
|
||||
var type = target.staticType;
|
||||
if (type is InterfaceType) {
|
||||
return type.element3;
|
||||
return type.element;
|
||||
} else if (target is Identifier) {
|
||||
var element = target.element;
|
||||
if (element is InterfaceElement) {
|
||||
|
||||
@@ -61,6 +61,8 @@
|
||||
* Deprecate `InterfaceType.lookUpSetter3`, use `lookUpSetter` instead.
|
||||
* Remove `PropertyAccessorFragmentImplImplicitGetter`, `PropertyAccessorFragmentImplImplicitSetter`,
|
||||
and `FormalParameterFragmentImplOfImplicitSetter`, replace with `GetterFragmentImpl`, and `SetterFragmentImpl`.
|
||||
* Deprecate `ExtensionTypeFragment.representation2`, use `representation` instead.
|
||||
* Deprecate `DartType.element3`, use `element` instead.
|
||||
|
||||
## 7.4.1
|
||||
* Restore `InstanceElement.augmented` getter.
|
||||
|
||||
+12
-6
@@ -4337,7 +4337,8 @@ package:analyzer/dart/element/type.dart:
|
||||
DartType (class extends Object):
|
||||
new (constructor: DartType Function())
|
||||
alias (getter: InstantiatedTypeAliasElement?)
|
||||
element3 (getter: Element?, experimental)
|
||||
element (getter: Element?, experimental)
|
||||
element3 (getter: Element?, deprecated, experimental)
|
||||
extensionTypeErasure (getter: DartType)
|
||||
isBottom (getter: bool)
|
||||
isDartAsyncFuture (getter: bool)
|
||||
@@ -4369,7 +4370,8 @@ package:analyzer/dart/element/type.dart:
|
||||
new (constructor: DynamicType Function())
|
||||
FunctionType (class extends Object implements DartType):
|
||||
new (constructor: FunctionType Function())
|
||||
element3 (getter: Null)
|
||||
element (getter: Null)
|
||||
element3 (getter: Null, deprecated)
|
||||
formalParameters (getter: List<FormalParameterElement>, experimental)
|
||||
namedParameterTypes (getter: Map<String, DartType>)
|
||||
normalParameterTypes (getter: List<DartType>)
|
||||
@@ -4385,7 +4387,8 @@ package:analyzer/dart/element/type.dart:
|
||||
new (constructor: InterfaceType Function())
|
||||
allSupertypes (getter: List<InterfaceType>)
|
||||
constructors2 (getter: List<ConstructorElement>, experimental)
|
||||
element3 (getter: InterfaceElement, experimental)
|
||||
element (getter: InterfaceElement, experimental)
|
||||
element3 (getter: InterfaceElement, deprecated, experimental)
|
||||
getters (getter: List<GetterElement>, experimental)
|
||||
interfaces (getter: List<InterfaceType>)
|
||||
methods2 (getter: List<MethodElement>, experimental)
|
||||
@@ -4416,7 +4419,8 @@ package:analyzer/dart/element/type.dart:
|
||||
typeArguments (getter: List<DartType>)
|
||||
RecordType (class extends Object implements DartType):
|
||||
new (constructor: RecordType Function({required Map<String, DartType> named, required NullabilitySuffix nullabilitySuffix, required List<DartType> positional}))
|
||||
element3 (getter: Null)
|
||||
element (getter: Null)
|
||||
element3 (getter: Null, deprecated)
|
||||
namedFields (getter: List<RecordTypeNamedField>)
|
||||
positionalFields (getter: List<RecordTypePositionalField>)
|
||||
RecordTypeField (class extends Object):
|
||||
@@ -4430,10 +4434,12 @@ package:analyzer/dart/element/type.dart:
|
||||
TypeParameterType (class extends Object implements DartType):
|
||||
new (constructor: TypeParameterType Function())
|
||||
bound (getter: DartType)
|
||||
element3 (getter: TypeParameterElement, experimental)
|
||||
element (getter: TypeParameterElement, experimental)
|
||||
element3 (getter: TypeParameterElement, deprecated, experimental)
|
||||
VoidType (class extends Object implements DartType):
|
||||
new (constructor: VoidType Function())
|
||||
element3 (getter: Null)
|
||||
element (getter: Null)
|
||||
element3 (getter: Null, deprecated)
|
||||
package:analyzer/dart/element/type_provider.dart:
|
||||
TypeProvider (class extends Object):
|
||||
new (constructor: TypeProvider Function())
|
||||
|
||||
@@ -39,6 +39,12 @@ abstract class DartType {
|
||||
/// Return the element representing the declaration of this type, or `null`
|
||||
/// if the type is not associated with an element.
|
||||
@experimental
|
||||
Element? get element;
|
||||
|
||||
/// Return the element representing the declaration of this type, or `null`
|
||||
/// if the type is not associated with an element.
|
||||
@Deprecated('Use element instead')
|
||||
@experimental
|
||||
Element? get element3;
|
||||
|
||||
/// The extension type erasure of this type.
|
||||
@@ -202,6 +208,10 @@ abstract class DynamicType implements DartType {}
|
||||
///
|
||||
/// Clients may not extend, implement or mix-in this class.
|
||||
abstract class FunctionType implements DartType {
|
||||
@override
|
||||
Null get element;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3;
|
||||
|
||||
@@ -271,6 +281,11 @@ abstract class InterfaceType implements ParameterizedType {
|
||||
@experimental
|
||||
List<ConstructorElement> get constructors2;
|
||||
|
||||
@experimental
|
||||
@override
|
||||
InterfaceElement get element;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@experimental
|
||||
@override
|
||||
InterfaceElement get element3;
|
||||
@@ -525,6 +540,10 @@ abstract class RecordType implements DartType {
|
||||
required NullabilitySuffix nullabilitySuffix,
|
||||
}) = RecordTypeImpl.fromApi;
|
||||
|
||||
@override
|
||||
Null get element;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3;
|
||||
|
||||
@@ -564,6 +583,11 @@ abstract class TypeParameterType implements DartType {
|
||||
/// or `dynamic` if there was no explicit bound.
|
||||
DartType get bound;
|
||||
|
||||
@experimental
|
||||
@override
|
||||
TypeParameterElement get element;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@experimental
|
||||
@override
|
||||
TypeParameterElement get element3;
|
||||
@@ -572,6 +596,10 @@ abstract class TypeParameterType implements DartType {
|
||||
/// The special type `void` is used to indicate that the value of an
|
||||
/// expression is meaningless, and intended to be discarded.
|
||||
abstract class VoidType implements DartType {
|
||||
@override
|
||||
Null get element;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3;
|
||||
}
|
||||
|
||||
@@ -719,7 +719,7 @@ class _IndexContributor extends GeneralizingAstVisitor {
|
||||
_addSubtypeForClassDeclaration(node);
|
||||
var declaredElement = node.declaredFragment!.element;
|
||||
if (node.extendsClause == null) {
|
||||
var objectElement = declaredElement.supertype?.element3;
|
||||
var objectElement = declaredElement.supertype?.element;
|
||||
recordRelationOffset(
|
||||
objectElement,
|
||||
IndexRelationKind.IS_EXTENDED_BY,
|
||||
@@ -1468,7 +1468,7 @@ class _IndexContributor extends GeneralizingAstVisitor {
|
||||
if (superType != null) {
|
||||
_recordIsAncestorOf(
|
||||
descendant,
|
||||
superType.element3,
|
||||
superType.element,
|
||||
true,
|
||||
visitedElements,
|
||||
);
|
||||
@@ -1477,20 +1477,20 @@ class _IndexContributor extends GeneralizingAstVisitor {
|
||||
for (InterfaceType mixinType in ancestor.mixins) {
|
||||
_recordIsAncestorOf(
|
||||
descendant,
|
||||
mixinType.element3,
|
||||
mixinType.element,
|
||||
true,
|
||||
visitedElements,
|
||||
);
|
||||
}
|
||||
if (ancestor is MixinElement) {
|
||||
for (InterfaceType type in ancestor.superclassConstraints) {
|
||||
_recordIsAncestorOf(descendant, type.element3, true, visitedElements);
|
||||
_recordIsAncestorOf(descendant, type.element, true, visitedElements);
|
||||
}
|
||||
}
|
||||
for (InterfaceType implementedType in ancestor.interfaces) {
|
||||
_recordIsAncestorOf(
|
||||
descendant,
|
||||
implementedType.element3,
|
||||
implementedType.element,
|
||||
true,
|
||||
visitedElements,
|
||||
);
|
||||
|
||||
@@ -554,7 +554,7 @@ class ConstantVerifier extends RecursiveAstVisitor<void> {
|
||||
).eliminateToGreatest(valueType);
|
||||
return _typeSystem.isSubtypeOf(constantType, valueTypeGreatest);
|
||||
} else if (valueType is TypeParameterTypeImpl) {
|
||||
var bound = valueType.promotedBound ?? valueType.element3.bound;
|
||||
var bound = valueType.promotedBound ?? valueType.element.bound;
|
||||
if (bound != null && !hasTypeParameterReference(bound)) {
|
||||
var lowestBound =
|
||||
valueType.nullabilitySuffix == NullabilitySuffix.question
|
||||
|
||||
@@ -301,7 +301,7 @@ class ConstantEvaluationEngine {
|
||||
var superclass = constant.returnType.superclass;
|
||||
if (superclass != null && !superclass.isDartCoreObject) {
|
||||
var unnamedConstructor =
|
||||
superclass.element3.unnamedConstructor2?.baseElement;
|
||||
superclass.element.unnamedConstructor2?.baseElement;
|
||||
if (unnamedConstructor != null && unnamedConstructor.isConst) {
|
||||
callback(unnamedConstructor.asElement);
|
||||
}
|
||||
@@ -955,7 +955,7 @@ class ConstantVisitor extends UnifyingAstVisitor<Constant> {
|
||||
if (typeArgumentTypes != null) {
|
||||
var instantiatedTypeArgumentTypes = typeArgumentTypes.map((type) {
|
||||
if (type is TypeParameterType) {
|
||||
return _lexicalTypeEnvironment?[type.element3] ?? type;
|
||||
return _lexicalTypeEnvironment?[type.element] ?? type;
|
||||
} else {
|
||||
return type;
|
||||
}
|
||||
@@ -2989,7 +2989,7 @@ class _InstanceCreationEvaluator {
|
||||
}
|
||||
|
||||
var definingType = this.definingType;
|
||||
if (definingType.element3 case ExtensionTypeElement element) {
|
||||
if (definingType.element case ExtensionTypeElement element) {
|
||||
var representation = _fieldMap[element.representation.name3];
|
||||
if (representation != null) {
|
||||
return representation;
|
||||
|
||||
@@ -1580,7 +1580,7 @@ class GenericState extends InstanceState {
|
||||
return enclosing is ClassElement && enclosing.isDartCoreObject;
|
||||
}
|
||||
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
var library = element.library2;
|
||||
|
||||
var eqEq = type.lookUpMethod('==', library, concrete: true);
|
||||
|
||||
@@ -59,7 +59,7 @@ class ClassHierarchy {
|
||||
interfacesMerger.add(type);
|
||||
|
||||
var substitution = Substitution.fromInterfaceType(type);
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
var rawInterfaces = implementedInterfaces(element);
|
||||
for (var rawInterface in rawInterfaces) {
|
||||
var newInterface = substitution.mapInterfaceType(rawInterface);
|
||||
@@ -127,7 +127,7 @@ class InterfacesMerger {
|
||||
}
|
||||
|
||||
void add(InterfaceTypeImpl type) {
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
var classResult = _map[element];
|
||||
if (classResult == null) {
|
||||
classResult = _ClassInterfaceType(
|
||||
|
||||
@@ -213,7 +213,7 @@ class ElementDisplayStringBuilder {
|
||||
return;
|
||||
}
|
||||
|
||||
_write(type.element3.name3 ?? '<null>');
|
||||
_write(type.element.name3 ?? '<null>');
|
||||
_writeTypeArguments(type.typeArguments);
|
||||
_writeNullability(type.nullabilitySuffix);
|
||||
}
|
||||
@@ -376,14 +376,14 @@ class ElementDisplayStringBuilder {
|
||||
if (hasSuffix) {
|
||||
_write('(');
|
||||
}
|
||||
_write(type.element3.displayName);
|
||||
_write(type.element.displayName);
|
||||
_write(' & ');
|
||||
_writeType(promotedBound);
|
||||
if (hasSuffix) {
|
||||
_write(')');
|
||||
}
|
||||
} else {
|
||||
_write(type.element3.displayName);
|
||||
_write(type.element.displayName);
|
||||
}
|
||||
_writeNullability(type.nullabilitySuffix);
|
||||
}
|
||||
@@ -600,7 +600,7 @@ class ElementDisplayStringBuilder {
|
||||
|
||||
void collectTypeParameters(DartType? type) {
|
||||
if (type is TypeParameterType) {
|
||||
referencedTypeParameters.add(type.element3);
|
||||
referencedTypeParameters.add(type.element);
|
||||
} else if (type is FunctionType) {
|
||||
for (var typeParameter in type.typeParameters) {
|
||||
collectTypeParameters(typeParameter.bound);
|
||||
|
||||
@@ -263,12 +263,12 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
|
||||
}
|
||||
// check mixins
|
||||
for (var mixinType in currentElement.mixins) {
|
||||
classesToVisit.add(mixinType.element3);
|
||||
classesToVisit.add(mixinType.element);
|
||||
}
|
||||
// check super
|
||||
var supertype = currentElement.supertype;
|
||||
if (supertype != null) {
|
||||
classesToVisit.add(supertype.element3);
|
||||
classesToVisit.add(supertype.element);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -330,7 +330,7 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
|
||||
|
||||
// No subclasses in the library.
|
||||
for (var class_ in library2.classes) {
|
||||
if (class_.supertype?.element3 == this) {
|
||||
if (class_.supertype?.element == this) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -575,7 +575,7 @@ class ClassFragmentImpl extends ClassOrMixinFragmentImpl
|
||||
// Assign to break a possible infinite recursion during computing.
|
||||
_constructors = const <ConstructorFragmentImpl>[];
|
||||
|
||||
var superElement2 = superType.element3 as ClassElementImpl;
|
||||
var superElement2 = superType.element as ClassElementImpl;
|
||||
var superElement = superElement2.firstFragment;
|
||||
|
||||
var constructorsToForward = superElement.constructors
|
||||
@@ -604,7 +604,7 @@ class ClassFragmentImpl extends ClassOrMixinFragmentImpl
|
||||
);
|
||||
|
||||
bool typeHasInstanceVariables(InterfaceTypeImpl type) =>
|
||||
type.element3.fields.any((e) => !e.isSynthetic);
|
||||
type.element.fields.any((e) => !e.isSynthetic);
|
||||
|
||||
// Now create an implicit constructor for every constructor found above,
|
||||
// substituting type parameters as appropriate.
|
||||
@@ -4894,14 +4894,14 @@ recorded above.
|
||||
}
|
||||
for (var mixin in element.mixins.reversed) {
|
||||
mixin as InterfaceTypeImpl;
|
||||
getter = mixin.element3.getGetter(name);
|
||||
getter = mixin.element.getGetter(name);
|
||||
if (getter != null) {
|
||||
yield getter as PropertyAccessorElement2OrMember;
|
||||
}
|
||||
}
|
||||
var supertype = element.firstFragment.supertype;
|
||||
supertype as InterfaceTypeImpl?;
|
||||
element = supertype?.element3;
|
||||
element = supertype?.element;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4920,14 +4920,14 @@ recorded above.
|
||||
}
|
||||
for (var mixin in element.mixins.reversed) {
|
||||
mixin as InterfaceTypeImpl;
|
||||
method = mixin.element3.getMethod(name);
|
||||
method = mixin.element.getMethod(name);
|
||||
if (method != null) {
|
||||
yield method as MethodElement2OrMember;
|
||||
}
|
||||
}
|
||||
var supertype = element.firstFragment.supertype;
|
||||
supertype as InterfaceTypeImpl?;
|
||||
element = supertype?.element3;
|
||||
element = supertype?.element;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4946,14 +4946,14 @@ recorded above.
|
||||
}
|
||||
for (var mixin in element.mixins.reversed) {
|
||||
mixin as InterfaceTypeImpl;
|
||||
setter = mixin.element3.getSetter(name);
|
||||
setter = mixin.element.getSetter(name);
|
||||
if (setter != null) {
|
||||
yield setter as PropertyAccessorElement2OrMember;
|
||||
}
|
||||
}
|
||||
var supertype = element.firstFragment.supertype;
|
||||
supertype as InterfaceTypeImpl?;
|
||||
element = supertype?.element3;
|
||||
element = supertype?.element;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9734,7 +9734,7 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
|
||||
return false;
|
||||
}
|
||||
var typeParameters = typeParameters2;
|
||||
var aliasedClass = aliasedType_.element3;
|
||||
var aliasedClass = aliasedType_.element;
|
||||
var typeArguments = aliasedType_.typeArguments;
|
||||
var typeParameterCount = typeParameters.length;
|
||||
if (typeParameterCount != aliasedClass.typeParameters2.length) {
|
||||
@@ -9751,7 +9751,7 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
|
||||
}
|
||||
var typeArgument = typeArguments[i];
|
||||
if (typeArgument is TypeParameterType &&
|
||||
typeParameters[i] != typeArgument.element3) {
|
||||
typeParameters[i] != typeArgument.element) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -9833,7 +9833,7 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
|
||||
);
|
||||
} else if (type is InterfaceTypeImpl) {
|
||||
return InterfaceTypeImpl(
|
||||
element: type.element3,
|
||||
element: type.element,
|
||||
typeArguments: type.typeArguments,
|
||||
nullabilitySuffix: resultNullability,
|
||||
alias: InstantiatedTypeAliasElementImpl(
|
||||
@@ -9853,7 +9853,7 @@ class TypeAliasElementImpl extends TypeDefiningElementImpl
|
||||
);
|
||||
} else if (type is TypeParameterTypeImpl) {
|
||||
return TypeParameterTypeImpl(
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
nullabilitySuffix: resultNullability,
|
||||
alias: InstantiatedTypeAliasElementImpl(
|
||||
element2: this,
|
||||
@@ -10081,7 +10081,7 @@ class TypeParameterElementImpl extends TypeDefiningElementImpl
|
||||
required NullabilitySuffix nullabilitySuffix,
|
||||
}) {
|
||||
return TypeParameterTypeImpl(
|
||||
element3: this,
|
||||
element: this,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
);
|
||||
}
|
||||
@@ -10233,7 +10233,7 @@ class TypeParameterFragmentImpl extends FragmentImpl
|
||||
/// Computes the variance of the type parameters in the [type].
|
||||
shared.Variance computeVarianceInType(DartType type) {
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
if (type.element3 == element) {
|
||||
if (type.element == element) {
|
||||
return shared.Variance.covariant;
|
||||
} else {
|
||||
return shared.Variance.unrelated;
|
||||
@@ -10242,7 +10242,7 @@ class TypeParameterFragmentImpl extends FragmentImpl
|
||||
var result = shared.Variance.unrelated;
|
||||
for (int i = 0; i < type.typeArguments.length; ++i) {
|
||||
var argument = type.typeArguments[i];
|
||||
var parameter = type.element3.typeParameters2[i];
|
||||
var parameter = type.element.typeParameters2[i];
|
||||
|
||||
var parameterVariance = parameter.variance;
|
||||
result = result.meet(
|
||||
|
||||
@@ -13,7 +13,7 @@ import 'package:meta/meta_meta.dart';
|
||||
|
||||
extension DartTypeExtension on DartType {
|
||||
bool get isExtensionType {
|
||||
return element3 is ExtensionTypeElement;
|
||||
return element is ExtensionTypeElement;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -110,7 +110,7 @@ extension ElementAnnotationExtensions on ElementAnnotation {
|
||||
if (element is GetterElement) {
|
||||
var type = element.returnType;
|
||||
if (type is InterfaceType) {
|
||||
interfaceElement = type.element3;
|
||||
interfaceElement = type.element;
|
||||
}
|
||||
} else if (element is ConstructorElement) {
|
||||
interfaceElement = element.enclosingElement;
|
||||
|
||||
@@ -795,7 +795,7 @@ class GenericInferrer {
|
||||
}
|
||||
if (errorEntity is ConstructorName &&
|
||||
!(errorEntity.type.type as InterfaceType)
|
||||
.element3
|
||||
.element
|
||||
.metadata
|
||||
.hasOptionalTypeArgs) {
|
||||
String constructorName =
|
||||
@@ -829,7 +829,7 @@ class GenericInferrer {
|
||||
if (element is VariableElement) {
|
||||
// For variable elements, we check their type and possible alias type.
|
||||
var type = element.type;
|
||||
var typeElement = type is InterfaceType ? type.element3 : null;
|
||||
var typeElement = type is InterfaceType ? type.element : null;
|
||||
if (typeElement != null && typeElement.metadata.hasOptionalTypeArgs) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -248,7 +248,7 @@ class InheritanceManager3 {
|
||||
}) {
|
||||
type as InterfaceTypeImpl; // TODO(scheglov): remove cast
|
||||
var rawElement = getMember(
|
||||
type.element3,
|
||||
type.element,
|
||||
name,
|
||||
concrete: concrete,
|
||||
forMixinIndex: forMixinIndex,
|
||||
@@ -501,7 +501,7 @@ class InheritanceManager3 {
|
||||
if (superType != null) {
|
||||
superType as InterfaceTypeImpl;
|
||||
var substitution = Substitution.fromInterfaceType(superType);
|
||||
superTypeInterface = getInterface(superType.element3);
|
||||
superTypeInterface = getInterface(superType.element);
|
||||
_addCandidates(
|
||||
namedCandidates: namedCandidates,
|
||||
substitution: substitution,
|
||||
@@ -523,7 +523,7 @@ class InheritanceManager3 {
|
||||
// interfaces. Consider using `Map<Name, ExecutableElement>` here.
|
||||
var mixinsConflicts = <List<Conflict>>[];
|
||||
for (var mixin in element.mixins) {
|
||||
var mixinElement = mixin.element3;
|
||||
var mixinElement = mixin.element;
|
||||
var substitution = Substitution.fromInterfaceType(mixin);
|
||||
var mixinInterface = getInterface(mixinElement);
|
||||
// `class X extends S with M1, M2 {}` is semantically a sequence of:
|
||||
@@ -598,7 +598,7 @@ class InheritanceManager3 {
|
||||
_addCandidates(
|
||||
namedCandidates: namedCandidates,
|
||||
substitution: Substitution.fromInterfaceType(interface),
|
||||
interface: getInterface(interface.element3),
|
||||
interface: getInterface(interface.element),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -707,7 +707,7 @@ class InheritanceManager3 {
|
||||
var notExtensionCandidates = <Name, _ExtensionTypeCandidates>{};
|
||||
for (var interface in element.interfaces) {
|
||||
var substitution = Substitution.fromInterfaceType(interface);
|
||||
for (var entry in getInterface(interface.element3).map.entries) {
|
||||
for (var entry in getInterface(interface.element).map.entries) {
|
||||
var name = entry.key;
|
||||
var executable = ExecutableMember.from(entry.value, substitution);
|
||||
if (executable.isExtensionTypeMember) {
|
||||
@@ -857,7 +857,7 @@ class InheritanceManager3 {
|
||||
var superCandidates = <Name, List<ExecutableElement2OrMember>>{};
|
||||
for (var constraint in element.superclassConstraints) {
|
||||
var substitution = Substitution.fromInterfaceType(constraint);
|
||||
var interfaceObj = getInterface(constraint.element3);
|
||||
var interfaceObj = getInterface(constraint.element);
|
||||
_addCandidates(
|
||||
namedCandidates: superCandidates,
|
||||
substitution: substitution,
|
||||
@@ -879,7 +879,7 @@ class InheritanceManager3 {
|
||||
_addCandidates(
|
||||
namedCandidates: interfaceCandidates,
|
||||
substitution: Substitution.fromInterfaceType(interface),
|
||||
interface: getInterface(interface.element3),
|
||||
interface: getInterface(interface.element),
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -82,7 +82,7 @@ class LeastGreatestClosureHelper extends ReplacementVisitor {
|
||||
|
||||
@override
|
||||
TypeImpl? visitTypeParameterType(TypeParameterType type) {
|
||||
if (eliminationTargets.contains(type.element3)) {
|
||||
if (eliminationTargets.contains(type.element)) {
|
||||
var replacement = _typeParameterReplacement;
|
||||
return replacement.withNullability(
|
||||
uniteNullabilities(
|
||||
|
||||
@@ -60,10 +60,10 @@ class InterfaceLeastUpperBoundHelper {
|
||||
return type1.withNullability(nullability);
|
||||
}
|
||||
|
||||
if (type1.element3 == type2.element3) {
|
||||
if (type1.element == type2.element) {
|
||||
var args1 = type1.typeArguments;
|
||||
var args2 = type2.typeArguments;
|
||||
var params = type1.element3.typeParameters2;
|
||||
var params = type1.element.typeParameters2;
|
||||
assert(args1.length == args2.length);
|
||||
assert(args1.length == params.length);
|
||||
|
||||
@@ -95,7 +95,7 @@ class InterfaceLeastUpperBoundHelper {
|
||||
}
|
||||
|
||||
return InterfaceTypeImpl(
|
||||
element: type1.element3,
|
||||
element: type1.element,
|
||||
typeArguments: args,
|
||||
nullabilitySuffix: nullability,
|
||||
);
|
||||
@@ -125,7 +125,7 @@ class InterfaceLeastUpperBoundHelper {
|
||||
return;
|
||||
}
|
||||
|
||||
if (type.element3 is ExtensionTypeElement) {
|
||||
if (type.element is ExtensionTypeElement) {
|
||||
set.add(typeSystem.objectQuestion);
|
||||
}
|
||||
|
||||
@@ -206,7 +206,7 @@ class InterfaceLeastUpperBoundHelper {
|
||||
InterfaceType type,
|
||||
Set<InterfaceElement> visitedElements,
|
||||
) {
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
// recursion
|
||||
if (visitedElements.contains(element)) {
|
||||
return 0;
|
||||
@@ -330,7 +330,7 @@ class LeastUpperBoundHelper {
|
||||
LeastUpperBoundHelper(this._typeSystem);
|
||||
|
||||
InterfaceTypeImpl get _interfaceTypeFunctionNone {
|
||||
return _typeSystem.typeProvider.functionType.element3.instantiateImpl(
|
||||
return _typeSystem.typeProvider.functionType.element.instantiateImpl(
|
||||
typeArguments: const [],
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
);
|
||||
@@ -415,7 +415,7 @@ class LeastUpperBoundHelper {
|
||||
}
|
||||
// otherwise UP(B1a, T2)
|
||||
// where B1a is the greatest closure of B1 with respect to X1
|
||||
var B1a = _typeSystem.greatestClosure(B1, [X1.element3]);
|
||||
var B1a = _typeSystem.greatestClosure(B1, [X1.element]);
|
||||
return getLeastUpperBound(B1a, T2);
|
||||
}
|
||||
|
||||
@@ -432,7 +432,7 @@ class LeastUpperBoundHelper {
|
||||
}
|
||||
// otherwise UP(T1, B2a)
|
||||
// where B2a is the greatest closure of B2 with respect to X2
|
||||
var B2a = _typeSystem.greatestClosure(B2, [X2.element3]);
|
||||
var B2a = _typeSystem.greatestClosure(B2, [X2.element]);
|
||||
return getLeastUpperBound(T1, B2a);
|
||||
}
|
||||
|
||||
@@ -538,7 +538,7 @@ class LeastUpperBoundHelper {
|
||||
// otherwise UP(B1a, T2)
|
||||
// where B1a is the greatest closure of B1 with respect to X1
|
||||
var bound = _typeParameterBound(T1);
|
||||
var closure = _typeSystem.greatestClosure(bound, [T1.element3]);
|
||||
var closure = _typeSystem.greatestClosure(bound, [T1.element]);
|
||||
return getLeastUpperBound(closure, T2);
|
||||
}
|
||||
|
||||
@@ -556,7 +556,7 @@ class LeastUpperBoundHelper {
|
||||
// otherwise UP(T1, B2a)
|
||||
// where B2a is the greatest closure of B2 with respect to X2
|
||||
var bound = _typeParameterBound(T2);
|
||||
var closure = _typeSystem.greatestClosure(bound, [T2.element3]);
|
||||
var closure = _typeSystem.greatestClosure(bound, [T2.element]);
|
||||
return getLeastUpperBound(T1, closure);
|
||||
}
|
||||
|
||||
@@ -848,7 +848,7 @@ class LeastUpperBoundHelper {
|
||||
|
||||
/// Return the promoted or declared bound of the type parameter.
|
||||
TypeImpl _typeParameterBound(TypeParameterTypeImpl type) {
|
||||
var bound = type.promotedBound ?? type.element3.bound;
|
||||
var bound = type.promotedBound ?? type.element.bound;
|
||||
if (bound != null) {
|
||||
return bound;
|
||||
}
|
||||
|
||||
@@ -77,7 +77,7 @@ class NonCovariantTypeParameterPositionVisitor implements TypeVisitor<bool> {
|
||||
@override
|
||||
bool visitTypeParameterType(TypeParameterType type) {
|
||||
return _variance != Variance.covariant &&
|
||||
_typeParameters.contains(type.element3);
|
||||
_typeParameters.contains(type.element);
|
||||
}
|
||||
|
||||
@override
|
||||
|
||||
@@ -140,7 +140,7 @@ class NormalizeHelper {
|
||||
|
||||
// NORM(C<T0, ..., Tn>) = C<R0, ..., Rn> where Ri is NORM(Ti)
|
||||
if (T is InterfaceTypeImpl) {
|
||||
return T.element3.instantiateImpl(
|
||||
return T.element.instantiateImpl(
|
||||
typeArguments: T.typeArguments.map(_normalize).toFixedList(),
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
);
|
||||
@@ -210,7 +210,7 @@ class NormalizeHelper {
|
||||
/// NORM(X & T)
|
||||
/// NORM(X extends T)
|
||||
TypeImpl _typeParameterType(TypeParameterTypeImpl T) {
|
||||
var element = T.element3;
|
||||
var element = T.element;
|
||||
|
||||
// NORM(X & T)
|
||||
var promotedBound = T.promotedBound;
|
||||
@@ -259,7 +259,7 @@ class NormalizeHelper {
|
||||
// * if S is X then X
|
||||
if (S is TypeParameterType &&
|
||||
S.nullabilitySuffix == NullabilitySuffix.none &&
|
||||
S.element3 == X) {
|
||||
S.element == X) {
|
||||
return X.instantiate(nullabilitySuffix: NullabilitySuffix.none);
|
||||
}
|
||||
|
||||
@@ -277,7 +277,7 @@ class NormalizeHelper {
|
||||
|
||||
// * else X & S
|
||||
return TypeParameterTypeImpl(
|
||||
element3: X,
|
||||
element: X,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
promotedBound: S,
|
||||
);
|
||||
|
||||
@@ -90,7 +90,7 @@ class ReplaceTopBottomVisitor {
|
||||
}
|
||||
|
||||
InterfaceTypeImpl _interfaceType(InterfaceTypeImpl type, Variance variance) {
|
||||
var typeParameters = type.element3.typeParameters2;
|
||||
var typeParameters = type.element.typeParameters2;
|
||||
if (typeParameters.isEmpty) {
|
||||
return type;
|
||||
}
|
||||
@@ -105,7 +105,7 @@ class ReplaceTopBottomVisitor {
|
||||
}
|
||||
|
||||
return InterfaceTypeImpl(
|
||||
element: type.element3,
|
||||
element: type.element,
|
||||
nullabilitySuffix: type.nullabilitySuffix,
|
||||
typeArguments: newTypeArguments,
|
||||
);
|
||||
|
||||
@@ -87,7 +87,7 @@ class ReplacementVisitor
|
||||
}
|
||||
|
||||
return InterfaceTypeImpl(
|
||||
element: type.element3,
|
||||
element: type.element,
|
||||
typeArguments: newTypeArguments ?? type.typeArguments,
|
||||
nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
|
||||
alias: newAlias ?? type.alias,
|
||||
@@ -106,7 +106,7 @@ class ReplacementVisitor
|
||||
return NamedTypeBuilder(
|
||||
linker: type.linker,
|
||||
typeSystem: type.typeSystem,
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
arguments: newTypeArguments ?? type.arguments,
|
||||
nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
|
||||
);
|
||||
@@ -134,7 +134,7 @@ class ReplacementVisitor
|
||||
|
||||
var promotedBound = (type as TypeParameterTypeImpl).promotedBound;
|
||||
return TypeParameterTypeImpl(
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
|
||||
promotedBound: newPromotedBound ?? promotedBound,
|
||||
alias: type.alias,
|
||||
@@ -150,7 +150,7 @@ class ReplacementVisitor
|
||||
}
|
||||
|
||||
return TypeParameterTypeImpl(
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
nullabilitySuffix: newNullability,
|
||||
alias: type.alias,
|
||||
);
|
||||
@@ -377,7 +377,7 @@ class ReplacementVisitor
|
||||
}
|
||||
|
||||
var newTypeArguments = _typeArguments(
|
||||
type.element3.typeParameters2,
|
||||
type.element.typeParameters2,
|
||||
type.typeArguments,
|
||||
);
|
||||
|
||||
@@ -399,7 +399,7 @@ class ReplacementVisitor
|
||||
var newNullability = visitNullability(type);
|
||||
|
||||
var parameters = const <TypeParameterElementImpl>[];
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
if (element is InterfaceElementImpl) {
|
||||
parameters = element.typeParameters2;
|
||||
} else if (element is TypeAliasElementImpl) {
|
||||
|
||||
@@ -98,7 +98,7 @@ class RuntimeTypeEqualityVisitor
|
||||
@override
|
||||
bool visitInterfaceType(InterfaceType T1, DartType T2) {
|
||||
if (T2 is InterfaceType &&
|
||||
identical(T1.element3, T2.element3) &&
|
||||
identical(T1.element, T2.element) &&
|
||||
_compatibleNullability(T1, T2)) {
|
||||
var T1_typeArguments = T1.typeArguments;
|
||||
var T2_typeArguments = T2.typeArguments;
|
||||
@@ -177,7 +177,7 @@ class RuntimeTypeEqualityVisitor
|
||||
bool visitTypeParameterType(TypeParameterType T1, DartType T2) {
|
||||
return T2 is TypeParameterType &&
|
||||
_compatibleNullability(T1, T2) &&
|
||||
identical(T1.element3, T2.element3);
|
||||
identical(T1.element, T2.element);
|
||||
}
|
||||
|
||||
@override
|
||||
|
||||
@@ -86,7 +86,7 @@ class SubtypeHelper {
|
||||
T0 is TypeParameterTypeImpl) {
|
||||
var S = T0.promotedBound;
|
||||
if (S == null) {
|
||||
var B = T0.element3.bound ?? _objectQuestion;
|
||||
var B = T0.element.bound ?? _objectQuestion;
|
||||
return isSubtypeOf(B, _objectNone);
|
||||
} else {
|
||||
return isSubtypeOf(S, _objectNone);
|
||||
@@ -109,7 +109,7 @@ class SubtypeHelper {
|
||||
return false;
|
||||
}
|
||||
// Extension types require explicit `Object` implementation.
|
||||
if (T0 is InterfaceTypeImpl && T0.element3 is ExtensionTypeElement) {
|
||||
if (T0 is InterfaceTypeImpl && T0.element is ExtensionTypeElement) {
|
||||
for (var interface in T0.interfaces) {
|
||||
if (isSubtypeOf(interface, T1)) {
|
||||
return true;
|
||||
@@ -173,7 +173,7 @@ class SubtypeHelper {
|
||||
if (T0 is TypeParameterTypeImpl &&
|
||||
T1 is TypeParameterTypeImpl &&
|
||||
T1.promotedBound == null &&
|
||||
T0.element3 == T1.element3) {
|
||||
T0.element == T1.element) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -183,7 +183,7 @@ class SubtypeHelper {
|
||||
var T1_promotedBound = T1.promotedBound;
|
||||
if (T1_promotedBound != null) {
|
||||
var X1 = TypeParameterTypeImpl(
|
||||
element3: T1.element3,
|
||||
element: T1.element,
|
||||
nullabilitySuffix: T1.nullabilitySuffix,
|
||||
);
|
||||
return isSubtypeOf(T0, X1) && isSubtypeOf(T0, T1_promotedBound);
|
||||
@@ -215,7 +215,7 @@ class SubtypeHelper {
|
||||
if (S0 != null && isSubtypeOf(S0, T1)) {
|
||||
return true;
|
||||
}
|
||||
var B0 = T0.element3.bound;
|
||||
var B0 = T0.element.bound;
|
||||
if (B0 != null && isSubtypeOf(B0, T1)) {
|
||||
return true;
|
||||
}
|
||||
@@ -243,7 +243,7 @@ class SubtypeHelper {
|
||||
if (S0 != null && isSubtypeOf(S0, T1)) {
|
||||
return true;
|
||||
}
|
||||
var B0 = T0.element3.bound;
|
||||
var B0 = T0.element.bound;
|
||||
if (B0 != null && isSubtypeOf(B0, T1)) {
|
||||
return true;
|
||||
}
|
||||
@@ -269,7 +269,7 @@ class SubtypeHelper {
|
||||
return true;
|
||||
}
|
||||
|
||||
var B0 = T0.element3.bound;
|
||||
var B0 = T0.element.bound;
|
||||
if (B0 != null && isSubtypeOf(B0, T1)) {
|
||||
return true;
|
||||
}
|
||||
@@ -454,8 +454,8 @@ class SubtypeHelper {
|
||||
return false;
|
||||
}
|
||||
|
||||
var subElement = subType.element3;
|
||||
var superElement = superType.element3;
|
||||
var subElement = subType.element;
|
||||
var superElement = superType.element;
|
||||
if (identical(subElement, superElement)) {
|
||||
return _interfaceArguments(superElement, subType, superType);
|
||||
}
|
||||
@@ -466,7 +466,7 @@ class SubtypeHelper {
|
||||
}
|
||||
|
||||
for (var interface in subElement.allSupertypes) {
|
||||
if (identical(interface.element3, superElement)) {
|
||||
if (identical(interface.element, superElement)) {
|
||||
var substitution = Substitution.fromInterfaceType(subType);
|
||||
var substitutedInterface = substitution.mapInterfaceType(interface);
|
||||
return _interfaceArguments(
|
||||
|
||||
@@ -119,7 +119,7 @@ class TopMergeHelper {
|
||||
}
|
||||
|
||||
if (T is TypeParameterType && S is TypeParameterType) {
|
||||
if (T.element3 == S.element3) {
|
||||
if (T.element == S.element) {
|
||||
return T;
|
||||
} else {
|
||||
throw _TopMergeStateError(T, S, 'Not the same type parameters');
|
||||
@@ -225,7 +225,7 @@ class TopMergeHelper {
|
||||
}
|
||||
|
||||
InterfaceTypeImpl _interfaceTypes(InterfaceTypeImpl T, InterfaceTypeImpl S) {
|
||||
if (T.element3 != S.element3) {
|
||||
if (T.element != S.element) {
|
||||
throw _TopMergeStateError(T, S, 'Different class elements');
|
||||
}
|
||||
|
||||
@@ -239,7 +239,7 @@ class TopMergeHelper {
|
||||
(i) => topMerge(T_arguments[i], S_arguments[i]),
|
||||
growable: false,
|
||||
);
|
||||
return T.element3.instantiateImpl(
|
||||
return T.element.instantiateImpl(
|
||||
typeArguments: arguments,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
);
|
||||
|
||||
@@ -39,7 +39,11 @@ class DynamicTypeImpl extends TypeImpl
|
||||
DynamicTypeImpl._();
|
||||
|
||||
@override
|
||||
DynamicElementImpl get element3 => DynamicElementImpl.instance;
|
||||
DynamicElementImpl get element => DynamicElementImpl.instance;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
DynamicElementImpl get element3 => element;
|
||||
|
||||
@override
|
||||
int get hashCode => 1;
|
||||
@@ -210,6 +214,10 @@ class FunctionTypeImpl extends TypeImpl
|
||||
super.alias,
|
||||
});
|
||||
|
||||
@override
|
||||
Null get element => null;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3 => null;
|
||||
|
||||
@@ -412,7 +420,7 @@ class FunctionTypeImpl extends TypeImpl
|
||||
return instantiate([
|
||||
for (var i = 0; i < typeFormals.length; i++)
|
||||
TypeParameterTypeImpl(
|
||||
element3: TypeParameterFragmentImpl.synthetic(name2: 'T$i').element,
|
||||
element: TypeParameterFragmentImpl.synthetic(name2: 'T$i').element,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
),
|
||||
]).hashCode;
|
||||
@@ -534,7 +542,7 @@ class FunctionTypeImpl extends TypeImpl
|
||||
/// `FutureOr<...>`.
|
||||
class FutureOrTypeImpl extends InterfaceTypeImpl {
|
||||
FutureOrTypeImpl({
|
||||
required super.element3,
|
||||
required super.element,
|
||||
required super.typeArgument,
|
||||
required super.nullabilitySuffix,
|
||||
super.alias,
|
||||
@@ -550,7 +558,7 @@ class FutureOrTypeImpl extends InterfaceTypeImpl {
|
||||
if (this.nullabilitySuffix == nullabilitySuffix) return this;
|
||||
|
||||
return FutureOrTypeImpl(
|
||||
element3: element3,
|
||||
element: element,
|
||||
typeArgument: typeArgument,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
alias: alias,
|
||||
@@ -574,7 +582,7 @@ class InstantiatedTypeAliasElementImpl implements InstantiatedTypeAliasElement {
|
||||
/// A concrete implementation of an [InterfaceType].
|
||||
class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
@override
|
||||
final InterfaceElementImpl element3;
|
||||
final InterfaceElementImpl element;
|
||||
|
||||
@override
|
||||
final List<TypeImpl> typeArguments;
|
||||
@@ -602,7 +610,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}) {
|
||||
if (element.name3 == 'FutureOr' && element.library2.isDartAsync) {
|
||||
return FutureOrTypeImpl(
|
||||
element3: element,
|
||||
element: element,
|
||||
typeArgument:
|
||||
typeArguments.isNotEmpty
|
||||
? typeArguments[0]
|
||||
@@ -611,10 +619,10 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
alias: alias,
|
||||
);
|
||||
} else if (element.name3 == 'Null' && element.library2.isDartCore) {
|
||||
return NullTypeImpl(element3: element, alias: alias);
|
||||
return NullTypeImpl(element: element, alias: alias);
|
||||
} else {
|
||||
return InterfaceTypeImpl._(
|
||||
element3: element,
|
||||
element: element,
|
||||
typeArguments: typeArguments,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
alias: alias,
|
||||
@@ -623,33 +631,33 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}
|
||||
|
||||
InterfaceTypeImpl._({
|
||||
required this.element3,
|
||||
required this.element,
|
||||
required this.typeArguments,
|
||||
required this.nullabilitySuffix,
|
||||
required super.alias,
|
||||
});
|
||||
|
||||
InterfaceTypeImpl._futureOr({
|
||||
required this.element3,
|
||||
required this.element,
|
||||
required TypeImpl typeArgument,
|
||||
required this.nullabilitySuffix,
|
||||
super.alias,
|
||||
}) : typeArguments = [typeArgument] {
|
||||
assert(element3.name3 == 'FutureOr' && element3.library2.isDartAsync);
|
||||
assert(element.name3 == 'FutureOr' && element.library2.isDartAsync);
|
||||
assert(this is FutureOrTypeImpl);
|
||||
}
|
||||
|
||||
InterfaceTypeImpl._null({required this.element3, super.alias})
|
||||
InterfaceTypeImpl._null({required this.element, super.alias})
|
||||
: typeArguments = const [],
|
||||
nullabilitySuffix = NullabilitySuffix.none {
|
||||
assert(element3.name3 == 'Null' && element3.library2.isDartCore);
|
||||
assert(element.name3 == 'Null' && element.library2.isDartCore);
|
||||
assert(this is NullTypeImpl);
|
||||
}
|
||||
|
||||
@override
|
||||
List<InterfaceTypeImpl> get allSupertypes {
|
||||
var substitution = Substitution.fromInterfaceType(this);
|
||||
return element3.allSupertypes.map((interface) {
|
||||
return element.allSupertypes.map((interface) {
|
||||
return substitution
|
||||
.mapInterfaceType(interface)
|
||||
.withNullability(nullabilitySuffix);
|
||||
@@ -659,135 +667,139 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
@override
|
||||
List<ConstructorElementMixin2> get constructors2 {
|
||||
return _constructors ??=
|
||||
element3.constructors.map((constructor) {
|
||||
element.constructors.map((constructor) {
|
||||
return ConstructorMember.from2(constructor, this);
|
||||
}).toFixedList();
|
||||
}
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
InterfaceElementImpl get element3 => element;
|
||||
|
||||
@override
|
||||
List<GetterElement2OrMember> get getters {
|
||||
return _getters ??=
|
||||
element3.getters.map((e) {
|
||||
element.getters.map((e) {
|
||||
return GetterMember.forTargetType(e, this);
|
||||
}).toFixedList();
|
||||
}
|
||||
|
||||
@override
|
||||
int get hashCode {
|
||||
return element3.hashCode;
|
||||
return element.hashCode;
|
||||
}
|
||||
|
||||
@override
|
||||
List<InterfaceTypeImpl> get interfaces {
|
||||
return _instantiateSuperTypes(element3.interfaces);
|
||||
return _instantiateSuperTypes(element.interfaces);
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartAsyncFuture {
|
||||
return element3.name3 == "Future" && element3.library2.isDartAsync;
|
||||
return element.name3 == "Future" && element.library2.isDartAsync;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartAsyncStream {
|
||||
return element3.name3 == "Stream" && element3.library2.isDartAsync;
|
||||
return element.name3 == "Stream" && element.library2.isDartAsync;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreBool {
|
||||
return element3.name3 == "bool" && element3.library2.isDartCore;
|
||||
return element.name3 == "bool" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreDouble {
|
||||
return element3.name3 == "double" && element3.library2.isDartCore;
|
||||
return element.name3 == "double" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreEnum {
|
||||
var element = element3;
|
||||
var element = this.element;
|
||||
return element is ClassElementImpl && element.isDartCoreEnum;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreFunction {
|
||||
return element3.name3 == "Function" && element3.library2.isDartCore;
|
||||
return element.name3 == "Function" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreInt {
|
||||
return element3.name3 == "int" && element3.library2.isDartCore;
|
||||
return element.name3 == "int" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreIterable {
|
||||
return element3.name3 == "Iterable" && element3.library2.isDartCore;
|
||||
return element.name3 == "Iterable" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreList {
|
||||
return element3.name3 == "List" && element3.library2.isDartCore;
|
||||
return element.name3 == "List" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreMap {
|
||||
return element3.name3 == "Map" && element3.library2.isDartCore;
|
||||
return element.name3 == "Map" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreNum {
|
||||
return element3.name3 == "num" && element3.library2.isDartCore;
|
||||
return element.name3 == "num" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreObject {
|
||||
return element3.name3 == "Object" && element3.library2.isDartCore;
|
||||
return element.name3 == "Object" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreRecord {
|
||||
return element3.name3 == "Record" && element3.library2.isDartCore;
|
||||
return element.name3 == "Record" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreSet {
|
||||
return element3.name3 == "Set" && element3.library2.isDartCore;
|
||||
return element.name3 == "Set" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreString {
|
||||
return element3.name3 == "String" && element3.library2.isDartCore;
|
||||
return element.name3 == "String" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreSymbol {
|
||||
return element3.name3 == "Symbol" && element3.library2.isDartCore;
|
||||
return element.name3 == "Symbol" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
bool get isDartCoreType {
|
||||
return element3.name3 == "Type" && element3.library2.isDartCore;
|
||||
return element.name3 == "Type" && element.library2.isDartCore;
|
||||
}
|
||||
|
||||
@override
|
||||
List<MethodElement2OrMember> get methods2 {
|
||||
return _methods ??=
|
||||
element3.methods.map((e) {
|
||||
element.methods.map((e) {
|
||||
return MethodMember.forTargetType(e, this);
|
||||
}).toFixedList();
|
||||
}
|
||||
|
||||
@override
|
||||
List<InterfaceTypeImpl> get mixins {
|
||||
return _instantiateSuperTypes(element3.mixins);
|
||||
return _instantiateSuperTypes(element.mixins);
|
||||
}
|
||||
|
||||
@Deprecated('Check element, or use getDisplayString()')
|
||||
@override
|
||||
String get name => element3.name3!;
|
||||
String get name => element.name3!;
|
||||
|
||||
/// The instantiated representation type, if [element3] is an extension type.
|
||||
/// The instantiated representation type, if [element] is an extension type.
|
||||
TypeImpl? get representationType {
|
||||
if (element3 case ExtensionTypeElement element) {
|
||||
if (element case ExtensionTypeElement element) {
|
||||
var substitution = Substitution.fromInterfaceType(this);
|
||||
var representationType = element.representation.type;
|
||||
return substitution.substituteType(representationType);
|
||||
@@ -798,14 +810,14 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
@override
|
||||
List<SetterElement2OrMember> get setters {
|
||||
return _setters ??=
|
||||
element3.setters.map((e) {
|
||||
element.setters.map((e) {
|
||||
return SetterMember.forTargetType(e, this);
|
||||
}).toFixedList();
|
||||
}
|
||||
|
||||
@override
|
||||
InterfaceTypeImpl? get superclass {
|
||||
var supertype = element3.supertype;
|
||||
var supertype = element.supertype;
|
||||
if (supertype == null) {
|
||||
return null;
|
||||
}
|
||||
@@ -817,7 +829,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
|
||||
@override
|
||||
List<InterfaceTypeImpl> get superclassConstraints {
|
||||
var element = element3;
|
||||
var element = this.element;
|
||||
if (element is MixinElementImpl) {
|
||||
var constraints = element.superclassConstraints;
|
||||
return _instantiateSuperTypes(constraints);
|
||||
@@ -827,7 +839,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}
|
||||
|
||||
InheritanceManager3 get _inheritanceManager =>
|
||||
element3.library2.session.inheritanceManager;
|
||||
element.library2.session.inheritanceManager;
|
||||
|
||||
@override
|
||||
bool operator ==(Object other) {
|
||||
@@ -835,7 +847,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
return true;
|
||||
}
|
||||
if (other is InterfaceTypeImpl) {
|
||||
if (!identical(other.element3, element3)) {
|
||||
if (!identical(other.element, element)) {
|
||||
return false;
|
||||
}
|
||||
if (other.nullabilitySuffix != nullabilitySuffix) {
|
||||
@@ -866,12 +878,12 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
|
||||
@override
|
||||
InterfaceTypeImpl? asInstanceOf2(InterfaceElement targetElement) {
|
||||
if (element3 == targetElement) {
|
||||
if (element == targetElement) {
|
||||
return this;
|
||||
}
|
||||
|
||||
for (var rawInterface in element3.allSupertypes) {
|
||||
if (rawInterface.element3 == targetElement) {
|
||||
for (var rawInterface in element.allSupertypes) {
|
||||
if (rawInterface.element == targetElement) {
|
||||
var substitution = Substitution.fromInterfaceType(this);
|
||||
return substitution.mapInterfaceType(rawInterface);
|
||||
}
|
||||
@@ -882,7 +894,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
|
||||
@override
|
||||
GetterElement2OrMember? getGetter(String getterName) {
|
||||
var element = element3.getGetter(getterName);
|
||||
var element = this.element.getGetter(getterName);
|
||||
return element != null ? GetterMember.forTargetType(element, this) : null;
|
||||
}
|
||||
|
||||
@@ -894,7 +906,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
|
||||
@override
|
||||
MethodElement2OrMember? getMethod(String methodName) {
|
||||
var element = element3.getMethod(methodName);
|
||||
var element = this.element.getMethod(methodName);
|
||||
return element != null ? MethodMember.forTargetType(element, this) : null;
|
||||
}
|
||||
|
||||
@@ -906,7 +918,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
|
||||
@override
|
||||
SetterElement2OrMember? getSetter(String setterName) {
|
||||
var element = element3.getSetter(setterName);
|
||||
var element = this.element.getSetter(setterName);
|
||||
return element != null ? SetterMember.forTargetType(element, this) : null;
|
||||
}
|
||||
|
||||
@@ -924,9 +936,9 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
// prepare base ConstructorElement
|
||||
ConstructorElementImpl? constructorElement;
|
||||
if (constructorName == null) {
|
||||
constructorElement = element3.unnamedConstructor2;
|
||||
constructorElement = element.unnamedConstructor2;
|
||||
} else {
|
||||
constructorElement = element3.getNamedConstructor2(constructorName);
|
||||
constructorElement = element.getNamedConstructor2(constructorName);
|
||||
}
|
||||
// not found or not accessible
|
||||
if (constructorElement == null ||
|
||||
@@ -964,7 +976,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
return result;
|
||||
}
|
||||
} else {
|
||||
var rawElement = inheritance.getInherited(element3, nameObj);
|
||||
var rawElement = inheritance.getInherited(element, nameObj);
|
||||
if (rawElement is GetterElement2OrMember) {
|
||||
return GetterMember.forTargetType(rawElement, this);
|
||||
}
|
||||
@@ -978,7 +990,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}
|
||||
|
||||
if (recoveryStatic) {
|
||||
return element3.lookupStaticGetter(name, library);
|
||||
return element.lookupStaticGetter(name, library);
|
||||
}
|
||||
|
||||
return null;
|
||||
@@ -1020,7 +1032,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
return result;
|
||||
}
|
||||
} else {
|
||||
var rawElement = inheritance.getInherited(element3, nameObj);
|
||||
var rawElement = inheritance.getInherited(element, nameObj);
|
||||
if (rawElement is MethodElement2OrMember) {
|
||||
return MethodMember.forTargetType(rawElement, this);
|
||||
}
|
||||
@@ -1034,7 +1046,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}
|
||||
|
||||
if (recoveryStatic) {
|
||||
return element3.lookupStaticMethod(name, library);
|
||||
return element.lookupStaticMethod(name, library);
|
||||
}
|
||||
|
||||
return null;
|
||||
@@ -1076,7 +1088,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
return result;
|
||||
}
|
||||
} else {
|
||||
var rawElement = inheritance.getInherited(element3, nameObj);
|
||||
var rawElement = inheritance.getInherited(element, nameObj);
|
||||
if (rawElement is SetterElement2OrMember) {
|
||||
return SetterMember.forTargetType(rawElement, this);
|
||||
}
|
||||
@@ -1090,7 +1102,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
}
|
||||
|
||||
if (recoveryStatic) {
|
||||
return element3.lookupStaticSetter(name, library);
|
||||
return element.lookupStaticSetter(name, library);
|
||||
}
|
||||
|
||||
return null;
|
||||
@@ -1130,7 +1142,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
if (this.nullabilitySuffix == nullabilitySuffix) return this;
|
||||
|
||||
return InterfaceTypeImpl(
|
||||
element: element3,
|
||||
element: element,
|
||||
typeArguments: typeArguments,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
alias: alias,
|
||||
@@ -1143,7 +1155,7 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
|
||||
if (definedTypes.isEmpty) return definedTypes;
|
||||
|
||||
MapSubstitution? substitution;
|
||||
if (element3.typeParameters2.isNotEmpty) {
|
||||
if (element.typeParameters2.isNotEmpty) {
|
||||
substitution = Substitution.fromInterfaceType(this);
|
||||
}
|
||||
|
||||
@@ -1170,7 +1182,11 @@ class InvalidTypeImpl extends TypeImpl
|
||||
InvalidTypeImpl._();
|
||||
|
||||
@override
|
||||
Null get element3 => null;
|
||||
Null get element => null;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3 => element;
|
||||
|
||||
@override
|
||||
int get hashCode => 1;
|
||||
@@ -1219,6 +1235,10 @@ class NeverTypeImpl extends TypeImpl implements NeverType {
|
||||
/// The unique instance of this class, non-nullable.
|
||||
static final NeverTypeImpl instance = NeverTypeImpl._(NullabilitySuffix.none);
|
||||
|
||||
@override
|
||||
final NeverElementImpl element = NeverElementImpl.instance;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
final NeverElementImpl element3 = NeverElementImpl.instance;
|
||||
|
||||
@@ -1282,7 +1302,7 @@ class NeverTypeImpl extends TypeImpl implements NeverType {
|
||||
/// A concrete implementation of [DartType] representing the type `Null`, with
|
||||
/// no type parameters and no nullability suffix.
|
||||
class NullTypeImpl extends InterfaceTypeImpl implements SharedNullType {
|
||||
NullTypeImpl({required super.element3, super.alias}) : super._null();
|
||||
NullTypeImpl({required super.element, super.alias}) : super._null();
|
||||
|
||||
@override
|
||||
bool get isDartCoreNull => true;
|
||||
@@ -1341,7 +1361,11 @@ class RecordTypeImpl extends TypeImpl implements RecordType, SharedRecordType {
|
||||
}
|
||||
|
||||
@override
|
||||
Null get element3 => null;
|
||||
Null get element => null;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3 => element;
|
||||
|
||||
@override
|
||||
int get hashCode {
|
||||
@@ -1629,7 +1653,7 @@ abstract class TypeImpl implements DartType, SharedType {
|
||||
/// A concrete implementation of a [TypeParameterType].
|
||||
class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
@override
|
||||
final TypeParameterElementImpl element3;
|
||||
final TypeParameterElementImpl element;
|
||||
|
||||
@override
|
||||
final NullabilitySuffix nullabilitySuffix;
|
||||
@@ -1637,13 +1661,13 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
/// An optional promoted bound on the type parameter.
|
||||
///
|
||||
/// 'null' indicates that the type parameter's bound has not been promoted and
|
||||
/// is therefore the same as the bound of [element3].
|
||||
/// is therefore the same as the bound of [element].
|
||||
final TypeImpl? promotedBound;
|
||||
|
||||
/// Initialize a newly created type parameter type to be declared by the given
|
||||
/// [element3] and to have the given name.
|
||||
/// [element] and to have the given name.
|
||||
TypeParameterTypeImpl({
|
||||
required this.element3,
|
||||
required this.element,
|
||||
required this.nullabilitySuffix,
|
||||
DartType? promotedBound,
|
||||
super.alias,
|
||||
@@ -1653,10 +1677,14 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
|
||||
@override
|
||||
TypeImpl get bound =>
|
||||
promotedBound ?? element3.bound ?? DynamicTypeImpl.instance;
|
||||
promotedBound ?? element.bound ?? DynamicTypeImpl.instance;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
TypeParameterElementImpl get element3 => element;
|
||||
|
||||
@override
|
||||
int get hashCode => element3.hashCode;
|
||||
int get hashCode => element.hashCode;
|
||||
|
||||
@override
|
||||
bool get isBottom {
|
||||
@@ -1665,7 +1693,7 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
// bounds form a loop. So we have to be more careful.
|
||||
Set<TypeParameterElement> seenTypes = {};
|
||||
TypeParameterType type = this;
|
||||
while (seenTypes.add(type.element3)) {
|
||||
while (seenTypes.add(type.element)) {
|
||||
if (type.nullabilitySuffix == NullabilitySuffix.question) {
|
||||
return false;
|
||||
}
|
||||
@@ -1682,11 +1710,11 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
|
||||
@Deprecated('Check element, or use getDisplayString()')
|
||||
@override
|
||||
String get name => element3.name3!;
|
||||
String get name => element.name3!;
|
||||
|
||||
TypeParameterTypeImpl get withoutPromotedBound {
|
||||
return TypeParameterTypeImpl(
|
||||
element3: element3,
|
||||
element: element,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
);
|
||||
}
|
||||
@@ -1697,7 +1725,7 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (other is TypeParameterTypeImpl && other.element3 == element3) {
|
||||
if (other is TypeParameterTypeImpl && other.element == element) {
|
||||
if (other.nullabilitySuffix != nullabilitySuffix) {
|
||||
return false;
|
||||
}
|
||||
@@ -1732,14 +1760,14 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
|
||||
|
||||
@override
|
||||
bool referencesAny2(Set<TypeParameterElementImpl> parameters) {
|
||||
return parameters.contains(element3);
|
||||
return parameters.contains(element);
|
||||
}
|
||||
|
||||
@override
|
||||
TypeImpl withNullability(NullabilitySuffix nullabilitySuffix) {
|
||||
if (this.nullabilitySuffix == nullabilitySuffix) return this;
|
||||
return TypeParameterTypeImpl(
|
||||
element3: element3,
|
||||
element: element,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
promotedBound: promotedBound,
|
||||
);
|
||||
@@ -1754,6 +1782,10 @@ class VoidTypeImpl extends TypeImpl implements VoidType, SharedVoidType {
|
||||
/// Prevent the creation of instances of this class.
|
||||
VoidTypeImpl._();
|
||||
|
||||
@override
|
||||
Null get element => null;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Null get element3 => null;
|
||||
|
||||
|
||||
@@ -34,7 +34,7 @@ FreshTypeParameters getFreshTypeParameters2(
|
||||
var map = <TypeParameterElement, DartType>{};
|
||||
for (int i = 0; i < typeParameters.length; ++i) {
|
||||
map[typeParameters[i]] = TypeParameterTypeImpl(
|
||||
element3: freshParameters[i],
|
||||
element: freshParameters[i],
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
);
|
||||
}
|
||||
@@ -195,7 +195,7 @@ abstract class Substitution {
|
||||
if (type.typeArguments.isEmpty) {
|
||||
return _NullSubstitution.instance;
|
||||
}
|
||||
return fromPairs2(type.element3.typeParameters2, type.typeArguments);
|
||||
return fromPairs2(type.element.typeParameters2, type.typeArguments);
|
||||
}
|
||||
|
||||
/// Substitutes each parameter to the type it maps to in [map].
|
||||
@@ -317,7 +317,7 @@ class _NullSubstitution extends MapSubstitution {
|
||||
@override
|
||||
DartType getSubstitute(TypeParameterElement parameter, bool upperBound) {
|
||||
return TypeParameterTypeImpl(
|
||||
element3: parameter as TypeParameterElementImpl,
|
||||
element: parameter as TypeParameterElementImpl,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
);
|
||||
}
|
||||
@@ -521,7 +521,7 @@ abstract class _TypeSubstitutor
|
||||
}
|
||||
|
||||
return InterfaceTypeImpl(
|
||||
element: type.element3,
|
||||
element: type.element,
|
||||
typeArguments: typeArguments,
|
||||
nullabilitySuffix: type.nullabilitySuffix,
|
||||
alias: alias,
|
||||
@@ -546,7 +546,7 @@ abstract class _TypeSubstitutor
|
||||
return NamedTypeBuilder(
|
||||
linker: type.linker,
|
||||
typeSystem: type.typeSystem,
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
arguments: arguments,
|
||||
nullabilitySuffix: type.nullabilitySuffix,
|
||||
);
|
||||
@@ -593,7 +593,7 @@ abstract class _TypeSubstitutor
|
||||
|
||||
@override
|
||||
TypeImpl visitTypeParameterType(covariant TypeParameterTypeImpl type) {
|
||||
var argument = getSubstitute(type.element3);
|
||||
var argument = getSubstitute(type.element);
|
||||
if (argument == null) {
|
||||
return type;
|
||||
}
|
||||
|
||||
@@ -247,8 +247,8 @@ class TypeConstraintGatherer
|
||||
InterfaceType type,
|
||||
InterfaceElementImpl typeDeclaration,
|
||||
) {
|
||||
for (var interface in type.element3.allSupertypes) {
|
||||
if (interface.element3 == typeDeclaration) {
|
||||
for (var interface in type.element.allSupertypes) {
|
||||
if (interface.element == typeDeclaration) {
|
||||
var substitution = Substitution.fromInterfaceType(type);
|
||||
return substitution.mapInterfaceType(interface).typeArguments;
|
||||
}
|
||||
|
||||
@@ -21,7 +21,7 @@ class DemotionVisitor extends ReplacementVisitor {
|
||||
}
|
||||
|
||||
return TypeParameterTypeImpl(
|
||||
element3: type.element3,
|
||||
element: type.element,
|
||||
nullabilitySuffix: type.nullabilitySuffix,
|
||||
alias: type.alias,
|
||||
);
|
||||
|
||||
@@ -78,7 +78,7 @@ const Set<String> _nonSubtypableDartTypedDataClassNames = {
|
||||
abstract class TypeProviderBase implements TypeProvider {
|
||||
@override
|
||||
bool isObjectGetter(String id) {
|
||||
var element = objectType.element3.getGetter(id);
|
||||
var element = objectType.element.getGetter(id);
|
||||
return element != null && !element.isStatic;
|
||||
}
|
||||
|
||||
@@ -89,7 +89,7 @@ abstract class TypeProviderBase implements TypeProvider {
|
||||
|
||||
@override
|
||||
bool isObjectMethod(String id) {
|
||||
var element = objectType.element3.getMethod(id);
|
||||
var element = objectType.element.getMethod(id);
|
||||
return element != null && !element.isStatic;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,7 +24,11 @@ class UnknownInferredType extends TypeImpl implements SharedUnknownType {
|
||||
const UnknownInferredType._();
|
||||
|
||||
@override
|
||||
Element? get element3 => null;
|
||||
Element? get element => null;
|
||||
|
||||
@Deprecated('Use element instead')
|
||||
@override
|
||||
Element? get element3 => element;
|
||||
|
||||
@override
|
||||
int get hashCode => 1;
|
||||
|
||||
@@ -195,8 +195,8 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
if (left is InterfaceTypeImpl && right is InterfaceTypeImpl) {
|
||||
var leftElement = left.element3;
|
||||
var rightElement = right.element3;
|
||||
var leftElement = left.element;
|
||||
var rightElement = right.element;
|
||||
|
||||
// Can happen in JavaScript.
|
||||
if (left.isDartCoreInt && right.isDartCoreDouble ||
|
||||
@@ -208,7 +208,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
InterfaceTypeImpl left,
|
||||
InterfaceTypeImpl right,
|
||||
) {
|
||||
assert(left.element3 == right.element3);
|
||||
assert(left.element == right.element);
|
||||
var leftArguments = left.typeArguments;
|
||||
var rightArguments = right.typeArguments;
|
||||
assert(leftArguments.length == rightArguments.length);
|
||||
@@ -421,7 +421,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
// * otherwise, flatten(T) = flatten(X)
|
||||
return flatten(
|
||||
TypeParameterTypeImpl(
|
||||
element3: T.element3,
|
||||
element: T.element,
|
||||
nullabilitySuffix: nullabilitySuffix,
|
||||
),
|
||||
);
|
||||
@@ -525,7 +525,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
}
|
||||
return candidates
|
||||
.where((type) => type.element3.typeParameters2.isNotEmpty)
|
||||
.where((type) => type.element.typeParameters2.isNotEmpty)
|
||||
.toList();
|
||||
}
|
||||
|
||||
@@ -538,7 +538,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
FunctionTypeImpl? getCallMethodType(DartType t) {
|
||||
if (t is InterfaceTypeImpl) {
|
||||
return t
|
||||
.lookUpMethod(MethodElement.CALL_METHOD_NAME, t.element3.library2)
|
||||
.lookUpMethod(MethodElement.CALL_METHOD_NAME, t.element.library2)
|
||||
?.type;
|
||||
}
|
||||
return null;
|
||||
@@ -567,7 +567,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
visitedTypes.add(type);
|
||||
if (type is TypeParameterType) {
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
if ((candidates == null || candidates.contains(element)) &&
|
||||
!boundTypeParameters.contains(element)) {
|
||||
parameters ??= <TypeParameterElement>[];
|
||||
@@ -715,7 +715,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
return type.instantiate(typeArguments);
|
||||
} else if (type is InterfaceTypeImpl) {
|
||||
// TODO(scheglov): Use `ClassElement.instantiate()`, don't use raw types.
|
||||
return type.element3.instantiateImpl(
|
||||
return type.element.instantiateImpl(
|
||||
typeArguments: typeArguments,
|
||||
nullabilitySuffix: type.nullabilitySuffix,
|
||||
);
|
||||
@@ -828,7 +828,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
if (type.isDartCoreNull) {
|
||||
return true;
|
||||
}
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
if (element is EnumElement) {
|
||||
return true;
|
||||
}
|
||||
@@ -847,7 +847,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
if (promotedBound != null && isAlwaysExhaustive(promotedBound)) {
|
||||
return true;
|
||||
}
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
if (bound != null && isAlwaysExhaustive(bound)) {
|
||||
return true;
|
||||
}
|
||||
@@ -910,7 +910,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
if (bound != null && isDynamicBounded(bound)) {
|
||||
return true;
|
||||
}
|
||||
@@ -946,7 +946,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
if (bound != null && isFunctionBounded(bound)) {
|
||||
return true;
|
||||
}
|
||||
@@ -970,7 +970,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
// `T` is an extension type that does not implement `Future`.
|
||||
if (T.element3 is ExtensionTypeElement) {
|
||||
if (T.element is ExtensionTypeElement) {
|
||||
var anyFuture = typeProvider.futureType(objectQuestion);
|
||||
if (!isSubtypeOf(T, anyFuture)) {
|
||||
return true;
|
||||
@@ -984,7 +984,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
// `T` is a type variable with bound `S`, and `S` is incompatible
|
||||
// with await.
|
||||
if (T.element3.bound case var S?) {
|
||||
if (T.element.bound case var S?) {
|
||||
return isIncompatibleWithAwait(S);
|
||||
}
|
||||
}
|
||||
@@ -999,7 +999,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
if (bound != null && isInvalidBounded(bound)) {
|
||||
return true;
|
||||
}
|
||||
@@ -1064,8 +1064,8 @@ class TypeSystemImpl implements TypeSystem {
|
||||
// is anything except none by this point.
|
||||
assert(T_nullability == NullabilitySuffix.none);
|
||||
assert(S_nullability == NullabilitySuffix.none);
|
||||
var T_element = T.element3;
|
||||
var S_element = S.element3;
|
||||
var T_element = T.element;
|
||||
var S_element = S.element;
|
||||
|
||||
// MOREBOTTOM(X&T, Y&S) = MOREBOTTOM(T, S)
|
||||
var T_promotedBound = T.promotedBound;
|
||||
@@ -1183,11 +1183,11 @@ class TypeSystemImpl implements TypeSystem {
|
||||
if (type.isDartAsyncFutureOr) {
|
||||
return isNonNullable(type.typeArguments[0]);
|
||||
}
|
||||
if (type.element3 is ExtensionTypeElement) {
|
||||
if (type.element is ExtensionTypeElement) {
|
||||
return type.interfaces.isNotEmpty;
|
||||
}
|
||||
} else if (type is TypeParameterType) {
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
return bound != null && isNonNullable(bound);
|
||||
}
|
||||
return true;
|
||||
@@ -1275,7 +1275,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
if (type.isDartAsyncFutureOr) {
|
||||
return isStrictlyNonNullable(type.typeArguments[0]);
|
||||
}
|
||||
if (type.element3 is ExtensionTypeElement) {
|
||||
if (type.element is ExtensionTypeElement) {
|
||||
return type.interfaces.isNotEmpty;
|
||||
}
|
||||
} else if (type is TypeParameterType) {
|
||||
@@ -1491,13 +1491,13 @@ class TypeSystemImpl implements TypeSystem {
|
||||
if (type.isDartCoreNull) return NeverTypeImpl.instance;
|
||||
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
|
||||
// NonNull(X & T) = X & NonNull(T)
|
||||
if (type.promotedBound != null) {
|
||||
var promotedBound = promoteToNonNull(type.promotedBound!);
|
||||
return TypeParameterTypeImpl(
|
||||
element3: element,
|
||||
element: element,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
promotedBound: promotedBound,
|
||||
);
|
||||
@@ -1512,7 +1512,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
promotedBound = null;
|
||||
}
|
||||
return TypeParameterTypeImpl(
|
||||
element3: element,
|
||||
element: element,
|
||||
nullabilitySuffix: NullabilitySuffix.none,
|
||||
promotedBound: promotedBound,
|
||||
);
|
||||
@@ -1667,7 +1667,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
return resolveToBound(promotedBound);
|
||||
}
|
||||
|
||||
var bound = type.element3.bound;
|
||||
var bound = type.element.bound;
|
||||
if (bound == null) {
|
||||
return objectQuestion;
|
||||
}
|
||||
@@ -1769,9 +1769,9 @@ class TypeSystemImpl implements TypeSystem {
|
||||
// `U` to `S` where `S <: U`, yielding a type parameter `T extends S`.
|
||||
if (from is TypeParameterTypeImpl) {
|
||||
if (isSubtypeOf(to, from.bound)) {
|
||||
var declaration = from.element3.baseElement;
|
||||
var declaration = from.element.baseElement;
|
||||
return TypeParameterTypeImpl(
|
||||
element3: declaration as TypeParameterElementImpl,
|
||||
element: declaration as TypeParameterElementImpl,
|
||||
nullabilitySuffix: _promotedTypeParameterTypeNullability(
|
||||
from.nullabilitySuffix,
|
||||
to.nullabilitySuffix,
|
||||
@@ -1788,7 +1788,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
/// the type arguments of [right]. Both types must be instantiations of the
|
||||
/// same element.
|
||||
bool _canBeEqualArguments(InterfaceType left, InterfaceType right) {
|
||||
assert(left.element3 == right.element3);
|
||||
assert(left.element == right.element);
|
||||
var leftArguments = left.typeArguments;
|
||||
var rightArguments = right.typeArguments;
|
||||
assert(leftArguments.length == rightArguments.length);
|
||||
@@ -1805,7 +1805,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
/// Optimistically estimates, if [left] can be equal to [right].
|
||||
bool _canBeEqualTo(DartType left, DartType right) {
|
||||
if (left is InterfaceType && right is InterfaceType) {
|
||||
if (left.element3 != right.element3) {
|
||||
if (left.element != right.element) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1845,7 +1845,7 @@ class TypeSystemImpl implements TypeSystem {
|
||||
}
|
||||
|
||||
if (T is TypeParameterTypeImpl) {
|
||||
var bound = T.element3.bound;
|
||||
var bound = T.element.bound;
|
||||
if (bound != null) {
|
||||
var result = _futureTypeOfBounded(bound);
|
||||
if (result != null) {
|
||||
|
||||
@@ -83,8 +83,8 @@ class TypeBoundedHelper {
|
||||
typeParameters = alias.element2.typeParameters2;
|
||||
typeArguments = alias.typeArguments;
|
||||
} else if (type is InterfaceTypeImpl) {
|
||||
elementName = type.element3.name3;
|
||||
typeParameters = type.element3.typeParameters2;
|
||||
elementName = type.element.name3;
|
||||
typeParameters = type.element.typeParameters2;
|
||||
typeArguments = type.typeArguments;
|
||||
} else {
|
||||
return const RegularBoundedTypeResult._();
|
||||
|
||||
@@ -446,7 +446,7 @@ class AnnotationResolver {
|
||||
ExecutableElement? getter;
|
||||
var aliasedType = typeAliasElement.aliasedType;
|
||||
if (aliasedType is InterfaceType) {
|
||||
var classElement = aliasedType.element3;
|
||||
var classElement = aliasedType.element;
|
||||
if (getterName != null) {
|
||||
getter = classElement.getGetter(getterName.name);
|
||||
}
|
||||
|
||||
@@ -209,7 +209,7 @@ class AstRewriter {
|
||||
node: node,
|
||||
typeIdentifier: target,
|
||||
constructorIdentifier: methodName,
|
||||
classElement: aliasedType.element3,
|
||||
classElement: aliasedType.element,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -234,7 +234,7 @@ class AstRewriter {
|
||||
node: node,
|
||||
typeNameIdentifier: target,
|
||||
constructorIdentifier: methodName,
|
||||
classElement: aliasedType.element3,
|
||||
classElement: aliasedType.element,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -296,7 +296,7 @@ class AstRewriter {
|
||||
// X.named
|
||||
return _toConstructorReference_prefixed(
|
||||
node: node,
|
||||
classElement: aliasedType.element3,
|
||||
classElement: aliasedType.element,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -386,7 +386,7 @@ class AstRewriter {
|
||||
node: node,
|
||||
receiver: receiverIdentifier,
|
||||
typeArguments: typeArguments,
|
||||
classElement: aliasedType.element3,
|
||||
classElement: aliasedType.element,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ class CommentReferenceResolver {
|
||||
|
||||
if (prefixElement is TypeAliasElement) {
|
||||
// When resolving `name`, use the aliased element.
|
||||
prefixElement = prefixElement.aliasedType.element3;
|
||||
prefixElement = prefixElement.aliasedType.element;
|
||||
}
|
||||
|
||||
if (prefixElement is PrefixElement) {
|
||||
@@ -140,7 +140,7 @@ class CommentReferenceResolver {
|
||||
|
||||
if (element is TypeAliasElement) {
|
||||
// When resolving `propertyName`, use the aliased element.
|
||||
element = element.aliasedType.element3;
|
||||
element = element.aliasedType.element;
|
||||
}
|
||||
|
||||
if (element is InterfaceElement) {
|
||||
|
||||
@@ -55,7 +55,7 @@ class ConstructorReferenceResolver {
|
||||
if (enclosingElement is TypeAliasElement) {
|
||||
var aliasedType = enclosingElement.aliasedType;
|
||||
enclosingElement =
|
||||
aliasedType is InterfaceType ? aliasedType.element3 : null;
|
||||
aliasedType is InterfaceType ? aliasedType.element : null;
|
||||
}
|
||||
// TODO(srawlins): Handle `enclosingElement` being a function typedef:
|
||||
// typedef F<T> = void Function(); var a = F<int>.extensionOnType;`.
|
||||
|
||||
@@ -648,7 +648,7 @@ class TypeSystemOperations
|
||||
|
||||
@override
|
||||
bool isExtensionTypeInternal(TypeImpl type) {
|
||||
return type is InterfaceType && type.element3 is ExtensionTypeElement;
|
||||
return type is InterfaceType && type.element is ExtensionTypeElement;
|
||||
}
|
||||
|
||||
@override
|
||||
@@ -661,7 +661,7 @@ class TypeSystemOperations
|
||||
return type is InterfaceType &&
|
||||
!type.isDartCoreNull &&
|
||||
!type.isDartAsyncFutureOr &&
|
||||
type.element3 is! ExtensionTypeElement;
|
||||
type.element is! ExtensionTypeElement;
|
||||
}
|
||||
|
||||
@override
|
||||
@@ -778,7 +778,7 @@ class TypeSystemOperations
|
||||
@override
|
||||
TypeParameterElementImpl? matchInferableParameterInternal(TypeImpl type) {
|
||||
if (type is TypeParameterTypeImpl) {
|
||||
return type.element3;
|
||||
return type.element;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
@@ -828,7 +828,7 @@ class TypeSystemOperations
|
||||
return TypeDeclarationMatchResult(
|
||||
typeDeclarationKind: TypeDeclarationKind.interfaceDeclaration,
|
||||
typeDeclarationType: interfaceType,
|
||||
typeDeclaration: interfaceType.element3,
|
||||
typeDeclaration: interfaceType.element,
|
||||
typeArguments: interfaceType.typeArguments,
|
||||
);
|
||||
} else if (isExtensionTypeInternal(type)) {
|
||||
@@ -836,7 +836,7 @@ class TypeSystemOperations
|
||||
return TypeDeclarationMatchResult(
|
||||
typeDeclarationKind: TypeDeclarationKind.extensionTypeDeclaration,
|
||||
typeDeclarationType: interfaceType,
|
||||
typeDeclaration: interfaceType.element3,
|
||||
typeDeclaration: interfaceType.element,
|
||||
typeArguments: interfaceType.typeArguments,
|
||||
);
|
||||
} else {
|
||||
@@ -848,7 +848,7 @@ class TypeSystemOperations
|
||||
TypeImpl? matchTypeParameterBoundInternal(TypeImpl type) {
|
||||
if (type is TypeParameterTypeImpl &&
|
||||
type.nullabilitySuffix == NullabilitySuffix.none) {
|
||||
return type.promotedBound ?? type.element3.bound;
|
||||
return type.promotedBound ?? type.element.bound;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -177,7 +177,7 @@ class FunctionReferenceResolver {
|
||||
// extension method applies.
|
||||
return type.lookUpMethod(
|
||||
MethodElement.CALL_METHOD_NAME,
|
||||
type.element3.library2,
|
||||
type.element.library2,
|
||||
) ??
|
||||
_extensionResolver.findExtension(type, node, callMethodName).getter2;
|
||||
}
|
||||
@@ -249,7 +249,7 @@ class FunctionReferenceResolver {
|
||||
// If the type of the function is a type parameter, the tearoff is
|
||||
// disallowed, reported in [_resolveDisallowedExpression]. Use the type
|
||||
// parameter's bound here in an attempt to assign the intended types.
|
||||
rawType = rawType.element3.bound;
|
||||
rawType = rawType.element.bound;
|
||||
}
|
||||
|
||||
if (rawType is FunctionType) {
|
||||
@@ -927,7 +927,7 @@ class FunctionReferenceResolver {
|
||||
} else if (receiverElement is TypeAliasElement) {
|
||||
var aliasedType = receiverElement.aliasedType;
|
||||
if (aliasedType is InterfaceType) {
|
||||
var element = _resolveStaticElement(aliasedType.element3, name);
|
||||
var element = _resolveStaticElement(aliasedType.element, name);
|
||||
name.element = element;
|
||||
return element?.referenceType;
|
||||
} else {
|
||||
|
||||
@@ -73,7 +73,7 @@ class InstanceCreationExpressionResolver {
|
||||
|
||||
// TODO(kallentu): Support other context types
|
||||
if (dotShorthandContextType is InterfaceTypeImpl) {
|
||||
InterfaceElementImpl? contextElement = dotShorthandContextType.element3;
|
||||
InterfaceElementImpl? contextElement = dotShorthandContextType.element;
|
||||
// This branch will be true if we're resolving an explicitly marked
|
||||
// const constructor invocation. It's completely unresolved, unlike a
|
||||
// rewritten [DotShorthandConstructorInvocation] that resulted from
|
||||
@@ -134,7 +134,7 @@ class InstanceCreationExpressionResolver {
|
||||
var whyNotPromotedArguments = <WhyNotPromotedGetter>[];
|
||||
_resolver.elementResolver.visitDotShorthandConstructorInvocation(node);
|
||||
var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
|
||||
typeElement: dotShorthandContextType.element3,
|
||||
typeElement: dotShorthandContextType.element,
|
||||
constructorName: node.constructorName,
|
||||
definingLibrary: _resolver.definingLibrary,
|
||||
);
|
||||
|
||||
@@ -172,7 +172,7 @@ class MethodInvocationResolver with ScopeHelpers {
|
||||
if (aliasedType is InterfaceType) {
|
||||
return _resolveReceiverTypeLiteral(
|
||||
node,
|
||||
aliasedType.element3,
|
||||
aliasedType.element,
|
||||
nameNode,
|
||||
name,
|
||||
whyNotPromotedArguments,
|
||||
@@ -274,7 +274,7 @@ class MethodInvocationResolver with ScopeHelpers {
|
||||
|
||||
// TODO(kallentu): Dot shorthands work - Support other context types
|
||||
if (dotShorthandContextType is InterfaceTypeImpl) {
|
||||
var receiver = dotShorthandContextType.element3;
|
||||
var receiver = dotShorthandContextType.element;
|
||||
return _resolveReceiverTypeLiteralForDotShorthand(
|
||||
node,
|
||||
receiver,
|
||||
@@ -851,7 +851,7 @@ class MethodInvocationResolver with ScopeHelpers {
|
||||
contextType: contextType,
|
||||
);
|
||||
var receiverTypeName = switch (receiverType) {
|
||||
InterfaceTypeImpl() => receiverType.element3.name3!,
|
||||
InterfaceTypeImpl() => receiverType.element.name3!,
|
||||
FunctionType() => 'Function',
|
||||
_ => '<unknown>',
|
||||
};
|
||||
@@ -1158,7 +1158,7 @@ class MethodInvocationResolver with ScopeHelpers {
|
||||
|
||||
String receiverClassName = '<unknown>';
|
||||
if (receiverType is InterfaceTypeImpl) {
|
||||
receiverClassName = receiverType.element3.name3!;
|
||||
receiverClassName = receiverType.element.name3!;
|
||||
} else if (receiverType is FunctionType) {
|
||||
receiverClassName = 'Function';
|
||||
}
|
||||
@@ -1187,7 +1187,7 @@ class MethodInvocationResolver with ScopeHelpers {
|
||||
required TypeImpl contextType,
|
||||
}) {
|
||||
if (node.isCascaded) {
|
||||
receiver = _typeType.element3;
|
||||
receiver = _typeType.element;
|
||||
}
|
||||
|
||||
var element = _resolveElement(receiver, nameNode);
|
||||
|
||||
@@ -260,7 +260,7 @@ class NamedTypeResolver with ScopeHelpers {
|
||||
if (element is InterfaceElementImpl) {
|
||||
if (identical(node, withClause_namedType)) {
|
||||
for (var mixin in enclosingClass!.mixins) {
|
||||
if (mixin.element3 == element) {
|
||||
if (mixin.element == element) {
|
||||
return mixin;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -81,7 +81,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
// Infer type parameters.
|
||||
var elementToInfer = _resolver.inferenceHelper
|
||||
.constructorElementToInfer(
|
||||
typeElement: context.element3,
|
||||
typeElement: context.element,
|
||||
constructorName: identifier,
|
||||
definingLibrary: _resolver.definingLibrary,
|
||||
);
|
||||
@@ -114,7 +114,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
}
|
||||
|
||||
// Didn't find any constructor tearoffs, look for static getters.
|
||||
var contextElement = context.element3;
|
||||
var contextElement = context.element;
|
||||
return _resolveTargetInterfaceElement(
|
||||
typeReference: contextElement,
|
||||
isCascaded: false,
|
||||
@@ -506,7 +506,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
var aliasedType = targetElement.aliasedType;
|
||||
if (aliasedType is InterfaceType) {
|
||||
return _resolveTargetInterfaceElement(
|
||||
typeReference: aliasedType.element3,
|
||||
typeReference: aliasedType.element,
|
||||
isCascaded: isCascaded,
|
||||
propertyName: propertyName,
|
||||
hasRead: hasRead,
|
||||
@@ -779,7 +779,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
bool resolvingDotShorthand = false,
|
||||
}) {
|
||||
if (isCascaded) {
|
||||
typeReference = _resolver.typeProvider.typeType.element3;
|
||||
typeReference = _resolver.typeProvider.typeType.element;
|
||||
}
|
||||
|
||||
ExecutableElement? readElement;
|
||||
@@ -927,7 +927,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
if (hasRead) {
|
||||
var name = Name(_definingLibrary.source.uri, propertyName.name);
|
||||
readElement = _resolver.inheritance.getMember(
|
||||
targetType.element3,
|
||||
targetType.element,
|
||||
name,
|
||||
forSuper: true,
|
||||
);
|
||||
@@ -939,7 +939,7 @@ class PropertyElementResolver with ScopeHelpers {
|
||||
// But we would like to give the user at least some resolution.
|
||||
// So, we retry simply looking for an inherited member.
|
||||
readElement = _resolver.inheritance.getInherited(
|
||||
targetType.element3,
|
||||
targetType.element,
|
||||
name,
|
||||
);
|
||||
if (readElement != null) {
|
||||
|
||||
@@ -1723,7 +1723,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
|
||||
return;
|
||||
}
|
||||
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
switch (element) {
|
||||
case ClassElement():
|
||||
return;
|
||||
@@ -1875,7 +1875,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
|
||||
.EXTENSION_TYPE_IMPLEMENTS_REPRESENTATION_NOT_SUPERTYPE,
|
||||
arguments: [
|
||||
implementedRepresentation,
|
||||
type.element3.name3 ?? '',
|
||||
type.element.name3 ?? '',
|
||||
declaredRepresentation,
|
||||
declaredElement.name2 ?? '',
|
||||
],
|
||||
|
||||
@@ -279,7 +279,7 @@ class TypePropertyResolver {
|
||||
_needsGetterError = _getterRequested == null;
|
||||
|
||||
if (_getterRequested == null && recoverWithStatic) {
|
||||
var classElement = type.element3;
|
||||
var classElement = type.element;
|
||||
_getterRecovery ??=
|
||||
classElement.lookupStaticGetter(_name, _definingLibrary) ??
|
||||
classElement.lookupStaticMethod(_name, _definingLibrary);
|
||||
@@ -297,7 +297,7 @@ class TypePropertyResolver {
|
||||
_needsSetterError = _setterRequested == null;
|
||||
|
||||
if (_setterRequested == null && recoverWithStatic) {
|
||||
var classElement = type.element3;
|
||||
var classElement = type.element;
|
||||
_setterRecovery ??= classElement.lookupStaticSetter(
|
||||
_name,
|
||||
_definingLibrary,
|
||||
|
||||
@@ -787,12 +787,12 @@ class TypedLiteralResolver {
|
||||
// The literal is ambiguous, and further analysis won't resolve the
|
||||
// ambiguity. Leave it as neither a set nor a map.
|
||||
} else if (literalType is InterfaceType &&
|
||||
literalType.element3 == _typeProvider.mapElement2) {
|
||||
literalType.element == _typeProvider.mapElement2) {
|
||||
node.becomeMap();
|
||||
} else {
|
||||
assert(
|
||||
literalType is InterfaceType &&
|
||||
literalType.element3 == _typeProvider.setElement2,
|
||||
literalType.element == _typeProvider.setElement2,
|
||||
);
|
||||
node.becomeSet();
|
||||
}
|
||||
|
||||
@@ -77,7 +77,7 @@ class AnnotationVerifier {
|
||||
return;
|
||||
}
|
||||
|
||||
var element = type.element3;
|
||||
var element = type.element;
|
||||
if (element is InterfaceElement &&
|
||||
element.allSupertypes.any((t) => t.isDartAsyncFuture)) {
|
||||
return;
|
||||
@@ -300,10 +300,10 @@ class AnnotationVerifier {
|
||||
var parent = node.parent;
|
||||
if (parent is ClassDeclaration) {
|
||||
classElement = parent.declaredFragment?.element;
|
||||
superElement = classElement?.supertype?.element3;
|
||||
superElement = classElement?.supertype?.element;
|
||||
} else if (parent is ClassTypeAlias) {
|
||||
classElement = parent.declaredFragment?.element;
|
||||
superElement = classElement?.supertype?.element3;
|
||||
superElement = classElement?.supertype?.element;
|
||||
} else {
|
||||
// If `parent` is neither of the above types, then `_checkKinds` will
|
||||
// report a warning.
|
||||
|
||||
@@ -66,7 +66,7 @@ class BaseOrFinalTypeVerifier {
|
||||
for (NamedType interface in interfaces) {
|
||||
var interfaceType = interface.type;
|
||||
if (interfaceType is InterfaceType) {
|
||||
var interfaceElement = interfaceType.element3;
|
||||
var interfaceElement = interfaceType.element;
|
||||
if (interfaceElement is InterfaceElementImpl) {
|
||||
// Return early if an error has been reported to prevent reporting
|
||||
// multiple errors on one element.
|
||||
@@ -90,7 +90,7 @@ class BaseOrFinalTypeVerifier {
|
||||
InterfaceElementImpl subElement,
|
||||
) {
|
||||
for (var supertype in supertypes) {
|
||||
var supertypeElement = supertype.element3;
|
||||
var supertypeElement = supertype.element;
|
||||
if (supertypeElement is InterfaceElementImpl) {
|
||||
// Return early if an error has been reported to prevent reporting
|
||||
// multiple errors on one element.
|
||||
@@ -141,7 +141,7 @@ class BaseOrFinalTypeVerifier {
|
||||
) {
|
||||
InterfaceElementImpl? baseOrFinalElement;
|
||||
for (var supertype in supertypes) {
|
||||
var supertypeElement = supertype.element3;
|
||||
var supertypeElement = supertype.element;
|
||||
if (supertypeElement is InterfaceElementImpl) {
|
||||
baseOrFinalElement = _getExplicitlyBaseOrFinalElement(supertypeElement);
|
||||
if (baseOrFinalElement != null) {
|
||||
|
||||
@@ -691,7 +691,7 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
|
||||
var type = node.typeOrThrow;
|
||||
// Only report non-aliased, non-user-defined `Null?` and `dynamic?`. Do
|
||||
// not report synthetic `dynamic` in place of an unresolved type.
|
||||
if ((type is InterfaceType && type.element3 == _nullType.element3 ||
|
||||
if ((type is InterfaceType && type.element == _nullType.element ||
|
||||
(type is DynamicType && node.name.lexeme == 'dynamic')) &&
|
||||
type.alias == null) {
|
||||
_diagnosticReporter.atToken(
|
||||
@@ -918,17 +918,17 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
|
||||
return true;
|
||||
}
|
||||
for (InterfaceType interface in element.mixins) {
|
||||
if (isOrInheritsImmutable(interface.element3, visited)) {
|
||||
if (isOrInheritsImmutable(interface.element, visited)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
for (InterfaceType mixin in element.interfaces) {
|
||||
if (isOrInheritsImmutable(mixin.element3, visited)) {
|
||||
if (isOrInheritsImmutable(mixin.element, visited)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (element.supertype != null) {
|
||||
return isOrInheritsImmutable(element.supertype!.element3, visited);
|
||||
return isOrInheritsImmutable(element.supertype!.element, visited);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
@@ -952,13 +952,13 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
|
||||
nonFinalFields = nonFinalInstanceFields(element);
|
||||
nonFinalFields = nonFinalFields.followedBy(
|
||||
element.mixins.expand(
|
||||
(InterfaceType mixin) => nonFinalInstanceFields(mixin.element3),
|
||||
(InterfaceType mixin) => nonFinalInstanceFields(mixin.element),
|
||||
),
|
||||
);
|
||||
if (element.supertype != null) {
|
||||
nonFinalFields = nonFinalFields.followedBy(
|
||||
definedOrInheritedNonFinalInstanceFields(
|
||||
element.supertype!.element3,
|
||||
element.supertype!.element,
|
||||
visited,
|
||||
),
|
||||
);
|
||||
@@ -1049,7 +1049,7 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
|
||||
// TODO(srawlins): Perhaps replace this with a getter on Element, like
|
||||
// `Element.hasOrInheritsSealed`?
|
||||
for (InterfaceType supertype in element.allSupertypes) {
|
||||
var superclass = supertype.element3;
|
||||
var superclass = supertype.element;
|
||||
if (superclass.metadata.hasSealed) {
|
||||
if (!currentPackageContains(superclass)) {
|
||||
if (element is MixinElement &&
|
||||
|
||||
@@ -145,7 +145,7 @@ class CovariantParametersVerifier {
|
||||
|
||||
var superMembers = <_SuperMember>[];
|
||||
for (var interface in interfaces) {
|
||||
var superMember = _correspondingMember(interface.element3, _thisMember);
|
||||
var superMember = _correspondingMember(interface.element, _thisMember);
|
||||
if (superMember != null) {
|
||||
superMembers.add(_SuperMember(interface, superMember));
|
||||
}
|
||||
|
||||
@@ -227,7 +227,7 @@ abstract class BaseDeprecatedMemberUseVerifier {
|
||||
} else if (node is MethodInvocation &&
|
||||
displayName == MethodElement.CALL_METHOD_NAME) {
|
||||
var invokeType = node.staticInvokeType as InterfaceType;
|
||||
var invokeClass = invokeType.element3;
|
||||
var invokeClass = invokeType.element;
|
||||
displayName = "${invokeClass.name3}.${element.displayName}";
|
||||
}
|
||||
var message = _deprecatedMessage(element, strictCasts: _strictCasts);
|
||||
|
||||
@@ -302,8 +302,8 @@ class ErrorHandlerVerifier {
|
||||
/// the 'dart:async' library.
|
||||
bool _isDartCoreAsyncType(DartType type, String typeName) =>
|
||||
type is InterfaceType &&
|
||||
type.element3.name3 == typeName &&
|
||||
type.element3.library2.isDartAsync;
|
||||
type.element.name3 == typeName &&
|
||||
type.element.library2.isDartAsync;
|
||||
}
|
||||
|
||||
/// Visits a function body, looking for return statements.
|
||||
|
||||
@@ -429,7 +429,7 @@ class _ClassVerifier {
|
||||
InterfaceTypeImpl type, {
|
||||
required int mixinIndex,
|
||||
}) {
|
||||
var libraryUri = type.element3.library2.uri;
|
||||
var libraryUri = type.element.library2.uri;
|
||||
for (var method in type.methods2) {
|
||||
_checkDeclaredMember(node, libraryUri, method, mixinIndex: mixinIndex);
|
||||
}
|
||||
@@ -456,7 +456,7 @@ class _ClassVerifier {
|
||||
if (type is! InterfaceType) {
|
||||
return false;
|
||||
}
|
||||
var typeElement = type.element3;
|
||||
var typeElement = type.element;
|
||||
|
||||
var classElement = this.classElement;
|
||||
if (typeElement is ClassElement &&
|
||||
@@ -612,26 +612,26 @@ class _ClassVerifier {
|
||||
// n-case
|
||||
var supertype = element.supertype;
|
||||
if (supertype != null &&
|
||||
_checkForRecursiveInterfaceInheritance(supertype.element3, path)) {
|
||||
_checkForRecursiveInterfaceInheritance(supertype.element, path)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
for (var type in element.mixins) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element3, path)) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (element is MixinElementImpl) {
|
||||
for (var type in element.superclassConstraints) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element3, path)) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (var type in element.interfaces) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element3, path)) {
|
||||
if (_checkForRecursiveInterfaceInheritance(type.element, path)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -730,7 +730,7 @@ class _ClassVerifier {
|
||||
return false;
|
||||
}
|
||||
|
||||
var interfaceElement = type.element3;
|
||||
var interfaceElement = type.element;
|
||||
if (interfaceElement is EnumElement ||
|
||||
interfaceElement is ExtensionTypeElement) {
|
||||
return false;
|
||||
@@ -750,20 +750,20 @@ class _ClassVerifier {
|
||||
/// Return the error code that should be used when the given class [element]
|
||||
/// references itself directly.
|
||||
DiagnosticCode _getRecursiveErrorCode(InterfaceElement element) {
|
||||
if (element.supertype?.element3 == classElement.asElement2) {
|
||||
if (element.supertype?.element == classElement.asElement2) {
|
||||
return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_EXTENDS;
|
||||
}
|
||||
|
||||
if (element is MixinElement) {
|
||||
for (var type in element.superclassConstraints) {
|
||||
if (type.element3 == classElement.asElement2) {
|
||||
if (type.element == classElement.asElement2) {
|
||||
return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_ON;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (var type in element.mixins) {
|
||||
if (type.element3 == classElement.asElement2) {
|
||||
if (type.element == classElement.asElement2) {
|
||||
return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_WITH;
|
||||
}
|
||||
}
|
||||
@@ -774,7 +774,7 @@ class _ClassVerifier {
|
||||
/// If [name] is not implemented in the extended concrete class, the
|
||||
/// issue should be fixed there, and then [classElement] will not have it too.
|
||||
bool _isNotImplementedInConcreteSuperClass(Name name) {
|
||||
var superElement = classElement.supertype?.element3;
|
||||
var superElement = classElement.supertype?.element;
|
||||
if (superElement is ClassElementImpl && !superElement.isAbstract) {
|
||||
var superInterface = inheritance.getInterface(superElement);
|
||||
return superInterface.map.containsKey(name);
|
||||
|
||||
@@ -150,7 +150,7 @@ class _TypeToConvert implements _ToConvert {
|
||||
addElementsFrom(parameter.type);
|
||||
}
|
||||
} else if (type is InterfaceType) {
|
||||
if (elements.add(type.element3)) {
|
||||
if (elements.add(type.element)) {
|
||||
for (var typeArgument in type.typeArguments) {
|
||||
addElementsFrom(typeArgument);
|
||||
}
|
||||
|
||||
@@ -100,11 +100,11 @@ class MustCallSuperVerifier {
|
||||
var superclasses = Queue<InterfaceElement?>();
|
||||
|
||||
void addToQueue(InterfaceElement element) {
|
||||
superclasses.addAll(element.mixins.map((i) => i.element3));
|
||||
superclasses.add(element.supertype?.element3);
|
||||
superclasses.addAll(element.mixins.map((i) => i.element));
|
||||
superclasses.add(element.supertype?.element);
|
||||
if (element is MixinElement) {
|
||||
superclasses.addAll(
|
||||
element.superclassConstraints.map((i) => i.element3),
|
||||
element.superclassConstraints.map((i) => i.element),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -204,7 +204,7 @@ extension on InterfaceType? {
|
||||
bool isConcrete(String name) {
|
||||
var self = this;
|
||||
if (self == null) return false;
|
||||
var element = self.element3;
|
||||
var element = self.element;
|
||||
|
||||
var library = element.library2 as LibraryElementImpl;
|
||||
var inheritanceManager = library.session.inheritanceManager;
|
||||
|
||||
@@ -48,7 +48,7 @@ class NullSafeApiVerifier {
|
||||
var targetType = node.realTarget?.staticType;
|
||||
if (targetType is! InterfaceTypeImpl) return;
|
||||
|
||||
var targetClass = targetType.element3;
|
||||
var targetClass = targetType.element;
|
||||
|
||||
if (targetClass.library2.isDartAsync == true &&
|
||||
targetClass.name3 == 'Completer' &&
|
||||
|
||||
@@ -312,8 +312,8 @@ class TypeArgumentsVerifier {
|
||||
typeParameters = alias.element2.typeParameters2;
|
||||
typeArguments = alias.typeArguments;
|
||||
} else if (type is InterfaceTypeImpl) {
|
||||
elementName = type.element3.name3;
|
||||
typeParameters = type.element3.typeParameters2;
|
||||
elementName = type.element.name3;
|
||||
typeParameters = type.element.typeParameters2;
|
||||
typeArguments = type.typeArguments;
|
||||
} else {
|
||||
return;
|
||||
@@ -681,7 +681,7 @@ class TypeArgumentsVerifier {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (namedType.type?.element3 is ExtensionTypeElement) {
|
||||
if (namedType.type?.element is ExtensionTypeElement) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user