chore!: Remove DeprecatedVectorStart

compiler/noirc_frontend/src/hir/comptime/display.rs

@@ -322,7 +322,6 @@ impl<'interner> TokenPrettyPrinter<'interner> {
             | Token::Slash
             | Token::Percent
             | Token::Ampersand
-            | Token::DeprecatedVectorStart
             | Token::ShiftLeft
             | Token::ShiftRight
             | Token::LogicalAnd => {

compiler/noirc_frontend/src/lexer/lexer.rs

@@ -111,8 +111,6 @@
             let start = self.position;
             self.next_char();
             Ok(Token::LogicalAnd.into_span(start, start + 1))
-        } else if self.peek_char_is('[') {
-            self.single_char_token(Token::DeprecatedVectorStart)
         } else {
             self.single_char_token(Token::Ampersand)
         }
@@ -188,7 +186,7 @@
                 self.next_char();
                 Err(LexerErrorKind::UnicodeCharacterLooksLikeSpaceButIsItNot { char: ch, location })
             }
             Some(ch) if Self::is_bidi_control(ch) => Err(LexerErrorKind::BidiControlCharacter {
                 char: ch,
                 location: self.location(Span::single_char(self.position)),
             }),
@@ -534,8 +532,8 @@
                             });
                         }
                     },
                     other if Self::is_bidi_control(other) => {
                         return Err(LexerErrorKind::BidiControlCharacter {
                             char: other,
                             location: self.location(Span::single_char(self.position)),
                         });
@@ -624,8 +622,8 @@
                             found_curly = true;
                             break;
                         }
                         other if Self::is_bidi_control(other) => {
                             return Err(LexerErrorKind::BidiControlCharacter {
                                 char: other,
                                 location: self.location(Span::single_char(self.position)),
                             });
@@ -782,8 +780,8 @@
                     break;
                 }
                 self.next_char();
                 if Self::is_bidi_control(ch) {
                     return Err(LexerErrorKind::BidiControlCharacter {
                         char: ch,
                         location: self.location(Span::single_char(self.position)),
                     });
@@ -913,8 +911,8 @@
                     location: self.location(Span::single_char(self.position)),
                 });
             }
             if Self::is_bidi_control(ch) {
                 return Err(LexerErrorKind::BidiControlCharacter {
                     char: ch,
                     location: self.location(Span::single_char(self.position)),
                 });

compiler/noirc_frontend/src/lexer/token.rs

@@ -110,8 +110,6 @@ pub enum Token {
     Percent,
     /// &
     Ampersand,
-    /// &
-    DeprecatedVectorStart,
     /// @
     At,
     /// ^
@@ -388,7 +386,6 @@ impl Display for Token {
             Token::Backslash => write!(f, "\\"),
             Token::Percent => write!(f, "%"),
             Token::Ampersand => write!(f, "&"),
-            Token::DeprecatedVectorStart => write!(f, "&"),
             Token::At => write!(f, "@"),
             Token::Caret => write!(f, "^"),
             Token::ShiftLeft => write!(f, "<<"),

compiler/noirc_frontend/src/parser/parser/expression.rs

@@ -961,9 +961,7 @@ impl Parser<'_> {
 
     /// VectorExpression = '@' ArrayLiteral
     fn parse_vector_literal(&mut self) -> Option<ArrayLiteralOrError> {
-        if !((self.at(Token::At) || self.at(Token::DeprecatedVectorStart))
-            && self.next_is(Token::LeftBracket))
-        {
+        if !(self.at(Token::At) && self.next_is(Token::LeftBracket)) {
             return None;
         }
 

compiler/noirc_frontend/src/parser/parser/types.rs

@@ -235,8 +235,7 @@ impl Parser<'_> {
             return Some(typ);
         }
 
-        // The `&` may be lexed as a vector start if this is an array or vector type
-        if self.eat(Token::Ampersand) || self.eat(Token::DeprecatedVectorStart) {
+        if self.eat(Token::Ampersand) {
             let mutable = self.eat_keyword(Keyword::Mut);
 
             return Some(UnresolvedTypeData::Reference(

tooling/lsp/src/requests/semantic_tokens.rs

@@ -391,7 +391,6 @@ impl<'args> SemanticTokenCollector<'args> {
             | Token::Bang
             | Token::DollarSign
             | Token::At
-            | Token::DeprecatedVectorStart
             | Token::EOF
             | Token::Whitespace(_)
             | Token::UnquoteMarker(_)

tooling/nargo_doc/src/html/colorize.rs

@@ -154,7 +154,6 @@ fn colorize_token(token: &LocatedToken, line: &str, result: &mut String) {
         | Token::Backslash
         | Token::Percent
         | Token::Ampersand
-        | Token::DeprecatedVectorStart
         | Token::At
         | Token::Caret
         | Token::ShiftLeft

tooling/nargo_fmt/src/formatter/expression.rs

@@ -157,13 +157,7 @@ impl ChunkFormatter<'_, '_> {
 
         group.text(self.chunk(|formatter| {
             if is_vector {
-                if formatter.is_at(Token::DeprecatedVectorStart) {
-                    // Support the old vector syntax `&[1, 2, 3]`
-                    formatter.bump();
-                    formatter.write("@");
-                } else {
-                    formatter.write_token(Token::At);
-                }
+                formatter.write_token(Token::At);
             }
             formatter.write_left_bracket();
         }));
@@ -1573,13 +1567,6 @@ mod tests {
         assert_format(src, expected);
     }
 
-    #[test]
-    fn format_old_vector_syntax() {
-        let src = "global x = &[ 1 , 2 , 3 , ] ;";
-        let expected = "global x = @[1, 2, 3];\n";
-        assert_format(src, expected);
-    }
-
     #[test]
     fn format_repeated_array() {
         let src = "global x = [ 1 ; 3 ] ;";

tooling/nargo_fmt/src/formatter/types.rs

@@ -69,19 +69,7 @@ impl Formatter<'_> {
                 self.format_generic_type_args(generic_type_args);
             }
             UnresolvedTypeData::Reference(typ, mutable) => {
-                // `&` can be represented with Ampersand or VectorStart in the lexer depending
-                // on whether it's right next to a `[` or not.
-                match &self.token {
-                    Token::Ampersand => {
-                        self.write_token(Token::Ampersand);
-                    }
-                    Token::DeprecatedVectorStart => {
-                        self.write_token(Token::DeprecatedVectorStart);
-                    }
-                    _ => {
-                        panic!("Expected Ampersand or VectorStart, found {:?}", self.token);
-                    }
-                }
+                self.write_token(Token::Ampersand);
                 if mutable {
                     self.write_keyword(Keyword::Mut);
                     self.write_space();