mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Be consistent about token accesors

Browse Source
This commit is contained in:
Aleksey Kladov 2020-04-09 18:40:43 +02:00
parent e6d22187a6
commit 2bfb65db93
14 changed files with 36 additions and 114 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.is_mutable() {
if bind_pat.mut_kw_token().is_some() {
tested_by!(test_not_inline_mut_variable);
return None;
}

2
crates/ra_assists/src/handlers/introduce_variable.rs
View File

@ -61,7 +61,7 @@ pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
};
if is_full_stmt {
tested_by!(test_introduce_var_expr_stmt);
if !full_stmt.unwrap().has_semi() {
if full_stmt.unwrap().semi_token().is_none() {
buf.push_str(";");
}
edit.replace(expr.syntax().text_range(), buf);

7
crates/ra_hir_def/src/body/lower.rs
View File

@ -572,7 +572,10 @@ fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
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.is_mutable(), bp.is_ref());
let annotation = BindingAnnotation::new(
bp.mut_kw_token().is_some(),
bp.ref_kw_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
@ -613,7 +616,7 @@ fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
}
ast::Pat::RefPat(p) => {
let pat = self.collect_pat_opt(p.pat());
let mutability = Mutability::from_mutable(p.is_mut());
let mutability = Mutability::from_mutable(p.mut_kw_token().is_some());
Pat::Ref { pat, mutability }
}
ast::Pat::PathPat(p) => {

6
crates/ra_hir_def/src/data.rs
View File

@ -75,7 +75,7 @@ pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<Func
TypeRef::unit()
};
let ret_type = if src.value.is_async() {
let ret_type = if src.value.async_kw_token().is_some() {
let future_impl = desugar_future_path(ret_type);
let ty_bound = TypeBound::Path(future_impl);
TypeRef::ImplTrait(vec![ty_bound])
@ -136,7 +136,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.is_auto();
let auto = src.value.auto_kw_token().is_some();
let ast_id_map = db.ast_id_map(src.file_id);
let container = AssocContainerId::TraitId(tr);
@ -213,7 +213,7 @@ pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData>
let target_trait = src.value.target_trait().map(TypeRef::from_ast);
let target_type = TypeRef::from_ast_opt(src.value.target_type());
let is_negative = src.value.is_negative();
let is_negative = src.value.excl_token().is_some();
let module_id = impl_loc.container.module(db);
let mut items = Vec::new();

2
crates/ra_hir_def/src/generics.rs
View File

@ -194,7 +194,7 @@ fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) {
}
fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) {
if bound.has_question_mark() {
if bound.question_token().is_some() {
// FIXME: remove this bound
return;
}

2
crates/ra_hir_def/src/nameres/raw.rs
View File

@ -287,7 +287,7 @@ fn add_module(&mut self, current_module: Option<Idx<ModuleData>>, module: ast::M
let visibility = RawVisibility::from_ast_with_hygiene(module.visibility(), &self.hygiene);
let ast_id = self.source_ast_id_map.ast_id(&module);
if module.has_semi() {
if module.semi_token().is_some() {
let item =
self.raw_items.modules.alloc(ModuleData::Declaration { name, visibility, ast_id });
self.push_item(current_module, attrs, RawItemKind::Module(item));

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

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

5
crates/ra_ide/src/completion/completion_context.rs
View File

@ -190,7 +190,10 @@ fn fill(
if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
self.is_pat_binding_or_const = true;
if bind_pat.has_at() || bind_pat.is_ref() || bind_pat.is_mutable() {
if bind_pat.at_token().is_some()
|| bind_pat.ref_kw_token().is_some()
|| bind_pat.mut_kw_token().is_some()
{
self.is_pat_binding_or_const = false;
}
if bind_pat.syntax().parent().and_then(ast::RecordFieldPatList::cast).is_some() {

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.is_mutable() {
if it.mut_kw_token().is_some() {
return Some(ReferenceAccess::Write);
}
}

2
crates/ra_ide/src/typing.rs
View File

@ -63,7 +63,7 @@ fn on_char_typed_inner(
fn on_eq_typed(file: &SourceFile, offset: TextUnit) -> Option<SingleFileChange> {
assert_eq!(file.syntax().text().char_at(offset), Some('='));
let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
if let_stmt.has_semi() {
if let_stmt.semi_token().is_some() {
return None;
}
if let Some(expr) = let_stmt.initializer() {

4
crates/ra_syntax/src/ast/edit.rs
View File

@ -33,9 +33,9 @@ pub fn with_body(&self, body: ast::Block) -> ast::FnDef {
let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() {
old_body.syntax().clone().into()
} else if let Some(semi) = self.semicolon_token() {
} else if let Some(semi) = self.semi_token() {
to_insert.push(make::tokens::single_space().into());
semi.into()
semi.syntax.clone().into()
} else {
to_insert.push(make::tokens::single_space().into());
to_insert.push(body.syntax().clone().into());

104
crates/ra_syntax/src/ast/extensions.rs
View File

@ -136,12 +136,6 @@ pub fn parent_path(&self) -> Option<ast::Path> {
}
}
impl ast::Module {
pub fn has_semi(&self) -> bool {
self.semi_token().is_some()
}
}
impl ast::UseTreeList {
pub fn parent_use_tree(&self) -> ast::UseTree {
self.syntax()
@ -172,10 +166,6 @@ fn target(&self) -> (Option<ast::TypeRef>, Option<ast::TypeRef>) {
let second = types.next();
(first, second)
}
pub fn is_negative(&self) -> bool {
self.excl_token().is_some()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
@ -216,31 +206,6 @@ pub fn kind(&self) -> StructKind {
}
}
impl ast::FnDef {
pub fn semicolon_token(&self) -> Option<SyntaxToken> {
Some(self.semi_token()?.syntax().clone())
}
pub fn is_async(&self) -> bool {
self.async_kw_token().is_some()
}
}
impl ast::LetStmt {
pub fn has_semi(&self) -> bool {
match self.syntax().last_child_or_token() {
None => false,
Some(node) => node.kind() == T![;],
}
}
}
impl ast::ExprStmt {
pub fn has_semi(&self) -> bool {
self.semi_token().is_some()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FieldKind {
Name(ast::NameRef),
@ -269,25 +234,6 @@ pub fn field_access(&self) -> Option<FieldKind> {
}
}
impl ast::RefPat {
pub fn is_mut(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
impl ast::BindPat {
pub fn is_mutable(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
pub fn is_ref(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![ref])
}
pub fn has_at(&self) -> bool {
self.syntax().children_with_tokens().any(|it| it.kind() == T![@])
}
}
pub struct SlicePatComponents {
pub prefix: Vec<ast::Pat>,
pub slice: Option<ast::Pat>,
@ -322,18 +268,6 @@ pub fn components(&self) -> SlicePatComponents {
}
}
impl ast::PointerType {
pub fn is_mut(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
impl ast::ReferenceType {
pub fn is_mut(&self) -> bool {
self.syntax().children_with_tokens().any(|n| n.kind() == T![mut])
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub enum SelfParamKind {
/// self
@ -347,7 +281,7 @@ pub enum SelfParamKind {
impl ast::SelfParam {
pub fn kind(&self) -> SelfParamKind {
if self.amp_token().is_some() {
if self.amp_mut_kw().is_some() {
if self.amp_mut_kw_token().is_some() {
SelfParamKind::MutRef
} else {
SelfParamKind::Ref
@ -358,7 +292,7 @@ pub fn kind(&self) -> SelfParamKind {
}
/// the "mut" in "mut self", not the one in "&mut self"
pub fn mut_kw(&self) -> Option<ast::MutKw> {
pub fn mut_kw_token(&self) -> Option<ast::MutKw> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
@ -367,7 +301,7 @@ pub fn mut_kw(&self) -> Option<ast::MutKw> {
}
/// the "mut" in "&mut self", not the one in "mut self"
pub fn amp_mut_kw(&self) -> Option<ast::MutKw> {
pub fn amp_mut_kw_token(&self) -> Option<ast::MutKw> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
@ -399,11 +333,7 @@ pub fn kind(&self) -> TypeBoundKind {
}
}
pub fn has_question_mark(&self) -> bool {
self.question().is_some()
}
pub fn const_question(&self) -> Option<ast::Question> {
pub fn const_question_token(&self) -> Option<ast::Question> {
self.syntax()
.children_with_tokens()
.filter_map(|it| it.into_token())
@ -411,7 +341,7 @@ pub fn const_question(&self) -> Option<ast::Question> {
.find_map(ast::Question::cast)
}
pub fn question(&self) -> Option<ast::Question> {
pub fn question_token(&self) -> Option<ast::Question> {
if self.const_kw_token().is_some() {
self.syntax()
.children_with_tokens()
@ -424,12 +354,6 @@ pub fn question(&self) -> Option<ast::Question> {
}
}
impl ast::TraitDef {
pub fn is_auto(&self) -> bool {
self.syntax().children_with_tokens().any(|t| t.kind() == T![auto])
}
}
pub enum VisibilityKind {
In(ast::Path),
PubCrate,
@ -442,28 +366,16 @@ impl ast::Visibility {
pub fn kind(&self) -> VisibilityKind {
if let Some(path) = children(self).next() {
VisibilityKind::In(path)
} else if self.is_pub_crate() {
} else if self.crate_kw_token().is_some() {
VisibilityKind::PubCrate
} else if self.is_pub_super() {
} else if self.super_kw_token().is_some() {
VisibilityKind::PubSuper
} else if self.is_pub_self() {
} else if self.self_kw_token().is_some() {
VisibilityKind::PubSuper
} else {
VisibilityKind::Pub
}
}
fn is_pub_crate(&self) -> bool {
self.syntax().children_with_tokens().any(|it| it.kind() == T![crate])
}
fn is_pub_super(&self) -> bool {
self.syntax().children_with_tokens().any(|it| it.kind() == T![super])
}
fn is_pub_self(&self) -> bool {
self.syntax().children_with_tokens().any(|it| it.kind() == T![self])
}
}
impl ast::MacroCall {

3
crates/ra_syntax/src/ast/generated/nodes.rs
View File

@ -555,6 +555,7 @@ fn syntax(&self) -> &SyntaxNode { &self.syntax }
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 type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1532,6 +1533,7 @@ 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 at_token(&self) -> Option<At> { support::token(&self.syntax) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2114,6 +2116,7 @@ pub fn let_kw_token(&self) -> Option<LetKw> { support::token(&self.syntax) }
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) }
pub fn semi_token(&self) -> Option<Semi> { support::token(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Condition {

5
xtask/src/ast_src.rs
View File

@ -408,7 +408,7 @@ struct ParenType { LParen, TypeRef, RParen }
struct TupleType { LParen, fields: [TypeRef], RParen }
struct NeverType { Excl }
struct PathType { Path }
struct PointerType { Star, ConstKw, TypeRef }
struct PointerType { Star, ConstKw, MutKw, TypeRef }
struct ArrayType { LBrack, TypeRef, Semi, Expr, RBrack }
struct SliceType { LBrack, TypeRef, RBrack }
struct ReferenceType { Amp, Lifetime, MutKw, TypeRef }
@ -485,7 +485,7 @@ struct OrPat { pats: [Pat] }
struct ParenPat { LParen, Pat, RParen }
struct RefPat { Amp, MutKw, Pat }
struct BoxPat { BoxKw, Pat }
struct BindPat: AttrsOwner, NameOwner { RefKw, MutKw, Pat }
struct BindPat: AttrsOwner, NameOwner { RefKw, MutKw, At, Pat }
struct PlaceholderPat { Underscore }
struct DotDotPat { Dotdot }
struct PathPat { Path }
@ -545,6 +545,7 @@ struct LetStmt: AttrsOwner, TypeAscriptionOwner {
Pat,
Eq,
initializer: Expr,
Semi,
}
struct Condition { LetKw, Pat, Eq, Expr }
struct Block: AttrsOwner, ModuleItemOwner {