blob: 417985a2a2b5fd2f979ef769f2ed4cd48ef3c1b6 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'ast.dart';
import 'functional.dart';
import 'generator.dart';
import 'generator_tools.dart';
import 'pigeon_lib.dart' show Error;
/// General comment opening token.
const String _commentPrefix = '//';
const String _voidType = 'void';
/// Documentation comment spec.
const DocumentCommentSpecification _docCommentSpec =
DocumentCommentSpecification(_commentPrefix);
/// The default serializer for Flutter.
const String _defaultCodecSerializer = 'flutter::StandardCodecSerializer';
/// Options that control how C++ code will be generated.
class CppOptions {
/// Creates a [CppOptions] object
const CppOptions({
this.headerIncludePath,
this.namespace,
this.copyrightHeader,
this.headerOutPath,
});
/// The path to the header that will get placed in the source filed (example:
/// "foo.h").
final String? headerIncludePath;
/// The namespace where the generated class will live.
final String? namespace;
/// A copyright header that will get prepended to generated code.
final Iterable<String>? copyrightHeader;
/// The path to the output header file location.
final String? headerOutPath;
/// Creates a [CppOptions] from a Map representation where:
/// `x = CppOptions.fromMap(x.toMap())`.
static CppOptions fromMap(Map<String, Object> map) {
return CppOptions(
headerIncludePath: map['header'] as String?,
namespace: map['namespace'] as String?,
copyrightHeader: map['copyrightHeader'] as Iterable<String>?,
headerOutPath: map['cppHeaderOut'] as String?,
);
}
/// Converts a [CppOptions] to a Map representation where:
/// `x = CppOptions.fromMap(x.toMap())`.
Map<String, Object> toMap() {
final Map<String, Object> result = <String, Object>{
if (headerIncludePath != null) 'header': headerIncludePath!,
if (namespace != null) 'namespace': namespace!,
if (copyrightHeader != null) 'copyrightHeader': copyrightHeader!,
};
return result;
}
/// Overrides any non-null parameters from [options] into this to make a new
/// [CppOptions].
CppOptions merge(CppOptions options) {
return CppOptions.fromMap(mergeMaps(toMap(), options.toMap()));
}
}
/// Class that manages all Cpp code generation.
class CppGenerator extends Generator<OutputFileOptions<CppOptions>> {
/// Constructor.
const CppGenerator();
/// Generates C++ file of type specified in [generatorOptions]
@override
void generate(OutputFileOptions<CppOptions> generatorOptions, Root root,
StringSink sink) {
assert(generatorOptions.fileType == FileType.header ||
generatorOptions.fileType == FileType.source);
if (generatorOptions.fileType == FileType.header) {
const CppHeaderGenerator()
.generate(generatorOptions.languageOptions, root, sink);
} else if (generatorOptions.fileType == FileType.source) {
const CppSourceGenerator()
.generate(generatorOptions.languageOptions, root, sink);
}
}
}
/// Writes C++ header (.h) file to sink.
class CppHeaderGenerator extends StructuredGenerator<CppOptions> {
/// Constructor.
const CppHeaderGenerator();
@override
void writeFilePrologue(
CppOptions generatorOptions, Root root, Indent indent) {
if (generatorOptions.copyrightHeader != null) {
addLines(indent, generatorOptions.copyrightHeader!, linePrefix: '// ');
}
indent.writeln('$_commentPrefix ${getGeneratedCodeWarning()}');
indent.writeln('$_commentPrefix $seeAlsoWarning');
indent.newln();
}
@override
void writeFileImports(CppOptions generatorOptions, Root root, Indent indent) {
final String guardName = _getGuardName(generatorOptions.headerIncludePath);
indent.writeln('#ifndef $guardName');
indent.writeln('#define $guardName');
_writeSystemHeaderIncludeBlock(indent, <String>[
'flutter/basic_message_channel.h',
'flutter/binary_messenger.h',
'flutter/encodable_value.h',
'flutter/standard_message_codec.h',
]);
indent.newln();
_writeSystemHeaderIncludeBlock(indent, <String>[
'map',
'string',
'optional',
]);
indent.newln();
if (generatorOptions.namespace != null) {
indent.writeln('namespace ${generatorOptions.namespace} {');
}
indent.newln();
if (generatorOptions.namespace?.endsWith('_pigeontest') ?? false) {
final String testFixtureClass =
'${_pascalCaseFromSnakeCase(generatorOptions.namespace!.replaceAll('_pigeontest', ''))}Test';
indent.writeln('class $testFixtureClass;');
}
indent.newln();
indent.writeln('$_commentPrefix Generated class from Pigeon.');
}
@override
void writeEnum(
CppOptions generatorOptions, Root root, Indent indent, Enum anEnum) {
indent.newln();
addDocumentationComments(
indent, anEnum.documentationComments, _docCommentSpec);
indent.write('enum class ${anEnum.name} ');
indent.addScoped('{', '};', () {
enumerate(anEnum.members, (int index, final EnumMember member) {
addDocumentationComments(
indent, member.documentationComments, _docCommentSpec);
indent.writeln(
'${member.name} = $index${index == anEnum.members.length - 1 ? '' : ','}');
});
});
}
@override
void writeGeneralUtilities(
CppOptions generatorOptions, Root root, Indent indent) {
_writeErrorOr(indent, friends: root.apis.map((Api api) => api.name));
}
@override
void writeDataClass(
CppOptions generatorOptions, Root root, Indent indent, Class klass) {
// When generating for a Pigeon unit test, add a test fixture friend class to
// allow unit testing private methods, since testing serialization via public
// methods is essentially an end-to-end test.
String? testFixtureClass;
if (generatorOptions.namespace?.endsWith('_pigeontest') ?? false) {
testFixtureClass =
'${_pascalCaseFromSnakeCase(generatorOptions.namespace!.replaceAll('_pigeontest', ''))}Test';
}
indent.newln();
const List<String> generatedMessages = <String>[
' Generated class from Pigeon that represents data sent in messages.'
];
addDocumentationComments(
indent, klass.documentationComments, _docCommentSpec,
generatorComments: generatedMessages);
final Iterable<NamedType> orderedFields =
getFieldsInSerializationOrder(klass);
indent.write('class ${klass.name} ');
indent.addScoped('{', '};', () {
_writeAccessBlock(indent, _ClassAccess.public, () {
final Iterable<NamedType> requiredFields =
orderedFields.where((NamedType type) => !type.type.isNullable);
// Minimal constructor, if needed.
if (requiredFields.length != orderedFields.length) {
_writeClassConstructor(root, indent, klass, requiredFields,
'Constructs an object setting all non-nullable fields.');
}
// All-field constructor.
_writeClassConstructor(root, indent, klass, orderedFields,
'Constructs an object setting all fields.');
for (final NamedType field in orderedFields) {
addDocumentationComments(
indent, field.documentationComments, _docCommentSpec);
final HostDatatype baseDatatype = getFieldHostDatatype(
field, root.classes, root.enums, _baseCppTypeForBuiltinDartType);
// Declare a getter and setter.
_writeFunctionDeclaration(indent, _makeGetterName(field),
returnType: _getterReturnType(baseDatatype), isConst: true);
final String setterName = _makeSetterName(field);
_writeFunctionDeclaration(indent, setterName,
returnType: _voidType,
parameters: <String>[
'${_unownedArgumentType(baseDatatype)} value_arg'
]);
if (field.type.isNullable) {
// Add a second setter that takes the non-nullable version of the
// argument for convenience, since setting literal values with the
// pointer version is non-trivial.
final HostDatatype nonNullType = _nonNullableType(baseDatatype);
_writeFunctionDeclaration(indent, setterName,
returnType: _voidType,
parameters: <String>[
'${_unownedArgumentType(nonNullType)} value_arg'
]);
}
indent.newln();
}
});
_writeAccessBlock(indent, _ClassAccess.private, () {
_writeFunctionDeclaration(indent, 'FromEncodableList',
returnType: klass.name,
parameters: <String>['const flutter::EncodableList& list'],
isStatic: true);
_writeFunctionDeclaration(indent, 'ToEncodableList',
returnType: 'flutter::EncodableList', isConst: true);
for (final Class friend in root.classes) {
if (friend != klass &&
friend.fields.any(
(NamedType element) => element.type.baseName == klass.name)) {
indent.writeln('friend class ${friend.name};');
}
}
for (final Api api in root.apis) {
// TODO(gaaclarke): Find a way to be more precise with our
// friendships.
indent.writeln('friend class ${api.name};');
indent.writeln('friend class ${_getCodecSerializerName(api)};');
}
if (testFixtureClass != null) {
indent.writeln('friend class $testFixtureClass;');
}
for (final NamedType field in orderedFields) {
final HostDatatype hostDatatype = getFieldHostDatatype(
field, root.classes, root.enums, _baseCppTypeForBuiltinDartType);
indent.writeln(
'${_valueType(hostDatatype)} ${_makeInstanceVariableName(field)};');
}
});
}, nestCount: 0);
indent.newln();
}
@override
void writeFlutterApi(
CppOptions generatorOptions,
Root root,
Indent indent,
Api api,
) {
assert(api.location == ApiLocation.flutter);
if (getCodecClasses(api, root).isNotEmpty) {
_writeCodec(generatorOptions, root, indent, api);
}
const List<String> generatedMessages = <String>[
' Generated class from Pigeon that represents Flutter messages that can be called from C++.'
];
addDocumentationComments(indent, api.documentationComments, _docCommentSpec,
generatorComments: generatedMessages);
indent.write('class ${api.name} ');
indent.addScoped('{', '};', () {
_writeAccessBlock(indent, _ClassAccess.public, () {
_writeFunctionDeclaration(indent, api.name,
parameters: <String>['flutter::BinaryMessenger* binary_messenger']);
_writeFunctionDeclaration(indent, 'GetCodec',
returnType: 'const flutter::StandardMessageCodec&', isStatic: true);
for (final Method func in api.methods) {
final HostDatatype returnType = getHostDatatype(func.returnType,
root.classes, root.enums, _baseCppTypeForBuiltinDartType);
addDocumentationComments(
indent, func.documentationComments, _docCommentSpec);
final Iterable<String> argTypes = func.arguments.map((NamedType arg) {
final HostDatatype hostType = getFieldHostDatatype(
arg, root.classes, root.enums, _baseCppTypeForBuiltinDartType);
return _flutterApiArgumentType(hostType);
});
final Iterable<String> argNames =
indexMap(func.arguments, _getArgumentName);
final List<String> parameters = <String>[
...map2(argTypes, argNames, (String x, String y) => '$x $y'),
..._flutterApiCallbackParameters(returnType),
];
_writeFunctionDeclaration(indent, _makeMethodName(func),
returnType: _voidType, parameters: parameters);
}
});
indent.addScoped(' private:', null, () {
indent.writeln('flutter::BinaryMessenger* binary_messenger_;');
});
}, nestCount: 0);
indent.newln();
}
@override
void writeHostApi(
CppOptions generatorOptions,
Root root,
Indent indent,
Api api,
) {
assert(api.location == ApiLocation.host);
if (getCodecClasses(api, root).isNotEmpty) {
_writeCodec(generatorOptions, root, indent, api);
}
const List<String> generatedMessages = <String>[
' Generated interface from Pigeon that represents a handler of messages from Flutter.'
];
addDocumentationComments(indent, api.documentationComments, _docCommentSpec,
generatorComments: generatedMessages);
indent.write('class ${api.name} ');
indent.addScoped('{', '};', () {
_writeAccessBlock(indent, _ClassAccess.public, () {
// Prevent copying/assigning.
_writeFunctionDeclaration(indent, api.name,
parameters: <String>['const ${api.name}&'], deleted: true);
_writeFunctionDeclaration(indent, 'operator=',
returnType: '${api.name}&',
parameters: <String>['const ${api.name}&'],
deleted: true);
// No-op virtual destructor.
_writeFunctionDeclaration(indent, '~${api.name}',
isVirtual: true, inlineNoop: true);
for (final Method method in api.methods) {
final HostDatatype returnType = getHostDatatype(method.returnType,
root.classes, root.enums, _baseCppTypeForBuiltinDartType);
final String returnTypeName = _hostApiReturnType(returnType);
final List<String> parameters = <String>[];
if (method.arguments.isNotEmpty) {
final Iterable<String> argTypes =
method.arguments.map((NamedType arg) {
final HostDatatype hostType = getFieldHostDatatype(arg,
root.classes, root.enums, _baseCppTypeForBuiltinDartType);
return _hostApiArgumentType(hostType);
});
final Iterable<String> argNames =
method.arguments.map((NamedType e) => _makeVariableName(e));
parameters.addAll(
map2(argTypes, argNames, (String argType, String argName) {
return '$argType $argName';
}));
}
addDocumentationComments(
indent, method.documentationComments, _docCommentSpec);
final String methodReturn;
if (method.isAsynchronous) {
methodReturn = _voidType;
parameters.add('std::function<void($returnTypeName reply)> result');
} else {
methodReturn = returnTypeName;
}
_writeFunctionDeclaration(indent, _makeMethodName(method),
returnType: methodReturn,
parameters: parameters,
isVirtual: true,
isPureVirtual: true);
}
indent.newln();
indent.writeln('$_commentPrefix The codec used by ${api.name}.');
_writeFunctionDeclaration(indent, 'GetCodec',
returnType: 'const flutter::StandardMessageCodec&', isStatic: true);
indent.writeln(
'$_commentPrefix Sets up an instance of `${api.name}` to handle messages through the `binary_messenger`.');
_writeFunctionDeclaration(indent, 'SetUp',
returnType: _voidType,
isStatic: true,
parameters: <String>[
'flutter::BinaryMessenger* binary_messenger',
'${api.name}* api',
]);
_writeFunctionDeclaration(indent, 'WrapError',
returnType: 'flutter::EncodableValue',
isStatic: true,
parameters: <String>['std::string_view error_message']);
_writeFunctionDeclaration(indent, 'WrapError',
returnType: 'flutter::EncodableValue',
isStatic: true,
parameters: <String>['const FlutterError& error']);
});
_writeAccessBlock(indent, _ClassAccess.protected, () {
indent.writeln('${api.name}() = default;');
});
}, nestCount: 0);
}
void _writeClassConstructor(Root root, Indent indent, Class klass,
Iterable<NamedType> params, String docComment) {
final List<String> paramStrings = params.map((NamedType param) {
final HostDatatype hostDatatype = getFieldHostDatatype(
param, root.classes, root.enums, _baseCppTypeForBuiltinDartType);
return '${_hostApiArgumentType(hostDatatype)} ${_makeVariableName(param)}';
}).toList();
indent.writeln('$_commentPrefix $docComment');
_writeFunctionDeclaration(indent, klass.name,
isConstructor: true, parameters: paramStrings);
indent.newln();
}
void _writeCodec(
CppOptions generatorOptions, Root root, Indent indent, Api api) {
assert(getCodecClasses(api, root).isNotEmpty);
final String codeSerializerName = _getCodecSerializerName(api);
indent
.write('class $codeSerializerName : public $_defaultCodecSerializer ');
indent.addScoped('{', '};', () {
_writeAccessBlock(indent, _ClassAccess.public, () {
_writeFunctionDeclaration(indent, codeSerializerName,
isConstructor: true);
_writeFunctionDeclaration(indent, 'GetInstance',
returnType: '$codeSerializerName&', isStatic: true, inlineBody: () {
indent.writeln('static $codeSerializerName sInstance;');
indent.writeln('return sInstance;');
});
indent.newln();
_writeFunctionDeclaration(indent, 'WriteValue',
returnType: _voidType,
parameters: <String>[
'const flutter::EncodableValue& value',
'flutter::ByteStreamWriter* stream'
],
isConst: true,
isOverride: true);
});
indent.writeScoped(' protected:', '', () {
_writeFunctionDeclaration(indent, 'ReadValueOfType',
returnType: 'flutter::EncodableValue',
parameters: <String>[
'uint8_t type',
'flutter::ByteStreamReader* stream'
],
isConst: true,
isOverride: true);
});
}, nestCount: 0);
indent.newln();
}
void _writeErrorOr(Indent indent,
{Iterable<String> friends = const <String>[]}) {
final String friendLines = friends
.map((String className) => '\tfriend class $className;')
.join('\n');
indent.format('''
class FlutterError {
public:
\texplicit FlutterError(const std::string& code)
\t\t: code_(code) {}
\texplicit FlutterError(const std::string& code, const std::string& message)
\t\t: code_(code), message_(message) {}
\texplicit FlutterError(const std::string& code, const std::string& message, const flutter::EncodableValue& details)
\t\t: code_(code), message_(message), details_(details) {}
\tconst std::string& code() const { return code_; }
\tconst std::string& message() const { return message_; }
\tconst flutter::EncodableValue& details() const { return details_; }
private:
\tstd::string code_;
\tstd::string message_;
\tflutter::EncodableValue details_;
};
template<class T> class ErrorOr {
public:
\tErrorOr(const T& rhs) : v_(rhs) {}
\tErrorOr(const T&& rhs) : v_(std::move(rhs)) {}
\tErrorOr(const FlutterError& rhs) : v_(rhs) {}
\tErrorOr(const FlutterError&& rhs) : v_(std::move(rhs)) {}
\tbool has_error() const { return std::holds_alternative<FlutterError>(v_); }
\tconst T& value() const { return std::get<T>(v_); };
\tconst FlutterError& error() const { return std::get<FlutterError>(v_); };
private:
$friendLines
\tErrorOr() = default;
\tT TakeValue() && { return std::get<T>(std::move(v_)); }
\tstd::variant<T, FlutterError> v_;
};
''');
}
@override
void writeCloseNamespace(
CppOptions generatorOptions, Root root, Indent indent) {
if (generatorOptions.namespace != null) {
indent.writeln('} // namespace ${generatorOptions.namespace}');
}
final String guardName = _getGuardName(generatorOptions.headerIncludePath);
indent.writeln('#endif // $guardName');
}
}
/// Writes C++ source (.cpp) file to sink.
class CppSourceGenerator extends StructuredGenerator<CppOptions> {
/// Constructor.
const CppSourceGenerator();
@override
void writeFilePrologue(
CppOptions generatorOptions, Root root, Indent indent) {
if (generatorOptions.copyrightHeader != null) {
addLines(indent, generatorOptions.copyrightHeader!, linePrefix: '// ');
}
indent.writeln('$_commentPrefix ${getGeneratedCodeWarning()}');
indent.writeln('$_commentPrefix $seeAlsoWarning');
indent.newln();
indent.addln('#undef _HAS_EXCEPTIONS');
indent.newln();
}
@override
void writeFileImports(CppOptions generatorOptions, Root root, Indent indent) {
indent.writeln('#include "${generatorOptions.headerIncludePath}"');
indent.newln();
_writeSystemHeaderIncludeBlock(indent, <String>[
'flutter/basic_message_channel.h',
'flutter/binary_messenger.h',
'flutter/encodable_value.h',
'flutter/standard_message_codec.h',
]);
indent.newln();
_writeSystemHeaderIncludeBlock(indent, <String>[
'map',
'string',
'optional',
]);
indent.newln();
}
@override
void writeOpenNamespace(
CppOptions generatorOptions, Root root, Indent indent) {
if (generatorOptions.namespace != null) {
indent.writeln('namespace ${generatorOptions.namespace} {');
}
}
@override
void writeGeneralUtilities(
CppOptions generatorOptions, Root root, Indent indent) {
final List<String> usingDirectives = <String>[
'flutter::BasicMessageChannel',
'flutter::CustomEncodableValue',
'flutter::EncodableList',
'flutter::EncodableMap',
'flutter::EncodableValue',
];
usingDirectives.sort();
for (final String using in usingDirectives) {
indent.writeln('using $using;');
}
indent.newln();
}
@override
void writeDataClass(
CppOptions generatorOptions, Root root, Indent indent, Class klass) {
final Set<String> customClassNames =
root.classes.map((Class x) => x.name).toSet();
final Set<String> customEnumNames =
root.enums.map((Enum x) => x.name).toSet();
indent.writeln('$_commentPrefix ${klass.name}');
indent.newln();
final Iterable<NamedType> orderedFields =
getFieldsInSerializationOrder(klass);
final Iterable<NamedType> requiredFields =
orderedFields.where((NamedType type) => !type.type.isNullable);
// Minimal constructor, if needed.
if (requiredFields.length != orderedFields.length) {
_writeClassConstructor(root, indent, klass, requiredFields);
}
// All-field constructor.
_writeClassConstructor(root, indent, klass, orderedFields);
// Getters and setters.
for (final NamedType field in orderedFields) {
_writeCppSourceClassField(generatorOptions, root, indent, klass, field);
}
// Serialization.
writeClassEncode(generatorOptions, root, indent, klass, customClassNames,
customEnumNames);
// Deserialization.
writeClassDecode(generatorOptions, root, indent, klass, customClassNames,
customEnumNames);
}
@override
void writeClassEncode(
CppOptions generatorOptions,
Root root,
Indent indent,
Class klass,
Set<String> customClassNames,
Set<String> customEnumNames,
) {
_writeFunctionDefinition(indent, 'ToEncodableList',
scope: klass.name,
returnType: 'EncodableList',
isConst: true, body: () {
indent.writeln('EncodableList list;');
indent.writeln('list.reserve(${klass.fields.length});');
for (final NamedType field in getFieldsInSerializationOrder(klass)) {
final HostDatatype hostDatatype = getFieldHostDatatype(field,
root.classes, root.enums, _shortBaseCppTypeForBuiltinDartType);
final String encodableValue = _wrappedHostApiArgumentExpression(
root, _makeInstanceVariableName(field), field.type, hostDatatype,
preSerializeClasses: true);
indent.writeln('list.push_back($encodableValue);');
}
indent.writeln('return list;');
});
}
@override
void writeClassDecode(
CppOptions generatorOptions,
Root root,
Indent indent,
Class klass,
Set<String> customClassNames,
Set<String> customEnumNames,
) {
// Returns the expression to convert the given EncodableValue to a field
// value.
String getValueExpression(NamedType field, String encodable) {
if (customEnumNames.contains(field.type.baseName)) {
return '(${field.type.baseName})(std::get<int32_t>($encodable))';
} else if (field.type.baseName == 'int') {
return '$encodable.LongValue()';
} else {
final HostDatatype hostDatatype = getFieldHostDatatype(field,
root.classes, root.enums, _shortBaseCppTypeForBuiltinDartType);
if (!hostDatatype.isBuiltin &&
root.classes
.map((Class x) => x.name)
.contains(field.type.baseName)) {
return '${hostDatatype.datatype}::FromEncodableList(std::get<EncodableList>($encodable))';
} else {
return 'std::get<${hostDatatype.datatype}>($encodable)';
}
}
}
_writeFunctionDefinition(indent, 'FromEncodableList',
scope: klass.name,
returnType: klass.name,
parameters: <String>['const EncodableList& list'], body: () {
const String instanceVariable = 'decoded';
final Iterable<_IndexedField> indexedFields = indexMap(
getFieldsInSerializationOrder(klass),
(int index, NamedType field) => _IndexedField(index, field));
final Iterable<_IndexedField> nullableFields = indexedFields
.where((_IndexedField field) => field.field.type.isNullable);
final Iterable<_IndexedField> nonNullableFields = indexedFields
.where((_IndexedField field) => !field.field.type.isNullable);
// Non-nullable fields must be set via the constructor.
String constructorArgs = nonNullableFields
.map((_IndexedField param) =>
getValueExpression(param.field, 'list[${param.index}]'))
.join(',\n\t');
if (constructorArgs.isNotEmpty) {
constructorArgs = '(\n\t$constructorArgs)';
}
indent.format('${klass.name} $instanceVariable$constructorArgs;');
// Add the nullable fields via setters, since converting the encodable
// values to the pointer types that the convenience constructor uses for
// nullable fields is non-trivial.
for (final _IndexedField entry in nullableFields) {
final NamedType field = entry.field;
final String setterName = _makeSetterName(field);
final String encodableFieldName =
'${_encodablePrefix}_${_makeVariableName(field)}';
indent.writeln('auto& $encodableFieldName = list[${entry.index}];');
final String valueExpression =
getValueExpression(field, encodableFieldName);
indent.writeScoped('if (!$encodableFieldName.IsNull()) {', '}', () {
indent.writeln('$instanceVariable.$setterName($valueExpression);');
});
}
// This returns by value, relying on copy elision, since it makes the
// usage more convenient during deserialization than it would be with
// explicit transfer via unique_ptr.
indent.writeln('return $instanceVariable;');
});
}
@override
void writeFlutterApi(
CppOptions generatorOptions,
Root root,
Indent indent,
Api api,
) {
assert(api.location == ApiLocation.flutter);
if (getCodecClasses(api, root).isNotEmpty) {
_writeCodec(generatorOptions, root, indent, api);
}
indent.writeln(
'$_commentPrefix Generated class from Pigeon that represents Flutter messages that can be called from C++.');
_writeFunctionDefinition(indent, api.name,
scope: api.name,
parameters: <String>['flutter::BinaryMessenger* binary_messenger'],
initializers: <String>['binary_messenger_(binary_messenger)']);
final String codeSerializerName = getCodecClasses(api, root).isNotEmpty
? _getCodecSerializerName(api)
: _defaultCodecSerializer;
_writeFunctionDefinition(indent, 'GetCodec',
scope: api.name,
returnType: 'const flutter::StandardMessageCodec&', body: () {
indent.writeln(
'return flutter::StandardMessageCodec::GetInstance(&$codeSerializerName::GetInstance());');
});
for (final Method func in api.methods) {
final String channelName = makeChannelName(api, func);
final HostDatatype returnType = getHostDatatype(func.returnType,
root.classes, root.enums, _shortBaseCppTypeForBuiltinDartType);
// Determine the input parameter list, saved in a structured form for later
// use as platform channel call arguments.
final Iterable<_HostNamedType> hostParameters =
indexMap(func.arguments, (int i, NamedType arg) {
final HostDatatype hostType = getFieldHostDatatype(
arg, root.classes, root.enums, _shortBaseCppTypeForBuiltinDartType);
return _HostNamedType(_getSafeArgumentName(i, arg), hostType, arg.type);
});
final List<String> parameters = <String>[
...hostParameters.map((_HostNamedType arg) =>
'${_flutterApiArgumentType(arg.hostType)} ${arg.name}'),
..._flutterApiCallbackParameters(returnType),
];
_writeFunctionDefinition(indent, _makeMethodName(func),
scope: api.name,
returnType: _voidType,
parameters: parameters, body: () {
const String channel = 'channel';
indent.writeln(
'auto channel = std::make_unique<BasicMessageChannel<>>(binary_messenger_, '
'"$channelName", &GetCodec());');
// Convert arguments to EncodableValue versions.
const String argumentListVariableName = 'encoded_api_arguments';
indent.write('EncodableValue $argumentListVariableName = ');
if (func.arguments.isEmpty) {
indent.addln('EncodableValue();');
} else {
indent.addScoped('EncodableValue(EncodableList{', '});', () {
for (final _HostNamedType param in hostParameters) {
final String encodedArgument = _wrappedHostApiArgumentExpression(
root, param.name, param.originalType, param.hostType,
preSerializeClasses: false);
indent.writeln('$encodedArgument,');
}
});
}
indent.write('$channel->Send($argumentListVariableName, '
// ignore: missing_whitespace_between_adjacent_strings
'[on_success = std::move(on_success), on_error = std::move(on_error)]'
'(const uint8_t* reply, size_t reply_size) ');
indent.addScoped('{', '});', () {
final String successCallbackArgument;
if (func.returnType.isVoid) {
successCallbackArgument = '';
} else {
successCallbackArgument = 'return_value';
final String encodedReplyName =
'encodable_$successCallbackArgument';
indent.writeln(
'std::unique_ptr<EncodableValue> response = GetCodec().DecodeMessage(reply, reply_size);');
indent.writeln('const auto& $encodedReplyName = *response;');
_writeEncodableValueArgumentUnwrapping(indent, returnType,
argName: successCallbackArgument,
encodableArgName: encodedReplyName);
}
indent.writeln('on_success($successCallbackArgument);');
});
});
}
}
@override
void writeHostApi(
CppOptions generatorOptions, Root root, Indent indent, Api api) {
assert(api.location == ApiLocation.host);
if (getCodecClasses(api, root).isNotEmpty) {
_writeCodec(generatorOptions, root, indent, api);
}
final String codeSerializerName = getCodecClasses(api, root).isNotEmpty
? _getCodecSerializerName(api)
: _defaultCodecSerializer;
indent.writeln('/// The codec used by ${api.name}.');
_writeFunctionDefinition(indent, 'GetCodec',
scope: api.name,
returnType: 'const flutter::StandardMessageCodec&', body: () {
indent.writeln(
'return flutter::StandardMessageCodec::GetInstance(&$codeSerializerName::GetInstance());');
});
indent.writeln(
'$_commentPrefix Sets up an instance of `${api.name}` to handle messages through the `binary_messenger`.');
_writeFunctionDefinition(indent, 'SetUp',
scope: api.name,
returnType: _voidType,
parameters: <String>[
'flutter::BinaryMessenger* binary_messenger',
'${api.name}* api'
], body: () {
for (final Method method in api.methods) {
final String channelName = makeChannelName(api, method);
indent.writeScoped('{', '}', () {
indent.writeln(
'auto channel = std::make_unique<BasicMessageChannel<>>(binary_messenger, '
'"$channelName", &GetCodec());');
indent.writeScoped('if (api != nullptr) {', '} else {', () {
indent.write(
'channel->SetMessageHandler([api](const EncodableValue& message, const flutter::MessageReply<EncodableValue>& reply) ');
indent.addScoped('{', '});', () {
indent.writeScoped('try {', '}', () {
final List<String> methodArgument = <String>[];
if (method.arguments.isNotEmpty) {
indent.writeln(
'const auto& args = std::get<EncodableList>(message);');
enumerate(method.arguments, (int index, NamedType arg) {
final HostDatatype hostType = getHostDatatype(
arg.type,
root.classes,
root.enums,
(TypeDeclaration x) =>
_shortBaseCppTypeForBuiltinDartType(x));
final String argName = _getSafeArgumentName(index, arg);
final String encodableArgName =
'${_encodablePrefix}_$argName';
indent.writeln(
'const auto& $encodableArgName = args.at($index);');
if (!arg.type.isNullable) {
indent.writeScoped(
'if ($encodableArgName.IsNull()) {', '}', () {
indent.writeln(
'reply(WrapError("$argName unexpectedly null."));');
indent.writeln('return;');
});
}
_writeEncodableValueArgumentUnwrapping(indent, hostType,
argName: argName, encodableArgName: encodableArgName);
methodArgument.add(argName);
});
}
final HostDatatype returnType = getHostDatatype(
method.returnType,
root.classes,
root.enums,
_shortBaseCppTypeForBuiltinDartType);
final String returnTypeName = _hostApiReturnType(returnType);
if (method.isAsynchronous) {
methodArgument.add(
'[reply]($returnTypeName&& output) {${indent.newline}'
'${_wrapResponse(indent, root, method.returnType, prefix: '\t')}${indent.newline}'
'}',
);
}
final String call =
'api->${_makeMethodName(method)}(${methodArgument.join(', ')})';
if (method.isAsynchronous) {
indent.format('$call;');
} else {
indent.writeln('$returnTypeName output = $call;');
indent.format(_wrapResponse(indent, root, method.returnType));
}
}, addTrailingNewline: false);
indent.add(' catch (const std::exception& exception) ');
indent.addScoped('{', '}', () {
// There is a potential here for `reply` to be called twice, which
// is a violation of the API contract, because there's no way of
// knowing whether or not the plugin code called `reply` before
// throwing. Since use of `@async` suggests that the reply is
// probably not sent within the scope of the stack, err on the
// side of potential double-call rather than no call (which is
// also an API violation) so that unexpected errors have a better
// chance of being caught and handled in a useful way.
indent.writeln('reply(WrapError(exception.what()));');
});
});
});
indent.addScoped(null, '}', () {
indent.writeln('channel->SetMessageHandler(nullptr);');
});
});
}
});
_writeFunctionDefinition(indent, 'WrapError',
scope: api.name,
returnType: 'EncodableValue',
parameters: <String>['std::string_view error_message'], body: () {
indent.format('''
return EncodableValue(EncodableList{
\tEncodableValue(std::string(error_message)),
\tEncodableValue("Error"),
\tEncodableValue()
});''');
});
_writeFunctionDefinition(indent, 'WrapError',
scope: api.name,
returnType: 'EncodableValue',
parameters: <String>['const FlutterError& error'], body: () {
indent.format('''
return EncodableValue(EncodableList{
\tEncodableValue(error.code()),
\tEncodableValue(error.message()),
\terror.details()
});''');
});
}
void _writeCodec(
CppOptions generatorOptions,
Root root,
Indent indent,
Api api,
) {
assert(getCodecClasses(api, root).isNotEmpty);
final String codeSerializerName = _getCodecSerializerName(api);
indent.newln();
_writeFunctionDefinition(indent, codeSerializerName,
scope: codeSerializerName);
_writeFunctionDefinition(indent, 'ReadValueOfType',
scope: codeSerializerName,
returnType: 'EncodableValue',
parameters: <String>[
'uint8_t type',
'flutter::ByteStreamReader* stream',
],
isConst: true, body: () {
indent.write('switch (type) ');
indent.addScoped('{', '}', () {
for (final EnumeratedClass customClass in getCodecClasses(api, root)) {
indent.writeln('case ${customClass.enumeration}:');
indent.nest(1, () {
indent.writeln(
'return CustomEncodableValue(${customClass.name}::FromEncodableList(std::get<EncodableList>(ReadValue(stream))));');
});
}
indent.writeln('default:');
indent.nest(1, () {
indent.writeln(
'return $_defaultCodecSerializer::ReadValueOfType(type, stream);');
});
});
});
_writeFunctionDefinition(indent, 'WriteValue',
scope: codeSerializerName,
returnType: _voidType,
parameters: <String>[
'const EncodableValue& value',
'flutter::ByteStreamWriter* stream',
],
isConst: true, body: () {
indent.write(
'if (const CustomEncodableValue* custom_value = std::get_if<CustomEncodableValue>(&value)) ');
indent.addScoped('{', '}', () {
for (final EnumeratedClass customClass in getCodecClasses(api, root)) {
indent.write(
'if (custom_value->type() == typeid(${customClass.name})) ');
indent.addScoped('{', '}', () {
indent.writeln('stream->WriteByte(${customClass.enumeration});');
indent.writeln(
'WriteValue(EncodableValue(std::any_cast<${customClass.name}>(*custom_value).ToEncodableList()), stream);');
indent.writeln('return;');
});
}
});
indent.writeln('$_defaultCodecSerializer::WriteValue(value, stream);');
});
}
void _writeClassConstructor(
Root root, Indent indent, Class klass, Iterable<NamedType> params) {
final Iterable<_HostNamedType> hostParams = params.map((NamedType param) {
return _HostNamedType(
_makeVariableName(param),
getFieldHostDatatype(
param,
root.classes,
root.enums,
_shortBaseCppTypeForBuiltinDartType,
),
param.type,
);
});
final List<String> paramStrings = hostParams
.map((_HostNamedType param) =>
'${_hostApiArgumentType(param.hostType)} ${param.name}')
.toList();
final List<String> initializerStrings = hostParams
.map((_HostNamedType param) =>
'${param.name}_(${_fieldValueExpression(param.hostType, param.name)})')
.toList();
_writeFunctionDefinition(indent, klass.name,
scope: klass.name,
parameters: paramStrings,
initializers: initializerStrings);
}
void _writeCppSourceClassField(CppOptions generatorOptions, Root root,
Indent indent, Class klass, NamedType field) {
final HostDatatype hostDatatype = getFieldHostDatatype(
field, root.classes, root.enums, _shortBaseCppTypeForBuiltinDartType);
final String instanceVariableName = _makeInstanceVariableName(field);
final String setterName = _makeSetterName(field);
final String returnExpression = hostDatatype.isNullable
? '$instanceVariableName ? &(*$instanceVariableName) : nullptr'
: instanceVariableName;
// Writes a setter treating the type as [type], to allow generating multiple
// setter variants.
void writeSetter(HostDatatype type) {
const String setterArgumentName = 'value_arg';
_writeFunctionDefinition(
indent,
setterName,
scope: klass.name,
returnType: _voidType,
parameters: <String>[
'${_unownedArgumentType(type)} $setterArgumentName'
],
body: () {
indent.writeln(
'$instanceVariableName = ${_fieldValueExpression(type, setterArgumentName)};');
},
);
}
_writeFunctionDefinition(
indent,
_makeGetterName(field),
scope: klass.name,
returnType: _getterReturnType(hostDatatype),
isConst: true,
body: () {
indent.writeln('return $returnExpression;');
},
);
writeSetter(hostDatatype);
if (hostDatatype.isNullable) {
// Write the non-nullable variant; see _writeCppHeaderDataClass.
writeSetter(_nonNullableType(hostDatatype));
}
indent.newln();
}
/// Returns the value to use when setting a field of the given type from
/// an argument of that type.
///
/// For non-nullable values this is just the variable itself, but for nullable
/// values this handles the conversion between an argument type (a pointer)
/// and the field type (a std::optional).
String _fieldValueExpression(HostDatatype type, String variable) {
return type.isNullable
? '$variable ? ${_valueType(type)}(*$variable) : std::nullopt'
: variable;
}
String _wrapResponse(Indent indent, Root root, TypeDeclaration returnType,
{String prefix = ''}) {
final String nonErrorPath;
final String errorCondition;
final String errorGetter;
const String nullValue = 'EncodableValue()';
if (returnType.isVoid) {
nonErrorPath = '${prefix}wrapped.push_back($nullValue);';
errorCondition = 'output.has_value()';
errorGetter = 'value';
} else {
final HostDatatype hostType = getHostDatatype(returnType, root.classes,
root.enums, _shortBaseCppTypeForBuiltinDartType);
const String extractedValue = 'std::move(output).TakeValue()';
final String wrapperType =
hostType.isBuiltin ? 'EncodableValue' : 'CustomEncodableValue';
if (returnType.isNullable) {
// The value is a std::optional, so needs an extra layer of
// handling.
nonErrorPath = '''
${prefix}auto output_optional = $extractedValue;
${prefix}if (output_optional) {
$prefix\twrapped.push_back($wrapperType(std::move(output_optional).value()));
$prefix} else {
$prefix\twrapped.push_back($nullValue);
$prefix}''';
} else {
nonErrorPath =
'${prefix}wrapped.push_back($wrapperType($extractedValue));';
}
errorCondition = 'output.has_error()';
errorGetter = 'error';
}
// Ideally this code would use an initializer list to create
// an EncodableList inline, which would be less code. However,
// that would always copy the element, so the slightly more
// verbose create-and-push approach is used instead.
return '''
${prefix}if ($errorCondition) {
$prefix\treply(WrapError(output.$errorGetter()));
$prefix\treturn;
$prefix}
${prefix}EncodableList wrapped;
$nonErrorPath
${prefix}reply(EncodableValue(std::move(wrapped)));''';
}
@override
void writeCloseNamespace(
CppOptions generatorOptions, Root root, Indent indent) {
if (generatorOptions.namespace != null) {
indent.writeln('} // namespace ${generatorOptions.namespace}');
}
}
/// Returns the expression to create an EncodableValue from a host API argument
/// with the given [variableName] and types.
///
/// If [preSerializeClasses] is true, custom classes will be returned as
/// encodable lists rather than CustomEncodableValues; see
/// https://github.com/flutter/flutter/issues/119351 for why this is currently
/// needed.
String _wrappedHostApiArgumentExpression(Root root, String variableName,
TypeDeclaration dartType, HostDatatype hostType,
{required bool preSerializeClasses}) {
final String encodableValue;
if (!hostType.isBuiltin &&
root.classes.any((Class c) => c.name == dartType.baseName)) {
if (preSerializeClasses) {
final String operator = hostType.isNullable ? '->' : '.';
encodableValue =
'EncodableValue($variableName${operator}ToEncodableList())';
} else {
final String nonNullValue =
hostType.isNullable ? '*$variableName' : variableName;
encodableValue = 'CustomEncodableValue($nonNullValue)';
}
} else if (!hostType.isBuiltin &&
root.enums.any((Enum e) => e.name == dartType.baseName)) {
final String nonNullValue =
hostType.isNullable ? '(*$variableName)' : variableName;
encodableValue = 'EncodableValue((int)$nonNullValue)';
} else {
final String operator = hostType.isNullable ? '*' : '';
encodableValue = 'EncodableValue($operator$variableName)';
}
if (hostType.isNullable) {
return '$variableName ? $encodableValue : EncodableValue()';
}
return encodableValue;
}
/// Writes the code to declare and populate a variable of type [hostType]
/// called [argName] to use as a parameter to an API method call, from an
/// existing EncodableValue variable called [encodableArgName].
void _writeEncodableValueArgumentUnwrapping(
Indent indent,
HostDatatype hostType, {
required String argName,
required String encodableArgName,
}) {
if (hostType.isNullable) {
// Nullable arguments are always pointers, with nullptr corresponding to
// null.
if (hostType.datatype == 'int64_t') {
// The EncodableValue will either be an int32_t or an int64_t depending
// on the value, but the generated API requires an int64_t so that it can
// handle any case. Create a local variable for the 64-bit value...
final String valueVarName = '${argName}_value';
indent.writeln(
'const int64_t $valueVarName = $encodableArgName.IsNull() ? 0 : $encodableArgName.LongValue();');
// ... then declare the arg as a reference to that local.
indent.writeln(
'const auto* $argName = $encodableArgName.IsNull() ? nullptr : &$valueVarName;');
} else if (hostType.datatype == 'EncodableValue') {
// Generic objects just pass the EncodableValue through directly.
indent.writeln('const auto* $argName = &$encodableArgName;');
} else if (hostType.isBuiltin) {
indent.writeln(
'const auto* $argName = std::get_if<${hostType.datatype}>(&$encodableArgName);');
} else {
indent.writeln(
'const auto* $argName = &(std::any_cast<const ${hostType.datatype}&>(std::get<CustomEncodableValue>($encodableArgName)));');
}
} else {
// Non-nullable arguments are either passed by value or reference, but the
// extraction doesn't need to distinguish since those are the same at the
// call site.
if (hostType.datatype == 'int64_t') {
// The EncodableValue will either be an int32_t or an int64_t depending
// on the value, but the generated API requires an int64_t so that it can
// handle any case.
indent
.writeln('const int64_t $argName = $encodableArgName.LongValue();');
} else if (hostType.datatype == 'EncodableValue') {
// Generic objects just pass the EncodableValue through directly. This
// creates an alias just to avoid having to special-case the
// argName/encodableArgName distinction at a higher level.
indent.writeln('const auto& $argName = $encodableArgName;');
} else if (hostType.isBuiltin) {
indent.writeln(
'const auto& $argName = std::get<${hostType.datatype}>($encodableArgName);');
} else {
indent.writeln(
'const auto& $argName = std::any_cast<const ${hostType.datatype}&>(std::get<CustomEncodableValue>($encodableArgName));');
}
}
}
/// A wrapper for [_baseCppTypeForBuiltinDartType] that generated Flutter
/// types without the namespace, since the implementation file uses `using`
/// directives.
String? _shortBaseCppTypeForBuiltinDartType(TypeDeclaration type) {
return _baseCppTypeForBuiltinDartType(type, includeFlutterNamespace: false);
}
}
/// Contains information about a host function argument.
///
/// This is comparable to a [NamedType], but has already gone through host type
/// and variable name mapping, and it tracks the original [NamedType] that it
/// was created from.
class _HostNamedType {
const _HostNamedType(this.name, this.hostType, this.originalType);
final String name;
final HostDatatype hostType;
final TypeDeclaration originalType;
}
/// Contains a class field and its serialization index.
class _IndexedField {
const _IndexedField(this.index, this.field);
final int index;
final NamedType field;
}
String _getCodecSerializerName(Api api) => '${api.name}CodecSerializer';
const String _encodablePrefix = 'encodable';
String _getArgumentName(int count, NamedType argument) =>
argument.name.isEmpty ? 'arg$count' : _makeVariableName(argument);
/// Returns an argument name that can be used in a context where it is possible to collide.
String _getSafeArgumentName(int count, NamedType argument) =>
'${_getArgumentName(count, argument)}_arg';
/// Returns a non-nullable variant of [type].
HostDatatype _nonNullableType(HostDatatype type) {
return HostDatatype(
datatype: type.datatype, isBuiltin: type.isBuiltin, isNullable: false);
}
String _pascalCaseFromCamelCase(String camelCase) =>
camelCase[0].toUpperCase() + camelCase.substring(1);
String _snakeCaseFromCamelCase(String camelCase) {
return camelCase.replaceAllMapped(RegExp(r'[A-Z]'),
(Match m) => '${m.start == 0 ? '' : '_'}${m[0]!.toLowerCase()}');
}
String _pascalCaseFromSnakeCase(String snakeCase) {
final String camelCase = snakeCase.replaceAllMapped(
RegExp(r'_([a-z])'), (Match m) => m[1]!.toUpperCase());
return _pascalCaseFromCamelCase(camelCase);
}
String _makeMethodName(Method method) => _pascalCaseFromCamelCase(method.name);
String _makeGetterName(NamedType field) => _snakeCaseFromCamelCase(field.name);
String _makeSetterName(NamedType field) =>
'set_${_snakeCaseFromCamelCase(field.name)}';
String _makeVariableName(NamedType field) =>
_snakeCaseFromCamelCase(field.name);
String _makeInstanceVariableName(NamedType field) =>
'${_makeVariableName(field)}_';
// TODO(stuartmorgan): Remove this in favor of _isPodType once callers have
// all been updated to using HostDatatypes.
bool _isReferenceType(String dataType) {
switch (dataType) {
case 'bool':
case 'int64_t':
case 'double':
return false;
default:
return true;
}
}
/// Returns the parameters to use for the success and error callbacks in a
/// Flutter API function signature.
List<String> _flutterApiCallbackParameters(HostDatatype returnType) {
return <String>[
'std::function<void(${_flutterApiReturnType(returnType)})>&& on_success',
'std::function<void(const FlutterError&)>&& on_error',
];
}
/// Returns true if [type] corresponds to a plain-old-data type (i.e., one that
/// should generally be passed by value rather than pointer/reference) in C++.
bool _isPodType(HostDatatype type) {
return !_isReferenceType(type.datatype);
}
String? _baseCppTypeForBuiltinDartType(
TypeDeclaration type, {
bool includeFlutterNamespace = true,
}) {
final String flutterNamespace = includeFlutterNamespace ? 'flutter::' : '';
final Map<String, String> cppTypeForDartTypeMap = <String, String>{
'void': 'void',
'bool': 'bool',
'int': 'int64_t',
'String': 'std::string',
'double': 'double',
'Uint8List': 'std::vector<uint8_t>',
'Int32List': 'std::vector<int32_t>',
'Int64List': 'std::vector<int64_t>',
'Float64List': 'std::vector<double>',
'Map': '${flutterNamespace}EncodableMap',
'List': '${flutterNamespace}EncodableList',
'Object': '${flutterNamespace}EncodableValue',
};
if (cppTypeForDartTypeMap.containsKey(type.baseName)) {
return cppTypeForDartTypeMap[type.baseName];
} else {
return null;
}
}
/// Returns the C++ type to use in a value context (variable declaration,
/// pass-by-value, etc.) for the given C++ base type.
String _valueType(HostDatatype type) {
final String baseType = type.datatype;
return type.isNullable ? 'std::optional<$baseType>' : baseType;
}
/// Returns the C++ type to use in an argument context without ownership
/// transfer for the given base type.
String _unownedArgumentType(HostDatatype type) {
final bool isString = type.datatype == 'std::string';
final String baseType = isString ? 'std::string_view' : type.datatype;
if (isString || _isPodType(type)) {
return type.isNullable ? 'const $baseType*' : baseType;
}
// TODO(stuartmorgan): Consider special-casing `Object?` here, so that there
// aren't two ways of representing null (nullptr or an isNull EncodableValue).
return type.isNullable ? 'const $baseType*' : 'const $baseType&';
}
/// Returns the C++ type to use for arguments to a host API. This is slightly
/// different from [_unownedArgumentType] since passing `std::string_view*` in
/// to the host API implementation when the actual type is `std::string*` is
/// needlessly complicated, so it uses `std::string` directly.
String _hostApiArgumentType(HostDatatype type) {
final String baseType = type.datatype;
if (_isPodType(type)) {
return type.isNullable ? 'const $baseType*' : baseType;
}
return type.isNullable ? 'const $baseType*' : 'const $baseType&';
}
/// Returns the C++ type to use for arguments to a Flutter API.
String _flutterApiArgumentType(HostDatatype type) {
// Nullable strings use std::string* rather than std::string_view*
// since there's no implicit conversion for the pointer types, making them
// more awkward to use. For consistency, and since EncodableValue will end
// up making a std::string internally anyway, std::string is used for the
// non-nullable case as well.
if (type.datatype == 'std::string') {
return type.isNullable ? 'const std::string*' : 'const std::string&';
}
return _unownedArgumentType(type);
}
/// Returns the C++ type to use for the return of a getter for a field of type
/// [type].
String _getterReturnType(HostDatatype type) {
final String baseType = type.datatype;
if (_isPodType(type)) {
// Use pointers rather than optionals even for nullable POD, since the
// semantics of using them is essentially identical and this makes them
// consistent with non-POD.
return type.isNullable ? 'const $baseType*' : baseType;
}
return type.isNullable ? 'const $baseType*' : 'const $baseType&';
}
/// Returns the C++ type to use for the return of a host API method returning
/// [type].
String _hostApiReturnType(HostDatatype type) {
if (type.datatype == 'void') {
return 'std::optional<FlutterError>';
}
String valueType = type.datatype;
if (type.isNullable) {
valueType = 'std::optional<$valueType>';
}
return 'ErrorOr<$valueType>';
}
/// Returns the C++ type to use for the paramer to the asynchronous "return"
/// callback of a Flutter API method returning [type].
String _flutterApiReturnType(HostDatatype type) {
if (type.datatype == 'void') {
return 'void';
}
// For anything other than void, handle it the same way as a host API argument
// since it has the same basic structure of being a function defined by the
// client, being called by the generated code.
return _hostApiArgumentType(type);
}
String _getGuardName(String? headerFileName) {
const String prefix = 'PIGEON_';
if (headerFileName != null) {
return '$prefix${headerFileName.replaceAll('.', '_').toUpperCase()}_';
} else {
return '${prefix}H_';
}
}
void _writeSystemHeaderIncludeBlock(Indent indent, List<String> headers) {
headers.sort();
for (final String header in headers) {
indent.writeln('#include <$header>');
}
}
enum _FunctionOutputType { declaration, definition }
/// Writes a function declaration or definition to [indent].
///
/// If [parameters] are given, each should be a string of the form 'type name'.
void _writeFunction(
Indent indent,
_FunctionOutputType type, {
required String name,
String? returnType,
String? scope,
List<String> parameters = const <String>[],
List<String> startingAnnotations = const <String>[],
List<String> trailingAnnotations = const <String>[],
List<String> initializers = const <String>[],
void Function()? body,
}) {
assert(body == null || type == _FunctionOutputType.definition);
// Set the initial indentation.
indent.write('');
// Write any starting annotations (e.g., 'static').
for (final String annotation in startingAnnotations) {
indent.add('$annotation ');
}
// Write the signature.
if (returnType != null) {
indent.add('$returnType ');
}
if (scope != null) {
indent.add('$scope::');
}
indent.add(name);
// Write the parameters.
if (parameters.isEmpty) {
indent.add('()');
} else if (parameters.length == 1) {
indent.add('(${parameters.first})');
} else {
indent.addScoped('(', null, () {
enumerate(parameters, (int index, final String param) {
if (index == parameters.length - 1) {
indent.write('$param)');
} else {
indent.writeln('$param,');
}
});
}, addTrailingNewline: false);
}
// Write any trailing annotations (e.g., 'const').
for (final String annotation in trailingAnnotations) {
indent.add(' $annotation');
}
// Write the initializer list, if any.
if (initializers.isNotEmpty) {
indent.newln();
indent.write(' : ');
// The first item goes on the same line as the ":", the rest go on their
// own lines indented two extra levels, with no comma or newline after the
// last one. The easiest way to express the special casing of the first and
// last is with a join+format.
indent.format(initializers.join(',\n\t\t'),
leadingSpace: false, trailingNewline: false);
}
// Write the body or end the declaration.
if (type == _FunctionOutputType.declaration) {
indent.addln(';');
} else {
if (body != null) {
indent.addScoped(' {', '}', body);
} else {
indent.addln(' {}');
}
}
}
void _writeFunctionDeclaration(
Indent indent,
String name, {
String? returnType,
List<String> parameters = const <String>[],
bool isStatic = false,
bool isVirtual = false,
bool isConstructor = false,
bool isPureVirtual = false,
bool isConst = false,
bool isOverride = false,
bool deleted = false,
bool inlineNoop = false,
void Function()? inlineBody,
}) {
assert(!(isVirtual && isOverride), 'virtual is redundant with override');
assert(isVirtual || !isPureVirtual, 'pure virtual methods must be virtual');
assert(returnType == null || !isConstructor,
'constructors cannot have return types');
_writeFunction(
indent,
inlineNoop || (inlineBody != null)
? _FunctionOutputType.definition
: _FunctionOutputType.declaration,
name: name,
returnType: returnType,
parameters: parameters,
startingAnnotations: <String>[
if (inlineBody != null) 'inline',
if (isStatic) 'static',
if (isVirtual) 'virtual',
if (isConstructor && parameters.isNotEmpty) 'explicit'
],
trailingAnnotations: <String>[
if (isConst) 'const',
if (isOverride) 'override',
if (deleted) '= delete',
if (isPureVirtual) '= 0',
],
body: inlineBody,
);
}
void _writeFunctionDefinition(
Indent indent,
String name, {
String? returnType,
String? scope,
List<String> parameters = const <String>[],
bool isConst = false,
List<String> initializers = const <String>[],
void Function()? body,
}) {
_writeFunction(
indent,
_FunctionOutputType.definition,
name: name,
scope: scope,
returnType: returnType,
parameters: parameters,
trailingAnnotations: <String>[
if (isConst) 'const',
],
initializers: initializers,
body: body,
);
indent.newln();
}
enum _ClassAccess { public, protected, private }
void _writeAccessBlock(
Indent indent, _ClassAccess access, void Function() body) {
final String accessLabel;
switch (access) {
case _ClassAccess.public:
accessLabel = 'public';
break;
case _ClassAccess.protected:
accessLabel = 'protected';
break;
case _ClassAccess.private:
accessLabel = 'private';
break;
}
indent.addScoped(' $accessLabel:', '', body);
}
/// Validates an AST to make sure the cpp generator supports everything.
List<Error> validateCpp(CppOptions options, Root root) {
final List<Error> result = <Error>[];
for (final Api api in root.apis) {
for (final Method method in api.methods) {
for (final NamedType arg in method.arguments) {
if (isEnum(root, arg.type)) {
// TODO(gaaclarke): Add line number and filename.
result.add(Error(
message:
"Nullable enum types aren't supported in C++ arguments in method:${api.name}.${method.name} argument:(${arg.type.baseName} ${arg.name})."));
}
}
}
}
return result;
}