diff --git a/lib/src/generator/templates.runtime_renderers.dart b/lib/src/generator/templates.runtime_renderers.dart index 97c5089aad..e2069f515c 100644 --- a/lib/src/generator/templates.runtime_renderers.dart +++ b/lib/src/generator/templates.runtime_renderers.dart @@ -20472,6 +20472,34 @@ class _Renderer_Parameter extends RendererBase { ); }, ), + 'element2': Property( + getValue: (CT_ c) => c.element2, + renderVariable: + (CT_ c, Property self, List remainingNames) => + self.renderSimpleVariable( + c, + remainingNames, + 'FormalParameterElement', + ), + + isNullValue: (CT_ c) => false, + + renderValue: ( + CT_ c, + RendererBase r, + List ast, + StringSink sink, + ) { + renderSimple( + c.element2, + ast, + r.template, + sink, + parent: r, + getters: _invisibleGetters['FormalParameterElement']!, + ); + }, + ), 'enclosingElement': Property( getValue: (CT_ c) => c.enclosingElement, renderVariable: ( @@ -26105,6 +26133,28 @@ const _invisibleGetters = { 'runtimeType', }, 'File': {'hashCode', 'lengthSync', 'modificationStamp', 'runtimeType'}, + 'FormalParameterElement': { + 'baseElement', + 'defaultValueCode', + 'firstFragment', + 'formalParameters', + 'fragments', + 'hasDefaultValue', + 'hashCode', + 'isCovariant', + 'isInitializingFormal', + 'isNamed', + 'isOptional', + 'isOptionalNamed', + 'isOptionalPositional', + 'isPositional', + 'isRequired', + 'isRequiredNamed', + 'isRequiredPositional', + 'isSuperFormal', + 'runtimeType', + 'typeParameters2', + }, 'FunctionElement': { 'augmentation', 'augmentationTarget', diff --git a/lib/src/model/container.dart b/lib/src/model/container.dart index 7e6040535e..e0910ae2f3 100644 --- a/lib/src/model/container.dart +++ b/lib/src/model/container.dart @@ -4,6 +4,7 @@ // 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'; import 'package:dartdoc/src/model/comment_referable.dart'; import 'package:dartdoc/src/model/model.dart'; @@ -158,9 +159,16 @@ abstract class Container extends ModelElement /// 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(); + late final Set _allElements2 = + allModelElements.map((e) => e.element2).toSet(); + bool get hasPublicStaticFields => staticFields.any((e) => e.isPublic); List get publicStaticFieldsSorted => diff --git a/lib/src/model/inheritable.dart b/lib/src/model/inheritable.dart index 3a55647aa3..313e6f23d5 100644 --- a/lib/src/model/inheritable.dart +++ b/lib/src/model/inheritable.dart @@ -2,9 +2,7 @@ // 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:collection/collection.dart' show IterableExtension; import 'package:dartdoc/src/model/attribute.dart'; import 'package:dartdoc/src/model/comment_referable.dart'; @@ -16,7 +14,7 @@ import 'package:dartdoc/src/model/model.dart'; /// We can search the inheritance chain between this instance and /// [definingEnclosingContainer] in [Inheritable.canonicalEnclosingContainer], /// for the canonical [Class] closest to where this member was defined. We -/// can then know that when we find [Inheritable.element] inside that [Class]'s +/// can then know that when we find [Inheritable.element2] inside that [Class]'s /// namespace, that's the one we should treat as canonical and implementors of /// this class can use that knowledge to determine canonicalization. /// @@ -51,19 +49,19 @@ mixin Inheritable on ContainerMember { ?.allCanonicalModelElements .firstWhereOrNull((m) => m.name == name && - m is PropertyAccessorElement == this is PropertyAccessorElement); + m is PropertyAccessorElement2 == this is PropertyAccessorElement2); @override Container? computeCanonicalEnclosingContainer() { if (isInherited) { - var searchElement = element.declaration; + var searchElement = element2.baseElement; // TODO(jcollins-g): generate warning if an inherited element's definition // is in an intermediate non-canonical class in the inheritance chain? Container? found; var reverseInheritance = _inheritance.reversed.toList(); for (var i = 0; i < reverseInheritance.length; i++) { var container = reverseInheritance[i]; - if (container.containsElement(searchElement)) { + if (container.containsElement2(searchElement)) { var previousIsHiddenAndNotDefining = i > 0 && _isHiddenInterface(reverseInheritance[i - 1]) && container != definingEnclosingContainer; @@ -97,7 +95,7 @@ mixin Inheritable on ContainerMember { // starting from the ModelElement. if (canonicalContainer != null) { assert(canonicalContainer.isCanonical); - assert(canonicalContainer.containsElement(searchElement)); + assert(canonicalContainer.containsElement2(searchElement)); found = canonicalContainer; break; } @@ -125,8 +123,8 @@ mixin Inheritable on ContainerMember { /// implementation. bool _isHiddenInterface(Container? c) => c != null && - c.element.name == 'Interceptor' && - c.element.library?.name == '_interceptors'; + c.element2.name3 == 'Interceptor' && + c.element2.library2?.name3 == '_interceptors'; /// A roughly ordered list of this element's enclosing container's inheritance /// chain. diff --git a/lib/src/model/model_element.dart b/lib/src/model/model_element.dart index 4067917c02..d4d7cf29ce 100644 --- a/lib/src/model/model_element.dart +++ b/lib/src/model/model_element.dart @@ -252,7 +252,7 @@ abstract class ModelElement } if (e.kind == ElementKind.NEVER) { return packageGraph.allConstructedModelElements[key] = - NeverType(e, packageGraph); + NeverType(e.asElement2!, packageGraph); } var newModelElement = ModelElement._constructFromElementDeclaration( @@ -299,7 +299,7 @@ abstract class ModelElement }) { return switch (e) { LibraryElement() => packageGraph.findButDoNotCreateLibraryFor(e)!, - PrefixElement() => Prefix(e, library, packageGraph), + PrefixElement() => Prefix(e.asElement2, library, packageGraph), EnumElement() => Enum(e, library, packageGraph), MixinElement() => Mixin(e, library, packageGraph), ClassElement() => Class(e, library, packageGraph), @@ -310,12 +310,13 @@ abstract class ModelElement GenericFunctionTypeElement() => ModelFunctionTypedef(e, library, packageGraph), TypeAliasElement(aliasedType: FunctionType()) => - FunctionTypedef(e, library, packageGraph), + FunctionTypedef(e.asElement2, library, packageGraph), TypeAliasElement() when e.aliasedType.documentableElement2.asElement is InterfaceElement => - ClassTypedef(e, library, packageGraph), - TypeAliasElement() => GeneralizedTypedef(e, library, packageGraph), + ClassTypedef(e.asElement2, library, packageGraph), + TypeAliasElement() => + GeneralizedTypedef(e.asElement2, library, packageGraph), MethodElement(isOperator: true) when enclosingContainer == null => Operator(e.asElement2, library, packageGraph), MethodElement(isOperator: true) @@ -334,7 +335,7 @@ abstract class ModelElement MethodElement(isOperator: false) => Method.inherited( e.asElement2, enclosingContainer, library, packageGraph, originalMember: originalMember as ExecutableMember?), - ParameterElement() => Parameter(e, library, packageGraph, + ParameterElement() => Parameter(e.asElement2, library, packageGraph, originalMember: originalMember as ParameterMember?), PropertyAccessorElement() => _constructFromPropertyAccessor( e, diff --git a/lib/src/model/never.dart b/lib/src/model/never.dart index 8dd01a1e8e..af36c14c8e 100644 --- a/lib/src/model/never.dart +++ b/lib/src/model/never.dart @@ -2,18 +2,23 @@ // 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 +import 'package:analyzer/src/utilities/extensions/element.dart'; import 'package:dartdoc/src/model/comment_referable.dart'; import 'package:dartdoc/src/model/kind.dart'; import 'package:dartdoc/src/model/model.dart'; class NeverType extends ModelElement with HasNoPage { @override - final Element element; + // ignore: analyzer_use_new_elements + Element get element => element2.asElement!; + + @override + final Element2 element2; - NeverType(this.element, PackageGraph packageGraph) + NeverType(this.element2, PackageGraph packageGraph) : super(Library.sentinel, packageGraph); /// `Never` is not a real object, and so we can't document it, so there diff --git a/lib/src/model/parameter.dart b/lib/src/model/parameter.dart index c1b4987fac..59ba4f4a1b 100644 --- a/lib/src/model/parameter.dart +++ b/lib/src/model/parameter.dart @@ -2,11 +2,12 @@ // 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 import 'package:analyzer/src/dart/element/member.dart' show ParameterMember; +// ignore: implementation_imports +import 'package:analyzer/src/utilities/extensions/element.dart'; import 'package:dartdoc/src/element_type.dart'; import 'package:dartdoc/src/model/comment_referable.dart'; import 'package:dartdoc/src/model/kind.dart'; @@ -14,24 +15,29 @@ import 'package:dartdoc/src/model/model.dart'; class Parameter extends ModelElement with HasNoPage { @override - final ParameterElement element; + // ignore: analyzer_use_new_elements + ParameterElement get element => element2.asElement; - Parameter(this.element, super.library, super.packageGraph, + @override + final FormalParameterElement element2; + + Parameter(this.element2, super.library, super.packageGraph, {ParameterMember? super.originalMember}); - String? get defaultValue => hasDefaultValue ? element.defaultValueCode : null; + String? get defaultValue => + hasDefaultValue ? element2.defaultValueCode : null; @override ModelElement? get enclosingElement { - final enclosingElement = element.enclosingElement3; + final enclosingElement = element2.enclosingElement2; return enclosingElement == null ? null - : getModelFor(enclosingElement, library); + : getModelFor2(enclosingElement, library); } bool get hasDefaultValue { - return element.defaultValueCode != null && - element.defaultValueCode!.isNotEmpty; + return element2.defaultValueCode != null && + element2.defaultValueCode!.isNotEmpty; } @override @@ -39,19 +45,22 @@ class Parameter extends ModelElement with HasNoPage { @override String get htmlId { - final enclosingElement = element.enclosingElement3; + final enclosingElement = element2.enclosingElement2; if (enclosingElement == null) { return 'param-$name'; } - var enclosingName = enclosingElement.name; - if (enclosingElement is GenericFunctionTypeElement) { + var enclosingName = enclosingElement.lookupName; + if (enclosingName == 'new') { + enclosingName = ''; + } + if (enclosingElement is GenericFunctionTypeElement2) { // TODO(jcollins-g): Drop when GenericFunctionTypeElement populates // name. Also, allowing null here is allowed as a workaround for // dart-lang/sdk#32005. - for (Element e = enclosingElement; - e.enclosingElement3 != null; - e = e.enclosingElement3!) { - enclosingName = e.name; + for (Element2 e = enclosingElement; + e.enclosingElement2 != null; + e = e.enclosingElement2!) { + enclosingName = e.lookupName; if (enclosingName != null && enclosingName.isNotEmpty) break; } } @@ -59,22 +68,22 @@ class Parameter extends ModelElement with HasNoPage { } @override - int get hashCode => element.hashCode; + int get hashCode => element2.hashCode; @override bool operator ==(Object other) => - other is Parameter && (element.type == other.element.type); + other is Parameter && (element2.type == other.element2.type); - bool get isCovariant => element.isCovariant; + bool get isCovariant => element2.isCovariant; - bool get isRequiredPositional => element.isRequiredPositional; + bool get isRequiredPositional => element2.isRequiredPositional; - bool get isNamed => element.isNamed; + bool get isNamed => element2.isNamed; - bool get isOptionalPositional => element.isOptionalPositional; + bool get isOptionalPositional => element2.isOptionalPositional; /// Only true if this is a required named parameter. - bool get isRequiredNamed => element.isRequiredNamed; + bool get isRequiredNamed => element2.isRequiredNamed; @override Kind get kind => Kind.parameter; @@ -102,5 +111,5 @@ class Parameter extends ModelElement with HasNoPage { super.originalMember as ParameterMember?; late final ElementType modelType = - getTypeFor((originalMember ?? element).type, library); + getTypeFor((originalMember ?? element2).type, library); } diff --git a/lib/src/model/prefix.dart b/lib/src/model/prefix.dart index 2033dc4270..b277b78531 100644 --- a/lib/src/model/prefix.dart +++ b/lib/src/model/prefix.dart @@ -2,41 +2,53 @@ // 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/kind.dart'; import 'package:dartdoc/src/model/model.dart'; -/// Represents a [PrefixElement] for dartdoc. +/// Represents a [PrefixElement2] for dartdoc. /// /// Like [Parameter], it doesn't have doc pages, but participates in lookups. /// Forwards to its referenced library if referred to directly. class Prefix extends ModelElement with HasNoPage { @override - final PrefixElement element; + // ignore: analyzer_use_new_elements + PrefixElement get element => element2.asElement; + + @override + final PrefixElement2 element2; /// [library] is the library the prefix is defined in, not the [Library] - /// referred to by the [PrefixElement]. - Prefix(this.element, super.library, super.packageGraph); + /// referred to by the [PrefixElement2]. + Prefix(this.element2, super.library, super.packageGraph); @override bool get isCanonical => false; // TODO(jcollins-g): consider connecting PrefixElement to the imported library // in analyzer? - late final Library associatedLibrary = getModelForElement(library - .element.definingCompilationUnit.libraryImports - .firstWhere((i) => i.prefix?.element == element) - .importedLibrary!) as Library; + late final Library associatedLibrary = + getModelForElement2(_getImportedLibraryElement()!) as Library; + + LibraryElement2? _getImportedLibraryElement() { + final importLists = + library.element2.fragments.map((fragment) => fragment.libraryImports2); + return importLists + .expand((import) => import) + .firstWhere((i) => i.prefix2?.element == element2) + .importedLibrary2; + } @override Library? get canonicalModelElement => associatedLibrary.canonicalLibrary; @override - Scope get scope => element.scope; + Scope get scope => element2.scope; @override ModelElement get enclosingElement => library; diff --git a/lib/src/model/typedef.dart b/lib/src/model/typedef.dart index 317dcc982b..7fc9e4ee28 100644 --- a/lib/src/model/typedef.dart +++ b/lib/src/model/typedef.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'; import 'package:analyzer/dart/element/type.dart'; @@ -17,16 +15,17 @@ import 'package:dartdoc/src/model/model.dart'; abstract class Typedef extends ModelElement with TypeParameters, Categorization { @override - final TypeAliasElement element; + // ignore: analyzer_use_new_elements + TypeAliasElement get element => element2.asElement; @override - TypeAliasElement2 get element2 => element.asElement2; + final TypeAliasElement2 element2; - Typedef(this.element, super.library, super.packageGraph); + Typedef(this.element2, super.library, super.packageGraph); - DartType get aliasedType => element.aliasedType; + DartType get aliasedType => element2.aliasedType; - late final ElementType modelType = getTypeFor(element.aliasedType, library); + late final ElementType modelType = getTypeFor(element2.aliasedType, library); @override Library get enclosingElement => library; @@ -69,8 +68,8 @@ abstract class Typedef extends ModelElement Kind get kind => Kind.typedef; @override - List get typeParameters => element.typeParameters - .map((f) => getModelFor(f, library) as TypeParameter) + List get typeParameters => element2.typeParameters2 + .map((f) => getModelFor2(f, library) as TypeParameter) .toList(growable: false); @override @@ -134,10 +133,10 @@ class FunctionTypedef extends Typedef { FunctionTypedef(super.element, super.library, super.packageGraph) { assert( isCallable, - 'Expected callable but: ${element.runtimeType} is FunctionTypedElement ' - '|| (${element.runtimeType} is TypeAliasElement && ' - '${element.aliasedType.runtimeType} is FunctionType) is not true for ' - '"${element.name}" in "${element.library}"'); + 'Expected callable but: ${element2.runtimeType} is FunctionTypedElement ' + '|| (${element2.runtimeType} is TypeAliasElement && ' + '${element2.aliasedType.runtimeType} is FunctionType) is not true for ' + '"${element2.name3}" in "${element2.library2}"'); } @override