1 files changed, 65 insertions, 15 deletions
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index f0936e9f3..663338844 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -4,10 +4,11 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
-use ra_db::{LocalSyntaxPtr, Cancelable};
+use ra_db::LocalSyntaxPtr;
-use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner, NameOwner};
+use ra_syntax::ast::{self, AstNode, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor};
 use crate::{Path, type_ref::{Mutability, TypeRef}, Name, HirDatabase, DefId, Def, name::AsName};
+use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
@@ -104,6 +105,16 @@ impl BodySyntaxMapping {
 }
 #[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Literal {
+    String(String),
+    ByteString(Vec<u8>),
+    Char(char),
+    Bool(bool),
+    Int(u64, UncertainIntTy),
+    Float(u64, UncertainFloatTy), // FIXME: f64 is not Eq
+}
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Expr {
    /// This is produced if syntax tree does not have a required expression piece.
    Missing,
@@ -171,7 +182,7 @@ pub enum Expr {
    },
    UnaryOp {
        expr: ExprId,
-        op: Option<UnaryOp>,
+        op: UnaryOp,
    },
    BinaryOp {
        lhs: ExprId,
@@ -186,6 +197,7 @@ pub enum Expr {
    Tuple {
        exprs: Vec<ExprId>,
    },
+    Literal(Literal),
 }
 pub use ra_syntax::ast::PrefixOp as UnaryOp;
@@ -305,6 +317,7 @@ impl Expr {
                    f(*expr);
                }
            }
+            Expr::Literal(_) => {}
        }
    }
 }
@@ -343,8 +356,8 @@ impl Pat {
 // Queries
-pub(crate) fn body_hir(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<Body>> {
+pub(crate) fn body_hir(db: &impl HirDatabase, def_id: DefId) -> Arc<Body> {
-    Ok(Arc::clone(&body_syntax_mapping(db, def_id)?.body))
+    Arc::clone(&body_syntax_mapping(db, def_id).body)
 }
 struct ExprCollector {
@@ -599,8 +612,11 @@ impl ExprCollector {
            }
            ast::ExprKind::PrefixExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
-                let op = e.op();
+                if let Some(op) = e.op() {
-                self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                    self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                } else {
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                }
            }
            ast::ExprKind::LambdaExpr(e) => {
                let mut args = Vec::new();
@@ -633,13 +649,50 @@ impl ExprCollector {
                let exprs = e.exprs().map(|expr| self.collect_expr(expr)).collect();
                self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
            }
+            ast::ExprKind::Literal(e) => {
+                let child = if let Some(child) = e.literal_expr() {
+                    child
+                } else {
+                    return self.alloc_expr(Expr::Missing, syntax_ptr);
+                };
+                let lit = match child.flavor() {
+                    LiteralFlavor::IntNumber { suffix } => {
+                        let known_name = suffix
+                            .map(|s| Name::new(s))
+                            .and_then(|name| UncertainIntTy::from_name(&name));
+                        Literal::Int(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainIntTy::Unknown),
+                        )
+                    }
+                    LiteralFlavor::FloatNumber { suffix } => {
+                        let known_name = suffix
+                            .map(|s| Name::new(s))
+                            .and_then(|name| UncertainFloatTy::from_name(&name));
+                        Literal::Float(
+                            Default::default(),
+                            known_name.unwrap_or(UncertainFloatTy::Unknown),
+                        )
+                    }
+                    LiteralFlavor::ByteString => Literal::ByteString(Default::default()),
+                    LiteralFlavor::String => Literal::String(Default::default()),
+                    LiteralFlavor::Byte => {
+                        Literal::Int(Default::default(), UncertainIntTy::Unsigned(UintTy::U8))
+                    }
+                    LiteralFlavor::Bool => Literal::Bool(Default::default()),
+                    LiteralFlavor::Char => Literal::Char(Default::default()),
+                };
+                self.alloc_expr(Expr::Literal(lit), syntax_ptr)
+            }
            // TODO implement HIR for these:
            ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::ExprKind::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::ExprKind::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::ExprKind::Literal(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
        }
    }
@@ -776,17 +829,14 @@ pub(crate) fn collect_fn_body_syntax(node: &ast::FnDef) -> BodySyntaxMapping {
    collector.into_body_syntax_mapping(params, body)
 }
-pub(crate) fn body_syntax_mapping(
+pub(crate) fn body_syntax_mapping(db: &impl HirDatabase, def_id: DefId) -> Arc<BodySyntaxMapping> {
-    db: &impl HirDatabase,
+    let def = def_id.resolve(db);
-    def_id: DefId,
-) -> Cancelable<Arc<BodySyntaxMapping>> {
-    let def = def_id.resolve(db)?;
    let body_syntax_mapping = match def {
-        Def::Function(f) => collect_fn_body_syntax(&f.source(db)?.1),
+        Def::Function(f) => collect_fn_body_syntax(&f.source(db).1),
        // TODO: consts, etc.
        _ => panic!("Trying to get body for item type without body"),
    };
-    Ok(Arc::new(body_syntax_mapping))
+    Arc::new(body_syntax_mapping)
 }