diff --git a/pkg/kernel/lib/text/serializer_combinators.dart b/pkg/kernel/lib/text/serializer_combinators.dart index 91d4ac079994..748b0b548c44 100644 --- a/pkg/kernel/lib/text/serializer_combinators.dart +++ b/pkg/kernel/lib/text/serializer_combinators.dart @@ -230,7 +230,7 @@ class UriSerializer extends TextSerializer { // They require a function mapping serializables to a tag string. This is // implemented by Tagger visitors. // A tagged union of serializer/deserializers. -class Case extends TextSerializer { +class Case extends TextSerializer { final Tagger tagger; final List _tags; final List> _serializers; diff --git a/pkg/kernel/lib/text/text_serialization_verifier.dart b/pkg/kernel/lib/text/text_serialization_verifier.dart index 581c7ef0ed87..dde9c3cc85dc 100644 --- a/pkg/kernel/lib/text/text_serialization_verifier.dart +++ b/pkg/kernel/lib/text/text_serialization_verifier.dart @@ -325,19 +325,13 @@ class VerificationState { static bool isSupported(Node node) => !isNotSupported(node); static bool isNotSupported(Node node) => - node is FunctionNode && node.body == null || - node is Procedure && - (!node.isStatic || node.kind != ProcedureKind.Method) || - node is Class || node is Component || - node is Constructor || node is Extension || node is Library || node is LibraryPart || node is MapEntry || node is Name && node.isPrivate || node is RedirectingFactoryConstructor || - node is Supertype || node is Typedef; } @@ -485,6 +479,10 @@ class TextSerializationVerifier extends RecursiveVisitor { makeRoundTrip(node, switchCaseSerializer); } else if (node is Initializer) { makeRoundTrip(node, initializerSerializer); + } else if (node is Supertype) { + makeRoundTrip(node, supertypeSerializer); + } else if (node is Class) { + makeRoundTrip(node, classSerializer); } else { throw new StateError( "Don't know how to make a round trip for a supported node " diff --git a/pkg/kernel/lib/text/text_serializer.dart b/pkg/kernel/lib/text/text_serializer.dart index cba55cb05377..8daa96047cef 100644 --- a/pkg/kernel/lib/text/text_serializer.dart +++ b/pkg/kernel/lib/text/text_serializer.dart @@ -10,8 +10,8 @@ import 'serializer_combinators.dart'; import '../visitor.dart' show ExpressionVisitor; -abstract class Tagger { - String tag(T node); +abstract class Tagger { + String tag(T object); } class NameTagger implements Tagger { @@ -810,25 +810,21 @@ const Map variableDeclarationFlagToName = const { VariableDeclaration.FlagRequired: "required", }; -class VariableDeclarationFlagTagger implements Tagger { - String tag(IntLiteral wrappedFlag) { - int flag = wrappedFlag.value; +class VariableDeclarationFlagTagger implements Tagger { + String tag(int flag) { return variableDeclarationFlagToName[flag] ?? (throw StateError("Unknown VariableDeclaration flag value: ${flag}.")); } } TextSerializer variableDeclarationFlagsSerializer = Wrapped( - (w) => List.generate(30, (i) => IntLiteral(w & (1 << i))) - .where((f) => f.value != 0) - .toList(), - (u) => u.fold(0, (fs, f) => fs |= f.value), + (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(), + (u) => u.fold(0, (fs, f) => fs |= f), ListSerializer(Case( VariableDeclarationFlagTagger(), Map.fromIterable(variableDeclarationFlagToName.entries, key: (e) => e.value, - value: (e) => - Wrapped((_) => null, (_) => IntLiteral(e.key), Nothing()))))); + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))))); TextSerializer variableDeclarationSerializer = Wrapped( (v) => Tuple2(v.name, v), @@ -1380,195 +1376,58 @@ TextSerializer functionDeclarationSerializer = Wrapped( Case statementSerializer = new Case.uninitialized(const StatementTagger()); -class FunctionNodeTagger implements Tagger { - const FunctionNodeTagger(); - - String tag(FunctionNode node) { - switch (node.asyncMarker) { - case AsyncMarker.Async: - return "async"; - case AsyncMarker.Sync: - return "sync"; - case AsyncMarker.AsyncStar: - return "async-star"; - case AsyncMarker.SyncStar: - return "sync-star"; - case AsyncMarker.SyncYielding: - return "sync-yielding"; - } - throw new UnsupportedError("${node.asyncMarker}"); - } -} +const Map asyncMarkerToName = { + AsyncMarker.Async: "async", + AsyncMarker.Sync: "sync", + AsyncMarker.AsyncStar: "async-star", + AsyncMarker.SyncStar: "sync-star", + AsyncMarker.SyncYielding: "sync-yielding", +}; -TextSerializer syncFunctionNodeSerializer = new Wrapped( - unwrapFunctionNode, - wrapSyncFunctionNode, - new Bind( - new Rebind( - typeParametersSerializer, - new Tuple3Serializer( - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer))), - new Tuple2Serializer(dartTypeSerializer, statementSerializer))); - -Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> unwrapFunctionNode(FunctionNode node) { - return new Tuple2( - new Tuple2( - node.typeParameters, - new Tuple3( - node.positionalParameters.sublist(0, node.requiredParameterCount), - node.positionalParameters.sublist(node.requiredParameterCount), - node.namedParameters)), - new Tuple2(node.returnType, node.body)); -} - -FunctionNode wrapSyncFunctionNode( - Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> - tuple) { - return new FunctionNode(tuple.second.second, - typeParameters: tuple.first.first, - positionalParameters: - tuple.first.second.first + tuple.first.second.second, - namedParameters: tuple.first.second.third, - requiredParameterCount: tuple.first.second.first.length, - returnType: tuple.second.first, - asyncMarker: AsyncMarker.Sync); -} - -TextSerializer asyncFunctionNodeSerializer = new Wrapped( - unwrapFunctionNode, - wrapAsyncFunctionNode, - new Bind( - new Rebind( - typeParametersSerializer, - new Tuple3Serializer( - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer))), - new Tuple2Serializer(dartTypeSerializer, statementSerializer))); - -FunctionNode wrapAsyncFunctionNode( - Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> - tuple) { - return new FunctionNode(tuple.second.second, - typeParameters: tuple.first.first, - positionalParameters: - tuple.first.second.first + tuple.first.second.second, - namedParameters: tuple.first.second.third, - requiredParameterCount: tuple.first.second.first.length, - returnType: tuple.second.first, - asyncMarker: AsyncMarker.Async); -} - -TextSerializer syncStarFunctionNodeSerializer = new Wrapped( - unwrapFunctionNode, - wrapSyncStarFunctionNode, - new Bind( - new Rebind( - typeParametersSerializer, - new Tuple3Serializer( - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer))), - new Tuple2Serializer(dartTypeSerializer, statementSerializer))); - -FunctionNode wrapSyncStarFunctionNode( - Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> - tuple) { - return new FunctionNode(tuple.second.second, - typeParameters: tuple.first.first, - positionalParameters: - tuple.first.second.first + tuple.first.second.second, - namedParameters: tuple.first.second.third, - requiredParameterCount: tuple.first.second.first.length, - returnType: tuple.second.first, - asyncMarker: AsyncMarker.SyncStar); -} - -TextSerializer asyncStarFunctionNodeSerializer = new Wrapped( - unwrapFunctionNode, - wrapAsyncStarFunctionNode, - new Bind( - new Rebind( - typeParametersSerializer, - new Tuple3Serializer( - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer))), - new Tuple2Serializer(dartTypeSerializer, statementSerializer))); - -FunctionNode wrapAsyncStarFunctionNode( - Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> - tuple) { - return new FunctionNode(tuple.second.second, - typeParameters: tuple.first.first, - positionalParameters: - tuple.first.second.first + tuple.first.second.second, - namedParameters: tuple.first.second.third, - requiredParameterCount: tuple.first.second.first.length, - returnType: tuple.second.first, - asyncMarker: AsyncMarker.AsyncStar); -} +class AsyncMarkerTagger implements Tagger { + const AsyncMarkerTagger(); -TextSerializer syncYieldingStarFunctionNodeSerializer = - new Wrapped( - unwrapFunctionNode, - wrapSyncYieldingFunctionNode, - new Bind( - new Rebind( - typeParametersSerializer, - new Tuple3Serializer( - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer), - new ListSerializer(variableDeclarationSerializer))), - new Tuple2Serializer(dartTypeSerializer, statementSerializer))); - -FunctionNode wrapSyncYieldingFunctionNode( - Tuple2< - Tuple2< - List, - Tuple3, List, - List>>, - Tuple2> - tuple) { - return new FunctionNode(tuple.second.second, - typeParameters: tuple.first.first, - positionalParameters: - tuple.first.second.first + tuple.first.second.second, - namedParameters: tuple.first.second.third, - requiredParameterCount: tuple.first.second.first.length, - returnType: tuple.second.first, - asyncMarker: AsyncMarker.SyncYielding); + String tag(AsyncMarker node) { + return asyncMarkerToName[node] ?? (throw new UnsupportedError("${node}")); + } } -Case functionNodeSerializer = - new Case.uninitialized(const FunctionNodeTagger()); +TextSerializer asyncMarkerSerializer = Case( + AsyncMarkerTagger(), + Map.fromIterable(asyncMarkerToName.entries, + key: (e) => e.value, + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))); + +TextSerializer functionNodeSerializer = new Wrapped( + (w) => Tuple2( + w.asyncMarker, + Tuple2( + Tuple2( + w.typeParameters, + Tuple3( + w.positionalParameters.sublist(0, w.requiredParameterCount), + w.positionalParameters.sublist(w.requiredParameterCount), + w.namedParameters)), + Tuple2(w.returnType, w.body))), + (u) => FunctionNode(u.second.second.second, + typeParameters: u.second.first.first, + positionalParameters: + u.second.first.second.first + u.second.first.second.second, + namedParameters: u.second.first.second.third, + requiredParameterCount: u.second.first.second.first.length, + returnType: u.second.second.first, + asyncMarker: u.first), + Tuple2Serializer( + asyncMarkerSerializer, + Bind( + Rebind( + typeParametersSerializer, + Tuple3Serializer( + ListSerializer(variableDeclarationSerializer), + ListSerializer(variableDeclarationSerializer), + ListSerializer(variableDeclarationSerializer))), + Tuple2Serializer( + dartTypeSerializer, Optional(statementSerializer))))); const Map procedureFlagToName = const { Procedure.FlagStatic: "static", @@ -1585,27 +1444,23 @@ const Map procedureFlagToName = const { Procedure.FlagNonNullableByDefault: "non-nullable-by-default", }; -class ProcedureFlagTagger implements Tagger { +class ProcedureFlagTagger implements Tagger { const ProcedureFlagTagger(); - String tag(IntLiteral wrappedFlag) { - int flag = wrappedFlag.value; + String tag(int flag) { return procedureFlagToName[flag] ?? (throw StateError("Unknown Procedure flag value: ${flag}.")); } } TextSerializer procedureFlagsSerializer = Wrapped( - (w) => List.generate(30, (i) => IntLiteral(w & (1 << i))) - .where((f) => f.value != 0) - .toList(), - (u) => u.fold(0, (fs, f) => fs |= f.value), + (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(), + (u) => u.fold(0, (fs, f) => fs |= f), ListSerializer(Case( ProcedureFlagTagger(), Map.fromIterable(procedureFlagToName.entries, key: (e) => e.value, - value: (e) => - Wrapped((_) => null, (_) => IntLiteral(e.key), Nothing()))))); + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))))); const Map fieldFlagToName = const { Field.FlagFinal: "final", @@ -1621,27 +1476,48 @@ const Map fieldFlagToName = const { Field.FlagInternalImplementation: "internal-implementation", }; -class FieldFlagTagger implements Tagger { +class FieldFlagTagger implements Tagger { const FieldFlagTagger(); - String tag(IntLiteral wrappedFlag) { - int flag = wrappedFlag.value; + String tag(int flag) { return fieldFlagToName[flag] ?? (throw StateError("Unknown Field flag value: ${flag}.")); } } TextSerializer fieldFlagsSerializer = Wrapped( - (w) => List.generate(30, (i) => IntLiteral(w & (1 << i))) - .where((f) => f.value != 0) - .toList(), - (u) => u.fold(0, (fs, f) => fs |= f.value), + (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(), + (u) => u.fold(0, (fs, f) => fs |= f), ListSerializer(Case( FieldFlagTagger(), Map.fromIterable(fieldFlagToName.entries, key: (e) => e.value, - value: (e) => - Wrapped((_) => null, (_) => IntLiteral(e.key), Nothing()))))); + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))))); + +const Map constructorFlagToName = const { + Constructor.FlagConst: "const", + Constructor.FlagExternal: "external", + Constructor.FlagSynthetic: "synthetic", + Constructor.FlagNonNullableByDefault: "non-nullable-by-default", +}; + +class ConstructorFlagTagger implements Tagger { + const ConstructorFlagTagger(); + + String tag(int flag) { + return constructorFlagToName[flag] ?? + (throw StateError("Unknown Constructor flag value: ${flag}.")); + } +} + +TextSerializer constructorFlagsSerializer = Wrapped( + (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(), + (u) => u.fold(0, (fs, f) => fs |= f), + ListSerializer(Case( + ConstructorFlagTagger(), + Map.fromIterable(constructorFlagToName.entries, + key: (e) => e.value, + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))))); class MemberTagger implements Tagger { const MemberTagger(); @@ -1649,12 +1525,22 @@ class MemberTagger implements Tagger { String tag(Member node) { if (node is Field) { return "field"; + } else if (node is Constructor) { + return "constructor"; } else if (node is Procedure) { switch (node.kind) { case ProcedureKind.Method: return "method"; + case ProcedureKind.Getter: + return "getter"; + case ProcedureKind.Setter: + return "setter"; + case ProcedureKind.Operator: + return "operator"; + case ProcedureKind.Factory: + return "factory"; default: - throw new UnsupportedError("${node.kind}"); + throw new UnsupportedError("MemberTagger.tag(${node.kind})"); } } else { throw UnimplementedError("MemberTagger.tag(${node.runtimeType})"); @@ -1675,6 +1561,38 @@ TextSerializer methodSerializer = Wrapped( Tuple3Serializer( nameSerializer, procedureFlagsSerializer, functionNodeSerializer)); +TextSerializer getterSerializer = Wrapped( + (w) => Tuple3(w.name, w.flags, w.function), + (u) => Procedure(u.first, ProcedureKind.Getter, u.third)..flags = u.second, + Tuple3Serializer( + nameSerializer, procedureFlagsSerializer, functionNodeSerializer)); + +TextSerializer setterSerializer = Wrapped( + (w) => Tuple3(w.name, w.flags, w.function), + (u) => Procedure(u.first, ProcedureKind.Setter, u.third)..flags = u.second, + Tuple3Serializer( + nameSerializer, procedureFlagsSerializer, functionNodeSerializer)); + +TextSerializer operatorSerializer = Wrapped( + (w) => Tuple3(w.name, w.flags, w.function), + (u) => + Procedure(u.first, ProcedureKind.Operator, u.third)..flags = u.second, + Tuple3Serializer( + nameSerializer, procedureFlagsSerializer, functionNodeSerializer)); + +TextSerializer factorySerializer = Wrapped( + (w) => Tuple3(w.name, w.flags, w.function), + (u) => Procedure(u.first, ProcedureKind.Factory, u.third)..flags = u.second, + Tuple3Serializer( + nameSerializer, procedureFlagsSerializer, functionNodeSerializer)); + +TextSerializer constructorSerializer = Wrapped( + (w) => Tuple4(w.name, w.flags, w.initializers, w.function), + (u) => Constructor(u.fourth, name: u.first, initializers: u.third) + ..flags = u.second, + Tuple4Serializer(nameSerializer, constructorFlagsSerializer, + ListSerializer(initializerSerializer), functionNodeSerializer)); + Case memberSerializer = new Case.uninitialized(const MemberTagger()); class LibraryTagger implements Tagger { @@ -1686,12 +1604,14 @@ class LibraryTagger implements Tagger { } TextSerializer libraryContentsSerializer = new Wrapped( - (w) => Tuple2(w.importUri, [...w.fields, ...w.procedures]), + (w) => Tuple3(w.importUri, [...w.fields, ...w.procedures], w.classes), (u) => Library(u.first, fields: u.second.where((m) => m is Field).cast().toList(), procedures: - u.second.where((m) => m is Procedure).cast().toList()), - new Tuple2Serializer(const UriSerializer(), ListSerializer(memberSerializer)), + u.second.where((m) => m is Procedure).cast().toList(), + classes: u.third), + Tuple3Serializer(const UriSerializer(), ListSerializer(memberSerializer), + ListSerializer(classSerializer)), ); Case librarySerializer = new Case.uninitialized(const LibraryTagger()); @@ -1879,6 +1799,77 @@ TextSerializer superInitializerSerializer = Wrapped( Case initializerSerializer = Case.uninitialized(InitializerTagger()); +TextSerializer supertypeSerializer = Wrapped( + (w) => Tuple2(w.className.canonicalName, w.typeArguments), + (u) => Supertype.byReference(u.first.getReference(), u.second), + Tuple2Serializer( + CanonicalNameSerializer(), ListSerializer(dartTypeSerializer))); + +const Map classFlagToName = const { + Class.FlagAbstract: "abstract", + Class.FlagEnum: "enum", + Class.FlagAnonymousMixin: "anonymous-mixin", + Class.FlagEliminatedMixin: "eliminated-mixin", + Class.FlagMixinDeclaration: "mixin-declaration", + Class.FlagHasConstConstructor: "has-const-constructor", +}; + +class ClassFlagTagger implements Tagger { + const ClassFlagTagger(); + + String tag(int flag) { + return classFlagToName[flag] ?? + (throw StateError("Unknown Class flag value: ${flag}.")); + } +} + +TextSerializer classFlagsSerializer = Wrapped( + (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(), + (u) => u.fold(0, (fs, f) => fs |= f), + ListSerializer(Case( + ClassFlagTagger(), + Map.fromIterable(classFlagToName.entries, + key: (e) => e.value, + value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()))))); + +TextSerializer classSerializer = Wrapped( + (w) => Tuple3( + w.name, + w.flags, + Tuple2( + w.typeParameters, + Tuple4(w.supertype, w.mixedInType, w.implementedTypes, + [...w.fields, ...w.constructors, ...w.procedures]))), + (u) => Class( + name: u.first, + typeParameters: u.third.first, + supertype: u.third.second.first, + mixedInType: u.third.second.second, + implementedTypes: u.third.second.third, + fields: u.third.second.fourth + .where((m) => m is Field) + .cast() + .toList(), + constructors: u.third.second.fourth + .where((m) => m is Constructor) + .cast() + .toList(), + procedures: u.third.second.fourth + .where((m) => m is Procedure) + .cast() + .toList()) + ..flags = u.second, + Tuple3Serializer( + DartString(), + classFlagsSerializer, + Bind( + typeParametersSerializer, + Tuple4Serializer( + Optional(supertypeSerializer), + Optional(supertypeSerializer), + ListSerializer(supertypeSerializer), + ListSerializer(memberSerializer))))); + void initializeSerializers() { expressionSerializer.registerTags({ "string": stringLiteralSerializer, @@ -1974,15 +1965,15 @@ void initializeSerializers() { "continue": continueSwitchStatementSerializer, "local-fun": functionDeclarationSerializer, }); - functionNodeSerializer.registerTags({ - "sync": syncFunctionNodeSerializer, - "async": asyncFunctionNodeSerializer, - "sync-star": syncStarFunctionNodeSerializer, - "async-star": asyncStarFunctionNodeSerializer, - "sync-yielding": syncYieldingStarFunctionNodeSerializer, + memberSerializer.registerTags({ + "field": fieldSerializer, + "method": methodSerializer, + "getter": getterSerializer, + "setter": setterSerializer, + "operator": operatorSerializer, + "factory": factorySerializer, + "constructor": constructorSerializer, }); - memberSerializer - .registerTags({"field": fieldSerializer, "method": methodSerializer}); librarySerializer.registerTags({ "legacy": libraryContentsSerializer, "null-safe": libraryContentsSerializer, diff --git a/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart b/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart index aa5fe6d31668..0c9de8344a93 100644 --- a/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart +++ b/pkg/kernel/test/text_serializer_from_kernel_nodes_test.dart @@ -389,9 +389,9 @@ void test() { returnType: new TypeParameterType(t, Nullability.legacy), asyncMarker: AsyncMarker.Sync))), expectation: '' - '(expr (fun (sync ("T^0") ((dynamic)) ((dynamic)) ("t1^1" ' + '(expr (fun (sync) ("T^0") ((dynamic)) ((dynamic)) ("t1^1" ' '() (par "T^0" _) _ ()) ("t2^2" () (par "T^0" _) ' - '_ ()) () (par "T^0" _) (ret (get-var "t1^1" _)))))', + '_ ()) () (par "T^0" _) (ret (get-var "t1^1" _))))', makeSerializationState: () => new SerializationState(new SerializationEnvironment(null)), makeDeserializationState: () => new DeserializationState( @@ -415,8 +415,8 @@ void test() { node: foo, expectation: '' '(method (public "foo") ((static))' - ' (sync () () () ("x^0" () (dynamic) _ ()) () ()' - ' (dynamic) (ret (get-var "x^0" _))))', + ' (sync) () () () ("x^0" () (dynamic) _ ()) () ()' + ' (dynamic) (ret (get-var "x^0" _)))', makeSerializationState: () => new SerializationState(new SerializationEnvironment(null)), makeDeserializationState: () => new DeserializationState( @@ -451,13 +451,16 @@ void test() { '(legacy "package:foo/bar.dart"' '' ' ((method (public "foo") ((static))' - ' (sync () () () ("x^0" () (dynamic) _ ()) () () (dynamic)' - ' (ret (get-var "x^0" _))))' + ' (sync) () () () ("x^0" () (dynamic) _ ()) () () (dynamic)' + ' (ret (get-var "x^0" _)))' '' ' (method (public "bar") ((static))' - ' (sync () () () ("x^0" () (dynamic) _ ()) () () (dynamic)' - ' (ret (invoke-static "package:foo/bar.dart::@methods::foo"' - ' () ((get-var "x^0" _)) ()))))))', + ' (sync) () () () ("x^0" () (dynamic) _ ()) () () (dynamic)' + ' (ret' + ' (invoke-static "package:foo/bar.dart::@methods::foo"' + ' () ((get-var "x^0" _)) ()))))' + '' + ' ())', makeSerializationState: () => new SerializationState(new SerializationEnvironment(null)), makeDeserializationState: () => new DeserializationState( @@ -481,10 +484,12 @@ void test() { node: library, expectation: '' '(legacy "package:foo/bar.dart"' + '' ' ((method (public "foo") ((static))' - ' (sync () () () () () ()' - ' (interface "package:foo/bar.dart::A" ())' - ' (ret (null))))))', + ' (sync) () () () () () () (interface "package:foo/bar.dart::A" ())' + ' (ret (null))))' + '' + ' ("A" () () () () _ _ () ()))', makeSerializationState: () => new SerializationState(new SerializationEnvironment(null)), makeDeserializationState: () => new DeserializationState(