blob: 6400c29adc4bb008faf5d2fff8067ab34de9e5f1 [file] [log] [blame]
// Copyright (c) 2020, 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 'dart:typed_data';
import 'package:analyzer/dart/analysis/features.dart';
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/analysis/experiments.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/member.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/dart/element/type_algebra.dart';
import 'package:analyzer/src/dart/resolver/variance.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
import 'package:analyzer/src/summary2/ast_binary_reader.dart';
import 'package:analyzer/src/summary2/ast_binary_tag.dart';
import 'package:analyzer/src/summary2/data_reader.dart';
import 'package:analyzer/src/summary2/element_flags.dart';
import 'package:analyzer/src/summary2/informative_data.dart';
import 'package:analyzer/src/summary2/linked_element_factory.dart';
import 'package:analyzer/src/summary2/reference.dart';
import 'package:analyzer/src/task/inference_error.dart';
import 'package:pub_semver/pub_semver.dart';
class BundleReader {
final SummaryDataReader _reader;
final Map<Uri, Uint8List> _unitsInformativeBytes;
final Map<String, LibraryReader> libraryMap = {};
BundleReader({
required LinkedElementFactory elementFactory,
required Uint8List resolutionBytes,
Map<Uri, Uint8List> unitsInformativeBytes = const {},
}) : _reader = SummaryDataReader(resolutionBytes),
_unitsInformativeBytes = unitsInformativeBytes {
_reader.offset = _reader.bytes.length - 4 * 4;
var baseResolutionOffset = _reader.readUInt32();
var librariesOffset = _reader.readUInt32();
var referencesOffset = _reader.readUInt32();
var stringsOffset = _reader.readUInt32();
_reader.createStringTable(stringsOffset);
var referenceReader = _ReferenceReader(
elementFactory,
_reader,
referencesOffset,
);
_reader.offset = librariesOffset;
var libraryHeaderList = _reader.readTypedList(() {
return _LibraryHeader(
uriStr: _reader.readStringReference(),
offset: _reader.readUInt30(),
classMembersLengths: _reader.readUInt30List(),
);
});
for (var libraryHeader in libraryHeaderList) {
var uriStr = libraryHeader.uriStr;
var reference = elementFactory.rootReference.getChild(uriStr);
libraryMap[uriStr] = LibraryReader._(
elementFactory: elementFactory,
reader: _reader,
unitsInformativeBytes: _unitsInformativeBytes,
baseResolutionOffset: baseResolutionOffset,
referenceReader: referenceReader,
reference: reference,
offset: libraryHeader.offset,
classMembersLengths: libraryHeader.classMembersLengths,
);
}
}
}
class ClassElementLinkedData extends ElementLinkedData<ClassElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
void Function()? _readMembers;
void Function()? applyInformativeDataToMembers;
ClassElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
/// Ensure that all members of the [element] are available. This includes
/// being able to ask them for example using [ClassElement.methods], and
/// as well access them through their [Reference]s. For a class declaration
/// this means reading them, for a named mixin application this means
/// computing constructors.
void readMembers(ClassElementImpl element) {
if (element.isMixinApplication) {
element.constructors;
} else {
_readMembers?.call();
_readMembers = null;
applyInformativeDataToMembers?.call();
applyInformativeDataToMembers = null;
}
}
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
_readTypeParameters(reader, element.typeParameters);
element.supertype = reader._readOptionalInterfaceType();
element.mixins = reader._readInterfaceTypeList();
element.interfaces = reader._readInterfaceTypeList();
applyConstantOffsets?.perform();
}
}
class CompilationUnitElementLinkedData
extends ElementLinkedData<CompilationUnitElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
CompilationUnitElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
applyConstantOffsets?.perform();
}
}
class ConstructorElementLinkedData
extends ElementLinkedData<ConstructorElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
ConstructorElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
_addEnclosingElementTypeParameters(reader, element);
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
reader._addFormalParameters(element.parameters);
_readFormalParameters(reader, element.parameters);
element.superConstructor = reader.readElement() as ConstructorElement?;
element.redirectedConstructor = reader.readElement() as ConstructorElement?;
element.constantInitializers = reader._readNodeList();
applyConstantOffsets?.perform();
}
}
/// Lazy reader of resolution information.
abstract class ElementLinkedData<E extends ElementImpl> {
final Reference reference;
final LibraryReader _libraryReader;
final CompilationUnitElementImpl unitElement;
/// When this object is created, this offset is the offset of the resolution
/// information in the [_libraryReader]. After reading is done, this offset
/// is set to `-1`.
int _offset;
ElementLinkedData(
this.reference, LibraryReader libraryReader, this.unitElement, int offset)
: _libraryReader = libraryReader,
_offset = offset;
void read(ElementImpl element) {
if (_offset == -1) {
return null;
}
var dataReader = _libraryReader._reader.fork(_offset);
_offset = -1;
var reader = ResolutionReader(
_libraryReader._elementFactory,
_libraryReader._referenceReader,
dataReader,
);
_read(element as E, reader);
}
void _addEnclosingElementTypeParameters(
ResolutionReader reader,
ElementImpl element,
) {
var enclosing = element.enclosingElement;
if (enclosing is ClassElement) {
reader._addTypeParameters(enclosing.typeParameters);
} else if (enclosing is CompilationUnitElement) {
// Nothing.
} else if (enclosing is ExtensionElement) {
reader._addTypeParameters(enclosing.typeParameters);
} else {
throw UnimplementedError('${enclosing.runtimeType}');
}
}
void _read(E element, ResolutionReader reader);
void _readFormalParameters(
ResolutionReader reader,
List<ParameterElement> parameters,
) {
for (var parameter in parameters) {
parameter as ParameterElementImpl;
parameter.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
_readTypeParameters(reader, parameter.typeParameters);
_readFormalParameters(reader, parameter.parameters);
parameter.type = reader.readRequiredType();
if (parameter is ConstVariableElement) {
var defaultParameter = parameter as ConstVariableElement;
var initializer = reader._readOptionalExpression();
if (initializer != null) {
defaultParameter.constantInitializer = initializer;
}
}
if (parameter is FieldFormalParameterElementImpl) {
parameter.field = reader.readElement() as FieldElement?;
}
}
}
void _readTypeParameters(
ResolutionReader reader,
List<TypeParameterElement> typeParameters,
) {
reader._addTypeParameters(typeParameters);
for (var typeParameter in typeParameters) {
typeParameter as TypeParameterElementImpl;
typeParameter.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
typeParameter.bound = reader.readType();
typeParameter.defaultType = reader.readType();
}
}
}
class EnumElementLinkedData extends ElementLinkedData<EnumElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
EnumElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: element.enclosingElement,
);
_readTypeParameters(reader, element.typeParameters);
element.supertype = reader._readOptionalInterfaceType();
element.mixins = reader._readInterfaceTypeList();
element.interfaces = reader._readInterfaceTypeList();
applyConstantOffsets?.perform();
}
}
class ExtensionElementLinkedData
extends ElementLinkedData<ExtensionElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
ExtensionElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: element.enclosingElement,
);
_readTypeParameters(reader, element.typeParameters);
element.extendedType = reader.readRequiredType();
applyConstantOffsets?.perform();
}
}
class FieldElementLinkedData extends ElementLinkedData<FieldElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
FieldElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
_addEnclosingElementTypeParameters(reader, element);
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
element.type = reader.readRequiredType();
if (element is ConstFieldElementImpl) {
var initializer = reader._readOptionalExpression();
if (initializer != null) {
element.constantInitializer = initializer;
ConstantContextForExpressionImpl(initializer);
}
}
applyConstantOffsets?.perform();
}
}
class FunctionElementLinkedData extends ElementLinkedData<FunctionElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
FunctionElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
_readTypeParameters(reader, element.typeParameters);
element.returnType = reader.readRequiredType();
_readFormalParameters(reader, element.parameters);
applyConstantOffsets?.perform();
}
}
class LibraryElementLinkedData extends ElementLinkedData<LibraryElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
LibraryElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
LinkedElementFactory get elementFactory {
return _libraryReader._elementFactory;
}
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
for (var import in element.imports) {
import as ImportElementImpl;
import.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
import.importedLibrary = reader.readElement() as LibraryElementImpl?;
}
for (var export in element.exports) {
export as ExportElementImpl;
export.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
export.exportedLibrary = reader.readElement() as LibraryElementImpl?;
}
element.entryPoint = reader.readElement() as FunctionElement?;
applyConstantOffsets?.perform();
}
}
class LibraryReader {
final LinkedElementFactory _elementFactory;
final SummaryDataReader _reader;
final Map<Uri, Uint8List> _unitsInformativeBytes;
final int _baseResolutionOffset;
final _ReferenceReader _referenceReader;
final Reference _reference;
final int _offset;
final Uint32List _classMembersLengths;
int _classMembersLengthsIndex = 0;
late List<Reference> exports;
LibraryReader._({
required LinkedElementFactory elementFactory,
required SummaryDataReader reader,
required Map<Uri, Uint8List> unitsInformativeBytes,
required int baseResolutionOffset,
required _ReferenceReader referenceReader,
required Reference reference,
required int offset,
required Uint32List classMembersLengths,
}) : _elementFactory = elementFactory,
_reader = reader,
_unitsInformativeBytes = unitsInformativeBytes,
_baseResolutionOffset = baseResolutionOffset,
_referenceReader = referenceReader,
_reference = reference,
_offset = offset,
_classMembersLengths = classMembersLengths;
LibraryElementImpl readElement({required Source librarySource}) {
var analysisContext = _elementFactory.analysisContext;
var analysisSession = _elementFactory.analysisSession;
var sourceFactory = analysisContext.sourceFactory;
_reader.offset = _offset;
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var featureSet = _readFeatureSet();
var libraryElement = LibraryElementImpl(
analysisContext, analysisSession, name, -1, 0, featureSet);
_reference.element = libraryElement;
libraryElement.reference = _reference;
libraryElement.languageVersion = _readLanguageVersion();
libraryElement.imports = _reader.readTypedList(_readImportElement);
libraryElement.exports = _reader.readTypedList(_readExportElement);
LibraryElementFlags.read(_reader, libraryElement);
var unitContainerRef = _reference.getChild('@unit');
var unitCount = _reader.readUInt30();
var units = <CompilationUnitElementImpl>[];
for (var i = 0; i < unitCount; i++) {
var unitElement = _readUnitElement(
sourceFactory: sourceFactory,
unitContainerRef: unitContainerRef,
libraryElement: libraryElement,
librarySource: librarySource,
);
units.add(unitElement);
}
var exportsIndexList = _reader.readUInt30List();
exports = exportsIndexList
.map((index) => _referenceReader.referenceOfIndex(index))
.toList();
libraryElement.definingCompilationUnit = units[0];
libraryElement.parts = units.skip(1).toList();
libraryElement.linkedData = LibraryElementLinkedData(
reference: _reference,
libraryReader: this,
unitElement: units[0],
offset: resolutionOffset,
);
_declareDartCoreDynamicNever();
InformativeDataApplier(_elementFactory, _unitsInformativeBytes)
.applyTo(libraryElement);
return libraryElement;
}
/// These elements are implicitly declared in `dart:core`.
void _declareDartCoreDynamicNever() {
if (_reference.name == 'dart:core') {
_reference.getChild('dynamic').element = DynamicElementImpl.instance;
_reference.getChild('Never').element = NeverElementImpl.instance;
}
}
ClassElementImpl _readClassElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = unitReference.getChild('@class').getChild(name);
var element = ClassElementImpl(name, -1);
var linkedData = ClassElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
ClassElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
if (!element.isMixinApplication) {
var membersOffset = _reader.offset;
linkedData._readMembers = () {
_reader.offset = membersOffset;
_readClassElementMembers(unitElement, element, reference);
};
_reader.offset += _classMembersLengths[_classMembersLengthsIndex++];
}
return element;
}
void _readClassElementMembers(
CompilationUnitElementImpl unitElement,
ClassElementImpl element,
Reference reference,
) {
var accessors = <PropertyAccessorElementImpl>[];
var fields = <FieldElement>[];
_readFields(unitElement, element, reference, accessors, fields);
_readPropertyAccessors(
unitElement, element, reference, accessors, fields, '@field');
element.fields = fields;
element.accessors = accessors;
element.constructors = _readConstructors(unitElement, element, reference);
element.methods = _readMethods(unitElement, element, reference);
}
void _readClasses(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var length = _reader.readUInt30();
unitElement.classes = List.generate(length, (index) {
return _readClassElement(unitElement, unitReference);
});
}
List<ConstructorElementImpl> _readConstructors(
CompilationUnitElementImpl unitElement,
AbstractClassElementImpl classElement,
Reference classReference,
) {
var containerRef = classReference.getChild('@constructor');
var length = _reader.readUInt30();
return List.generate(length, (_) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = containerRef.getChild(name);
var element = ConstructorElementImpl(name, -1);
var linkedData = ConstructorElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
ConstructorElementFlags.read(_reader, element);
element.parameters = _readParameters(element, reference);
return element;
});
}
EnumElementImpl _readEnumElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = unitReference.getChild('@enum').getChild(name);
var element = EnumElementImpl(name, -1);
var linkedData = EnumElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
EnumElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
var accessors = <PropertyAccessorElement>[];
var fields = <FieldElement>[];
_readFields(unitElement, element, reference, accessors, fields);
_readPropertyAccessors(
unitElement, element, reference, accessors, fields, '@field');
element.fields = fields;
element.accessors = accessors;
element.constructors = _readConstructors(unitElement, element, reference);
element.methods = _readMethods(unitElement, element, reference);
return element;
}
void _readEnums(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var count = _reader.readUInt30();
unitElement.enums = List.generate(count, (_) {
return _readEnumElement(unitElement, unitReference);
});
}
ExportElementImpl _readExportElement() {
var element = ExportElementImpl(-1);
element.uri = _reader.readOptionalStringReference();
element.combinators = _reader.readTypedList(_readNamespaceCombinator);
return element;
}
ExtensionElementImpl _readExtensionElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readOptionalStringReference();
var refName = _reader.readStringReference();
var reference = unitReference.getChild('@extension').getChild(refName);
var element = ExtensionElementImpl(name, -1);
element.setLinkedData(
reference,
ExtensionElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
),
);
element.typeParameters = _readTypeParameters();
var accessors = <PropertyAccessorElement>[];
var fields = <FieldElement>[];
_readPropertyAccessors(
unitElement, element, reference, accessors, fields, '@field');
_readFields(unitElement, element, reference, accessors, fields);
element.accessors = accessors;
element.fields = fields;
element.methods = _readMethods(unitElement, element, reference);
return element;
}
void _readExtensions(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var count = _reader.readUInt30();
unitElement.extensions = List.generate(count, (_) {
return _readExtensionElement(unitElement, unitReference);
});
}
FeatureSet _readFeatureSet() {
var featureSetEncoded = _reader.readUint8List();
return ExperimentStatus.fromStorage(featureSetEncoded);
}
FieldElementImpl _readFieldElement(
CompilationUnitElementImpl unitElement,
ElementImpl classElement,
Reference classReference,
Reference containerRef,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var isConstElement = _reader.readBool();
var reference = containerRef.getChild(name);
FieldElementImpl element;
if (isConstElement) {
element = ConstFieldElementImpl(name, -1);
} else {
element = FieldElementImpl(name, -1);
}
var linkedData = FieldElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
FieldElementFlags.read(_reader, element);
element.typeInferenceError = _readTopLevelInferenceError();
element.createImplicitAccessors(classReference, name);
return element;
}
void _readFields(
CompilationUnitElementImpl unitElement,
ElementImpl classElement,
Reference classReference,
List<PropertyAccessorElement> accessors,
List<FieldElement> variables,
) {
var containerRef = classReference.getChild('@field');
var createdElements = <FieldElement>[];
var variableElementCount = _reader.readUInt30();
for (var i = 0; i < variableElementCount; i++) {
var variable = _readFieldElement(
unitElement, classElement, classReference, containerRef);
createdElements.add(variable);
variables.add(variable);
var getter = variable.getter;
if (getter is PropertyAccessorElementImpl) {
accessors.add(getter);
}
var setter = variable.setter;
if (setter is PropertyAccessorElementImpl) {
accessors.add(setter);
}
}
}
void _readFunctions(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var count = _reader.readUInt30();
unitElement.functions = List.generate(count, (_) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = unitReference.getChild('@function').getChild(name);
var element = FunctionElementImpl(name, -1);
var linkedData = FunctionElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
FunctionElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
element.parameters = _readParameters(element, reference);
return element;
});
}
ImportElementImpl _readImportElement() {
var element = ImportElementImpl(-1);
ImportElementFlags.read(_reader, element);
element.uri = _reader.readOptionalStringReference();
var prefixName = _reader.readOptionalStringReference();
if (prefixName != null) {
var reference = _reference.getChild('@prefix').getChild(prefixName);
var prefixElement =
PrefixElementImpl(prefixName, -1, reference: reference);
element.prefix = prefixElement;
}
element.combinators = _reader.readTypedList(_readNamespaceCombinator);
return element;
}
LibraryLanguageVersion _readLanguageVersion() {
var packageMajor = _reader.readUInt30();
var packageMinor = _reader.readUInt30();
var package = Version(packageMajor, packageMinor, 0);
Version? override;
if (_reader.readBool()) {
var overrideMajor = _reader.readUInt30();
var overrideMinor = _reader.readUInt30();
override = Version(overrideMajor, overrideMinor, 0);
}
return LibraryLanguageVersion(package: package, override: override);
}
List<MethodElementImpl> _readMethods(
CompilationUnitElementImpl unitElement,
ElementImpl enclosingElement,
Reference enclosingReference,
) {
var containerRef = enclosingReference.getChild('@method');
var length = _reader.readUInt30();
return List.generate(length, (_) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = containerRef.getChild(name);
var element = MethodElementImpl(name, -1);
var linkedData = MethodElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
MethodElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
element.parameters = _readParameters(element, reference);
element.typeInferenceError = _readTopLevelInferenceError();
return element;
});
}
MixinElementImpl _readMixinElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = unitReference.getChild('@mixin').getChild(name);
var element = MixinElementImpl(name, -1);
var linkedData = MixinElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
MixinElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
var fields = <FieldElement>[];
var accessors = <PropertyAccessorElement>[];
_readFields(unitElement, element, reference, accessors, fields);
_readPropertyAccessors(
unitElement, element, reference, accessors, fields, '@field');
element.fields = fields;
element.accessors = accessors;
element.constructors = _readConstructors(unitElement, element, reference);
element.methods = _readMethods(unitElement, element, reference);
element.superInvokedNames = _reader.readStringReferenceList();
return element;
}
void _readMixins(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var length = _reader.readUInt30();
unitElement.mixins = List.generate(length, (index) {
return _readMixinElement(unitElement, unitReference);
});
}
NamespaceCombinator _readNamespaceCombinator() {
var tag = _reader.readByte();
if (tag == Tag.HideCombinator) {
var combinator = HideElementCombinatorImpl();
combinator.hiddenNames = _reader.readStringReferenceList();
return combinator;
} else if (tag == Tag.ShowCombinator) {
var combinator = ShowElementCombinatorImpl();
combinator.shownNames = _reader.readStringReferenceList();
return combinator;
} else {
throw UnimplementedError('tag: $tag');
}
}
List<ParameterElementImpl> _readParameters(
ElementImpl enclosingElement,
Reference enclosingReference,
) {
var containerRef = enclosingReference.getChild('@parameter');
var length = _reader.readUInt30();
return List.generate(length, (_) {
var name = _reader.readStringReference();
var isInitializingFormal = _reader.readBool();
var isSuperFormal = _reader.readBool();
var reference = containerRef.getChild(name);
var kindIndex = _reader.readByte();
var kind = ResolutionReader._formalParameterKind(kindIndex);
ParameterElementImpl element;
if (kind.isRequiredPositional) {
if (isInitializingFormal) {
element = FieldFormalParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
} else if (isSuperFormal) {
element = SuperFormalParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
} else {
element = ParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
}
} else {
if (isInitializingFormal) {
element = DefaultFieldFormalParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
} else if (isSuperFormal) {
element = DefaultSuperFormalParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
} else {
element = DefaultParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
);
}
element.reference = reference;
reference.element = element;
}
ParameterElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
element.parameters = _readParameters(element, reference);
return element;
});
}
PropertyAccessorElementImpl _readPropertyAccessorElement(
CompilationUnitElementImpl unitElement,
ElementImpl classElement,
Reference classReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var element = PropertyAccessorElementImpl(name, -1);
PropertyAccessorElementFlags.read(_reader, element);
var reference = classReference
.getChild(element.isGetter ? '@getter' : '@setter')
.getChild(name);
var linkedData = PropertyAccessorElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
element.parameters = _readParameters(element, reference);
return element;
}
void _readPropertyAccessors(
CompilationUnitElementImpl unitElement,
ElementImpl enclosingElement,
Reference enclosingReference,
List<PropertyAccessorElement> accessors,
List<PropertyInducingElement> properties,
String containerRefName,
) {
var containerRef = enclosingReference.getChild(containerRefName);
var accessorCount = _reader.readUInt30();
for (var i = 0; i < accessorCount; i++) {
var accessor = _readPropertyAccessorElement(
unitElement,
enclosingElement,
enclosingReference,
);
accessors.add(accessor);
var name = accessor.displayName;
var isGetter = accessor.isGetter;
var reference = containerRef.getChild(name);
PropertyInducingElementImpl property;
if (enclosingElement is CompilationUnitElementImpl) {
var existing = reference.element;
if (existing is TopLevelVariableElementImpl) {
property = existing;
} else {
var field = TopLevelVariableElementImpl(name, -1);
property = field;
}
} else {
var existing = reference.element;
if (existing is FieldElementImpl) {
property = existing;
} else {
var field = FieldElementImpl(name, -1);
field.isStatic = accessor.isStatic;
property = field;
}
}
if (reference.element == null) {
reference.element = property;
properties.add(property);
property.enclosingElement = enclosingElement;
property.isSynthetic = true;
}
accessor.variable = property;
if (isGetter) {
property.getter = accessor;
} else {
property.setter = accessor;
if (property.isSynthetic) {
property.isFinal = false;
}
}
}
}
TopLevelInferenceError? _readTopLevelInferenceError() {
var kindIndex = _reader.readByte();
var kind = TopLevelInferenceErrorKind.values[kindIndex];
if (kind == TopLevelInferenceErrorKind.none) {
return null;
}
return TopLevelInferenceError(
kind: kind,
arguments: _reader.readStringReferenceList(),
);
}
TopLevelVariableElementImpl _readTopLevelVariableElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var isConst = _reader.readBool();
var reference = unitReference.getChild('@variable').getChild(name);
TopLevelVariableElementImpl element;
if (isConst) {
element = ConstTopLevelVariableElementImpl(name, -1);
} else {
element = TopLevelVariableElementImpl(name, -1);
}
var linkedData = TopLevelVariableElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
element.isConst = isConst;
TopLevelVariableElementFlags.read(_reader, element);
element.typeInferenceError = _readTopLevelInferenceError();
element.createImplicitAccessors(unitReference, name);
return element;
}
void _readTopLevelVariables(
CompilationUnitElementImpl unitElement,
Reference unitReference,
List<PropertyAccessorElementImpl> accessors,
List<TopLevelVariableElementImpl> variables,
) {
var variableElementCount = _reader.readUInt30();
for (var i = 0; i < variableElementCount; i++) {
var variable = _readTopLevelVariableElement(unitElement, unitReference);
variables.add(variable);
var getter = variable.getter;
if (getter is PropertyAccessorElementImpl) {
accessors.add(getter);
}
var setter = variable.setter;
if (setter is PropertyAccessorElementImpl) {
accessors.add(setter);
}
}
}
TypeAliasElementImpl _readTypeAliasElement(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var name = _reader.readStringReference();
var reference = unitReference.getChild('@typeAlias').getChild(name);
var isFunctionTypeAliasBased = _reader.readBool();
TypeAliasElementImpl element;
if (isFunctionTypeAliasBased) {
element = TypeAliasElementImpl(name, -1);
element.isFunctionTypeAliasBased = true;
} else {
element = TypeAliasElementImpl(name, -1);
}
var linkedData = TypeAliasElementLinkedData(
reference: reference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
);
element.setLinkedData(reference, linkedData);
element.isFunctionTypeAliasBased = isFunctionTypeAliasBased;
TypeAliasElementFlags.read(_reader, element);
element.typeParameters = _readTypeParameters();
return element;
}
void _readTypeAliases(
CompilationUnitElementImpl unitElement,
Reference unitReference,
) {
var length = _reader.readUInt30();
unitElement.typeAliases = List.generate(length, (_) {
return _readTypeAliasElement(unitElement, unitReference);
});
}
List<TypeParameterElementImpl> _readTypeParameters() {
var length = _reader.readUInt30();
return List.generate(length, (_) {
var name = _reader.readStringReference();
var varianceEncoding = _reader.readByte();
var variance = _decodeVariance(varianceEncoding);
var element = TypeParameterElementImpl(name, -1);
element.variance = variance;
return element;
});
}
CompilationUnitElementImpl _readUnitElement({
required SourceFactory sourceFactory,
required Reference unitContainerRef,
required LibraryElementImpl libraryElement,
required Source librarySource,
}) {
var resolutionOffset = _baseResolutionOffset + _reader.readUInt30();
var unitUriStr = _reader.readStringReference();
var unitUri = Uri.parse(unitUriStr);
var unitSource = sourceFactory.forUri2(unitUri)!;
var unitElement = CompilationUnitElementImpl();
unitElement.source = unitSource;
unitElement.librarySource = librarySource;
var unitReference = unitContainerRef.getChild(unitUriStr);
unitElement.setLinkedData(
unitReference,
CompilationUnitElementLinkedData(
reference: unitReference,
libraryReader: this,
unitElement: unitElement,
offset: resolutionOffset,
),
);
unitElement.uri = _reader.readOptionalStringReference();
unitElement.isSynthetic = _reader.readBool();
_readClasses(unitElement, unitReference);
_readEnums(unitElement, unitReference);
_readExtensions(unitElement, unitReference);
_readFunctions(unitElement, unitReference);
_readMixins(unitElement, unitReference);
_readTypeAliases(unitElement, unitReference);
var accessors = <PropertyAccessorElementImpl>[];
var variables = <TopLevelVariableElementImpl>[];
_readTopLevelVariables(unitElement, unitReference, accessors, variables);
_readPropertyAccessors(unitElement, unitElement, unitReference, accessors,
variables, '@variable');
unitElement.accessors = accessors;
unitElement.topLevelVariables = variables;
return unitElement;
}
static Variance? _decodeVariance(int index) {
var tag = TypeParameterVarianceTag.values[index];
switch (tag) {
case TypeParameterVarianceTag.legacy:
return null;
case TypeParameterVarianceTag.unrelated:
return Variance.unrelated;
case TypeParameterVarianceTag.covariant:
return Variance.covariant;
case TypeParameterVarianceTag.contravariant:
return Variance.contravariant;
case TypeParameterVarianceTag.invariant:
return Variance.invariant;
}
}
}
class MethodElementLinkedData extends ElementLinkedData<MethodElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
MethodElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
_addEnclosingElementTypeParameters(reader, element);
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
_readTypeParameters(reader, element.typeParameters);
_readFormalParameters(reader, element.parameters);
element.returnType = reader.readRequiredType();
applyConstantOffsets?.perform();
}
}
class MixinElementLinkedData extends ElementLinkedData<MixinElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
MixinElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: element.enclosingElement,
);
_readTypeParameters(reader, element.typeParameters);
element.superclassConstraints = reader._readInterfaceTypeList();
element.interfaces = reader._readInterfaceTypeList();
applyConstantOffsets?.perform();
}
}
class PropertyAccessorElementLinkedData
extends ElementLinkedData<PropertyAccessorElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
PropertyAccessorElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
_addEnclosingElementTypeParameters(reader, element);
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
element.returnType = reader.readRequiredType();
_readFormalParameters(reader, element.parameters);
applyConstantOffsets?.perform();
}
}
/// Helper for reading elements and types from their binary encoding.
class ResolutionReader {
final LinkedElementFactory _elementFactory;
final _ReferenceReader _referenceReader;
final SummaryDataReader _reader;
/// The stack of [TypeParameterElement]s and [ParameterElement] that are
/// available in the scope of [readElement] and [readType].
///
/// This stack is shared with the client of the reader, and update mostly
/// by the client. However it is also updated during [_readFunctionType].
final List<Element> _localElements = [];
ResolutionReader(
this._elementFactory,
this._referenceReader,
this._reader,
);
int readByte() {
return _reader.readByte();
}
double readDouble() {
return _reader.readDouble();
}
Element? readElement() {
var memberFlags = _reader.readByte();
var element = _readRawElement();
if (element == null) {
return null;
}
if (memberFlags == Tag.RawElement) {
return element;
}
if (memberFlags == Tag.MemberLegacyWithTypeArguments ||
memberFlags == Tag.MemberWithTypeArguments) {
var arguments = _readTypeList();
// TODO(scheglov) why to check for empty? If we have this flags.
if (arguments.isNotEmpty) {
var typeParameters =
(element.enclosingElement as TypeParameterizedElement)
.typeParameters;
var substitution = Substitution.fromPairs(typeParameters, arguments);
element =
ExecutableMember.from2(element as ExecutableElement, substitution);
}
}
if (memberFlags == Tag.MemberLegacyWithTypeArguments) {
return Member.legacy(element);
}
if (memberFlags == Tag.MemberWithTypeArguments) {
return element;
}
throw UnimplementedError('memberFlags: $memberFlags');
}
FunctionType? readOptionalFunctionType() {
var type = readType();
return type is FunctionType ? type : null;
}
List<DartType>? readOptionalTypeList() {
if (_reader.readBool()) {
return _readTypeList();
} else {
return null;
}
}
DartType readRequiredType() {
return readType()!;
}
String readStringReference() {
return _reader.readStringReference();
}
List<String> readStringReferenceList() {
return _reader.readStringReferenceList();
}
DartType? readType() {
var tag = _reader.readByte();
if (tag == Tag.NullType) {
return null;
} else if (tag == Tag.DynamicType) {
var type = DynamicTypeImpl.instance;
return _readAliasElementArguments(type);
} else if (tag == Tag.FunctionType) {
var type = _readFunctionType();
return _readAliasElementArguments(type);
} else if (tag == Tag.InterfaceType) {
var element = readElement() as ClassElement;
var typeArguments = _readTypeList();
var nullability = _readNullability();
var type = InterfaceTypeImpl(
element: element,
typeArguments: typeArguments,
nullabilitySuffix: nullability,
);
return _readAliasElementArguments(type);
} else if (tag == Tag.InterfaceType_noTypeArguments_none) {
var element = readElement() as ClassElement;
var type = InterfaceTypeImpl(
element: element,
typeArguments: const <DartType>[],
nullabilitySuffix: NullabilitySuffix.none,
);
return _readAliasElementArguments(type);
} else if (tag == Tag.InterfaceType_noTypeArguments_question) {
var element = readElement() as ClassElement;
var type = InterfaceTypeImpl(
element: element,
typeArguments: const <DartType>[],
nullabilitySuffix: NullabilitySuffix.question,
);
return _readAliasElementArguments(type);
} else if (tag == Tag.InterfaceType_noTypeArguments_star) {
var element = readElement() as ClassElement;
var type = InterfaceTypeImpl(
element: element,
typeArguments: const <DartType>[],
nullabilitySuffix: NullabilitySuffix.star,
);
return _readAliasElementArguments(type);
} else if (tag == Tag.NeverType) {
var nullability = _readNullability();
var type = NeverTypeImpl.instance.withNullability(nullability);
return _readAliasElementArguments(type);
} else if (tag == Tag.TypeParameterType) {
var element = readElement() as TypeParameterElement;
var nullability = _readNullability();
var type = TypeParameterTypeImpl(
element: element,
nullabilitySuffix: nullability,
);
return _readAliasElementArguments(type);
} else if (tag == Tag.VoidType) {
var type = VoidTypeImpl.instance;
return _readAliasElementArguments(type);
} else {
throw UnimplementedError('$tag');
}
}
List<T> readTypedList<T>(T Function() read) {
var length = readUInt30();
return List<T>.generate(length, (_) {
return read();
});
}
int readUInt30() {
return _reader.readUInt30();
}
int readUInt32() {
return _reader.readUInt32();
}
void _addFormalParameters(List<ParameterElement> parameters) {
for (var parameter in parameters) {
_localElements.add(parameter);
}
}
void _addTypeParameters(List<TypeParameterElement> typeParameters) {
for (var typeParameter in typeParameters) {
_localElements.add(typeParameter);
}
}
ElementImpl? _readAliasedElement(CompilationUnitElementImpl unitElement) {
var tag = _reader.readByte();
if (tag == AliasedElementTag.nothing) {
return null;
} else if (tag == AliasedElementTag.genericFunctionElement) {
var typeParameters = _readTypeParameters(unitElement);
var formalParameters = _readFormalParameters(unitElement);
var returnType = readRequiredType();
_localElements.length -= typeParameters.length;
return GenericFunctionTypeElementImpl.forOffset(-1)
..typeParameters = typeParameters
..parameters = formalParameters
..returnType = returnType;
} else {
throw UnimplementedError('tag: $tag');
}
}
DartType _readAliasElementArguments(DartType type) {
var aliasElement = _readRawElement();
if (aliasElement is TypeAliasElement) {
var aliasArguments = _readTypeList();
if (type is DynamicType) {
// TODO(scheglov) add support for `dynamic` aliasing
return type;
} else if (type is FunctionType) {
return FunctionTypeImpl(
typeFormals: type.typeFormals,
parameters: type.parameters,
returnType: type.returnType,
nullabilitySuffix: type.nullabilitySuffix,
alias: InstantiatedTypeAliasElementImpl(
element: aliasElement,
typeArguments: aliasArguments,
),
);
} else if (type is InterfaceType) {
return InterfaceTypeImpl(
element: type.element,
typeArguments: type.typeArguments,
nullabilitySuffix: type.nullabilitySuffix,
alias: InstantiatedTypeAliasElementImpl(
element: aliasElement,
typeArguments: aliasArguments,
),
);
} else if (type is TypeParameterType) {
return TypeParameterTypeImpl(
element: type.element,
nullabilitySuffix: type.nullabilitySuffix,
alias: InstantiatedTypeAliasElementImpl(
element: aliasElement,
typeArguments: aliasArguments,
),
);
} else if (type is VoidType) {
// TODO(scheglov) add support for `void` aliasing
return type;
} else {
throw UnimplementedError('${type.runtimeType}');
}
}
return type;
}
List<ElementAnnotationImpl> _readAnnotationList({
required CompilationUnitElementImpl unitElement,
}) {
var length = _reader.readUInt30();
if (length == 0) {
return const <ElementAnnotationImpl>[];
}
return List.generate(length, (_) {
var ast = _readRequiredNode() as Annotation;
return ElementAnnotationImpl(unitElement)
..annotationAst = ast
..element = ast.element;
});
}
List<ParameterElementImpl> _readFormalParameters(
CompilationUnitElementImpl? unitElement,
) {
var formalParameterCount = _reader.readUInt30();
return List.generate(formalParameterCount, (_) {
var kindIndex = _reader.readByte();
var kind = _formalParameterKind(kindIndex);
var hasImplicitType = _reader.readBool();
var isInitializingFormal = _reader.readBool();
var typeParameters = _readTypeParameters(unitElement);
var type = readRequiredType();
var name = readStringReference();
if (kind.isRequiredPositional) {
ParameterElementImpl element;
if (isInitializingFormal) {
element = FieldFormalParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
)..type = type;
} else {
element = ParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
)..type = type;
}
element.hasImplicitType = hasImplicitType;
element.typeParameters = typeParameters;
element.parameters = _readFormalParameters(unitElement);
// TODO(scheglov) reuse for formal parameters
_localElements.length -= typeParameters.length;
if (unitElement != null) {
element.metadata = _readAnnotationList(unitElement: unitElement);
}
return element;
} else {
var element = DefaultParameterElementImpl(
name: name,
nameOffset: -1,
parameterKind: kind,
)..type = type;
element.hasImplicitType = hasImplicitType;
element.typeParameters = typeParameters;
element.parameters = _readFormalParameters(unitElement);
// TODO(scheglov) reuse for formal parameters
_localElements.length -= typeParameters.length;
if (unitElement != null) {
element.metadata = _readAnnotationList(unitElement: unitElement);
}
return element;
}
});
}
/// TODO(scheglov) Optimize for write/read of types without type parameters.
FunctionType _readFunctionType() {
// TODO(scheglov) reuse for formal parameters
var typeParameters = _readTypeParameters(null);
var returnType = readRequiredType();
var formalParameters = _readFormalParameters(null);
var nullability = _readNullability();
_localElements.length -= typeParameters.length;
return FunctionTypeImpl(
typeFormals: typeParameters,
parameters: formalParameters,
returnType: returnType,
nullabilitySuffix: nullability,
);
}
InterfaceType _readInterfaceType() {
return readType() as InterfaceType;
}
List<InterfaceType> _readInterfaceTypeList() {
var length = _reader.readUInt30();
if (length == 0) {
return const <InterfaceType>[];
}
return List.generate(length, (_) => _readInterfaceType());
}
List<T> _readNodeList<T>() {
var length = _reader.readUInt30();
return List<T>.generate(length, (_) {
return _readRequiredNode() as T;
});
}
NullabilitySuffix _readNullability() {
var index = _reader.readByte();
return NullabilitySuffix.values[index];
}
ExpressionImpl? _readOptionalExpression() {
if (_reader.readBool()) {
return _readRequiredNode() as ExpressionImpl;
} else {
return null;
}
}
InterfaceType? _readOptionalInterfaceType() {
return readType() as InterfaceType?;
}
Element? _readRawElement() {
var index = _reader.readUInt30();
if ((index & 0x1) == 0x1) {
return _localElements[index >> 1];
}
var referenceIndex = index >> 1;
var reference = _referenceReader.referenceOfIndex(referenceIndex);
return _elementFactory.elementOfReference(reference);
}
AstNode _readRequiredNode() {
var astReader = AstBinaryReader(reader: this);
return astReader.readNode();
}
List<DartType> _readTypeList() {
var types = <DartType>[];
var length = _reader.readUInt30();
for (var i = 0; i < length; i++) {
var argument = readType()!;
types.add(argument);
}
return types;
}
List<TypeParameterElementImpl> _readTypeParameters(
CompilationUnitElementImpl? unitElement,
) {
var typeParameterCount = _reader.readUInt30();
var typeParameters = List.generate(typeParameterCount, (_) {
var name = readStringReference();
var typeParameter = TypeParameterElementImpl(name, -1);
_localElements.add(typeParameter);
return typeParameter;
});
for (var typeParameter in typeParameters) {
typeParameter.bound = readType();
if (unitElement != null) {
typeParameter.metadata = _readAnnotationList(unitElement: unitElement);
}
}
return typeParameters;
}
static ParameterKind _formalParameterKind(int encoding) {
if (encoding == Tag.ParameterKindRequiredPositional) {
return ParameterKind.REQUIRED;
} else if (encoding == Tag.ParameterKindOptionalPositional) {
return ParameterKind.POSITIONAL;
} else if (encoding == Tag.ParameterKindRequiredNamed) {
return ParameterKind.NAMED_REQUIRED;
} else if (encoding == Tag.ParameterKindOptionalNamed) {
return ParameterKind.NAMED;
} else {
throw StateError('Unexpected parameter kind encoding: $encoding');
}
}
}
class TopLevelVariableElementLinkedData
extends ElementLinkedData<TopLevelVariableElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
TopLevelVariableElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
element.type = reader.readRequiredType();
if (element is ConstTopLevelVariableElementImpl) {
var initializer = reader._readOptionalExpression();
if (initializer != null) {
element.constantInitializer = initializer;
ConstantContextForExpressionImpl(initializer);
}
}
applyConstantOffsets?.perform();
}
}
class TypeAliasElementLinkedData
extends ElementLinkedData<TypeAliasElementImpl> {
ApplyConstantOffsets? applyConstantOffsets;
TypeAliasElementLinkedData({
required Reference reference,
required LibraryReader libraryReader,
required CompilationUnitElementImpl unitElement,
required int offset,
}) : super(reference, libraryReader, unitElement, offset);
@override
void _read(element, reader) {
element.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
_readTypeParameters(reader, element.typeParameters);
element.aliasedElement = reader._readAliasedElement(unitElement);
element.aliasedType = reader.readRequiredType();
applyConstantOffsets?.perform();
}
}
/// Information that we need to know about each library before reading it,
/// and without reading it.
///
/// Specifically, the [offset] allows us to know the location of each library,
/// so that when we need to read this library, we know where it starts without
/// reading previous libraries.
class _LibraryHeader {
final String uriStr;
final int offset;
/// We don't read class members when reading libraries, by performance
/// reasons - in many cases only some classes of a library are used. But
/// we need to know how much data to skip for each class.
final Uint32List classMembersLengths;
_LibraryHeader({
required this.uriStr,
required this.offset,
required this.classMembersLengths,
});
}
class _ReferenceReader {
final LinkedElementFactory elementFactory;
final SummaryDataReader _reader;
late final Uint32List _parents;
late final Uint32List _names;
late final List<Reference?> _references;
_ReferenceReader(this.elementFactory, this._reader, int offset) {
_reader.offset = offset;
_parents = _reader.readUInt30List();
_names = _reader.readUInt30List();
assert(_parents.length == _names.length);
_references = List.filled(_names.length, null);
}
Reference referenceOfIndex(int index) {
var reference = _references[index];
if (reference != null) {
return reference;
}
if (index == 0) {
reference = elementFactory.rootReference;
_references[index] = reference;
return reference;
}
var nameIndex = _names[index];
var name = _reader.stringOfIndex(nameIndex);
var parentIndex = _parents[index];
var parent = referenceOfIndex(parentIndex);
reference = parent.getChild(name);
_references[index] = reference;
return reference;
}
}