Parse property declarations

For now this uses the syntax

    property<qualified type name> name;

api/sixtyfps-rs/sixtyfps-rs-macro/lib.rs

@@ -34,6 +34,8 @@ fn fill_token_vec(stream: TokenStream, vec: &mut Vec<parser::Token>) {
                     ';' => SyntaxKind::Semicolon,
                     '!' => SyntaxKind::Bang,
                     '.' => SyntaxKind::Dot,
+                    '<' => SyntaxKind::LAngle,
+                    '>' => SyntaxKind::RAngle,
                     _ => SyntaxKind::Error,
                 };
                 vec.push(parser::Token {

sixtyfps_compiler/object_tree.rs

@@ -74,6 +74,7 @@ pub struct Element {
 
     /// This should probably be in the Component instead
     pub signals_declaration: Vec<String>,
+    pub property_declarations: Vec<PropertyDeclaration>,
 }
 
 impl Element {
@@ -169,6 +170,10 @@ impl Element {
             r.signals_declaration.push(name);
         }
 
+        for prop_decl in node.children().filter(|n| n.kind() == SyntaxKind::PropertyDeclaration) {
+            r.property_declarations.push(PropertyDeclaration::from_node(prop_decl));
+        }
+
         for se in node.children() {
             if se.kind() == SyntaxKind::SubElement {
                 let id = se.child_text(SyntaxKind::Identifier).unwrap_or_default();
@@ -185,6 +190,27 @@ impl Element {
     }
 }
 
+#[derive(Default, Debug, Clone)]
+pub struct PropertyDeclaration {
+    property_type: QualifiedTypeName,
+    name: String,
+}
+
+impl PropertyDeclaration {
+    pub fn from_node(node: SyntaxNode) -> Self {
+        debug_assert_eq!(node.kind(), SyntaxKind::PropertyDeclaration);
+        Self {
+            property_type: QualifiedTypeName::from_node(
+                node.children()
+                    .filter(|n| n.kind() == SyntaxKind::QualifiedTypeName)
+                    .nth(0)
+                    .unwrap(),
+            ),
+            name: node.child_text(SyntaxKind::Identifier).unwrap(),
+        }
+    }
+}
+
 #[derive(Default, Debug, Clone)]
 pub struct QualifiedTypeName {
     members: Vec<String>,

sixtyfps_compiler/parser.rs

@@ -45,6 +45,7 @@ macro_rules! declare_token_kind {
             RepeatedElement,
             SignalDeclaration,
             SignalConnection,
+            PropertyDeclaration,
             Binding,
             CodeStatement,
             CodeBlock,
@@ -74,6 +75,8 @@ declare_token_kind! {
     RBrace -> r"\}",
     LParent -> r"\(",
     RParent -> r"\)",
+    LAngle -> r"<",
+    RAngle -> r">",
     ColonEqual -> ":=",
     FatArrow -> r"=>",
     Equal -> r"=",

sixtyfps_compiler/parser/document.rs

@@ -66,6 +66,7 @@ pub fn parse_element(p: &mut impl Parser) -> bool {
 /// for xx in model: Sub {}
 /// clicked => {}
 /// signal foobar;
+/// property<int> width;
 /// ```
 fn parse_element_content(p: &mut impl Parser) {
     loop {
@@ -82,6 +83,9 @@ fn parse_element_content(p: &mut impl Parser) {
                 SyntaxKind::Identifier if p.peek().as_str() == "signal" => {
                     parse_signal_declaration(&mut *p);
                 }
+                SyntaxKind::LAngle if p.peek().as_str() == "property" => {
+                    parse_property_declaration(&mut *p);
+                }
                 _ => {
                     p.consume();
                     p.error("FIXME");
@@ -219,3 +223,18 @@ fn parse_signal_declaration(p: &mut impl Parser) {
     p.expect(SyntaxKind::Identifier);
     p.expect(SyntaxKind::Semicolon);
 }
+
+#[cfg_attr(test, parser_test)]
+/// ```test
+/// property<int> foobar;
+/// ```
+fn parse_property_declaration(p: &mut impl Parser) {
+    debug_assert_eq!(p.peek().as_str(), "property");
+    let mut p = p.start_node(SyntaxKind::PropertyDeclaration);
+    p.consume(); // property
+    p.expect(SyntaxKind::LAngle);
+    parse_qualified_type_name(&mut *p);
+    p.expect(SyntaxKind::RAngle);
+    p.expect(SyntaxKind::Identifier);
+    p.expect(SyntaxKind::Semicolon);
+}

sixtyfps_compiler/tests/basic/property_declaration.60

@@ -0,0 +1,4 @@
+
+Test := Rectangle {
+    property<int> foo;
+}