fix(parser): better handling for multi-reference objects (&&T, &&&T, etc)

- Formatter no longer inserts breakline before & in an unary & (or &&), meaning &&T isn't coerced
  into & &T. This also had the effect of removing excess whitespace in some other cases (see tests).
- Implementation: parser consumes && and pushes two & into the token queue, which is then
parsed similarly to &(&T).
- consolidated tests and added triple &&&T test

Author: Gilad Chase

crates/cairo-lang-formatter/src/node_properties.rs

@@ -758,7 +758,9 @@ impl<'a> SyntaxNodeFormat for SyntaxNode<'a> {
                         true,
                     ))
                 }
-                SyntaxKind::TerminalAnd => {
+                SyntaxKind::TerminalAnd
+                    if matches!(self.parent_kind(db), Some(SyntaxKind::ExprBinary)) =>
+                {
                     BreakLinePointsPositions::Leading(BreakLinePointProperties::new(
                         13,
                         BreakLinePointIndentation::Indented,

crates/cairo-lang-parser/src/operators.rs

@@ -4,6 +4,7 @@ pub fn get_unary_operator_precedence(kind: SyntaxKind) -> Option<usize> {
     match kind {
         SyntaxKind::TerminalAt
         | SyntaxKind::TerminalAnd
+        | SyntaxKind::TerminalAndAnd
         | SyntaxKind::TerminalNot
         | SyntaxKind::TerminalBitNot
         | SyntaxKind::TerminalMul

crates/cairo-lang-parser/src/parser.rs

@@ -1503,7 +1503,10 @@ impl<'a, 'mt> Parser<'a, 'mt> {
     fn expect_unary_operator(&mut self) -> UnaryOperatorGreen<'a> {
         match self.peek().kind {
             SyntaxKind::TerminalAt => self.take::<TerminalAt<'_>>().into(),
-            SyntaxKind::TerminalAnd => self.take::<TerminalAnd<'_>>().into(),
+            SyntaxKind::TerminalAnd | SyntaxKind::TerminalAndAnd => {
+                self.unglue_andand_for_unary();
+                self.take::<TerminalAnd<'_>>().into()
+            }
             SyntaxKind::TerminalNot => self.take::<TerminalNot<'_>>().into(),
             SyntaxKind::TerminalBitNot => self.take::<TerminalBitNot<'_>>().into(),
             SyntaxKind::TerminalMinus => self.take::<TerminalMinus<'_>>().into(),
@@ -1707,7 +1710,8 @@ impl<'a, 'mt> Parser<'a, 'mt> {
                 let expr = self.parse_type_expr();
                 Ok(ExprUnary::new_green(self.db, op, expr).into())
             }
-            SyntaxKind::TerminalAnd => {
+            SyntaxKind::TerminalAnd | SyntaxKind::TerminalAndAnd => {
+                self.unglue_andand_for_unary();
                 let op = self.take::<TerminalAnd<'_>>().into();
                 let expr = self.parse_type_expr();
                 Ok(ExprUnary::new_green(self.db, op, expr).into())
@@ -3547,6 +3551,26 @@ impl<'a, 'mt> Parser<'a, 'mt> {
         self.next_next_terminal().kind
     }
 
+    /// Consumes a '&&' token and pushes two '&' tokens into the token stream.
+    /// If the current token is not '&&', does nothing.
+    fn unglue_andand_for_unary(&mut self) {
+        if self.peek().kind != SyntaxKind::TerminalAndAnd {
+            return;
+        }
+
+        // Consume the && token and create base '&' token from it.
+        let and_terminal = LexerTerminal {
+            text: SmolStrId::from(self.db, "&"),
+            kind: SyntaxKind::TerminalAnd,
+            ..self.advance() // Consume the && token and grab its trivia.
+        };
+
+        // The second '&' (hence pushing it first) was glued to the first, so no leading trivia.
+        self.terminals.push_front(LexerTerminal { leading_trivia: vec![], ..and_terminal });
+        // The first '&' was glued to the second, hence no trailing trivia.
+        self.terminals.push_front(LexerTerminal { trailing_trivia: vec![], ..and_terminal });
+    }
+
     /// Move forward one terminal.
     fn take_raw(&mut self) -> LexerTerminal<'a> {
         self.offset = self.offset.add_width(self.current_width);

crates/cairo-lang-parser/src/parser_test_data/partial_trees/reference

@@ -4,7 +4,7 @@
 test_partial_parser_tree(expect_diagnostics: false)
 
 //! > cairo_code
-fn f(x: &u32) {}
+fn f(x: &u32, y: &&u32, z: &&&u32) {}
 
 //! > top_level_kind
 ExprUnary
@@ -21,6 +21,26 @@ ExprUnary
         └── segments (kind: ExprPathInner)
             └── item #0 (kind: PathSegmentSimple)
                 └── ident (kind: TokenIdentifier): 'u32'
+└── Top level kind: ExprUnary
+    ├── op (kind: TokenAnd): '&'
+    └── expr (kind: ExprUnary)
+        ├── op (kind: TokenAnd): '&'
+        └── expr (kind: ExprPath)
+            ├── dollar (kind: OptionTerminalDollarEmpty) []
+            └── segments (kind: ExprPathInner)
+                └── item #0 (kind: PathSegmentSimple)
+                    └── ident (kind: TokenIdentifier): 'u32'
+└── Top level kind: ExprUnary
+    ├── op (kind: TokenAnd): '&'
+    └── expr (kind: ExprUnary)
+        ├── op (kind: TokenAnd): '&'
+        └── expr (kind: ExprUnary)
+            ├── op (kind: TokenAnd): '&'
+            └── expr (kind: ExprPath)
+                ├── dollar (kind: OptionTerminalDollarEmpty) []
+                └── segments (kind: ExprPathInner)
+                    └── item #0 (kind: PathSegmentSimple)
+                        └── ident (kind: TokenIdentifier): 'u32'
 
 //! > ==========================================================================
 
@@ -30,7 +50,7 @@ ExprUnary
 test_partial_parser_tree(expect_diagnostics: false)
 
 //! > cairo_code
-fn f(x: &@u32, y: @ &u32) {}
+fn f(x: &@u32, y: @&u32) {}
 
 //! > top_level_kind
 ParamList
@@ -79,7 +99,7 @@ ParamList
 test_partial_parser_tree(expect_diagnostics: false)
 
 //! > cairo_code
-fn f() -> Option< &u64> {}
+fn f() -> Option<&u64> {}
 
 //! > top_level_kind
 ExprUnary
@@ -99,13 +119,17 @@ ExprUnary
 
 //! > ==========================================================================
 
-//! > Test double reference &&x
+//! > Test double reference with literal &&5_u32
 
 //! > test_runner_name
 test_partial_parser_tree(expect_diagnostics: false)
 
 //! > cairo_code
-fn f(x: & &u32) {}
+fn f() {
+    let x = &1_u32;
+    let y = &&2_u32;
+    let z = &&&3_u32;
+}
 
 //! > top_level_kind
 ExprUnary
@@ -115,36 +139,18 @@ ExprUnary
 //! > expected_diagnostics
 
 //! > expected_tree
+└── Top level kind: ExprUnary
+    ├── op (kind: TokenAnd): '&'
+    └── expr (kind: TokenLiteralNumber): '1_u32'
 └── Top level kind: ExprUnary
     ├── op (kind: TokenAnd): '&'
     └── expr (kind: ExprUnary)
         ├── op (kind: TokenAnd): '&'
-        └── expr (kind: ExprPath)
-            ├── dollar (kind: OptionTerminalDollarEmpty) []
-            └── segments (kind: ExprPathInner)
-                └── item #0 (kind: PathSegmentSimple)
-                    └── ident (kind: TokenIdentifier): 'u32'
-
-//! > ==========================================================================
-
-//! > Test double &T as expr
-
-//! > test_runner_name
-test_partial_parser_tree(expect_diagnostics: false)
-
-//! > cairo_code
-fn f() {
-    let x =  &1_u32;
-}
-
-//! > top_level_kind
-ExprUnary
-
-//! > ignored_kinds
-
-//! > expected_diagnostics
-
-//! > expected_tree
+        └── expr (kind: TokenLiteralNumber): '2_u32'
 └── Top level kind: ExprUnary
     ├── op (kind: TokenAnd): '&'
-    └── expr (kind: TokenLiteralNumber): '1_u32'
+    └── expr (kind: ExprUnary)
+        ├── op (kind: TokenAnd): '&'
+        └── expr (kind: ExprUnary)
+            ├── op (kind: TokenAnd): '&'
+            └── expr (kind: TokenLiteralNumber): '3_u32'