blob: 23ae7a9feda0ed6be4030d6f41032136f8760c26 [file] [log] [blame]
// Copyright (c) 2021, 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 '../api.dart';
import 'remote_instance.dart';
import 'serialization.dart';
import 'serialization_extensions.dart';
class IdentifierImpl extends RemoteInstance implements Identifier {
@override
final String name;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.identifier;
IdentifierImpl({required int id, required this.name}) : super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.addString(name);
}
@override
bool operator ==(Object other) => other is IdentifierImpl && other.id == id;
@override
int get hashCode => id;
}
abstract class TypeAnnotationImpl extends RemoteInstance
implements TypeAnnotation {
@override
final bool isNullable;
TypeAnnotationImpl({required int id, required this.isNullable}) : super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.addBool(isNullable);
}
}
class NamedTypeAnnotationImpl extends TypeAnnotationImpl
implements NamedTypeAnnotation {
@override
TypeAnnotationCode get code {
NamedTypeAnnotationCode underlyingType =
NamedTypeAnnotationCode(name: identifier, typeArguments: [
for (TypeAnnotation typeArg in typeArguments) typeArg.code,
]);
return isNullable ? underlyingType.asNullable : underlyingType;
}
@override
final IdentifierImpl identifier;
@override
final List<TypeAnnotationImpl> typeArguments;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.namedTypeAnnotation;
NamedTypeAnnotationImpl({
required super.id,
required super.isNullable,
required this.identifier,
required this.typeArguments,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
identifier.serialize(serializer);
serializer.startList();
for (TypeAnnotationImpl typeArg in typeArguments) {
typeArg.serialize(serializer);
}
serializer.endList();
}
}
class StaticTypeImpl extends RemoteInstance implements StaticType {
StaticTypeImpl(super.id);
@override
RemoteInstanceKind get kind => RemoteInstanceKind.staticType;
// When used by the client, requests need to made through the
// ClientStaticTypeImpl wrapper which will issue RPC requests to implement
// these methods.
@override
Future<NamedStaticType?> asInstanceOf(TypeDeclaration declaration) {
throw UnsupportedError('use ClientStaticTypeImpl');
}
@override
Future<bool> isExactly(covariant StaticType other) {
throw UnsupportedError('use ClientStaticTypeImpl');
}
@override
Future<bool> isSubtypeOf(covariant StaticType other) {
throw UnsupportedError('use ClientStaticTypeImpl');
}
}
class NamedStaticTypeImpl extends StaticTypeImpl implements NamedStaticType {
@override
final ParameterizedTypeDeclarationImpl declaration;
@override
final List<StaticTypeImpl> typeArguments;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.namedStaticType;
NamedStaticTypeImpl(
super.id, {
required this.declaration,
required this.typeArguments,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
declaration.serialize(serializer);
serializer.startList();
for (StaticTypeImpl typeArg in typeArguments) {
typeArg.serialize(serializer);
}
serializer.endList();
}
}
class RecordTypeAnnotationImpl extends TypeAnnotationImpl
implements RecordTypeAnnotation {
@override
TypeAnnotationCode get code {
RecordTypeAnnotationCode underlyingType = RecordTypeAnnotationCode(
namedFields: [for (RecordFieldImpl field in namedFields) field.code],
positionalFields: [
for (RecordFieldImpl field in positionalFields) field.code
],
);
return isNullable ? underlyingType.asNullable : underlyingType;
}
@override
final List<RecordFieldImpl> namedFields;
@override
final List<RecordFieldImpl> positionalFields;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.recordTypeAnnotation;
RecordTypeAnnotationImpl({
required super.id,
required super.isNullable,
required this.namedFields,
required this.positionalFields,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.startList();
for (RecordFieldImpl field in namedFields) {
field.serialize(serializer);
}
serializer.endList();
serializer.startList();
for (RecordFieldImpl field in positionalFields) {
field.serialize(serializer);
}
serializer.endList();
}
}
class RecordFieldImpl extends RemoteInstance implements RecordField {
@override
RecordFieldCode get code {
return RecordFieldCode(type: type.code, name: name);
}
@override
final String? name;
@override
final TypeAnnotationImpl type;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.recordField;
RecordFieldImpl({
required int id,
required this.name,
required this.type,
}) : super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.addNullableString(name);
type.serialize(serializer);
}
}
class FunctionTypeAnnotationImpl extends TypeAnnotationImpl
implements FunctionTypeAnnotation {
@override
TypeAnnotationCode get code {
FunctionTypeAnnotationCode underlyingType = FunctionTypeAnnotationCode(
returnType: returnType.code,
typeParameters: [
for (TypeParameter typeParam in typeParameters) typeParam.code,
],
positionalParameters: [
for (FormalParameter positional in positionalParameters)
if (positional.isRequired) positional.code,
],
optionalPositionalParameters: [
for (FormalParameter positional in positionalParameters)
if (!positional.isRequired) positional.code,
],
namedParameters: [
for (FormalParameter named in namedParameters) named.code,
],
);
return isNullable ? underlyingType.asNullable : underlyingType;
}
@override
final List<FormalParameterImpl> namedParameters;
@override
final List<FormalParameterImpl> positionalParameters;
@override
final TypeAnnotationImpl returnType;
@override
final List<TypeParameterImpl> typeParameters;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.functionTypeAnnotation;
FunctionTypeAnnotationImpl({
required super.id,
required super.isNullable,
required this.namedParameters,
required this.positionalParameters,
required this.returnType,
required this.typeParameters,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
returnType.serialize(serializer);
serializer.startList();
for (FormalParameterImpl param in positionalParameters) {
param.serialize(serializer);
}
serializer.endList();
serializer.startList();
for (FormalParameterImpl param in namedParameters) {
param.serialize(serializer);
}
serializer.endList();
serializer.startList();
for (TypeParameterImpl typeParam in typeParameters) {
typeParam.serialize(serializer);
}
serializer.endList();
}
}
class OmittedTypeAnnotationImpl extends TypeAnnotationImpl
implements OmittedTypeAnnotation {
OmittedTypeAnnotationImpl({required super.id}) : super(isNullable: false);
@override
TypeAnnotationCode get code => OmittedTypeAnnotationCode(this);
@override
RemoteInstanceKind get kind => RemoteInstanceKind.omittedTypeAnnotation;
}
abstract class MetadataAnnotationImpl extends RemoteInstance
implements MetadataAnnotation {
MetadataAnnotationImpl(super.id);
}
class IdentifierMetadataAnnotationImpl extends MetadataAnnotationImpl
implements IdentifierMetadataAnnotation {
@override
final IdentifierImpl identifier;
@override
RemoteInstanceKind get kind =>
RemoteInstanceKind.identifierMetadataAnnotation;
IdentifierMetadataAnnotationImpl({required int id, required this.identifier})
: super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
identifier.serialize(serializer);
}
}
class ConstructorMetadataAnnotationImpl extends MetadataAnnotationImpl
implements ConstructorMetadataAnnotation {
@override
final IdentifierImpl constructor;
@override
final NamedTypeAnnotationImpl type;
@override
final List<ExpressionCode> positionalArguments;
@override
final Map<String, ExpressionCode> namedArguments;
@override
RemoteInstanceKind get kind =>
RemoteInstanceKind.constructorMetadataAnnotation;
ConstructorMetadataAnnotationImpl(
{required int id,
required this.constructor,
required this.type,
required this.positionalArguments,
required this.namedArguments})
: super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
constructor.serialize(serializer);
type.serialize(serializer);
serializer.startList();
for (ExpressionCode positionalArgument in positionalArguments) {
positionalArgument.serialize(serializer);
}
serializer.endList();
serializer.startList();
for (MapEntry<String, ExpressionCode> entry in namedArguments.entries) {
serializer.addString(entry.key);
entry.value.serialize(serializer);
}
serializer.endList();
}
}
abstract class DeclarationImpl extends RemoteInstance implements Declaration {
@override
final IdentifierImpl identifier;
@override
final LibraryImpl library;
@override
final List<MetadataAnnotationImpl> metadata;
DeclarationImpl({
required int id,
required this.identifier,
required this.library,
required this.metadata,
}) : super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
identifier.serialize(serializer);
library.serialize(serializer);
serializer.startList();
for (MetadataAnnotationImpl annotation in metadata) {
annotation.serialize(serializer);
}
serializer.endList();
}
}
class FormalParameterDeclarationImpl extends DeclarationImpl
implements FormalParameterDeclaration {
@override
final TypeAnnotationImpl type;
@override
final bool isNamed;
@override
final bool isRequired;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.formalParameterDeclaration;
@override
String get name => identifier.name;
FormalParameterDeclarationImpl({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required this.isNamed,
required this.isRequired,
required this.type,
});
FormalParameterDeclarationImpl.fromBitMask({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required BitMask<ParameterIntrospectionBit> bitMask,
required this.type,
}) : isNamed = bitMask.has(ParameterIntrospectionBit.isNamed),
isRequired = bitMask.has(ParameterIntrospectionBit.isRequired);
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<ParameterIntrospectionBit>? bitMask}) {
super.serializeUncached(serializer);
bitMask ??= BitMask();
if (isNamed) bitMask.add(ParameterIntrospectionBit.isNamed);
if (isRequired) bitMask.add(ParameterIntrospectionBit.isRequired);
bitMask.freeze();
serializer.addInt(bitMask._mask);
type.serialize(serializer);
}
@override
ParameterCode get code =>
ParameterCode(name: identifier.name, type: type.code, keywords: [
if (isNamed && isRequired) 'required',
]);
}
class FormalParameterImpl extends RemoteInstance implements FormalParameter {
@override
final bool isNamed;
@override
final bool isRequired;
@override
final List<MetadataAnnotationImpl> metadata;
@override
final String? name;
@override
final TypeAnnotationImpl type;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.formalParameter;
FormalParameterImpl({
required int id,
required this.isNamed,
required this.isRequired,
required this.metadata,
required this.name,
required this.type,
}) : super(id);
FormalParameterImpl.fromBitMask({
required int id,
required BitMask<ParameterIntrospectionBit> bitMask,
required this.metadata,
required this.name,
required this.type,
}) : isNamed = bitMask.has(ParameterIntrospectionBit.isNamed),
isRequired = bitMask.has(ParameterIntrospectionBit.isRequired),
super(id);
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<ParameterIntrospectionBit>? bitMask}) {
super.serializeUncached(serializer);
bitMask ??= BitMask();
if (isNamed) bitMask.add(ParameterIntrospectionBit.isNamed);
if (isRequired) bitMask.add(ParameterIntrospectionBit.isRequired);
bitMask.freeze();
serializer
..addInt(bitMask._mask)
..startList();
for (MetadataAnnotationImpl annotation in metadata) {
annotation.serialize(serializer);
}
serializer.endList();
serializer.addNullableString(name);
type.serialize(serializer);
}
@override
ParameterCode get code =>
ParameterCode(name: name, type: type.code, keywords: [
if (isNamed && isRequired) 'required',
]);
}
class TypeParameterImpl extends RemoteInstance implements TypeParameter {
@override
final TypeAnnotationImpl? bound;
@override
final List<MetadataAnnotationImpl> metadata;
@override
final String name;
@override
TypeParameterCode get code =>
TypeParameterCode(name: name, bound: bound?.code);
@override
RemoteInstanceKind get kind => RemoteInstanceKind.typeParameter;
TypeParameterImpl({
required int id,
required this.bound,
required this.metadata,
required this.name,
}) : super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
bound.serializeNullable(serializer);
serializer.startList();
for (MetadataAnnotationImpl annotation in metadata) {
annotation.serialize(serializer);
}
serializer.endList();
serializer.addString(name);
}
}
class TypeParameterDeclarationImpl extends DeclarationImpl
implements TypeParameterDeclaration {
@override
final TypeAnnotationImpl? bound;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.typeParameterDeclaration;
@override
String get name => identifier.name;
TypeParameterDeclarationImpl({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required this.bound,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
bound.serializeNullable(serializer);
}
@override
TypeParameterCode get code =>
TypeParameterCode(name: identifier.name, bound: bound?.code);
}
class FunctionDeclarationImpl extends DeclarationImpl
implements FunctionDeclaration {
@override
final bool hasBody;
@override
final bool hasExternal;
@override
final bool isGetter;
@override
final bool isOperator;
@override
final bool isSetter;
@override
final List<FormalParameterDeclarationImpl> namedParameters;
@override
final List<FormalParameterDeclarationImpl> positionalParameters;
@override
final TypeAnnotationImpl returnType;
@override
final List<TypeParameterDeclarationImpl> typeParameters;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.functionDeclaration;
FunctionDeclarationImpl({
// Declaration fields
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// FunctionDeclaration fields
required this.hasBody,
required this.hasExternal,
required this.isGetter,
required this.isOperator,
required this.isSetter,
required this.namedParameters,
required this.positionalParameters,
required this.returnType,
required this.typeParameters,
});
FunctionDeclarationImpl.fromBitMask({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required BitMask<FunctionIntrospectionBit> bitMask,
required this.namedParameters,
required this.positionalParameters,
required this.returnType,
required this.typeParameters,
}) : hasBody = bitMask.has(FunctionIntrospectionBit.hasBody),
hasExternal = bitMask.has(FunctionIntrospectionBit.hasExternal),
isGetter = bitMask.has(FunctionIntrospectionBit.isGetter),
isOperator = bitMask.has(FunctionIntrospectionBit.isOperator),
isSetter = bitMask.has(FunctionIntrospectionBit.isSetter);
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<FunctionIntrospectionBit>? bitMask}) {
super.serializeUncached(serializer);
bitMask ??= BitMask();
if (hasBody) bitMask.add(FunctionIntrospectionBit.hasBody);
if (hasExternal) bitMask.add(FunctionIntrospectionBit.hasExternal);
if (isGetter) bitMask.add(FunctionIntrospectionBit.isGetter);
if (isOperator) bitMask.add(FunctionIntrospectionBit.isOperator);
if (isSetter) bitMask.add(FunctionIntrospectionBit.isSetter);
bitMask.freeze();
serializer
..addInt(bitMask._mask)
..startList();
for (FormalParameterDeclarationImpl named in namedParameters) {
named.serialize(serializer);
}
serializer
..endList()
..startList();
for (FormalParameterDeclarationImpl positional in positionalParameters) {
positional.serialize(serializer);
}
serializer.endList();
returnType.serialize(serializer);
serializer.startList();
for (TypeParameterDeclarationImpl param in typeParameters) {
param.serialize(serializer);
}
serializer.endList();
}
}
class MethodDeclarationImpl extends FunctionDeclarationImpl
implements MethodDeclaration {
@override
final IdentifierImpl definingType;
@override
final bool hasStatic;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.methodDeclaration;
MethodDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Function fields.
required super.hasBody,
required super.hasExternal,
required super.isGetter,
required super.isOperator,
required super.isSetter,
required super.namedParameters,
required super.positionalParameters,
required super.returnType,
required super.typeParameters,
// Method fields.
required this.definingType,
required this.hasStatic,
});
MethodDeclarationImpl.fromBitMask({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Function fields.
required super.bitMask,
required super.namedParameters,
required super.positionalParameters,
required super.returnType,
required super.typeParameters,
// Method fields.
required this.definingType,
}) : hasStatic = bitMask.has(FunctionIntrospectionBit.hasStatic),
super.fromBitMask();
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<FunctionIntrospectionBit>? bitMask}) {
bitMask ??= BitMask();
if (hasStatic) bitMask.add(FunctionIntrospectionBit.hasStatic);
super.serializeUncached(serializer, bitMask: bitMask);
definingType.serialize(serializer);
}
}
class ConstructorDeclarationImpl extends MethodDeclarationImpl
implements ConstructorDeclaration {
@override
final bool isFactory;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.constructorDeclaration;
ConstructorDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Function fields.
required super.hasBody,
required super.hasExternal,
required super.namedParameters,
required super.positionalParameters,
required super.returnType,
required super.typeParameters,
// Method fields.
required super.definingType,
// Constructor fields.
required this.isFactory,
}) : super(
isGetter: false,
isOperator: false,
isSetter: false,
hasStatic: true,
);
ConstructorDeclarationImpl.fromBitMask({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Function fields.
required super.bitMask,
required super.namedParameters,
required super.positionalParameters,
required super.returnType,
required super.typeParameters,
// Method fields.
required super.definingType,
}) : isFactory = bitMask.has(FunctionIntrospectionBit.isFactory),
super.fromBitMask();
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<FunctionIntrospectionBit>? bitMask}) {
bitMask ??= BitMask();
if (isFactory) bitMask.add(FunctionIntrospectionBit.isFactory);
super.serializeUncached(serializer, bitMask: bitMask);
}
}
class VariableDeclarationImpl extends DeclarationImpl
implements VariableDeclaration {
@override
final bool hasConst;
@override
final bool hasExternal;
@override
final bool hasFinal;
@override
final bool hasInitializer;
@override
final bool hasLate;
@override
final TypeAnnotationImpl type;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.variableDeclaration;
VariableDeclarationImpl({
// Declaration fields
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Variable fields
required this.hasConst,
required this.hasExternal,
required this.hasFinal,
required this.hasInitializer,
required this.hasLate,
required this.type,
});
VariableDeclarationImpl.fromBitMask({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required BitMask<VariableIntrospectionBit> bitMask,
required this.type,
}) : hasConst = bitMask.has(VariableIntrospectionBit.hasConst),
hasExternal = bitMask.has(VariableIntrospectionBit.hasExternal),
hasFinal = bitMask.has(VariableIntrospectionBit.hasFinal),
hasInitializer = bitMask.has(VariableIntrospectionBit.hasInitializer),
hasLate = bitMask.has(VariableIntrospectionBit.hasLate);
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<VariableIntrospectionBit>? bitMask}) {
super.serializeUncached(serializer);
bitMask ??= BitMask();
if (hasConst) bitMask.add(VariableIntrospectionBit.hasConst);
if (hasExternal) bitMask.add(VariableIntrospectionBit.hasExternal);
if (hasFinal) bitMask.add(VariableIntrospectionBit.hasFinal);
if (hasInitializer) bitMask.add(VariableIntrospectionBit.hasInitializer);
if (hasLate) bitMask.add(VariableIntrospectionBit.hasLate);
bitMask.freeze();
serializer.addInt(bitMask._mask);
type.serialize(serializer);
}
}
class FieldDeclarationImpl extends VariableDeclarationImpl
implements FieldDeclaration {
@override
final IdentifierImpl definingType;
@override
final bool hasAbstract;
@override
final bool hasStatic;
FieldDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Variable fields.
required super.hasConst,
required super.hasExternal,
required super.hasFinal,
required super.hasInitializer,
required super.hasLate,
required super.type,
// Field fields.
required this.definingType,
required this.hasAbstract,
required this.hasStatic,
});
FieldDeclarationImpl.fromBitMask({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// Variable fields.
required super.bitMask,
required super.type,
// Field fields.
required this.definingType,
}) : hasAbstract = bitMask.has(VariableIntrospectionBit.hasAbstract),
hasStatic = bitMask.has(VariableIntrospectionBit.hasStatic),
super.fromBitMask();
@override
RemoteInstanceKind get kind => RemoteInstanceKind.fieldDeclaration;
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer,
{BitMask<VariableIntrospectionBit>? bitMask}) {
bitMask ??= BitMask();
if (hasAbstract) bitMask.add(VariableIntrospectionBit.hasAbstract);
if (hasStatic) bitMask.add(VariableIntrospectionBit.hasStatic);
super.serializeUncached(serializer, bitMask: bitMask);
definingType.serialize(serializer);
}
}
abstract interface class TypeDeclarationImpl
implements DeclarationImpl, TypeDeclaration {}
abstract class ParameterizedTypeDeclarationImpl extends DeclarationImpl
implements ParameterizedTypeDeclaration, TypeDeclarationImpl {
@override
final List<TypeParameterDeclarationImpl> typeParameters;
ParameterizedTypeDeclarationImpl({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required this.typeParameters,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.startList();
for (TypeParameterDeclarationImpl param in typeParameters) {
param.serialize(serializer);
}
serializer.endList();
}
}
class ClassDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements ClassDeclaration {
@override
final bool hasAbstract;
@override
final bool hasBase;
@override
final bool hasExternal;
@override
final bool hasFinal;
@override
final bool hasInterface;
@override
final bool hasMixin;
@override
final bool hasSealed;
@override
final List<NamedTypeAnnotationImpl> interfaces;
@override
final List<NamedTypeAnnotationImpl> mixins;
@override
final NamedTypeAnnotationImpl? superclass;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.classDeclaration;
ClassDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// TypeDeclaration fields.
required super.typeParameters,
// ClassDeclaration fields.
required this.hasAbstract,
required this.hasBase,
required this.hasExternal,
required this.hasFinal,
required this.hasInterface,
required this.hasMixin,
required this.hasSealed,
required this.interfaces,
required this.mixins,
required this.superclass,
});
ClassDeclarationImpl.fromBitMask({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// TypeDeclaration fields.
required super.typeParameters,
// ClassDeclaration fields.
required BitMask<ClassIntrospectionBit> bitMask,
required this.interfaces,
required this.mixins,
required this.superclass,
}) : hasAbstract = bitMask.has(ClassIntrospectionBit.hasAbstract),
hasBase = bitMask.has(ClassIntrospectionBit.hasBase),
hasExternal = bitMask.has(ClassIntrospectionBit.hasExternal),
hasFinal = bitMask.has(ClassIntrospectionBit.hasFinal),
hasInterface = bitMask.has(ClassIntrospectionBit.hasInterface),
hasMixin = bitMask.has(ClassIntrospectionBit.hasMixin),
hasSealed = bitMask.has(ClassIntrospectionBit.hasSealed);
/// If subclasses have their own values to add to [bitMask], they must do so
/// before calling this function, and pass the mask here.
@override
void serializeUncached(Serializer serializer, {BitMask? bitMask}) {
super.serializeUncached(serializer);
bitMask ??= BitMask();
if (hasAbstract) bitMask.add(ClassIntrospectionBit.hasAbstract);
if (hasBase) bitMask.add(ClassIntrospectionBit.hasBase);
if (hasExternal) bitMask.add(ClassIntrospectionBit.hasExternal);
if (hasFinal) bitMask.add(ClassIntrospectionBit.hasFinal);
if (hasInterface) bitMask.add(ClassIntrospectionBit.hasInterface);
if (hasMixin) bitMask.add(ClassIntrospectionBit.hasMixin);
if (hasSealed) bitMask.add(ClassIntrospectionBit.hasSealed);
bitMask.freeze();
serializer
..addInt(bitMask._mask)
..startList();
for (NamedTypeAnnotationImpl interface in interfaces) {
interface.serialize(serializer);
}
serializer
..endList()
..startList();
for (NamedTypeAnnotationImpl mixin in mixins) {
mixin.serialize(serializer);
}
serializer.endList();
superclass.serializeNullable(serializer);
}
}
class EnumDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements EnumDeclaration {
@override
final List<NamedTypeAnnotationImpl> interfaces;
@override
final List<NamedTypeAnnotationImpl> mixins;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.enumDeclaration;
EnumDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// TypeDeclaration fields.
required super.typeParameters,
// EnumDeclaration fields.
required this.interfaces,
required this.mixins,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer.startList();
for (NamedTypeAnnotationImpl interface in interfaces) {
interface.serialize(serializer);
}
serializer
..endList()
..startList();
for (NamedTypeAnnotationImpl mixin in mixins) {
mixin.serialize(serializer);
}
serializer.endList();
}
}
class EnumValueDeclarationImpl extends DeclarationImpl
implements EnumValueDeclaration {
@override
final IdentifierImpl definingEnum;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.enumValueDeclaration;
EnumValueDeclarationImpl({
required super.id,
required super.identifier,
required super.library,
required super.metadata,
required this.definingEnum,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
definingEnum.serialize(serializer);
}
}
class ExtensionDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements ExtensionDeclaration {
@override
final TypeAnnotationImpl onType;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.extensionDeclaration;
ExtensionDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// ParameterizedTypeDeclaration fields.
required super.typeParameters,
// ExtensionDeclaration fields.
required this.onType,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
onType.serialize(serializer);
}
}
class ExtensionTypeDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements ExtensionTypeDeclaration {
@override
final TypeAnnotationImpl representationType;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.extensionTypeDeclaration;
ExtensionTypeDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// ParameterizedTypeDeclaration fields.
required super.typeParameters,
// ExtensionTypeDeclaration fields.
required this.representationType,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
representationType.serialize(serializer);
}
}
class MixinDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements MixinDeclaration {
@override
final bool hasBase;
@override
final List<NamedTypeAnnotationImpl> interfaces;
@override
final List<NamedTypeAnnotationImpl> superclassConstraints;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.mixinDeclaration;
MixinDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// TypeDeclaration fields.
required super.typeParameters,
// MixinDeclaration fields.
required this.hasBase,
required this.interfaces,
required this.superclassConstraints,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
serializer
..addBool(hasBase)
..startList();
for (NamedTypeAnnotationImpl interface in interfaces) {
interface.serialize(serializer);
}
serializer
..endList()
..startList();
for (NamedTypeAnnotationImpl constraint in superclassConstraints) {
constraint.serialize(serializer);
}
serializer.endList();
}
}
class TypeAliasDeclarationImpl extends ParameterizedTypeDeclarationImpl
implements TypeAliasDeclaration {
/// The type being aliased.
@override
final TypeAnnotationImpl aliasedType;
@override
RemoteInstanceKind get kind => RemoteInstanceKind.typeAliasDeclaration;
TypeAliasDeclarationImpl({
// Declaration fields.
required super.id,
required super.identifier,
required super.library,
required super.metadata,
// TypeDeclaration fields.
required super.typeParameters,
// TypeAlias fields.
required this.aliasedType,
});
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
aliasedType.serialize(serializer);
}
}
class LibraryImpl extends RemoteInstance implements Library {
@override
RemoteInstanceKind get kind => RemoteInstanceKind.library;
@override
final LanguageVersionImpl languageVersion;
@override
final List<MetadataAnnotationImpl> metadata;
@override
final Uri uri;
LibraryImpl(
{required int id,
required this.languageVersion,
required this.metadata,
required this.uri})
: super(id);
@override
void serializeUncached(Serializer serializer) {
super.serializeUncached(serializer);
languageVersion.serialize(serializer);
serializer.startList();
for (MetadataAnnotationImpl annotation in metadata) {
annotation.serialize(serializer);
}
serializer.endList();
serializer.addUri(uri);
}
}
/// This class doesn't implement [RemoteInstance] as it is always attached to a
/// [Library] and doesn't need its own kind or ID.
class LanguageVersionImpl implements LanguageVersion, Serializable {
@override
final int major;
@override
final int minor;
LanguageVersionImpl(this.major, this.minor);
@override
void serialize(Serializer serializer) {
serializer
..addInt(major)
..addInt(minor);
}
}
/// A general bit mask class for specific enum types.
///
/// This should always be specialized to exactly one enum type, since the mask
/// uses the enum indexes.
final class BitMask<T extends Enum> {
int _mask;
bool _frozen = false;
BitMask([this._mask = 0])
: assert(
T is! Enum,
);
void add(T bit) {
if (_frozen) throw StateError('Cannot modify a frozen BitMask');
_mask |= bit.mask;
}
bool has(T bit) {
return (_mask & bit.mask) != 0;
}
void freeze() => _frozen = true;
}
/// Defines the bits for the bit mask for all boolean class fields.
enum ClassIntrospectionBit {
hasAbstract,
hasBase,
hasExternal,
hasFinal,
hasInterface,
hasMixin,
hasSealed;
}
/// Defines the bits for the bit mask for all boolean function fields.
enum FunctionIntrospectionBit {
hasBody,
hasExternal,
hasStatic,
isFactory,
isGetter,
isOperator,
isSetter,
}
/// Defines the bits for the bit mask for all boolean parameter fields.
enum ParameterIntrospectionBit {
isNamed,
isRequired,
}
/// Defines the bits for the bit mask for all boolean variable fields.
enum VariableIntrospectionBit {
hasAbstract,
hasConst,
hasExternal,
hasFinal,
hasInitializer,
hasLate,
hasStatic;
}
extension on Enum {
/// The mask bit for this enum value based on its index.
int get mask => 1 << index;
}