dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Fine. Use separate declaredXyz in InstanceItem.

Browse Source 
This simplifies the implementation, even if makes it less cool.

Change-Id: I9418f959ca36455a1fff59cd4f980b319351d987
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/428562
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Paul Berry <paulberry@google.com>
This commit is contained in:
Konstantin Shcheglov
2025-05-15 19:26:43 -07:00
committed by Commit Queue
parent 69cb105a5f
commit 72b0d2d2af
7 changed files with 910 additions and 1436 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/analyzer/lib/src/fine/base_name_members.dart
-876
View File
@@ -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<BaseName, BaseNameMembers> 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<BaseName, BaseNameMembers> {
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),
);
}
}
pkg/analyzer/lib/src/fine/library_manifest.dart
+54 -31
View File
@@ -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;
}
pkg/analyzer/lib/src/fine/lookup_name.dart
+46
View File
@@ -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<LookupName> 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);
}
pkg/analyzer/lib/src/fine/manifest_item.dart
+332 -68
View File
@@ -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<ClassElementImpl2> {
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<ClassElementImpl2> {
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<ClassElementImpl2> {
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<E extends InstanceElementImpl2>
extends TopLevelItem<E> {
final List<ManifestTypeParameter> typeParameters;
final Map<LookupName, InstanceItemFieldItem> declaredFields;
/// The names of duplicate or otherwise conflicting members.
/// Such names will not be added to `declaredXyz` maps.
final Map<LookupName, ManifestItemId> 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<BaseName, BaseNameMembers> declaredMembers;
final Map<LookupName, InstanceItemFieldItem> declaredFields;
final Map<LookupName, InstanceItemGetterItem> declaredGetters;
final Map<LookupName, InstanceItemSetterItem> declaredSetters;
final Map<LookupName, InstanceItemMethodItem> declaredMethods;
final Map<LookupName, InterfaceItemConstructorItem> declaredConstructors;
final Map<LookupName, ManifestItemId> 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<GetterElementImpl> {
void writeKind(BufferedSink sink) {
sink.writeEnum(_InstanceItemMemberItemKind.getter);
}
static Map<LookupName, InstanceItemGetterItem> readMap(
SummaryDataReader reader,
) {
return reader.readMap(
readKey: () => LookupName.read(reader),
readValue: () => InstanceItemGetterItem.read(reader),
);
}
}
sealed class InstanceItemMemberItem<E extends AnnotatableElementImpl>
@@ -369,6 +533,15 @@ class InstanceItemMethodItem
void writeKind(BufferedSink sink) {
sink.writeEnum(_InstanceItemMemberItemKind.method);
}
static Map<LookupName, InstanceItemMethodItem> readMap(
SummaryDataReader reader,
) {
return reader.readMap(
readKey: () => LookupName.read(reader),
readValue: () => InstanceItemMethodItem.read(reader),
);
}
}
class InstanceItemSetterItem extends InstanceItemMemberItem<SetterElementImpl> {
@@ -422,6 +595,15 @@ class InstanceItemSetterItem extends InstanceItemMemberItem<SetterElementImpl> {
void writeKind(BufferedSink sink) {
sink.writeEnum(_InstanceItemMemberItemKind.setter);
}
static Map<LookupName, InstanceItemSetterItem> 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<E extends InterfaceElementImpl2>
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<LookupName, InterfaceItemConstructorItem> 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<MixinElementImpl2> {
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<MixinElementImpl2> {
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<MixinElementImpl2> {
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<LookupName, InstanceItemFieldItem> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
}
extension LookupNameIdMapExtension on Map<LookupName, ManifestItemId> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
static Map<LookupName, ManifestItemId> 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<LookupName, ManifestItemId> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
static Map<LookupName, ManifestItemId> read(SummaryDataReader reader) {
return reader.readMap(
readKey: () => LookupName.read(reader),
readValue: () => ManifestItemId.read(reader),
);
}
}
extension _LookupNameToInstanceItemFieldItemMapExtension
on Map<LookupName, InstanceItemFieldItem> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
}
extension _LookupNameToInstanceItemGetterItemMapExtension
on Map<LookupName, InstanceItemGetterItem> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
}
extension _LookupNameToInstanceItemMethodItemMapExtension
on Map<LookupName, InstanceItemMethodItem> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
}
extension _LookupNameToInstanceItemSetterItemMapExtension
on Map<LookupName, InstanceItemSetterItem> {
void write(BufferedSink sink) {
sink.writeMap(
this,
writeKey: (name) => name.write(sink),
writeValue: (items) => items.write(sink),
);
}
}
extension _LookupNameToInterfaceItemConstructorItemMapExtension
on Map<LookupName, InterfaceItemConstructorItem> {
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<LookupName, ManifestItemId> readLookupNameToIdMap() {
return readMap(
readKey: () => LookupName.read(this),
readValue: () => ManifestItemId.read(this),
);
}
}
pkg/analyzer/lib/src/fine/requirements.dart
+69 -7
View File
@@ -191,28 +191,39 @@ final class ExportRequirementShowCombinator
/// of [InterfaceItemRequirements].
class InstanceItemRequirements {
final Map<LookupName, ManifestItemId?> requestedFields;
/// These are "methods" in wide meaning: methods, getters, setters.
final Map<LookupName, ManifestItemId?> requestedGetters;
final Map<LookupName, ManifestItemId?> requestedSetters;
final Map<LookupName, ManifestItemId?> 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({
pkg/analyzer/test/src/dart/analysis/driver_test.dart
+311 -313
View File
File diff suppressed because it is too large Load Diff
pkg/analyzer/test/src/dart/analysis/result_printer.dart
+98 -141
View File
@@ -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<V> on Map<LookupName, V> {
}
}
extension<V> on Map<BaseName, V> {
List<MapEntry<BaseName, V>> get sorted {
return entries.sortedByCompare((entry) => entry.key, BaseName.compare);
}
}
extension<V> on Map<Uri, V> {
List<MapEntry<Uri, V>> get sorted {
return entries.sortedBy((entry) => entry.key.toString());