Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-11-10 07:04:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge #3923

Browse source 
3923: Cleanup keyword accessors r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2020-04-09 21:47:34 +00:00 committed by GitHub
commit 176f7f6117
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 151 additions and 1060 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/ra_assists/src/handlers/inline_local_variable.rs
View file

@ -29,7 +29,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
ast::Pat::BindPat(pat) => pat,
_ => return None,
};
if bind_pat.mut_kw_token().is_some() {
if bind_pat.mut_token().is_some() {
tested_by!(test_not_inline_mut_variable);
return None;
}

10
crates/ra_hir_def/src/body/lower.rs
View file

@ -372,7 +372,7 @@ impl ExprCollector<'_> {
}
ast::Expr::RefExpr(e) => {
let expr = self.collect_expr_opt(e.expr());
let mutability = Mutability::from_mutable(e.is_mut());
let mutability = Mutability::from_mutable(e.mut_token().is_some());
self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
}
ast::Expr::PrefixExpr(e) => {
@ -587,10 +587,8 @@ impl ExprCollector<'_> {
let pattern = match &pat {
ast::Pat::BindPat(bp) => {
let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
let annotation = BindingAnnotation::new(
bp.mut_kw_token().is_some(),
bp.ref_kw_token().is_some(),
);
let annotation =
BindingAnnotation::new(bp.mut_token().is_some(), bp.ref_token().is_some());
let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
// This could also be a single-segment path pattern. To
@ -631,7 +629,7 @@ impl ExprCollector<'_> {
}
ast::Pat::RefPat(p) => {
let pat = self.collect_pat_opt(p.pat());
let mutability = Mutability::from_mutable(p.mut_kw_token().is_some());
let mutability = Mutability::from_mutable(p.mut_token().is_some());
Pat::Ref { pat, mutability }
}
ast::Pat::PathPat(p) => {

4
crates/ra_hir_def/src/data.rs
View file

@ -74,7 +74,7 @@ impl FunctionData {
TypeRef::unit()
};
let ret_type = if src.value.async_kw_token().is_some() {
let ret_type = if src.value.async_token().is_some() {
let future_impl = desugar_future_path(ret_type);
let ty_bound = TypeBound::Path(future_impl);
TypeRef::ImplTrait(vec![ty_bound])
@ -135,7 +135,7 @@ impl TraitData {
pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
let src = tr.lookup(db).source(db);
let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
let auto = src.value.auto_kw_token().is_some();
let auto = src.value.auto_token().is_some();
let ast_id_map = db.ast_id_map(src.file_id);
let container = AssocContainerId::TraitId(tr);

4
crates/ra_hir_def/src/type_ref.rs
View file

@ -77,7 +77,7 @@ impl TypeRef {
}
ast::TypeRef::PointerType(inner) => {
let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
let mutability = Mutability::from_mutable(inner.mut_token().is_some());
TypeRef::RawPtr(Box::new(inner_ty), mutability)
}
ast::TypeRef::ArrayType(inner) => {
@ -88,7 +88,7 @@ impl TypeRef {
}
ast::TypeRef::ReferenceType(inner) => {
let inner_ty = TypeRef::from_ast_opt(inner.type_ref());
let mutability = Mutability::from_mutable(inner.mut_kw_token().is_some());
let mutability = Mutability::from_mutable(inner.mut_token().is_some());
TypeRef::Reference(Box::new(inner_ty), mutability)
}
ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,

4
crates/ra_hir_ty/src/tests.rs
View file

@ -23,7 +23,7 @@ use insta::assert_snapshot;
use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
use ra_syntax::{
algo,
ast::{self, AstNode, AstToken},
ast::{self, AstNode},
};
use stdx::format_to;
@ -101,7 +101,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
let node = src_ptr.value.to_node(&src_ptr.file_syntax(&db));
let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) {
(self_param.self_kw_token().unwrap().syntax().text_range(), "self".to_string())
(self_param.self_token().unwrap().text_range(), "self".to_string())
} else {
(src_ptr.value.range(), node.text().to_string().replace("\n", " "))
};

30
crates/ra_ide/src/completion/complete_fn_param.rs
View file

@ -1,6 +1,9 @@
//! FIXME: write short doc here
use ra_syntax::{ast, match_ast, AstNode};
use ra_syntax::{
ast::{self, ModuleItemOwner},
match_ast, AstNode,
};
use rustc_hash::FxHashMap;
use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
@ -16,11 +19,19 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
let mut params = FxHashMap::default();
for node in ctx.token.parent().ancestors() {
match_ast! {
let items = match_ast! {
match node {
ast::SourceFile(it) => process(it, &mut params),
ast::ItemList(it) => process(it, &mut params),
_ => (),
ast::SourceFile(it) => it.items(),
ast::ItemList(it) => it.items(),
_ => continue,
}
};
for item in items {
if let ast::ModuleItem::FnDef(func) = item {
func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
let text = param.syntax().text().to_string();
params.entry(text).or_insert((0, param)).0 += 1;
})
}
}
}
@ -39,15 +50,6 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
.lookup_by(lookup)
.add_to(acc)
});
fn process<N: ast::FnDefOwner>(node: N, params: &mut FxHashMap<String, (u32, ast::Param)>) {
node.functions().filter_map(|it| it.param_list()).flat_map(|it| it.params()).for_each(
|param| {
let text = param.syntax().text().to_string();
params.entry(text).or_insert((0, param)).0 += 1;
},
)
}
}
#[cfg(test)]

4
crates/ra_ide/src/completion/completion_context.rs
View file

@ -191,8 +191,8 @@ impl<'a> CompletionContext<'a> {
if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
self.is_pat_binding_or_const = true;
if bind_pat.at_token().is_some()
|| bind_pat.ref_kw_token().is_some()
|| bind_pat.mut_kw_token().is_some()
|| bind_pat.ref_token().is_some()
|| bind_pat.mut_token().is_some()
{
self.is_pat_binding_or_const = false;
}

2
crates/ra_ide/src/references.rs
View file

@ -152,7 +152,7 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio
if stmt.initializer().is_some() {
let pat = stmt.pat()?;
if let ast::Pat::BindPat(it) = pat {
if it.mut_kw_token().is_some() {
if it.mut_token().is_some() {
return Some(ReferenceAccess::Write);
}
}

6
crates/ra_syntax/src/ast.rs
View file

@ -80,7 +80,7 @@ impl<N: AstNode> Iterator for AstChildren<N> {
}
mod support {
use super::{AstChildren, AstNode, AstToken, SyntaxNode};
use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
parent.children().find_map(N::cast)
@ -93,6 +93,10 @@ mod support {
pub(super) fn token<T: AstToken>(parent: &SyntaxNode) -> Option<T> {
parent.children_with_tokens().filter_map(|it| it.into_token()).find_map(T::cast)
}
pub(super) fn token2(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind)
}
}
#[test]

10
crates/ra_syntax/src/ast/expr_extensions.rs
View file

@ -48,16 +48,6 @@ impl ast::IfExpr {
}
}
impl ast::RefExpr {
pub fn is_mut(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
pub fn raw_token(&self) -> Option<SyntaxToken> {
None // FIXME: implement &raw
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum PrefixOp {
/// The `*` operator for dereferencing

18
crates/ra_syntax/src/ast/extensions.rs
View file

@ -279,7 +279,7 @@ pub enum SelfParamKind {
impl ast::SelfParam {
pub fn kind(&self) -> SelfParamKind {
if self.amp_token().is_some() {
if self.amp_mut_kw_token().is_some() {
if self.amp_mut_token().is_some() {
SelfParamKind::MutRef
} else {
SelfParamKind::Ref
@ -290,21 +290,21 @@ impl ast::SelfParam {
}
/// the "mut" in "mut self", not the one in "&mut self"
pub fn mut_kw_token(&self) -> Option<ast::MutKw> {
pub fn mut_token(&self) -> Option<SyntaxToken> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.take_while(|it| it.kind() != T![&])
.find_map(ast::MutKw::cast)
.find(|it| it.kind() == T![mut])
}
/// the "mut" in "&mut self", not the one in "mut self"
pub fn amp_mut_kw_token(&self) -> Option<ast::MutKw> {
pub fn amp_mut_token(&self) -> Option<SyntaxToken> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
.skip_while(|it| it.kind() != T![&])
.find_map(ast::MutKw::cast)
.find(|it| it.kind() == T![mut])
}
}
@ -340,7 +340,7 @@ impl ast::TypeBound {
}
pub fn question_token(&self) -> Option<ast::Question> {
if self.const_kw_token().is_some() {
if self.const_token().is_some() {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
@ -364,11 +364,11 @@ impl ast::Visibility {
pub fn kind(&self) -> VisibilityKind {
if let Some(path) = support::children(self.syntax()).next() {
VisibilityKind::In(path)
} else if self.crate_kw_token().is_some() {
} else if self.crate_token().is_some() {
VisibilityKind::PubCrate
} else if self.super_kw_token().is_some() {
} else if self.super_token().is_some() {
VisibilityKind::PubSuper
} else if self.self_kw_token().is_some() {
} else if self.self_token().is_some() {
VisibilityKind::PubSuper
} else {
VisibilityKind::Pub

144
crates/ra_syntax/src/ast/generated/nodes.rs
View file

@ -4,7 +4,7 @@ use super::tokens::*;
use crate::{
ast::{self, support, AstChildren, AstNode},
SyntaxKind::{self, *},
SyntaxNode,
SyntaxNode, SyntaxToken,
};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SourceFile {
@ -22,7 +22,6 @@ impl AstNode for SourceFile {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ast::ModuleItemOwner for SourceFile {}
impl ast::FnDefOwner for SourceFile {}
impl ast::AttrsOwner for SourceFile {}
impl SourceFile {
pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
@ -49,11 +48,11 @@ impl ast::DocCommentsOwner for FnDef {}
impl ast::AttrsOwner for FnDef {}
impl FnDef {
pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
pub fn async_kw_token(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
pub fn fn_kw_token(&self) -> Option<FnKw> { support::token(&self.syntax) }
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) }
pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) }
pub fn async_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ASYNC_KW) }
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) }
pub fn fn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FN_KW) }
pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
@ -99,7 +98,7 @@ impl ast::TypeParamsOwner for StructDef {}
impl ast::AttrsOwner for StructDef {}
impl ast::DocCommentsOwner for StructDef {}
impl StructDef {
pub fn struct_kw_token(&self) -> Option<StructKw> { support::token(&self.syntax) }
pub fn struct_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STRUCT_KW) }
pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
}
@ -124,7 +123,7 @@ impl ast::TypeParamsOwner for UnionDef {}
impl ast::AttrsOwner for UnionDef {}
impl ast::DocCommentsOwner for UnionDef {}
impl UnionDef {
pub fn union_kw_token(&self) -> Option<UnionKw> { support::token(&self.syntax) }
pub fn union_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNION_KW) }
pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
support::child(&self.syntax)
}
@ -231,7 +230,7 @@ impl ast::TypeParamsOwner for EnumDef {}
impl ast::AttrsOwner for EnumDef {}
impl ast::DocCommentsOwner for EnumDef {}
impl EnumDef {
pub fn enum_kw_token(&self) -> Option<EnumKw> { support::token(&self.syntax) }
pub fn enum_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ENUM_KW) }
pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -300,9 +299,9 @@ impl ast::DocCommentsOwner for TraitDef {}
impl ast::TypeParamsOwner for TraitDef {}
impl ast::TypeBoundsOwner for TraitDef {}
impl TraitDef {
pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
pub fn auto_kw_token(&self) -> Option<AutoKw> { support::token(&self.syntax) }
pub fn trait_kw_token(&self) -> Option<TraitKw> { support::token(&self.syntax) }
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) }
pub fn auto_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AUTO_KW) }
pub fn trait_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRAIT_KW) }
pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -325,7 +324,7 @@ impl ast::NameOwner for Module {}
impl ast::AttrsOwner for Module {}
impl ast::DocCommentsOwner for Module {}
impl Module {
pub fn mod_kw_token(&self) -> Option<ModKw> { support::token(&self.syntax) }
pub fn mod_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MOD_KW) }
pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
}
@ -344,7 +343,6 @@ impl AstNode for ItemList {
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ast::FnDefOwner for ItemList {}
impl ast::ModuleItemOwner for ItemList {}
impl ItemList {
pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }
@ -373,8 +371,8 @@ impl ast::AttrsOwner for ConstDef {}
impl ast::DocCommentsOwner for ConstDef {}
impl ast::TypeAscriptionOwner for ConstDef {}
impl ConstDef {
pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) }
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
@ -401,8 +399,8 @@ impl ast::AttrsOwner for StaticDef {}
impl ast::DocCommentsOwner for StaticDef {}
impl ast::TypeAscriptionOwner for StaticDef {}
impl StaticDef {
pub fn static_kw_token(&self) -> Option<StaticKw> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn static_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STATIC_KW) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
@ -429,8 +427,8 @@ impl ast::AttrsOwner for TypeAliasDef {}
impl ast::DocCommentsOwner for TypeAliasDef {}
impl ast::TypeBoundsOwner for TypeAliasDef {}
impl TypeAliasDef {
pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
pub fn type_kw_token(&self) -> Option<TypeKw> { support::token(&self.syntax) }
pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) }
pub fn type_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TYPE_KW) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
@ -453,12 +451,12 @@ impl AstNode for ImplDef {
impl ast::TypeParamsOwner for ImplDef {}
impl ast::AttrsOwner for ImplDef {}
impl ImplDef {
pub fn default_kw_token(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
pub fn impl_kw_token(&self) -> Option<ImplKw> { support::token(&self.syntax) }
pub fn default_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DEFAULT_KW) }
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) }
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) }
pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IMPL_KW) }
pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) }
pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -554,8 +552,8 @@ impl AstNode for PointerType {
}
impl PointerType {
pub fn star_token(&self) -> Option<Star> { support::token(&self.syntax) }
pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -618,7 +616,7 @@ impl AstNode for ReferenceType {
impl ReferenceType {
pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -656,8 +654,8 @@ impl AstNode for FnPointerType {
}
impl FnPointerType {
pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
pub fn fn_kw_token(&self) -> Option<FnKw> { support::token(&self.syntax) }
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) }
pub fn fn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FN_KW) }
pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
}
@ -677,7 +675,7 @@ impl AstNode for ForType {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ForType {
pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) }
pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
@ -698,7 +696,7 @@ impl AstNode for ImplTraitType {
}
impl ast::TypeBoundsOwner for ImplTraitType {}
impl ImplTraitType {
pub fn impl_kw_token(&self) -> Option<ImplKw> { support::token(&self.syntax) }
pub fn impl_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IMPL_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DynTraitType {
@ -717,7 +715,7 @@ impl AstNode for DynTraitType {
}
impl ast::TypeBoundsOwner for DynTraitType {}
impl DynTraitType {
pub fn dyn_kw_token(&self) -> Option<DynKw> { support::token(&self.syntax) }
pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, DYN_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TupleExpr {
@ -818,9 +816,9 @@ impl AstNode for LambdaExpr {
}
impl ast::AttrsOwner for LambdaExpr {}
impl LambdaExpr {
pub fn static_kw_token(&self) -> Option<StaticKw> { support::token(&self.syntax) }
pub fn async_kw_token(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
pub fn move_kw_token(&self) -> Option<MoveKw> { support::token(&self.syntax) }
pub fn static_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, STATIC_KW) }
pub fn async_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, ASYNC_KW) }
pub fn move_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MOVE_KW) }
pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
@ -842,7 +840,7 @@ impl AstNode for IfExpr {
}
impl ast::AttrsOwner for IfExpr {}
impl IfExpr {
pub fn if_kw_token(&self) -> Option<IfKw> { support::token(&self.syntax) }
pub fn if_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IF_KW) }
pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -863,7 +861,7 @@ impl AstNode for LoopExpr {
impl ast::AttrsOwner for LoopExpr {}
impl ast::LoopBodyOwner for LoopExpr {}
impl LoopExpr {
pub fn loop_kw_token(&self) -> Option<LoopKw> { support::token(&self.syntax) }
pub fn loop_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LOOP_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TryBlockExpr {
@ -882,7 +880,7 @@ impl AstNode for TryBlockExpr {
}
impl ast::AttrsOwner for TryBlockExpr {}
impl TryBlockExpr {
pub fn try_kw_token(&self) -> Option<TryKw> { support::token(&self.syntax) }
pub fn try_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRY_KW) }
pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -903,9 +901,9 @@ impl AstNode for ForExpr {
impl ast::AttrsOwner for ForExpr {}
impl ast::LoopBodyOwner for ForExpr {}
impl ForExpr {
pub fn for_kw_token(&self) -> Option<ForKw> { support::token(&self.syntax) }
pub fn for_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, FOR_KW) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
pub fn in_kw_token(&self) -> Option<InKw> { support::token(&self.syntax) }
pub fn in_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IN_KW) }
pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -926,7 +924,7 @@ impl AstNode for WhileExpr {
impl ast::AttrsOwner for WhileExpr {}
impl ast::LoopBodyOwner for WhileExpr {}
impl WhileExpr {
pub fn while_kw_token(&self) -> Option<WhileKw> { support::token(&self.syntax) }
pub fn while_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, WHILE_KW) }
pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -946,7 +944,9 @@ impl AstNode for ContinueExpr {
}
impl ast::AttrsOwner for ContinueExpr {}
impl ContinueExpr {
pub fn continue_kw_token(&self) -> Option<ContinueKw> { support::token(&self.syntax) }
pub fn continue_token(&self) -> Option<SyntaxToken> {
support::token2(&self.syntax, CONTINUE_KW)
}
pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -966,7 +966,7 @@ impl AstNode for BreakExpr {
}
impl ast::AttrsOwner for BreakExpr {}
impl BreakExpr {
pub fn break_kw_token(&self) -> Option<BreakKw> { support::token(&self.syntax) }
pub fn break_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BREAK_KW) }
pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
@ -1006,7 +1006,7 @@ impl AstNode for BlockExpr {
impl ast::AttrsOwner for BlockExpr {}
impl BlockExpr {
pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
pub fn unsafe_kw_token(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, UNSAFE_KW) }
pub fn block(&self) -> Option<Block> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1130,7 +1130,7 @@ impl ast::AttrsOwner for AwaitExpr {}
impl AwaitExpr {
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn dot_token(&self) -> Option<Dot> { support::token(&self.syntax) }
pub fn await_kw_token(&self) -> Option<AwaitKw> { support::token(&self.syntax) }
pub fn await_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AWAIT_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TryExpr {
@ -1149,7 +1149,7 @@ impl AstNode for TryExpr {
}
impl ast::AttrsOwner for TryExpr {}
impl TryExpr {
pub fn try_kw_token(&self) -> Option<TryKw> { support::token(&self.syntax) }
pub fn try_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, TRY_KW) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1170,7 +1170,7 @@ impl AstNode for CastExpr {
impl ast::AttrsOwner for CastExpr {}
impl CastExpr {
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn as_kw_token(&self) -> Option<AsKw> { support::token(&self.syntax) }
pub fn as_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AS_KW) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1191,8 +1191,8 @@ impl AstNode for RefExpr {
impl ast::AttrsOwner for RefExpr {}
impl RefExpr {
pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
pub fn raw_kw_token(&self) -> Option<RawKw> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn raw_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, RAW_KW) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1232,7 +1232,7 @@ impl AstNode for BoxExpr {
}
impl ast::AttrsOwner for BoxExpr {}
impl BoxExpr {
pub fn box_kw_token(&self) -> Option<BoxKw> { support::token(&self.syntax) }
pub fn box_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BOX_KW) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1308,7 +1308,7 @@ impl AstNode for MatchExpr {
}
impl ast::AttrsOwner for MatchExpr {}
impl MatchExpr {
pub fn match_kw_token(&self) -> Option<MatchKw> { support::token(&self.syntax) }
pub fn match_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MATCH_KW) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
}
@ -1371,7 +1371,7 @@ impl AstNode for MatchGuard {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl MatchGuard {
pub fn if_kw_token(&self) -> Option<IfKw> { support::token(&self.syntax) }
pub fn if_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, IF_KW) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1491,7 +1491,7 @@ impl AstNode for RefPat {
}
impl RefPat {
pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1510,7 +1510,7 @@ impl AstNode for BoxPat {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl BoxPat {
pub fn box_kw_token(&self) -> Option<BoxKw> { support::token(&self.syntax) }
pub fn box_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, BOX_KW) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1531,8 +1531,8 @@ impl AstNode for BindPat {
impl ast::AttrsOwner for BindPat {}
impl ast::NameOwner for BindPat {}
impl BindPat {
pub fn ref_kw_token(&self) -> Option<RefKw> { support::token(&self.syntax) }
pub fn mut_kw_token(&self) -> Option<MutKw> { support::token(&self.syntax) }
pub fn ref_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, REF_KW) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, MUT_KW) }
pub fn at_token(&self) -> Option<At> { support::token(&self.syntax) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
}
@ -1788,10 +1788,10 @@ impl AstNode for Visibility {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl Visibility {
pub fn pub_kw_token(&self) -> Option<PubKw> { support::token(&self.syntax) }
pub fn super_kw_token(&self) -> Option<SuperKw> { support::token(&self.syntax) }
pub fn self_kw_token(&self) -> Option<SelfKw> { support::token(&self.syntax) }
pub fn crate_kw_token(&self) -> Option<CrateKw> { support::token(&self.syntax) }
pub fn pub_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, PUB_KW) }
pub fn super_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SUPER_KW) }
pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SELF_KW) }
pub fn crate_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CRATE_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Name {
@ -1996,7 +1996,7 @@ impl AstNode for TypeBound {
}
impl TypeBound {
pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
pub fn const_kw_token(&self) -> Option<ConstKw> { support::token(&self.syntax) }
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CONST_KW) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2053,7 +2053,7 @@ impl AstNode for WhereClause {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl WhereClause {
pub fn where_kw_token(&self) -> Option<WhereKw> { support::token(&self.syntax) }
pub fn where_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, WHERE_KW) }
pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2112,7 +2112,7 @@ impl AstNode for LetStmt {
impl ast::AttrsOwner for LetStmt {}
impl ast::TypeAscriptionOwner for LetStmt {}
impl LetStmt {
pub fn let_kw_token(&self) -> Option<LetKw> { support::token(&self.syntax) }
pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LET_KW) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
@ -2134,7 +2134,7 @@ impl AstNode for Condition {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl Condition {
pub fn let_kw_token(&self) -> Option<LetKw> { support::token(&self.syntax) }
pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, LET_KW) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
@ -2203,7 +2203,7 @@ impl ast::AttrsOwner for SelfParam {}
impl SelfParam {
pub fn amp_token(&self) -> Option<Amp> { support::token(&self.syntax) }
pub fn lifetime_token(&self) -> Option<Lifetime> { support::token(&self.syntax) }
pub fn self_kw_token(&self) -> Option<SelfKw> { support::token(&self.syntax) }
pub fn self_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, SELF_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Param {
@ -2244,7 +2244,7 @@ impl AstNode for UseItem {
impl ast::AttrsOwner for UseItem {}
impl ast::VisibilityOwner for UseItem {}
impl UseItem {
pub fn use_kw_token(&self) -> Option<UseKw> { support::token(&self.syntax) }
pub fn use_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, USE_KW) }
pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2285,7 +2285,7 @@ impl AstNode for Alias {
}
impl ast::NameOwner for Alias {}
impl Alias {
pub fn as_kw_token(&self) -> Option<AsKw> { support::token(&self.syntax) }
pub fn as_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, AS_KW) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UseTreeList {
@ -2325,8 +2325,8 @@ impl AstNode for ExternCrateItem {
impl ast::AttrsOwner for ExternCrateItem {}
impl ast::VisibilityOwner for ExternCrateItem {}
impl ExternCrateItem {
pub fn extern_kw_token(&self) -> Option<ExternKw> { support::token(&self.syntax) }
pub fn crate_kw_token(&self) -> Option<CrateKw> { support::token(&self.syntax) }
pub fn extern_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, EXTERN_KW) }
pub fn crate_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, CRATE_KW) }
pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
}
@ -2512,7 +2512,6 @@ impl AstNode for MacroItems {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ast::ModuleItemOwner for MacroItems {}
impl ast::FnDefOwner for MacroItems {}
impl MacroItems {}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MacroStmts {
@ -2548,7 +2547,6 @@ impl AstNode for ExternItemList {
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ast::FnDefOwner for ExternItemList {}
impl ast::ModuleItemOwner for ExternItemList {}
impl ExternItemList {
pub fn l_curly_token(&self) -> Option<LCurly> { support::token(&self.syntax) }

916
crates/ra_syntax/src/ast/generated/tokens.rs
View file

@ -1046,906 +1046,6 @@ impl AstToken for Shreq {
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AsKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for AsKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for AsKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == AS_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AsyncKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for AsyncKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for AsyncKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == ASYNC_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AwaitKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for AwaitKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for AwaitKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct BoxKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for BoxKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for BoxKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct BreakKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for BreakKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for BreakKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ConstKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ConstKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ConstKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ContinueKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ContinueKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ContinueKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CrateKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for CrateKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for CrateKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == CRATE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DynKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for DynKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for DynKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ElseKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ElseKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ElseKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == ELSE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EnumKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for EnumKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for EnumKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ExternKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ExternKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ExternKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FalseKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for FalseKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for FalseKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == FALSE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FnKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for FnKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for FnKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == FN_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ForKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ForKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ForKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct IfKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for IfKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for IfKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == IF_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ImplKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ImplKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ImplKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct InKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for InKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for InKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == IN_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct LetKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for LetKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for LetKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == LET_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct LoopKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for LoopKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for LoopKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MacroKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for MacroKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for MacroKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MatchKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for MatchKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for MatchKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ModKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ModKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ModKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == MOD_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MoveKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for MoveKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for MoveKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == MOVE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MutKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for MutKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for MutKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == MUT_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PubKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for PubKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for PubKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == PUB_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RefKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for RefKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for RefKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == REF_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReturnKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ReturnKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ReturnKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SelfKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for SelfKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for SelfKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct StaticKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for StaticKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for StaticKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct StructKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for StructKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for StructKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SuperKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for SuperKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for SuperKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == SUPER_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TraitKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for TraitKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for TraitKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TrueKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for TrueKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for TrueKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == TRUE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TryKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for TryKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for TryKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TypeKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for TypeKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for TypeKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnsafeKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for UnsafeKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for UnsafeKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == UNSAFE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UseKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for UseKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for UseKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == USE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WhereKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for WhereKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for WhereKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WhileKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for WhileKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for WhileKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AutoKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for AutoKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for AutoKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == AUTO_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DefaultKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for DefaultKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for DefaultKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == DEFAULT_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ExistentialKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for ExistentialKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for ExistentialKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == EXISTENTIAL_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnionKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for UnionKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for UnionKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == UNION_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RawKw {
pub(crate) syntax: SyntaxToken,
}
impl std::fmt::Display for RawKw {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Display::fmt(&self.syntax, f)
}
}
impl AstToken for RawKw {
fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_KW }
fn cast(syntax: SyntaxToken) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct IntNumber {
pub(crate) syntax: SyntaxToken,
}
@ -2687,8 +1787,6 @@ pub enum LiteralToken {
FloatNumber(FloatNumber),
String(String),
RawString(RawString),
TrueKw(TrueKw),
FalseKw(FalseKw),
ByteString(ByteString),
RawByteString(RawByteString),
Char(Char),
@ -2706,12 +1804,6 @@ impl From<String> for LiteralToken {
impl From<RawString> for LiteralToken {
fn from(node: RawString) -> LiteralToken { LiteralToken::RawString(node) }
}
impl From<TrueKw> for LiteralToken {
fn from(node: TrueKw) -> LiteralToken { LiteralToken::TrueKw(node) }
}
impl From<FalseKw> for LiteralToken {
fn from(node: FalseKw) -> LiteralToken { LiteralToken::FalseKw(node) }
}
impl From<ByteString> for LiteralToken {
fn from(node: ByteString) -> LiteralToken { LiteralToken::ByteString(node) }
}
@ -2732,8 +1824,8 @@ impl std::fmt::Display for LiteralToken {
impl AstToken for LiteralToken {
fn can_cast(kind: SyntaxKind) -> bool {
match kind {
INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | TRUE_KW | FALSE_KW | BYTE_STRING
| RAW_BYTE_STRING | CHAR | BYTE => true,
INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | BYTE_STRING | RAW_BYTE_STRING
| CHAR | BYTE => true,
_ => false,
}
}
@ -2743,8 +1835,6 @@ impl AstToken for LiteralToken {
FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }),
STRING => LiteralToken::String(String { syntax }),
RAW_STRING => LiteralToken::RawString(RawString { syntax }),
TRUE_KW => LiteralToken::TrueKw(TrueKw { syntax }),
FALSE_KW => LiteralToken::FalseKw(FalseKw { syntax }),
BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }),
RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }),
CHAR => LiteralToken::Char(Char { syntax }),
@ -2759,8 +1849,6 @@ impl AstToken for LiteralToken {
LiteralToken::FloatNumber(it) => &it.syntax,
LiteralToken::String(it) => &it.syntax,
LiteralToken::RawString(it) => &it.syntax,
LiteralToken::TrueKw(it) => &it.syntax,
LiteralToken::FalseKw(it) => &it.syntax,
LiteralToken::ByteString(it) => &it.syntax,
LiteralToken::RawByteString(it) => &it.syntax,
LiteralToken::Char(it) => &it.syntax,

12
crates/ra_syntax/src/ast/traits.rs
View file

@ -1,8 +1,7 @@
//! Various traits that are implemented by ast nodes.
//!
//! The implementations are usually trivial, and live in generated.rs
use itertools::Itertools;
use stdx::SepBy;
use crate::{
ast::{self, support, AstChildren, AstNode, AstToken},
@ -43,12 +42,6 @@ pub trait ArgListOwner: AstNode {
}
}
pub trait FnDefOwner: AstNode {
fn functions(&self) -> AstChildren<ast::FnDef> {
support::children(self.syntax())
}
}
pub trait ModuleItemOwner: AstNode {
fn items(&self) -> AstChildren<ast::ModuleItem> {
support::children(self.syntax())
@ -122,7 +115,8 @@ pub trait DocCommentsOwner: AstNode {
// of a line in markdown.
line[pos..end].to_owned()
})
.join("\n");
.sep_by("\n")
.to_string();
if has_comments {
Some(docs)

12
xtask/src/ast_src.rs
View file

@ -298,7 +298,7 @@ macro_rules! ast_enums {
pub(crate) const AST_SRC: AstSrc = AstSrc {
nodes: &ast_nodes! {
struct SourceFile: ModuleItemOwner, FnDefOwner, AttrsOwner {
struct SourceFile: ModuleItemOwner, AttrsOwner {
modules: [Module],
}
@ -364,7 +364,7 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
Semi
}
struct ItemList: FnDefOwner, ModuleItemOwner {
struct ItemList: ModuleItemOwner {
LCurly,
impl_items: [ImplItem],
RCurly
@ -604,14 +604,14 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
struct LifetimeArg { Lifetime }
struct ConstArg { Literal, Eq, BlockExpr }
struct MacroItems: ModuleItemOwner, FnDefOwner { }
struct MacroItems: ModuleItemOwner{ }
struct MacroStmts {
statements: [Stmt],
Expr,
}
struct ExternItemList: FnDefOwner, ModuleItemOwner {
struct ExternItemList: ModuleItemOwner {
LCurly,
extern_items: [ExternItem],
RCurly
@ -814,8 +814,8 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
FloatNumber,
String,
RawString,
TrueKw,
FalseKw,
// TrueKw,
// FalseKw,
ByteString,
RawByteString,
Char,

33
xtask/src/codegen/gen_syntax.rs
View file

@ -58,11 +58,14 @@ fn generate_tokens(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
.chain(kinds.tokens.into_iter().copied().map(|x| x.into()))
.collect();
let tokens = all_token_kinds.iter().map(|kind_str| {
let tokens = all_token_kinds.iter().filter_map(|kind_str| {
if kind_str.ends_with("_KW") {
return None;
}
let kind_str = &**kind_str;
let kind = format_ident!("{}", kind_str);
let name = format_ident!("{}", to_pascal_case(kind_str));
quote! {
let res = quote! {
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct #name {
pub(crate) syntax: SyntaxToken,
@ -81,7 +84,8 @@ fn generate_tokens(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
}
fn syntax(&self) -> &SyntaxToken { &self.syntax }
}
}
};
Some(res)
});
let enums = grammar.token_enums.iter().map(|en| {
@ -186,8 +190,12 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
});
let methods = node.fields.iter().map(|(name, field)| {
let is_kw = name.ends_with("Kw");
let method_name = match field {
FieldSrc::Shorthand => format_ident!("{}", to_lower_snake_case(&name)),
FieldSrc::Shorthand => {
let name = if is_kw { &name[..name.len() - 2] } else { &name };
format_ident!("{}", to_lower_snake_case(name))
}
_ => format_ident!("{}", name),
};
let ty = match field {
@ -209,9 +217,18 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
let is_token = token_kinds.contains(&ty.to_string());
if is_token {
let method_name = format_ident!("{}_token", method_name);
quote! {
pub fn #method_name(&self) -> Option<#ty> {
support::token(&self.syntax)
if is_kw {
let token_kind = format_ident!("{}", to_upper_snake_case(name));
quote! {
pub fn #method_name(&self) -> Option<SyntaxToken> {
support::token2(&self.syntax, #token_kind)
}
}
} else {
quote! {
pub fn #method_name(&self) -> Option<#ty> {
support::token(&self.syntax)
}
}
}
} else {
@ -332,7 +349,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
let ast = quote! {
use crate::{
SyntaxNode, SyntaxKind::{self, *},
SyntaxNode, SyntaxToken, SyntaxKind::{self, *},
ast::{self, AstNode, AstChildren, support},
};