refactor(rsliint_parser): Refine variable declaration AST Tree

Changes the js grammar of the variable declaration to match our new AST facade as defined in #1725 (and proposed in #1719)

* Split `VarDecl` into `JsVariableDeclarationStatement` and `JsVariableDeclaration` to correctly account for variable declarations inside for loops (that aren't statements).
* Change the parser to emit a `let` token instead of an ident if let is used inside a variable declaration (let is a valid identifier which is why the lexer returns an `ident` token)
* Rename `Declarator` to `JsVariableDeclarator`
* Split out the `init` into a `JsEqualValueClause` that holds the `=` token and the initializer expression.

crates/rome_formatter/src/cst.rs

@@ -1,13 +1,13 @@
 use crate::{token, FormatElement, FormatResult, Formatter, ToFormatElement};
 use rslint_parser::ast::{
 	ArgList, ArrayExpr, ArrayPattern, ArrowExpr, AssignPattern, CallExpr, ClassBody, ClassDecl,
-	ClassProp, Condition, ConstructorParameters, Declarator, FnDecl, ForInStmt, ForStmt,
-	ForStmtInit, ForStmtTest, ForStmtUpdate, Getter, IdentProp, JsBlockStatement, JsCaseClause,
-	JsCatchClause, JsContinueStatement, JsDebuggerStatement, JsDefaultClause, JsDoWhileStatement,
+	ClassProp, Condition, ConstructorParameters, FnDecl, ForInStmt, ForStmt, ForStmtInit,
+	ForStmtTest, ForStmtUpdate, Getter, IdentProp, JsBlockStatement, JsCaseClause, JsCatchClause,
+	JsContinueStatement, JsDebuggerStatement, JsDefaultClause, JsDoWhileStatement,
 	JsEmptyStatement, JsExpressionStatement, JsFinallyClause, JsIfStatement, JsLabeledStatement,
-	JsReturnStatement, JsScript, JsSwitchStatement, JsTryStatement, JsWhileStatement,
-	JsWithStatement, Literal, LiteralProp, Name, NameRef, ObjectExpr, ParameterList, SequenceExpr,
-	Setter, SinglePattern, VarDecl,
+	JsReturnStatement, JsScript, JsSwitchStatement, JsTryStatement, JsVariableDeclarationStatement,
+	JsVariableDeclarator, JsWhileStatement, JsWithStatement, Literal, LiteralProp, Name, NameRef,
+	ObjectExpr, ParameterList, SequenceExpr, Setter, SinglePattern,
 };
 use rslint_parser::{AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
 
@@ -44,10 +44,12 @@ impl ToFormatElement for SyntaxNode {
 			SyntaxKind::SPREAD_ELEMENT => SinglePattern::cast(self.clone())
 				.unwrap()
 				.to_format_element(formatter),
-			SyntaxKind::VAR_DECL => VarDecl::cast(self.clone())
-				.unwrap()
-				.to_format_element(formatter),
-			SyntaxKind::DECLARATOR => Declarator::cast(self.clone())
+			SyntaxKind::JS_VARIABLE_DECLARATION_STATEMENT => {
+				JsVariableDeclarationStatement::cast(self.clone())
+					.unwrap()
+					.to_format_element(formatter)
+			}
+			SyntaxKind::JS_VARIABLE_DECLARATOR => JsVariableDeclarator::cast(self.clone())
 				.unwrap()
 				.to_format_element(formatter),
 			SyntaxKind::FN_DECL => FnDecl::cast(self.clone())

crates/rome_formatter/src/ts/declarators/declarator.rs → crates/rome_formatter/src/ts/auxiliary/equal_value_clause.rs

@@ -1,16 +1,14 @@
 use crate::{
 	format_elements, space_token, FormatElement, FormatResult, Formatter, ToFormatElement,
 };
-use rslint_parser::ast::Declarator;
+use rslint_parser::ast::JsEqualValueClause;
 
-impl ToFormatElement for Declarator {
+impl ToFormatElement for JsEqualValueClause {
 	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
 		Ok(format_elements![
-			formatter.format_node(self.pattern()?)?,
-			space_token(),
 			formatter.format_token(&self.eq_token()?)?,
 			space_token(),
-			formatter.format_node(self.value()?)?,
+			formatter.format_node(self.expression()?)?
 		])
 	}
 }

crates/rome_formatter/src/ts/auxiliary/mod.rs

@@ -0,0 +1 @@
+mod equal_value_clause;

crates/rome_formatter/src/ts/declarators/decl.rs

@@ -6,7 +6,7 @@ impl ToFormatElement for Decl {
 		match self {
 			Decl::FnDecl(fn_decl) => fn_decl.to_format_element(formatter),
 			Decl::ClassDecl(class_declarator) => class_declarator.to_format_element(formatter),
-			Decl::VarDecl(var_decl) => var_decl.to_format_element(formatter),
+			Decl::JsVariableDeclarationStatement(var_decl) => var_decl.to_format_element(formatter),
 			Decl::TsEnum(_) => todo!(),
 			Decl::TsTypeAliasDecl(_) => todo!(),
 			Decl::TsNamespaceDecl(_) => todo!(),

crates/rome_formatter/src/ts/declarators/mod.rs

@@ -1,4 +1,3 @@
 mod decl;
-mod declarator;
 mod fn_decl;
-mod var_decl;
+mod variable_declaration_statement;

crates/rome_formatter/src/ts/declarators/variable_declaration_statement.rs

@@ -0,0 +1,47 @@
+use crate::{
+	empty_element, format_elements, join_elements, space_token, token, FormatElement, FormatResult,
+	Formatter, ToFormatElement,
+};
+use rslint_parser::ast::{
+	JsVariableDeclaration, JsVariableDeclarationStatement, JsVariableDeclarator,
+};
+
+impl ToFormatElement for JsVariableDeclarationStatement {
+	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+		Ok(format_elements![
+			formatter.format_node(self.declaration()?)?,
+			token(";"),
+		])
+	}
+}
+
+impl ToFormatElement for JsVariableDeclaration {
+	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+		let mut declarators = Vec::with_capacity(self.declarators().len());
+
+		for declarator in self.declarators().iter() {
+			declarators.push(formatter.format_node(declarator)?);
+		}
+
+		Ok(format_elements![
+			formatter.format_token(&self.kind_token()?)?,
+			space_token(),
+			join_elements(format_elements![token(","), space_token()], declarators),
+		])
+	}
+}
+
+impl ToFormatElement for JsVariableDeclarator {
+	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+		let initializer = if let Some(initializer) = self.init() {
+			format_elements![space_token(), formatter.format_node(initializer)?]
+		} else {
+			empty_element()
+		};
+
+		Ok(format_elements![
+			formatter.format_node(self.id()?)?,
+			initializer
+		])
+	}
+}

crates/rome_formatter/src/ts/mod.rs

@@ -1,4 +1,5 @@
 mod arg_list;
+mod auxiliary;
 mod class;
 mod condition;
 mod declarators;

crates/rome_formatter/src/ts/statements/for_stmt.rs

@@ -52,7 +52,7 @@ impl ToFormatElement for ForStmtInit {
 impl ToFormatElement for ForHead {
 	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
 		match self {
-			ForHead::VarDecl(decl) => decl.to_format_element(formatter),
+			ForHead::JsVariableDeclaration(decl) => decl.to_format_element(formatter),
 			ForHead::JsAnyExpression(expr) => expr.to_format_element(formatter),
 		}
 	}

crates/rslint_parser/src/ast.rs

@@ -349,7 +349,7 @@ impl<N: AstNode> IntoIterator for &AstSeparatedList<N> {
 /// Specific result used when navigating nodes using AST APIs
 pub type SyntaxResult<ResultType> = Result<ResultType, SyntaxError>;
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub enum SyntaxError {
 	/// Error thrown when a mandatory node is not found
 	MissingRequiredChild(SyntaxNode),
@@ -364,14 +364,12 @@ mod support {
 	use crate::SyntaxList;
 	use crate::{SyntaxError, SyntaxResult};
 
-	// TODO: #1725 remove once API are set in stone
-	#[allow(dead_code)]
-	pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
+	pub(super) fn node<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
 		parent.children().find_map(N::cast)
 	}
 
-	pub(super) fn as_optional_node<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
-		parent.children().find_map(N::cast)
+	pub(super) fn required_node<N: AstNode>(parent: &SyntaxNode) -> SyntaxResult<N> {
+		node(parent).ok_or_else(|| SyntaxError::MissingRequiredChild(parent.clone()))
 	}
 
 	pub(super) fn elements(parent: &SyntaxNode) -> SyntaxElementChildren {
@@ -409,29 +407,11 @@ mod support {
 			.find(|it| it.kind() == kind)
 	}
 
-	pub(super) fn as_optional_token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
-		parent
-			.children_with_tokens()
-			.filter_map(|it| it.into_token())
-			.find(|it| it.kind() == kind)
-	}
-
-	pub(super) fn as_mandatory_node<N: AstNode>(parent: &SyntaxNode) -> SyntaxResult<N> {
-		parent
-			.children()
-			.find_map(N::cast)
-			.ok_or_else(|| SyntaxError::MissingRequiredChild(parent.clone()))
-	}
-
-	pub(super) fn as_mandatory_token(
+	pub(super) fn required_token(
 		parent: &SyntaxNode,
 		kind: SyntaxKind,
 	) -> SyntaxResult<SyntaxToken> {
-		parent
-			.children_with_tokens()
-			.filter_map(|it| it.into_token())
-			.find(|it| it.kind() == kind)
-			.ok_or_else(|| SyntaxError::MissingRequiredChild(parent.clone()))
+		token(parent, kind).ok_or_else(|| SyntaxError::MissingRequiredChild(parent.clone()))
 	}
 
 	pub(super) fn find_token(
@@ -447,6 +427,14 @@ mod support {
 					.any(|possible_kind| *possible_kind == it.kind())
 			})
 	}
+
+	pub(super) fn find_required_token(
+		parent: &SyntaxNode,
+		possible_kinds: &[SyntaxKind],
+	) -> SyntaxResult<SyntaxToken> {
+		find_token(parent, possible_kinds)
+			.ok_or_else(|| SyntaxError::MissingRequiredChild(parent.clone()))
+	}
 }
 
 #[cfg(test)]

crates/rslint_parser/src/ast/expr_ext.rs

@@ -5,7 +5,7 @@ use SyntaxKind::*;
 
 impl BracketExpr {
 	pub fn object(&self) -> Option<JsAnyExpression> {
-		support::child(self.syntax())
+		support::node(self.syntax())
 	}
 
 	pub fn prop(&self) -> Option<JsAnyExpression> {
@@ -15,7 +15,7 @@ impl BracketExpr {
 
 impl CondExpr {
 	pub fn test(&self) -> Option<JsAnyExpression> {
-		support::child(self.syntax())
+		support::node(self.syntax())
 	}
 
 	pub fn cons(&self) -> Option<JsAnyExpression> {
@@ -29,7 +29,7 @@ impl CondExpr {
 
 impl LiteralProp {
 	pub fn key(&self) -> SyntaxResult<PropName> {
-		support::as_mandatory_node::<PropName>(self.syntax())
+		support::required_node::<PropName>(self.syntax())
 	}
 
 	pub fn value(&self) -> SyntaxResult<JsAnyExpression> {
@@ -144,7 +144,7 @@ impl BinExpr {
 	}
 
 	pub fn lhs(&self) -> Option<JsAnyExpression> {
-		support::child(self.syntax())
+		support::node(self.syntax())
 	}
 
 	pub fn rhs(&self) -> Option<JsAnyExpression> {