feat(parser): collect @Property rules as variable definitions (#38)

Phase 2 of #38: synthesise one Property per @Property rule, with
ident pointing at the prelude --name and value pointing at the
initial-value declaration (or empty if absent). Custom properties
declared via @Property now show up in LSP completion / hover /
go-to-definition / rename, and don't trip no-undefined-variable-use
when referenced.

Other at-rules continue to be skipped.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: jo16oh

crates/css-var-kit/src/parser/css.rs

@@ -11,6 +11,17 @@ struct Scanner<'a> {
     col: u32,
 }
 
+struct AtPropertyParts {
+    name_start: usize,
+    name_end: usize,
+    name_line: u32,
+    name_col: u32,
+    value_start: usize,
+    value_end: usize,
+    value_line: u32,
+    value_col: u32,
+}
+
 impl<'a> Scanner<'a> {
     fn new_with_offset(css: &'a OwnedStr, line_offset: u32, column_offset: u32) -> Self {
         Self {
@@ -169,6 +180,110 @@ impl<'a> Scanner<'a> {
         }
     }
 
+    fn skip_inline_and_newlines(&mut self) {
+        while !self.is_eof() && matches!(self.bytes[self.pos], b' ' | b'\t' | b'\n' | b'\r') {
+            self.advance(1);
+        }
+    }
+
+    /// Scans an `@property --name { … initial-value: V; … }` rule.
+    /// The leading `@property` token has already been consumed.
+    /// Returns prelude name + `initial-value` spans (the value span is empty
+    /// when no `initial-value` declaration is present). The closing `}` is
+    /// consumed. Returns `None` only when the prelude lacks an identifier or
+    /// the body never opens.
+    fn scan_at_property_rule(&mut self) -> Option<AtPropertyParts> {
+        self.skip_inline_and_newlines();
+
+        let name_start = self.pos;
+        let name_line = self.line;
+        let name_col = self.col;
+        while !self.is_eof() {
+            if self.bytes[self.pos] == b'\\' {
+                self.skip_escape();
+            } else if is_ident_char(self.bytes[self.pos]) {
+                self.advance(1);
+            } else {
+                break;
+            }
+        }
+        let name_end = self.pos;
+        if name_start == name_end {
+            self.skip_at_rule_prelude();
+            self.skip_at_rule_body();
+            return None;
+        }
+
+        self.skip_at_rule_prelude();
+        if self.is_eof() || self.bytes[self.pos] != b'{' {
+            return None;
+        }
+        self.advance(1); // consume '{'
+
+        let mut value_start = self.pos;
+        let mut value_end = self.pos;
+        let mut value_line = self.line;
+        let mut value_col = self.col;
+
+        let mut depth = 1i32;
+        while !self.is_eof() && depth > 0 {
+            match self.bytes[self.pos] {
+                b'"' | b'\'' => self.skip_string_literal(),
+                b'/' if self.peek_at(1) == Some(b'*') => self.skip_comment(),
+                b'{' => {
+                    depth += 1;
+                    self.advance(1);
+                }
+                b'}' => {
+                    depth -= 1;
+                    self.advance(1);
+                }
+                _ if depth == 1 && is_ident_start(self.bytes[self.pos]) => {
+                    let prop_name_start = self.pos;
+                    while !self.is_eof() {
+                        if self.bytes[self.pos] == b'\\' {
+                            self.skip_escape();
+                        } else if is_ident_char(self.bytes[self.pos]) {
+                            self.advance(1);
+                        } else {
+                            break;
+                        }
+                    }
+                    let prop_name_end = self.pos;
+                    self.skip_whitespace();
+                    if !self.is_eof() && self.bytes[self.pos] == b':' {
+                        self.advance(1);
+                        self.skip_whitespace();
+                        let line = self.line;
+                        let col = self.col;
+                        let start = self.pos;
+                        let end = self.scan_value_end();
+                        let prop_name = &self.bytes[prop_name_start..prop_name_end];
+                        if prop_name.eq_ignore_ascii_case(b"initial-value") {
+                            // Last `initial-value` wins, matching CSS cascade.
+                            value_start = start;
+                            value_end = end;
+                            value_line = line;
+                            value_col = col;
+                        }
+                    }
+                }
+                _ => self.advance(1),
+            }
+        }
+
+        Some(AtPropertyParts {
+            name_start,
+            name_end,
+            name_line,
+            name_col,
+            value_start,
+            value_end,
+            value_line,
+            value_col,
+        })
+    }
+
     fn scan_value_end(&mut self) -> usize {
         let mut paren_depth = 0i32;
 
@@ -314,11 +429,36 @@ fn parse_impl(
                 }
             }
             b'@' => {
-                pending_ignores.clear();
+                let ignore_comments = std::mem::take(&mut pending_ignores);
                 let name = s.read_at_rule_name();
-                s.skip_at_rule_prelude();
-                if !is_transparent_at_rule(name) {
-                    s.skip_at_rule_body();
+                if name.eq_ignore_ascii_case("property") {
+                    if let Some(parts) = s.scan_at_property_rule() {
+                        let raw_name = css.slice(parts.name_start..parts.name_end);
+                        let raw_value = css.map(|s| s[parts.value_start..parts.value_end].trim());
+                        properties.push(Property {
+                            file_path: file_path.clone(),
+                            source: source.clone(),
+                            ident: PropertyIdent::new(
+                                raw_name,
+                                parts.name_start + byte_offset,
+                                parts.name_line,
+                                parts.name_col,
+                            ),
+                            value: PropertyValue {
+                                raw: raw_value,
+                                offset: parts.value_start + byte_offset,
+                                line: parts.value_line,
+                                column: parts.value_col,
+                            },
+                            ignore_comments,
+                            token_list: OnceCell::new(),
+                        });
+                    }
+                } else {
+                    s.skip_at_rule_prelude();
+                    if !is_transparent_at_rule(name) {
+                        s.skip_at_rule_body();
+                    }
                 }
             }
             b'{' => {
@@ -829,21 +969,116 @@ mod tests {
     }
 
     #[test]
-    fn at_property_rule_skipped() {
+    fn at_property_rule_collects_definition() {
         let css = "@property --my-color {\n  syntax: \"<color>\";\n  inherits: false;\n  initial-value: red;\n}\n.a { color: var(--my-color); }";
         let result = test_parse(css);
-        assert_eq!(result.properties.len(), 1);
-        assert_eq!(result.properties[0].ident.raw.as_str(), "color");
-        assert_eq!(result.properties[0].value.raw.as_str(), "var(--my-color)");
+        assert_eq!(result.properties.len(), 2);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--my-color");
+        assert_eq!(result.properties[0].value.raw.as_str(), "red");
+        assert_eq!(result.properties[1].ident.raw.as_str(), "color");
+        assert_eq!(result.properties[1].value.raw.as_str(), "var(--my-color)");
     }
 
     #[test]
-    fn at_property_between_selectors() {
+    fn at_property_between_selectors_collects_definition() {
         let css = ".before { margin: 0; }\n@property --x {\n  syntax: \"*\";\n  inherits: true;\n}\n.after { padding: 0; }";
         let result = test_parse(css);
-        assert_eq!(result.properties.len(), 2);
+        assert_eq!(result.properties.len(), 3);
         assert_eq!(result.properties[0].ident.raw.as_str(), "margin");
-        assert_eq!(result.properties[1].ident.raw.as_str(), "padding");
+        assert_eq!(result.properties[1].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[1].value.raw.as_str(), "");
+        assert_eq!(result.properties[2].ident.raw.as_str(), "padding");
+    }
+
+    #[test]
+    fn at_property_extracts_initial_value() {
+        let css = "@property --logo-color {\n  syntax: \"<color>\";\n  inherits: false;\n  initial-value: #c0ffee;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        let p = &result.properties[0];
+        assert_eq!(p.ident.raw.as_str(), "--logo-color");
+        assert_eq!(p.value.raw.as_str(), "#c0ffee");
+        // name on line 0, after "@property " (10 cols)
+        assert_eq!(p.ident.line, 0);
+        assert_eq!(p.ident.column, 10);
+        // value on line 3, after "  initial-value: " (17 cols)
+        assert_eq!(p.value.line, 3);
+        assert_eq!(p.value.column, 17);
+    }
+
+    #[test]
+    fn at_property_without_initial_value() {
+        let css = "@property --x {\n  syntax: \"*\";\n  inherits: true;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[0].value.raw.as_str(), "");
+    }
+
+    #[test]
+    fn at_property_initial_value_with_var() {
+        let css = "@property --x {\n  syntax: \"<color>\";\n  initial-value: var(--base, red);\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[0].value.raw.as_str(), "var(--base, red)");
+    }
+
+    #[test]
+    fn at_property_with_string_in_syntax() {
+        let css =
+            "@property --x {\n  syntax: \"<length> | <percentage>\";\n  initial-value: 8px;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[0].value.raw.as_str(), "8px");
+    }
+
+    #[test]
+    fn at_property_invalid_name() {
+        let css = "@property foo {\n  initial-value: red;\n}\n.a { color: red; }";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 2);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "foo");
+        assert_eq!(result.properties[0].value.raw.as_str(), "red");
+        assert_eq!(result.properties[1].ident.raw.as_str(), "color");
+    }
+
+    #[test]
+    fn at_property_last_initial_value_wins() {
+        let css = "@property --x {\n  initial-value: red;\n  initial-value: blue;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].value.raw.as_str(), "blue");
+    }
+
+    #[test]
+    fn at_property_cvk_ignore_propagates() {
+        let css = "/* cvk-ignore */\n@property --x {\n  initial-value: red;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(
+            result.properties[0].ignore_comments,
+            map_owned_str(vec!["cvk-ignore"])
+        );
+    }
+
+    #[test]
+    fn at_property_inside_media() {
+        let css = "@media (prefers-color-scheme: dark) {\n  @property --x {\n    initial-value: white;\n  }\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[0].value.raw.as_str(), "white");
+    }
+
+    #[test]
+    fn at_property_uppercase() {
+        let css = "@PROPERTY --x {\n  initial-value: red;\n}";
+        let result = test_parse(css);
+        assert_eq!(result.properties.len(), 1);
+        assert_eq!(result.properties[0].ident.raw.as_str(), "--x");
+        assert_eq!(result.properties[0].value.raw.as_str(), "red");
     }
 
     #[test]