Version 2.12.0-48.0.dev
Merge commit '2f27573c41eca3c54683a8c19cc47678a9947c3a' into 'dev'
diff --git a/.dart_tool/package_config.json b/.dart_tool/package_config.json
index c75c95d3..d9dd292 100644
--- a/.dart_tool/package_config.json
+++ b/.dart_tool/package_config.json
@@ -11,7 +11,7 @@
"constraint, update this by running tools/generate_package_config.dart."
],
"configVersion": 2,
- "generated": "2020-10-26T09:42:07.748397",
+ "generated": "2020-11-15T14:18:10.587065",
"generator": "tools/generate_package_config.dart",
"packages": [
{
@@ -267,7 +267,7 @@
"name": "front_end",
"rootUri": "../pkg/front_end",
"packageUri": "lib/",
- "languageVersion": "2.2"
+ "languageVersion": "2.6"
},
{
"name": "front_end_testcases",
@@ -361,7 +361,7 @@
"name": "kernel",
"rootUri": "../pkg/kernel",
"packageUri": "lib/",
- "languageVersion": "2.2"
+ "languageVersion": "2.6"
},
{
"name": "language_versioning_2.7_test",
diff --git a/pkg/front_end/pubspec.yaml b/pkg/front_end/pubspec.yaml
index 3f3905b..e34f9f2 100644
--- a/pkg/front_end/pubspec.yaml
+++ b/pkg/front_end/pubspec.yaml
@@ -6,7 +6,7 @@
publish_to: none
environment:
- sdk: '>=2.2.2 <3.0.0'
+ sdk: '>=2.6.0 <3.0.0'
dependencies:
_fe_analyzer_shared: any
diff --git a/pkg/front_end/test/static_types/cfe_allowed.json b/pkg/front_end/test/static_types/cfe_allowed.json
index 1e26e85..9dd0b5b 100644
--- a/pkg/front_end/test/static_types/cfe_allowed.json
+++ b/pkg/front_end/test/static_types/cfe_allowed.json
@@ -40,28 +40,6 @@
"pkg/front_end/lib/src/fasta/kernel/body_builder.dart": {
"Dynamic invocation of 'buildForEffect'.": 1
},
- "pkg/kernel/lib/text/text_serializer.dart": {
- "Dynamic access of 'first'.": 68,
- "Dynamic invocation of 'getReference'.": 10,
- "Dynamic access of 'second'.": 88,
- "Dynamic access of 'third'.": 29,
- "Dynamic access of 'fourth'.": 17,
- "Dynamic access of 'fifth'.": 3,
- "Dynamic access of 'sixth'.": 2,
- "Dynamic invocation of 'fold'.": 9,
- "Dynamic invocation of '|'.": 8,
- "Dynamic access of 'value'.": 11,
- "Dynamic access of 'key'.": 11,
- "Dynamic update to 'name'.": 2,
- "Dynamic invocation of 'addAnnotation'.": 1,
- "Dynamic access of 'expressions'.": 1,
- "Dynamic access of 'length'.": 3,
- "Dynamic invocation of '+'.": 2,
- "Dynamic invocation of 'toList'.": 5,
- "Dynamic invocation of 'cast'.": 5,
- "Dynamic invocation of 'where'.": 5,
- "Dynamic access of 'seventh'.": 1
- },
"pkg/_fe_analyzer_shared/lib/src/util/link.dart": {
"Dynamic access of 'isEmpty'.": 1
},
diff --git a/pkg/front_end/testcases/text_serialization.status b/pkg/front_end/testcases/text_serialization.status
index 20825b3..cdc1183 100644
--- a/pkg/front_end/testcases/text_serialization.status
+++ b/pkg/front_end/testcases/text_serialization.status
@@ -24,10 +24,6 @@
general/callable_type_variable: TypeCheckError
general/candidate_found: TypeCheckError
general/cascade: RuntimeError
-general/constants/with_unevaluated_agnostic/const_asserts: TextSerializationFailure
-general/constants/with_unevaluated_agnostic/const_collections_2: TextSerializationFailure
-general/constants/with_unevaluated_agnostic/various: TextSerializationFailure
-general/constants/with_unevaluated_agnostic/various_2: TextSerializationFailure
general/constructor_initializer_invalid: RuntimeError
general/covariant_field: TypeCheckError
general/covariant_generic: RuntimeError
diff --git a/pkg/kernel/lib/text/text_serializer.dart b/pkg/kernel/lib/text/text_serializer.dart
index 42b5bda..0aee5ce 100644
--- a/pkg/kernel/lib/text/text_serializer.dart
+++ b/pkg/kernel/lib/text/text_serializer.dart
@@ -23,7 +23,7 @@
TextSerializer<Name> publicName =
Wrapped((w) => w.text, (u) => Name(u), const DartString());
-TextSerializer<Name> privateName = Wrapped(
+TextSerializer<Name> privateName = Wrapped<Tuple2<String, CanonicalName>, Name>(
(w) => Tuple2(w.text, w.library.canonicalName),
(u) => Name.byReference(u.first, u.second.getReference()),
Tuple2Serializer(DartString(), CanonicalNameSerializer()));
@@ -629,39 +629,48 @@
return new FunctionExpression(node);
}
-TextSerializer<ListConcatenation> listConcatenationSerializer = Wrapped(
- (lc) => Tuple2(lc.typeArgument, lc.lists),
- (t) => ListConcatenation(t.second, typeArgument: t.first),
- Tuple2Serializer(dartTypeSerializer, ListSerializer(expressionSerializer)));
+TextSerializer<ListConcatenation> listConcatenationSerializer =
+ Wrapped<Tuple2<DartType, List<Expression>>, ListConcatenation>(
+ (lc) => Tuple2(lc.typeArgument, lc.lists),
+ (t) => ListConcatenation(t.second, typeArgument: t.first),
+ Tuple2Serializer(
+ dartTypeSerializer, ListSerializer(expressionSerializer)));
-TextSerializer<SetConcatenation> setConcatenationSerializer = Wrapped(
- (sc) => Tuple2(sc.typeArgument, sc.sets),
- (t) => SetConcatenation(t.second, typeArgument: t.first),
- Tuple2Serializer(dartTypeSerializer, ListSerializer(expressionSerializer)));
+TextSerializer<SetConcatenation> setConcatenationSerializer =
+ Wrapped<Tuple2<DartType, List<Expression>>, SetConcatenation>(
+ (sc) => Tuple2(sc.typeArgument, sc.sets),
+ (t) => SetConcatenation(t.second, typeArgument: t.first),
+ Tuple2Serializer(
+ dartTypeSerializer, ListSerializer(expressionSerializer)));
-TextSerializer<MapConcatenation> mapConcatenationSerializer = Wrapped(
- (mc) => Tuple3(mc.keyType, mc.valueType, mc.maps),
- (t) => MapConcatenation(t.third, keyType: t.first, valueType: t.second),
- Tuple3Serializer(dartTypeSerializer, dartTypeSerializer,
- ListSerializer(expressionSerializer)));
+TextSerializer<MapConcatenation> mapConcatenationSerializer =
+ Wrapped<Tuple3<DartType, DartType, List<Expression>>, MapConcatenation>(
+ (mc) => Tuple3(mc.keyType, mc.valueType, mc.maps),
+ (t) => MapConcatenation(t.third, keyType: t.first, valueType: t.second),
+ Tuple3Serializer(dartTypeSerializer, dartTypeSerializer,
+ ListSerializer(expressionSerializer)));
-TextSerializer<BlockExpression> blockExpressionSerializer = Wrapped(
- (w) => Tuple2(w.body.statements, w.value),
- (u) => BlockExpression(Block(u.first), u.second),
- const BlockSerializer());
+TextSerializer<BlockExpression> blockExpressionSerializer =
+ Wrapped<Tuple2<List<Statement>, Expression>, BlockExpression>(
+ (w) => Tuple2(w.body.statements, w.value),
+ (u) => BlockExpression(Block(u.first), u.second),
+ const BlockSerializer());
-TextSerializer<Instantiation> instantiationSerializer = Wrapped(
- (i) => Tuple2(i.expression, i.typeArguments),
- (t) => Instantiation(t.first, t.second),
- Tuple2Serializer(expressionSerializer, ListSerializer(dartTypeSerializer)));
+TextSerializer<Instantiation> instantiationSerializer =
+ Wrapped<Tuple2<Expression, List<DartType>>, Instantiation>(
+ (i) => Tuple2(i.expression, i.typeArguments),
+ (t) => Instantiation(t.first, t.second),
+ Tuple2Serializer(
+ expressionSerializer, ListSerializer(dartTypeSerializer)));
TextSerializer<NullCheck> nullCheckSerializer =
Wrapped((nc) => nc.operand, (op) => NullCheck(op), expressionSerializer);
-TextSerializer<FileUriExpression> fileUriExpressionSerializer = Wrapped(
- (fue) => Tuple2(fue.expression, fue.fileUri),
- (t) => FileUriExpression(t.first, t.second),
- Tuple2Serializer(expressionSerializer, const UriSerializer()));
+TextSerializer<FileUriExpression> fileUriExpressionSerializer =
+ Wrapped<Tuple2<Expression, Uri>, FileUriExpression>(
+ (fue) => Tuple2(fue.expression, fue.fileUri),
+ (t) => FileUriExpression(t.first, t.second),
+ Tuple2Serializer(expressionSerializer, const UriSerializer()));
TextSerializer<CheckLibraryIsLoaded> checkLibraryIsLoadedSerializer = Wrapped(
(clil) => clil.import,
@@ -671,12 +680,16 @@
TextSerializer<LoadLibrary> loadLibrarySerializer = Wrapped(
(ll) => ll.import, (i) => LoadLibrary(i), libraryDependencySerializer);
-TextSerializer<ConstantExpression> constantExpressionSerializer = Wrapped(
- (ce) => Tuple2(ce.constant, ce.type),
- (t) => ConstantExpression(t.first, t.second),
- Tuple2Serializer(constantSerializer, dartTypeSerializer));
+TextSerializer<ConstantExpression> constantExpressionSerializer =
+ Wrapped<Tuple2<Constant, DartType>, ConstantExpression>(
+ (ce) => Tuple2(ce.constant, ce.type),
+ (t) => ConstantExpression(t.first, t.second),
+ Tuple2Serializer(constantSerializer, dartTypeSerializer));
-TextSerializer<InstanceCreation> instanceCreationSerializer = Wrapped(
+TextSerializer<InstanceCreation> instanceCreationSerializer = Wrapped<
+ Tuple6<CanonicalName, List<DartType>, List<CanonicalName>,
+ List<Expression>, List<AssertStatement>, List<Expression>>,
+ InstanceCreation>(
(ic) => Tuple6(
ic.classReference.canonicalName,
ic.typeArguments,
@@ -684,8 +697,12 @@
ic.fieldValues.values.toList(),
ic.asserts,
ic.unusedArguments),
- (t) => InstanceCreation(t.first.getReference(), t.second,
- Map.fromIterables(t.third, t.fourth), t.fifth, t.sixth),
+ (t) => InstanceCreation(
+ t.first.getReference(),
+ t.second,
+ Map.fromIterables(t.third.map((cn) => cn.reference), t.fourth),
+ t.fifth,
+ t.sixth),
Tuple6Serializer(
CanonicalNameSerializer(),
ListSerializer(dartTypeSerializer),
@@ -746,36 +763,39 @@
}
}
-TextSerializer<int> variableDeclarationFlagsSerializer = Wrapped(
- (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, (_) => e.key, Nothing())))));
+TextSerializer<int> variableDeclarationFlagsSerializer =
+ Wrapped<List<int>, int>(
+ (w) => List.generate(30, (i) => w & (1 << i))
+ .where((f) => f != 0)
+ .toList(),
+ (u) => u.fold(0, (fs, f) => fs |= f),
+ ListSerializer(Case(VariableDeclarationFlagTagger(),
+ convertFlagsMap(variableDeclarationFlagToName))));
-TextSerializer<VariableDeclaration> variableDeclarationSerializer = Wrapped(
- (v) => Tuple2(v.name, v),
- (t) => t.second..name = t.first,
- Binder<VariableDeclaration>(
- new Wrapped(
- (w) => Tuple4(w.flags, w.type, w.initializer, w.annotations),
- (u) => u.fourth.fold(
- VariableDeclaration(null,
- flags: u.first, type: u.second, initializer: u.third),
- (v, a) => v..addAnnotation(a)),
- Tuple4Serializer(
- variableDeclarationFlagsSerializer,
- dartTypeSerializer,
- new Optional(expressionSerializer),
- new ListSerializer(expressionSerializer))),
- ));
+TextSerializer<VariableDeclaration> variableDeclarationSerializer =
+ Wrapped<Tuple2<String, VariableDeclaration>, VariableDeclaration>(
+ (v) => Tuple2(v.name, v),
+ (t) => t.second..name = t.first,
+ Binder<VariableDeclaration>(
+ new Wrapped<Tuple4<int, DartType, Expression, List<Expression>>,
+ VariableDeclaration>(
+ (w) => Tuple4(w.flags, w.type, w.initializer, w.annotations),
+ (u) => u.fourth.fold(
+ VariableDeclaration(null,
+ flags: u.first, type: u.second, initializer: u.third),
+ (v, a) => v..addAnnotation(a)),
+ Tuple4Serializer(
+ variableDeclarationFlagsSerializer,
+ dartTypeSerializer,
+ new Optional(expressionSerializer),
+ new ListSerializer(expressionSerializer))),
+ ));
-TextSerializer<TypeParameter> typeParameterSerializer = Wrapped(
- (p) => Tuple2(p.name, p),
- (t) => t.second..name = t.first,
- Binder(Wrapped((_) => null, (_) => TypeParameter(), const Nothing())));
+TextSerializer<TypeParameter> typeParameterSerializer =
+ Wrapped<Tuple2<String, TypeParameter>, TypeParameter>(
+ (p) => Tuple2(p.name, p),
+ (t) => t.second..name = t.first,
+ Binder(Wrapped((_) => null, (_) => TypeParameter(), const Nothing())));
TextSerializer<List<TypeParameter>> typeParametersSerializer = new Zip(
new Rebind(
@@ -1048,18 +1068,23 @@
return new YieldStatement(expression);
}
-TextSerializer<AssertStatement> assertStatementSerializer = Wrapped(
- (a) => Tuple2(a.condition, a.message),
- (t) => AssertStatement(t.first, message: t.second),
- Tuple2Serializer(expressionSerializer, Optional(expressionSerializer)));
+TextSerializer<AssertStatement> assertStatementSerializer =
+ Wrapped<Tuple2<Expression, Expression>, AssertStatement>(
+ (a) => Tuple2(a.condition, a.message),
+ (t) => AssertStatement(t.first, message: t.second),
+ Tuple2Serializer(expressionSerializer, Optional(expressionSerializer)));
-TextSerializer<Block> blockSerializer = new Wrapped(
- (w) => Tuple2(w.statements, null),
- (u) => Block(u.first),
- const BlockSerializer());
+TextSerializer<Block> blockSerializer =
+ Wrapped<Tuple2<List<Statement>, Expression>, Block>(
+ (w) => Tuple2(w.statements, null),
+ (u) => Block(u.first),
+ const BlockSerializer());
-TextSerializer<AssertBlock> assertBlockSerializer = new Wrapped(
- (w) => Tuple2(w.statements, null), (u) => u.first, const BlockSerializer());
+TextSerializer<AssertBlock> assertBlockSerializer =
+ Wrapped<Tuple2<List<Statement>, Expression>, AssertBlock>(
+ (w) => Tuple2(w.statements, null),
+ (u) => AssertBlock(u.first),
+ const BlockSerializer());
/// Serializer for [Block]s.
///
@@ -1179,7 +1204,10 @@
return new DoStatement(tuple.first, tuple.second);
}
-TextSerializer<ForStatement> forStatementSerializer = new Wrapped(
+TextSerializer<ForStatement> forStatementSerializer = Wrapped<
+ Tuple2<List<VariableDeclaration>,
+ Tuple3<Expression, List<Expression>, Statement>>,
+ ForStatement>(
(w) => Tuple2(w.variables, Tuple3(w.condition, w.updates, w.body)),
(u) =>
ForStatement(u.first, u.second.first, u.second.second, u.second.third),
@@ -1223,7 +1251,7 @@
(ls) => Tuple2(ls, ls.body),
(t) => t.first..body = t.second,
Bind(
- Wrapped(
+ Wrapped<Tuple2<String, LabeledStatement>, LabeledStatement>(
(ls) => Tuple2("L", ls),
(t) => t.second,
Binder(Wrapped(
@@ -1243,37 +1271,47 @@
return new BreakStatement(node);
}
-TextSerializer<TryFinally> tryFinallySerializer = Wrapped(
- (w) => Tuple2(w.body, w.finalizer),
- (u) => TryFinally(u.first, u.second),
- Tuple2Serializer(statementSerializer, statementSerializer));
+TextSerializer<TryFinally> tryFinallySerializer =
+ Wrapped<Tuple2<Statement, Statement>, TryFinally>(
+ (w) => Tuple2(w.body, w.finalizer),
+ (u) => TryFinally(u.first, u.second),
+ Tuple2Serializer(statementSerializer, statementSerializer));
-TextSerializer<TryCatch> tryCatchSerializer = Wrapped(
- (w) => Tuple2(w.body, w.catches),
- (u) => TryCatch(u.first, u.second),
- Tuple2Serializer(statementSerializer, ListSerializer(catchSerializer)));
+TextSerializer<TryCatch> tryCatchSerializer =
+ Wrapped<Tuple2<Statement, List<Catch>>, TryCatch>(
+ (w) => Tuple2(w.body, w.catches),
+ (u) => TryCatch(u.first, u.second),
+ Tuple2Serializer(statementSerializer, ListSerializer(catchSerializer)));
-TextSerializer<Catch> catchSerializer = Wrapped(
- (w) => Tuple2(w.guard, Tuple2(Tuple2(w.exception, w.stackTrace), w.body)),
- (u) => Catch(u.second.first.first, u.second.second,
- stackTrace: u.second.first.second, guard: u.first),
- Tuple2Serializer(
- dartTypeSerializer,
- Bind(
- Tuple2Serializer(Optional(variableDeclarationSerializer),
- Optional(variableDeclarationSerializer)),
- statementSerializer)));
+TextSerializer<Catch> catchSerializer =
+ Wrapped<
+ Tuple2<
+ DartType,
+ Tuple2<Tuple2<VariableDeclaration, VariableDeclaration>,
+ Statement>>,
+ Catch>(
+ (w) =>
+ Tuple2(w.guard, Tuple2(Tuple2(w.exception, w.stackTrace), w.body)),
+ (u) => Catch(u.second.first.first, u.second.second,
+ stackTrace: u.second.first.second, guard: u.first),
+ Tuple2Serializer(
+ dartTypeSerializer,
+ Bind(
+ Tuple2Serializer(Optional(variableDeclarationSerializer),
+ Optional(variableDeclarationSerializer)),
+ statementSerializer)));
-TextSerializer<SwitchStatement> switchStatementSerializer = Wrapped(
- (w) => Tuple2(w.expression, w.cases),
- (u) => SwitchStatement(u.first, u.second),
- Tuple2Serializer(
- expressionSerializer,
- Zip(
- Bind(ListSerializer<SwitchCase>(switchCaseSerializer),
- ListSerializer(statementSerializer)),
- (SwitchCase c, Statement b) => c..body = b,
- (SwitchCase z) => Tuple2(z, z.body))));
+TextSerializer<SwitchStatement> switchStatementSerializer =
+ Wrapped<Tuple2<Expression, List<SwitchCase>>, SwitchStatement>(
+ (w) => Tuple2(w.expression, w.cases),
+ (u) => SwitchStatement(u.first, u.second),
+ Tuple2Serializer(
+ expressionSerializer,
+ Zip(
+ Bind(ListSerializer<SwitchCase>(switchCaseSerializer),
+ ListSerializer(statementSerializer)),
+ (SwitchCase c, Statement b) => c..body = b,
+ (SwitchCase z) => Tuple2(z, z.body))));
class SwitchCaseTagger implements Tagger<SwitchCase> {
String tag(SwitchCase node) {
@@ -1281,15 +1319,17 @@
}
}
-TextSerializer<SwitchCase> switchCaseCaseSerializer = Wrapped(
- (w) => Tuple2("L", w),
- (u) => u.second,
- Binder(Wrapped(
- (w) => w.expressions,
- (u) => SwitchCase(u, List.filled(u.length, 0), null),
- ListSerializer(expressionSerializer))));
+TextSerializer<SwitchCase> switchCaseCaseSerializer =
+ Wrapped<Tuple2<String, SwitchCase>, SwitchCase>(
+ (w) => Tuple2("L", w),
+ (u) => u.second,
+ Binder(Wrapped<List<Expression>, SwitchCase>(
+ (w) => w.expressions,
+ (u) => SwitchCase(u, List.filled(u.length, 0), null),
+ ListSerializer(expressionSerializer))));
-TextSerializer<SwitchCase> switchCaseDefaultSerializer = Wrapped(
+TextSerializer<SwitchCase> switchCaseDefaultSerializer = Wrapped<
+ Tuple2<String, SwitchCase>, SwitchCase>(
(w) => Tuple2("L", w),
(u) => u.second,
Binder(
@@ -1303,10 +1343,11 @@
TextSerializer<ContinueSwitchStatement> continueSwitchStatementSerializer =
Wrapped((w) => w.target, (u) => ContinueSwitchStatement(u), ScopedUse());
-TextSerializer<FunctionDeclaration> functionDeclarationSerializer = Wrapped(
- (w) => Tuple2(w.variable, w.function),
- (u) => FunctionDeclaration(u.first, u.second),
- Rebind(variableDeclarationSerializer, functionNodeSerializer));
+TextSerializer<FunctionDeclaration> functionDeclarationSerializer =
+ Wrapped<Tuple2<VariableDeclaration, FunctionNode>, FunctionDeclaration>(
+ (w) => Tuple2(w.variable, w.function),
+ (u) => FunctionDeclaration(u.first, u.second),
+ Rebind(variableDeclarationSerializer, functionNodeSerializer));
Case<Statement> statementSerializer =
new Case.uninitialized(const StatementTagger());
@@ -1327,14 +1368,24 @@
}
}
-TextSerializer<AsyncMarker> asyncMarkerSerializer = Case(
- AsyncMarkerTagger(),
- Map.fromIterable(asyncMarkerToName.entries,
- key: (e) => e.value,
- value: (e) => Wrapped((_) => null, (_) => e.key, Nothing())));
+TextSerializer<AsyncMarker> asyncMarkerSerializer =
+ Case(AsyncMarkerTagger(), convertFlagsMap(asyncMarkerToName));
-TextSerializer<Tuple2<FunctionNode, List<Initializer>>>
- functionNodeWithInitializersSerializer = Wrapped(
+// '/**/' comments added to guide formatting.
+
+TextSerializer<Tuple2<FunctionNode, List<Initializer>>> /**/
+ functionNodeWithInitializersSerializer = Wrapped<
+ Tuple2<
+ AsyncMarker,
+ Tuple2< /**/
+ Tuple2< /**/
+ List<TypeParameter>,
+ Tuple3<
+ List<VariableDeclaration>,
+ List<VariableDeclaration>,
+ List<VariableDeclaration>>>,
+ Tuple3<DartType, List<Initializer>, Statement>>>,
+ Tuple2<FunctionNode, List<Initializer>>>(
(w) => Tuple2(
w.first.asyncMarker,
Tuple2(
@@ -1371,10 +1422,11 @@
Optional(ListSerializer(initializerSerializer)),
Optional(statementSerializer)))));
-TextSerializer<FunctionNode> functionNodeSerializer = Wrapped(
- (w) => Tuple2(w, null),
- (u) => u.first,
- functionNodeWithInitializersSerializer);
+TextSerializer<FunctionNode> functionNodeSerializer =
+ Wrapped<Tuple2<FunctionNode, List<Initializer>>, FunctionNode>(
+ (w) => Tuple2(w, null),
+ (u) => u.first,
+ functionNodeWithInitializersSerializer);
const Map<int, String> procedureFlagToName = const {
Procedure.FlagStatic: "static",
@@ -1400,14 +1452,11 @@
}
}
-TextSerializer<int> procedureFlagsSerializer = Wrapped(
+TextSerializer<int> procedureFlagsSerializer = Wrapped<List<int>, int>(
(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, (_) => e.key, Nothing())))));
+ ListSerializer(
+ Case(ProcedureFlagTagger(), convertFlagsMap(procedureFlagToName))));
const Map<int, String> fieldFlagToName = const {
Field.FlagFinal: "final",
@@ -1432,14 +1481,10 @@
}
}
-TextSerializer<int> fieldFlagsSerializer = Wrapped(
+TextSerializer<int> fieldFlagsSerializer = Wrapped<List<int>, int>(
(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, (_) => e.key, Nothing())))));
+ ListSerializer(Case(FieldFlagTagger(), convertFlagsMap(fieldFlagToName))));
const Map<int, String> constructorFlagToName = const {
Constructor.FlagConst: "const",
@@ -1457,14 +1502,11 @@
}
}
-TextSerializer<int> constructorFlagsSerializer = Wrapped(
+TextSerializer<int> constructorFlagsSerializer = Wrapped<List<int>, int>(
(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())))));
+ ListSerializer(
+ Case(ConstructorFlagTagger(), convertFlagsMap(constructorFlagToName))));
const Map<int, String> redirectingFactoryConstructorFlagToName = const {
RedirectingFactoryConstructor.FlagConst: "const",
@@ -1483,14 +1525,14 @@
}
}
-TextSerializer<int> redirectingFactoryConstructorFlagsSerializer = Wrapped(
- (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(),
- (u) => u.fold(0, (fs, f) => fs |= f),
- ListSerializer(Case(
- RedirectingFactoryConstructorFlagTagger(),
- Map.fromIterable(redirectingFactoryConstructorFlagToName.entries,
- key: (e) => e.value,
- value: (e) => Wrapped((_) => null, (_) => e.key, Nothing())))));
+TextSerializer<int> redirectingFactoryConstructorFlagsSerializer =
+ Wrapped<List<int>, int>(
+ (w) => List.generate(30, (i) => w & (1 << i))
+ .where((f) => f != 0)
+ .toList(),
+ (u) => u.fold(0, (fs, f) => fs |= f),
+ ListSerializer(Case(RedirectingFactoryConstructorFlagTagger(),
+ convertFlagsMap(redirectingFactoryConstructorFlagToName))));
class MemberTagger implements Tagger<Member> {
const MemberTagger();
@@ -1523,45 +1565,57 @@
}
}
-TextSerializer<Field> fieldSerializer = Wrapped(
- (w) => Tuple4(w.name, w.flags, w.type, w.initializer),
- (u) =>
- Field(u.first, type: u.third, initializer: u.fourth)..flags = u.second,
- Tuple4Serializer(nameSerializer, fieldFlagsSerializer, dartTypeSerializer,
- Optional(expressionSerializer)));
+TextSerializer<Field> fieldSerializer =
+ Wrapped<Tuple4<Name, int, DartType, Expression>, Field>(
+ (w) => Tuple4(w.name, w.flags, w.type, w.initializer),
+ (u) => Field(u.first, type: u.third, initializer: u.fourth)
+ ..flags = u.second,
+ Tuple4Serializer(nameSerializer, fieldFlagsSerializer,
+ dartTypeSerializer, Optional(expressionSerializer)));
-TextSerializer<Procedure> methodSerializer = Wrapped(
- (w) => Tuple3(w.name, w.flags, w.function),
- (u) => Procedure(u.first, ProcedureKind.Method, u.third)..flags = u.second,
- Tuple3Serializer(
- nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
+TextSerializer<Procedure> methodSerializer =
+ Wrapped<Tuple3<Name, int, FunctionNode>, Procedure>(
+ (w) => Tuple3(w.name, w.flags, w.function),
+ (u) =>
+ Procedure(u.first, ProcedureKind.Method, u.third)..flags = u.second,
+ Tuple3Serializer(
+ nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
-TextSerializer<Procedure> 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<Procedure> getterSerializer =
+ Wrapped<Tuple3<Name, int, FunctionNode>, Procedure>(
+ (w) => Tuple3(w.name, w.flags, w.function),
+ (u) =>
+ Procedure(u.first, ProcedureKind.Getter, u.third)..flags = u.second,
+ Tuple3Serializer(
+ nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
-TextSerializer<Procedure> 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<Procedure> setterSerializer =
+ Wrapped<Tuple3<Name, int, FunctionNode>, Procedure>(
+ (w) => Tuple3(w.name, w.flags, w.function),
+ (u) =>
+ Procedure(u.first, ProcedureKind.Setter, u.third)..flags = u.second,
+ Tuple3Serializer(
+ nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
-TextSerializer<Procedure> 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<Procedure> operatorSerializer =
+ Wrapped<Tuple3<Name, int, FunctionNode>, Procedure>(
+ (w) => Tuple3(w.name, w.flags, w.function),
+ (u) => Procedure(u.first, ProcedureKind.Operator, u.third)
+ ..flags = u.second,
+ Tuple3Serializer(
+ nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
-TextSerializer<Procedure> 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<Procedure> factorySerializer =
+ Wrapped<Tuple3<Name, int, FunctionNode>, Procedure>(
+ (w) => Tuple3(w.name, w.flags, w.function),
+ (u) => Procedure(u.first, ProcedureKind.Factory, u.third)
+ ..flags = u.second,
+ Tuple3Serializer(
+ nameSerializer, procedureFlagsSerializer, functionNodeSerializer));
-TextSerializer<Constructor> constructorSerializer = Wrapped(
+TextSerializer<Constructor> constructorSerializer = Wrapped<
+ Tuple3<Name, int, Tuple2<FunctionNode, List<Initializer>>>,
+ Constructor>(
(w) => Tuple3(w.name, w.flags, Tuple2(w.function, w.initializers)),
(u) =>
Constructor(u.third.first, name: u.first, initializers: u.third.second)
@@ -1570,7 +1624,16 @@
functionNodeWithInitializersSerializer));
TextSerializer<RedirectingFactoryConstructor>
- redirectingFactoryConstructorSerializer = Wrapped(
+ redirectingFactoryConstructorSerializer = Wrapped<
+ Tuple4<
+ Name,
+ int,
+ CanonicalName,
+ Tuple2<
+ List<TypeParameter>,
+ Tuple4<List<VariableDeclaration>, List<VariableDeclaration>,
+ List<VariableDeclaration>, List<DartType>>>>,
+ RedirectingFactoryConstructor>(
(w) => Tuple4(
w.name,
w.flags,
@@ -1586,7 +1649,7 @@
.toList(),
w.namedParameters,
w.typeArguments))),
- (u) => RedirectingFactoryConstructor(u.third,
+ (u) => RedirectingFactoryConstructor(u.third.reference,
name: u.first,
typeParameters: u.fourth.first,
positionalParameters:
@@ -1609,10 +1672,11 @@
Case<Member> memberSerializer = new Case.uninitialized(const MemberTagger());
-TextSerializer<LibraryPart> libraryPartSerializer = Wrapped(
- (w) => Tuple2(w.partUri, w.annotations),
- (u) => LibraryPart(u.second, u.first),
- Tuple2Serializer(DartString(), ListSerializer(expressionSerializer)));
+TextSerializer<LibraryPart> libraryPartSerializer =
+ Wrapped<Tuple2<String, List<Expression>>, LibraryPart>(
+ (w) => Tuple2(w.partUri, w.annotations),
+ (u) => LibraryPart(u.second, u.first),
+ Tuple2Serializer(DartString(), ListSerializer(expressionSerializer)));
class LibraryTagger implements Tagger<Library> {
const LibraryTagger();
@@ -1638,16 +1702,16 @@
}
}
-TextSerializer<int> libraryFlagsSerializer = Wrapped(
+TextSerializer<int> libraryFlagsSerializer = Wrapped<List<int>, int>(
(w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(),
(u) => u.fold(0, (fs, f) => fs |= f),
- ListSerializer(Case(
- LibraryFlagTagger(),
- Map.fromIterable(libraryFlagToName.entries,
- key: (e) => e.value,
- value: (e) => Wrapped((_) => null, (_) => e.key, Nothing())))));
+ ListSerializer(
+ Case(LibraryFlagTagger(), convertFlagsMap(libraryFlagToName))));
-TextSerializer<Library> librarySerializer = new Wrapped(
+TextSerializer<Library> librarySerializer = new Wrapped<
+ Tuple7<Uri, int, List<LibraryPart>, List<Member>, List<Class>,
+ List<Typedef>, List<Extension>>,
+ Library>(
(w) => Tuple7(w.importUri, w.flags, w.parts, [...w.fields, ...w.procedures],
w.classes, w.typedefs, w.extensions),
(u) => Library(u.first,
@@ -1669,16 +1733,17 @@
ListSerializer(extensionSerializer)),
);
-TextSerializer<Component> componentSerializer = Wrapped(
- (w) => w.libraries,
- (u) => Component(nameRoot: CanonicalName.root(), libraries: u),
- ListSerializer(librarySerializer));
+TextSerializer<Component> componentSerializer =
+ Wrapped<List<Library>, Component>(
+ (w) => w.libraries,
+ (u) => Component(nameRoot: CanonicalName.root(), libraries: u),
+ ListSerializer(librarySerializer));
class ShowHideTagger implements Tagger<Combinator> {
String tag(Combinator node) => node.isShow ? "show" : "hide";
}
-TextSerializer<Combinator> showSerializer = Wrapped(
+TextSerializer<Combinator> showSerializer = Wrapped<List<String>, Combinator>(
(c) => c.names, (ns) => Combinator(true, ns), ListSerializer(DartString()));
TextSerializer<Combinator> hideSerializer = Wrapped((c) => c.names,
@@ -1689,7 +1754,9 @@
"hide": hideSerializer,
});
-TextSerializer<LibraryDependency> libraryDependencySerializer = Wrapped(
+TextSerializer<LibraryDependency> libraryDependencySerializer = Wrapped<
+ Tuple5<CanonicalName, String, List<Combinator>, int, List<Expression>>,
+ LibraryDependency>(
(ld) => Tuple5(ld.importedLibraryReference.canonicalName, ld.name,
ld.combinators, ld.flags, ld.annotations),
(t) => LibraryDependency.byReference(
@@ -1725,64 +1792,78 @@
}
TextSerializer<BoolConstant> boolConstantSerializer =
- Wrapped((w) => w.value, (u) => BoolConstant(u), DartBool());
+ Wrapped<bool, BoolConstant>(
+ (w) => w.value, (u) => BoolConstant(u), DartBool());
TextSerializer<DoubleConstant> doubleConstantSerializer =
- Wrapped((w) => w.value, (u) => DoubleConstant(u), DartDouble());
+ Wrapped<double, DoubleConstant>(
+ (w) => w.value, (u) => DoubleConstant(u), DartDouble());
TextSerializer<IntConstant> intConstantSerializer =
- Wrapped((w) => w.value, (u) => IntConstant(u), DartInt());
+ Wrapped<int, IntConstant>((w) => w.value, (u) => IntConstant(u), DartInt());
-TextSerializer<ListConstant> listConstantSerializer = Wrapped(
- (w) => Tuple2(w.typeArgument, w.entries),
- (u) => ListConstant(u.first, u.second),
- Tuple2Serializer(dartTypeSerializer, ListSerializer(constantSerializer)));
+TextSerializer<ListConstant> listConstantSerializer =
+ Wrapped<Tuple2<DartType, List<Constant>>, ListConstant>(
+ (w) => Tuple2(w.typeArgument, w.entries),
+ (u) => ListConstant(u.first, u.second),
+ Tuple2Serializer(
+ dartTypeSerializer, ListSerializer(constantSerializer)));
-TextSerializer<MapConstant> mapConstantSerializer = Wrapped(
- (w) => Tuple3(w.keyType, w.valueType, w.entries),
- (u) => MapConstant(u.first, u.second, u.third),
- Tuple3Serializer(
- dartTypeSerializer,
- dartTypeSerializer,
- Zip(
- Tuple2Serializer(ListSerializer(constantSerializer),
- ListSerializer(constantSerializer)),
- (k, v) => ConstantMapEntry(k, v),
- (z) => Tuple2(z.key, z.value))));
+TextSerializer<MapConstant> mapConstantSerializer =
+ Wrapped<Tuple3<DartType, DartType, List<ConstantMapEntry>>, MapConstant>(
+ (w) => Tuple3(w.keyType, w.valueType, w.entries),
+ (u) => MapConstant(u.first, u.second, u.third),
+ Tuple3Serializer(
+ dartTypeSerializer,
+ dartTypeSerializer,
+ Zip(
+ Tuple2Serializer(ListSerializer(constantSerializer),
+ ListSerializer(constantSerializer)),
+ (k, v) => ConstantMapEntry(k, v),
+ (z) => Tuple2(z.key, z.value))));
TextSerializer<NullConstant> nullConstantSerializer =
- Wrapped((w) => null, (u) => NullConstant(), Nothing());
+ Wrapped<void, NullConstant>((w) => null, (u) => NullConstant(), Nothing());
TextSerializer<PartialInstantiationConstant>
- partialInstantiationConstantSerializer = Wrapped(
+ partialInstantiationConstantSerializer = Wrapped<
+ Tuple2<TearOffConstant, List<DartType>>,
+ PartialInstantiationConstant>(
(w) => Tuple2(w.tearOffConstant, w.types),
(u) => PartialInstantiationConstant(u.first, u.second),
Tuple2Serializer(
tearOffConstantSerializer, ListSerializer(dartTypeSerializer)));
-TextSerializer<SetConstant> setConstantSerializer = Wrapped(
- (w) => Tuple2(w.typeArgument, w.entries),
- (u) => SetConstant(u.first, u.second),
- Tuple2Serializer(dartTypeSerializer, ListSerializer(constantSerializer)));
+TextSerializer<SetConstant> setConstantSerializer =
+ Wrapped<Tuple2<DartType, List<Constant>>, SetConstant>(
+ (w) => Tuple2(w.typeArgument, w.entries),
+ (u) => SetConstant(u.first, u.second),
+ Tuple2Serializer(
+ dartTypeSerializer, ListSerializer(constantSerializer)));
TextSerializer<StringConstant> stringConstantSerializer =
- Wrapped((w) => w.value, (u) => StringConstant(u), DartString());
+ Wrapped<String, StringConstant>(
+ (w) => w.value, (u) => StringConstant(u), DartString());
-TextSerializer<SymbolConstant> symbolConstantSerializer = Wrapped(
- (w) => Tuple2(w.name, w.libraryReference?.canonicalName),
- (u) => SymbolConstant(u.first, u.second?.getReference()),
- Tuple2Serializer(DartString(), Optional(CanonicalNameSerializer())));
+TextSerializer<SymbolConstant> symbolConstantSerializer =
+ Wrapped<Tuple2<String, CanonicalName>, SymbolConstant>(
+ (w) => Tuple2(w.name, w.libraryReference?.canonicalName),
+ (u) => SymbolConstant(u.first, u.second?.getReference()),
+ Tuple2Serializer(DartString(), Optional(CanonicalNameSerializer())));
-TextSerializer<TearOffConstant> tearOffConstantSerializer = Wrapped(
- (w) => w.procedureReference.canonicalName,
- (u) => TearOffConstant.byReference(u.getReference()),
- CanonicalNameSerializer());
+TextSerializer<TearOffConstant> tearOffConstantSerializer =
+ Wrapped<CanonicalName, TearOffConstant>(
+ (w) => w.procedureReference.canonicalName,
+ (u) => TearOffConstant.byReference(u.getReference()),
+ CanonicalNameSerializer());
TextSerializer<TypeLiteralConstant> typeLiteralConstantSerializer =
- Wrapped((w) => w.type, (u) => TypeLiteralConstant(u), dartTypeSerializer);
+ Wrapped<DartType, TypeLiteralConstant>(
+ (w) => w.type, (u) => TypeLiteralConstant(u), dartTypeSerializer);
-TextSerializer<UnevaluatedConstant> unevaluatedConstantSerializer = Wrapped(
- (w) => w.expression, (u) => UnevaluatedConstant(u), expressionSerializer);
+TextSerializer<UnevaluatedConstant> unevaluatedConstantSerializer =
+ Wrapped<Expression, UnevaluatedConstant>((w) => w.expression,
+ (u) => UnevaluatedConstant(u), expressionSerializer);
TextSerializer<InstanceConstant> instanceConstantSerializer =
Wrapped<
@@ -1826,42 +1907,46 @@
}
}
-TextSerializer<AssertInitializer> assertInitializerSerializer = Wrapped(
- (w) => w.statement, (u) => AssertInitializer(u), statementSerializer);
+TextSerializer<AssertInitializer> assertInitializerSerializer =
+ Wrapped<Statement, AssertInitializer>(
+ (w) => w.statement, (u) => AssertInitializer(u), statementSerializer);
-TextSerializer<FieldInitializer> fieldInitializerSerializer = Wrapped(
- (w) => Tuple2(w.fieldReference.canonicalName, w.value),
- (u) => FieldInitializer.byReference(u.first.getReference(), u.second),
- Tuple2Serializer(CanonicalNameSerializer(), expressionSerializer));
+TextSerializer<FieldInitializer> fieldInitializerSerializer =
+ Wrapped<Tuple2<CanonicalName, Expression>, FieldInitializer>(
+ (w) => Tuple2(w.fieldReference.canonicalName, w.value),
+ (u) => FieldInitializer.byReference(u.first.getReference(), u.second),
+ Tuple2Serializer(CanonicalNameSerializer(), expressionSerializer));
TextSerializer<InvalidInitializer> invalidInitializerSerializer =
- Wrapped((_) => null, (_) => InvalidInitializer(), Nothing());
+ Wrapped<void, InvalidInitializer>(
+ (_) => null, (_) => InvalidInitializer(), Nothing());
-TextSerializer<LocalInitializer> localInitializerSerializer = Wrapped(
- (w) => w.variable,
- (u) => LocalInitializer(u),
- variableDeclarationSerializer);
+TextSerializer<LocalInitializer> localInitializerSerializer =
+ Wrapped<VariableDeclaration, LocalInitializer>((w) => w.variable,
+ (u) => LocalInitializer(u), variableDeclarationSerializer);
TextSerializer<RedirectingInitializer> redirectingInitializerSerializer =
- Wrapped(
+ Wrapped<Tuple2<CanonicalName, Arguments>, RedirectingInitializer>(
(w) => Tuple2(w.targetReference.canonicalName, w.arguments),
(u) => RedirectingInitializer.byReference(
u.first.getReference(), u.second),
Tuple2Serializer(CanonicalNameSerializer(), argumentsSerializer));
-TextSerializer<SuperInitializer> superInitializerSerializer = Wrapped(
- (w) => Tuple2(w.targetReference.canonicalName, w.arguments),
- (u) => SuperInitializer.byReference(u.first.getReference(), u.second),
- Tuple2Serializer(CanonicalNameSerializer(), argumentsSerializer));
+TextSerializer<SuperInitializer> superInitializerSerializer =
+ Wrapped<Tuple2<CanonicalName, Arguments>, SuperInitializer>(
+ (w) => Tuple2(w.targetReference.canonicalName, w.arguments),
+ (u) => SuperInitializer.byReference(u.first.getReference(), u.second),
+ Tuple2Serializer(CanonicalNameSerializer(), argumentsSerializer));
Case<Initializer> initializerSerializer =
Case.uninitialized(InitializerTagger());
-TextSerializer<Supertype> supertypeSerializer = Wrapped(
- (w) => Tuple2(w.className.canonicalName, w.typeArguments),
- (u) => Supertype.byReference(u.first.getReference(), u.second),
- Tuple2Serializer(
- CanonicalNameSerializer(), ListSerializer(dartTypeSerializer)));
+TextSerializer<Supertype> supertypeSerializer =
+ Wrapped<Tuple2<CanonicalName, List<DartType>>, Supertype>(
+ (w) => Tuple2(w.className.canonicalName, w.typeArguments),
+ (u) => Supertype.byReference(u.first.getReference(), u.second),
+ Tuple2Serializer(
+ CanonicalNameSerializer(), ListSerializer(dartTypeSerializer)));
const Map<int, String> classFlagToName = const {
Class.FlagAbstract: "abstract",
@@ -1881,16 +1966,20 @@
}
}
-TextSerializer<int> classFlagsSerializer = Wrapped(
+TextSerializer<int> classFlagsSerializer = Wrapped<List<int>, int>(
(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())))));
+ ListSerializer(Case(ClassFlagTagger(), convertFlagsMap(classFlagToName))));
-TextSerializer<Class> classSerializer = Wrapped(
+TextSerializer<Class> classSerializer = Wrapped<
+ Tuple3<
+ String,
+ int,
+ Tuple2<
+ List<TypeParameter>,
+ /* Comment added to guide formatting. */
+ Tuple4<Supertype, Supertype, List<Supertype>, List<Member>>>>,
+ Class>(
(w) => Tuple3(
w.name,
w.flags,
@@ -1928,11 +2017,13 @@
ListSerializer(supertypeSerializer),
ListSerializer(memberSerializer)))));
-TextSerializer<Typedef> typedefSerializer = Wrapped(
- (w) => Tuple2(w.name, Tuple2(w.typeParameters, w.type)),
- (u) => Typedef(u.first, u.second.second, typeParameters: u.second.first),
- Tuple2Serializer(
- DartString(), Bind(typeParametersSerializer, dartTypeSerializer)));
+TextSerializer<Typedef> typedefSerializer =
+ Wrapped<Tuple2<String, Tuple2<List<TypeParameter>, DartType>>, Typedef>(
+ (w) => Tuple2(w.name, Tuple2(w.typeParameters, w.type)),
+ (u) =>
+ Typedef(u.first, u.second.second, typeParameters: u.second.first),
+ Tuple2Serializer(
+ DartString(), Bind(typeParametersSerializer, dartTypeSerializer)));
const Map<int, String> extensionMemberDescriptorFlagToName = const {
ExtensionMemberDescriptor.FlagStatic: "static",
@@ -1948,14 +2039,14 @@
}
}
-TextSerializer<int> extensionMemberDescriptorFlagsSerializer = Wrapped(
- (w) => List.generate(30, (i) => w & (1 << i)).where((f) => f != 0).toList(),
- (u) => u.fold(0, (fs, f) => fs |= f),
- ListSerializer(Case(
- ExtensionMemberDescriptorFlagTagger(),
- Map.fromIterable(extensionMemberDescriptorFlagToName.entries,
- key: (e) => e.value,
- value: (e) => Wrapped((_) => null, (_) => e.key, Nothing())))));
+TextSerializer<int> extensionMemberDescriptorFlagsSerializer =
+ Wrapped<List<int>, int>(
+ (w) => List.generate(30, (i) => w & (1 << i))
+ .where((f) => f != 0)
+ .toList(),
+ (u) => u.fold(0, (fs, f) => fs |= f),
+ ListSerializer(Case(ExtensionMemberDescriptorFlagTagger(),
+ convertFlagsMap(extensionMemberDescriptorFlagToName))));
const Map<ExtensionMemberKind, String> extensionMemberKindToName = const {
ExtensionMemberKind.Field: "field",
@@ -1976,13 +2067,11 @@
}
TextSerializer<ExtensionMemberKind> extensionMemberKindSerializer = Case(
- ExtensionMemberKindTagger(),
- Map.fromIterable(extensionMemberKindToName.entries,
- key: (e) => e.value,
- value: (e) => Wrapped((_) => null, (_) => e.key, Nothing())));
+ ExtensionMemberKindTagger(), convertFlagsMap(extensionMemberKindToName));
TextSerializer<ExtensionMemberDescriptor> extensionMemberDescriptorSerializer =
- Wrapped(
+ Wrapped<Tuple4<Name, ExtensionMemberKind, int, CanonicalName>,
+ ExtensionMemberDescriptor>(
(w) => Tuple4(w.name, w.kind, w.flags, w.member.canonicalName),
(u) => ExtensionMemberDescriptor()
..name = u.first
@@ -1995,7 +2084,10 @@
extensionMemberDescriptorFlagsSerializer,
CanonicalNameSerializer()));
-TextSerializer<Extension> extensionSerializer = Wrapped(
+TextSerializer<Extension> extensionSerializer = Wrapped<
+ Tuple3<String, Tuple2<List<TypeParameter>, DartType>,
+ List<ExtensionMemberDescriptor>>,
+ Extension>(
(w) => Tuple3(w.name, Tuple2(w.typeParameters, w.onType), w.members),
(u) => Extension(
name: u.first,
@@ -2135,3 +2227,15 @@
"super": superInitializerSerializer,
});
}
+
+Map<String, Wrapped<void, T>> convertFlagsMap<T>(Map<T, String> map) {
+ return map.entries.toMap(
+ key: (e) => e.value,
+ value: (e) => Wrapped((_) => null, (_) => e.key, Nothing()));
+}
+
+extension MapFromIterable<E> on Iterable<E> {
+ Map<K, V> toMap<K, V>({K Function(E) key, V Function(E) value}) {
+ return {for (E e in this) key(e): value(e)};
+ }
+}
diff --git a/pkg/kernel/pubspec.yaml b/pkg/kernel/pubspec.yaml
index 1732869..dc4c5f73 100644
--- a/pkg/kernel/pubspec.yaml
+++ b/pkg/kernel/pubspec.yaml
@@ -6,7 +6,7 @@
publish_to: none
environment:
- sdk: '>=2.2.2 <3.0.0'
+ sdk: '>=2.6.0 <3.0.0'
dependencies:
meta: ^1.0.0
dev_dependencies:
diff --git a/pkg/kernel/test/binary/can_read_platform_test.dart b/pkg/kernel/test/binary/can_read_platform_test.dart
new file mode 100644
index 0000000..4984a0b
--- /dev/null
+++ b/pkg/kernel/test/binary/can_read_platform_test.dart
@@ -0,0 +1,104 @@
+// 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:io';
+
+import 'package:kernel/binary/ast_from_binary.dart';
+import 'package:kernel/kernel.dart';
+
+main() {
+ File exe = new File(Platform.resolvedExecutable).absolute;
+ int steps = 0;
+ Directory parent = exe.parent.parent;
+ while (true) {
+ Set<String> foundDirs = {};
+ for (FileSystemEntity entry in parent.listSync(recursive: false)) {
+ if (entry is Directory) {
+ List<String> pathSegments = entry.uri.pathSegments;
+ String name = pathSegments[pathSegments.length - 2];
+ foundDirs.add(name);
+ }
+ }
+ if (foundDirs.contains("pkg") &&
+ foundDirs.contains("tools") &&
+ foundDirs.contains("tests")) {
+ break;
+ }
+ steps++;
+ if (parent.uri == parent.parent.uri) {
+ throw "Reached end without finding the root.";
+ }
+ parent = parent.parent;
+ }
+ // We had to go $steps steps to reach the "root" --- now we should go 2 steps
+ // shorter to be in the "compiled dir".
+ parent = exe.parent;
+ for (int i = steps - 2; i >= 0; i--) {
+ parent = parent.parent;
+ }
+
+ List<File> dills = [];
+ for (FileSystemEntity entry in parent.listSync(recursive: false)) {
+ if (entry is File) {
+ if (entry.path.toLowerCase().endsWith(".dill")) {
+ dills.add(entry);
+ }
+ }
+ }
+ Directory sdk = new Directory.fromUri(parent.uri.resolve("dart-sdk/"));
+ for (FileSystemEntity entry in sdk.listSync(recursive: true)) {
+ if (entry is File) {
+ if (entry.path.toLowerCase().endsWith(".dill")) {
+ dills.add(entry);
+ }
+ }
+ }
+
+ print("Found ${dills.length} dills!");
+
+ List<File> errors = [];
+ for (File dill in dills) {
+ if (!canRead(dill)) {
+ errors.add(dill);
+ }
+ }
+ if (errors.isEmpty) {
+ print("Read all OK.");
+ } else {
+ print("Errors when reading:");
+ for (File error in errors) {
+ print(error);
+ }
+ exitCode = 1;
+ }
+}
+
+bool canRead(File dill) {
+ print("Reading $dill");
+ List<int> bytes = dill.readAsBytesSync();
+
+ try {
+ Component component = new Component();
+ new BinaryBuilderWithMetadata(bytes).readComponent(component);
+ int libs = component.libraries.length;
+
+ component = new Component();
+ new BinaryBuilder(bytes).readComponent(component);
+ if (libs != component.libraries.length) {
+ throw "Didn't get the same number of libraries: $libs when reading with "
+ "BinaryBuilderWithMetadata and ${component.libraries.length} "
+ "when reading with BinaryBuilder";
+ }
+
+ return true;
+ } catch (e, st) {
+ print("Error for $dill:");
+ print(e);
+ print(st);
+ print("");
+ print("--------------------");
+ print("");
+ return false;
+ }
+}
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index cb51ea4..3a41006 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -713,9 +713,10 @@
bool EnqueueEntrypointInvocationAndNotifySpawner(Thread* thread) {
auto isolate = thread->isolate();
+ auto zone = thread->zone();
// Step 1) Resolve the entrypoint function.
- auto& result = Object::Handle(thread->zone(), state_->ResolveFunction());
+ auto& result = Object::Handle(zone, state_->ResolveFunction());
const bool is_spawn_uri = state_->is_spawn_uri();
if (result.IsError()) {
ASSERT(is_spawn_uri);
@@ -723,23 +724,22 @@
return false;
}
ASSERT(result.IsFunction());
- auto& func = Function::Handle(thread->zone(), Function::Cast(result).raw());
+ auto& func = Function::Handle(zone, Function::Cast(result).raw());
func = func.ImplicitClosureFunction();
const auto& entrypoint_closure =
- Object::Handle(func.ImplicitStaticClosure());
+ Object::Handle(zone, func.ImplicitStaticClosure());
// Step 2) Enqueue delayed invocation of entrypoint callback.
- const Array& args = Array::Handle(Array::New(4));
+ const Array& args = Array::Handle(zone, Array::New(4));
args.SetAt(0, entrypoint_closure);
- args.SetAt(1, Instance::Handle(state_->BuildArgs(thread)));
- args.SetAt(2, Instance::Handle(state_->BuildMessage(thread)));
+ args.SetAt(1, Instance::Handle(zone, state_->BuildArgs(thread)));
+ args.SetAt(2, Instance::Handle(zone, state_->BuildMessage(thread)));
args.SetAt(3, is_spawn_uri ? Bool::True() : Bool::False());
- const auto& lib = Library::Handle(Library::IsolateLibrary());
- const auto& entry_name =
- String::Handle(String::New("_delayEntrypointInvocation"));
+ const auto& lib = Library::Handle(zone, Library::IsolateLibrary());
+ const auto& entry_name = String::Handle(zone, String::New("_startIsolate"));
const auto& entry_point =
- Function::Handle(lib.LookupLocalFunction(entry_name));
+ Function::Handle(zone, lib.LookupLocalFunction(entry_name));
ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
result = DartEntry::InvokeFunction(entry_point, args);
if (result.IsError()) {
@@ -749,15 +749,15 @@
// Step 3) Pause the isolate if required & Notify parent isolate about
// isolate creation.
- const auto& capabilities = Array::Handle(thread->zone(), Array::New(2));
- auto& capability = Capability::Handle(thread->zone());
+ const auto& capabilities = Array::Handle(zone, Array::New(2));
+ auto& capability = Capability::Handle(zone);
capability = Capability::New(isolate->pause_capability());
capabilities.SetAt(0, capability);
capability = Capability::New(isolate->terminate_capability());
capabilities.SetAt(1, capability);
const auto& send_port =
- SendPort::Handle(SendPort::New(isolate->main_port()));
- const auto& message = Array::Handle(thread->zone(), Array::New(2));
+ SendPort::Handle(zone, SendPort::New(isolate->main_port()));
+ const auto& message = Array::Handle(zone, Array::New(2));
message.SetAt(0, send_port);
message.SetAt(1, capabilities);
if (state_->paused()) {
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index 73afe4c..e3e32f3 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -14,7 +14,6 @@
dart/data_uri_import_test/none: SkipByDesign
dart/emit_aot_size_info_flag_test: Pass, Slow # Spawns several subprocesses
dart/isolates/*: Pass, Slow # Tests use many isolates and take a longer time.
-dart/isolates/dart_api_create_lightweight_isolate_test: Skip # Issue #44180
dart/minimal_kernel_test: Pass, Slow # Spawns several subprocesses
dart/null_safety_autodetection_in_kernel_compiler_test: Pass, Slow # Spawns several subprocesses
dart/slow_path_shared_stub_test: Pass, Slow # Uses --shared-slow-path-triggers-gc flag.
@@ -24,7 +23,6 @@
dart_2/data_uri_import_test/none: SkipByDesign
dart_2/emit_aot_size_info_flag_test: Pass, Slow # Spawns several subprocesses
dart_2/isolates/*: Pass, Slow # Tests use many isolates and take a longer time.
-dart_2/isolates/dart_api_create_lightweight_isolate_test: Skip # Issue #44180
dart_2/minimal_kernel_test: Pass, Slow # Spawns several subprocesses
dart_2/null_safety_autodetection_in_kernel_compiler_test: Pass, Slow # Spawns several subprocesses
dart_2/slow_path_shared_stub_test: Pass, Slow # Uses --shared-slow-path-triggers-gc flag.
@@ -142,7 +140,9 @@
dart/*: SkipByDesign # Migrated tests are not supposed to run on non-NNBD bots.
[ $system == android ]
+dart/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # On android this test does not work due to not being able to identify library uri.
dart/sdk_hash_test: SkipByDesign # The test doesn't know location of cross-platform gen_snapshot
+dart_2/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # On android this test does not work due to not being able to identify library uri.
dart_2/sdk_hash_test: SkipByDesign # The test doesn't know location of cross-platform gen_snapshot
[ $system == fuchsia ]
@@ -160,7 +160,9 @@
[ $system == windows ]
cc/CorelibCompilerStats: Skip
dart/disassemble_determinism_test: Slow, Pass # Times out on slower bots.
+dart/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # https://dartbug.com/40579: Dart C API symbols not available.
dart_2/disassemble_determinism_test: Slow, Pass # Times out on slower bots.
+dart_2/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # https://dartbug.com/40579: Dart C API symbols not available.
[ $arch == ia32 && $mode == debug && $system == windows ]
dart/transferable_test: Skip # This is performance test and somehow debug win ia32 bot's performance is unpredictable
@@ -183,11 +185,13 @@
[ $builder_tag == obfuscated && $compiler == dartkp ]
dart/extension_names_test: SkipByDesign # No demangling (obfuscated).
dart/extension_unnamed_names_test: SkipByDesign # No demangling (obfuscated).
+dart/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # https://dartbug.com/44215: This test relies on non-obfuscated library uris.
dart/optimized_stacktrace_line_and_column_test: SkipByDesign # Looks for filenames in stacktrace output
dart/optimized_stacktrace_line_test: SkipByDesign # Looks for filenames in stacktrace output
dart/regress_37382_test: SkipByDesign # Matches the type arguments names
dart_2/extension_names_test: SkipByDesign # No demangling (obfuscated).
dart_2/extension_unnamed_names_test: SkipByDesign # No demangling (obfuscated).
+dart_2/isolates/dart_api_create_lightweight_isolate_test: SkipByDesign # https://dartbug.com/44215: This test relies on non-obfuscated library uris.
dart_2/optimized_stacktrace_line_and_column_test: SkipByDesign # Looks for filenames in stacktrace output
dart_2/optimized_stacktrace_line_test: SkipByDesign # Looks for filenames in stacktrace output
dart_2/regress_37382_test: SkipByDesign # Matches the type arguments names
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 535b34c..9f3015f 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -2846,7 +2846,7 @@
}
const auto& intermediate =
*new (zone_) compiler::ffi::NativeRegistersLocation(
- dst_payload_type, dst_container_type, scratch);
+ zone_, dst_payload_type, dst_container_type, scratch);
EmitNativeMove(intermediate, source, temp);
EmitNativeMove(destination, intermediate, temp);
if (TMP == kNoRegister) {
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.cc b/runtime/vm/compiler/ffi/native_calling_convention.cc
index 2ac1445..fe3881c 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.cc
+++ b/runtime/vm/compiler/ffi/native_calling_convention.cc
@@ -4,11 +4,10 @@
#include "vm/compiler/ffi/native_calling_convention.h"
-#include "vm/compiler/ffi/marshaller.h"
#include "vm/compiler/ffi/native_location.h"
#include "vm/compiler/ffi/native_type.h"
-#include "vm/log.h"
-#include "vm/symbols.h"
+#include "vm/cpu.h"
+#include "vm/zone_text_buffer.h"
namespace dart {
@@ -82,13 +81,13 @@
const Register register_1 = AllocateCpuRegister();
const Register register_2 = AllocateCpuRegister();
return *new (zone_) NativeRegistersLocation(
- payload_type, container_type, register_1, register_2);
+ zone_, payload_type, container_type, register_1, register_2);
}
} else {
ASSERT(payload_type.SizeInBytes() <= target::kWordSize);
if (cpu_regs_used + 1 <= CallingConventions::kNumArgRegs) {
return *new (zone_) NativeRegistersLocation(
- payload_type, container_type, AllocateCpuRegister());
+ zone_, payload_type, container_type, AllocateCpuRegister());
} else {
// Transfer on stack.
}
@@ -232,12 +231,12 @@
ASSERT(container_type.IsInt() || container_type.IsVoid());
if (container_type.SizeInBytes() == 8 && target::kWordSize == 4) {
return *new (zone) NativeRegistersLocation(
- payload_type, container_type, CallingConventions::kReturnReg,
+ zone, payload_type, container_type, CallingConventions::kReturnReg,
CallingConventions::kSecondReturnReg);
}
ASSERT(container_type.SizeInBytes() <= target::kWordSize);
- return *new (zone) NativeRegistersLocation(payload_type, container_type,
+ return *new (zone) NativeRegistersLocation(zone, payload_type, container_type,
CallingConventions::kReturnReg);
}
@@ -261,23 +260,41 @@
return Utils::RoundUp(max_height_in_bytes, compiler::target::kWordSize);
}
-const char* NativeCallingConvention::ToCString() const {
- char buffer[1024];
- BufferFormatter bf(buffer, 1024);
- PrintTo(&bf);
- return Thread::Current()->zone()->MakeCopyOfString(buffer);
-}
-
-void NativeCallingConvention::PrintTo(BaseTextBuffer* f) const {
- f->AddString("(");
+void NativeCallingConvention::PrintTo(BaseTextBuffer* f,
+ bool multi_line) const {
+ if (!multi_line) {
+ f->AddString("(");
+ }
for (intptr_t i = 0; i < argument_locations_.length(); i++) {
if (i > 0) {
- f->AddString(", ");
+ if (multi_line) {
+ f->AddString("\n");
+ } else {
+ f->AddString(", ");
+ }
}
argument_locations_[i]->PrintTo(f);
}
- f->AddString(") => ");
+ if (multi_line) {
+ f->AddString("\n=>\n");
+ } else {
+ f->AddString(") => ");
+ }
return_location_.PrintTo(f);
+ if (multi_line) {
+ f->AddString("\n");
+ }
+}
+
+const char* NativeCallingConvention::ToCString(Zone* zone,
+ bool multi_line) const {
+ ZoneTextBuffer textBuffer(zone);
+ PrintTo(&textBuffer, multi_line);
+ return textBuffer.buffer();
+}
+
+const char* NativeCallingConvention::ToCString(bool multi_line) const {
+ return ToCString(Thread::Current()->zone(), multi_line);
}
} // namespace ffi
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.h b/runtime/vm/compiler/ffi/native_calling_convention.h
index 4948910..bb10887 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.h
+++ b/runtime/vm/compiler/ffi/native_calling_convention.h
@@ -9,9 +9,7 @@
#error "AOT runtime should not use compiler sources (including header files)"
#endif // defined(DART_PRECOMPILED_RUNTIME)
-#include <platform/globals.h>
-
-#include "vm/compiler/backend/locations.h"
+#include "platform/globals.h"
#include "vm/compiler/ffi/native_location.h"
#include "vm/compiler/ffi/native_type.h"
@@ -41,8 +39,10 @@
intptr_t StackTopInBytes() const;
- void PrintTo(BaseTextBuffer* f) const;
- const char* ToCString() const;
+ void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
+ void PrintToMultiLine(BaseTextBuffer* f) const;
+ const char* ToCString(Zone* zone, bool multi_line = false) const;
+ const char* ToCString(bool multi_line = false) const;
private:
NativeCallingConvention(const NativeLocations& argument_locations,
diff --git a/runtime/vm/compiler/ffi/native_location.cc b/runtime/vm/compiler/ffi/native_location.cc
index f954e9f..dce51c1 100644
--- a/runtime/vm/compiler/ffi/native_location.cc
+++ b/runtime/vm/compiler/ffi/native_location.cc
@@ -4,7 +4,7 @@
#include "vm/compiler/ffi/native_location.h"
-#include "vm/compiler/backend/il_printer.h"
+#include "vm/zone_text_buffer.h"
namespace dart {
@@ -41,7 +41,7 @@
switch (loc.kind()) {
case Location::Kind::kRegister:
return *new (zone)
- NativeRegistersLocation(native_rep, native_rep, loc.reg());
+ NativeRegistersLocation(zone, native_rep, native_rep, loc.reg());
case Location::Kind::kFpuRegister:
return *new (zone)
NativeFpuRegistersLocation(native_rep, native_rep, loc.fpu_reg());
@@ -126,12 +126,13 @@
}
UNREACHABLE();
}
+
NativeRegistersLocation& NativeRegistersLocation::Split(Zone* zone,
intptr_t index) const {
ASSERT(num_regs() == 2);
return *new (zone) NativeRegistersLocation(
- payload_type().Split(zone, index), container_type().Split(zone, index),
- reg_at(index));
+ zone, payload_type().Split(zone, index),
+ container_type().Split(zone, index), reg_at(index));
}
NativeStackLocation& NativeStackLocation::Split(Zone* zone,
@@ -264,11 +265,14 @@
PrintRepresentations(f, *this);
}
+const char* NativeLocation::ToCString(Zone* zone) const {
+ ZoneTextBuffer textBuffer(zone);
+ PrintTo(&textBuffer);
+ return textBuffer.buffer();
+}
+
const char* NativeLocation::ToCString() const {
- char buffer[1024];
- BufferFormatter bf(buffer, 1024);
- PrintTo(&bf);
- return Thread::Current()->zone()->MakeCopyOfString(buffer);
+ return ToCString(Thread::Current()->zone());
}
intptr_t SizeFromFpuRegisterKind(enum FpuRegisterKind kind) {
diff --git a/runtime/vm/compiler/ffi/native_location.h b/runtime/vm/compiler/ffi/native_location.h
index 6c7e980..c3cce14 100644
--- a/runtime/vm/compiler/ffi/native_location.h
+++ b/runtime/vm/compiler/ffi/native_location.h
@@ -12,8 +12,8 @@
#include "platform/assert.h"
#include "vm/compiler/backend/locations.h"
#include "vm/compiler/ffi/native_type.h"
+#include "vm/constants.h"
#include "vm/growable_array.h"
-#include "vm/thread.h"
namespace dart {
@@ -97,6 +97,7 @@
}
virtual void PrintTo(BaseTextBuffer* f) const;
+ const char* ToCString(Zone* zone) const;
const char* ToCString() const;
const NativeRegistersLocation& AsRegisters() const;
@@ -138,19 +139,21 @@
const NativeType& container_type,
ZoneGrowableArray<Register>* registers)
: NativeLocation(payload_type, container_type), regs_(registers) {}
- NativeRegistersLocation(const NativeType& payload_type,
+ NativeRegistersLocation(Zone* zone,
+ const NativeType& payload_type,
const NativeType& container_type,
Register reg)
: NativeLocation(payload_type, container_type) {
- regs_ = new ZoneGrowableArray<Register>();
+ regs_ = new (zone) ZoneGrowableArray<Register>(zone, 1);
regs_->Add(reg);
}
- NativeRegistersLocation(const NativeType& payload_type,
+ NativeRegistersLocation(Zone* zone,
+ const NativeType& payload_type,
const NativeType& container_type,
Register register1,
Register register2)
: NativeLocation(payload_type, container_type) {
- regs_ = new ZoneGrowableArray<Register>();
+ regs_ = new (zone) ZoneGrowableArray<Register>(zone, 2);
regs_->Add(register1);
regs_->Add(register2);
}
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index c5cd230..7c1faae 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -7,11 +7,8 @@
#include "platform/assert.h"
#include "platform/globals.h"
#include "vm/class_id.h"
-#include "vm/compiler/runtime_api.h"
-#include "vm/growable_array.h"
-#include "vm/log.h"
-#include "vm/object.h"
-#include "vm/symbols.h"
+#include "vm/constants.h"
+#include "vm/zone_text_buffer.h"
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "vm/compiler/backend/locations.h"
@@ -282,11 +279,14 @@
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
+const char* NativeType::ToCString(Zone* zone) const {
+ ZoneTextBuffer textBuffer(zone);
+ PrintTo(&textBuffer);
+ return textBuffer.buffer();
+}
+
const char* NativeType::ToCString() const {
- char buffer[1024];
- BufferFormatter bf(buffer, 1024);
- PrintTo(&bf);
- return Thread::Current()->zone()->MakeCopyOfString(buffer);
+ return ToCString(Thread::Current()->zone());
}
static const char* PrimitiveTypeToCString(PrimitiveType rep) {
@@ -328,11 +328,14 @@
f->Printf("%s", PrimitiveTypeToCString(representation_));
}
+const char* NativeFunctionType::ToCString(Zone* zone) const {
+ ZoneTextBuffer textBuffer(zone);
+ PrintTo(&textBuffer);
+ return textBuffer.buffer();
+}
+
const char* NativeFunctionType::ToCString() const {
- char buffer[1024];
- BufferFormatter bf(buffer, 1024);
- PrintTo(&bf);
- return Thread::Current()->zone()->MakeCopyOfString(buffer);
+ return ToCString(Thread::Current()->zone());
}
void NativeFunctionType::PrintTo(BaseTextBuffer* f) const {
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index 693b7c0..d2ca9c1 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -5,12 +5,11 @@
#ifndef RUNTIME_VM_COMPILER_FFI_NATIVE_TYPE_H_
#define RUNTIME_VM_COMPILER_FFI_NATIVE_TYPE_H_
-#include <platform/globals.h>
-
#include "platform/assert.h"
+#include "platform/globals.h"
#include "vm/allocation.h"
-#include "vm/compiler/runtime_api.h"
#include "vm/growable_array.h"
+#include "vm/object.h"
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "vm/compiler/backend/locations.h"
@@ -58,7 +57,7 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
static NativePrimitiveType& FromUnboxedRepresentation(Zone* zone,
Representation rep);
-#endif
+#endif // !defined(DART_PRECOMPILED_RUNTIME)
virtual bool IsPrimitive() const { return false; }
const NativePrimitiveType& AsPrimitive() const;
@@ -104,6 +103,7 @@
const NativeType& WidenTo4Bytes(Zone* zone) const;
virtual void PrintTo(BaseTextBuffer* f) const;
+ const char* ToCString(Zone* zone) const;
const char* ToCString() const;
virtual ~NativeType() {}
@@ -180,6 +180,8 @@
const NativeType& return_type() const { return return_type_; }
void PrintTo(BaseTextBuffer* f) const;
+ const char* ToCString(Zone* zone) const;
+
const char* ToCString() const;
private:
diff --git a/tools/VERSION b/tools/VERSION
index 7f57bc0..9c3e9575 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 12
PATCH 0
-PRERELEASE 47
+PRERELEASE 48
PRERELEASE_PATCH 0
\ No newline at end of file
