git.delta.rocks / jrsonnet / refs/commits / a7bbbb48a2fd

6565
66ExprVar =66ExprVar =
67    name:Name67    name:Name
68ExprLocal =
69    'local'
70    (Bind (',' Bind)* ','?)
71    ';'
72    Expr
7368
74ExprIfThenElse =69ExprIfThenElse =
75    'if'70    'if'
91ExprError =86ExprError =
92    'error'87    'error'
93    Expr88    Expr
89
90StmtLocal =
91    'local'
92    (Bind (',' Bind)* ','?)
93    ';'
9494
95Expr =95Expr =
96    StmtLocal*
97    ExprBase
98ExprBase =
96    ExprBinary99    ExprBinary
97|   ExprUnary100|   ExprUnary
98|   ExprSlice101|   ExprSlice
109|   ExprArrayComp112|   ExprArrayComp
110|   ExprImport113|   ExprImport
111|   ExprVar114|   ExprVar
112|   ExprLocal
113|   ExprIfThenElse115|   ExprIfThenElse
114|   ExprFunction116|   ExprFunction
115|   ExprAssert117|   ExprAssert

18	}18	}
19}19}
20
21#[derive(Debug, Clone, PartialEq, Eq, Hash)]
22pub struct Expr {
23	pub(crate) syntax: SyntaxNode,
24}
25impl Expr {
26	pub fn stmt_locals(&self) -> AstChildren<StmtLocal> {
27		support::children(&self.syntax)
28	}
29	pub fn expr_base(&self) -> Option<ExprBase> {
30		support::child(&self.syntax)
31	}
32}
2033
21#[derive(Debug, Clone, PartialEq, Eq, Hash)]34#[derive(Debug, Clone, PartialEq, Eq, Hash)]
22pub struct ExprBinary {35pub struct ExprBinary {
302	}315	}
303}316}
304
305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
306pub struct ExprLocal {
307	pub(crate) syntax: SyntaxNode,
308}
309impl ExprLocal {
310	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
311		support::token(&self.syntax, T![local])
312	}
313	pub fn binds(&self) -> AstChildren<Bind> {
314		support::children(&self.syntax)
315	}
316	pub fn semi_token(&self) -> Option<SyntaxToken> {
317		support::token(&self.syntax, T![;])
318	}
319	pub fn expr(&self) -> Option<Expr> {
320		support::child(&self.syntax)
321	}
322}
323317
324#[derive(Debug, Clone, PartialEq, Eq, Hash)]318#[derive(Debug, Clone, PartialEq, Eq, Hash)]
325pub struct ExprIfThenElse {319pub struct ExprIfThenElse {
452	}446	}
453}447}
448
449#[derive(Debug, Clone, PartialEq, Eq, Hash)]
450pub struct StmtLocal {
451	pub(crate) syntax: SyntaxNode,
452}
453impl StmtLocal {
454	pub fn local_kw_token(&self) -> Option<SyntaxToken> {
455		support::token(&self.syntax, T![local])
456	}
457	pub fn binds(&self) -> AstChildren<Bind> {
458		support::children(&self.syntax)
459	}
460	pub fn semi_token(&self) -> Option<SyntaxToken> {
461		support::token(&self.syntax, T![;])
462	}
463}
454464
455#[derive(Debug, Clone, PartialEq, Eq, Hash)]465#[derive(Debug, Clone, PartialEq, Eq, Hash)]
456pub struct SliceDescEnd {466pub struct SliceDescEnd {
809	}819	}
810}820}
811
812#[derive(Debug, Clone, PartialEq, Eq, Hash)]
813pub enum Expr {
814	ExprBinary(ExprBinary),
815	ExprUnary(ExprUnary),
816	ExprSlice(ExprSlice),
817	ExprIndex(ExprIndex),
818	ExprIndexExpr(ExprIndexExpr),
819	ExprApply(ExprApply),
820	ExprObjExtend(ExprObjExtend),
821	ExprParened(ExprParened),
822	ExprString(ExprString),
823	ExprNumber(ExprNumber),
824	ExprLiteral(ExprLiteral),
825	ExprArray(ExprArray),
826	ExprObject(ExprObject),
827	ExprArrayComp(ExprArrayComp),
828	ExprImport(ExprImport),
829	ExprVar(ExprVar),
830	ExprLocal(ExprLocal),
831	ExprIfThenElse(ExprIfThenElse),
832	ExprFunction(ExprFunction),
833	ExprAssert(ExprAssert),
834	ExprError(ExprError),
835}
836821
837#[derive(Debug, Clone, PartialEq, Eq, Hash)]822#[derive(Debug, Clone, PartialEq, Eq, Hash)]
838pub enum ObjBody {823pub enum ObjBody {
852	BindFunction(BindFunction),837	BindFunction(BindFunction),
853}838}
839
840#[derive(Debug, Clone, PartialEq, Eq, Hash)]
841pub enum ExprBase {
842	ExprBinary(ExprBinary),
843	ExprUnary(ExprUnary),
844	ExprSlice(ExprSlice),
845	ExprIndex(ExprIndex),
846	ExprIndexExpr(ExprIndexExpr),
847	ExprApply(ExprApply),
848	ExprObjExtend(ExprObjExtend),
849	ExprParened(ExprParened),
850	ExprString(ExprString),
851	ExprNumber(ExprNumber),
852	ExprLiteral(ExprLiteral),
853	ExprArray(ExprArray),
854	ExprObject(ExprObject),
855	ExprArrayComp(ExprArrayComp),
856	ExprImport(ExprImport),
857	ExprVar(ExprVar),
858	ExprIfThenElse(ExprIfThenElse),
859	ExprFunction(ExprFunction),
860	ExprAssert(ExprAssert),
861	ExprError(ExprError),
862}
854863
855#[derive(Debug, Clone, PartialEq, Eq, Hash)]864#[derive(Debug, Clone, PartialEq, Eq, Hash)]
856pub enum MemberComp {865pub enum MemberComp {
1054		&self.syntax1063		&self.syntax
1055	}1064	}
1056}1065}
1066impl AstNode for Expr {
1067	fn can_cast(kind: SyntaxKind) -> bool {
1068		kind == EXPR
1069	}
1070	fn cast(syntax: SyntaxNode) -> Option<Self> {
1071		if Self::can_cast(syntax.kind()) {
1072			Some(Self { syntax })
1073		} else {
1074			None
1075		}
1076	}
1077	fn syntax(&self) -> &SyntaxNode {
1078		&self.syntax
1079	}
1080}
1057impl AstNode for ExprBinary {1081impl AstNode for ExprBinary {
1058	fn can_cast(kind: SyntaxKind) -> bool {1082	fn can_cast(kind: SyntaxKind) -> bool {
1059		kind == EXPR_BINARY1083		kind == EXPR_BINARY
1354		&self.syntax1378		&self.syntax
1355	}1379	}
1356}1380}
1357impl AstNode for ExprLocal {
1358	fn can_cast(kind: SyntaxKind) -> bool {
1359		kind == EXPR_LOCAL
1360	}
1361	fn cast(syntax: SyntaxNode) -> Option<Self> {
1362		if Self::can_cast(syntax.kind()) {
1363			Some(Self { syntax })
1364		} else {
1365			None
1366		}
1367	}
1368	fn syntax(&self) -> &SyntaxNode {
1369		&self.syntax
1370	}
1371}
1372impl AstNode for ExprIfThenElse {1381impl AstNode for ExprIfThenElse {
1373	fn can_cast(kind: SyntaxKind) -> bool {1382	fn can_cast(kind: SyntaxKind) -> bool {
1374		kind == EXPR_IF_THEN_ELSE1383		kind == EXPR_IF_THEN_ELSE
1489		&self.syntax1498		&self.syntax
1490	}1499	}
1491}1500}
1501impl AstNode for StmtLocal {
1502	fn can_cast(kind: SyntaxKind) -> bool {
1503		kind == STMT_LOCAL
1504	}
1505	fn cast(syntax: SyntaxNode) -> Option<Self> {
1506		if Self::can_cast(syntax.kind()) {
1507			Some(Self { syntax })
1508		} else {
1509			None
1510		}
1511	}
1512	fn syntax(&self) -> &SyntaxNode {
1513		&self.syntax
1514	}
1515}
1492impl AstNode for SliceDescEnd {1516impl AstNode for SliceDescEnd {
1493	fn can_cast(kind: SyntaxKind) -> bool {1517	fn can_cast(kind: SyntaxKind) -> bool {
1494		kind == SLICE_DESC_END1518		kind == SLICE_DESC_END
1849		&self.syntax1873		&self.syntax
1850	}1874	}
1851}1875}
1852impl From<ExprBinary> for Expr {
1853	fn from(node: ExprBinary) -> Expr {
1854		Expr::ExprBinary(node)
1855	}
1856}
1857impl From<ExprUnary> for Expr {
1858	fn from(node: ExprUnary) -> Expr {
1859		Expr::ExprUnary(node)
1860	}
1861}
1862impl From<ExprSlice> for Expr {
1863	fn from(node: ExprSlice) -> Expr {
1864		Expr::ExprSlice(node)
1865	}
1866}
1867impl From<ExprIndex> for Expr {
1868	fn from(node: ExprIndex) -> Expr {
1869		Expr::ExprIndex(node)
1870	}
1871}
1872impl From<ExprIndexExpr> for Expr {
1873	fn from(node: ExprIndexExpr) -> Expr {
1874		Expr::ExprIndexExpr(node)
1875	}
1876}
1877impl From<ExprApply> for Expr {
1878	fn from(node: ExprApply) -> Expr {
1879		Expr::ExprApply(node)
1880	}
1881}
1882impl From<ExprObjExtend> for Expr {
1883	fn from(node: ExprObjExtend) -> Expr {
1884		Expr::ExprObjExtend(node)
1885	}
1886}
1887impl From<ExprParened> for Expr {
1888	fn from(node: ExprParened) -> Expr {
1889		Expr::ExprParened(node)
1890	}
1891}
1892impl From<ExprString> for Expr {
1893	fn from(node: ExprString) -> Expr {
1894		Expr::ExprString(node)
1895	}
1896}
1897impl From<ExprNumber> for Expr {
1898	fn from(node: ExprNumber) -> Expr {
1899		Expr::ExprNumber(node)
1900	}
1901}
1902impl From<ExprLiteral> for Expr {
1903	fn from(node: ExprLiteral) -> Expr {
1904		Expr::ExprLiteral(node)
1905	}
1906}
1907impl From<ExprArray> for Expr {
1908	fn from(node: ExprArray) -> Expr {
1909		Expr::ExprArray(node)
1910	}
1911}
1912impl From<ExprObject> for Expr {
1913	fn from(node: ExprObject) -> Expr {
1914		Expr::ExprObject(node)
1915	}
1916}
1917impl From<ExprArrayComp> for Expr {
1918	fn from(node: ExprArrayComp) -> Expr {
1919		Expr::ExprArrayComp(node)
1920	}
1921}
1922impl From<ExprImport> for Expr {
1923	fn from(node: ExprImport) -> Expr {
1924		Expr::ExprImport(node)
1925	}
1926}
1927impl From<ExprVar> for Expr {
1928	fn from(node: ExprVar) -> Expr {
1929		Expr::ExprVar(node)
1930	}
1931}
1932impl From<ExprLocal> for Expr {
1933	fn from(node: ExprLocal) -> Expr {
1934		Expr::ExprLocal(node)
1935	}
1936}
1937impl From<ExprIfThenElse> for Expr {
1938	fn from(node: ExprIfThenElse) -> Expr {
1939		Expr::ExprIfThenElse(node)
1940	}
1941}
1942impl From<ExprFunction> for Expr {
1943	fn from(node: ExprFunction) -> Expr {
1944		Expr::ExprFunction(node)
1945	}
1946}
1947impl From<ExprAssert> for Expr {
1948	fn from(node: ExprAssert) -> Expr {
1949		Expr::ExprAssert(node)
1950	}
1951}
1952impl From<ExprError> for Expr {
1953	fn from(node: ExprError) -> Expr {
1954		Expr::ExprError(node)
1955	}
1956}
1957impl AstNode for Expr {
1958	fn can_cast(kind: SyntaxKind) -> bool {
1959		match kind {
1960			EXPR_BINARY | EXPR_UNARY | EXPR_SLICE | EXPR_INDEX | EXPR_INDEX_EXPR | EXPR_APPLY
1961			| EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING | EXPR_NUMBER | EXPR_LITERAL
1962			| EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP | EXPR_IMPORT | EXPR_VAR | EXPR_LOCAL
1963			| EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ASSERT | EXPR_ERROR => true,
1964			_ => false,
1965		}
1966	}
1967	fn cast(syntax: SyntaxNode) -> Option<Self> {
1968		let res = match syntax.kind() {
1969			EXPR_BINARY => Expr::ExprBinary(ExprBinary { syntax }),
1970			EXPR_UNARY => Expr::ExprUnary(ExprUnary { syntax }),
1971			EXPR_SLICE => Expr::ExprSlice(ExprSlice { syntax }),
1972			EXPR_INDEX => Expr::ExprIndex(ExprIndex { syntax }),
1973			EXPR_INDEX_EXPR => Expr::ExprIndexExpr(ExprIndexExpr { syntax }),
1974			EXPR_APPLY => Expr::ExprApply(ExprApply { syntax }),
1975			EXPR_OBJ_EXTEND => Expr::ExprObjExtend(ExprObjExtend { syntax }),
1976			EXPR_PARENED => Expr::ExprParened(ExprParened { syntax }),
1977			EXPR_STRING => Expr::ExprString(ExprString { syntax }),
1978			EXPR_NUMBER => Expr::ExprNumber(ExprNumber { syntax }),
1979			EXPR_LITERAL => Expr::ExprLiteral(ExprLiteral { syntax }),
1980			EXPR_ARRAY => Expr::ExprArray(ExprArray { syntax }),
1981			EXPR_OBJECT => Expr::ExprObject(ExprObject { syntax }),
1982			EXPR_ARRAY_COMP => Expr::ExprArrayComp(ExprArrayComp { syntax }),
1983			EXPR_IMPORT => Expr::ExprImport(ExprImport { syntax }),
1984			EXPR_VAR => Expr::ExprVar(ExprVar { syntax }),
1985			EXPR_LOCAL => Expr::ExprLocal(ExprLocal { syntax }),
1986			EXPR_IF_THEN_ELSE => Expr::ExprIfThenElse(ExprIfThenElse { syntax }),
1987			EXPR_FUNCTION => Expr::ExprFunction(ExprFunction { syntax }),
1988			EXPR_ASSERT => Expr::ExprAssert(ExprAssert { syntax }),
1989			EXPR_ERROR => Expr::ExprError(ExprError { syntax }),
1990			_ => return None,
1991		};
1992		Some(res)
1993	}
1994	fn syntax(&self) -> &SyntaxNode {
1995		match self {
1996			Expr::ExprBinary(it) => &it.syntax,
1997			Expr::ExprUnary(it) => &it.syntax,
1998			Expr::ExprSlice(it) => &it.syntax,
1999			Expr::ExprIndex(it) => &it.syntax,
2000			Expr::ExprIndexExpr(it) => &it.syntax,
2001			Expr::ExprApply(it) => &it.syntax,
2002			Expr::ExprObjExtend(it) => &it.syntax,
2003			Expr::ExprParened(it) => &it.syntax,
2004			Expr::ExprString(it) => &it.syntax,
2005			Expr::ExprNumber(it) => &it.syntax,
2006			Expr::ExprLiteral(it) => &it.syntax,
2007			Expr::ExprArray(it) => &it.syntax,
2008			Expr::ExprObject(it) => &it.syntax,
2009			Expr::ExprArrayComp(it) => &it.syntax,
2010			Expr::ExprImport(it) => &it.syntax,
2011			Expr::ExprVar(it) => &it.syntax,
2012			Expr::ExprLocal(it) => &it.syntax,
2013			Expr::ExprIfThenElse(it) => &it.syntax,
2014			Expr::ExprFunction(it) => &it.syntax,
2015			Expr::ExprAssert(it) => &it.syntax,
2016			Expr::ExprError(it) => &it.syntax,
2017		}
2018	}
2019}
2020impl From<ObjBodyComp> for ObjBody {1876impl From<ObjBodyComp> for ObjBody {
2021	fn from(node: ObjBodyComp) -> ObjBody {1877	fn from(node: ObjBodyComp) -> ObjBody {
2022		ObjBody::ObjBodyComp(node)1878		ObjBody::ObjBodyComp(node)
2113		}1969		}
2114	}1970	}
2115}1971}
1972impl From<ExprBinary> for ExprBase {
1973	fn from(node: ExprBinary) -> ExprBase {
1974		ExprBase::ExprBinary(node)
1975	}
1976}
1977impl From<ExprUnary> for ExprBase {
1978	fn from(node: ExprUnary) -> ExprBase {
1979		ExprBase::ExprUnary(node)
1980	}
1981}
1982impl From<ExprSlice> for ExprBase {
1983	fn from(node: ExprSlice) -> ExprBase {
1984		ExprBase::ExprSlice(node)
1985	}
1986}
1987impl From<ExprIndex> for ExprBase {
1988	fn from(node: ExprIndex) -> ExprBase {
1989		ExprBase::ExprIndex(node)
1990	}
1991}
1992impl From<ExprIndexExpr> for ExprBase {
1993	fn from(node: ExprIndexExpr) -> ExprBase {
1994		ExprBase::ExprIndexExpr(node)
1995	}
1996}
1997impl From<ExprApply> for ExprBase {
1998	fn from(node: ExprApply) -> ExprBase {
1999		ExprBase::ExprApply(node)
2000	}
2001}
2002impl From<ExprObjExtend> for ExprBase {
2003	fn from(node: ExprObjExtend) -> ExprBase {
2004		ExprBase::ExprObjExtend(node)
2005	}
2006}
2007impl From<ExprParened> for ExprBase {
2008	fn from(node: ExprParened) -> ExprBase {
2009		ExprBase::ExprParened(node)
2010	}
2011}
2012impl From<ExprString> for ExprBase {
2013	fn from(node: ExprString) -> ExprBase {
2014		ExprBase::ExprString(node)
2015	}
2016}
2017impl From<ExprNumber> for ExprBase {
2018	fn from(node: ExprNumber) -> ExprBase {
2019		ExprBase::ExprNumber(node)
2020	}
2021}
2022impl From<ExprLiteral> for ExprBase {
2023	fn from(node: ExprLiteral) -> ExprBase {
2024		ExprBase::ExprLiteral(node)
2025	}
2026}
2027impl From<ExprArray> for ExprBase {
2028	fn from(node: ExprArray) -> ExprBase {
2029		ExprBase::ExprArray(node)
2030	}
2031}
2032impl From<ExprObject> for ExprBase {
2033	fn from(node: ExprObject) -> ExprBase {
2034		ExprBase::ExprObject(node)
2035	}
2036}
2037impl From<ExprArrayComp> for ExprBase {
2038	fn from(node: ExprArrayComp) -> ExprBase {
2039		ExprBase::ExprArrayComp(node)
2040	}
2041}
2042impl From<ExprImport> for ExprBase {
2043	fn from(node: ExprImport) -> ExprBase {
2044		ExprBase::ExprImport(node)
2045	}
2046}
2047impl From<ExprVar> for ExprBase {
2048	fn from(node: ExprVar) -> ExprBase {
2049		ExprBase::ExprVar(node)
2050	}
2051}
2052impl From<ExprIfThenElse> for ExprBase {
2053	fn from(node: ExprIfThenElse) -> ExprBase {
2054		ExprBase::ExprIfThenElse(node)
2055	}
2056}
2057impl From<ExprFunction> for ExprBase {
2058	fn from(node: ExprFunction) -> ExprBase {
2059		ExprBase::ExprFunction(node)
2060	}
2061}
2062impl From<ExprAssert> for ExprBase {
2063	fn from(node: ExprAssert) -> ExprBase {
2064		ExprBase::ExprAssert(node)
2065	}
2066}
2067impl From<ExprError> for ExprBase {
2068	fn from(node: ExprError) -> ExprBase {
2069		ExprBase::ExprError(node)
2070	}
2071}
2072impl AstNode for ExprBase {
2073	fn can_cast(kind: SyntaxKind) -> bool {
2074		match kind {
2075			EXPR_BINARY | EXPR_UNARY | EXPR_SLICE | EXPR_INDEX | EXPR_INDEX_EXPR | EXPR_APPLY
2076			| EXPR_OBJ_EXTEND | EXPR_PARENED | EXPR_STRING | EXPR_NUMBER | EXPR_LITERAL
2077			| EXPR_ARRAY | EXPR_OBJECT | EXPR_ARRAY_COMP | EXPR_IMPORT | EXPR_VAR
2078			| EXPR_IF_THEN_ELSE | EXPR_FUNCTION | EXPR_ASSERT | EXPR_ERROR => true,
2079			_ => false,
2080		}
2081	}
2082	fn cast(syntax: SyntaxNode) -> Option<Self> {
2083		let res = match syntax.kind() {
2084			EXPR_BINARY => ExprBase::ExprBinary(ExprBinary { syntax }),
2085			EXPR_UNARY => ExprBase::ExprUnary(ExprUnary { syntax }),
2086			EXPR_SLICE => ExprBase::ExprSlice(ExprSlice { syntax }),
2087			EXPR_INDEX => ExprBase::ExprIndex(ExprIndex { syntax }),
2088			EXPR_INDEX_EXPR => ExprBase::ExprIndexExpr(ExprIndexExpr { syntax }),
2089			EXPR_APPLY => ExprBase::ExprApply(ExprApply { syntax }),
2090			EXPR_OBJ_EXTEND => ExprBase::ExprObjExtend(ExprObjExtend { syntax }),
2091			EXPR_PARENED => ExprBase::ExprParened(ExprParened { syntax }),
2092			EXPR_STRING => ExprBase::ExprString(ExprString { syntax }),
2093			EXPR_NUMBER => ExprBase::ExprNumber(ExprNumber { syntax }),
2094			EXPR_LITERAL => ExprBase::ExprLiteral(ExprLiteral { syntax }),
2095			EXPR_ARRAY => ExprBase::ExprArray(ExprArray { syntax }),
2096			EXPR_OBJECT => ExprBase::ExprObject(ExprObject { syntax }),
2097			EXPR_ARRAY_COMP => ExprBase::ExprArrayComp(ExprArrayComp { syntax }),
2098			EXPR_IMPORT => ExprBase::ExprImport(ExprImport { syntax }),
2099			EXPR_VAR => ExprBase::ExprVar(ExprVar { syntax }),
2100			EXPR_IF_THEN_ELSE => ExprBase::ExprIfThenElse(ExprIfThenElse { syntax }),
2101			EXPR_FUNCTION => ExprBase::ExprFunction(ExprFunction { syntax }),
2102			EXPR_ASSERT => ExprBase::ExprAssert(ExprAssert { syntax }),
2103			EXPR_ERROR => ExprBase::ExprError(ExprError { syntax }),
2104			_ => return None,
2105		};
2106		Some(res)
2107	}
2108	fn syntax(&self) -> &SyntaxNode {
2109		match self {
2110			ExprBase::ExprBinary(it) => &it.syntax,
2111			ExprBase::ExprUnary(it) => &it.syntax,
2112			ExprBase::ExprSlice(it) => &it.syntax,
2113			ExprBase::ExprIndex(it) => &it.syntax,
2114			ExprBase::ExprIndexExpr(it) => &it.syntax,
2115			ExprBase::ExprApply(it) => &it.syntax,
2116			ExprBase::ExprObjExtend(it) => &it.syntax,
2117			ExprBase::ExprParened(it) => &it.syntax,
2118			ExprBase::ExprString(it) => &it.syntax,
2119			ExprBase::ExprNumber(it) => &it.syntax,
2120			ExprBase::ExprLiteral(it) => &it.syntax,
2121			ExprBase::ExprArray(it) => &it.syntax,
2122			ExprBase::ExprObject(it) => &it.syntax,
2123			ExprBase::ExprArrayComp(it) => &it.syntax,
2124			ExprBase::ExprImport(it) => &it.syntax,
2125			ExprBase::ExprVar(it) => &it.syntax,
2126			ExprBase::ExprIfThenElse(it) => &it.syntax,
2127			ExprBase::ExprFunction(it) => &it.syntax,
2128			ExprBase::ExprAssert(it) => &it.syntax,
2129			ExprBase::ExprError(it) => &it.syntax,
2130		}
2131	}
2132}
2116impl From<MemberBindStmt> for MemberComp {2133impl From<MemberBindStmt> for MemberComp {
2117	fn from(node: MemberBindStmt) -> MemberComp {2134	fn from(node: MemberBindStmt) -> MemberComp {
2118		MemberComp::MemberBindStmt(node)2135		MemberComp::MemberBindStmt(node)
2725		std::fmt::Display::fmt(self.syntax(), f)2742		std::fmt::Display::fmt(self.syntax(), f)
2726	}2743	}
2727}2744}
2728impl std::fmt::Display for Expr {
2729	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2730		std::fmt::Display::fmt(self.syntax(), f)
2731	}
2732}
2733impl std::fmt::Display for ObjBody {2745impl std::fmt::Display for ObjBody {
2734	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2746	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2735		std::fmt::Display::fmt(self.syntax(), f)2747		std::fmt::Display::fmt(self.syntax(), f)
2745		std::fmt::Display::fmt(self.syntax(), f)2757		std::fmt::Display::fmt(self.syntax(), f)
2746	}2758	}
2747}2759}
2760impl std::fmt::Display for ExprBase {
2761	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2762		std::fmt::Display::fmt(self.syntax(), f)
2763	}
2764}
2748impl std::fmt::Display for MemberComp {2765impl std::fmt::Display for MemberComp {
2749	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2766	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2750		std::fmt::Display::fmt(self.syntax(), f)2767		std::fmt::Display::fmt(self.syntax(), f)
2775		std::fmt::Display::fmt(self.syntax(), f)2792		std::fmt::Display::fmt(self.syntax(), f)
2776	}2793	}
2777}2794}
2795impl std::fmt::Display for Expr {
2796	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2797		std::fmt::Display::fmt(self.syntax(), f)
2798	}
2799}
2778impl std::fmt::Display for ExprBinary {2800impl std::fmt::Display for ExprBinary {
2779	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2801	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2780		std::fmt::Display::fmt(self.syntax(), f)2802		std::fmt::Display::fmt(self.syntax(), f)
2875		std::fmt::Display::fmt(self.syntax(), f)2897		std::fmt::Display::fmt(self.syntax(), f)
2876	}2898	}
2877}2899}
2878impl std::fmt::Display for ExprLocal {
2879	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2880		std::fmt::Display::fmt(self.syntax(), f)
2881	}
2882}
2883impl std::fmt::Display for ExprIfThenElse {2900impl std::fmt::Display for ExprIfThenElse {
2884	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2901	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2885		std::fmt::Display::fmt(self.syntax(), f)2902		std::fmt::Display::fmt(self.syntax(), f)
2920		std::fmt::Display::fmt(self.syntax(), f)2937		std::fmt::Display::fmt(self.syntax(), f)
2921	}2938	}
2922}2939}
2940impl std::fmt::Display for StmtLocal {
2941	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2942		std::fmt::Display::fmt(self.syntax(), f)
2943	}
2944}
2923impl std::fmt::Display for SliceDescEnd {2945impl std::fmt::Display for SliceDescEnd {
2924	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {2946	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2925		std::fmt::Display::fmt(self.syntax(), f)2947		std::fmt::Display::fmt(self.syntax(), f)

143	IMPORTBIN_KW,143	IMPORTBIN_KW,
144	#[token("import")]144	#[token("import")]
145	IMPORT_KW,145	IMPORT_KW,
146	#[token("local")]
147	LOCAL_KW,
148	#[token("if")]146	#[token("if")]
149	IF_KW,147	IF_KW,
150	#[token("then")]148	#[token("then")]
155	FUNCTION_KW,153	FUNCTION_KW,
156	#[token("error")]154	#[token("error")]
157	ERROR_KW,155	ERROR_KW,
156	#[token("local")]
157	LOCAL_KW,
158	#[token("in")]158	#[token("in")]
159	IN_KW,159	IN_KW,
160	META_OBJECT_APPLY,160	META_OBJECT_APPLY,
180	#[error]180	#[error]
181	LEXING_ERROR,181	LEXING_ERROR,
182	SOURCE_FILE,182	SOURCE_FILE,
183	EXPR,
183	EXPR_BINARY,184	EXPR_BINARY,
184	LHS_EXPR,185	LHS_EXPR,
185	EXPR_UNARY,186	EXPR_UNARY,
200	EXPR_ARRAY_COMP,201	EXPR_ARRAY_COMP,
201	EXPR_IMPORT,202	EXPR_IMPORT,
202	EXPR_VAR,203	EXPR_VAR,
203	EXPR_LOCAL,
204	EXPR_IF_THEN_ELSE,204	EXPR_IF_THEN_ELSE,
205	TRUE_EXPR,205	TRUE_EXPR,
206	FALSE_EXPR,206	FALSE_EXPR,
209	EXPR_ASSERT,209	EXPR_ASSERT,
210	ASSERTION,210	ASSERTION,
211	EXPR_ERROR,211	EXPR_ERROR,
212	STMT_LOCAL,
212	SLICE_DESC_END,213	SLICE_DESC_END,
213	SLICE_DESC_STEP,214	SLICE_DESC_STEP,
214	ARG,215	ARG,
233	DESTRUCT_OBJECT_FIELD,234	DESTRUCT_OBJECT_FIELD,
234	DESTRUCT_REST,235	DESTRUCT_REST,
235	DESTRUCT_ARRAY_ELEMENT,236	DESTRUCT_ARRAY_ELEMENT,
236	EXPR,
237	OBJ_BODY,237	OBJ_BODY,
238	COMP_SPEC,238	COMP_SPEC,
239	BIND,239	BIND,
240	EXPR_BASE,
240	MEMBER_COMP,241	MEMBER_COMP,
241	MEMBER,242	MEMBER,
242	FIELD_NAME,243	FIELD_NAME,
262			| PLUS | MINUS | MUL | DIV | MODULO | NOT | BIT_NOT | L_BRACK | R_BRACK | L_PAREN263			| PLUS | MINUS | MUL | DIV | MODULO | NOT | BIT_NOT | L_BRACK | R_BRACK | L_PAREN
263			| R_PAREN | L_BRACE | R_BRACE | COLON | COLONCOLON | COLONCOLONCOLON | SEMI | DOT264			| R_PAREN | L_BRACE | R_BRACE | COLON | COLONCOLON | COLONCOLONCOLON | SEMI | DOT
264			| DOTDOTDOT | COMMA | DOLLAR | ASSIGN | QUESTION_MARK | TAILSTRICT_KW265			| DOTDOTDOT | COMMA | DOLLAR | ASSIGN | QUESTION_MARK | TAILSTRICT_KW
265			| IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW | LOCAL_KW | IF_KW | THEN_KW | ELSE_KW266			| IMPORTSTR_KW | IMPORTBIN_KW | IMPORT_KW | IF_KW | THEN_KW | ELSE_KW | FUNCTION_KW
266			| FUNCTION_KW | ERROR_KW | IN_KW | NULL_KW | TRUE_KW | FALSE_KW | SELF_KW267			| ERROR_KW | LOCAL_KW | IN_KW | NULL_KW | TRUE_KW | FALSE_KW | SELF_KW | SUPER_KW
267			| SUPER_KW | FOR_KW | ASSERT_KW => true,268			| FOR_KW | ASSERT_KW => true,
268			_ => false,269			_ => false,
269		}270		}
270	}271	}
271	pub fn is_enum(self) -> bool {272	pub fn is_enum(self) -> bool {
272		match self {273		match self {
273			EXPR | OBJ_BODY | COMP_SPEC | BIND | MEMBER_COMP | MEMBER | FIELD_NAME | DESTRUCT274			OBJ_BODY | COMP_SPEC | BIND | EXPR_BASE | MEMBER_COMP | MEMBER | FIELD_NAME
274			| DESTRUCT_ARRAY_PART | BINARY_OPERATOR | UNARY_OPERATOR | LITERAL | TEXT | NUMBER275			| DESTRUCT | DESTRUCT_ARRAY_PART | BINARY_OPERATOR | UNARY_OPERATOR | LITERAL
275			| IMPORT_KIND | VISIBILITY | TRIVIA | CUSTOM_ERROR => true,276			| TEXT | NUMBER | IMPORT_KIND | VISIBILITY | TRIVIA | CUSTOM_ERROR => true,
276			_ => false,277			_ => false,
277		}278		}
278	}279	}
285	}286	}
286}287}
287#[macro_export]288#[macro_export]
288macro_rules ! T { [||] => { $ crate :: SyntaxKind :: OR } ; [&&] => { $ crate :: SyntaxKind :: AND } ; [|] => { $ crate :: SyntaxKind :: BIT_OR } ; [^] => { $ crate :: SyntaxKind :: BIT_XOR } ; [&] => { $ crate :: SyntaxKind :: BIT_AND } ; [==] => { $ crate :: SyntaxKind :: EQ } ; [!=] => { $ crate :: SyntaxKind :: NE } ; [<] => { $ crate :: SyntaxKind :: LT } ; [>] => { $ crate :: SyntaxKind :: GT } ; [<=] => { $ crate :: SyntaxKind :: LE } ; [>=] => { $ crate :: SyntaxKind :: GE } ; [<<] => { $ crate :: SyntaxKind :: LHS } ; [>>] => { $ crate :: SyntaxKind :: RHS } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [*] => { $ crate :: SyntaxKind :: MUL } ; [/] => { $ crate :: SyntaxKind :: DIV } ; [%] => { $ crate :: SyntaxKind :: MODULO } ; [!] => { $ crate :: SyntaxKind :: NOT } ; [~] => { $ crate :: SyntaxKind :: BIT_NOT } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_BRACE } ; ['}'] => { $ crate :: SyntaxKind :: R_BRACE } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLONCOLON } ; [:::] => { $ crate :: SyntaxKind :: COLONCOLONCOLON } ; [;] => { $ crate :: SyntaxKind :: SEMI } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [...] => { $ crate :: SyntaxKind :: DOTDOTDOT } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['$'] => { $ crate :: SyntaxKind :: DOLLAR } ; [=] => { $ crate :: SyntaxKind :: ASSIGN } ; [?] => { $ crate :: SyntaxKind :: QUESTION_MARK } ; [tailstrict] => { $ crate :: SyntaxKind :: TAILSTRICT_KW } ; [importstr] => { $ crate :: SyntaxKind :: IMPORTSTR_KW } ; [importbin] => { $ crate :: SyntaxKind :: IMPORTBIN_KW } ; [import] => { $ crate :: SyntaxKind :: IMPORT_KW } ; [local] => { $ crate :: SyntaxKind :: LOCAL_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [then] => { $ crate :: SyntaxKind :: THEN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [function] => { $ crate :: SyntaxKind :: FUNCTION_KW } ; [error] => { $ crate :: SyntaxKind :: ERROR_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [null] => { $ crate :: SyntaxKind :: NULL_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [assert] => { $ crate :: SyntaxKind :: ASSERT_KW } }289macro_rules ! T { [||] => { $ crate :: SyntaxKind :: OR } ; [&&] => { $ crate :: SyntaxKind :: AND } ; [|] => { $ crate :: SyntaxKind :: BIT_OR } ; [^] => { $ crate :: SyntaxKind :: BIT_XOR } ; [&] => { $ crate :: SyntaxKind :: BIT_AND } ; [==] => { $ crate :: SyntaxKind :: EQ } ; [!=] => { $ crate :: SyntaxKind :: NE } ; [<] => { $ crate :: SyntaxKind :: LT } ; [>] => { $ crate :: SyntaxKind :: GT } ; [<=] => { $ crate :: SyntaxKind :: LE } ; [>=] => { $ crate :: SyntaxKind :: GE } ; [<<] => { $ crate :: SyntaxKind :: LHS } ; [>>] => { $ crate :: SyntaxKind :: RHS } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [*] => { $ crate :: SyntaxKind :: MUL } ; [/] => { $ crate :: SyntaxKind :: DIV } ; [%] => { $ crate :: SyntaxKind :: MODULO } ; [!] => { $ crate :: SyntaxKind :: NOT } ; [~] => { $ crate :: SyntaxKind :: BIT_NOT } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_BRACE } ; ['}'] => { $ crate :: SyntaxKind :: R_BRACE } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLONCOLON } ; [:::] => { $ crate :: SyntaxKind :: COLONCOLONCOLON } ; [;] => { $ crate :: SyntaxKind :: SEMI } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [...] => { $ crate :: SyntaxKind :: DOTDOTDOT } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['$'] => { $ crate :: SyntaxKind :: DOLLAR } ; [=] => { $ crate :: SyntaxKind :: ASSIGN } ; [?] => { $ crate :: SyntaxKind :: QUESTION_MARK } ; [tailstrict] => { $ crate :: SyntaxKind :: TAILSTRICT_KW } ; [importstr] => { $ crate :: SyntaxKind :: IMPORTSTR_KW } ; [importbin] => { $ crate :: SyntaxKind :: IMPORTBIN_KW } ; [import] => { $ crate :: SyntaxKind :: IMPORT_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [then] => { $ crate :: SyntaxKind :: THEN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [function] => { $ crate :: SyntaxKind :: FUNCTION_KW } ; [error] => { $ crate :: SyntaxKind :: ERROR_KW } ; [local] => { $ crate :: SyntaxKind :: LOCAL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [null] => { $ crate :: SyntaxKind :: NULL_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [assert] => { $ crate :: SyntaxKind :: ASSERT_KW } }
289pub use T;290pub use T;
290291