diff options
Diffstat (limited to 'crates')
-rw-r--r-- | crates/ra_cfg/src/lib.rs | 5 | ||||
-rw-r--r-- | crates/ra_fmt/src/lib.rs | 5 | ||||
-rw-r--r-- | crates/ra_hir/src/expr.rs | 408 | ||||
-rw-r--r-- | crates/ra_hir/src/expr/lower.rs | 82 | ||||
-rw-r--r-- | crates/ra_hir/src/ty/infer/expr.rs | 4 | ||||
-rw-r--r-- | crates/ra_hir/src/ty/lower.rs | 38 | ||||
-rw-r--r-- | crates/ra_hir/src/ty/primitive.rs | 26 | ||||
-rw-r--r-- | crates/ra_hir_def/src/body.rs | 2 | ||||
-rw-r--r-- | crates/ra_hir_def/src/body/lower.rs | 49 | ||||
-rw-r--r-- | crates/ra_hir_def/src/builtin_type.rs | 86 | ||||
-rw-r--r-- | crates/ra_hir_def/src/expr.rs | 419 | ||||
-rw-r--r-- | crates/ra_hir_def/src/lib.rs | 2 |
12 files changed, 604 insertions, 522 deletions
diff --git a/crates/ra_cfg/src/lib.rs b/crates/ra_cfg/src/lib.rs index 1bee3eb99..51d953f6e 100644 --- a/crates/ra_cfg/src/lib.rs +++ b/crates/ra_cfg/src/lib.rs | |||
@@ -1,11 +1,12 @@ | |||
1 | //! ra_cfg defines conditional compiling options, `cfg` attibute parser and evaluator | 1 | //! ra_cfg defines conditional compiling options, `cfg` attibute parser and evaluator |
2 | |||
3 | mod cfg_expr; | ||
4 | |||
2 | use std::iter::IntoIterator; | 5 | use std::iter::IntoIterator; |
3 | 6 | ||
4 | use ra_syntax::SmolStr; | 7 | use ra_syntax::SmolStr; |
5 | use rustc_hash::FxHashSet; | 8 | use rustc_hash::FxHashSet; |
6 | 9 | ||
7 | mod cfg_expr; | ||
8 | |||
9 | pub use cfg_expr::{parse_cfg, CfgExpr}; | 10 | pub use cfg_expr::{parse_cfg, CfgExpr}; |
10 | 11 | ||
11 | /// Configuration options used for conditional compilition on items with `cfg` attributes. | 12 | /// Configuration options used for conditional compilition on items with `cfg` attributes. |
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs index e22ac9753..a30ed4cbb 100644 --- a/crates/ra_fmt/src/lib.rs +++ b/crates/ra_fmt/src/lib.rs | |||
@@ -1,5 +1,7 @@ | |||
1 | //! This crate provides some utilities for indenting rust code. | 1 | //! This crate provides some utilities for indenting rust code. |
2 | //! | 2 | |
3 | use std::iter::successors; | ||
4 | |||
3 | use itertools::Itertools; | 5 | use itertools::Itertools; |
4 | use ra_syntax::{ | 6 | use ra_syntax::{ |
5 | ast::{self, AstNode, AstToken}, | 7 | ast::{self, AstNode, AstToken}, |
@@ -7,7 +9,6 @@ use ra_syntax::{ | |||
7 | SyntaxKind::*, | 9 | SyntaxKind::*, |
8 | SyntaxNode, SyntaxToken, T, | 10 | SyntaxNode, SyntaxToken, T, |
9 | }; | 11 | }; |
10 | use std::iter::successors; | ||
11 | 12 | ||
12 | pub fn reindent(text: &str, indent: &str) -> String { | 13 | pub fn reindent(text: &str, indent: &str) -> String { |
13 | let indent = format!("\n{}", indent); | 14 | let indent = format!("\n{}", indent); |
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index 53da7f0bf..dd2bae9b4 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs | |||
@@ -6,29 +6,18 @@ pub(crate) mod validation; | |||
6 | 6 | ||
7 | use std::{ops::Index, sync::Arc}; | 7 | use std::{ops::Index, sync::Arc}; |
8 | 8 | ||
9 | use hir_def::{ | 9 | use ra_arena::{map::ArenaMap, Arena}; |
10 | path::GenericArgs, | ||
11 | type_ref::{Mutability, TypeRef}, | ||
12 | }; | ||
13 | use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId}; | ||
14 | use ra_syntax::{ast, AstPtr}; | 10 | use ra_syntax::{ast, AstPtr}; |
15 | use rustc_hash::FxHashMap; | 11 | use rustc_hash::FxHashMap; |
16 | 12 | ||
17 | use crate::{ | 13 | use crate::{db::HirDatabase, DefWithBody, Either, HasSource, Resolver, Source}; |
18 | db::HirDatabase, | ||
19 | ty::primitive::{UncertainFloatTy, UncertainIntTy}, | ||
20 | DefWithBody, Either, HasSource, Name, Path, Resolver, Source, | ||
21 | }; | ||
22 | 14 | ||
23 | pub use self::scope::ExprScopes; | 15 | pub use self::scope::ExprScopes; |
24 | 16 | ||
25 | #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] | 17 | pub use hir_def::expr::{ |
26 | pub struct ExprId(RawId); | 18 | ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, MatchArm, |
27 | impl_arena_id!(ExprId); | 19 | Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp, |
28 | 20 | }; | |
29 | #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] | ||
30 | pub struct PatId(RawId); | ||
31 | impl_arena_id!(PatId); | ||
32 | 21 | ||
33 | /// The body of an item (function, const etc.). | 22 | /// The body of an item (function, const etc.). |
34 | #[derive(Debug, Eq, PartialEq)] | 23 | #[derive(Debug, Eq, PartialEq)] |
@@ -187,388 +176,3 @@ impl BodySourceMap { | |||
187 | self.field_map[&(expr, field)] | 176 | self.field_map[&(expr, field)] |
188 | } | 177 | } |
189 | } | 178 | } |
190 | |||
191 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
192 | pub enum Literal { | ||
193 | String(String), | ||
194 | ByteString(Vec<u8>), | ||
195 | Char(char), | ||
196 | Bool(bool), | ||
197 | Int(u64, UncertainIntTy), | ||
198 | Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq | ||
199 | } | ||
200 | |||
201 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
202 | pub enum Expr { | ||
203 | /// This is produced if syntax tree does not have a required expression piece. | ||
204 | Missing, | ||
205 | Path(Path), | ||
206 | If { | ||
207 | condition: ExprId, | ||
208 | then_branch: ExprId, | ||
209 | else_branch: Option<ExprId>, | ||
210 | }, | ||
211 | Block { | ||
212 | statements: Vec<Statement>, | ||
213 | tail: Option<ExprId>, | ||
214 | }, | ||
215 | Loop { | ||
216 | body: ExprId, | ||
217 | }, | ||
218 | While { | ||
219 | condition: ExprId, | ||
220 | body: ExprId, | ||
221 | }, | ||
222 | For { | ||
223 | iterable: ExprId, | ||
224 | pat: PatId, | ||
225 | body: ExprId, | ||
226 | }, | ||
227 | Call { | ||
228 | callee: ExprId, | ||
229 | args: Vec<ExprId>, | ||
230 | }, | ||
231 | MethodCall { | ||
232 | receiver: ExprId, | ||
233 | method_name: Name, | ||
234 | args: Vec<ExprId>, | ||
235 | generic_args: Option<GenericArgs>, | ||
236 | }, | ||
237 | Match { | ||
238 | expr: ExprId, | ||
239 | arms: Vec<MatchArm>, | ||
240 | }, | ||
241 | Continue, | ||
242 | Break { | ||
243 | expr: Option<ExprId>, | ||
244 | }, | ||
245 | Return { | ||
246 | expr: Option<ExprId>, | ||
247 | }, | ||
248 | RecordLit { | ||
249 | path: Option<Path>, | ||
250 | fields: Vec<RecordLitField>, | ||
251 | spread: Option<ExprId>, | ||
252 | }, | ||
253 | Field { | ||
254 | expr: ExprId, | ||
255 | name: Name, | ||
256 | }, | ||
257 | Await { | ||
258 | expr: ExprId, | ||
259 | }, | ||
260 | Try { | ||
261 | expr: ExprId, | ||
262 | }, | ||
263 | TryBlock { | ||
264 | body: ExprId, | ||
265 | }, | ||
266 | Cast { | ||
267 | expr: ExprId, | ||
268 | type_ref: TypeRef, | ||
269 | }, | ||
270 | Ref { | ||
271 | expr: ExprId, | ||
272 | mutability: Mutability, | ||
273 | }, | ||
274 | Box { | ||
275 | expr: ExprId, | ||
276 | }, | ||
277 | UnaryOp { | ||
278 | expr: ExprId, | ||
279 | op: UnaryOp, | ||
280 | }, | ||
281 | BinaryOp { | ||
282 | lhs: ExprId, | ||
283 | rhs: ExprId, | ||
284 | op: Option<BinaryOp>, | ||
285 | }, | ||
286 | Index { | ||
287 | base: ExprId, | ||
288 | index: ExprId, | ||
289 | }, | ||
290 | Lambda { | ||
291 | args: Vec<PatId>, | ||
292 | arg_types: Vec<Option<TypeRef>>, | ||
293 | body: ExprId, | ||
294 | }, | ||
295 | Tuple { | ||
296 | exprs: Vec<ExprId>, | ||
297 | }, | ||
298 | Array(Array), | ||
299 | Literal(Literal), | ||
300 | } | ||
301 | |||
302 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
303 | pub enum BinaryOp { | ||
304 | LogicOp(LogicOp), | ||
305 | ArithOp(ArithOp), | ||
306 | CmpOp(CmpOp), | ||
307 | Assignment { op: Option<ArithOp> }, | ||
308 | } | ||
309 | |||
310 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
311 | pub enum LogicOp { | ||
312 | And, | ||
313 | Or, | ||
314 | } | ||
315 | |||
316 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
317 | pub enum CmpOp { | ||
318 | Eq { negated: bool }, | ||
319 | Ord { ordering: Ordering, strict: bool }, | ||
320 | } | ||
321 | |||
322 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
323 | pub enum Ordering { | ||
324 | Less, | ||
325 | Greater, | ||
326 | } | ||
327 | |||
328 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
329 | pub enum ArithOp { | ||
330 | Add, | ||
331 | Mul, | ||
332 | Sub, | ||
333 | Div, | ||
334 | Rem, | ||
335 | Shl, | ||
336 | Shr, | ||
337 | BitXor, | ||
338 | BitOr, | ||
339 | BitAnd, | ||
340 | } | ||
341 | |||
342 | pub use ra_syntax::ast::PrefixOp as UnaryOp; | ||
343 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
344 | pub enum Array { | ||
345 | ElementList(Vec<ExprId>), | ||
346 | Repeat { initializer: ExprId, repeat: ExprId }, | ||
347 | } | ||
348 | |||
349 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
350 | pub struct MatchArm { | ||
351 | pub pats: Vec<PatId>, | ||
352 | pub guard: Option<ExprId>, | ||
353 | pub expr: ExprId, | ||
354 | } | ||
355 | |||
356 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
357 | pub struct RecordLitField { | ||
358 | pub name: Name, | ||
359 | pub expr: ExprId, | ||
360 | } | ||
361 | |||
362 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
363 | pub enum Statement { | ||
364 | Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> }, | ||
365 | Expr(ExprId), | ||
366 | } | ||
367 | |||
368 | impl Expr { | ||
369 | pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) { | ||
370 | match self { | ||
371 | Expr::Missing => {} | ||
372 | Expr::Path(_) => {} | ||
373 | Expr::If { condition, then_branch, else_branch } => { | ||
374 | f(*condition); | ||
375 | f(*then_branch); | ||
376 | if let Some(else_branch) = else_branch { | ||
377 | f(*else_branch); | ||
378 | } | ||
379 | } | ||
380 | Expr::Block { statements, tail } => { | ||
381 | for stmt in statements { | ||
382 | match stmt { | ||
383 | Statement::Let { initializer, .. } => { | ||
384 | if let Some(expr) = initializer { | ||
385 | f(*expr); | ||
386 | } | ||
387 | } | ||
388 | Statement::Expr(e) => f(*e), | ||
389 | } | ||
390 | } | ||
391 | if let Some(expr) = tail { | ||
392 | f(*expr); | ||
393 | } | ||
394 | } | ||
395 | Expr::TryBlock { body } => f(*body), | ||
396 | Expr::Loop { body } => f(*body), | ||
397 | Expr::While { condition, body } => { | ||
398 | f(*condition); | ||
399 | f(*body); | ||
400 | } | ||
401 | Expr::For { iterable, body, .. } => { | ||
402 | f(*iterable); | ||
403 | f(*body); | ||
404 | } | ||
405 | Expr::Call { callee, args } => { | ||
406 | f(*callee); | ||
407 | for arg in args { | ||
408 | f(*arg); | ||
409 | } | ||
410 | } | ||
411 | Expr::MethodCall { receiver, args, .. } => { | ||
412 | f(*receiver); | ||
413 | for arg in args { | ||
414 | f(*arg); | ||
415 | } | ||
416 | } | ||
417 | Expr::Match { expr, arms } => { | ||
418 | f(*expr); | ||
419 | for arm in arms { | ||
420 | f(arm.expr); | ||
421 | } | ||
422 | } | ||
423 | Expr::Continue => {} | ||
424 | Expr::Break { expr } | Expr::Return { expr } => { | ||
425 | if let Some(expr) = expr { | ||
426 | f(*expr); | ||
427 | } | ||
428 | } | ||
429 | Expr::RecordLit { fields, spread, .. } => { | ||
430 | for field in fields { | ||
431 | f(field.expr); | ||
432 | } | ||
433 | if let Some(expr) = spread { | ||
434 | f(*expr); | ||
435 | } | ||
436 | } | ||
437 | Expr::Lambda { body, .. } => { | ||
438 | f(*body); | ||
439 | } | ||
440 | Expr::BinaryOp { lhs, rhs, .. } => { | ||
441 | f(*lhs); | ||
442 | f(*rhs); | ||
443 | } | ||
444 | Expr::Index { base, index } => { | ||
445 | f(*base); | ||
446 | f(*index); | ||
447 | } | ||
448 | Expr::Field { expr, .. } | ||
449 | | Expr::Await { expr } | ||
450 | | Expr::Try { expr } | ||
451 | | Expr::Cast { expr, .. } | ||
452 | | Expr::Ref { expr, .. } | ||
453 | | Expr::UnaryOp { expr, .. } | ||
454 | | Expr::Box { expr } => { | ||
455 | f(*expr); | ||
456 | } | ||
457 | Expr::Tuple { exprs } => { | ||
458 | for expr in exprs { | ||
459 | f(*expr); | ||
460 | } | ||
461 | } | ||
462 | Expr::Array(a) => match a { | ||
463 | Array::ElementList(exprs) => { | ||
464 | for expr in exprs { | ||
465 | f(*expr); | ||
466 | } | ||
467 | } | ||
468 | Array::Repeat { initializer, repeat } => { | ||
469 | f(*initializer); | ||
470 | f(*repeat) | ||
471 | } | ||
472 | }, | ||
473 | Expr::Literal(_) => {} | ||
474 | } | ||
475 | } | ||
476 | } | ||
477 | |||
478 | /// Explicit binding annotations given in the HIR for a binding. Note | ||
479 | /// that this is not the final binding *mode* that we infer after type | ||
480 | /// inference. | ||
481 | #[derive(Clone, PartialEq, Eq, Debug, Copy)] | ||
482 | pub enum BindingAnnotation { | ||
483 | /// No binding annotation given: this means that the final binding mode | ||
484 | /// will depend on whether we have skipped through a `&` reference | ||
485 | /// when matching. For example, the `x` in `Some(x)` will have binding | ||
486 | /// mode `None`; if you do `let Some(x) = &Some(22)`, it will | ||
487 | /// ultimately be inferred to be by-reference. | ||
488 | Unannotated, | ||
489 | |||
490 | /// Annotated with `mut x` -- could be either ref or not, similar to `None`. | ||
491 | Mutable, | ||
492 | |||
493 | /// Annotated as `ref`, like `ref x` | ||
494 | Ref, | ||
495 | |||
496 | /// Annotated as `ref mut x`. | ||
497 | RefMut, | ||
498 | } | ||
499 | |||
500 | impl BindingAnnotation { | ||
501 | fn new(is_mutable: bool, is_ref: bool) -> Self { | ||
502 | match (is_mutable, is_ref) { | ||
503 | (true, true) => BindingAnnotation::RefMut, | ||
504 | (false, true) => BindingAnnotation::Ref, | ||
505 | (true, false) => BindingAnnotation::Mutable, | ||
506 | (false, false) => BindingAnnotation::Unannotated, | ||
507 | } | ||
508 | } | ||
509 | } | ||
510 | |||
511 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
512 | pub struct RecordFieldPat { | ||
513 | pub(crate) name: Name, | ||
514 | pub(crate) pat: PatId, | ||
515 | } | ||
516 | |||
517 | /// Close relative to rustc's hir::PatKind | ||
518 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
519 | pub enum Pat { | ||
520 | Missing, | ||
521 | Wild, | ||
522 | Tuple(Vec<PatId>), | ||
523 | Record { | ||
524 | path: Option<Path>, | ||
525 | args: Vec<RecordFieldPat>, | ||
526 | // FIXME: 'ellipsis' option | ||
527 | }, | ||
528 | Range { | ||
529 | start: ExprId, | ||
530 | end: ExprId, | ||
531 | }, | ||
532 | Slice { | ||
533 | prefix: Vec<PatId>, | ||
534 | rest: Option<PatId>, | ||
535 | suffix: Vec<PatId>, | ||
536 | }, | ||
537 | Path(Path), | ||
538 | Lit(ExprId), | ||
539 | Bind { | ||
540 | mode: BindingAnnotation, | ||
541 | name: Name, | ||
542 | subpat: Option<PatId>, | ||
543 | }, | ||
544 | TupleStruct { | ||
545 | path: Option<Path>, | ||
546 | args: Vec<PatId>, | ||
547 | }, | ||
548 | Ref { | ||
549 | pat: PatId, | ||
550 | mutability: Mutability, | ||
551 | }, | ||
552 | } | ||
553 | |||
554 | impl Pat { | ||
555 | pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) { | ||
556 | match self { | ||
557 | Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {} | ||
558 | Pat::Bind { subpat, .. } => { | ||
559 | subpat.iter().copied().for_each(f); | ||
560 | } | ||
561 | Pat::Tuple(args) | Pat::TupleStruct { args, .. } => { | ||
562 | args.iter().copied().for_each(f); | ||
563 | } | ||
564 | Pat::Ref { pat, .. } => f(*pat), | ||
565 | Pat::Slice { prefix, rest, suffix } => { | ||
566 | let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter()); | ||
567 | total_iter.copied().for_each(f); | ||
568 | } | ||
569 | Pat::Record { args, .. } => { | ||
570 | args.iter().map(|f| f.pat).for_each(f); | ||
571 | } | ||
572 | } | ||
573 | } | ||
574 | } | ||
diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs index 6463dd65e..7b0bfd919 100644 --- a/crates/ra_hir/src/expr/lower.rs +++ b/crates/ra_hir/src/expr/lower.rs | |||
@@ -1,6 +1,10 @@ | |||
1 | //! FIXME: write short doc here | 1 | //! FIXME: write short doc here |
2 | 2 | ||
3 | use hir_def::{path::GenericArgs, type_ref::TypeRef}; | 3 | use hir_def::{ |
4 | builtin_type::{BuiltinFloat, BuiltinInt}, | ||
5 | path::GenericArgs, | ||
6 | type_ref::TypeRef, | ||
7 | }; | ||
4 | use hir_expand::{ | 8 | use hir_expand::{ |
5 | hygiene::Hygiene, | 9 | hygiene::Hygiene, |
6 | name::{self, AsName, Name}, | 10 | name::{self, AsName, Name}, |
@@ -16,15 +20,13 @@ use ra_syntax::{ | |||
16 | use test_utils::tested_by; | 20 | use test_utils::tested_by; |
17 | 21 | ||
18 | use crate::{ | 22 | use crate::{ |
19 | db::HirDatabase, | 23 | db::HirDatabase, AstId, DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, |
20 | ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy}, | 24 | Mutability, Path, Resolver, Source, |
21 | AstId, DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path, Resolver, | ||
22 | Source, | ||
23 | }; | 25 | }; |
24 | 26 | ||
25 | use super::{ | 27 | use super::{ |
26 | ArithOp, Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, CmpOp, Expr, ExprId, Literal, | 28 | Array, BinaryOp, BindingAnnotation, Body, BodySourceMap, Expr, ExprId, Literal, MatchArm, Pat, |
27 | LogicOp, MatchArm, Ordering, Pat, PatId, PatPtr, RecordFieldPat, RecordLitField, Statement, | 29 | PatId, PatPtr, RecordFieldPat, RecordLitField, Statement, |
28 | }; | 30 | }; |
29 | 31 | ||
30 | pub(super) fn lower( | 32 | pub(super) fn lower( |
@@ -46,7 +48,7 @@ pub(super) fn lower( | |||
46 | exprs: Arena::default(), | 48 | exprs: Arena::default(), |
47 | pats: Arena::default(), | 49 | pats: Arena::default(), |
48 | params: Vec::new(), | 50 | params: Vec::new(), |
49 | body_expr: ExprId((!0).into()), | 51 | body_expr: ExprId::dummy(), |
50 | }, | 52 | }, |
51 | } | 53 | } |
52 | .collect(params, body) | 54 | .collect(params, body) |
@@ -423,28 +425,18 @@ where | |||
423 | ast::Expr::Literal(e) => { | 425 | ast::Expr::Literal(e) => { |
424 | let lit = match e.kind() { | 426 | let lit = match e.kind() { |
425 | LiteralKind::IntNumber { suffix } => { | 427 | LiteralKind::IntNumber { suffix } => { |
426 | let known_name = suffix | 428 | let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it)); |
427 | .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known)); | ||
428 | 429 | ||
429 | Literal::Int( | 430 | Literal::Int(Default::default(), known_name) |
430 | Default::default(), | ||
431 | known_name.unwrap_or(UncertainIntTy::Unknown), | ||
432 | ) | ||
433 | } | 431 | } |
434 | LiteralKind::FloatNumber { suffix } => { | 432 | LiteralKind::FloatNumber { suffix } => { |
435 | let known_name = suffix | 433 | let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it)); |
436 | .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known)); | ||
437 | 434 | ||
438 | Literal::Float( | 435 | Literal::Float(Default::default(), known_name) |
439 | Default::default(), | ||
440 | known_name.unwrap_or(UncertainFloatTy::Unknown), | ||
441 | ) | ||
442 | } | 436 | } |
443 | LiteralKind::ByteString => Literal::ByteString(Default::default()), | 437 | LiteralKind::ByteString => Literal::ByteString(Default::default()), |
444 | LiteralKind::String => Literal::String(Default::default()), | 438 | LiteralKind::String => Literal::String(Default::default()), |
445 | LiteralKind::Byte => { | 439 | LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)), |
446 | Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8())) | ||
447 | } | ||
448 | LiteralKind::Bool => Literal::Bool(Default::default()), | 440 | LiteralKind::Bool => Literal::Bool(Default::default()), |
449 | LiteralKind::Char => Literal::Char(Default::default()), | 441 | LiteralKind::Char => Literal::Char(Default::default()), |
450 | }; | 442 | }; |
@@ -601,47 +593,3 @@ where | |||
601 | Path::from_src(path, &hygiene) | 593 | Path::from_src(path, &hygiene) |
602 | } | 594 | } |
603 | } | 595 | } |
604 | |||
605 | impl From<ast::BinOp> for BinaryOp { | ||
606 | fn from(ast_op: ast::BinOp) -> Self { | ||
607 | match ast_op { | ||
608 | ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or), | ||
609 | ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And), | ||
610 | ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }), | ||
611 | ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }), | ||
612 | ast::BinOp::LesserEqualTest => { | ||
613 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false }) | ||
614 | } | ||
615 | ast::BinOp::GreaterEqualTest => { | ||
616 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false }) | ||
617 | } | ||
618 | ast::BinOp::LesserTest => { | ||
619 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true }) | ||
620 | } | ||
621 | ast::BinOp::GreaterTest => { | ||
622 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true }) | ||
623 | } | ||
624 | ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add), | ||
625 | ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul), | ||
626 | ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub), | ||
627 | ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div), | ||
628 | ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem), | ||
629 | ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl), | ||
630 | ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr), | ||
631 | ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor), | ||
632 | ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr), | ||
633 | ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd), | ||
634 | ast::BinOp::Assignment => BinaryOp::Assignment { op: None }, | ||
635 | ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) }, | ||
636 | ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) }, | ||
637 | ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) }, | ||
638 | ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) }, | ||
639 | ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) }, | ||
640 | ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) }, | ||
641 | ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) }, | ||
642 | ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) }, | ||
643 | ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) }, | ||
644 | ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) }, | ||
645 | } | ||
646 | } | ||
647 | } | ||
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs index 4af1d65ee..6d9792391 100644 --- a/crates/ra_hir/src/ty/infer/expr.rs +++ b/crates/ra_hir/src/ty/infer/expr.rs | |||
@@ -452,8 +452,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { | |||
452 | Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type) | 452 | Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type) |
453 | } | 453 | } |
454 | Literal::Char(..) => Ty::simple(TypeCtor::Char), | 454 | Literal::Char(..) => Ty::simple(TypeCtor::Char), |
455 | Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int(*ty)), | 455 | Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())), |
456 | Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float(*ty)), | 456 | Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())), |
457 | }, | 457 | }, |
458 | }; | 458 | }; |
459 | // use a new type variable if we got Ty::Unknown here | 459 | // use a new type variable if we got Ty::Unknown here |
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 52d24e24d..1832fcf50 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs | |||
@@ -25,7 +25,7 @@ use crate::{ | |||
25 | generics::{GenericDef, WherePredicate}, | 25 | generics::{GenericDef, WherePredicate}, |
26 | resolve::{Resolver, TypeNs}, | 26 | resolve::{Resolver, TypeNs}, |
27 | ty::{ | 27 | ty::{ |
28 | primitive::{FloatTy, IntTy}, | 28 | primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy}, |
29 | Adt, | 29 | Adt, |
30 | }, | 30 | }, |
31 | util::make_mut_slice, | 31 | util::make_mut_slice, |
@@ -657,13 +657,41 @@ fn type_for_builtin(def: BuiltinType) -> Ty { | |||
657 | BuiltinType::Char => TypeCtor::Char, | 657 | BuiltinType::Char => TypeCtor::Char, |
658 | BuiltinType::Bool => TypeCtor::Bool, | 658 | BuiltinType::Bool => TypeCtor::Bool, |
659 | BuiltinType::Str => TypeCtor::Str, | 659 | BuiltinType::Str => TypeCtor::Str, |
660 | BuiltinType::Int(BuiltinInt { signedness, bitness }) => { | 660 | BuiltinType::Int(t) => TypeCtor::Int(IntTy::from(t).into()), |
661 | TypeCtor::Int(IntTy { signedness, bitness }.into()) | 661 | BuiltinType::Float(t) => TypeCtor::Float(FloatTy::from(t).into()), |
662 | } | ||
663 | BuiltinType::Float(BuiltinFloat { bitness }) => TypeCtor::Float(FloatTy { bitness }.into()), | ||
664 | }) | 662 | }) |
665 | } | 663 | } |
666 | 664 | ||
665 | impl From<BuiltinInt> for IntTy { | ||
666 | fn from(t: BuiltinInt) -> Self { | ||
667 | IntTy { signedness: t.signedness, bitness: t.bitness } | ||
668 | } | ||
669 | } | ||
670 | |||
671 | impl From<BuiltinFloat> for FloatTy { | ||
672 | fn from(t: BuiltinFloat) -> Self { | ||
673 | FloatTy { bitness: t.bitness } | ||
674 | } | ||
675 | } | ||
676 | |||
677 | impl From<Option<BuiltinInt>> for UncertainIntTy { | ||
678 | fn from(t: Option<BuiltinInt>) -> Self { | ||
679 | match t { | ||
680 | None => UncertainIntTy::Unknown, | ||
681 | Some(t) => UncertainIntTy::Known(t.into()), | ||
682 | } | ||
683 | } | ||
684 | } | ||
685 | |||
686 | impl From<Option<BuiltinFloat>> for UncertainFloatTy { | ||
687 | fn from(t: Option<BuiltinFloat>) -> Self { | ||
688 | match t { | ||
689 | None => UncertainFloatTy::Unknown, | ||
690 | Some(t) => UncertainFloatTy::Known(t.into()), | ||
691 | } | ||
692 | } | ||
693 | } | ||
694 | |||
667 | fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig { | 695 | fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig { |
668 | let struct_data = db.struct_data(def.id.into()); | 696 | let struct_data = db.struct_data(def.id.into()); |
669 | let fields = match struct_data.variant_data.fields() { | 697 | let fields = match struct_data.variant_data.fields() { |
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs index 1749752f1..7362de4c3 100644 --- a/crates/ra_hir/src/ty/primitive.rs +++ b/crates/ra_hir/src/ty/primitive.rs | |||
@@ -129,24 +129,6 @@ impl IntTy { | |||
129 | (Signedness::Unsigned, IntBitness::X128) => "u128", | 129 | (Signedness::Unsigned, IntBitness::X128) => "u128", |
130 | } | 130 | } |
131 | } | 131 | } |
132 | |||
133 | pub(crate) fn from_suffix(suffix: &str) -> Option<IntTy> { | ||
134 | match suffix { | ||
135 | "isize" => Some(IntTy::isize()), | ||
136 | "i8" => Some(IntTy::i8()), | ||
137 | "i16" => Some(IntTy::i16()), | ||
138 | "i32" => Some(IntTy::i32()), | ||
139 | "i64" => Some(IntTy::i64()), | ||
140 | "i128" => Some(IntTy::i128()), | ||
141 | "usize" => Some(IntTy::usize()), | ||
142 | "u8" => Some(IntTy::u8()), | ||
143 | "u16" => Some(IntTy::u16()), | ||
144 | "u32" => Some(IntTy::u32()), | ||
145 | "u64" => Some(IntTy::u64()), | ||
146 | "u128" => Some(IntTy::u128()), | ||
147 | _ => None, | ||
148 | } | ||
149 | } | ||
150 | } | 132 | } |
151 | 133 | ||
152 | #[derive(Copy, Clone, PartialEq, Eq, Hash)] | 134 | #[derive(Copy, Clone, PartialEq, Eq, Hash)] |
@@ -181,12 +163,4 @@ impl FloatTy { | |||
181 | FloatBitness::X64 => "f64", | 163 | FloatBitness::X64 => "f64", |
182 | } | 164 | } |
183 | } | 165 | } |
184 | |||
185 | pub(crate) fn from_suffix(suffix: &str) -> Option<FloatTy> { | ||
186 | match suffix { | ||
187 | "f32" => Some(FloatTy::f32()), | ||
188 | "f64" => Some(FloatTy::f64()), | ||
189 | _ => None, | ||
190 | } | ||
191 | } | ||
192 | } | 166 | } |
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs new file mode 100644 index 000000000..7447904ea --- /dev/null +++ b/crates/ra_hir_def/src/body.rs | |||
@@ -0,0 +1,2 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | mod lower; | ||
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs new file mode 100644 index 000000000..1a144b1f9 --- /dev/null +++ b/crates/ra_hir_def/src/body/lower.rs | |||
@@ -0,0 +1,49 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | |||
3 | use ra_syntax::ast; | ||
4 | |||
5 | use crate::expr::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering}; | ||
6 | |||
7 | impl From<ast::BinOp> for BinaryOp { | ||
8 | fn from(ast_op: ast::BinOp) -> Self { | ||
9 | match ast_op { | ||
10 | ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or), | ||
11 | ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And), | ||
12 | ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }), | ||
13 | ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }), | ||
14 | ast::BinOp::LesserEqualTest => { | ||
15 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false }) | ||
16 | } | ||
17 | ast::BinOp::GreaterEqualTest => { | ||
18 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false }) | ||
19 | } | ||
20 | ast::BinOp::LesserTest => { | ||
21 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true }) | ||
22 | } | ||
23 | ast::BinOp::GreaterTest => { | ||
24 | BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true }) | ||
25 | } | ||
26 | ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add), | ||
27 | ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul), | ||
28 | ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub), | ||
29 | ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div), | ||
30 | ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem), | ||
31 | ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl), | ||
32 | ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr), | ||
33 | ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor), | ||
34 | ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr), | ||
35 | ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd), | ||
36 | ast::BinOp::Assignment => BinaryOp::Assignment { op: None }, | ||
37 | ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) }, | ||
38 | ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) }, | ||
39 | ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) }, | ||
40 | ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) }, | ||
41 | ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) }, | ||
42 | ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) }, | ||
43 | ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) }, | ||
44 | ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) }, | ||
45 | ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) }, | ||
46 | ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) }, | ||
47 | } | ||
48 | } | ||
49 | } | ||
diff --git a/crates/ra_hir_def/src/builtin_type.rs b/crates/ra_hir_def/src/builtin_type.rs index 996e86fd9..5e8157144 100644 --- a/crates/ra_hir_def/src/builtin_type.rs +++ b/crates/ra_hir_def/src/builtin_type.rs | |||
@@ -56,22 +56,22 @@ impl BuiltinType { | |||
56 | (name::BOOL, BuiltinType::Bool), | 56 | (name::BOOL, BuiltinType::Bool), |
57 | (name::STR, BuiltinType::Str ), | 57 | (name::STR, BuiltinType::Str ), |
58 | 58 | ||
59 | (name::ISIZE, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::Xsize })), | 59 | (name::ISIZE, BuiltinType::Int(BuiltinInt::ISIZE)), |
60 | (name::I8, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X8 })), | 60 | (name::I8, BuiltinType::Int(BuiltinInt::I8)), |
61 | (name::I16, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X16 })), | 61 | (name::I16, BuiltinType::Int(BuiltinInt::I16)), |
62 | (name::I32, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X32 })), | 62 | (name::I32, BuiltinType::Int(BuiltinInt::I32)), |
63 | (name::I64, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X64 })), | 63 | (name::I64, BuiltinType::Int(BuiltinInt::I64)), |
64 | (name::I128, BuiltinType::Int(BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X128 })), | 64 | (name::I128, BuiltinType::Int(BuiltinInt::I128)), |
65 | 65 | ||
66 | (name::USIZE, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize })), | 66 | (name::USIZE, BuiltinType::Int(BuiltinInt::USIZE)), |
67 | (name::U8, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X8 })), | 67 | (name::U8, BuiltinType::Int(BuiltinInt::U8)), |
68 | (name::U16, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X16 })), | 68 | (name::U16, BuiltinType::Int(BuiltinInt::U16)), |
69 | (name::U32, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X32 })), | 69 | (name::U32, BuiltinType::Int(BuiltinInt::U32)), |
70 | (name::U64, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X64 })), | 70 | (name::U64, BuiltinType::Int(BuiltinInt::U64)), |
71 | (name::U128, BuiltinType::Int(BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X128 })), | 71 | (name::U128, BuiltinType::Int(BuiltinInt::U128)), |
72 | 72 | ||
73 | (name::F32, BuiltinType::Float(BuiltinFloat { bitness: FloatBitness::X32 })), | 73 | (name::F32, BuiltinType::Float(BuiltinFloat::F32)), |
74 | (name::F64, BuiltinType::Float(BuiltinFloat { bitness: FloatBitness::X64 })), | 74 | (name::F64, BuiltinType::Float(BuiltinFloat::F64)), |
75 | ]; | 75 | ]; |
76 | } | 76 | } |
77 | 77 | ||
@@ -104,3 +104,57 @@ impl fmt::Display for BuiltinType { | |||
104 | f.write_str(type_name) | 104 | f.write_str(type_name) |
105 | } | 105 | } |
106 | } | 106 | } |
107 | |||
108 | #[rustfmt::skip] | ||
109 | impl BuiltinInt { | ||
110 | pub const ISIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::Xsize }; | ||
111 | pub const I8 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X8 }; | ||
112 | pub const I16 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X16 }; | ||
113 | pub const I32 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X32 }; | ||
114 | pub const I64 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X64 }; | ||
115 | pub const I128 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X128 }; | ||
116 | |||
117 | pub const USIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize }; | ||
118 | pub const U8 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X8 }; | ||
119 | pub const U16 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X16 }; | ||
120 | pub const U32 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X32 }; | ||
121 | pub const U64 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X64 }; | ||
122 | pub const U128 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X128 }; | ||
123 | |||
124 | |||
125 | pub fn from_suffix(suffix: &str) -> Option<BuiltinInt> { | ||
126 | let res = match suffix { | ||
127 | "isize" => Self::ISIZE, | ||
128 | "i8" => Self::I8, | ||
129 | "i16" => Self::I16, | ||
130 | "i32" => Self::I32, | ||
131 | "i64" => Self::I64, | ||
132 | "i128" => Self::I128, | ||
133 | |||
134 | "usize" => Self::USIZE, | ||
135 | "u8" => Self::U8, | ||
136 | "u16" => Self::U16, | ||
137 | "u32" => Self::U32, | ||
138 | "u64" => Self::U64, | ||
139 | "u128" => Self::U128, | ||
140 | |||
141 | _ => return None, | ||
142 | }; | ||
143 | Some(res) | ||
144 | } | ||
145 | } | ||
146 | |||
147 | #[rustfmt::skip] | ||
148 | impl BuiltinFloat { | ||
149 | pub const F32: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X32 }; | ||
150 | pub const F64: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X64 }; | ||
151 | |||
152 | pub fn from_suffix(suffix: &str) -> Option<BuiltinFloat> { | ||
153 | let res = match suffix { | ||
154 | "f32" => BuiltinFloat::F32, | ||
155 | "f64" => BuiltinFloat::F64, | ||
156 | _ => return None, | ||
157 | }; | ||
158 | Some(res) | ||
159 | } | ||
160 | } | ||
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs new file mode 100644 index 000000000..12eb0da68 --- /dev/null +++ b/crates/ra_hir_def/src/expr.rs | |||
@@ -0,0 +1,419 @@ | |||
1 | //! This module describes hir-level representation of expressions. | ||
2 | //! | ||
3 | //! This representaion is: | ||
4 | //! | ||
5 | //! 1. Identity-based. Each expression has an `id`, so we can distinguish | ||
6 | //! between different `1` in `1 + 1`. | ||
7 | //! 2. Independent of syntax. Though syntactic provenance information can be | ||
8 | //! attached separately via id-based side map. | ||
9 | //! 3. Unresolved. Paths are stored as sequences of names, and not as defs the | ||
10 | //! names refer to. | ||
11 | //! 4. Desugared. There's no `if let`. | ||
12 | |||
13 | use hir_expand::name::Name; | ||
14 | use ra_arena::{impl_arena_id, RawId}; | ||
15 | |||
16 | use crate::{ | ||
17 | builtin_type::{BuiltinFloat, BuiltinInt}, | ||
18 | path::{GenericArgs, Path}, | ||
19 | type_ref::{Mutability, TypeRef}, | ||
20 | }; | ||
21 | |||
22 | #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] | ||
23 | pub struct ExprId(RawId); | ||
24 | impl_arena_id!(ExprId); | ||
25 | |||
26 | impl ExprId { | ||
27 | pub fn dummy() -> ExprId { | ||
28 | ExprId((!0).into()) | ||
29 | } | ||
30 | } | ||
31 | |||
32 | #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] | ||
33 | pub struct PatId(RawId); | ||
34 | impl_arena_id!(PatId); | ||
35 | |||
36 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
37 | pub enum Literal { | ||
38 | String(String), | ||
39 | ByteString(Vec<u8>), | ||
40 | Char(char), | ||
41 | Bool(bool), | ||
42 | Int(u64, Option<BuiltinInt>), | ||
43 | Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq | ||
44 | } | ||
45 | |||
46 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
47 | pub enum Expr { | ||
48 | /// This is produced if syntax tree does not have a required expression piece. | ||
49 | Missing, | ||
50 | Path(Path), | ||
51 | If { | ||
52 | condition: ExprId, | ||
53 | then_branch: ExprId, | ||
54 | else_branch: Option<ExprId>, | ||
55 | }, | ||
56 | Block { | ||
57 | statements: Vec<Statement>, | ||
58 | tail: Option<ExprId>, | ||
59 | }, | ||
60 | Loop { | ||
61 | body: ExprId, | ||
62 | }, | ||
63 | While { | ||
64 | condition: ExprId, | ||
65 | body: ExprId, | ||
66 | }, | ||
67 | For { | ||
68 | iterable: ExprId, | ||
69 | pat: PatId, | ||
70 | body: ExprId, | ||
71 | }, | ||
72 | Call { | ||
73 | callee: ExprId, | ||
74 | args: Vec<ExprId>, | ||
75 | }, | ||
76 | MethodCall { | ||
77 | receiver: ExprId, | ||
78 | method_name: Name, | ||
79 | args: Vec<ExprId>, | ||
80 | generic_args: Option<GenericArgs>, | ||
81 | }, | ||
82 | Match { | ||
83 | expr: ExprId, | ||
84 | arms: Vec<MatchArm>, | ||
85 | }, | ||
86 | Continue, | ||
87 | Break { | ||
88 | expr: Option<ExprId>, | ||
89 | }, | ||
90 | Return { | ||
91 | expr: Option<ExprId>, | ||
92 | }, | ||
93 | RecordLit { | ||
94 | path: Option<Path>, | ||
95 | fields: Vec<RecordLitField>, | ||
96 | spread: Option<ExprId>, | ||
97 | }, | ||
98 | Field { | ||
99 | expr: ExprId, | ||
100 | name: Name, | ||
101 | }, | ||
102 | Await { | ||
103 | expr: ExprId, | ||
104 | }, | ||
105 | Try { | ||
106 | expr: ExprId, | ||
107 | }, | ||
108 | TryBlock { | ||
109 | body: ExprId, | ||
110 | }, | ||
111 | Cast { | ||
112 | expr: ExprId, | ||
113 | type_ref: TypeRef, | ||
114 | }, | ||
115 | Ref { | ||
116 | expr: ExprId, | ||
117 | mutability: Mutability, | ||
118 | }, | ||
119 | Box { | ||
120 | expr: ExprId, | ||
121 | }, | ||
122 | UnaryOp { | ||
123 | expr: ExprId, | ||
124 | op: UnaryOp, | ||
125 | }, | ||
126 | BinaryOp { | ||
127 | lhs: ExprId, | ||
128 | rhs: ExprId, | ||
129 | op: Option<BinaryOp>, | ||
130 | }, | ||
131 | Index { | ||
132 | base: ExprId, | ||
133 | index: ExprId, | ||
134 | }, | ||
135 | Lambda { | ||
136 | args: Vec<PatId>, | ||
137 | arg_types: Vec<Option<TypeRef>>, | ||
138 | body: ExprId, | ||
139 | }, | ||
140 | Tuple { | ||
141 | exprs: Vec<ExprId>, | ||
142 | }, | ||
143 | Array(Array), | ||
144 | Literal(Literal), | ||
145 | } | ||
146 | |||
147 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
148 | pub enum BinaryOp { | ||
149 | LogicOp(LogicOp), | ||
150 | ArithOp(ArithOp), | ||
151 | CmpOp(CmpOp), | ||
152 | Assignment { op: Option<ArithOp> }, | ||
153 | } | ||
154 | |||
155 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
156 | pub enum LogicOp { | ||
157 | And, | ||
158 | Or, | ||
159 | } | ||
160 | |||
161 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
162 | pub enum CmpOp { | ||
163 | Eq { negated: bool }, | ||
164 | Ord { ordering: Ordering, strict: bool }, | ||
165 | } | ||
166 | |||
167 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
168 | pub enum Ordering { | ||
169 | Less, | ||
170 | Greater, | ||
171 | } | ||
172 | |||
173 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] | ||
174 | pub enum ArithOp { | ||
175 | Add, | ||
176 | Mul, | ||
177 | Sub, | ||
178 | Div, | ||
179 | Rem, | ||
180 | Shl, | ||
181 | Shr, | ||
182 | BitXor, | ||
183 | BitOr, | ||
184 | BitAnd, | ||
185 | } | ||
186 | |||
187 | pub use ra_syntax::ast::PrefixOp as UnaryOp; | ||
188 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
189 | pub enum Array { | ||
190 | ElementList(Vec<ExprId>), | ||
191 | Repeat { initializer: ExprId, repeat: ExprId }, | ||
192 | } | ||
193 | |||
194 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
195 | pub struct MatchArm { | ||
196 | pub pats: Vec<PatId>, | ||
197 | pub guard: Option<ExprId>, | ||
198 | pub expr: ExprId, | ||
199 | } | ||
200 | |||
201 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
202 | pub struct RecordLitField { | ||
203 | pub name: Name, | ||
204 | pub expr: ExprId, | ||
205 | } | ||
206 | |||
207 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
208 | pub enum Statement { | ||
209 | Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> }, | ||
210 | Expr(ExprId), | ||
211 | } | ||
212 | |||
213 | impl Expr { | ||
214 | pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) { | ||
215 | match self { | ||
216 | Expr::Missing => {} | ||
217 | Expr::Path(_) => {} | ||
218 | Expr::If { condition, then_branch, else_branch } => { | ||
219 | f(*condition); | ||
220 | f(*then_branch); | ||
221 | if let Some(else_branch) = else_branch { | ||
222 | f(*else_branch); | ||
223 | } | ||
224 | } | ||
225 | Expr::Block { statements, tail } => { | ||
226 | for stmt in statements { | ||
227 | match stmt { | ||
228 | Statement::Let { initializer, .. } => { | ||
229 | if let Some(expr) = initializer { | ||
230 | f(*expr); | ||
231 | } | ||
232 | } | ||
233 | Statement::Expr(e) => f(*e), | ||
234 | } | ||
235 | } | ||
236 | if let Some(expr) = tail { | ||
237 | f(*expr); | ||
238 | } | ||
239 | } | ||
240 | Expr::TryBlock { body } => f(*body), | ||
241 | Expr::Loop { body } => f(*body), | ||
242 | Expr::While { condition, body } => { | ||
243 | f(*condition); | ||
244 | f(*body); | ||
245 | } | ||
246 | Expr::For { iterable, body, .. } => { | ||
247 | f(*iterable); | ||
248 | f(*body); | ||
249 | } | ||
250 | Expr::Call { callee, args } => { | ||
251 | f(*callee); | ||
252 | for arg in args { | ||
253 | f(*arg); | ||
254 | } | ||
255 | } | ||
256 | Expr::MethodCall { receiver, args, .. } => { | ||
257 | f(*receiver); | ||
258 | for arg in args { | ||
259 | f(*arg); | ||
260 | } | ||
261 | } | ||
262 | Expr::Match { expr, arms } => { | ||
263 | f(*expr); | ||
264 | for arm in arms { | ||
265 | f(arm.expr); | ||
266 | } | ||
267 | } | ||
268 | Expr::Continue => {} | ||
269 | Expr::Break { expr } | Expr::Return { expr } => { | ||
270 | if let Some(expr) = expr { | ||
271 | f(*expr); | ||
272 | } | ||
273 | } | ||
274 | Expr::RecordLit { fields, spread, .. } => { | ||
275 | for field in fields { | ||
276 | f(field.expr); | ||
277 | } | ||
278 | if let Some(expr) = spread { | ||
279 | f(*expr); | ||
280 | } | ||
281 | } | ||
282 | Expr::Lambda { body, .. } => { | ||
283 | f(*body); | ||
284 | } | ||
285 | Expr::BinaryOp { lhs, rhs, .. } => { | ||
286 | f(*lhs); | ||
287 | f(*rhs); | ||
288 | } | ||
289 | Expr::Index { base, index } => { | ||
290 | f(*base); | ||
291 | f(*index); | ||
292 | } | ||
293 | Expr::Field { expr, .. } | ||
294 | | Expr::Await { expr } | ||
295 | | Expr::Try { expr } | ||
296 | | Expr::Cast { expr, .. } | ||
297 | | Expr::Ref { expr, .. } | ||
298 | | Expr::UnaryOp { expr, .. } | ||
299 | | Expr::Box { expr } => { | ||
300 | f(*expr); | ||
301 | } | ||
302 | Expr::Tuple { exprs } => { | ||
303 | for expr in exprs { | ||
304 | f(*expr); | ||
305 | } | ||
306 | } | ||
307 | Expr::Array(a) => match a { | ||
308 | Array::ElementList(exprs) => { | ||
309 | for expr in exprs { | ||
310 | f(*expr); | ||
311 | } | ||
312 | } | ||
313 | Array::Repeat { initializer, repeat } => { | ||
314 | f(*initializer); | ||
315 | f(*repeat) | ||
316 | } | ||
317 | }, | ||
318 | Expr::Literal(_) => {} | ||
319 | } | ||
320 | } | ||
321 | } | ||
322 | |||
323 | /// Explicit binding annotations given in the HIR for a binding. Note | ||
324 | /// that this is not the final binding *mode* that we infer after type | ||
325 | /// inference. | ||
326 | #[derive(Clone, PartialEq, Eq, Debug, Copy)] | ||
327 | pub enum BindingAnnotation { | ||
328 | /// No binding annotation given: this means that the final binding mode | ||
329 | /// will depend on whether we have skipped through a `&` reference | ||
330 | /// when matching. For example, the `x` in `Some(x)` will have binding | ||
331 | /// mode `None`; if you do `let Some(x) = &Some(22)`, it will | ||
332 | /// ultimately be inferred to be by-reference. | ||
333 | Unannotated, | ||
334 | |||
335 | /// Annotated with `mut x` -- could be either ref or not, similar to `None`. | ||
336 | Mutable, | ||
337 | |||
338 | /// Annotated as `ref`, like `ref x` | ||
339 | Ref, | ||
340 | |||
341 | /// Annotated as `ref mut x`. | ||
342 | RefMut, | ||
343 | } | ||
344 | |||
345 | impl BindingAnnotation { | ||
346 | pub fn new(is_mutable: bool, is_ref: bool) -> Self { | ||
347 | match (is_mutable, is_ref) { | ||
348 | (true, true) => BindingAnnotation::RefMut, | ||
349 | (false, true) => BindingAnnotation::Ref, | ||
350 | (true, false) => BindingAnnotation::Mutable, | ||
351 | (false, false) => BindingAnnotation::Unannotated, | ||
352 | } | ||
353 | } | ||
354 | } | ||
355 | |||
356 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
357 | pub struct RecordFieldPat { | ||
358 | pub name: Name, | ||
359 | pub pat: PatId, | ||
360 | } | ||
361 | |||
362 | /// Close relative to rustc's hir::PatKind | ||
363 | #[derive(Debug, Clone, Eq, PartialEq)] | ||
364 | pub enum Pat { | ||
365 | Missing, | ||
366 | Wild, | ||
367 | Tuple(Vec<PatId>), | ||
368 | Record { | ||
369 | path: Option<Path>, | ||
370 | args: Vec<RecordFieldPat>, | ||
371 | // FIXME: 'ellipsis' option | ||
372 | }, | ||
373 | Range { | ||
374 | start: ExprId, | ||
375 | end: ExprId, | ||
376 | }, | ||
377 | Slice { | ||
378 | prefix: Vec<PatId>, | ||
379 | rest: Option<PatId>, | ||
380 | suffix: Vec<PatId>, | ||
381 | }, | ||
382 | Path(Path), | ||
383 | Lit(ExprId), | ||
384 | Bind { | ||
385 | mode: BindingAnnotation, | ||
386 | name: Name, | ||
387 | subpat: Option<PatId>, | ||
388 | }, | ||
389 | TupleStruct { | ||
390 | path: Option<Path>, | ||
391 | args: Vec<PatId>, | ||
392 | }, | ||
393 | Ref { | ||
394 | pat: PatId, | ||
395 | mutability: Mutability, | ||
396 | }, | ||
397 | } | ||
398 | |||
399 | impl Pat { | ||
400 | pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) { | ||
401 | match self { | ||
402 | Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {} | ||
403 | Pat::Bind { subpat, .. } => { | ||
404 | subpat.iter().copied().for_each(f); | ||
405 | } | ||
406 | Pat::Tuple(args) | Pat::TupleStruct { args, .. } => { | ||
407 | args.iter().copied().for_each(f); | ||
408 | } | ||
409 | Pat::Ref { pat, .. } => f(*pat), | ||
410 | Pat::Slice { prefix, rest, suffix } => { | ||
411 | let total_iter = prefix.iter().chain(rest.iter()).chain(suffix.iter()); | ||
412 | total_iter.copied().for_each(f); | ||
413 | } | ||
414 | Pat::Record { args, .. } => { | ||
415 | args.iter().map(|f| f.pat).for_each(f); | ||
416 | } | ||
417 | } | ||
418 | } | ||
419 | } | ||
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 239317efe..4a758bb83 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs | |||
@@ -14,6 +14,8 @@ pub mod type_ref; | |||
14 | pub mod builtin_type; | 14 | pub mod builtin_type; |
15 | pub mod adt; | 15 | pub mod adt; |
16 | pub mod diagnostics; | 16 | pub mod diagnostics; |
17 | pub mod expr; | ||
18 | pub mod body; | ||
17 | 19 | ||
18 | #[cfg(test)] | 20 | #[cfg(test)] |
19 | mod test_db; | 21 | mod test_db; |