parser: support group use statements

src/ast.rs

@@ -304,6 +304,11 @@ pub enum Statement {
         uses: Vec<Use>,
         kind: UseKind,
     },
+    GroupUse {
+        prefix: Identifier,
+        kind: UseKind,
+        uses: Vec<Use>,
+    },
     Comment {
         comment: ByteString,
     },

src/parser/mod.rs

@@ -224,31 +224,62 @@ impl Parser {
                     _ => UseKind::Normal,
                 };
 
-                let mut uses = Vec::new();
+                if self.peek.kind == TokenKind::LeftBrace {
-                while !self.is_eof() {
+                    let prefix = self.full_name()?;
-                    let name = self.full_name()?;
+                    self.next();
-                    let mut alias = None;
 
-                    if self.current.kind == TokenKind::As {
+                    let mut uses = Vec::new();
-                        self.next();
+                    while self.current.kind != TokenKind::RightBrace {
-                        alias = Some(self.ident()?.into());
+                        let name = self.full_name()?;
-                    }
+                        let mut alias = None;
-
+                        
-                    uses.push(Use {
+                        if self.current.kind == TokenKind::As {
-                        name: name.into(),
+                            self.next();
-                        alias,
+                            alias = Some(self.ident()?.into());
-                    });
+                        }
-
+
-                    if self.current.kind == TokenKind::Comma {
+                        uses.push(Use {
-                        self.next();
+                            name: name.into(),
-                        continue;
+                            alias,
+                        });
+
+                        if self.current.kind == TokenKind::Comma {
+                            self.next();
+                            continue;
+                        }
                     }
 
+                    self.rbrace()?;
                     self.semi()?;
-                    break;
-                }
 
-                Statement::Use { uses, kind }
+                    Statement::GroupUse { prefix: prefix.into(), kind, uses }
+                } else {
+                    let mut uses = Vec::new();
+                    while !self.is_eof() {
+                        let name = self.full_name()?;
+                        let mut alias = None;
+
+                        if self.current.kind == TokenKind::As {
+                            self.next();
+                            alias = Some(self.ident()?.into());
+                        }
+
+                        uses.push(Use {
+                            name: name.into(),
+                            alias,
+                        });
+
+                        if self.current.kind == TokenKind::Comma {
+                            self.next();
+                            continue;
+                        }
+
+                        self.semi()?;
+                        break;
+                    }
+
+                    Statement::Use { uses, kind }
+                }
             }
             TokenKind::Const => {
                 self.next();
@@ -5299,6 +5330,17 @@ mod tests {
         ]);
     }
 
+    #[test]
+    fn simple_group_use() {
+        assert_ast("<?php use Foo\\{Bar, Baz, Car};", &[
+            Statement::GroupUse { prefix: "Foo\\".into(), kind: crate::UseKind::Normal, uses: vec![
+                Use { name: "Bar".into(), alias: None },
+                Use { name: "Baz".into(), alias: None },
+                Use { name: "Car".into(), alias: None }
+            ]}     
+        ]);
+    }
+
     fn assert_ast(source: &str, expected: &[Statement]) {
         let mut lexer = Lexer::new(None);
         let tokens = lexer.tokenize(source).unwrap();