rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Add semicolons for consistency

Browse Source 
`clippy::semicolon_if_nothing_returned`
This commit is contained in:
Aramis Razzaghipour
2021-10-03 23:39:43 +11:00
parent 60c5449120
commit 55c0b86cde
46 changed files with 151 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
crates/syntax/src/algo.rs
View File

@@ -120,7 +120,7 @@ impl TreeDiff {
to.iter().for_each(|to| builder.insert(offset, to.to_string()));
}
for (from, to) in self.replacements.iter() {
builder.replace(from.text_range(), to.to_string())
builder.replace(from.text_range(), to.to_string());
}
for text_range in self.deletions.iter().map(SyntaxElement::text_range) {
builder.delete(text_range);
@@ -233,7 +233,7 @@ pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
diff.insertions.entry(insert_pos).or_insert_with(Vec::new).extend(drain);
rhs_children = rhs_children_clone;
} else {
go(diff, lhs_ele, rhs_ele)
go(diff, lhs_ele, rhs_ele);
}
}
}

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

@@ -126,7 +126,7 @@ impl IndentLevel {
if let Some(ws) = ast::Whitespace::cast(token) {
if ws.text().contains('\n') {
let new_ws = make::tokens::whitespace(&format!("{}{}", ws.syntax(), self));
ted::replace(ws.syntax(), &new_ws)
ted::replace(ws.syntax(), &new_ws);
}
}
}
@@ -143,7 +143,7 @@ impl IndentLevel {
let new_ws = make::tokens::whitespace(
&ws.syntax().text().replace(&format!("\n{}", self), "\n"),
);
ted::replace(ws.syntax(), &new_ws)
ted::replace(ws.syntax(), &new_ws);
}
}
}

26
crates/syntax/src/ast/edit_in_place.rs
View File

@@ -49,7 +49,7 @@ impl GenericParamsOwnerEdit for ast::Fn {
} else {
Position::last_child_of(self.syntax())
};
create_where_clause(position)
create_where_clause(position);
}
self.where_clause().unwrap()
}
@@ -77,7 +77,7 @@ impl GenericParamsOwnerEdit for ast::Impl {
} else {
Position::last_child_of(self.syntax())
};
create_where_clause(position)
create_where_clause(position);
}
self.where_clause().unwrap()
}
@@ -107,7 +107,7 @@ impl GenericParamsOwnerEdit for ast::Trait {
} else {
Position::last_child_of(self.syntax())
};
create_where_clause(position)
create_where_clause(position);
}
self.where_clause().unwrap()
}
@@ -145,7 +145,7 @@ impl GenericParamsOwnerEdit for ast::Struct {
} else {
Position::last_child_of(self.syntax())
};
create_where_clause(position)
create_where_clause(position);
}
self.where_clause().unwrap()
}
@@ -177,7 +177,7 @@ impl GenericParamsOwnerEdit for ast::Enum {
} else {
Position::last_child_of(self.syntax())
};
create_where_clause(position)
create_where_clause(position);
}
self.where_clause().unwrap()
}
@@ -234,7 +234,7 @@ impl ast::GenericParamList {
}
None => {
let after_l_angle = Position::after(self.l_angle_token().unwrap());
ted::insert(after_l_angle, generic_param.syntax())
ted::insert(after_l_angle, generic_param.syntax());
}
}
}
@@ -247,7 +247,7 @@ impl ast::WhereClause {
ted::append_child_raw(self.syntax(), make::token(T![,]));
}
}
ted::append_child(self.syntax(), predicate.syntax())
ted::append_child(self.syntax(), predicate.syntax());
}
}
@@ -267,7 +267,7 @@ impl ast::PathSegment {
pub fn get_or_create_generic_arg_list(&self) -> ast::GenericArgList {
if self.generic_arg_list().is_none() {
let arg_list = make::generic_arg_list().clone_for_update();
ted::append_child(self.syntax(), arg_list.syntax())
ted::append_child(self.syntax(), arg_list.syntax());
}
self.generic_arg_list().unwrap()
}
@@ -286,7 +286,7 @@ impl ast::UseTree {
break;
}
}
ted::remove(self.syntax())
ted::remove(self.syntax());
}
}
@@ -301,13 +301,13 @@ impl ast::Use {
let ws_text = next_ws.syntax().text();
if let Some(rest) = ws_text.strip_prefix('\n') {
if rest.is_empty() {
ted::remove(next_ws.syntax())
ted::remove(next_ws.syntax());
} else {
ted::replace(next_ws.syntax(), make::tokens::whitespace(rest))
ted::replace(next_ws.syntax(), make::tokens::whitespace(rest));
}
}
}
ted::remove(self.syntax())
ted::remove(self.syntax());
}
}
@@ -525,7 +525,7 @@ pub trait Indent: AstNode + Clone + Sized {
fn reindent_to(&self, target_level: IndentLevel) {
let current_level = IndentLevel::from_node(self.syntax());
self.dedent(current_level);
self.indent(target_level)
self.indent(target_level);
}
}

2
crates/syntax/src/ast/make.rs
View File

@@ -257,7 +257,7 @@ pub fn block_expr(
format_to!(buf, " {}\n", stmt);
}
if let Some(tail_expr) = tail_expr {
format_to!(buf, " {}\n", tail_expr)
format_to!(buf, " {}\n", tail_expr);
}
buf += "}";
ast_from_text(&format!("fn f() {}", buf))

4
crates/syntax/src/ast/token_ext.rs
View File

@@ -609,7 +609,7 @@ impl HasFormatSpecifier for ast::String {
TextRange::new(range.start.try_into().unwrap(), range.end.try_into().unwrap())
+ offset,
unescaped_char,
))
));
});
Some(res)
@@ -631,7 +631,7 @@ impl ast::IntNumber {
let mut text = token.text();
if let Some(suffix) = self.suffix() {
text = &text[..text.len() - suffix.len()]
text = &text[..text.len() - suffix.len()];
}
let radix = self.radix();

2
crates/syntax/src/display.rs
View File

@@ -28,7 +28,7 @@ pub fn function_declaration(node: &ast::Fn) -> String {
format_to!(buf, "{} ", abi);
}
if let Some(name) = node.name() {
format_to!(buf, "fn {}", name)
format_to!(buf, "fn {}", name);
}
if let Some(type_params) = node.generic_param_list() {
format_to!(buf, "{}", type_params);

4
crates/syntax/src/parsing/text_tree_sink.rs
View File

@@ -88,7 +88,7 @@ impl<'a> TreeSink for TextTreeSink<'a> {
}
fn error(&mut self, error: ParseError) {
self.inner.error(error, self.text_pos)
self.inner.error(error, self.text_pos);
}
}
@@ -108,7 +108,7 @@ impl<'a> TextTreeSink<'a> {
match mem::replace(&mut self.state, State::Normal) {
State::PendingFinish => {
self.eat_trivias();
self.inner.finish_node()
self.inner.finish_node();
}
State::PendingStart | State::Normal => unreachable!(),
}

2
crates/syntax/src/ptr.rs
View File

@@ -81,7 +81,7 @@ impl<N: AstNode> PartialEq for AstPtr<N> {
impl<N: AstNode> Hash for AstPtr<N> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.raw.hash(state)
self.raw.hash(state);
}
}

8
crates/syntax/src/syntax_node.rs
View File

@@ -56,19 +56,19 @@ impl SyntaxTreeBuilder {
pub fn token(&mut self, kind: SyntaxKind, text: &str) {
let kind = RustLanguage::kind_to_raw(kind);
self.inner.token(kind, text)
self.inner.token(kind, text);
}
pub fn start_node(&mut self, kind: SyntaxKind) {
let kind = RustLanguage::kind_to_raw(kind);
self.inner.start_node(kind)
self.inner.start_node(kind);
}
pub fn finish_node(&mut self) {
self.inner.finish_node()
self.inner.finish_node();
}
pub fn error(&mut self, error: parser::ParseError, text_pos: TextSize) {
self.errors.push(SyntaxError::new_at_offset(*error.0, text_pos))
self.errors.push(SyntaxError::new_at_offset(*error.0, text_pos));
}
}

28
crates/syntax/src/ted.rs
View File

@@ -77,23 +77,23 @@ impl Position {
}
pub fn insert(position: Position, elem: impl Element) {
insert_all(position, vec![elem.syntax_element()])
insert_all(position, vec![elem.syntax_element()]);
}
pub fn insert_raw(position: Position, elem: impl Element) {
insert_all_raw(position, vec![elem.syntax_element()])
insert_all_raw(position, vec![elem.syntax_element()]);
}
pub fn insert_all(position: Position, mut elements: Vec<SyntaxElement>) {
if let Some(first) = elements.first() {
if let Some(ws) = ws_before(&position, first) {
elements.insert(0, ws.into())
elements.insert(0, ws.into());
}
}
if let Some(last) = elements.last() {
if let Some(ws) = ws_after(&position, last) {
elements.push(ws.into())
elements.push(ws.into());
}
}
insert_all_raw(position, elements)
insert_all_raw(position, elements);
}
pub fn insert_all_raw(position: Position, elements: Vec<SyntaxElement>) {
let (parent, index) = match position.repr {
@@ -104,10 +104,10 @@ pub fn insert_all_raw(position: Position, elements: Vec<SyntaxElement>) {
}
pub fn remove(elem: impl Element) {
elem.syntax_element().detach()
elem.syntax_element().detach();
}
pub fn remove_all(range: RangeInclusive<SyntaxElement>) {
replace_all(range, Vec::new())
replace_all(range, Vec::new());
}
pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
let mut it = range.into_iter();
@@ -115,9 +115,9 @@ pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
match it.last() {
Some(mut last) => {
if first.index() > last.index() {
mem::swap(&mut first, &mut last)
mem::swap(&mut first, &mut last);
}
remove_all(first..=last)
remove_all(first..=last);
}
None => remove(first),
}
@@ -125,26 +125,26 @@ pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
}
pub fn replace(old: impl Element, new: impl Element) {
replace_with_many(old, vec![new.syntax_element()])
replace_with_many(old, vec![new.syntax_element()]);
}
pub fn replace_with_many(old: impl Element, new: Vec<SyntaxElement>) {
let old = old.syntax_element();
replace_all(old.clone()..=old, new)
replace_all(old.clone()..=old, new);
}
pub fn replace_all(range: RangeInclusive<SyntaxElement>, new: Vec<SyntaxElement>) {
let start = range.start().index();
let end = range.end().index();
let parent = range.start().parent().unwrap();
parent.splice_children(start..end + 1, new)
parent.splice_children(start..end + 1, new);
}
pub fn append_child(node: &(impl Into<SyntaxNode> + Clone), child: impl Element) {
let position = Position::last_child_of(node);
insert(position, child)
insert(position, child);
}
pub fn append_child_raw(node: &(impl Into<SyntaxNode> + Clone), child: impl Element) {
let position = Position::last_child_of(node);
insert_raw(position, child)
insert_raw(position, child);
}
fn ws_before(position: &Position, new: &SyntaxElement) -> Option<SyntaxToken> {

4
crates/syntax/src/validation.rs
View File

@@ -137,7 +137,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
if let Err(err) = char {
push_err(1, (range.start, err));
}
})
});
}
}
}
@@ -148,7 +148,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
if let Err(err) = char {
push_err(2, (range.start, err));
}
})
});
}
}
}

2
crates/syntax/src/validation/block.rs
View File

@@ -19,6 +19,6 @@ pub(crate) fn validate_block_expr(block: ast::BlockExpr, errors: &mut Vec<Syntax
"A block in this position cannot accept inner attributes",
attr.syntax().text_range(),
)
}))
}));
}
}