diff --git a/lib/src/generator/templates.runtime_renderers.dart b/lib/src/generator/templates.runtime_renderers.dart index bff56ab78d..015b78d4a3 100644 --- a/lib/src/generator/templates.runtime_renderers.dart +++ b/lib/src/generator/templates.runtime_renderers.dart @@ -4605,6 +4605,58 @@ class _Renderer_Container extends RendererBase { ); }, ), + 'element': Property( + getValue: (CT_ c) => c.element, + renderVariable: + (CT_ c, Property self, List remainingNames) => + self.renderSimpleVariable(c, remainingNames, 'Element'), + + isNullValue: (CT_ c) => false, + + renderValue: ( + CT_ c, + RendererBase r, + List ast, + StringSink sink, + ) { + renderSimple( + c.element, + ast, + r.template, + sink, + parent: r, + getters: _invisibleGetters['Element']!, + ); + }, + ), + 'element2': Property( + getValue: (CT_ c) => c.element2, + renderVariable: + (CT_ c, Property self, List remainingNames) => + self.renderSimpleVariable( + c, + remainingNames, + 'Element2', + ), + + isNullValue: (CT_ c) => false, + + renderValue: ( + CT_ c, + RendererBase r, + List ast, + StringSink sink, + ) { + renderSimple( + c.element2, + ast, + r.template, + sink, + parent: r, + getters: _invisibleGetters['Element2']!, + ); + }, + ), 'enclosingElement': Property( getValue: (CT_ c) => c.enclosingElement, renderVariable: ( @@ -11886,6 +11938,34 @@ class _Renderer_InheritingContainer extends RendererBase { ); }, ), + 'element2': Property( + getValue: (CT_ c) => c.element2, + renderVariable: + (CT_ c, Property self, List remainingNames) => + self.renderSimpleVariable( + c, + remainingNames, + 'InterfaceElement2', + ), + + isNullValue: (CT_ c) => false, + + renderValue: ( + CT_ c, + RendererBase r, + List ast, + StringSink sink, + ) { + renderSimple( + c.element2, + ast, + r.template, + sink, + parent: r, + getters: _invisibleGetters['InterfaceElement2']!, + ); + }, + ), 'enclosingElement': Property( getValue: (CT_ c) => c.enclosingElement, renderVariable: ( @@ -14312,7 +14392,7 @@ class _Renderer_LibraryContainer extends RendererBase { } } -String renderLibrary(LibraryTemplateData context, Template template) { +String renderLibraryRedirect(LibraryTemplateData context, Template template) { var buffer = StringBuffer(); _render_LibraryTemplateData(context, template.ast, template, buffer); return buffer.toString(); @@ -14558,7 +14638,7 @@ class _Renderer_LibraryTemplateData extends RendererBase { } } -String renderLibraryRedirect(LibraryTemplateData context, Template template) { +String renderLibrary(LibraryTemplateData context, Template template) { var buffer = StringBuffer(); _render_LibraryTemplateData(context, template.ast, template, buffer); return buffer.toString(); @@ -26508,6 +26588,19 @@ const _invisibleGetters = { 'thisType', 'unnamedConstructor', }, + 'InterfaceElement2': { + 'allSupertypes', + 'constructors2', + 'firstFragment', + 'fragments', + 'hashCode', + 'interfaces', + 'mixins', + 'runtimeType', + 'supertype', + 'thisType', + 'unnamedConstructor2', + }, 'Iterable': { 'first', 'hashCode', diff --git a/lib/src/model/class.dart b/lib/src/model/class.dart index 10263d222c..80a0f2a183 100644 --- a/lib/src/model/class.dart +++ b/lib/src/model/class.dart @@ -2,8 +2,6 @@ // for details. All rights reserved. Use of this source code is governed by a // BSD-style license that can be found in the LICENSE file. -// ignore_for_file: analyzer_use_new_elements - import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/element2.dart'; // ignore: implementation_imports @@ -20,10 +18,11 @@ import 'package:dartdoc/src/model/model.dart'; /// **inherited**: Filtered getters giving only inherited children. class Class extends InheritingContainer with Constructable, MixedInTypes { @override - final ClassElement element; + // ignore: analyzer_use_new_elements + ClassElement get element => element2.asElement; @override - ClassElement2 get element2 => element.asElement2; + final ClassElement2 element2; @override late final List allModelElements = [ @@ -51,10 +50,10 @@ class Class extends InheritingContainer with Constructable, MixedInTypes { ...interfaceElements.expandInheritanceChain, ]; - Class(this.element, Library library, PackageGraph packageGraph) + Class(this.element2, Library library, PackageGraph packageGraph) : super(library, packageGraph) { - if (element.name == 'Object' && - library.element.name == 'dart.core' && + if (element2.name3 == 'Object' && + library.element2.name3 == 'dart.core' && package.name == 'Dart') { packageGraph.objectClass = this; } @@ -64,32 +63,31 @@ class Class extends InheritingContainer with Constructable, MixedInTypes { String get fileName => '$name-class.html'; @override - bool get isAbstract => element.isAbstract; + bool get isAbstract => element2.isAbstract; @override - bool get isBase => element.isBase && !element.isSealed; + bool get isBase => element2.isBase && !element2.isSealed; bool get isErrorOrException { - bool isError(InterfaceElement element) => - element.library.isDartCore && - (element.name == 'Exception' || element.name == 'Error'); + bool isError(InterfaceElement2 e) => + e.library2.isDartCore && (e.name3 == 'Exception' || e.name3 == 'Error'); - final element = this.element; - if (isError(element)) return true; - return element.allSupertypes.map((t) => t.element).any(isError); + if (isError(element2)) return true; + return element2.allSupertypes.map((t) => t.element3).any(isError); } @override - bool get isFinal => element.isFinal && !element.isSealed; + bool get isFinal => element2.isFinal && !element2.isSealed; @override - bool get isImplementableInterface => element.isInterface && !element.isSealed; + bool get isImplementableInterface => + element2.isInterface && !element2.isSealed; @override - bool get isMixinClass => element.isMixinClass; + bool get isMixinClass => element2.isMixinClass; @override - bool get isSealed => element.isSealed; + bool get isSealed => element2.isSealed; @override Kind get kind => Kind.class_; diff --git a/lib/src/model/container.dart b/lib/src/model/container.dart index e0910ae2f3..40936563db 100644 --- a/lib/src/model/container.dart +++ b/lib/src/model/container.dart @@ -1,11 +1,12 @@ // Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file // for details. All rights reserved. Use of this source code is governed by a // BSD-style license that can be found in the LICENSE file. -// ignore_for_file: analyzer_use_new_elements import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/element2.dart'; import 'package:analyzer/dart/element/scope.dart'; +// ignore: implementation_imports +import 'package:analyzer/src/utilities/extensions/element.dart'; import 'package:dartdoc/src/model/comment_referable.dart'; import 'package:dartdoc/src/model/model.dart'; import 'package:dartdoc/src/model_utils.dart' as model_utils; @@ -33,6 +34,13 @@ abstract class Container extends ModelElement with Categorization, TypeParameters { Container(super.library, super.packageGraph); + @override + // ignore: analyzer_use_new_elements + Element get element => element2.asElement!; + + @override + Element2 get element2; + // TODO(jcollins-g): Implement a ContainerScope that flattens supertypes? @override Scope? get scope => null; @@ -40,20 +48,20 @@ abstract class Container extends ModelElement @override bool get hasParameters => false; - bool get isExtension => element is ExtensionElement; + bool get isExtension => element2 is ExtensionElement2; /// Whether this is an enum. - bool get isEnum => element is EnumElement; + bool get isEnum => element2 is EnumElement2; /// Whether this is an interface (e.g. class, enum, mixin, or extension type). - bool get isInterface => element is InterfaceElement; + bool get isInterface => element2 is InterfaceElement2; /// Whether this is a mixin. - bool get isMixin => element is MixinElement; + bool get isMixin => element2 is MixinElement2; /// Whether this container represents the Object class from 'dart:core'. bool get isDartCoreObject => - element.name == 'Object' && element.library?.name == 'dart.core'; + element2.name3 == 'Object' && element2.library2?.name3 == 'dart.core'; /// The model elements of all of the members of this container, including /// declared and inherited ones. @@ -157,16 +165,9 @@ abstract class Container extends ModelElement /// This container might be canonical for elements it does not contain. /// See [Inheritable.canonicalEnclosingContainer]. - bool containsElement(Element? element) => _allElements.contains(element); - - /// This container might be canonical for elements it does not contain. - /// See [Inheritable.canonicalEnclosingContainer]. - bool containsElement2(Element2? element) => _allElements2.contains(element); - - late final Set _allElements = - allModelElements.map((e) => e.element).toSet(); + bool containsElement(Element2? element) => _allElements.contains(element); - late final Set _allElements2 = + late final Set _allElements = allModelElements.map((e) => e.element2).toSet(); bool get hasPublicStaticFields => staticFields.any((e) => e.isPublic); diff --git a/lib/src/model/inheritable.dart b/lib/src/model/inheritable.dart index 313e6f23d5..0ee4af4ca3 100644 --- a/lib/src/model/inheritable.dart +++ b/lib/src/model/inheritable.dart @@ -61,7 +61,7 @@ mixin Inheritable on ContainerMember { var reverseInheritance = _inheritance.reversed.toList(); for (var i = 0; i < reverseInheritance.length; i++) { var container = reverseInheritance[i]; - if (container.containsElement2(searchElement)) { + if (container.containsElement(searchElement)) { var previousIsHiddenAndNotDefining = i > 0 && _isHiddenInterface(reverseInheritance[i - 1]) && container != definingEnclosingContainer; @@ -95,7 +95,7 @@ mixin Inheritable on ContainerMember { // starting from the ModelElement. if (canonicalContainer != null) { assert(canonicalContainer.isCanonical); - assert(canonicalContainer.containsElement2(searchElement)); + assert(canonicalContainer.containsElement(searchElement)); found = canonicalContainer; break; } diff --git a/lib/src/model/inheriting_container.dart b/lib/src/model/inheriting_container.dart index fc4a7e96c9..7cd552fc86 100644 --- a/lib/src/model/inheriting_container.dart +++ b/lib/src/model/inheriting_container.dart @@ -2,10 +2,11 @@ // for details. All rights reserved. Use of this source code is governed by a // BSD-style license that can be found in the LICENSE file. -// ignore_for_file: analyzer_use_new_elements - import 'package:analyzer/dart/element/element.dart'; +import 'package:analyzer/dart/element/element2.dart'; import 'package:analyzer/dart/element/type.dart'; +// ignore: implementation_imports +import 'package:analyzer/src/utilities/extensions/element.dart'; import 'package:collection/collection.dart' show IterableExtension; import 'package:dartdoc/src/element_type.dart'; import 'package:dartdoc/src/model/comment_referable.dart'; @@ -21,8 +22,8 @@ import 'package:meta/meta.dart'; /// Note that [Constructor]s are not considered to be modifiers so a /// [hasModifiers] override is not necessary for this mixin. mixin Constructable implements InheritingContainer { - late final List constructors = element.constructors - .map((e) => getModelFor(e, library) as Constructor) + late final List constructors = element2.constructors2 + .map((e) => getModelFor2(e, library) as Constructor) .toList(growable: false); @override @@ -73,9 +74,9 @@ abstract class InheritingContainer extends Container { InheritingContainer(super.library, super.packageGraph); DefinedElementType? get supertype { - final elementSupertype = element.supertype; + final elementSupertype = element2.supertype; return elementSupertype == null || - elementSupertype.element.supertype == null + elementSupertype.element3.supertype == null ? null : getTypeFor(elementSupertype, library) as DefinedElementType; } @@ -102,36 +103,37 @@ abstract class InheritingContainer extends Container { ]; Iterable get inheritedMethods { - var methodNames = declaredMethods.map((m) => m.element.name).toSet(); + var methodNames = declaredMethods.map((m) => m.element2.name3).toSet(); var inheritedMethodElements = _inheritedElements - .whereType() + .whereType() .where((e) => !e.isOperator && - e is! PropertyAccessorElement && - !methodNames.contains(e.name)) + e is! PropertyAccessorElement2 && + !methodNames.contains(e.name3)) .toSet(); return [ for (var e in inheritedMethodElements) - getModelFor(e, library, enclosingContainer: this) as Method, + getModelFor2(e, library, enclosingContainer: this) as Method, ]; } List get inheritedOperators { - var operatorNames = declaredOperators.map((o) => o.element.name).toSet(); + var operatorNames = + declaredOperators.map((o) => o.element2.lookupName).toSet(); var inheritedOperatorElements = _inheritedElements - .whereType() - .where((e) => e.isOperator && !operatorNames.contains(e.name)) + .whereType() + .where((e) => e.isOperator && !operatorNames.contains(e.lookupName)) .toSet(); return [ for (var e in inheritedOperatorElements) - getModelFor(e, library, enclosingContainer: this) as Operator, + getModelFor2(e, library, enclosingContainer: this) as Operator, ]; } late final DefinedElementType modelType = - getTypeFor(element.thisType, library) as DefinedElementType; + getTypeFor(element2.thisType, library) as DefinedElementType; /// A list of the inherited executable elements, one element per inherited /// `Name`. @@ -140,23 +142,23 @@ abstract class InheritingContainer extends Container { /// _this_ element are preferred over elements that are further away. In the /// case of ties, concrete inherited elements are prefered to non-concrete /// ones. - late final List _inheritedElements = () { - if (element case ClassElement classElement + late final List _inheritedElements = () { + if (element2 case ClassElement2 classElement when classElement.isDartCoreObject) { - return const []; + return const []; } // The mapping of all of the inherited element names to their _concrete_ // implementation element. var concreteInheritanceMap = - packageGraph.inheritanceManager.getInheritedConcreteMap2(element); + packageGraph.inheritanceManager.getInheritedConcreteMap(element2); // The mapping of all inherited element names to the nearest inherited // element that they resolve to. var inheritanceMap = - packageGraph.inheritanceManager.getInheritedMap2(element); + packageGraph.inheritanceManager.getInheritedMap(element2); var inheritanceChainElements = - inheritanceChain.map((c) => c.element).toList(growable: false); + inheritanceChain.map((c) => c.element2).toList(growable: false); // A combined map of names to inherited _concrete_ Elements, and other // inherited Elements. @@ -175,7 +177,7 @@ abstract class InheritingContainer extends Container { // Elements in the inheritance chain starting from `this.element` up to, // but not including, `Object`. var enclosingElement = - inheritedElement.enclosingElement3 as InterfaceElement; + inheritedElement.enclosingElement2 as InterfaceElement2; assert(inheritanceChainElements.contains(enclosingElement) || enclosingElement.isDartCoreObject); @@ -185,7 +187,7 @@ abstract class InheritingContainer extends Container { // accounts for intermediate abstract classes that have method/field // implementations. var enclosingElementFromCombined = - combinedMapElement.enclosingElement3 as InterfaceElement; + combinedMapElement.enclosingElement2 as InterfaceElement2; if (inheritanceChainElements.indexOf(enclosingElementFromCombined) < inheritanceChainElements.indexOf(enclosingElement)) { combinedMap[name.name] = inheritedElement; @@ -200,7 +202,7 @@ abstract class InheritingContainer extends Container { /// All fields defined on this container, _including inherited fields_. late List allFields = () { var inheritedAccessorElements = { - ..._inheritedElements.whereType() + ..._inheritedElements.whereType() }; // This structure keeps track of inherited accessors, allowing lookup @@ -210,10 +212,11 @@ abstract class InheritingContainer extends Container { // `.firstWhereOrNull((e) => e.isGetter)` and // `.firstWhereOrNull((e) => e.isSetter)` calls, which would be much simpler // if we used some sort of "pair" class instead. - var accessorMap = >{}; + var accessorMap = >{}; for (var accessorElement in inheritedAccessorElements) { accessorMap - .putIfAbsent(accessorElement.name.replaceFirst('=', ''), () => []) + .putIfAbsent( + accessorElement.name3?.replaceFirst('=', '') ?? '', () => []) .add(accessorElement); } @@ -222,27 +225,29 @@ abstract class InheritingContainer extends Container { // For half-inherited fields, the analyzer only links the non-inherited // to the [FieldElement]. Compose our [Field] class by hand by looking up // inherited accessors that may be related. - for (var field in element.fields) { - var getterElement = field.getter; - if (getterElement == null && accessorMap.containsKey(field.name)) { - getterElement = - accessorMap[field.name]!.firstWhereOrNull((e) => e.isGetter); + for (var field in element2.fields2) { + var getterElement = field.getter2; + if (getterElement == null && accessorMap.containsKey(field.name3)) { + getterElement = accessorMap[field.name3]! + .firstWhereOrNull((e) => e is GetterElement) as GetterElement?; } - var setterElement = field.setter; - if (setterElement == null && accessorMap.containsKey(field.name)) { - setterElement = - accessorMap[field.name]!.firstWhereOrNull((e) => e.isSetter); + var setterElement = field.setter2; + if (setterElement == null && accessorMap.containsKey(field.name3)) { + setterElement = accessorMap[field.name3]! + .firstWhereOrNull((e) => e is SetterElement) as SetterElement?; } fields.add(_createSingleField( getterElement, setterElement, inheritedAccessorElements, field)); - accessorMap.remove(field.name); + accessorMap.remove(field.name3); } // Now we only have inherited accessors who aren't associated with // anything in the fields. accessorMap.forEach((fieldName, elements) { - final getterElement = elements.firstWhereOrNull((e) => e.isGetter); - final setterElement = elements.firstWhereOrNull((e) => e.isSetter); + final getterElement = + elements.firstWhereOrNull((e) => e is GetterElement); + final setterElement = + elements.firstWhereOrNull((e) => e is SetterElement); fields.add(_createSingleField( getterElement, setterElement, inheritedAccessorElements)); }); @@ -251,15 +256,15 @@ abstract class InheritingContainer extends Container { }(); @override - late final List declaredMethods = element.methods - .map((e) => getModelFor(e, library) as Method) + late final List declaredMethods = element2.methods2 + .map((e) => getModelFor2(e, library) as Method) .toList(growable: false); @override - late final List typeParameters = element.typeParameters - .map((typeParameter) => getModelFor( + late final List typeParameters = element2.typeParameters2 + .map((typeParameter) => getModelFor2( typeParameter, - getModelForElement(typeParameter.enclosingElement3!.library!) + getModelForElement2(typeParameter.enclosingElement2!.library2!) as Library) as TypeParameter) .toList(growable: false); @@ -290,10 +295,15 @@ abstract class InheritingContainer extends Container { /// The [InheritingContainer] with the library in which [element] is defined. InheritingContainer get definingContainer => - getModelFor(element, library) as InheritingContainer; + getModelFor2(element2, library) as InheritingContainer; + + @override + + // ignore: analyzer_use_new_elements + InterfaceElement get element => element2.asElement; @override - InterfaceElement get element; + InterfaceElement2 get element2; @override Library get enclosingElement => library; @@ -343,8 +353,8 @@ abstract class InheritingContainer extends Container { List get _extensionInstanceFields => [ for (var extension in potentiallyApplicableExtensionsSorted) for (var field in extension.instanceFields) - getModelForPropertyInducingElement( - field.element, + getModelForPropertyInducingElement2( + field.element2, library, enclosingContainer: extension, getter: field.getter, @@ -367,8 +377,8 @@ abstract class InheritingContainer extends Container { List get _extensionInstanceMethods => [ for (var extension in potentiallyApplicableExtensionsSorted) for (var method in extension.instanceMethods) - getModelFor(method.element, library, enclosingContainer: extension) - as Method, + getModelFor2(method.element2, library, + enclosingContainer: extension) as Method, ]; @override @@ -384,7 +394,7 @@ abstract class InheritingContainer extends Container { List get _extensionInstanceOperators => [ for (var extension in potentiallyApplicableExtensionsSorted) for (var operator in extension.instanceOperators) - getModelFor(operator.element, library, + getModelFor2(operator.element2, library, enclosingContainer: extension) as Operator, ]; @@ -422,7 +432,7 @@ abstract class InheritingContainer extends Container { @visibleForTesting late final List directInterfaces = [ - for (var interface in element.interfaces) + for (var interface in element2.interfaces) getTypeFor(interface, library) as DefinedElementType ]; @@ -484,7 +494,7 @@ abstract class InheritingContainer extends Container { /// and so unlike other `public*` methods, is not a strict subset of /// [directInterfaces] (the direct interfaces). List get publicInterfaces { - var interfaceElements = {}; + var interfaceElements = {}; var interfaces = []; // Only interfaces with unique elements should be returned. Elements can @@ -493,8 +503,8 @@ abstract class InheritingContainer extends Container { // implements `EfficientLengthIterable` which implements `Iterable`), // but there is no chance of type arguments differing, as that is illegal. void addInterfaceIfUnique(DefinedElementType type) { - var firstPublicSuperElement = type.modelElement.element; - if (firstPublicSuperElement is InterfaceElement) { + var firstPublicSuperElement = type.modelElement.element2; + if (firstPublicSuperElement is InterfaceElement2) { if (interfaceElements.add(firstPublicSuperElement)) { interfaces.add(type); } @@ -585,21 +595,22 @@ abstract class InheritingContainer extends Container { /// Creates a single Field. /// - /// If [field] is not specified, picks the [FieldElement] from the - /// [PropertyAccessorElement] whose enclosing class inherits from the other + /// If [field] is not specified, picks the [FieldElement2] from the + /// [PropertyAccessorElement2] whose enclosing class inherits from the other /// (defaulting to the getter) and constructs a [Field] using that. Field _createSingleField( - PropertyAccessorElement? getterElement, - PropertyAccessorElement? setterElement, - Set inheritedAccessors, - [FieldElement? field]) { + PropertyAccessorElement2? getterElement, + PropertyAccessorElement2? setterElement, + Set inheritedAccessors, + [FieldElement2? field]) { // Return a [ContainerAccessor] with `isInherited = true` if [element] is // in [inheritedAccessors]. - ContainerAccessor? containerAccessorFrom(PropertyAccessorElement? element) { + ContainerAccessor? containerAccessorFrom( + PropertyAccessorElement2? element) { if (element == null) return null; final enclosingContainer = inheritedAccessors.contains(element) ? this : null; - return getModelFor(element, library, + return getModelFor2(element, library, enclosingContainer: enclosingContainer) as ContainerAccessor; } @@ -607,16 +618,16 @@ abstract class InheritingContainer extends Container { var setter = containerAccessorFrom(setterElement); // Rebind [getterElement], [setterElement] as [ModelElement.from] can // resolve [Member]s. - getterElement = getter?.element; - setterElement = setter?.element; + getterElement = getter?.element2; + setterElement = setter?.element2; assert(getter != null || setter != null); if (field == null) { // Pick an appropriate [FieldElement] to represent this element. // Only hard when dealing with a synthetic [Field]. if (getter != null && setter == null) { - field = getterElement!.variable2 as FieldElement; + field = getterElement!.variable3 as FieldElement2; } else if (getter == null && setter != null) { - field = setterElement!.variable2 as FieldElement; + field = setterElement!.variable3 as FieldElement2; } else { // In this case: `getter != null && setter != null`. getter!; @@ -629,9 +640,9 @@ abstract class InheritingContainer extends Container { if (setterEnclosingElement is Class && setterEnclosingElement._isInheritingFrom( getter.enclosingElement as InheritingContainer)) { - field = setterElement!.variable2 as FieldElement; + field = setterElement!.variable3 as FieldElement2; } else { - field = getterElement!.variable2 as FieldElement; + field = getterElement!.variable3 as FieldElement2; } } } @@ -639,14 +650,14 @@ abstract class InheritingContainer extends Container { if ((getter == null || getter.isInherited) && (setter == null || setter.isInherited)) { // Field is 100% inherited. - return getModelForPropertyInducingElement(field, library, + return getModelForPropertyInducingElement2(field, library, getter: getter, setter: setter, enclosingContainer: this) as Field; } else { // Field is <100% inherited (could be half-inherited). // TODO(jcollins-g): Navigation is probably still confusing for // half-inherited fields when traversing the inheritance tree. Make // this better, somehow. - return getModelForPropertyInducingElement(field, library, + return getModelForPropertyInducingElement2(field, library, getter: getter, setter: setter) as Field; } } @@ -659,7 +670,7 @@ abstract class InheritingContainer extends Container { /// Add the ability to support mixed-in types to an [InheritingContainer]. mixin MixedInTypes on InheritingContainer { - late final List mixedInTypes = element.mixins + late final List mixedInTypes = element2.mixins .map((f) => getTypeFor(f, library) as DefinedElementType) .toList(growable: false); @@ -672,8 +683,9 @@ mixin MixedInTypes on InheritingContainer { mixedInTypes.wherePublic; } -extension on InterfaceElement { - bool get isDartCoreObject => name == 'Object' && library.name == 'dart.core'; +extension on InterfaceElement2 { + bool get isDartCoreObject => + name3 == 'Object' && library2.name3 == 'dart.core'; } extension DefinedElementTypeIterableExtension on Iterable { diff --git a/lib/src/model/model_element.dart b/lib/src/model/model_element.dart index 8f08c9e232..eaba6ddfda 100644 --- a/lib/src/model/model_element.dart +++ b/lib/src/model/model_element.dart @@ -169,8 +169,8 @@ abstract class ModelElement 'Enum $e (${e.runtimeType}) does not have a constant value.'); } var index = constantIndex.toIntValue()!; - newModelElement = - EnumField.forConstant(index, e.asElement2, library, packageGraph, getter); + newModelElement = EnumField.forConstant( + index, e.asElement2, library, packageGraph, getter); } else if (e.enclosingElement3 is ExtensionElement) { newModelElement = Field(e, library, packageGraph, getter as ContainerAccessor?, setter as ContainerAccessor?); @@ -272,9 +272,9 @@ abstract class ModelElement factory ModelElement.for2_( Element2 e, Library library, PackageGraph packageGraph, {Container? enclosingContainer}) { - return ModelElement.for_(e.asElement!, library, packageGraph, - enclosingContainer: enclosingContainer); - } + return ModelElement.for_(e.asElement!, library, packageGraph, + enclosingContainer: enclosingContainer); + } /// Caches a newly-created [ModelElement] from [ModelElement.for_] or /// [ModelElement.forPropertyInducingElement]. @@ -309,13 +309,14 @@ abstract class ModelElement PrefixElement() => Prefix(e.asElement2, library, packageGraph), EnumElement() => Enum(e.asElement2, library, packageGraph), MixinElement() => Mixin(e.asElement2, library, packageGraph), - ClassElement() => Class(e, library, packageGraph), + ClassElement() => Class(e.asElement2, library, packageGraph), ExtensionElement() => Extension(e.asElement2, library, packageGraph), ExtensionTypeElement() => ExtensionType(e, library, packageGraph), - FunctionElement() => ModelFunction(e.asElement2 as TopLevelFunctionElement, library, packageGraph), + FunctionElement() => ModelFunction( + e.asElement2 as TopLevelFunctionElement, library, packageGraph), ConstructorElement() => Constructor(e, library, packageGraph), - GenericFunctionTypeElement() => - ModelFunctionTypedef(e.asElement2 as FunctionTypedElement2, library, packageGraph), + GenericFunctionTypeElement() => ModelFunctionTypedef( + e.asElement2 as FunctionTypedElement2, library, packageGraph), TypeAliasElement(aliasedType: FunctionType()) => FunctionTypedef(e.asElement2, library, packageGraph), TypeAliasElement()