diff --git a/pkg/analyzer/lib/src/fine/base_name_members.dart b/pkg/analyzer/lib/src/fine/base_name_members.dart deleted file mode 100644 index 44faf624301..00000000000 --- a/pkg/analyzer/lib/src/fine/base_name_members.dart +++ /dev/null @@ -1,876 +0,0 @@ -// Copyright (c) 2025, 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. - -import 'package:analyzer/src/fine/lookup_name.dart'; -import 'package:analyzer/src/fine/manifest_id.dart'; -import 'package:analyzer/src/fine/manifest_item.dart'; -import 'package:analyzer/src/summary2/data_reader.dart'; -import 'package:analyzer/src/summary2/data_writer.dart'; - -class BaseNameConflict extends BaseNameMembers { - final ManifestItemId id; - - factory BaseNameConflict() { - return BaseNameConflict._(id: ManifestItemId.generate()); - } - - factory BaseNameConflict.read(SummaryDataReader reader) { - return BaseNameConflict._(id: ManifestItemId.read(reader)); - } - - BaseNameConflict._({required this.id}); - - @override - BaseNameMembers addDeclaredConstructor( - InterfaceItemConstructorItem constructor, - ) { - return this; - } - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - return this; - } - - @override - BaseNameMembers addDeclaredIndexEq(InstanceItemMethodItem method) { - return this; - } - - @override - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - return this; - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return this; - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - return this; - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.conflict); - id.write(sink); - } -} - -class BaseNameConstructor extends BaseNameMembers { - final DeclaredOrInheritedConstructor constructor; - - BaseNameConstructor({required this.constructor}); - - factory BaseNameConstructor.read(SummaryDataReader reader) { - return BaseNameConstructor( - constructor: DeclaredOrInheritedConstructor.read(reader), - ); - } - - @override - ManifestItemId get constructorId => constructor.id; - - @override - InterfaceItemConstructorItem? get declaredConstructor { - return constructor.item; - } - - @override - BaseNameMembers addDeclaredConstructor( - InterfaceItemConstructorItem constructor, - ) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - if (getter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorGetter( - constructor: constructor, - getter: getter, - ); - } - } - - @override - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - if (method.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorMethod( - constructor: constructor, - method: method, - ); - } - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - if (setter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorSetter( - constructor: constructor, - setter: setter, - ); - } - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - return BaseNameConflict(); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.constructor); - constructor.write(sink); - } -} - -class BaseNameConstructorGetter extends BaseNameMembers { - final DeclaredOrInheritedConstructor constructor; - final InstanceItemGetterItem getter; - - BaseNameConstructorGetter({required this.constructor, required this.getter}) - : assert(!getter.isStatic); - - factory BaseNameConstructorGetter.read(SummaryDataReader reader) { - return BaseNameConstructorGetter( - constructor: DeclaredOrInheritedConstructor.read(reader), - getter: InstanceItemGetterItem.read(reader), - ); - } - - @override - ManifestItemId get constructorId => constructor.id; - - @override - InterfaceItemConstructorItem? get declaredConstructor { - return constructor.item; - } - - @override - InstanceItemGetterItem get declaredGetter { - return getter; - } - - @override - ManifestItemId get getterOrMethodId => getter.id; - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - if (setter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorGetterSetter( - constructor: constructor, - getter: getter, - setter: setter, - ); - } - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.constructorGetter); - constructor.write(sink); - getter.write(sink); - } -} - -class BaseNameConstructorGetterSetter extends BaseNameMembers { - final DeclaredOrInheritedConstructor constructor; - final InstanceItemGetterItem getter; - final InstanceItemSetterItem setter; - - BaseNameConstructorGetterSetter({ - required this.constructor, - required this.getter, - required this.setter, - }) : assert(!getter.isStatic), - assert(!setter.isStatic); - - factory BaseNameConstructorGetterSetter.read(SummaryDataReader reader) { - return BaseNameConstructorGetterSetter( - constructor: DeclaredOrInheritedConstructor.read(reader), - getter: InstanceItemGetterItem.read(reader), - setter: InstanceItemSetterItem.read(reader), - ); - } - - @override - ManifestItemId get constructorId => constructor.id; - - @override - InterfaceItemConstructorItem? get declaredConstructor { - return constructor.item; - } - - @override - InstanceItemGetterItem get declaredGetter { - return getter; - } - - @override - InstanceItemSetterItem get declaredSetter { - return setter; - } - - @override - ManifestItemId get getterOrMethodId => getter.id; - - @override - ManifestItemId get setterId => setter.id; - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.constructorGetterSetter); - constructor.write(sink); - getter.write(sink); - setter.write(sink); - } -} - -class BaseNameConstructorMethod extends BaseNameMembers { - final DeclaredOrInheritedConstructor constructor; - final InstanceItemMethodItem method; - - BaseNameConstructorMethod({required this.constructor, required this.method}) - : assert(!method.isStatic); - - factory BaseNameConstructorMethod.read(SummaryDataReader reader) { - return BaseNameConstructorMethod( - constructor: DeclaredOrInheritedConstructor.read(reader), - method: InstanceItemMethodItem.read(reader), - ); - } - - @override - ManifestItemId get constructorId => constructor.id; - - @override - InterfaceItemConstructorItem? get declaredConstructor { - return constructor.item; - } - - @override - InstanceItemMethodItem get declaredMethod { - return method; - } - - @override - ManifestItemId get getterOrMethodId => method.id; - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.constructorMethod); - constructor.write(sink); - method.write(sink); - } -} - -class BaseNameConstructorSetter extends BaseNameMembers { - final DeclaredOrInheritedConstructor constructor; - final InstanceItemSetterItem setter; - - BaseNameConstructorSetter({required this.constructor, required this.setter}) - : assert(!setter.isStatic); - - factory BaseNameConstructorSetter.read(SummaryDataReader reader) { - return BaseNameConstructorSetter( - constructor: DeclaredOrInheritedConstructor.read(reader), - setter: InstanceItemSetterItem.read(reader), - ); - } - - @override - ManifestItemId get constructorId => constructor.id; - - @override - InterfaceItemConstructorItem? get declaredConstructor { - return constructor.item; - } - - @override - InstanceItemSetterItem get declaredSetter { - return setter; - } - - @override - ManifestItemId get setterId => setter.id; - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.constructorSetter); - constructor.write(sink); - setter.write(sink); - } -} - -class BaseNameGetter extends BaseNameMembers { - final InstanceItemGetterItem getter; - - BaseNameGetter({required this.getter}); - - factory BaseNameGetter.read(SummaryDataReader reader) { - return BaseNameGetter(getter: InstanceItemGetterItem.read(reader)); - } - - @override - InstanceItemGetterItem get declaredGetter { - return getter; - } - - @override - ManifestItemId get getterOrMethodId => getter.id; - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - if (getter.isStatic != setter.isStatic) { - return BaseNameConflict(); - } - return BaseNameGetterSetter(getter: getter, setter: setter); - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - if (getter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorGetter( - constructor: InheritedConstructor(id), - getter: getter, - ); - } - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.getter); - getter.write(sink); - } -} - -class BaseNameGetterSetter extends BaseNameMembers { - final InstanceItemGetterItem getter; - final InstanceItemSetterItem setter; - - BaseNameGetterSetter({required this.getter, required this.setter}) - : assert( - getter.isStatic == setter.isStatic, - 'Getter and setter must have the same static modifier.', - ); - - factory BaseNameGetterSetter.read(SummaryDataReader reader) { - return BaseNameGetterSetter( - getter: InstanceItemGetterItem.read(reader), - setter: InstanceItemSetterItem.read(reader), - ); - } - - @override - InstanceItemGetterItem get declaredGetter { - return getter; - } - - @override - InstanceItemSetterItem get declaredSetter { - return setter; - } - - @override - ManifestItemId get getterOrMethodId => getter.id; - - @override - ManifestItemId get setterId => setter.id; - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - if (getter.isStatic || setter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorGetterSetter( - constructor: InheritedConstructor(id), - getter: getter, - setter: setter, - ); - } - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.getterSetter); - getter.write(sink); - setter.write(sink); - } -} - -class BaseNameIndexEq extends BaseNameMembers { - final InstanceItemMethodItem indexEq; - - BaseNameIndexEq({required this.indexEq}); - - factory BaseNameIndexEq.read(SummaryDataReader reader) { - return BaseNameIndexEq(indexEq: InstanceItemMethodItem.read(reader)); - } - - @override - InstanceItemMethodItem get declaredIndexEq { - return indexEq; - } - - @override - ManifestItemId get indexEqId => indexEq.id; - - @override - BaseNameMembers addDeclaredIndexEq(InstanceItemMethodItem method) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - return BaseNameMethodIndexEq(method: method, indexEq: indexEq); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.indexEq); - indexEq.write(sink); - } -} - -sealed class BaseNameMembers { - BaseNameMembers(); - - factory BaseNameMembers.read(SummaryDataReader reader) { - var kind = reader.readEnum(_BaseNameItemsKind.values); - switch (kind) { - case _BaseNameItemsKind.conflict: - return BaseNameConflict.read(reader); - case _BaseNameItemsKind.constructor: - return BaseNameConstructor.read(reader); - case _BaseNameItemsKind.constructorGetter: - return BaseNameConstructorGetter.read(reader); - case _BaseNameItemsKind.constructorGetterSetter: - return BaseNameConstructorGetterSetter.read(reader); - case _BaseNameItemsKind.constructorMethod: - return BaseNameConstructorMethod.read(reader); - case _BaseNameItemsKind.constructorSetter: - return BaseNameConstructorSetter.read(reader); - case _BaseNameItemsKind.getter: - return BaseNameGetter.read(reader); - case _BaseNameItemsKind.getterSetter: - return BaseNameGetterSetter.read(reader); - case _BaseNameItemsKind.method: - return BaseNameMethod.read(reader); - case _BaseNameItemsKind.methodIndexEq: - return BaseNameMethodIndexEq.read(reader); - case _BaseNameItemsKind.indexEq: - return BaseNameIndexEq.read(reader); - case _BaseNameItemsKind.setter: - return BaseNameSetter.read(reader); - } - } - - ManifestItemId? get constructorId => null; - - InterfaceItemConstructorItem? get declaredConstructor => null; - - InstanceItemGetterItem? get declaredGetter => null; - - InstanceItemMethodItem? get declaredIndexEq => null; - - InstanceItemMethodItem? get declaredMethod => null; - - InstanceItemSetterItem? get declaredSetter => null; - - ManifestItemId? get getterOrMethodId => null; - - ManifestItemId? get indexEqId => null; - - ManifestItemId? get setterId => null; - - BaseNameMembers addDeclaredConstructor( - InterfaceItemConstructorItem constructor, - ) { - _unexpectedTransition(); - } - - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - _unexpectedTransition(); - } - - BaseNameMembers addDeclaredIndexEq(InstanceItemMethodItem method) { - _unexpectedTransition(); - } - - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - _unexpectedTransition(); - } - - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - _unexpectedTransition(); - } - - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - _unexpectedTransition(); - } - - void write(BufferedSink sink); - - /// The current implementation iterates over members in a specific order: - /// 1. declared constructors - /// 2. declared methods - /// 3. declared getters - /// 4. declared setters - /// 5. inherited constructors - /// 6. inherited methods - /// 7. inherited getters - /// 8. inherited setters - /// - /// So, not all transitions are possible. - /// - /// For example we should never transit with [addDeclaredMethod] from - /// [BaseNameGetter]. Correspondingly, it is impossible to test such method - /// implementation, and instead of leaving it and make an impression that - /// it works, we throw an exception. - Never _unexpectedTransition() { - throw StateError('Transition from $runtimeType'); - } - - static Map readMap(SummaryDataReader reader) { - return reader.readMap( - readKey: () => BaseName.read(reader), - readValue: () => BaseNameMembers.read(reader), - ); - } -} - -class BaseNameMethod extends BaseNameMembers { - final InstanceItemMethodItem method; - - BaseNameMethod({required this.method}); - - factory BaseNameMethod.read(SummaryDataReader reader) { - return BaseNameMethod(method: InstanceItemMethodItem.read(reader)); - } - - @override - InstanceItemMethodItem get declaredMethod { - return method; - } - - @override - ManifestItemId get getterOrMethodId => method.id; - - @override - BaseNameMembers addDeclaredGetter(InstanceItemGetterItem getter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredIndexEq(InstanceItemMethodItem indexEq) { - return BaseNameMethodIndexEq(method: method, indexEq: indexEq); - } - - @override - BaseNameMembers addDeclaredMethod(InstanceItemMethodItem method) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - if (method.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorMethod( - constructor: InheritedConstructor(id), - method: method, - ); - } - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.method); - method.write(sink); - } -} - -class BaseNameMethodIndexEq extends BaseNameMembers { - final InstanceItemMethodItem method; - final InstanceItemMethodItem indexEq; - - BaseNameMethodIndexEq({required this.method, required this.indexEq}); - - factory BaseNameMethodIndexEq.read(SummaryDataReader reader) { - return BaseNameMethodIndexEq( - method: InstanceItemMethodItem.read(reader), - indexEq: InstanceItemMethodItem.read(reader), - ); - } - - @override - InstanceItemMethodItem get declaredIndexEq { - return indexEq; - } - - @override - InstanceItemMethodItem get declaredMethod { - return method; - } - - @override - ManifestItemId get getterOrMethodId => method.id; - - @override - ManifestItemId get indexEqId => indexEq.id; - - @override - BaseNameMembers addDeclaredIndexEq(InstanceItemMethodItem method) { - return BaseNameConflict(); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.methodIndexEq); - method.write(sink); - indexEq.write(sink); - } -} - -class BaseNameSetter extends BaseNameMembers { - final InstanceItemSetterItem setter; - - BaseNameSetter({required this.setter}); - - factory BaseNameSetter.read(SummaryDataReader reader) { - return BaseNameSetter(setter: InstanceItemSetterItem.read(reader)); - } - - @override - InstanceItemSetterItem get declaredSetter { - return setter; - } - - @override - ManifestItemId get setterId => setter.id; - - @override - BaseNameMembers addDeclaredSetter(InstanceItemSetterItem setter) { - return BaseNameConflict(); - } - - @override - BaseNameMembers addInheritedConstructor(ManifestItemId id) { - if (setter.isStatic) { - return BaseNameConflict(); - } else { - return BaseNameConstructorSetter( - constructor: InheritedConstructor(id), - setter: setter, - ); - } - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_BaseNameItemsKind.setter); - setter.write(sink); - } -} - -class DeclaredConstructor extends DeclaredOrInheritedConstructor { - @override - final InterfaceItemConstructorItem item; - - DeclaredConstructor(this.item); - - factory DeclaredConstructor.read(SummaryDataReader reader) { - return DeclaredConstructor(InterfaceItemConstructorItem.read(reader)); - } - - @override - ManifestItemId get id => item.id; - - @override - void write(BufferedSink sink) { - sink.writeEnum(_DeclaredOrInheritedKind.declared); - item.write(sink); - } -} - -sealed class DeclaredOrInheritedConstructor { - DeclaredOrInheritedConstructor(); - - factory DeclaredOrInheritedConstructor.read(SummaryDataReader reader) { - var kind = reader.readEnum(_DeclaredOrInheritedKind.values); - switch (kind) { - case _DeclaredOrInheritedKind.declared: - return DeclaredConstructor.read(reader); - case _DeclaredOrInheritedKind.inherited: - return InheritedConstructor.read(reader); - } - } - - ManifestItemId get id; - - InterfaceItemConstructorItem? get item => null; - - void write(BufferedSink sink); -} - -class InheritedConstructor extends DeclaredOrInheritedConstructor { - @override - final ManifestItemId id; - - InheritedConstructor(this.id); - - factory InheritedConstructor.read(SummaryDataReader reader) { - return InheritedConstructor(ManifestItemId.read(reader)); - } - - @override - void write(BufferedSink sink) { - sink.writeEnum(_DeclaredOrInheritedKind.inherited); - id.write(sink); - } -} - -enum _BaseNameItemsKind { - conflict, - constructor, - constructorGetter, - constructorGetterSetter, - constructorMethod, - constructorSetter, - getter, - getterSetter, - indexEq, - method, - methodIndexEq, - setter, -} - -enum _DeclaredOrInheritedKind { declared, inherited } - -extension BaseNameItemsMapExtension on Map { - void addDeclaredConstructor( - BaseName name, - InterfaceItemConstructorItem constructor, - ) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameConstructor( - constructor: DeclaredConstructor(constructor), - ); - } else { - this[name] = existing.addDeclaredConstructor(constructor); - } - } - - void addDeclaredGetter(BaseName name, InstanceItemGetterItem getter) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameGetter(getter: getter); - } else { - this[name] = existing.addDeclaredGetter(getter); - } - } - - void addDeclaredIndexEq(BaseName name, InstanceItemMethodItem method) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameIndexEq(indexEq: method); - } else { - this[name] = existing.addDeclaredIndexEq(method); - } - } - - void addDeclaredMethod(BaseName name, InstanceItemMethodItem method) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameMethod(method: method); - } else { - this[name] = existing.addDeclaredMethod(method); - } - } - - void addDeclaredSetter(BaseName name, InstanceItemSetterItem setter) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameSetter(setter: setter); - } else { - this[name] = existing.addDeclaredSetter(setter); - } - } - - void addInheritedConstructor(BaseName name, ManifestItemId id) { - var existing = this[name]; - if (existing == null) { - this[name] = BaseNameConstructor(constructor: InheritedConstructor(id)); - } else { - this[name] = existing.addInheritedConstructor(id); - } - } - - void write(BufferedSink sink) { - sink.writeMap( - this, - writeKey: (name) => name.write(sink), - writeValue: (items) => items.write(sink), - ); - } -} diff --git a/pkg/analyzer/lib/src/fine/library_manifest.dart b/pkg/analyzer/lib/src/fine/library_manifest.dart index 5e9e6370dd6..26910ec45b5 100644 --- a/pkg/analyzer/lib/src/fine/library_manifest.dart +++ b/pkg/analyzer/lib/src/fine/library_manifest.dart @@ -7,7 +7,6 @@ import 'dart:typed_data'; import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/src/dart/analysis/file_state.dart'; import 'package:analyzer/src/dart/element/element.dart'; -import 'package:analyzer/src/fine/base_name_members.dart'; import 'package:analyzer/src/fine/lookup_name.dart'; import 'package:analyzer/src/fine/manifest_context.dart'; import 'package:analyzer/src/fine/manifest_id.dart'; @@ -136,7 +135,13 @@ class LibraryManifestBuilder { encodingContext.withTypeParameters(element.typeParameters2, ( typeParameters, ) { - classItem.declaredMembers.clear(); + classItem.declaredConflicts.clear(); + // classItem.declaredFields.clear(); // TODO(scheglov): restore + classItem.declaredGetters.clear(); + classItem.declaredSetters.clear(); + classItem.declaredMethods.clear(); + classItem.declaredConstructors.clear(); + classItem.inheritedConstructors.clear(); _addInterfaceElementMembers( encodingContext: encodingContext, instanceElement: element, @@ -190,9 +195,7 @@ class LibraryManifestBuilder { id ??= _getInterfaceElementMemberId(superConstructor); inheritedMap[constructor] = id; - - var baseName = lookupName.asBaseName; - item.declaredMembers.addInheritedConstructor(baseName, id); + item.addInheritedConstructor(lookupName, id); } } @@ -244,8 +247,7 @@ class LibraryManifestBuilder { ); }); - var baseName = lookupName.asBaseName; - instanceItem.declaredMembers.addDeclaredGetter(baseName, item); + instanceItem.addDeclaredGetter(lookupName, item); } void _addInstanceElementMembers({ @@ -304,12 +306,7 @@ class LibraryManifestBuilder { ); }); - var baseName = lookupName.asBaseName; - if (lookupName.isIndexEq) { - instanceItem.declaredMembers.addDeclaredIndexEq(baseName, item); - } else { - instanceItem.declaredMembers.addDeclaredMethod(baseName, item); - } + instanceItem.addDeclaredMethod(lookupName, item); } void _addInstanceElementSetter({ @@ -330,8 +327,7 @@ class LibraryManifestBuilder { ); }); - var baseName = lookupName.asBaseName; - instanceItem.declaredMembers.addDeclaredSetter(baseName, item); + instanceItem.addDeclaredSetter(lookupName, item); } void _addInterfaceElementConstructor({ @@ -352,8 +348,7 @@ class LibraryManifestBuilder { ); }); - var baseName = lookupName.asBaseName; - interfaceItem.declaredMembers.addDeclaredConstructor(baseName, item); + interfaceItem.addDeclaredConstructor(lookupName, item); } void _addInterfaceElementMembers({ @@ -401,7 +396,13 @@ class LibraryManifestBuilder { encodingContext.withTypeParameters(element.typeParameters2, ( typeParameters, ) { - mixinItem.declaredMembers.clear(); + mixinItem.declaredConflicts.clear(); + // mixinItem.declaredFields.clear(); // TODO(scheglov): restore + mixinItem.declaredGetters.clear(); + mixinItem.declaredSetters.clear(); + mixinItem.declaredMethods.clear(); + mixinItem.declaredConstructors.clear(); + mixinItem.inheritedConstructors.clear(); _addInterfaceElementMembers( encodingContext: encodingContext, instanceElement: element, @@ -729,9 +730,38 @@ class LibraryManifestBuilder { } ManifestItemId _getInterfaceElementMemberId(ExecutableElementImpl2 element) { - if (declaredItems[element] case var declaredItem?) { - return declaredItem.id; + var enclosingElement = element.enclosingElement; + enclosingElement as InterfaceElementImpl2; + + var enclosingItem = declaredItems[enclosingElement]; + if (enclosingItem != null) { + // SAFETY: if item is in this library, it is for interface. + enclosingItem as InterfaceItem; + + // SAFETY: any element in interface has a name. + var lookupName = element.lookupName!.asLookupName; + + // Check for a conflict. + if (enclosingItem.declaredConflicts[lookupName] case var id?) { + return id; + } + + // SAFETY: null asserts are safe, because element is in this library. + switch (element) { + case GetterElementImpl(): + return enclosingItem.declaredGetters[lookupName]!.id; + case SetterElementImpl(): + return enclosingItem.declaredSetters[lookupName]!.id; + case MethodElementImpl2(): + return enclosingItem.declaredMethods[lookupName]!.id; + case ConstructorElementImpl2(): + if (enclosingItem.declaredConstructors[lookupName] case var item?) { + return item.id; + } + return enclosingItem.inheritedConstructors[lookupName]!; + } } + return elementFactory.getElementId(element)!; } @@ -950,8 +980,7 @@ class _LibraryMatch { return false; } - var baseName = lookupName.asBaseName; - var item = instanceItem.declaredMembers[baseName]?.declaredGetter; + var item = instanceItem.declaredGetters[lookupName]; if (item is! InstanceItemGetterItem) { return false; } @@ -975,11 +1004,7 @@ class _LibraryMatch { return false; } - var baseName = lookupName.asBaseName; - var item = - lookupName.isIndexEq - ? instanceItem.declaredMembers[baseName]?.declaredIndexEq - : instanceItem.declaredMembers[baseName]?.declaredMethod; + var item = instanceItem.declaredMethods[lookupName]; if (item is! InstanceItemMethodItem) { return false; } @@ -1003,8 +1028,7 @@ class _LibraryMatch { return true; } - var baseName = lookupName.asBaseName; - var item = instanceItem.declaredMembers[baseName]?.declaredSetter; + var item = instanceItem.declaredSetters[lookupName]; if (item is! InstanceItemSetterItem) { return false; } @@ -1028,8 +1052,7 @@ class _LibraryMatch { return false; } - var baseName = lookupName.asBaseName; - var item = interfaceItem.declaredMembers[baseName]?.declaredConstructor; + var item = interfaceItem.declaredConstructors[lookupName]; if (item is! InterfaceItemConstructorItem) { return false; } diff --git a/pkg/analyzer/lib/src/fine/lookup_name.dart b/pkg/analyzer/lib/src/fine/lookup_name.dart index c390f11a82b..78bb245d2d3 100644 --- a/pkg/analyzer/lib/src/fine/lookup_name.dart +++ b/pkg/analyzer/lib/src/fine/lookup_name.dart @@ -56,12 +56,58 @@ extension type LookupName(String _it) { return _it == '[]='; } + bool get isIndexOrIndexEq { + return const {'[]', '[]='}.contains(_it); + } + + bool get isOperator { + return const { + ...{'+', '-', '*', '/', '~/', '%'}, + ...{'<<', '>>', '>>>', '&', '^', '|', '~'}, + ...{'<', '<=', '>', '>=', '=='}, + 'unary-', + }.contains(_it); + } + bool get isPrivate => _it.startsWith('_'); bool get isSetter { return _it.endsWith('=') && !const {'==', '<=', '>=', '[]='}.contains(_it); } + /// This name must be a name of a method. + LookupName get methodToSetter { + assert(!isSetter); + if (isOperator || isIndexOrIndexEq) { + return this; + } + return LookupName('$_it='); + } + + List get relatedNames { + if (isOperator) { + return [this]; + } + + if (isIndexOrIndexEq) { + return ['[]'.asLookupName, '[]='.asLookupName]; + } + + if (isSetter) { + return [this, setterToGetter]; + } + + var setterName = '$_it='; + return [this, setterName.asLookupName]; + } + + /// This name must be a name of a setter. + LookupName get setterToGetter { + assert(isSetter); + assert(_it.endsWith('=')); + return _it.substring(0, _it.length - 1).asLookupName; + } + void write(BufferedSink sink) { sink.writeStringUtf8(_it); } diff --git a/pkg/analyzer/lib/src/fine/manifest_item.dart b/pkg/analyzer/lib/src/fine/manifest_item.dart index 25e05c83f95..516c6d4741b 100644 --- a/pkg/analyzer/lib/src/fine/manifest_item.dart +++ b/pkg/analyzer/lib/src/fine/manifest_item.dart @@ -4,7 +4,6 @@ import 'package:analyzer/dart/ast/ast.dart'; import 'package:analyzer/src/dart/element/element.dart'; -import 'package:analyzer/src/fine/base_name_members.dart'; import 'package:analyzer/src/fine/lookup_name.dart'; import 'package:analyzer/src/fine/manifest_ast.dart'; import 'package:analyzer/src/fine/manifest_context.dart'; @@ -20,8 +19,13 @@ class ClassItem extends InterfaceItem { required super.id, required super.metadata, required super.typeParameters, + required super.declaredConflicts, required super.declaredFields, - required super.declaredMembers, + required super.declaredGetters, + required super.declaredSetters, + required super.declaredMethods, + required super.declaredConstructors, + required super.inheritedConstructors, required super.supertype, required super.mixins, required super.interfaces, @@ -40,8 +44,13 @@ class ClassItem extends InterfaceItem { id: id, metadata: ManifestMetadata.encode(context, element.metadata2), typeParameters: typeParameters, + declaredConflicts: {}, declaredFields: {}, - declaredMembers: {}, + declaredGetters: {}, + declaredSetters: {}, + declaredMethods: {}, + declaredConstructors: {}, + inheritedConstructors: {}, supertype: element.supertype?.encode(context), mixins: element.mixins.encode(context), interfaces: element.interfaces.encode(context), @@ -55,8 +64,13 @@ class ClassItem extends InterfaceItem { id: ManifestItemId.read(reader), metadata: ManifestMetadata.read(reader), typeParameters: ManifestTypeParameter.readList(reader), + declaredConflicts: reader.readLookupNameToIdMap(), declaredFields: InstanceItemFieldItem.readMap(reader), - declaredMembers: BaseNameMembers.readMap(reader), + declaredGetters: InstanceItemGetterItem.readMap(reader), + declaredSetters: InstanceItemSetterItem.readMap(reader), + declaredMethods: InstanceItemMethodItem.readMap(reader), + declaredConstructors: InterfaceItemConstructorItem.readMap(reader), + inheritedConstructors: reader.readLookupNameToIdMap(), supertype: ManifestType.readOptional(reader), mixins: ManifestType.readList(reader), interfaces: ManifestType.readList(reader), @@ -76,62 +90,203 @@ sealed class InstanceItem extends TopLevelItem { final List typeParameters; - final Map declaredFields; + /// The names of duplicate or otherwise conflicting members. + /// Such names will not be added to `declaredXyz` maps. + final Map declaredConflicts; - /// This name is almost truth, it contains declared constructors, methods, - /// getters, and setters; both instance and static. But for class type - /// aliases it also has "inherited" constructors, references to the - /// superclass constructors. - final Map declaredMembers; + final Map declaredFields; + final Map declaredGetters; + final Map declaredSetters; + final Map declaredMethods; + final Map declaredConstructors; + final Map inheritedConstructors; InstanceItem({ required super.id, required super.metadata, required this.typeParameters, + required this.declaredConflicts, required this.declaredFields, - required this.declaredMembers, + required this.declaredGetters, + required this.declaredSetters, + required this.declaredMethods, + required this.declaredConstructors, + required this.inheritedConstructors, }); - ManifestItemId? getConstructorId(LookupName name) { - var baseNameMembers = declaredMembers[name.asBaseName]; - if (baseNameMembers == null) { - return null; + void addDeclaredConstructor( + LookupName lookupName, + InterfaceItemConstructorItem item, + ) { + var baseName = lookupName.asBaseName; + if (declaredConflicts.containsKey(baseName)) { + return; } - return baseNameMembers.constructorId; + var hasConflict = () { + // Constructors conflict with constructors. + if (declaredConstructors.containsKey(lookupName)) { + return true; + } + // Constructors conflict with static properties and methods. + return declaredGetters[lookupName]?.isStatic ?? + declaredSetters[lookupName]?.isStatic ?? + declaredMethods[lookupName]?.isStatic ?? + false; + }(); + if (hasConflict) { + _makeNameConflict(lookupName); + return; + } + + declaredConstructors[lookupName] = item; + } + + void addDeclaredGetter(LookupName lookupName, InstanceItemGetterItem item) { + var baseName = lookupName.asBaseName; + if (declaredConflicts.containsKey(baseName)) { + return; + } + + var hasConflict = () { + // Getters conflict with methods and getters. + if (declaredGetters.containsKey(lookupName) || + declaredMethods.containsKey(lookupName)) { + return true; + } + // Static getters conflict with constructors. + if (item.isStatic && declaredConstructors.containsKey(lookupName)) { + return true; + } + // Instance / static getters conflict with static / instance setter. + var lookupNameSetter = '${lookupName.asString}='.asLookupName; + if (declaredSetters[lookupNameSetter] case var setter?) { + if (setter.isStatic != item.isStatic) { + return true; + } + } + return false; + }(); + if (hasConflict) { + _makeNameConflict(lookupName); + return; + } + + declaredGetters[lookupName] = item; + } + + void addDeclaredMethod(LookupName lookupName, InstanceItemMethodItem item) { + var baseName = lookupName.asBaseName; + if (declaredConflicts.containsKey(baseName)) { + return; + } + + var hasConflict = () { + // Methods conflict with methods and properties. + if (declaredGetters.containsKey(lookupName) || + declaredSetters.containsKey(lookupName.methodToSetter) || + declaredMethods.containsKey(lookupName)) { + return true; + } + // Static methods conflict with constructors. + if (item.isStatic && declaredConstructors.containsKey(lookupName)) { + return true; + } + return false; + }(); + if (hasConflict) { + _makeNameConflict(lookupName); + return; + } + + declaredMethods[lookupName] = item; + } + + void addDeclaredSetter(LookupName lookupName, InstanceItemSetterItem item) { + var baseName = lookupName.asBaseName; + if (declaredConflicts.containsKey(baseName)) { + return; + } + + var hasConflict = () { + var lookupNameGetter = lookupName.setterToGetter; + // Setters conflict with setters and methods. + if (declaredSetters.containsKey(lookupName) || + declaredMethods.containsKey(lookupNameGetter)) { + return true; + } + // Static setters conflict with constructors. + if (item.isStatic && declaredConstructors.containsKey(lookupNameGetter)) { + return true; + } + // Instance / static setters conflict with static / instance getter. + if (declaredGetters[lookupNameGetter] case var getter?) { + if (getter.isStatic != item.isStatic) { + return true; + } + } + return false; + }(); + if (hasConflict) { + _makeNameConflict(lookupName); + return; + } + + declaredSetters[lookupName] = item; + } + + void addInheritedConstructor(LookupName lookupName, ManifestItemId id) { + // Inherited constructors exist only for class type aliases. + // So, not conflicts checking it required. + inheritedConstructors[lookupName] = id; + } + + ManifestItemId? getConstructorId(LookupName name) { + return declaredConstructors[name]?.id ?? + inheritedConstructors[name] ?? + declaredConflicts[name]; } ManifestItemId? getDeclaredFieldId(LookupName name) { - return declaredFields[name]?.id; + return declaredFields[name]?.id ?? declaredConflicts[name]; } - ManifestItemId? getDeclaredMemberId(LookupName name) { - var baseNameMembers = declaredMembers[name.asBaseName]; - if (baseNameMembers == null) { - return null; - } - - if (name.isSetter) { - return baseNameMembers.setterId; - } - - if (name.isIndexEq) { - return baseNameMembers.indexEqId; - } - - return baseNameMembers.getterOrMethodId; + ManifestItemId? getDeclaredGetterId(LookupName name) { + return declaredGetters[name]?.id ?? declaredConflicts[name]; } - ManifestItemId? getInterfaceMethodId(LookupName name) { - return getDeclaredMemberId(name); + ManifestItemId? getDeclaredMethodId(LookupName name) { + return declaredMethods[name]?.id ?? declaredConflicts[name]; + } + + ManifestItemId? getDeclaredSetterId(LookupName name) { + return declaredSetters[name]?.id ?? declaredConflicts[name]; } @override void write(BufferedSink sink) { super.write(sink); typeParameters.writeList(sink); + declaredConflicts.write(sink); declaredFields.write(sink); - declaredMembers.write(sink); + declaredGetters.write(sink); + declaredSetters.write(sink); + declaredMethods.write(sink); + declaredConstructors.write(sink); + inheritedConstructors.write(sink); + } + + void _makeNameConflict(LookupName lookupName2) { + var id = ManifestItemId.generate(); + for (var lookupName in lookupName2.relatedNames) { + declaredConflicts[lookupName] = id; + declaredFields.remove(lookupName); + declaredGetters.remove(lookupName); + declaredSetters.remove(lookupName); + declaredMethods.remove(lookupName); + declaredConstructors.remove(lookupName); + inheritedConstructors.remove(lookupName); + } } } @@ -256,6 +411,15 @@ class InstanceItemGetterItem extends InstanceItemMemberItem { void writeKind(BufferedSink sink) { sink.writeEnum(_InstanceItemMemberItemKind.getter); } + + static Map readMap( + SummaryDataReader reader, + ) { + return reader.readMap( + readKey: () => LookupName.read(reader), + readValue: () => InstanceItemGetterItem.read(reader), + ); + } } sealed class InstanceItemMemberItem @@ -369,6 +533,15 @@ class InstanceItemMethodItem void writeKind(BufferedSink sink) { sink.writeEnum(_InstanceItemMemberItemKind.method); } + + static Map readMap( + SummaryDataReader reader, + ) { + return reader.readMap( + readKey: () => LookupName.read(reader), + readValue: () => InstanceItemMethodItem.read(reader), + ); + } } class InstanceItemSetterItem extends InstanceItemMemberItem { @@ -422,6 +595,15 @@ class InstanceItemSetterItem extends InstanceItemMemberItem { void writeKind(BufferedSink sink) { sink.writeEnum(_InstanceItemMemberItemKind.setter); } + + static Map readMap( + SummaryDataReader reader, + ) { + return reader.readMap( + readKey: () => LookupName.read(reader), + readValue: () => InstanceItemSetterItem.read(reader), + ); + } } /// The item for [InterfaceElementImpl2]. @@ -436,15 +618,19 @@ sealed class InterfaceItem required super.id, required super.metadata, required super.typeParameters, + required super.declaredConflicts, required super.declaredFields, - required super.declaredMembers, + required super.declaredGetters, + required super.declaredSetters, + required super.declaredMethods, + required super.declaredConstructors, + required super.inheritedConstructors, required this.supertype, required this.mixins, required this.interfaces, required this.interface, }); - @override ManifestItemId? getInterfaceMethodId(LookupName name) { return interface.map[name]; } @@ -542,6 +728,15 @@ class InterfaceItemConstructorItem void writeKind(BufferedSink sink) { sink.writeEnum(_InstanceItemMemberItemKind.constructor); } + + static Map readMap( + SummaryDataReader reader, + ) { + return reader.readMap( + readKey: () => LookupName.read(reader), + readValue: () => InterfaceItemConstructorItem.read(reader), + ); + } } class ManifestAnnotation { @@ -601,7 +796,7 @@ class ManifestInterface { factory ManifestInterface.read(SummaryDataReader reader) { return ManifestInterface( - map: LookupNameIdMapExtension.read(reader), + map: _LookupNameToIdMapExtension.read(reader), combinedIds: reader.readMap( readKey: () => ManifestItemIdList.read(reader), readValue: () => ManifestItemId.read(reader), @@ -703,8 +898,13 @@ class MixinItem extends InterfaceItem { required super.supertype, required super.interfaces, required super.mixins, + required super.declaredConflicts, required super.declaredFields, - required super.declaredMembers, + required super.declaredMethods, + required super.declaredGetters, + required super.declaredSetters, + required super.declaredConstructors, + required super.inheritedConstructors, required super.interface, required this.superclassConstraints, }) : assert(supertype == null), @@ -723,8 +923,13 @@ class MixinItem extends InterfaceItem { id: id, metadata: ManifestMetadata.encode(context, element.metadata2), typeParameters: typeParameters, + declaredConflicts: {}, declaredFields: {}, - declaredMembers: {}, + declaredGetters: {}, + declaredSetters: {}, + declaredMethods: {}, + declaredConstructors: {}, + inheritedConstructors: {}, interface: ManifestInterface.empty(), supertype: element.supertype?.encode(context), mixins: element.mixins.encode(context), @@ -739,8 +944,13 @@ class MixinItem extends InterfaceItem { id: ManifestItemId.read(reader), metadata: ManifestMetadata.read(reader), typeParameters: ManifestTypeParameter.readList(reader), + declaredConflicts: reader.readLookupNameToIdMap(), declaredFields: InstanceItemFieldItem.readMap(reader), - declaredMembers: BaseNameMembers.readMap(reader), + declaredGetters: InstanceItemGetterItem.readMap(reader), + declaredSetters: InstanceItemSetterItem.readMap(reader), + declaredMethods: InstanceItemMethodItem.readMap(reader), + declaredConstructors: InterfaceItemConstructorItem.readMap(reader), + inheritedConstructors: reader.readLookupNameToIdMap(), supertype: ManifestType.readOptional(reader), mixins: ManifestType.readList(reader), interfaces: ManifestType.readList(reader), @@ -935,33 +1145,6 @@ enum _ManifestItemKind { topLevelSetter, } -extension FieldItemMapExtension on Map { - void write(BufferedSink sink) { - sink.writeMap( - this, - writeKey: (name) => name.write(sink), - writeValue: (items) => items.write(sink), - ); - } -} - -extension LookupNameIdMapExtension on Map { - void write(BufferedSink sink) { - sink.writeMap( - this, - writeKey: (name) => name.write(sink), - writeValue: (items) => items.write(sink), - ); - } - - static Map read(SummaryDataReader reader) { - return reader.readMap( - readKey: () => LookupName.read(reader), - readValue: () => ManifestItemId.read(reader), - ); - } -} - extension _AnnotatableElementExtension on AnnotatableElementImpl { MetadataImpl get effectiveMetadata { if (this case PropertyAccessorElementImpl2 accessor) { @@ -990,6 +1173,78 @@ extension _GetterElementImplExtension on GetterElementImpl { } } +extension _LookupNameToIdMapExtension on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } + + static Map read(SummaryDataReader reader) { + return reader.readMap( + readKey: () => LookupName.read(reader), + readValue: () => ManifestItemId.read(reader), + ); + } +} + +extension _LookupNameToInstanceItemFieldItemMapExtension + on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } +} + +extension _LookupNameToInstanceItemGetterItemMapExtension + on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } +} + +extension _LookupNameToInstanceItemMethodItemMapExtension + on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } +} + +extension _LookupNameToInstanceItemSetterItemMapExtension + on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } +} + +extension _LookupNameToInterfaceItemConstructorItemMapExtension + on Map { + void write(BufferedSink sink) { + sink.writeMap( + this, + writeKey: (name) => name.write(sink), + writeValue: (items) => items.write(sink), + ); + } +} + extension _PropertyAccessExtension on PropertyAccessorElementImpl2 { MetadataImpl get thisOrVariableMetadata { if (isSynthetic) { @@ -999,3 +1254,12 @@ extension _PropertyAccessExtension on PropertyAccessorElementImpl2 { } } } + +extension _SummaryDataReaderExtension on SummaryDataReader { + Map readLookupNameToIdMap() { + return readMap( + readKey: () => LookupName.read(this), + readValue: () => ManifestItemId.read(this), + ); + } +} diff --git a/pkg/analyzer/lib/src/fine/requirements.dart b/pkg/analyzer/lib/src/fine/requirements.dart index 0c0a4b7916a..71b08657ccf 100644 --- a/pkg/analyzer/lib/src/fine/requirements.dart +++ b/pkg/analyzer/lib/src/fine/requirements.dart @@ -191,28 +191,39 @@ final class ExportRequirementShowCombinator /// of [InterfaceItemRequirements]. class InstanceItemRequirements { final Map requestedFields; - - /// These are "methods" in wide meaning: methods, getters, setters. + final Map requestedGetters; + final Map requestedSetters; final Map requestedMethods; InstanceItemRequirements({ required this.requestedFields, + required this.requestedGetters, + required this.requestedSetters, required this.requestedMethods, }); factory InstanceItemRequirements.empty() { - return InstanceItemRequirements(requestedFields: {}, requestedMethods: {}); + return InstanceItemRequirements( + requestedFields: {}, + requestedGetters: {}, + requestedSetters: {}, + requestedMethods: {}, + ); } factory InstanceItemRequirements.read(SummaryDataReader reader) { return InstanceItemRequirements( requestedFields: reader.readNameToIdMap(), + requestedGetters: reader.readNameToIdMap(), + requestedSetters: reader.readNameToIdMap(), requestedMethods: reader.readNameToIdMap(), ); } void write(BufferedSink sink) { sink.writeNameToIdMap(requestedFields); + sink.writeNameToIdMap(requestedGetters); + sink.writeNameToIdMap(requestedSetters); sink.writeNameToIdMap(requestedMethods); } } @@ -383,10 +394,40 @@ class RequirementsManifest { } } + for (var getterEntry in requirements.requestedGetters.entries) { + var name = getterEntry.key; + var expectedId = getterEntry.value; + var currentId = instanceItem.getDeclaredGetterId(name); + if (expectedId != currentId) { + return InstanceMethodIdMismatch( + libraryUri: libraryUri, + interfaceName: instanceName, + methodName: name, + expectedId: expectedId, + actualId: currentId, + ); + } + } + + for (var setterEntry in requirements.requestedSetters.entries) { + var name = setterEntry.key; + var expectedId = setterEntry.value; + var currentId = instanceItem.getDeclaredSetterId(name); + if (expectedId != currentId) { + return InstanceMethodIdMismatch( + libraryUri: libraryUri, + interfaceName: instanceName, + methodName: name, + expectedId: expectedId, + actualId: currentId, + ); + } + } + for (var methodEntry in requirements.requestedMethods.entries) { var name = methodEntry.key; var expectedId = methodEntry.value; - var currentId = instanceItem.getDeclaredMemberId(name); + var currentId = instanceItem.getDeclaredMethodId(name); if (expectedId != currentId) { return InstanceMethodIdMismatch( libraryUri: libraryUri, @@ -575,7 +616,17 @@ class RequirementsManifest { required InstanceElementImpl2 element, required String name, }) { - record_instanceElement_getMethod(element: element, name: name); + var itemRequirements = _getInstanceItem(element); + if (itemRequirements == null) { + return; + } + + var item = itemRequirements.item; + var requirements = itemRequirements.requirements; + + var methodName = name.asLookupName; + var methodId = item.getDeclaredGetterId(methodName); + requirements.requestedGetters[methodName] = methodId; } void record_instanceElement_getMethod({ @@ -591,7 +642,7 @@ class RequirementsManifest { var requirements = itemRequirements.requirements; var methodName = name.asLookupName; - var methodId = item.getDeclaredMemberId(methodName); + var methodId = item.getDeclaredMethodId(methodName); requirements.requestedMethods[methodName] = methodId; } @@ -599,7 +650,18 @@ class RequirementsManifest { required InstanceElementImpl2 element, required String name, }) { - record_instanceElement_getMethod(element: element, name: '$name='); + assert(!name.endsWith('=')); + var itemRequirements = _getInstanceItem(element); + if (itemRequirements == null) { + return; + } + + var item = itemRequirements.item; + var requirements = itemRequirements.requirements; + + var methodName = '$name='.asLookupName; + var methodId = item.getDeclaredSetterId(methodName); + requirements.requestedSetters[methodName] = methodId; } void record_propertyAccessorElement_variable({ diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart index 63f83c302ff..3af4cb2d4ef 100644 --- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart +++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart @@ -16556,7 +16556,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -16572,14 +16572,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -16665,8 +16665,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -16683,15 +16683,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -17056,7 +17056,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -17072,14 +17072,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -17116,7 +17116,7 @@ class B extends A { foo=: #M4 interface map - foo: #M5 + foo: #M4 ''', updatedCode: r''' class A { @@ -17144,14 +17144,14 @@ class B extends A { foo: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo: #M8 - zzz: #M7 + foo: #M5 + zzz: #M6 ''', ); } @@ -17192,7 +17192,7 @@ class B extends A { foo=: #M5 interface map - foo: #M6 + foo: #M5 foo=: #M3 ''', updatedCode: r''' @@ -17225,15 +17225,15 @@ class B extends A { foo=: #M3 B: #M4 declaredConflicts - foo: #M7 - foo=: #M7 + foo: #M6 + foo=: #M6 declaredMethods - zzz: #M8 + zzz: #M7 interface map - foo: #M9 + foo: #M6 foo=: #M3 - zzz: #M8 + zzz: #M7 ''', ); } @@ -17268,7 +17268,7 @@ class B extends A { foo=: #M3 interface map - foo: #M4 + foo: #M3 ''', updatedCode: r''' class A { @@ -17294,14 +17294,14 @@ class B extends A { foo: #M1 B: #M2 declaredConflicts - foo: #M5 - foo=: #M5 + foo: #M4 + foo=: #M4 declaredMethods - zzz: #M6 + zzz: #M5 interface map - foo: #M7 - zzz: #M6 + foo: #M4 + zzz: #M5 ''', ); } @@ -17338,7 +17338,7 @@ class B extends A { foo=: #M4 interface map - foo: #M5 + foo: #M4 foo=: #M2 ''', updatedCode: r''' @@ -17367,15 +17367,15 @@ class B extends A { foo=: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo: #M8 + foo: #M5 foo=: #M2 - zzz: #M7 + zzz: #M6 ''', ); } @@ -17759,7 +17759,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -17775,14 +17775,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -17808,7 +17808,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -17825,14 +17825,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -17858,8 +17858,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -17876,15 +17876,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -17909,7 +17909,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -17925,14 +17925,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -17957,8 +17957,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -17974,15 +17974,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -18008,8 +18008,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -18026,15 +18026,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -18403,7 +18403,7 @@ class A { foo=: #M1 interface map - foo=: #M2 + foo=: #M1 ''', updatedCode: r''' class A { @@ -18419,14 +18419,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo=: #M5 - zzz: #M4 + foo=: #M2 + zzz: #M3 ''', ); } @@ -18807,7 +18807,7 @@ class A { foo=: #M1 interface map - foo=: #M2 + foo=: #M1 ''', updatedCode: r''' class A { @@ -18823,14 +18823,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo=: #M5 - zzz: #M4 + foo=: #M2 + zzz: #M3 ''', ); } @@ -18868,7 +18868,7 @@ class B extends A { interface map foo: #M2 - foo=: #M5 + foo=: #M4 ''', updatedCode: r''' class A { @@ -18896,15 +18896,15 @@ class B extends A { foo: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map foo: #M2 - foo=: #M8 - zzz: #M7 + foo=: #M5 + zzz: #M6 ''', ); } @@ -18946,7 +18946,7 @@ class B extends A { interface map foo: #M2 - foo=: #M6 + foo=: #M5 ''', updatedCode: r''' class A { @@ -18978,15 +18978,15 @@ class B extends A { foo=: #M3 B: #M4 declaredConflicts - foo: #M7 - foo=: #M7 + foo: #M6 + foo=: #M6 declaredMethods - zzz: #M8 + zzz: #M7 interface map foo: #M2 - foo=: #M9 - zzz: #M8 + foo=: #M6 + zzz: #M7 ''', ); } @@ -19022,7 +19022,7 @@ class B extends A { interface map foo: #M1 - foo=: #M4 + foo=: #M3 ''', updatedCode: r''' class A { @@ -19048,15 +19048,15 @@ class B extends A { foo: #M1 B: #M2 declaredConflicts - foo: #M5 - foo=: #M5 + foo: #M4 + foo=: #M4 declaredMethods - zzz: #M6 + zzz: #M5 interface map foo: #M1 - foo=: #M7 - zzz: #M6 + foo=: #M4 + zzz: #M5 ''', ); } @@ -19093,7 +19093,7 @@ class B extends A { foo=: #M4 interface map - foo=: #M5 + foo=: #M4 ''', updatedCode: r''' class A { @@ -19121,14 +19121,14 @@ class B extends A { foo=: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo=: #M8 - zzz: #M7 + foo=: #M5 + zzz: #M6 ''', ); } @@ -20743,7 +20743,7 @@ class A { []=: #M1 interface map - []: #M2 + []: #M1 ''', updatedCode: r''' class A { @@ -20758,14 +20758,14 @@ class A { manifest A: #M0 declaredConflicts - []: #M3 - []=: #M3 + []: #M2 + []=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - []: #M5 - zzz: #M4 + []: #M2 + zzz: #M3 ''', ); } @@ -20837,8 +20837,8 @@ class A { []=: #M1 interface map - []: #M2 - []=: #M3 + []: #M1 + []=: #M1 ''', updatedCode: r''' class A { @@ -20854,15 +20854,15 @@ class A { manifest A: #M0 declaredConflicts - []: #M4 - []=: #M4 + []: #M2 + []=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - []: #M6 - []=: #M7 - zzz: #M5 + []: #M2 + []=: #M2 + zzz: #M3 ''', ); } @@ -21240,7 +21240,7 @@ class A { []=: #M1 interface map - []=: #M2 + []=: #M1 ''', updatedCode: r''' class A { @@ -21255,14 +21255,14 @@ class A { manifest A: #M0 declaredConflicts - []: #M3 - []=: #M3 + []: #M2 + []=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - []=: #M5 - zzz: #M4 + []=: #M2 + zzz: #M3 ''', ); } @@ -21456,7 +21456,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -21471,14 +21471,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -21557,8 +21557,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -21574,15 +21574,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -21922,7 +21922,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -21937,14 +21937,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -21980,7 +21980,7 @@ class B extends A { foo=: #M4 interface map - foo: #M5 + foo: #M4 ''', updatedCode: r''' class A { @@ -22007,14 +22007,14 @@ class B extends A { foo: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo: #M8 - zzz: #M7 + foo: #M5 + zzz: #M6 ''', ); } @@ -22054,7 +22054,7 @@ class B extends A { foo=: #M5 interface map - foo: #M6 + foo: #M5 foo=: #M3 ''', updatedCode: r''' @@ -22086,15 +22086,15 @@ class B extends A { foo=: #M3 B: #M4 declaredConflicts - foo: #M7 - foo=: #M7 + foo: #M6 + foo=: #M6 declaredMethods - zzz: #M8 + zzz: #M7 interface map - foo: #M9 + foo: #M6 foo=: #M3 - zzz: #M8 + zzz: #M7 ''', ); } @@ -22128,7 +22128,7 @@ class B extends A { foo=: #M3 interface map - foo: #M4 + foo: #M3 ''', updatedCode: r''' class A { @@ -22153,14 +22153,14 @@ class B extends A { foo: #M1 B: #M2 declaredConflicts - foo: #M5 - foo=: #M5 + foo: #M4 + foo=: #M4 declaredMethods - zzz: #M6 + zzz: #M5 interface map - foo: #M7 - zzz: #M6 + foo: #M4 + zzz: #M5 ''', ); } @@ -22196,7 +22196,7 @@ class B extends A { foo=: #M4 interface map - foo: #M5 + foo: #M4 foo=: #M2 ''', updatedCode: r''' @@ -22224,15 +22224,15 @@ class B extends A { foo=: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo: #M8 + foo: #M5 foo=: #M2 - zzz: #M7 + zzz: #M6 ''', ); } @@ -22585,7 +22585,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -22600,14 +22600,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -22632,7 +22632,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -22648,14 +22648,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -22680,8 +22680,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -22697,15 +22697,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -22731,8 +22731,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -22749,15 +22749,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -22781,7 +22781,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -22796,14 +22796,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo: #M5 - zzz: #M4 + foo: #M2 + zzz: #M3 ''', ); } @@ -22827,8 +22827,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -22843,15 +22843,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -22876,8 +22876,8 @@ class A { foo=: #M1 interface map - foo: #M2 - foo=: #M3 + foo: #M1 + foo=: #M1 ''', updatedCode: r''' class A { @@ -22893,15 +22893,15 @@ class A { manifest A: #M0 declaredConflicts - foo: #M4 - foo=: #M4 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M5 + zzz: #M3 interface map - foo: #M6 - foo=: #M7 - zzz: #M5 + foo: #M2 + foo=: #M2 + zzz: #M3 ''', ); } @@ -23239,7 +23239,7 @@ class A { foo=: #M1 interface map - foo=: #M2 + foo=: #M1 ''', updatedCode: r''' class A { @@ -23254,14 +23254,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo=: #M5 - zzz: #M4 + foo=: #M2 + zzz: #M3 ''', ); } @@ -23617,7 +23617,7 @@ class A { foo=: #M1 interface map - foo=: #M2 + foo=: #M1 ''', updatedCode: r''' class A { @@ -23632,14 +23632,14 @@ class A { manifest A: #M0 declaredConflicts - foo: #M3 - foo=: #M3 + foo: #M2 + foo=: #M2 declaredMethods - zzz: #M4 + zzz: #M3 interface map - foo=: #M5 - zzz: #M4 + foo=: #M2 + zzz: #M3 ''', ); } @@ -23676,7 +23676,7 @@ class B extends A { interface map foo: #M2 - foo=: #M5 + foo=: #M4 ''', updatedCode: r''' class A { @@ -23703,15 +23703,15 @@ class B extends A { foo: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map foo: #M2 - foo=: #M8 - zzz: #M7 + foo=: #M5 + zzz: #M6 ''', ); } @@ -23752,7 +23752,7 @@ class B extends A { interface map foo: #M2 - foo=: #M6 + foo=: #M5 ''', updatedCode: r''' class A { @@ -23783,15 +23783,15 @@ class B extends A { foo=: #M3 B: #M4 declaredConflicts - foo: #M7 - foo=: #M7 + foo: #M6 + foo=: #M6 declaredMethods - zzz: #M8 + zzz: #M7 interface map foo: #M2 - foo=: #M9 - zzz: #M8 + foo=: #M6 + zzz: #M7 ''', ); } @@ -23826,7 +23826,7 @@ class B extends A { interface map foo: #M1 - foo=: #M4 + foo=: #M3 ''', updatedCode: r''' class A { @@ -23851,15 +23851,15 @@ class B extends A { foo: #M1 B: #M2 declaredConflicts - foo: #M5 - foo=: #M5 + foo: #M4 + foo=: #M4 declaredMethods - zzz: #M6 + zzz: #M5 interface map foo: #M1 - foo=: #M7 - zzz: #M6 + foo=: #M4 + zzz: #M5 ''', ); } @@ -23895,7 +23895,7 @@ class B extends A { foo=: #M4 interface map - foo=: #M5 + foo=: #M4 ''', updatedCode: r''' class A { @@ -23922,14 +23922,14 @@ class B extends A { foo=: #M2 B: #M3 declaredConflicts - foo: #M6 - foo=: #M6 + foo: #M5 + foo=: #M5 declaredMethods - zzz: #M7 + zzz: #M6 interface map - foo=: #M8 - zzz: #M7 + foo=: #M5 + zzz: #M6 ''', ); } @@ -25281,10 +25281,9 @@ class B = A with M; foo: #M1 foo=: #M1 B: #M2 - declaredConflicts - foo: #M3 - foo=: #M3 - M: #M4 + inheritedConstructors + foo: #M1 + M: #M3 ''', updatedCode: r''' mixin M {} @@ -25303,14 +25302,13 @@ class Z {} manifest A: #M0 declaredConflicts - foo: #M5 - foo=: #M5 + foo: #M4 + foo=: #M4 B: #M2 - declaredConflicts - foo: #M6 - foo=: #M6 - M: #M4 - Z: #M7 + inheritedConstructors + foo: #M4 + M: #M3 + Z: #M5 ''', ); } @@ -28642,7 +28640,7 @@ class A { foo=: #M3 interface map - foo: #M4 + foo: #M3 ''', ); } @@ -28684,7 +28682,7 @@ class A { foo=: #M3 interface map - foo: #M2 + foo: #M3 ''', ); } @@ -28726,7 +28724,7 @@ class A { foo=: #M3 interface map - foo: #M2 + foo: #M3 ''', ); } @@ -28768,7 +28766,7 @@ class A { foo=: #M3 interface map - foo: #M2 + foo: #M3 ''', ); } @@ -30099,7 +30097,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30112,10 +30110,10 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30139,7 +30137,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30152,10 +30150,10 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30179,7 +30177,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30192,7 +30190,7 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 ''', ); } @@ -30216,7 +30214,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30229,10 +30227,10 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30256,7 +30254,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30269,10 +30267,10 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30296,7 +30294,7 @@ class A { foo=: #M1 interface map - foo: #M2 + foo: #M1 ''', updatedCode: r''' class A { @@ -30309,7 +30307,7 @@ class A { manifest A: #M0 declaredMethods - foo: #M3 + foo: #M2 ''', ); } @@ -30727,7 +30725,7 @@ class A { foo=: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30767,7 +30765,7 @@ class A { foo=: #M2 interface map - foo: #M1 + foo: #M2 ''', ); } @@ -30807,7 +30805,7 @@ class A { foo=: #M2 interface map - foo: #M1 + foo: #M2 ''', ); } @@ -30847,7 +30845,7 @@ class A { foo=: #M2 interface map - foo: #M1 + foo: #M2 ''', ); } @@ -30884,7 +30882,7 @@ class A { foo=: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -30921,7 +30919,7 @@ class A { foo=: #M2 interface map - foo: #M3 + foo: #M2 ''', ); } @@ -31947,7 +31945,7 @@ class A { foo=: #M3 interface map - foo=: #M4 + foo=: #M3 ''', ); } @@ -31989,7 +31987,7 @@ class A { foo=: #M3 interface map - foo=: #M2 + foo=: #M3 ''', ); } @@ -32031,7 +32029,7 @@ class A { foo=: #M3 interface map - foo=: #M2 + foo=: #M3 ''', ); } @@ -32073,7 +32071,7 @@ class A { foo=: #M3 interface map - foo=: #M2 + foo=: #M3 ''', ); } diff --git a/pkg/analyzer/test/src/dart/analysis/result_printer.dart b/pkg/analyzer/test/src/dart/analysis/result_printer.dart index 71e5def4ed9..d9ec9820bc4 100644 --- a/pkg/analyzer/test/src/dart/analysis/result_printer.dart +++ b/pkg/analyzer/test/src/dart/analysis/result_printer.dart @@ -12,7 +12,6 @@ import 'package:analyzer/src/dart/analysis/driver_event.dart' as events; import 'package:analyzer/src/dart/analysis/library_graph.dart'; import 'package:analyzer/src/dart/analysis/results.dart'; import 'package:analyzer/src/dart/analysis/status.dart'; -import 'package:analyzer/src/fine/base_name_members.dart'; import 'package:analyzer/src/fine/library_manifest.dart'; import 'package:analyzer/src/fine/lookup_name.dart'; import 'package:analyzer/src/fine/manifest_ast.dart'; @@ -103,10 +102,38 @@ class BundleRequirementsPrinter { _writeNamedId, ); }); + // sink.withIndent(() { + // sink.writeElements( + // 'requestedGetters', + // instanceEntry.value.requestedGetters.sorted, + // _writeNamedId, + // ); + // }); + // sink.withIndent(() { + // sink.writeElements( + // 'requestedSetters', + // instanceEntry.value.requestedSetters.sorted, + // _writeNamedId, + // ); + // }); + // sink.withIndent(() { + // sink.writeElements( + // 'requestedMethods', + // instanceEntry.value.requestedMethods.sorted, + // _writeNamedId, + // ); + // }); + + // TODO(scheglov): separate requestedXyz. + var requestedMethods = { + ...instanceEntry.value.requestedGetters, + ...instanceEntry.value.requestedSetters, + ...instanceEntry.value.requestedMethods, + }; sink.withIndent(() { sink.writeElements( 'requestedMethods', - instanceEntry.value.requestedMethods.sorted, + requestedMethods.sorted, _writeNamedId, ); }); @@ -833,30 +860,16 @@ class LibraryManifestPrinter { void _writeInstanceItemMembers(InstanceItem item) { var ignored = configuration.ignoredManifestInstanceMemberNames; - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString); - }).toList(); - var conflicts = - declaredMembers - .map((e) => (e.key, e.value)) - .where((e) => e.$2 is BaseNameConflict) - .toList(); - var conflictNames = conflicts.map((e) => e.$1).toSet(); - - void writeDeclaredConflicts() { + void writeDeclaredDuplicateNames() { + var conflicts = item.declaredConflicts.sorted; if (conflicts.isNotEmpty) { sink.writelnWithIndent('declaredConflicts'); sink.withIndent(() { for (var entry in conflicts) { - var baseName = entry.$1; - var value = entry.$2; - if (value is BaseNameConflict) { - var idStr = idProvider.manifestId(value.id); - sink.writelnWithIndent('$baseName: $idStr'); - sink.writelnWithIndent('$baseName=: $idStr'); - } + var name = entry.key.asString; + var idStr = idProvider.manifestId(entry.value); + sink.writelnWithIndent('$name: $idStr'); } }); } @@ -865,8 +878,7 @@ class LibraryManifestPrinter { void writeDeclaredFields() { var declaredFields = item.declaredFields.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + return ignored.contains(entry.key.asString); }).toList(); if (declaredFields.isNotEmpty) { @@ -890,34 +902,24 @@ class LibraryManifestPrinter { } void writeDeclaredGetters() { - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + var declaredGetters = + item.declaredGetters.sorted.whereNot((entry) { + return ignored.contains(entry.key.asString); }).toList(); - var getters = - declaredMembers - .map((e) => (e.key, e.value.declaredGetter)) - .where((e) => e.$2 != null) - .toList(); - if (getters.isNotEmpty) { + if (declaredGetters.isNotEmpty) { sink.writelnWithIndent('declaredGetters'); sink.withIndent(() { - for (var entry in getters) { - var baseName = entry.$1; - var item = entry.$2; - if (item is! BaseNameConflict) { - if (item != null) { - var idStr = idProvider.manifestId(item.id); - sink.writelnWithIndent('$baseName: $idStr'); - if (configuration.withElementManifests) { - sink.withIndent(() { - _writeMetadata(item); - _writeNamedType('returnType', item.returnType); - }); - } - } + for (var entry in declaredGetters) { + var name = entry.key.asString; + var item = entry.value; + var idStr = idProvider.manifestId(item.id); + sink.writelnWithIndent('$name: $idStr'); + if (configuration.withElementManifests) { + sink.withIndent(() { + _writeMetadata(item); + _writeNamedType('returnType', item.returnType); + }); } } }); @@ -925,32 +927,24 @@ class LibraryManifestPrinter { } void writeDeclaredSetters() { - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + var declaredSetters = + item.declaredSetters.sorted.whereNot((entry) { + return ignored.contains(entry.key.asString); }).toList(); - var setters = - declaredMembers - .map((e) => (e.key, e.value.declaredSetter)) - .where((e) => e.$2 != null) - .toList(); - if (setters.isNotEmpty) { + if (declaredSetters.isNotEmpty) { sink.writelnWithIndent('declaredSetters'); sink.withIndent(() { - for (var entry in setters) { - var baseName = entry.$1; - var item = entry.$2; - if (item != null) { - var idStr = idProvider.manifestId(item.id); - sink.writelnWithIndent('$baseName=: $idStr'); - if (configuration.withElementManifests) { - sink.withIndent(() { - _writeMetadata(item); - _writeNamedType('valueType', item.valueType); - }); - } + for (var entry in declaredSetters) { + var name = entry.key.asString; + var item = entry.value; + var idStr = idProvider.manifestId(item.id); + sink.writelnWithIndent('$name: $idStr'); + if (configuration.withElementManifests) { + sink.withIndent(() { + _writeMetadata(item); + _writeNamedType('valueType', item.valueType); + }); } } }); @@ -958,39 +952,24 @@ class LibraryManifestPrinter { } void writeDeclaredMethods() { - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + var declaredMethods = + item.declaredMethods.sorted.whereNot((entry) { + return ignored.contains(entry.key.asString); }).toList(); - var methods = - declaredMembers - .map((e) => (e.key.asString, e.value.declaredMethod)) - .where((e) => e.$2 != null) - .toList(); - methods.addAll( - declaredMembers - .map((e) => ('${e.key}=', e.value.declaredIndexEq)) - .where((e) => e.$2 != null) - .toList(), - ); - methods.sortBy((e) => e.$1); - if (methods.isNotEmpty) { + if (declaredMethods.isNotEmpty) { sink.writelnWithIndent('declaredMethods'); sink.withIndent(() { - for (var entry in methods) { - var lookupNameStr = entry.$1; - var item = entry.$2; - if (item != null) { - var idStr = idProvider.manifestId(item.id); - sink.writelnWithIndent('$lookupNameStr: $idStr'); - if (configuration.withElementManifests) { - sink.withIndent(() { - _writeMetadata(item); - _writeNamedType('functionType', item.functionType); - }); - } + for (var entry in declaredMethods) { + var name = entry.key.asString; + var item = entry.value; + var idStr = idProvider.manifestId(item.id); + sink.writelnWithIndent('$name: $idStr'); + if (configuration.withElementManifests) { + sink.withIndent(() { + _writeMetadata(item); + _writeNamedType('functionType', item.functionType); + }); } } }); @@ -998,32 +977,26 @@ class LibraryManifestPrinter { } void writeDeclaredConstructors() { - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + var declaredConstructors = + item.declaredConstructors.sorted.whereNot((entry) { + return ignored.contains(entry.key.asString); }).toList(); - var constructors = - declaredMembers - .map((e) => (e.key, e.value.declaredConstructor)) - .where((e) => e.$2 != null) - .toList(); - if (constructors.isNotEmpty) { + if (declaredConstructors.isNotEmpty) { sink.writelnWithIndent('declaredConstructors'); sink.withIndent(() { - for (var entry in constructors) { - var baseName = entry.$1; - var item = entry.$2; - if (item != null) { - var idStr = idProvider.manifestId(item.id); - sink.writelnWithIndent('$baseName: $idStr'); - if (configuration.withElementManifests) { + for (var entry in declaredConstructors) { + var name = entry.key.asString; + var item = entry.value; + var idStr = idProvider.manifestId(item.id); + sink.writelnWithIndent('$name: $idStr'); + if (configuration.withElementManifests) { + sink.withIndent(() { sink.withIndent(() { _writeMetadata(item); _writeNamedType('functionType', item.functionType); }); - } + }); } } }); @@ -1031,34 +1004,24 @@ class LibraryManifestPrinter { } void writeInheritedConstructors() { - var declaredMembers = - item.declaredMembers.sorted.whereNot((entry) { - return ignored.contains(entry.key.asString) || - conflictNames.contains(entry.key); + var inheritedConstructors = + item.inheritedConstructors.sorted.whereNot((entry) { + return ignored.contains(entry.key.asString); }).toList(); - var constructors = - declaredMembers - .where((e) => e.value.declaredConstructor == null) - .map((e) => (e.key, e.value.constructorId)) - .where((e) => e.$2 != null) - .toList(); - if (constructors.isNotEmpty) { + if (inheritedConstructors.isNotEmpty) { sink.writelnWithIndent('inheritedConstructors'); sink.withIndent(() { - for (var entry in constructors) { - var baseName = entry.$1; - var id = entry.$2; - if (id != null) { - var idStr = idProvider.manifestId(id); - sink.writelnWithIndent('$baseName: $idStr'); - } + for (var entry in inheritedConstructors) { + var name = entry.key.asString; + var idStr = idProvider.manifestId(entry.value); + sink.writelnWithIndent('$name: $idStr'); } }); } } - writeDeclaredConflicts(); + writeDeclaredDuplicateNames(); writeDeclaredFields(); writeDeclaredGetters(); writeDeclaredSetters(); @@ -1511,12 +1474,6 @@ extension on Map { } } -extension on Map { - List> get sorted { - return entries.sortedByCompare((entry) => entry.key, BaseName.compare); - } -} - extension on Map { List> get sorted { return entries.sortedBy((entry) => entry.key.toString());