Add ConstructorInterfaceMember

Author: alexlapa

src/interface.rs

@@ -37,6 +37,15 @@ ast_types! {
             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
@@ -169,6 +178,12 @@ mod test {
         attributes.is_none();
     });
 
+    test!(should_parse_constructor_interface_member { "constructor(long a);" =>
+        "";
+        ConstructorInterfaceMember;
+        attributes.is_none();
+    });
+
     test!(should_parse_operation_interface_member { "void readString(long a, long b);" =>
         "";
         OperationInterfaceMember;

src/term.rs

@@ -300,6 +300,9 @@ generate_terms_for_names! {
 
     /// Represents the terminal symbol `legacycaller`
     LegacyCaller => "legacycaller",
+
+    /// Represents the terminal symbol `constructor`
+    Constructor => "constructor",
 }
 
 #[macro_export]
@@ -550,6 +553,9 @@ macro_rules! term {
     (legacycaller) => {
         $crate::term::LegacyCaller
     };
+    (constructor) => {
+        $crate::term::Constructor
+    };
 }
 
 #[cfg(test)]
@@ -680,5 +686,6 @@ mod test {
         error, Error, "Error";
         implements, Implements, "implements";
         legacycaller, LegacyCaller, "legacycaller";
+        constructor, Constructor, "constructor";
     ];
 }

tests/defs/interface-constructor.webidl

@@ -0,0 +1,4 @@
+interface InterfaceWithConstructor {
+  [Throws]
+  constructor(long a);
+};

tests/webidl.rs

@@ -3,6 +3,8 @@ extern crate weedle;
 use std::fs;
 use std::io::Read;
 
+use weedle::*;
+
 fn read_file(path: &str) -> String {
     let mut file = fs::File::open(path).unwrap();
     let mut file_content = String::new();
@@ -33,3 +35,65 @@ fn should_parse_mediacapture_streams_webidl() {
 
     assert_eq!(parsed.len(), 37);
 }
+
+#[test]
+fn interface_constructor() {
+    let content = read_file("./tests/defs/interface-constructor.webidl");
+    let mut parsed = weedle::parse(&content).unwrap();
+
+    assert_eq!(parsed.len(), 1);
+
+    let definition = parsed.pop().unwrap();
+
+    match definition {
+        Definition::Interface(mut interface) => {
+            assert!(interface.attributes.is_none());
+            assert_eq!(interface.interface, term!(interface));
+            assert_eq!(interface.identifier.0, "InterfaceWithConstructor");
+            assert_eq!(interface.inheritance, None);
+
+            assert_eq!(interface.members.body.len(), 1);
+
+            let body = interface.members.body.pop().unwrap();
+
+            match body {
+                interface::InterfaceMember::Constructor(constructor) => {
+                    let mut attributes = constructor.attributes.unwrap().body.list;
+                    assert_eq!(attributes.len(), 1);
+                    let attribute = attributes.pop().unwrap();
+
+                    match attribute {
+                        attribute::ExtendedAttribute::NoArgs(attribute) => {
+                            assert_eq!((attribute.0).0, "Throws");
+                        }
+                        _ => unreachable!(),
+                    }
+
+                    let mut args = constructor.args.body.list;
+                    assert_eq!(args.len(), 1);
+                    let arg = args.pop().unwrap();
+
+                    match arg {
+                        argument::Argument::Single(arg) => {
+                            assert!(arg.attributes.is_none());
+                            assert!(arg.optional.is_none());
+                            assert!(arg.type_.attributes.is_none());
+
+                            match arg.type_.type_ {
+                                types::Type::Single(types::SingleType::NonAny(
+                                    types::NonAnyType::Integer(_),
+                                )) => {}
+                                _ => unreachable!(),
+                            }
+                        }
+                        _ => unreachable!(),
+                    };
+
+                    assert_eq!(constructor.constructor, term::Constructor);
+                }
+                _ => unreachable!(),
+            }
+        }
+        _ => unreachable!(),
+    }
+}