summaryrefslogtreecommitdiffstats
path: root/third_party/rust/weedle2/src/interface.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /third_party/rust/weedle2/src/interface.rs
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/weedle2/src/interface.rs')
-rw-r--r--third_party/rust/weedle2/src/interface.rs249
1 files changed, 249 insertions, 0 deletions
diff --git a/third_party/rust/weedle2/src/interface.rs b/third_party/rust/weedle2/src/interface.rs
new file mode 100644
index 0000000000..5e30909c38
--- /dev/null
+++ b/third_party/rust/weedle2/src/interface.rs
@@ -0,0 +1,249 @@
+use crate::argument::ArgumentList;
+use crate::attribute::ExtendedAttributeList;
+use crate::common::{Generics, Identifier, Parenthesized};
+use crate::literal::ConstValue;
+use crate::types::{AttributedType, ConstType, ReturnType};
+
+/// Parses interface members
+pub type InterfaceMembers<'a> = Vec<InterfaceMember<'a>>;
+
+ast_types! {
+ /// Parses inheritance clause `: identifier`
+ #[derive(Copy)]
+ struct Inheritance<'a> {
+ colon: term!(:),
+ identifier: Identifier<'a>,
+ }
+
+ /// Parses one of the interface member variants
+ enum InterfaceMember<'a> {
+ /// Parses a const interface member `[attributes]? const type identifier = value;`
+ Const(struct ConstMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ const_: term!(const),
+ const_type: ConstType<'a>,
+ identifier: Identifier<'a>,
+ assign: term!(=),
+ const_value: ConstValue<'a>,
+ semi_colon: term!(;),
+ }),
+ /// Parses `[attributes]? (stringifier|inherit|static)? readonly? attribute attributedtype identifier;`
+ Attribute(struct AttributeInterfaceMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ modifier: Option<StringifierOrInheritOrStatic>,
+ readonly: Option<term!(readonly)>,
+ attribute: term!(attribute),
+ type_: AttributedType<'a>,
+ identifier: Identifier<'a>,
+ semi_colon: term!(;),
+ }),
+ /// Parses `[attributes]? constructor(( args ));`
+ ///
+ /// (( )) means ( ) chars
+ Constructor(struct ConstructorInterfaceMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ constructor: term!(constructor),
+ args: Parenthesized<ArgumentList<'a>>,
+ semi_colon: term!(;),
+ }),
+ /// Parses `[attributes]? (stringifier|static)? special? returntype identifier? (( args ));`
+ ///
+ /// (( )) means ( ) chars
+ Operation(struct OperationInterfaceMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ modifier: Option<StringifierOrStatic>,
+ special: Option<Special>,
+ return_type: ReturnType<'a>,
+ identifier: Option<Identifier<'a>>,
+ args: Parenthesized<ArgumentList<'a>>,
+ semi_colon: term!(;),
+ }),
+ /// Parses an iterable declaration `[attributes]? (iterable<attributedtype> | iterable<attributedtype, attributedtype>) ;`
+ Iterable(enum IterableInterfaceMember<'a> {
+ /// Parses an iterable declaration `[attributes]? iterable<attributedtype>;`
+ Single(struct SingleTypedIterable<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ iterable: term!(iterable),
+ generics: Generics<AttributedType<'a>>,
+ semi_colon: term!(;),
+ }),
+ /// Parses an iterable declaration `[attributes]? iterable<attributedtype, attributedtype>;`
+ Double(struct DoubleTypedIterable<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ iterable: term!(iterable),
+ generics: Generics<(AttributedType<'a>, term!(,), AttributedType<'a>)>,
+ semi_colon: term!(;),
+ }),
+ }),
+ /// Parses an async iterable declaration `[attributes]? async (iterable<attributedtype> | iterable<attributedtype, attributedtype>) (( args ))? ;`
+ AsyncIterable(enum AsyncIterableInterfaceMember<'a> {
+ /// Parses an async iterable declaration `[attributes]? async iterable<attributedtype> (( args ))? ;`
+ Single(struct SingleTypedAsyncIterable<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ async_iterable: (term!(async), term!(iterable)),
+ generics: Generics<AttributedType<'a>>,
+ args: Option<Parenthesized<ArgumentList<'a>>>,
+ semi_colon: term!(;),
+ }),
+ /// Parses an async iterable declaration `[attributes]? async iterable<attributedtype, attributedtype> (( args ))? ;`
+ Double(struct DoubleTypedAsyncIterable<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ async_iterable: (term!(async), term!(iterable)),
+ generics: Generics<(AttributedType<'a>, term!(,), AttributedType<'a>)>,
+ args: Option<Parenthesized<ArgumentList<'a>>>,
+ semi_colon: term!(;),
+ }),
+ }),
+ /// Parses an maplike declaration `[attributes]? readonly? maplike<attributedtype, attributedtype>;`
+ Maplike(struct MaplikeInterfaceMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ readonly: Option<term!(readonly)>,
+ maplike: term!(maplike),
+ generics: Generics<(AttributedType<'a>, term!(,), AttributedType<'a>)>,
+ semi_colon: term!(;),
+ }),
+ Setlike(struct SetlikeInterfaceMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ readonly: Option<term!(readonly)>,
+ setlike: term!(setlike),
+ generics: Generics<AttributedType<'a>>,
+ semi_colon: term!(;),
+ }),
+ /// Parses `stringifier;`
+ #[derive(Default)]
+ Stringifier(struct StringifierMember<'a> {
+ attributes: Option<ExtendedAttributeList<'a>>,
+ stringifier: term!(stringifier),
+ semi_colon: term!(;),
+ }),
+ }
+
+ /// Parses one of the special keyword `getter|setter|deleter`
+ #[derive(Copy)]
+ enum Special {
+ Getter(term!(getter)),
+ Setter(term!(setter)),
+ Deleter(term!(deleter)),
+ LegacyCaller(term!(legacycaller)),
+ }
+
+ /// Parses `stringifier|inherit|static`
+ #[derive(Copy)]
+ enum StringifierOrInheritOrStatic {
+ Stringifier(term!(stringifier)),
+ Inherit(term!(inherit)),
+ Static(term!(static)),
+ }
+
+ /// Parses `stringifier|static`
+ #[derive(Copy)]
+ enum StringifierOrStatic {
+ Stringifier(term!(stringifier)),
+ Static(term!(static)),
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::Parse;
+
+ test!(should_parse_stringifier_member { "stringifier;" =>
+ "";
+ StringifierMember;
+ });
+
+ test!(should_parse_stringifier_or_static { "static" =>
+ "";
+ StringifierOrStatic;
+ });
+
+ test!(should_parse_stringifier_or_inherit_or_static { "inherit" =>
+ "";
+ StringifierOrInheritOrStatic;
+ });
+
+ test!(should_parse_setlike_interface_member { "readonly setlike<long>;" =>
+ "";
+ SetlikeInterfaceMember;
+ attributes.is_none();
+ readonly == Some(term!(readonly));
+ });
+
+ test!(should_parse_maplike_interface_member { "readonly maplike<long, short>;" =>
+ "";
+ MaplikeInterfaceMember;
+ attributes.is_none();
+ readonly == Some(term!(readonly));
+ });
+
+ test!(should_parse_attribute_interface_member { "readonly attribute unsigned long width;" =>
+ "";
+ AttributeInterfaceMember;
+ attributes.is_none();
+ readonly == Some(term!(readonly));
+ identifier.0 == "width";
+ });
+
+ test!(should_parse_double_typed_iterable { "iterable<long, long>;" =>
+ "";
+ DoubleTypedIterable;
+ attributes.is_none();
+ });
+
+ test!(should_parse_single_typed_iterable { "iterable<long>;" =>
+ "";
+ SingleTypedIterable;
+ attributes.is_none();
+ });
+
+ test!(should_parse_double_typed_async_iterable { "async iterable<long, long>;" =>
+ "";
+ DoubleTypedAsyncIterable;
+ attributes.is_none();
+ args.is_none();
+ });
+
+ test!(should_parse_double_typed_async_iterable_with_args { "async iterable<long, long>(long a);" =>
+ "";
+ DoubleTypedAsyncIterable;
+ attributes.is_none();
+ args.is_some();
+ });
+
+ test!(should_parse_single_typed_async_iterable { "async iterable<long>;" =>
+ "";
+ SingleTypedAsyncIterable;
+ attributes.is_none();
+ args.is_none();
+ });
+
+ test!(should_parse_single_typed_async_iterable_with_args { "async iterable<long>(long a);" =>
+ "";
+ SingleTypedAsyncIterable;
+ attributes.is_none();
+ args.is_some();
+ });
+
+ test!(should_parse_constructor_interface_member { "constructor(long a);" =>
+ "";
+ ConstructorInterfaceMember;
+ attributes.is_none();
+ });
+
+ test!(should_parse_operation_interface_member { "undefined readString(long a, long b);" =>
+ "";
+ OperationInterfaceMember;
+ attributes.is_none();
+ modifier.is_none();
+ special.is_none();
+ identifier.is_some();
+ });
+
+ test!(should_parse_const_member { "const long name = 5;" =>
+ "";
+ ConstMember;
+ attributes.is_none();
+ identifier.0 == "name";
+ });
+}