From f210404ae784ccb2a53dbdd3b54b803dac46c0ad Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha@rome.tools>
Date: Mon, 15 Nov 2021 14:54:45 +0100
Subject: [PATCH] Rename `ArrowExpr` to `JsArrowFunctionExpression`

---
 crates/rome_formatter/src/cst.rs              |  28 +-
 crates/rome_formatter/src/ts/expr_or_block.rs |  11 -
 .../src/ts/expressions/arrow_expr.rs          |  21 +-
 .../src/ts/expressions/expression.rs          |   2 +-
 crates/rome_formatter/src/ts/mod.rs           |   3 +-
 crates/rslint_parser/src/ast/expr_ext.rs      |   6 +-
 .../rslint_parser/src/ast/generated/nodes.rs  | 567 +++++++++---------
 crates/rslint_parser/src/syntax/expr.rs       |  24 +-
 .../err/async_arrow_expr_await_parameter.rast |   4 +-
 .../err/binding_identifier_invalid.rast       |   2 +-
 .../inline/err/invalid_method_recover.rast    |   2 +-
 .../paren_or_arrow_expr_invalid_params.rast   |   2 +-
 .../inline/ok/arrow_expr_single_param.rast    |  16 +-
 .../test_data/inline/ok/async_arrow_expr.rast |   8 +-
 .../test_data/inline/ok/directives.rast       |   2 +-
 .../test_data/inline/ok/new_exprs.rast        |   2 +-
 .../inline/ok/paren_or_arrow_expr.rast        |   6 +-
 .../test_data/inline/ok/return_stmt.rast      |   2 +-
 crates/rslint_syntax/src/generated.rs         |   2 +-
 xtask/js.ungram                               |  26 +-
 xtask/src/codegen/kinds_src.rs                |   2 +-
 21 files changed, 374 insertions(+), 364 deletions(-)
 delete mode 100644 crates/rome_formatter/src/ts/expr_or_block.rs

diff --git a/crates/rome_formatter/src/cst.rs b/crates/rome_formatter/src/cst.rs
index d1f23cff0e85..76cb2fa965d3 100644
--- a/crates/rome_formatter/src/cst.rs
+++ b/crates/rome_formatter/src/cst.rs
@@ -1,15 +1,15 @@
 use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
 use rslint_parser::ast::{
-	ArgList, ArrayPattern, ArrowExpr, AssignPattern, CallExpr, ClassBody, ClassDecl, ClassProp,
-	Condition, ConstructorParameters, ForInStmt, ForStmt, ForStmtInit, ForStmtTest, ForStmtUpdate,
-	Getter, IdentProp, JsArrayExpression, JsBlockStatement, JsBooleanLiteral, JsCaseClause,
-	JsCatchClause, JsContinueStatement, JsDebuggerStatement, JsDefaultClause, JsDoWhileStatement,
-	JsEmptyStatement, JsExpressionStatement, JsFinallyClause, JsFunctionDeclaration, JsIfStatement,
-	JsLabeledStatement, JsNullLiteral, JsNumberLiteral, JsParameterList,
-	JsReferenceIdentifierExpression, JsReturnStatement, JsRoot, JsSequenceExpression,
-	JsStringLiteral, JsSwitchStatement, JsTryStatement, JsVariableDeclarationStatement,
-	JsVariableDeclarator, JsWhileStatement, JsWithStatement, LiteralProp, Name, ObjectExpr, Setter,
-	SinglePattern,
+	ArgList, ArrayPattern, AssignPattern, CallExpr, ClassBody, ClassDecl, ClassProp, Condition,
+	ConstructorParameters, ForInStmt, ForStmt, ForStmtInit, ForStmtTest, ForStmtUpdate, Getter,
+	IdentProp, JsArrayExpression, JsArrowFunctionExpression, JsBlockStatement, JsBooleanLiteral,
+	JsCaseClause, JsCatchClause, JsContinueStatement, JsDebuggerStatement, JsDefaultClause,
+	JsDoWhileStatement, JsEmptyStatement, JsExpressionStatement, JsFinallyClause,
+	JsFunctionDeclaration, JsIfStatement, JsLabeledStatement, JsNullLiteral, JsNumberLiteral,
+	JsParameterList, JsReferenceIdentifierExpression, JsReturnStatement, JsRoot,
+	JsSequenceExpression, JsStringLiteral, JsSwitchStatement, JsTryStatement,
+	JsVariableDeclarationStatement, JsVariableDeclarator, JsWhileStatement, JsWithStatement,
+	LiteralProp, Name, ObjectExpr, Setter, SinglePattern,
 };
 use rslint_parser::{AstNode, SyntaxKind, SyntaxNode};
 
@@ -19,9 +19,11 @@ impl ToFormatElement for SyntaxNode {
 			SyntaxKind::JS_ARRAY_EXPRESSION => JsArrayExpression::cast(self.clone())
 				.unwrap()
 				.to_format_element(formatter),
-			SyntaxKind::ARROW_EXPR => ArrowExpr::cast(self.clone())
-				.unwrap()
-				.to_format_element(formatter),
+			SyntaxKind::JS_ARROW_FUNCTION_EXPRESSION => {
+				JsArrowFunctionExpression::cast(self.clone())
+					.unwrap()
+					.to_format_element(formatter)
+			}
 			SyntaxKind::ASSIGN_PATTERN => AssignPattern::cast(self.clone())
 				.unwrap()
 				.to_format_element(formatter),
diff --git a/crates/rome_formatter/src/ts/expr_or_block.rs b/crates/rome_formatter/src/ts/expr_or_block.rs
deleted file mode 100644
index bdc4d97ff3eb..000000000000
--- a/crates/rome_formatter/src/ts/expr_or_block.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
-use rslint_parser::ast::ExprOrBlock;
-
-impl ToFormatElement for ExprOrBlock {
-	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
-		match self {
-			ExprOrBlock::JsFunctionBody(body) => body.to_format_element(formatter),
-			ExprOrBlock::JsAnyExpression(expr) => expr.to_format_element(formatter),
-		}
-	}
-}
diff --git a/crates/rome_formatter/src/ts/expressions/arrow_expr.rs b/crates/rome_formatter/src/ts/expressions/arrow_expr.rs
index b9ca823b5cd3..a9bdebf81208 100644
--- a/crates/rome_formatter/src/ts/expressions/arrow_expr.rs
+++ b/crates/rome_formatter/src/ts/expressions/arrow_expr.rs
@@ -1,11 +1,13 @@
-use rslint_parser::ast::{ArrowExpr, ArrowExprParams};
+use rslint_parser::ast::{
+	JsAnyArrowFunctionBody, JsAnyArrowFunctionParameters, JsArrowFunctionExpression,
+};
 
 use crate::{
 	concat_elements, format_elements, space_token, token, FormatElement, FormatResult, Formatter,
 	ToFormatElement,
 };
 
-impl ToFormatElement for ArrowExpr {
+impl ToFormatElement for JsArrowFunctionExpression {
 	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
 		let mut tokens: Vec<FormatElement> = vec![];
 
@@ -16,14 +18,14 @@ impl ToFormatElement for ArrowExpr {
 			));
 		}
 
-		if let Some(params) = self.params() {
+		if let Some(params) = self.parameter_list() {
 			match params {
-				ArrowExprParams::Name(name) => {
+				JsAnyArrowFunctionParameters::JsIdentifierBinding(name) => {
 					tokens.push(token("("));
 					tokens.push(formatter.format_node(name)?);
 					tokens.push(token(")"));
 				}
-				ArrowExprParams::JsParameterList(params) => {
+				JsAnyArrowFunctionParameters::JsParameterList(params) => {
 					tokens.push(formatter.format_node(params)?)
 				}
 			}
@@ -39,3 +41,12 @@ impl ToFormatElement for ArrowExpr {
 		Ok(concat_elements(tokens))
 	}
 }
+
+impl ToFormatElement for JsAnyArrowFunctionBody {
+	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
+		match self {
+			JsAnyArrowFunctionBody::JsFunctionBody(body) => body.to_format_element(formatter),
+			JsAnyArrowFunctionBody::JsAnyExpression(expr) => expr.to_format_element(formatter),
+		}
+	}
+}
diff --git a/crates/rome_formatter/src/ts/expressions/expression.rs b/crates/rome_formatter/src/ts/expressions/expression.rs
index c6e47ade2dc5..5376579071ea 100644
--- a/crates/rome_formatter/src/ts/expressions/expression.rs
+++ b/crates/rome_formatter/src/ts/expressions/expression.rs
@@ -4,7 +4,7 @@ use rslint_parser::ast::JsAnyExpression;
 impl ToFormatElement for JsAnyExpression {
 	fn to_format_element(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
 		match self {
-			JsAnyExpression::ArrowExpr(arrow) => arrow.to_format_element(formatter),
+			JsAnyExpression::JsArrowFunctionExpression(arrow) => arrow.to_format_element(formatter),
 			JsAnyExpression::JsAnyLiteral(literal) => literal.to_format_element(formatter),
 			JsAnyExpression::Template(_) => todo!(),
 			JsAnyExpression::JsReferenceIdentifierExpression(name_ref) => {
diff --git a/crates/rome_formatter/src/ts/mod.rs b/crates/rome_formatter/src/ts/mod.rs
index 176c9ef5fbd1..3bbdca88191e 100644
--- a/crates/rome_formatter/src/ts/mod.rs
+++ b/crates/rome_formatter/src/ts/mod.rs
@@ -1,10 +1,10 @@
 mod any_js_array_element;
 mod arg_list;
 mod auxiliary;
+mod bindings;
 mod class;
 mod condition;
 mod declarators;
-mod expr_or_block;
 mod expressions;
 mod getter;
 mod ident;
@@ -17,7 +17,6 @@ mod script;
 mod setter;
 mod spread;
 mod statements;
-mod bindings;
 
 #[cfg(test)]
 mod test {
diff --git a/crates/rslint_parser/src/ast/expr_ext.rs b/crates/rslint_parser/src/ast/expr_ext.rs
index 7ce42becca27..022d5de31ce5 100644
--- a/crates/rslint_parser/src/ast/expr_ext.rs
+++ b/crates/rslint_parser/src/ast/expr_ext.rs
@@ -333,9 +333,9 @@ impl JsStringLiteral {
 	}
 }
 
-impl ArrowExpr {
-	pub fn body(&self) -> Option<ExprOrBlock> {
-		ExprOrBlock::cast(self.syntax().children().last()?)
+impl JsArrowFunctionExpression {
+	pub fn body(&self) -> Option<JsAnyArrowFunctionBody> {
+		JsAnyArrowFunctionBody::cast(self.syntax().children().last()?)
 	}
 }
 
diff --git a/crates/rslint_parser/src/ast/generated/nodes.rs b/crates/rslint_parser/src/ast/generated/nodes.rs
index d60d64b230b0..b3f96ad845d6 100644
--- a/crates/rslint_parser/src/ast/generated/nodes.rs
+++ b/crates/rslint_parser/src/ast/generated/nodes.rs
@@ -772,6 +772,21 @@ impl JsArrayExpression {
 	}
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct JsArrowFunctionExpression {
+	pub(crate) syntax: SyntaxNode,
+}
+impl JsArrowFunctionExpression {
+	pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
+	pub fn type_parameters(&self) -> Option<TsTypeParams> { support::node(&self.syntax) }
+	pub fn parameter_list(&self) -> Option<JsAnyArrowFunctionParameters> {
+		support::node(&self.syntax)
+	}
+	pub fn fat_arrow_token(&self) -> SyntaxResult<SyntaxToken> {
+		support::required_token(&self.syntax, T ! [=>])
+	}
+	pub fn return_type(&self) -> Option<TsReturnType> { support::node(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct JsAwaitExpression {
 	pub(crate) syntax: SyntaxNode,
 }
@@ -841,7 +856,7 @@ impl JsFunctionExpression {
 	}
 	pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T ! [*]) }
 	pub fn id(&self) -> Option<JsIdentifierBinding> { support::node(&self.syntax) }
-	pub fn type_params(&self) -> Option<TsTypeParams> { support::node(&self.syntax) }
+	pub fn type_parameters(&self) -> Option<TsTypeParams> { support::node(&self.syntax) }
 	pub fn parameters(&self) -> SyntaxResult<JsParameterList> {
 		support::required_node(&self.syntax)
 	}
@@ -970,20 +985,6 @@ impl JsYieldExpression {
 	pub fn argument(&self) -> Option<JsAnyExpression> { support::node(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ArrowExpr {
-	pub(crate) syntax: SyntaxNode,
-}
-impl ArrowExpr {
-	pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
-	pub fn type_params(&self) -> Option<TsTypeParams> { support::node(&self.syntax) }
-	pub fn params(&self) -> Option<ArrowExprParams> { support::node(&self.syntax) }
-	pub fn fat_arrow_token(&self) -> SyntaxResult<SyntaxToken> {
-		support::required_token(&self.syntax, T ! [=>])
-	}
-	pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T ! [:]) }
-	pub fn return_type(&self) -> Option<TsType> { support::node(&self.syntax) }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Template {
 	pub(crate) syntax: SyntaxNode,
 }
@@ -2326,6 +2327,7 @@ pub enum JsAnyStatement {
 pub enum JsAnyExpression {
 	JsAnyLiteral(JsAnyLiteral),
 	JsArrayExpression(JsArrayExpression),
+	JsArrowFunctionExpression(JsArrowFunctionExpression),
 	JsAwaitExpression(JsAwaitExpression),
 	JsBinaryExpression(JsBinaryExpression),
 	JsConditionalExpression(JsConditionalExpression),
@@ -2340,7 +2342,6 @@ pub enum JsAnyExpression {
 	JsPreUpdateExpression(JsPreUpdateExpression),
 	JsPostUpdateExpression(JsPostUpdateExpression),
 	JsYieldExpression(JsYieldExpression),
-	ArrowExpr(ArrowExpr),
 	Template(Template),
 	ObjectExpr(ObjectExpr),
 	BracketExpr(BracketExpr),
@@ -2388,46 +2389,12 @@ pub enum JsAnyLiteral {
 	JsRegexLiteral(JsRegexLiteral),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ArrowExprParams {
-	Name(Name),
+pub enum JsAnyArrowFunctionParameters {
 	JsParameterList(JsParameterList),
+	JsIdentifierBinding(JsIdentifierBinding),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum TsType {
-	TsAny(TsAny),
-	TsUnknown(TsUnknown),
-	TsNumber(TsNumber),
-	TsObject(TsObject),
-	TsBoolean(TsBoolean),
-	TsBigint(TsBigint),
-	TsString(TsString),
-	TsSymbol(TsSymbol),
-	TsVoid(TsVoid),
-	TsUndefined(TsUndefined),
-	TsNull(TsNull),
-	TsNever(TsNever),
-	TsThis(TsThis),
-	TsLiteral(TsLiteral),
-	TsPredicate(TsPredicate),
-	TsTuple(TsTuple),
-	TsParen(TsParen),
-	TsTypeRef(TsTypeRef),
-	TsTemplate(TsTemplate),
-	TsMappedType(TsMappedType),
-	TsImport(TsImport),
-	TsArray(TsArray),
-	TsIndexedArray(TsIndexedArray),
-	TsTypeOperator(TsTypeOperator),
-	TsIntersection(TsIntersection),
-	TsUnion(TsUnion),
-	TsFnType(TsFnType),
-	TsConstructorType(TsConstructorType),
-	TsConditionalType(TsConditionalType),
-	TsObjectType(TsObjectType),
-	TsInfer(TsInfer),
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ExprOrBlock {
+pub enum JsAnyArrowFunctionBody {
 	JsAnyExpression(JsAnyExpression),
 	JsFunctionBody(JsFunctionBody),
 }
@@ -2469,6 +2436,40 @@ pub enum ConstructorParamOrPat {
 	Pattern(Pattern),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum TsType {
+	TsAny(TsAny),
+	TsUnknown(TsUnknown),
+	TsNumber(TsNumber),
+	TsObject(TsObject),
+	TsBoolean(TsBoolean),
+	TsBigint(TsBigint),
+	TsString(TsString),
+	TsSymbol(TsSymbol),
+	TsVoid(TsVoid),
+	TsUndefined(TsUndefined),
+	TsNull(TsNull),
+	TsNever(TsNever),
+	TsThis(TsThis),
+	TsLiteral(TsLiteral),
+	TsPredicate(TsPredicate),
+	TsTuple(TsTuple),
+	TsParen(TsParen),
+	TsTypeRef(TsTypeRef),
+	TsTemplate(TsTemplate),
+	TsMappedType(TsMappedType),
+	TsImport(TsImport),
+	TsArray(TsArray),
+	TsIndexedArray(TsIndexedArray),
+	TsTypeOperator(TsTypeOperator),
+	TsIntersection(TsIntersection),
+	TsUnion(TsUnion),
+	TsFnType(TsFnType),
+	TsConstructorType(TsConstructorType),
+	TsConditionalType(TsConditionalType),
+	TsObjectType(TsObjectType),
+	TsInfer(TsInfer),
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum JsAnyArrayElement {
 	JsAnyExpression(JsAnyExpression),
 	SpreadElement(SpreadElement),
@@ -3159,6 +3160,17 @@ impl AstNode for JsArrayExpression {
 	}
 	fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for JsArrowFunctionExpression {
+	fn can_cast(kind: SyntaxKind) -> bool { kind == JS_ARROW_FUNCTION_EXPRESSION }
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		if Self::can_cast(syntax.kind()) {
+			Some(Self { syntax })
+		} else {
+			None
+		}
+	}
+	fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for JsAwaitExpression {
 	fn can_cast(kind: SyntaxKind) -> bool { kind == JS_AWAIT_EXPRESSION }
 	fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3313,17 +3325,6 @@ impl AstNode for JsYieldExpression {
 	}
 	fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl AstNode for ArrowExpr {
-	fn can_cast(kind: SyntaxKind) -> bool { kind == ARROW_EXPR }
-	fn cast(syntax: SyntaxNode) -> Option<Self> {
-		if Self::can_cast(syntax.kind()) {
-			Some(Self { syntax })
-		} else {
-			None
-		}
-	}
-	fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
 impl AstNode for Template {
 	fn can_cast(kind: SyntaxKind) -> bool { kind == TEMPLATE }
 	fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -4838,6 +4839,11 @@ impl AstNode for JsAnyStatement {
 impl From<JsArrayExpression> for JsAnyExpression {
 	fn from(node: JsArrayExpression) -> JsAnyExpression { JsAnyExpression::JsArrayExpression(node) }
 }
+impl From<JsArrowFunctionExpression> for JsAnyExpression {
+	fn from(node: JsArrowFunctionExpression) -> JsAnyExpression {
+		JsAnyExpression::JsArrowFunctionExpression(node)
+	}
+}
 impl From<JsAwaitExpression> for JsAnyExpression {
 	fn from(node: JsAwaitExpression) -> JsAnyExpression { JsAnyExpression::JsAwaitExpression(node) }
 }
@@ -4900,9 +4906,6 @@ impl From<JsPostUpdateExpression> for JsAnyExpression {
 impl From<JsYieldExpression> for JsAnyExpression {
 	fn from(node: JsYieldExpression) -> JsAnyExpression { JsAnyExpression::JsYieldExpression(node) }
 }
-impl From<ArrowExpr> for JsAnyExpression {
-	fn from(node: ArrowExpr) -> JsAnyExpression { JsAnyExpression::ArrowExpr(node) }
-}
 impl From<Template> for JsAnyExpression {
 	fn from(node: Template) -> JsAnyExpression { JsAnyExpression::Template(node) }
 }
@@ -4957,6 +4960,7 @@ impl AstNode for JsAnyExpression {
 	fn can_cast(kind: SyntaxKind) -> bool {
 		match kind {
 			JS_ARRAY_EXPRESSION
+			| JS_ARROW_FUNCTION_EXPRESSION
 			| JS_AWAIT_EXPRESSION
 			| JS_BINARY_EXPRESSION
 			| JS_CONDITIONAL_EXPRESSION
@@ -4971,7 +4975,6 @@ impl AstNode for JsAnyExpression {
 			| JS_PRE_UPDATE_EXPRESSION
 			| JS_POST_UPDATE_EXPRESSION
 			| JS_YIELD_EXPRESSION
-			| ARROW_EXPR
 			| TEMPLATE
 			| OBJECT_EXPR
 			| BRACKET_EXPR
@@ -4995,6 +4998,9 @@ impl AstNode for JsAnyExpression {
 	fn cast(syntax: SyntaxNode) -> Option<Self> {
 		let res = match syntax.kind() {
 			JS_ARRAY_EXPRESSION => JsAnyExpression::JsArrayExpression(JsArrayExpression { syntax }),
+			JS_ARROW_FUNCTION_EXPRESSION => {
+				JsAnyExpression::JsArrowFunctionExpression(JsArrowFunctionExpression { syntax })
+			}
 			JS_AWAIT_EXPRESSION => JsAnyExpression::JsAwaitExpression(JsAwaitExpression { syntax }),
 			JS_BINARY_EXPRESSION => {
 				JsAnyExpression::JsBinaryExpression(JsBinaryExpression { syntax })
@@ -5031,7 +5037,6 @@ impl AstNode for JsAnyExpression {
 				JsAnyExpression::JsPostUpdateExpression(JsPostUpdateExpression { syntax })
 			}
 			JS_YIELD_EXPRESSION => JsAnyExpression::JsYieldExpression(JsYieldExpression { syntax }),
-			ARROW_EXPR => JsAnyExpression::ArrowExpr(ArrowExpr { syntax }),
 			TEMPLATE => JsAnyExpression::Template(Template { syntax }),
 			OBJECT_EXPR => JsAnyExpression::ObjectExpr(ObjectExpr { syntax }),
 			BRACKET_EXPR => JsAnyExpression::BracketExpr(BracketExpr { syntax }),
@@ -5062,6 +5067,7 @@ impl AstNode for JsAnyExpression {
 	fn syntax(&self) -> &SyntaxNode {
 		match self {
 			JsAnyExpression::JsArrayExpression(it) => &it.syntax,
+			JsAnyExpression::JsArrowFunctionExpression(it) => &it.syntax,
 			JsAnyExpression::JsAwaitExpression(it) => &it.syntax,
 			JsAnyExpression::JsBinaryExpression(it) => &it.syntax,
 			JsAnyExpression::JsConditionalExpression(it) => &it.syntax,
@@ -5076,7 +5082,6 @@ impl AstNode for JsAnyExpression {
 			JsAnyExpression::JsPreUpdateExpression(it) => &it.syntax,
 			JsAnyExpression::JsPostUpdateExpression(it) => &it.syntax,
 			JsAnyExpression::JsYieldExpression(it) => &it.syntax,
-			JsAnyExpression::ArrowExpr(it) => &it.syntax,
 			JsAnyExpression::Template(it) => &it.syntax,
 			JsAnyExpression::ObjectExpr(it) => &it.syntax,
 			JsAnyExpression::BracketExpr(it) => &it.syntax,
@@ -5260,216 +5265,48 @@ impl AstNode for JsAnyLiteral {
 		}
 	}
 }
-impl From<Name> for ArrowExprParams {
-	fn from(node: Name) -> ArrowExprParams { ArrowExprParams::Name(node) }
-}
-impl From<JsParameterList> for ArrowExprParams {
-	fn from(node: JsParameterList) -> ArrowExprParams { ArrowExprParams::JsParameterList(node) }
-}
-impl AstNode for ArrowExprParams {
-	fn can_cast(kind: SyntaxKind) -> bool {
-		match kind {
-			NAME | JS_PARAMETER_LIST => true,
-			_ => false,
-		}
-	}
-	fn cast(syntax: SyntaxNode) -> Option<Self> {
-		let res = match syntax.kind() {
-			NAME => ArrowExprParams::Name(Name { syntax }),
-			JS_PARAMETER_LIST => ArrowExprParams::JsParameterList(JsParameterList { syntax }),
-			_ => return None,
-		};
-		Some(res)
-	}
-	fn syntax(&self) -> &SyntaxNode {
-		match self {
-			ArrowExprParams::Name(it) => &it.syntax,
-			ArrowExprParams::JsParameterList(it) => &it.syntax,
-		}
+impl From<JsParameterList> for JsAnyArrowFunctionParameters {
+	fn from(node: JsParameterList) -> JsAnyArrowFunctionParameters {
+		JsAnyArrowFunctionParameters::JsParameterList(node)
 	}
 }
-impl From<TsAny> for TsType {
-	fn from(node: TsAny) -> TsType { TsType::TsAny(node) }
-}
-impl From<TsUnknown> for TsType {
-	fn from(node: TsUnknown) -> TsType { TsType::TsUnknown(node) }
-}
-impl From<TsNumber> for TsType {
-	fn from(node: TsNumber) -> TsType { TsType::TsNumber(node) }
-}
-impl From<TsObject> for TsType {
-	fn from(node: TsObject) -> TsType { TsType::TsObject(node) }
-}
-impl From<TsBoolean> for TsType {
-	fn from(node: TsBoolean) -> TsType { TsType::TsBoolean(node) }
-}
-impl From<TsBigint> for TsType {
-	fn from(node: TsBigint) -> TsType { TsType::TsBigint(node) }
-}
-impl From<TsString> for TsType {
-	fn from(node: TsString) -> TsType { TsType::TsString(node) }
-}
-impl From<TsSymbol> for TsType {
-	fn from(node: TsSymbol) -> TsType { TsType::TsSymbol(node) }
-}
-impl From<TsVoid> for TsType {
-	fn from(node: TsVoid) -> TsType { TsType::TsVoid(node) }
-}
-impl From<TsUndefined> for TsType {
-	fn from(node: TsUndefined) -> TsType { TsType::TsUndefined(node) }
-}
-impl From<TsNull> for TsType {
-	fn from(node: TsNull) -> TsType { TsType::TsNull(node) }
-}
-impl From<TsNever> for TsType {
-	fn from(node: TsNever) -> TsType { TsType::TsNever(node) }
-}
-impl From<TsThis> for TsType {
-	fn from(node: TsThis) -> TsType { TsType::TsThis(node) }
-}
-impl From<TsLiteral> for TsType {
-	fn from(node: TsLiteral) -> TsType { TsType::TsLiteral(node) }
-}
-impl From<TsPredicate> for TsType {
-	fn from(node: TsPredicate) -> TsType { TsType::TsPredicate(node) }
-}
-impl From<TsTuple> for TsType {
-	fn from(node: TsTuple) -> TsType { TsType::TsTuple(node) }
-}
-impl From<TsParen> for TsType {
-	fn from(node: TsParen) -> TsType { TsType::TsParen(node) }
-}
-impl From<TsTypeRef> for TsType {
-	fn from(node: TsTypeRef) -> TsType { TsType::TsTypeRef(node) }
-}
-impl From<TsTemplate> for TsType {
-	fn from(node: TsTemplate) -> TsType { TsType::TsTemplate(node) }
-}
-impl From<TsMappedType> for TsType {
-	fn from(node: TsMappedType) -> TsType { TsType::TsMappedType(node) }
-}
-impl From<TsImport> for TsType {
-	fn from(node: TsImport) -> TsType { TsType::TsImport(node) }
-}
-impl From<TsArray> for TsType {
-	fn from(node: TsArray) -> TsType { TsType::TsArray(node) }
-}
-impl From<TsIndexedArray> for TsType {
-	fn from(node: TsIndexedArray) -> TsType { TsType::TsIndexedArray(node) }
-}
-impl From<TsTypeOperator> for TsType {
-	fn from(node: TsTypeOperator) -> TsType { TsType::TsTypeOperator(node) }
-}
-impl From<TsIntersection> for TsType {
-	fn from(node: TsIntersection) -> TsType { TsType::TsIntersection(node) }
-}
-impl From<TsUnion> for TsType {
-	fn from(node: TsUnion) -> TsType { TsType::TsUnion(node) }
-}
-impl From<TsFnType> for TsType {
-	fn from(node: TsFnType) -> TsType { TsType::TsFnType(node) }
-}
-impl From<TsConstructorType> for TsType {
-	fn from(node: TsConstructorType) -> TsType { TsType::TsConstructorType(node) }
-}
-impl From<TsConditionalType> for TsType {
-	fn from(node: TsConditionalType) -> TsType { TsType::TsConditionalType(node) }
-}
-impl From<TsObjectType> for TsType {
-	fn from(node: TsObjectType) -> TsType { TsType::TsObjectType(node) }
-}
-impl From<TsInfer> for TsType {
-	fn from(node: TsInfer) -> TsType { TsType::TsInfer(node) }
+impl From<JsIdentifierBinding> for JsAnyArrowFunctionParameters {
+	fn from(node: JsIdentifierBinding) -> JsAnyArrowFunctionParameters {
+		JsAnyArrowFunctionParameters::JsIdentifierBinding(node)
+	}
 }
-impl AstNode for TsType {
+impl AstNode for JsAnyArrowFunctionParameters {
 	fn can_cast(kind: SyntaxKind) -> bool {
 		match kind {
-			TS_ANY | TS_UNKNOWN | TS_NUMBER | TS_OBJECT | TS_BOOLEAN | TS_BIGINT | TS_STRING
-			| TS_SYMBOL | TS_VOID | TS_UNDEFINED | TS_NULL | TS_NEVER | TS_THIS | TS_LITERAL
-			| TS_PREDICATE | TS_TUPLE | TS_PAREN | TS_TYPE_REF | TS_TEMPLATE | TS_MAPPED_TYPE
-			| TS_IMPORT | TS_ARRAY | TS_INDEXED_ARRAY | TS_TYPE_OPERATOR | TS_INTERSECTION
-			| TS_UNION | TS_FN_TYPE | TS_CONSTRUCTOR_TYPE | TS_CONDITIONAL_TYPE
-			| TS_OBJECT_TYPE | TS_INFER => true,
+			JS_PARAMETER_LIST | JS_IDENTIFIER_BINDING => true,
 			_ => false,
 		}
 	}
 	fn cast(syntax: SyntaxNode) -> Option<Self> {
 		let res = match syntax.kind() {
-			TS_ANY => TsType::TsAny(TsAny { syntax }),
-			TS_UNKNOWN => TsType::TsUnknown(TsUnknown { syntax }),
-			TS_NUMBER => TsType::TsNumber(TsNumber { syntax }),
-			TS_OBJECT => TsType::TsObject(TsObject { syntax }),
-			TS_BOOLEAN => TsType::TsBoolean(TsBoolean { syntax }),
-			TS_BIGINT => TsType::TsBigint(TsBigint { syntax }),
-			TS_STRING => TsType::TsString(TsString { syntax }),
-			TS_SYMBOL => TsType::TsSymbol(TsSymbol { syntax }),
-			TS_VOID => TsType::TsVoid(TsVoid { syntax }),
-			TS_UNDEFINED => TsType::TsUndefined(TsUndefined { syntax }),
-			TS_NULL => TsType::TsNull(TsNull { syntax }),
-			TS_NEVER => TsType::TsNever(TsNever { syntax }),
-			TS_THIS => TsType::TsThis(TsThis { syntax }),
-			TS_LITERAL => TsType::TsLiteral(TsLiteral { syntax }),
-			TS_PREDICATE => TsType::TsPredicate(TsPredicate { syntax }),
-			TS_TUPLE => TsType::TsTuple(TsTuple { syntax }),
-			TS_PAREN => TsType::TsParen(TsParen { syntax }),
-			TS_TYPE_REF => TsType::TsTypeRef(TsTypeRef { syntax }),
-			TS_TEMPLATE => TsType::TsTemplate(TsTemplate { syntax }),
-			TS_MAPPED_TYPE => TsType::TsMappedType(TsMappedType { syntax }),
-			TS_IMPORT => TsType::TsImport(TsImport { syntax }),
-			TS_ARRAY => TsType::TsArray(TsArray { syntax }),
-			TS_INDEXED_ARRAY => TsType::TsIndexedArray(TsIndexedArray { syntax }),
-			TS_TYPE_OPERATOR => TsType::TsTypeOperator(TsTypeOperator { syntax }),
-			TS_INTERSECTION => TsType::TsIntersection(TsIntersection { syntax }),
-			TS_UNION => TsType::TsUnion(TsUnion { syntax }),
-			TS_FN_TYPE => TsType::TsFnType(TsFnType { syntax }),
-			TS_CONSTRUCTOR_TYPE => TsType::TsConstructorType(TsConstructorType { syntax }),
-			TS_CONDITIONAL_TYPE => TsType::TsConditionalType(TsConditionalType { syntax }),
-			TS_OBJECT_TYPE => TsType::TsObjectType(TsObjectType { syntax }),
-			TS_INFER => TsType::TsInfer(TsInfer { syntax }),
+			JS_PARAMETER_LIST => {
+				JsAnyArrowFunctionParameters::JsParameterList(JsParameterList { syntax })
+			}
+			JS_IDENTIFIER_BINDING => {
+				JsAnyArrowFunctionParameters::JsIdentifierBinding(JsIdentifierBinding { syntax })
+			}
 			_ => return None,
 		};
 		Some(res)
 	}
 	fn syntax(&self) -> &SyntaxNode {
 		match self {
-			TsType::TsAny(it) => &it.syntax,
-			TsType::TsUnknown(it) => &it.syntax,
-			TsType::TsNumber(it) => &it.syntax,
-			TsType::TsObject(it) => &it.syntax,
-			TsType::TsBoolean(it) => &it.syntax,
-			TsType::TsBigint(it) => &it.syntax,
-			TsType::TsString(it) => &it.syntax,
-			TsType::TsSymbol(it) => &it.syntax,
-			TsType::TsVoid(it) => &it.syntax,
-			TsType::TsUndefined(it) => &it.syntax,
-			TsType::TsNull(it) => &it.syntax,
-			TsType::TsNever(it) => &it.syntax,
-			TsType::TsThis(it) => &it.syntax,
-			TsType::TsLiteral(it) => &it.syntax,
-			TsType::TsPredicate(it) => &it.syntax,
-			TsType::TsTuple(it) => &it.syntax,
-			TsType::TsParen(it) => &it.syntax,
-			TsType::TsTypeRef(it) => &it.syntax,
-			TsType::TsTemplate(it) => &it.syntax,
-			TsType::TsMappedType(it) => &it.syntax,
-			TsType::TsImport(it) => &it.syntax,
-			TsType::TsArray(it) => &it.syntax,
-			TsType::TsIndexedArray(it) => &it.syntax,
-			TsType::TsTypeOperator(it) => &it.syntax,
-			TsType::TsIntersection(it) => &it.syntax,
-			TsType::TsUnion(it) => &it.syntax,
-			TsType::TsFnType(it) => &it.syntax,
-			TsType::TsConstructorType(it) => &it.syntax,
-			TsType::TsConditionalType(it) => &it.syntax,
-			TsType::TsObjectType(it) => &it.syntax,
-			TsType::TsInfer(it) => &it.syntax,
+			JsAnyArrowFunctionParameters::JsParameterList(it) => &it.syntax,
+			JsAnyArrowFunctionParameters::JsIdentifierBinding(it) => &it.syntax,
 		}
 	}
 }
-impl From<JsFunctionBody> for ExprOrBlock {
-	fn from(node: JsFunctionBody) -> ExprOrBlock { ExprOrBlock::JsFunctionBody(node) }
+impl From<JsFunctionBody> for JsAnyArrowFunctionBody {
+	fn from(node: JsFunctionBody) -> JsAnyArrowFunctionBody {
+		JsAnyArrowFunctionBody::JsFunctionBody(node)
+	}
 }
-impl AstNode for ExprOrBlock {
+impl AstNode for JsAnyArrowFunctionBody {
 	fn can_cast(kind: SyntaxKind) -> bool {
 		match kind {
 			JS_FUNCTION_BODY => true,
@@ -5479,10 +5316,10 @@ impl AstNode for ExprOrBlock {
 	}
 	fn cast(syntax: SyntaxNode) -> Option<Self> {
 		let res = match syntax.kind() {
-			JS_FUNCTION_BODY => ExprOrBlock::JsFunctionBody(JsFunctionBody { syntax }),
+			JS_FUNCTION_BODY => JsAnyArrowFunctionBody::JsFunctionBody(JsFunctionBody { syntax }),
 			_ => {
 				if let Some(js_any_expression) = JsAnyExpression::cast(syntax) {
-					return Some(ExprOrBlock::JsAnyExpression(js_any_expression));
+					return Some(JsAnyArrowFunctionBody::JsAnyExpression(js_any_expression));
 				}
 				return None;
 			}
@@ -5491,8 +5328,8 @@ impl AstNode for ExprOrBlock {
 	}
 	fn syntax(&self) -> &SyntaxNode {
 		match self {
-			ExprOrBlock::JsFunctionBody(it) => &it.syntax,
-			ExprOrBlock::JsAnyExpression(it) => it.syntax(),
+			JsAnyArrowFunctionBody::JsFunctionBody(it) => &it.syntax,
+			JsAnyArrowFunctionBody::JsAnyExpression(it) => it.syntax(),
 		}
 	}
 }
@@ -5708,6 +5545,184 @@ impl AstNode for ConstructorParamOrPat {
 		}
 	}
 }
+impl From<TsAny> for TsType {
+	fn from(node: TsAny) -> TsType { TsType::TsAny(node) }
+}
+impl From<TsUnknown> for TsType {
+	fn from(node: TsUnknown) -> TsType { TsType::TsUnknown(node) }
+}
+impl From<TsNumber> for TsType {
+	fn from(node: TsNumber) -> TsType { TsType::TsNumber(node) }
+}
+impl From<TsObject> for TsType {
+	fn from(node: TsObject) -> TsType { TsType::TsObject(node) }
+}
+impl From<TsBoolean> for TsType {
+	fn from(node: TsBoolean) -> TsType { TsType::TsBoolean(node) }
+}
+impl From<TsBigint> for TsType {
+	fn from(node: TsBigint) -> TsType { TsType::TsBigint(node) }
+}
+impl From<TsString> for TsType {
+	fn from(node: TsString) -> TsType { TsType::TsString(node) }
+}
+impl From<TsSymbol> for TsType {
+	fn from(node: TsSymbol) -> TsType { TsType::TsSymbol(node) }
+}
+impl From<TsVoid> for TsType {
+	fn from(node: TsVoid) -> TsType { TsType::TsVoid(node) }
+}
+impl From<TsUndefined> for TsType {
+	fn from(node: TsUndefined) -> TsType { TsType::TsUndefined(node) }
+}
+impl From<TsNull> for TsType {
+	fn from(node: TsNull) -> TsType { TsType::TsNull(node) }
+}
+impl From<TsNever> for TsType {
+	fn from(node: TsNever) -> TsType { TsType::TsNever(node) }
+}
+impl From<TsThis> for TsType {
+	fn from(node: TsThis) -> TsType { TsType::TsThis(node) }
+}
+impl From<TsLiteral> for TsType {
+	fn from(node: TsLiteral) -> TsType { TsType::TsLiteral(node) }
+}
+impl From<TsPredicate> for TsType {
+	fn from(node: TsPredicate) -> TsType { TsType::TsPredicate(node) }
+}
+impl From<TsTuple> for TsType {
+	fn from(node: TsTuple) -> TsType { TsType::TsTuple(node) }
+}
+impl From<TsParen> for TsType {
+	fn from(node: TsParen) -> TsType { TsType::TsParen(node) }
+}
+impl From<TsTypeRef> for TsType {
+	fn from(node: TsTypeRef) -> TsType { TsType::TsTypeRef(node) }
+}
+impl From<TsTemplate> for TsType {
+	fn from(node: TsTemplate) -> TsType { TsType::TsTemplate(node) }
+}
+impl From<TsMappedType> for TsType {
+	fn from(node: TsMappedType) -> TsType { TsType::TsMappedType(node) }
+}
+impl From<TsImport> for TsType {
+	fn from(node: TsImport) -> TsType { TsType::TsImport(node) }
+}
+impl From<TsArray> for TsType {
+	fn from(node: TsArray) -> TsType { TsType::TsArray(node) }
+}
+impl From<TsIndexedArray> for TsType {
+	fn from(node: TsIndexedArray) -> TsType { TsType::TsIndexedArray(node) }
+}
+impl From<TsTypeOperator> for TsType {
+	fn from(node: TsTypeOperator) -> TsType { TsType::TsTypeOperator(node) }
+}
+impl From<TsIntersection> for TsType {
+	fn from(node: TsIntersection) -> TsType { TsType::TsIntersection(node) }
+}
+impl From<TsUnion> for TsType {
+	fn from(node: TsUnion) -> TsType { TsType::TsUnion(node) }
+}
+impl From<TsFnType> for TsType {
+	fn from(node: TsFnType) -> TsType { TsType::TsFnType(node) }
+}
+impl From<TsConstructorType> for TsType {
+	fn from(node: TsConstructorType) -> TsType { TsType::TsConstructorType(node) }
+}
+impl From<TsConditionalType> for TsType {
+	fn from(node: TsConditionalType) -> TsType { TsType::TsConditionalType(node) }
+}
+impl From<TsObjectType> for TsType {
+	fn from(node: TsObjectType) -> TsType { TsType::TsObjectType(node) }
+}
+impl From<TsInfer> for TsType {
+	fn from(node: TsInfer) -> TsType { TsType::TsInfer(node) }
+}
+impl AstNode for TsType {
+	fn can_cast(kind: SyntaxKind) -> bool {
+		match kind {
+			TS_ANY | TS_UNKNOWN | TS_NUMBER | TS_OBJECT | TS_BOOLEAN | TS_BIGINT | TS_STRING
+			| TS_SYMBOL | TS_VOID | TS_UNDEFINED | TS_NULL | TS_NEVER | TS_THIS | TS_LITERAL
+			| TS_PREDICATE | TS_TUPLE | TS_PAREN | TS_TYPE_REF | TS_TEMPLATE | TS_MAPPED_TYPE
+			| TS_IMPORT | TS_ARRAY | TS_INDEXED_ARRAY | TS_TYPE_OPERATOR | TS_INTERSECTION
+			| TS_UNION | TS_FN_TYPE | TS_CONSTRUCTOR_TYPE | TS_CONDITIONAL_TYPE
+			| TS_OBJECT_TYPE | TS_INFER => true,
+			_ => false,
+		}
+	}
+	fn cast(syntax: SyntaxNode) -> Option<Self> {
+		let res = match syntax.kind() {
+			TS_ANY => TsType::TsAny(TsAny { syntax }),
+			TS_UNKNOWN => TsType::TsUnknown(TsUnknown { syntax }),
+			TS_NUMBER => TsType::TsNumber(TsNumber { syntax }),
+			TS_OBJECT => TsType::TsObject(TsObject { syntax }),
+			TS_BOOLEAN => TsType::TsBoolean(TsBoolean { syntax }),
+			TS_BIGINT => TsType::TsBigint(TsBigint { syntax }),
+			TS_STRING => TsType::TsString(TsString { syntax }),
+			TS_SYMBOL => TsType::TsSymbol(TsSymbol { syntax }),
+			TS_VOID => TsType::TsVoid(TsVoid { syntax }),
+			TS_UNDEFINED => TsType::TsUndefined(TsUndefined { syntax }),
+			TS_NULL => TsType::TsNull(TsNull { syntax }),
+			TS_NEVER => TsType::TsNever(TsNever { syntax }),
+			TS_THIS => TsType::TsThis(TsThis { syntax }),
+			TS_LITERAL => TsType::TsLiteral(TsLiteral { syntax }),
+			TS_PREDICATE => TsType::TsPredicate(TsPredicate { syntax }),
+			TS_TUPLE => TsType::TsTuple(TsTuple { syntax }),
+			TS_PAREN => TsType::TsParen(TsParen { syntax }),
+			TS_TYPE_REF => TsType::TsTypeRef(TsTypeRef { syntax }),
+			TS_TEMPLATE => TsType::TsTemplate(TsTemplate { syntax }),
+			TS_MAPPED_TYPE => TsType::TsMappedType(TsMappedType { syntax }),
+			TS_IMPORT => TsType::TsImport(TsImport { syntax }),
+			TS_ARRAY => TsType::TsArray(TsArray { syntax }),
+			TS_INDEXED_ARRAY => TsType::TsIndexedArray(TsIndexedArray { syntax }),
+			TS_TYPE_OPERATOR => TsType::TsTypeOperator(TsTypeOperator { syntax }),
+			TS_INTERSECTION => TsType::TsIntersection(TsIntersection { syntax }),
+			TS_UNION => TsType::TsUnion(TsUnion { syntax }),
+			TS_FN_TYPE => TsType::TsFnType(TsFnType { syntax }),
+			TS_CONSTRUCTOR_TYPE => TsType::TsConstructorType(TsConstructorType { syntax }),
+			TS_CONDITIONAL_TYPE => TsType::TsConditionalType(TsConditionalType { syntax }),
+			TS_OBJECT_TYPE => TsType::TsObjectType(TsObjectType { syntax }),
+			TS_INFER => TsType::TsInfer(TsInfer { syntax }),
+			_ => return None,
+		};
+		Some(res)
+	}
+	fn syntax(&self) -> &SyntaxNode {
+		match self {
+			TsType::TsAny(it) => &it.syntax,
+			TsType::TsUnknown(it) => &it.syntax,
+			TsType::TsNumber(it) => &it.syntax,
+			TsType::TsObject(it) => &it.syntax,
+			TsType::TsBoolean(it) => &it.syntax,
+			TsType::TsBigint(it) => &it.syntax,
+			TsType::TsString(it) => &it.syntax,
+			TsType::TsSymbol(it) => &it.syntax,
+			TsType::TsVoid(it) => &it.syntax,
+			TsType::TsUndefined(it) => &it.syntax,
+			TsType::TsNull(it) => &it.syntax,
+			TsType::TsNever(it) => &it.syntax,
+			TsType::TsThis(it) => &it.syntax,
+			TsType::TsLiteral(it) => &it.syntax,
+			TsType::TsPredicate(it) => &it.syntax,
+			TsType::TsTuple(it) => &it.syntax,
+			TsType::TsParen(it) => &it.syntax,
+			TsType::TsTypeRef(it) => &it.syntax,
+			TsType::TsTemplate(it) => &it.syntax,
+			TsType::TsMappedType(it) => &it.syntax,
+			TsType::TsImport(it) => &it.syntax,
+			TsType::TsArray(it) => &it.syntax,
+			TsType::TsIndexedArray(it) => &it.syntax,
+			TsType::TsTypeOperator(it) => &it.syntax,
+			TsType::TsIntersection(it) => &it.syntax,
+			TsType::TsUnion(it) => &it.syntax,
+			TsType::TsFnType(it) => &it.syntax,
+			TsType::TsConstructorType(it) => &it.syntax,
+			TsType::TsConditionalType(it) => &it.syntax,
+			TsType::TsObjectType(it) => &it.syntax,
+			TsType::TsInfer(it) => &it.syntax,
+		}
+	}
+}
 impl From<SpreadElement> for JsAnyArrayElement {
 	fn from(node: SpreadElement) -> JsAnyArrayElement { JsAnyArrayElement::SpreadElement(node) }
 }
@@ -6205,17 +6220,12 @@ impl std::fmt::Display for JsAnyLiteral {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
 }
-impl std::fmt::Display for ArrowExprParams {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		std::fmt::Display::fmt(self.syntax(), f)
-	}
-}
-impl std::fmt::Display for TsType {
+impl std::fmt::Display for JsAnyArrowFunctionParameters {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
 }
-impl std::fmt::Display for ExprOrBlock {
+impl std::fmt::Display for JsAnyArrowFunctionBody {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
@@ -6240,6 +6250,11 @@ impl std::fmt::Display for ConstructorParamOrPat {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
 }
+impl std::fmt::Display for TsType {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
 impl std::fmt::Display for JsAnyArrayElement {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		std::fmt::Display::fmt(self.syntax(), f)
@@ -6580,6 +6595,11 @@ impl std::fmt::Display for JsArrayExpression {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
 }
+impl std::fmt::Display for JsArrowFunctionExpression {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		std::fmt::Display::fmt(self.syntax(), f)
+	}
+}
 impl std::fmt::Display for JsAwaitExpression {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		std::fmt::Display::fmt(self.syntax(), f)
@@ -6650,11 +6670,6 @@ impl std::fmt::Display for JsYieldExpression {
 		std::fmt::Display::fmt(self.syntax(), f)
 	}
 }
-impl std::fmt::Display for ArrowExpr {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		std::fmt::Display::fmt(self.syntax(), f)
-	}
-}
 impl std::fmt::Display for Template {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/rslint_parser/src/syntax/expr.rs b/crates/rslint_parser/src/syntax/expr.rs
index f5b6c5545b4d..5d94fb5632b9 100644
--- a/crates/rslint_parser/src/syntax/expr.rs
+++ b/crates/rslint_parser/src/syntax/expr.rs
@@ -5,7 +5,7 @@
 
 use syntax::decl::is_semi;
 
-use super::decl::{arrow_body, class_decl, parameter_list, maybe_private_name, method};
+use super::decl::{arrow_body, class_decl, maybe_private_name, method, parameter_list};
 use super::pat::pattern;
 use super::typescript::*;
 use super::util::*;
@@ -109,12 +109,12 @@ pub fn assign_expr(p: &mut Parser) -> Option<CompletedMarker> {
 			let m = p.start();
 			ts_type_params(p)?;
 			let res = assign_expr_base(p);
-			if res.map(|x| x.kind()) != Some(ARROW_EXPR) {
+			if res.map(|x| x.kind()) != Some(JS_ARROW_FUNCTION_EXPRESSION) {
 				m.abandon(p);
 				None
 			} else {
 				res.unwrap().undo_completion(p).abandon(p);
-				Some(m.complete(p, ARROW_EXPR))
+				Some(m.complete(p, JS_ARROW_FUNCTION_EXPRESSION))
 			}
 		});
 		if let Some(mut res) = res {
@@ -424,7 +424,7 @@ pub fn member_or_new_expr(p: &mut Parser, new_expr: bool) -> Option<CompletedMar
 		}
 
 		let complete = member_or_new_expr(p, new_expr)?;
-		if complete.kind() == ARROW_EXPR {
+		if complete.kind() == JS_ARROW_FUNCTION_EXPRESSION {
 			return Some(complete);
 		}
 
@@ -774,7 +774,7 @@ pub fn paren_or_arrow_expr(p: &mut Parser, can_be_arrow: bool) -> CompletedMarke
 		// events does not work apparently, therefore we need to clone the entire parser
 		let cloned = p.clone();
 		if func(p).is_some() {
-			let c = m.complete(p, ARROW_EXPR);
+			let c = m.complete(p, JS_ARROW_FUNCTION_EXPRESSION);
 			return c;
 		} else {
 			*p = cloned;
@@ -811,7 +811,7 @@ pub fn paren_or_arrow_expr(p: &mut Parser, can_be_arrow: bool) -> CompletedMarke
 
 			p.bump_any();
 			arrow_body(p);
-			return m.complete(p, ARROW_EXPR);
+			return m.complete(p, JS_ARROW_FUNCTION_EXPRESSION);
 		}
 	}
 
@@ -933,7 +933,7 @@ pub fn primary_expr(p: &mut Parser) -> Option<CompletedMarker> {
 						// test_err async_arrow_expr_await_parameter
 						// let a = async await => {}
 						p.bump_remap(T![ident]);
-						m.complete(p, NAME);
+						m.complete(p, JS_IDENTIFIER_BINDING);
 					}
 					if p.at(T![:]) {
 						let complete = ts_type_or_type_predicate_ann(p, T![:]);
@@ -949,7 +949,7 @@ pub fn primary_expr(p: &mut Parser) -> Option<CompletedMarker> {
 						in_async: true,
 						..p.state.clone()
 					}));
-					m.complete(p, ARROW_EXPR)
+					m.complete(p, JS_ARROW_FUNCTION_EXPRESSION)
 				} else {
 					identifier_reference(p)?
 				}
@@ -975,12 +975,12 @@ pub fn primary_expr(p: &mut Parser) -> Option<CompletedMarker> {
 				// foo =>
 				// {}
 
-				// parameters are binding so we need to change the kind from NAME_REF to NAME
-				ident.change_kind(p, NAME);
+				// parameters are binding so we need to change the kind from NAME_REF to JS_IDENTIFIER_BINDING
+				ident.change_kind(p, JS_IDENTIFIER_BINDING);
 				let m = ident.precede(p);
 				p.bump_any();
 				arrow_body(p);
-				m.complete(p, ARROW_EXPR)
+				m.complete(p, JS_ARROW_FUNCTION_EXPRESSION)
 			} else {
 				ident
 			}
@@ -1312,7 +1312,7 @@ pub fn lhs_expr(p: &mut Parser) -> Option<CompletedMarker> {
 	}
 
 	let lhs = member_or_new_expr(p, true)?;
-	if lhs.kind() == ARROW_EXPR {
+	if lhs.kind() == JS_ARROW_FUNCTION_EXPRESSION {
 		return Some(lhs);
 	}
 
diff --git a/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast b/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast
index 8e319f9f268c..6cd33fccbfd4 100644
--- a/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast
+++ b/crates/rslint_parser/test_data/inline/err/async_arrow_expr_await_parameter.rast
@@ -18,8 +18,8 @@ JS_ROOT@0..26
                 IDENT@8..13 "async"
     WHITESPACE@13..14 " "
     JS_EXPRESSION_STATEMENT@14..25
-      ARROW_EXPR@14..25
-        NAME@14..19
+      JS_ARROW_FUNCTION_EXPRESSION@14..25
+        JS_IDENTIFIER_BINDING@14..19
           IDENT@14..19 "await"
         WHITESPACE@19..20 " "
         FAT_ARROW@20..22 "=>"
diff --git a/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast b/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast
index 44fe3c7ea387..2a8348eeff96 100644
--- a/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast
+++ b/crates/rslint_parser/test_data/inline/err/binding_identifier_invalid.rast
@@ -2,7 +2,7 @@ JS_ROOT@0..83
   LIST@0..0
   LIST@0..82
     JS_EXPRESSION_STATEMENT@0..30
-      ARROW_EXPR@0..30
+      JS_ARROW_FUNCTION_EXPRESSION@0..30
         ASYNC_KW@0..5 "async"
         WHITESPACE@5..6 " "
         JS_PARAMETER_LIST@6..8
diff --git a/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast b/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast
index f5114b204ddc..3f60969c7c7d 100644
--- a/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast
+++ b/crates/rslint_parser/test_data/inline/err/invalid_method_recover.rast
@@ -23,7 +23,7 @@ JS_ROOT@0..48
             WHITESPACE@17..18 " "
             EQ@18..19 "="
             WHITESPACE@19..20 " "
-            ARROW_EXPR@20..43
+            JS_ARROW_FUNCTION_EXPRESSION@20..43
               JS_PARAMETER_LIST@20..22
                 L_PAREN@20..21 "("
                 LIST@21..21
diff --git a/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast b/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast
index bca91df5b589..33d83171fee6 100644
--- a/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast
+++ b/crates/rslint_parser/test_data/inline/err/paren_or_arrow_expr_invalid_params.rast
@@ -2,7 +2,7 @@ JS_ROOT@0..28
   LIST@0..0
   LIST@0..27
     JS_EXPRESSION_STATEMENT@0..6
-      ARROW_EXPR@0..6
+      JS_ARROW_FUNCTION_EXPRESSION@0..6
         JS_PARAMETER_LIST@0..4
           L_PAREN@0..1 "("
           LIST@1..4
diff --git a/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast b/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast
index adcecb526160..e71a20082ef5 100644
--- a/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast
+++ b/crates/rslint_parser/test_data/inline/ok/arrow_expr_single_param.rast
@@ -2,8 +2,8 @@ JS_ROOT@0..44
   LIST@0..0
   LIST@0..43
     JS_EXPRESSION_STATEMENT@0..9
-      ARROW_EXPR@0..9
-        NAME@0..3
+      JS_ARROW_FUNCTION_EXPRESSION@0..9
+        JS_IDENTIFIER_BINDING@0..3
           IDENT@0..3 "foo"
         WHITESPACE@3..4 " "
         FAT_ARROW@4..6 "=>"
@@ -15,8 +15,8 @@ JS_ROOT@0..44
           R_CURLY@8..9 "}"
     WHITESPACE@9..10 "\n"
     JS_EXPRESSION_STATEMENT@10..21
-      ARROW_EXPR@10..21
-        NAME@10..15
+      JS_ARROW_FUNCTION_EXPRESSION@10..21
+        JS_IDENTIFIER_BINDING@10..15
           IDENT@10..15 "yield"
         WHITESPACE@15..16 " "
         FAT_ARROW@16..18 "=>"
@@ -28,8 +28,8 @@ JS_ROOT@0..44
           R_CURLY@20..21 "}"
     WHITESPACE@21..22 "\n"
     JS_EXPRESSION_STATEMENT@22..33
-      ARROW_EXPR@22..33
-        NAME@22..27
+      JS_ARROW_FUNCTION_EXPRESSION@22..33
+        JS_IDENTIFIER_BINDING@22..27
           IDENT@22..27 "await"
         WHITESPACE@27..28 " "
         FAT_ARROW@28..30 "=>"
@@ -41,8 +41,8 @@ JS_ROOT@0..44
           R_CURLY@32..33 "}"
     WHITESPACE@33..34 "\n"
     JS_EXPRESSION_STATEMENT@34..43
-      ARROW_EXPR@34..43
-        NAME@34..37
+      JS_ARROW_FUNCTION_EXPRESSION@34..43
+        JS_IDENTIFIER_BINDING@34..37
           IDENT@34..37 "foo"
         WHITESPACE@37..38 " "
         FAT_ARROW@38..40 "=>"
diff --git a/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast b/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast
index 09d480ebdca2..ec05ea57eeb6 100644
--- a/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast
+++ b/crates/rslint_parser/test_data/inline/ok/async_arrow_expr.rast
@@ -14,10 +14,10 @@ JS_ROOT@0..82
             JS_EQUAL_VALUE_CLAUSE@6..23
               EQ@6..7 "="
               WHITESPACE@7..8 " "
-              ARROW_EXPR@8..23
+              JS_ARROW_FUNCTION_EXPRESSION@8..23
                 ASYNC_KW@8..13 "async"
                 WHITESPACE@13..14 " "
-                NAME@14..17
+                JS_IDENTIFIER_BINDING@14..17
                   IDENT@14..17 "foo"
                 WHITESPACE@17..18 " "
                 FAT_ARROW@18..20 "=>"
@@ -41,7 +41,7 @@ JS_ROOT@0..82
             JS_EQUAL_VALUE_CLAUSE@30..49
               EQ@30..31 "="
               WHITESPACE@31..32 " "
-              ARROW_EXPR@32..49
+              JS_ARROW_FUNCTION_EXPRESSION@32..49
                 ASYNC_KW@32..37 "async"
                 WHITESPACE@37..38 " "
                 JS_PARAMETER_LIST@38..43
@@ -61,7 +61,7 @@ JS_ROOT@0..82
                   R_CURLY@48..49 "}"
     WHITESPACE@49..50 "\n"
     JS_EXPRESSION_STATEMENT@50..81
-      ARROW_EXPR@50..81
+      JS_ARROW_FUNCTION_EXPRESSION@50..81
         ASYNC_KW@50..55 "async"
         WHITESPACE@55..56 " "
         JS_PARAMETER_LIST@56..74
diff --git a/crates/rslint_parser/test_data/inline/ok/directives.rast b/crates/rslint_parser/test_data/inline/ok/directives.rast
index f27666dfffd2..40063b310713 100644
--- a/crates/rslint_parser/test_data/inline/ok/directives.rast
+++ b/crates/rslint_parser/test_data/inline/ok/directives.rast
@@ -134,7 +134,7 @@ JS_ROOT@0..321
             JS_EQUAL_VALUE_CLAUSE@225..281
               EQ@225..226 "="
               WHITESPACE@226..227 " "
-              ARROW_EXPR@227..281
+              JS_ARROW_FUNCTION_EXPRESSION@227..281
                 JS_PARAMETER_LIST@227..229
                   L_PAREN@227..228 "("
                   LIST@228..228
diff --git a/crates/rslint_parser/test_data/inline/ok/new_exprs.rast b/crates/rslint_parser/test_data/inline/ok/new_exprs.rast
index 7141a4d06ca2..71c744531522 100644
--- a/crates/rslint_parser/test_data/inline/ok/new_exprs.rast
+++ b/crates/rslint_parser/test_data/inline/ok/new_exprs.rast
@@ -86,7 +86,7 @@ JS_ROOT@0..113
               PLUS@87..88 "+"
               WHITESPACE@88..89 " "
               JS_BINARY_EXPRESSION@89..111
-                ARROW_EXPR@89..100
+                JS_ARROW_FUNCTION_EXPRESSION@89..100
                   JS_PARAMETER_LIST@89..94
                     L_PAREN@89..90 "("
                     LIST@90..93
diff --git a/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast b/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast
index 04a66eed6053..a719c00dcfb8 100644
--- a/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast
+++ b/crates/rslint_parser/test_data/inline/ok/paren_or_arrow_expr.rast
@@ -10,7 +10,7 @@ JS_ROOT@0..85
       SEMICOLON@5..6 ";"
     WHITESPACE@6..7 "\n"
     JS_EXPRESSION_STATEMENT@7..19
-      ARROW_EXPR@7..18
+      JS_ARROW_FUNCTION_EXPRESSION@7..18
         JS_PARAMETER_LIST@7..12
           L_PAREN@7..8 "("
           LIST@8..11
@@ -43,7 +43,7 @@ JS_ROOT@0..85
       SEMICOLON@27..28 ";"
     WHITESPACE@28..29 "\n"
     JS_EXPRESSION_STATEMENT@29..64
-      ARROW_EXPR@29..63
+      JS_ARROW_FUNCTION_EXPRESSION@29..63
         JS_PARAMETER_LIST@29..57
           L_PAREN@29..30 "("
           LIST@30..56
@@ -92,7 +92,7 @@ JS_ROOT@0..85
       SEMICOLON@63..64 ";"
     WHITESPACE@64..65 "\n"
     JS_EXPRESSION_STATEMENT@65..84
-      ARROW_EXPR@65..84
+      JS_ARROW_FUNCTION_EXPRESSION@65..84
         JS_PARAMETER_LIST@65..78
           L_PAREN@65..66 "("
           LIST@66..77
diff --git a/crates/rslint_parser/test_data/inline/ok/return_stmt.rast b/crates/rslint_parser/test_data/inline/ok/return_stmt.rast
index fcf0edc05ff5..1fe0bcacc98c 100644
--- a/crates/rslint_parser/test_data/inline/ok/return_stmt.rast
+++ b/crates/rslint_parser/test_data/inline/ok/return_stmt.rast
@@ -2,7 +2,7 @@ JS_ROOT@0..43
   LIST@0..0
   LIST@0..42
     JS_EXPRESSION_STATEMENT@0..42
-      ARROW_EXPR@0..42
+      JS_ARROW_FUNCTION_EXPRESSION@0..42
         JS_PARAMETER_LIST@0..2
           L_PAREN@0..1 "("
           LIST@1..1
diff --git a/crates/rslint_syntax/src/generated.rs b/crates/rslint_syntax/src/generated.rs
index 12654b30d167..fd2a309ba4fb 100644
--- a/crates/rslint_syntax/src/generated.rs
+++ b/crates/rslint_syntax/src/generated.rs
@@ -242,7 +242,7 @@ pub enum SyntaxKind {
 	COMPUTED_PROPERTY_NAME,
 	FOR_OF_STMT,
 	SINGLE_PATTERN,
-	ARROW_EXPR,
+	JS_ARROW_FUNCTION_EXPRESSION,
 	JS_YIELD_EXPRESSION,
 	CLASS_DECL,
 	CLASS_EXPR,
diff --git a/xtask/js.ungram b/xtask/js.ungram
index da7cf05e20e2..5451697f5852 100644
--- a/xtask/js.ungram
+++ b/xtask/js.ungram
@@ -243,6 +243,7 @@ JsDebuggerStatement =
 JsAnyExpression =
 	JsAnyLiteral
 	| JsArrayExpression
+	| JsArrowFunctionExpression
 	| JsAwaitExpression
 	| JsBinaryExpression
 	| JsConditionalExpression
@@ -257,7 +258,6 @@ JsAnyExpression =
 	| JsPreUpdateExpression
 	| JsPostUpdateExpression
 	| JsYieldExpression
-	| ArrowExpr
 	| Template
 	| ObjectExpr
 	| BracketExpr
@@ -331,24 +331,22 @@ JsFunctionExpression =
 	'function'
 	'*'?
 	id: JsIdentifierBinding?
-	type_params: TsTypeParams?
+	type_parameters: TsTypeParams?
 	parameters: JsParameterList
 	return_type: TsReturnType?
 	body: JsFunctionBody
 
-// Arrow expression
-ArrowExpr =
+
+JsArrowFunctionExpression =
 	'async'?
-	type_params:TsTypeParams?
-	params:ArrowExprParams?
+	type_parameters: TsTypeParams?
+	parameter_list: JsAnyArrowFunctionParameters?
 	'=>'
-	':'?
-	return_type:TsType?
-	manual__body:ExprOrBlock
+	return_type: TsReturnType?
+	manual__body: JsAnyArrowFunctionBody
 
-ArrowExprParams =
-	Name
-	| JsParameterList
+JsAnyArrowFunctionParameters = JsParameterList | JsIdentifierBinding
+JsAnyArrowFunctionBody = JsAnyExpression | JsFunctionBody
 
 // Object expression
 ObjectExpr = '{' props:(ObjectProp (',' ObjectProp)* ','?) '}'
@@ -747,10 +745,6 @@ JsIdentifierBinding = name: 'ident'
 // AUXILIARY
 ///////////////
 
-ExprOrBlock =
-	JsAnyExpression
-	| JsFunctionBody
-
 
 JsParameterList =
 	'('
diff --git a/xtask/src/codegen/kinds_src.rs b/xtask/src/codegen/kinds_src.rs
index fab2322949b4..5e382c6ecdab 100644
--- a/xtask/src/codegen/kinds_src.rs
+++ b/xtask/src/codegen/kinds_src.rs
@@ -256,7 +256,7 @@ pub const KINDS_SRC: KindsSrc = KindsSrc {
 		"COMPUTED_PROPERTY_NAME",
 		"FOR_OF_STMT",
 		"SINGLE_PATTERN",
-		"ARROW_EXPR",
+		"JS_ARROW_FUNCTION_EXPRESSION",
 		"JS_YIELD_EXPRESSION",
 		"CLASS_DECL",
 		"CLASS_EXPR",