mirror of
https://github.com/rust-lang/rust-analyzer
synced 2024-12-24 12:03:31 +00:00
Add HIR Expr machinery
This commit is contained in:
Florian Diebold
parent
a6f33b4ca5
commit
136aba1cf3
9 changed files with 542 additions and 4 deletions
|
|
@ -106,6 +106,8 @@ salsa::database_storage! {
|
|||
fn struct_data() for hir::db::StructDataQuery;
|
||||
fn enum_data() for hir::db::EnumDataQuery;
|
||||
fn impls_in_module() for hir::db::ImplsInModuleQuery;
|
||||
fn body_hir() for hir::db::BodyHirQuery;
|
||||
fn body_syntax_mapping() for hir::db::BodySyntaxMappingQuery;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
|
||||
|
||||
/// A pionter to a syntax node inside a file.
|
||||
/// A pointer to a syntax node inside a file.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct LocalSyntaxPtr {
|
||||
range: TextRange,
|
||||
|
|
|
|||
|
|
@ -93,6 +93,16 @@ pub trait HirDatabase: SyntaxDatabase
|
|||
type ImplsInModuleQuery;
|
||||
use fn crate::impl_block::impls_in_module;
|
||||
}
|
||||
|
||||
fn body_hir(def_id: DefId) -> Cancelable<Arc<crate::expr::Body>> {
|
||||
type BodyHirQuery;
|
||||
use fn crate::expr::body_hir;
|
||||
}
|
||||
|
||||
fn body_syntax_mapping(def_id: DefId) -> Cancelable<Arc<crate::expr::BodySyntaxMapping>> {
|
||||
type BodySyntaxMappingQuery;
|
||||
use fn crate::expr::body_syntax_mapping;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
507
crates/ra_hir/src/expr.rs
Normal file
507
crates/ra_hir/src/expr.rs
Normal file
|
|
@ -0,0 +1,507 @@
|
|||
use std::sync::Arc;
|
||||
|
||||
use rustc_hash::FxHashMap;
|
||||
|
||||
use ra_arena::{Arena, RawId, impl_arena_id};
|
||||
use ra_db::{LocalSyntaxPtr, Cancelable};
|
||||
use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner};
|
||||
|
||||
use crate::{Path, type_ref::{Mutability, TypeRef}, Name, HirDatabase, DefId, Def, name::AsName};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct ExprId(RawId);
|
||||
impl_arena_id!(ExprId);
|
||||
|
||||
/// The body of an item (function, const etc.).
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub struct Body {
|
||||
exprs: Arena<ExprId, Expr>,
|
||||
pats: Arena<PatId, Pat>,
|
||||
/// The patterns for the function's arguments. While the argument types are
|
||||
/// part of the function signature, the patterns are not (they don't change
|
||||
/// the external type of the function).
|
||||
///
|
||||
/// If this `ExprTable` is for the body of a constant, this will just be
|
||||
/// empty.
|
||||
args: Vec<PatId>,
|
||||
/// The `ExprId` of the actual body expression.
|
||||
body_expr: ExprId,
|
||||
}
|
||||
|
||||
/// An item body together with the mapping from syntax nodes to HIR expression
|
||||
/// IDs. This is needed to go from e.g. a position in a file to the HIR
|
||||
/// expression containing it; but for type inference etc., we want to operate on
|
||||
/// a structure that is agnostic to the actual positions of expressions in the
|
||||
/// file, so that we don't recompute the type inference whenever some whitespace
|
||||
/// is typed.
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
pub struct BodySyntaxMapping {
|
||||
body: Arc<Body>,
|
||||
expr_syntax_mapping: FxHashMap<LocalSyntaxPtr, ExprId>,
|
||||
expr_syntax_mapping_back: FxHashMap<ExprId, LocalSyntaxPtr>,
|
||||
pat_syntax_mapping: FxHashMap<LocalSyntaxPtr, PatId>,
|
||||
pat_syntax_mapping_back: FxHashMap<PatId, LocalSyntaxPtr>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub enum Expr {
|
||||
/// This is produced if syntax tree does not have a required expression piece.
|
||||
Missing,
|
||||
Path(Path),
|
||||
If {
|
||||
condition: ExprId,
|
||||
then_branch: ExprId,
|
||||
else_branch: Option<ExprId>,
|
||||
},
|
||||
Block {
|
||||
statements: Vec<Statement>,
|
||||
tail: Option<ExprId>,
|
||||
},
|
||||
Loop {
|
||||
body: ExprId,
|
||||
},
|
||||
While {
|
||||
condition: ExprId,
|
||||
body: ExprId,
|
||||
},
|
||||
For {
|
||||
iterable: ExprId,
|
||||
pat: PatId,
|
||||
body: ExprId,
|
||||
},
|
||||
Call {
|
||||
callee: ExprId,
|
||||
args: Vec<ExprId>,
|
||||
},
|
||||
MethodCall {
|
||||
receiver: ExprId,
|
||||
method_name: Name,
|
||||
args: Vec<ExprId>,
|
||||
},
|
||||
Match {
|
||||
expr: ExprId,
|
||||
arms: Vec<MatchArm>,
|
||||
},
|
||||
Continue,
|
||||
Break {
|
||||
expr: Option<ExprId>,
|
||||
},
|
||||
Return {
|
||||
expr: Option<ExprId>,
|
||||
},
|
||||
StructLit {
|
||||
path: Option<Path>,
|
||||
fields: Vec<StructLitField>,
|
||||
spread: Option<ExprId>,
|
||||
},
|
||||
Field {
|
||||
expr: ExprId,
|
||||
name: Name,
|
||||
},
|
||||
Try {
|
||||
expr: ExprId,
|
||||
},
|
||||
Cast {
|
||||
expr: ExprId,
|
||||
type_ref: TypeRef,
|
||||
},
|
||||
Ref {
|
||||
expr: ExprId,
|
||||
mutability: Mutability,
|
||||
},
|
||||
UnaryOp {
|
||||
expr: ExprId,
|
||||
op: Option<UnaryOp>,
|
||||
},
|
||||
}
|
||||
|
||||
pub type UnaryOp = ast::PrefixOp;
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub struct MatchArm {
|
||||
pats: Vec<PatId>,
|
||||
// guard: Option<ExprId>, // TODO
|
||||
expr: ExprId,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub struct StructLitField {
|
||||
name: Name,
|
||||
expr: ExprId,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub enum Statement {
|
||||
Let {
|
||||
pat: PatId,
|
||||
type_ref: Option<TypeRef>,
|
||||
initializer: Option<ExprId>,
|
||||
},
|
||||
Expr(ExprId),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct PatId(RawId);
|
||||
impl_arena_id!(PatId);
|
||||
|
||||
#[derive(Debug, Clone, Eq, PartialEq)]
|
||||
pub struct Pat;
|
||||
|
||||
// Queries
|
||||
|
||||
pub(crate) fn body_hir(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<Body>> {
|
||||
Ok(Arc::clone(&body_syntax_mapping(db, def_id)?.body))
|
||||
}
|
||||
|
||||
struct ExprCollector {
|
||||
exprs: Arena<ExprId, Expr>,
|
||||
pats: Arena<PatId, Pat>,
|
||||
expr_syntax_mapping: FxHashMap<LocalSyntaxPtr, ExprId>,
|
||||
expr_syntax_mapping_back: FxHashMap<ExprId, LocalSyntaxPtr>,
|
||||
pat_syntax_mapping: FxHashMap<LocalSyntaxPtr, PatId>,
|
||||
pat_syntax_mapping_back: FxHashMap<PatId, LocalSyntaxPtr>,
|
||||
}
|
||||
|
||||
impl ExprCollector {
|
||||
fn alloc_expr(&mut self, expr: Expr, syntax_ptr: LocalSyntaxPtr) -> ExprId {
|
||||
let id = self.exprs.alloc(expr);
|
||||
self.expr_syntax_mapping.insert(syntax_ptr, id);
|
||||
self.expr_syntax_mapping_back.insert(id, syntax_ptr);
|
||||
id
|
||||
}
|
||||
|
||||
fn alloc_pat(&mut self, pat: Pat, syntax_ptr: LocalSyntaxPtr) -> PatId {
|
||||
let id = self.pats.alloc(pat);
|
||||
self.pat_syntax_mapping.insert(syntax_ptr, id);
|
||||
self.pat_syntax_mapping_back.insert(id, syntax_ptr);
|
||||
id
|
||||
}
|
||||
|
||||
fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
|
||||
let syntax_ptr = LocalSyntaxPtr::new(expr.syntax());
|
||||
match expr {
|
||||
ast::Expr::IfExpr(e) => {
|
||||
let condition = if let Some(condition) = e.condition() {
|
||||
if condition.pat().is_none() {
|
||||
self.collect_expr_opt(condition.expr())
|
||||
} else {
|
||||
// TODO handle if let
|
||||
return self.alloc_expr(Expr::Missing, syntax_ptr);
|
||||
}
|
||||
} else {
|
||||
self.exprs.alloc(Expr::Missing)
|
||||
};
|
||||
let then_branch = self.collect_block_opt(e.then_branch());
|
||||
let else_branch = e.else_branch().map(|e| self.collect_block(e));
|
||||
self.alloc_expr(
|
||||
Expr::If {
|
||||
condition,
|
||||
then_branch,
|
||||
else_branch,
|
||||
},
|
||||
syntax_ptr,
|
||||
)
|
||||
}
|
||||
ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()),
|
||||
ast::Expr::LoopExpr(e) => {
|
||||
let body = self.collect_block_opt(e.loop_body());
|
||||
self.alloc_expr(Expr::Loop { body }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::WhileExpr(e) => {
|
||||
let condition = if let Some(condition) = e.condition() {
|
||||
if condition.pat().is_none() {
|
||||
self.collect_expr_opt(condition.expr())
|
||||
} else {
|
||||
// TODO handle while let
|
||||
return self.alloc_expr(Expr::Missing, syntax_ptr);
|
||||
}
|
||||
} else {
|
||||
self.exprs.alloc(Expr::Missing)
|
||||
};
|
||||
let body = self.collect_block_opt(e.loop_body());
|
||||
self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::ForExpr(e) => {
|
||||
let iterable = self.collect_expr_opt(e.iterable());
|
||||
let pat = self.collect_pat_opt(e.pat());
|
||||
let body = self.collect_block_opt(e.loop_body());
|
||||
self.alloc_expr(
|
||||
Expr::For {
|
||||
iterable,
|
||||
pat,
|
||||
body,
|
||||
},
|
||||
syntax_ptr,
|
||||
)
|
||||
}
|
||||
ast::Expr::CallExpr(e) => {
|
||||
let callee = self.collect_expr_opt(e.expr());
|
||||
let args = if let Some(arg_list) = e.arg_list() {
|
||||
arg_list.args().map(|e| self.collect_expr(e)).collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::MethodCallExpr(e) => {
|
||||
let receiver = self.collect_expr_opt(e.expr());
|
||||
let args = if let Some(arg_list) = e.arg_list() {
|
||||
arg_list.args().map(|e| self.collect_expr(e)).collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let method_name = e
|
||||
.name_ref()
|
||||
.map(|nr| nr.as_name())
|
||||
.unwrap_or_else(Name::missing);
|
||||
self.alloc_expr(
|
||||
Expr::MethodCall {
|
||||
receiver,
|
||||
method_name,
|
||||
args,
|
||||
},
|
||||
syntax_ptr,
|
||||
)
|
||||
}
|
||||
ast::Expr::MatchExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
let arms = if let Some(match_arm_list) = e.match_arm_list() {
|
||||
match_arm_list
|
||||
.arms()
|
||||
.map(|arm| MatchArm {
|
||||
pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
|
||||
expr: self.collect_expr_opt(arm.expr()),
|
||||
})
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::PathExpr(e) => {
|
||||
let path = e
|
||||
.path()
|
||||
.and_then(Path::from_ast)
|
||||
.map(Expr::Path)
|
||||
.unwrap_or(Expr::Missing);
|
||||
self.alloc_expr(path, syntax_ptr)
|
||||
}
|
||||
ast::Expr::ContinueExpr(_e) => {
|
||||
// TODO: labels
|
||||
self.alloc_expr(Expr::Continue, syntax_ptr)
|
||||
}
|
||||
ast::Expr::BreakExpr(e) => {
|
||||
let expr = e.expr().map(|e| self.collect_expr(e));
|
||||
self.alloc_expr(Expr::Break { expr }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::ParenExpr(e) => {
|
||||
let inner = self.collect_expr_opt(e.expr());
|
||||
// make the paren expr point to the inner expression as well
|
||||
self.expr_syntax_mapping.insert(syntax_ptr, inner);
|
||||
inner
|
||||
}
|
||||
ast::Expr::ReturnExpr(e) => {
|
||||
let expr = e.expr().map(|e| self.collect_expr(e));
|
||||
self.alloc_expr(Expr::Return { expr }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::StructLit(e) => {
|
||||
let path = e.path().and_then(Path::from_ast);
|
||||
let fields = if let Some(nfl) = e.named_field_list() {
|
||||
nfl.fields()
|
||||
.map(|field| StructLitField {
|
||||
name: field
|
||||
.name_ref()
|
||||
.map(|nr| nr.as_name())
|
||||
.unwrap_or_else(Name::missing),
|
||||
expr: if let Some(e) = field.expr() {
|
||||
self.collect_expr(e)
|
||||
} else if let Some(nr) = field.name_ref() {
|
||||
// field shorthand
|
||||
let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(nr)));
|
||||
self.expr_syntax_mapping
|
||||
.insert(LocalSyntaxPtr::new(nr.syntax()), id);
|
||||
self.expr_syntax_mapping_back
|
||||
.insert(id, LocalSyntaxPtr::new(nr.syntax()));
|
||||
id
|
||||
} else {
|
||||
self.exprs.alloc(Expr::Missing)
|
||||
},
|
||||
})
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let spread = e.spread().map(|s| self.collect_expr(s));
|
||||
self.alloc_expr(
|
||||
Expr::StructLit {
|
||||
path,
|
||||
fields,
|
||||
spread,
|
||||
},
|
||||
syntax_ptr,
|
||||
)
|
||||
}
|
||||
ast::Expr::FieldExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
let name = e
|
||||
.name_ref()
|
||||
.map(|nr| nr.as_name())
|
||||
.unwrap_or_else(Name::missing);
|
||||
self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::TryExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
self.alloc_expr(Expr::Try { expr }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::CastExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
let type_ref = TypeRef::from_ast_opt(e.type_ref());
|
||||
self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::RefExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
let mutability = Mutability::from_mutable(e.is_mut());
|
||||
self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
|
||||
}
|
||||
ast::Expr::PrefixExpr(e) => {
|
||||
let expr = self.collect_expr_opt(e.expr());
|
||||
let op = e.op();
|
||||
self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
|
||||
}
|
||||
|
||||
// We should never get to these because they're handled in MatchExpr resp. StructLit:
|
||||
ast::Expr::MatchArmList(_) | ast::Expr::MatchArm(_) | ast::Expr::MatchGuard(_) => {
|
||||
panic!("collect_expr called on {:?}", expr)
|
||||
}
|
||||
ast::Expr::NamedFieldList(_) | ast::Expr::NamedField(_) => {
|
||||
panic!("collect_expr called on {:?}", expr)
|
||||
}
|
||||
|
||||
// TODO implement HIR for these:
|
||||
ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::LambdaExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::TupleExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::BinExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
ast::Expr::Literal(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
|
||||
}
|
||||
}
|
||||
|
||||
fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
|
||||
if let Some(expr) = expr {
|
||||
self.collect_expr(expr)
|
||||
} else {
|
||||
self.exprs.alloc(Expr::Missing)
|
||||
}
|
||||
}
|
||||
|
||||
fn collect_block(&mut self, block: ast::Block) -> ExprId {
|
||||
let statements = block
|
||||
.statements()
|
||||
.map(|s| match s {
|
||||
ast::Stmt::LetStmt(stmt) => {
|
||||
let pat = self.collect_pat_opt(stmt.pat());
|
||||
let type_ref = stmt.type_ref().map(TypeRef::from_ast);
|
||||
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())),
|
||||
})
|
||||
.collect();
|
||||
let tail = block.expr().map(|e| self.collect_expr(e));
|
||||
self.alloc_expr(
|
||||
Expr::Block { statements, tail },
|
||||
LocalSyntaxPtr::new(block.syntax()),
|
||||
)
|
||||
}
|
||||
|
||||
fn collect_block_opt(&mut self, block: Option<ast::Block>) -> ExprId {
|
||||
if let Some(block) = block {
|
||||
self.collect_block(block)
|
||||
} else {
|
||||
self.exprs.alloc(Expr::Missing)
|
||||
}
|
||||
}
|
||||
|
||||
fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
|
||||
let syntax_ptr = LocalSyntaxPtr::new(pat.syntax());
|
||||
// TODO
|
||||
self.alloc_pat(Pat, syntax_ptr)
|
||||
}
|
||||
|
||||
fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
|
||||
if let Some(pat) = pat {
|
||||
self.collect_pat(pat)
|
||||
} else {
|
||||
// TODO
|
||||
self.pats.alloc(Pat)
|
||||
}
|
||||
}
|
||||
|
||||
fn into_body_syntax_mapping(self, args: Vec<PatId>, body_expr: ExprId) -> BodySyntaxMapping {
|
||||
let body = Body {
|
||||
exprs: self.exprs,
|
||||
pats: self.pats,
|
||||
args,
|
||||
body_expr,
|
||||
};
|
||||
BodySyntaxMapping {
|
||||
body: Arc::new(body),
|
||||
expr_syntax_mapping: self.expr_syntax_mapping,
|
||||
expr_syntax_mapping_back: self.expr_syntax_mapping_back,
|
||||
pat_syntax_mapping: self.pat_syntax_mapping,
|
||||
pat_syntax_mapping_back: self.pat_syntax_mapping_back,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn body_syntax_mapping(
|
||||
db: &impl HirDatabase,
|
||||
def_id: DefId,
|
||||
) -> Cancelable<Arc<BodySyntaxMapping>> {
|
||||
let def = def_id.resolve(db)?;
|
||||
let mut collector = ExprCollector {
|
||||
exprs: Arena::default(),
|
||||
pats: Arena::default(),
|
||||
expr_syntax_mapping: FxHashMap::default(),
|
||||
expr_syntax_mapping_back: FxHashMap::default(),
|
||||
pat_syntax_mapping: FxHashMap::default(),
|
||||
pat_syntax_mapping_back: FxHashMap::default(),
|
||||
};
|
||||
|
||||
let (body, args) = match def {
|
||||
Def::Function(f) => {
|
||||
let node = f.syntax(db);
|
||||
let node = node.borrowed();
|
||||
|
||||
let args = if let Some(param_list) = node.param_list() {
|
||||
let mut args = Vec::new();
|
||||
// TODO self param
|
||||
for param in param_list.params() {
|
||||
let pat = if let Some(pat) = param.pat() {
|
||||
pat
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
args.push(collector.collect_pat(pat));
|
||||
}
|
||||
args
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
|
||||
let body = collector.collect_block_opt(node.body());
|
||||
(body, args)
|
||||
}
|
||||
// TODO: consts, etc.
|
||||
_ => panic!("Trying to get body for item type without body"),
|
||||
};
|
||||
|
||||
Ok(Arc::new(collector.into_body_syntax_mapping(args, body)))
|
||||
}
|
||||
|
|
@ -32,6 +32,7 @@ mod adt;
|
|||
mod type_ref;
|
||||
mod ty;
|
||||
mod impl_block;
|
||||
mod expr;
|
||||
|
||||
use crate::{
|
||||
db::HirDatabase,
|
||||
|
|
|
|||
|
|
@ -208,6 +208,8 @@ salsa::database_storage! {
|
|||
fn struct_data() for db::StructDataQuery;
|
||||
fn enum_data() for db::EnumDataQuery;
|
||||
fn impls_in_module() for db::ImplsInModuleQuery;
|
||||
fn body_hir() for db::BodyHirQuery;
|
||||
fn body_syntax_mapping() for db::BodySyntaxMappingQuery;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,6 +65,14 @@ impl Path {
|
|||
}
|
||||
}
|
||||
|
||||
/// Converts an `ast::NameRef` into a single-identifier `Path`.
|
||||
pub fn from_name_ref(name_ref: ast::NameRef) -> Path {
|
||||
Path {
|
||||
kind: PathKind::Plain,
|
||||
segments: vec![name_ref.as_name()],
|
||||
}
|
||||
}
|
||||
|
||||
/// `true` is this path is a single identifier, like `foo`
|
||||
pub fn is_ident(&self) -> bool {
|
||||
self.kind == PathKind::Plain && self.segments.len() == 1
|
||||
|
|
|
|||
|
|
@ -378,7 +378,11 @@ impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
|
|||
}
|
||||
|
||||
|
||||
impl<'a> BreakExpr<'a> {}
|
||||
impl<'a> BreakExpr<'a> {
|
||||
pub fn expr(self) -> Option<Expr<'a>> {
|
||||
super::child_opt(self)
|
||||
}
|
||||
}
|
||||
|
||||
// Byte
|
||||
#[derive(Debug, Clone, Copy,)]
|
||||
|
|
@ -3880,6 +3884,10 @@ impl<'a> StructLit<'a> {
|
|||
pub fn named_field_list(self) -> Option<NamedFieldList<'a>> {
|
||||
super::child_opt(self)
|
||||
}
|
||||
|
||||
pub fn spread(self) -> Option<Expr<'a>> {
|
||||
super::child_opt(self)
|
||||
}
|
||||
}
|
||||
|
||||
// StructPat
|
||||
|
|
|
|||
|
|
@ -384,7 +384,7 @@ Grammar(
|
|||
options: [ "Condition" ]
|
||||
),
|
||||
"ContinueExpr": (),
|
||||
"BreakExpr": (),
|
||||
"BreakExpr": (options: ["Expr"]),
|
||||
"Label": (),
|
||||
"BlockExpr": (
|
||||
options: [ "Block" ]
|
||||
|
|
@ -404,7 +404,7 @@ Grammar(
|
|||
collections: [ [ "pats", "Pat" ] ]
|
||||
),
|
||||
"MatchGuard": (),
|
||||
"StructLit": (options: ["Path", "NamedFieldList"]),
|
||||
"StructLit": (options: ["Path", "NamedFieldList", ["spread", "Expr"]]),
|
||||
"NamedFieldList": (collections: [ ["fields", "NamedField"] ]),
|
||||
"NamedField": (options: ["NameRef", "Expr"]),
|
||||
"CallExpr": (
|
||||
|
|
|
|||
Loading…
Reference in a new issue