squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Merge #5623

Browse source 
5623: Item is a Stmt r=matklad a=matklad



bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2020-07-31 13:54:19 +00:00 committed by GitHub
commit ad239f6197
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 95 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -74,6 +74,7 @@ impl TailReturnCollector {
let expr = match &stmt {
ast::Stmt::ExprStmt(stmt) => stmt.expr(),
ast::Stmt::LetStmt(stmt) => stmt.initializer(),
ast::Stmt::Item(_) => continue,
};
if let Some(expr) = &expr {
self.handle_exprs(expr, collect_break);
@ -94,6 +95,7 @@ impl TailReturnCollector {
let expr_stmt = match &expr_stmt {
ast::Stmt::ExprStmt(stmt) => stmt.expr(),
ast::Stmt::LetStmt(stmt) => stmt.initializer(),
ast::Stmt::Item(_) => None,
};
if let Some(expr) = &expr_stmt {
self.handle_exprs(expr, collect_break);

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

@ -10,7 +10,7 @@ use hir_expand::{
use ra_arena::Arena;
use ra_syntax::{
ast::{
self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, ModuleItemOwner, NameOwner,
self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
SlicePatComponents,
},
AstNode, AstPtr,
@ -601,14 +601,20 @@ impl ExprCollector<'_> {
self.collect_block_items(&block);
let statements = block
.statements()
.map(|s| match s {
ast::Stmt::LetStmt(stmt) => {
let pat = self.collect_pat_opt(stmt.pat());
let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
let initializer = stmt.initializer().map(|e| self.collect_expr(e));
Statement::Let { pat, type_ref, initializer }
}
ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
.filter_map(|s| {
let stmt = match s {
ast::Stmt::LetStmt(stmt) => {
let pat = self.collect_pat_opt(stmt.pat());
let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
let initializer = stmt.initializer().map(|e| self.collect_expr(e));
Statement::Let { pat, type_ref, initializer }
}
ast::Stmt::ExprStmt(stmt) => {
Statement::Expr(self.collect_expr_opt(stmt.expr()))
}
ast::Stmt::Item(_) => return None,
};
Some(stmt)
})
.collect();
let tail = block.expr().map(|e| self.collect_expr(e));
@ -620,7 +626,11 @@ impl ExprCollector<'_> {
let container = ContainerId::DefWithBodyId(self.def);
let items = block
.items()
.statements()
.filter_map(|stmt| match stmt {
ast::Stmt::Item(it) => Some(it),
ast::Stmt::LetStmt(_) | ast::Stmt::ExprStmt(_) => None,
})
.filter_map(|item| {
let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
ast::Item::Fn(def) => {

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

@ -17,7 +17,7 @@ use crate::{
pub use self::{
expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp},
generated::{nodes::*, tokens::*},
generated::*,
node_ext::{
AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents,
StructKind, TypeBoundKind, VisibilityKind,

43
crates/ra_syntax/src/ast/generated.rs
View file

@ -1,6 +1,41 @@
//! This file is actually hand-written, but the submodules are indeed generated.
#[rustfmt::skip]
mod nodes;
#[rustfmt::skip]
mod tokens;
#[rustfmt::skip]
pub(super) mod nodes;
#[rustfmt::skip]
pub(super) mod tokens;
use crate::{
AstNode,
SyntaxKind::{self, *},
SyntaxNode,
};
pub use {nodes::*, tokens::*};
// Stmt is the only nested enum, so it's easier to just hand-write it
impl AstNode for Stmt {
fn can_cast(kind: SyntaxKind) -> bool {
match kind {
LET_STMT | EXPR_STMT => true,
_ => Item::can_cast(kind),
}
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
let res = match syntax.kind() {
LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
_ => {
let item = Item::cast(syntax)?;
Stmt::Item(item)
}
};
Some(res)
}
fn syntax(&self) -> &SyntaxNode {
match self {
Stmt::LetStmt(it) => &it.syntax,
Stmt::ExprStmt(it) => &it.syntax,
Stmt::Item(it) => it.syntax(),
}
}
}

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

@ -348,7 +348,6 @@ pub struct BlockExpr {
pub(crate) syntax: SyntaxNode,
}
impl ast::AttrsOwner for BlockExpr {}
impl ast::ModuleItemOwner for BlockExpr {}
impl BlockExpr {
pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
@ -1395,8 +1394,8 @@ impl ast::AttrsOwner for GenericParam {}
pub enum Stmt {
LetStmt(LetStmt),
ExprStmt(ExprStmt),
Item(Item),
}
impl ast::AttrsOwner for Stmt {}
impl AstNode for SourceFile {
fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
fn cast(syntax: SyntaxNode) -> Option<Self> {
@ -3380,27 +3379,8 @@ impl From<LetStmt> for Stmt {
impl From<ExprStmt> for Stmt {
fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
}
impl AstNode for Stmt {
fn can_cast(kind: SyntaxKind) -> bool {
match kind {
LET_STMT | EXPR_STMT => true,
_ => false,
}
}
fn cast(syntax: SyntaxNode) -> Option<Self> {
let res = match syntax.kind() {
LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
_ => return None,
};
Some(res)
}
fn syntax(&self) -> &SyntaxNode {
match self {
Stmt::LetStmt(it) => &it.syntax,
Stmt::ExprStmt(it) => &it.syntax,
}
}
impl From<Item> for Stmt {
fn from(node: Item) -> Stmt { Stmt::Item(node) }
}
impl std::fmt::Display for Item {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

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

@ -153,25 +153,10 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
quote!(impl ast::#trait_name for #name {})
});
(
let ast_node = if en.name == "Stmt" {
quote! {}
} else {
quote! {
#[pretty_doc_comment_placeholder_workaround]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum #name {
#(#variants(#variants),)*
}
#(#traits)*
},
quote! {
#(
impl From<#variants> for #name {
fn from(node: #variants) -> #name {
#name::#variants(node)
}
}
)*
impl AstNode for #name {
fn can_cast(kind: SyntaxKind) -> bool {
match kind {
@ -196,6 +181,28 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
}
}
}
}
};
(
quote! {
#[pretty_doc_comment_placeholder_workaround]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum #name {
#(#variants(#variants),)*
}
#(#traits)*
},
quote! {
#(
impl From<#variants> for #name {
fn from(node: #variants) -> #name {
#name::#variants(node)
}
}
)*
#ast_node
},
)
})
@ -497,13 +504,7 @@ fn lower(grammar: &Grammar) -> AstSrc {
let mut res = AstSrc::default();
res.tokens = vec!["Whitespace".into(), "Comment".into(), "String".into(), "RawString".into()];
let nodes = grammar
.iter()
.filter(|&node| match grammar[node].rule {
Rule::Node(it) if it == node => false,
_ => true,
})
.collect::<Vec<_>>();
let nodes = grammar.iter().collect::<Vec<_>>();
for &node in &nodes {
let name = grammar[node].name.clone();
@ -693,6 +694,9 @@ fn extract_struct_trait(node: &mut AstNodeSrc, trait_name: &str, methods: &[&str
fn extract_enum_traits(ast: &mut AstSrc) {
for enm in &mut ast.enums {
if enm.name == "Stmt" {
continue;
}
let nodes = &ast.nodes;
let mut variant_traits = enm
.variants

2
xtask/src/codegen/rust.ungram
View file

@ -197,6 +197,7 @@ Attr =
Stmt =
LetStmt
| ExprStmt
| Item
LetStmt =
Attr* 'let' Pat (':' Type)?
@ -316,7 +317,6 @@ Label =
BlockExpr =
Attr* Label
'{'
Item*
statements:Stmt*
Expr?
'}'