5 files changed, 293 insertions, 0 deletions

diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
new file mode 100644
index 000000000..ad79b17e4
--- /dev/null
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -0,0 +1,130 @@
+use std::fmt;
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
+pub enum IntTy {
+    Isize,
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+}
+
+impl fmt::Debug for IntTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for IntTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.ty_to_string())
+    }
+}
+
+impl IntTy {
+    pub fn ty_to_string(&self) -> &'static str {
+        match *self {
+            IntTy::Isize => "isize",
+            IntTy::I8 => "i8",
+            IntTy::I16 => "i16",
+            IntTy::I32 => "i32",
+            IntTy::I64 => "i64",
+            IntTy::I128 => "i128",
+        }
+    }
+
+    pub fn from_string(s: &str) -> Option<IntTy> {
+        match s {
+            "isize" => Some(IntTy::Isize),
+            "i8" => Some(IntTy::I8),
+            "i16" => Some(IntTy::I16),
+            "i32" => Some(IntTy::I32),
+            "i64" => Some(IntTy::I64),
+            "i128" => Some(IntTy::I128),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
+pub enum UintTy {
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+}
+
+impl UintTy {
+    pub fn ty_to_string(&self) -> &'static str {
+        match *self {
+            UintTy::Usize => "usize",
+            UintTy::U8 => "u8",
+            UintTy::U16 => "u16",
+            UintTy::U32 => "u32",
+            UintTy::U64 => "u64",
+            UintTy::U128 => "u128",
+        }
+    }
+
+    pub fn from_string(s: &str) -> Option<UintTy> {
+        match s {
+            "usize" => Some(UintTy::Usize),
+            "u8" => Some(UintTy::U8),
+            "u16" => Some(UintTy::U16),
+            "u32" => Some(UintTy::U32),
+            "u64" => Some(UintTy::U64),
+            "u128" => Some(UintTy::U128),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Debug for UintTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for UintTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.ty_to_string())
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash, Copy, PartialOrd, Ord)]
+pub enum FloatTy {
+    F32,
+    F64,
+}
+
+impl fmt::Debug for FloatTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for FloatTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.ty_to_string())
+    }
+}
+
+impl FloatTy {
+    pub fn ty_to_string(self) -> &'static str {
+        match self {
+            FloatTy::F32 => "f32",
+            FloatTy::F64 => "f64",
+        }
+    }
+
+    pub fn from_string(s: &str) -> Option<FloatTy> {
+        match s {
+            "f32" => Some(FloatTy::F32),
+            "f64" => Some(FloatTy::F64),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
new file mode 100644
index 000000000..b6c02cd80
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -0,0 +1,134 @@
+use std::fmt::Write;
+use std::path::{PathBuf, Path};
+use std::fs;
+
+use ra_db::{SyntaxDatabase};
+use ra_syntax::ast::{self, AstNode};
+use test_utils::{project_dir, assert_eq_text, read_text};
+
+use crate::{
+    source_binder,
+    mock::MockDatabase,
+};
+
+// These tests compare the inference results for all expressions in a file
+// against snapshots of the current results. If you change something and these
+// tests fail expectedly, you can update the comparison files by deleting them
+// and running the tests again. Similarly, to add a new test, just write the
+// test here in the same pattern and it will automatically write the snapshot.
+
+#[test]
+fn infer_basics() {
+    check_inference(
+        r#"
+fn test(a: u32, b: isize, c: !, d: &str) {
+    a;
+    b;
+    c;
+    d;
+    1usize;
+    1isize;
+    "test";
+    1.0f32;
+}"#,
+        "0001_basics.txt",
+    );
+}
+
+#[test]
+fn infer_let() {
+    check_inference(
+        r#"
+fn test() {
+    let a = 1isize;
+    let b: usize = 1;
+    let c = b;
+}
+}"#,
+        "0002_let.txt",
+    );
+}
+
+#[test]
+fn infer_paths() {
+    check_inference(
+        r#"
+fn a() -> u32 { 1 }
+
+mod b {
+    fn c() -> u32 { 1 }
+}
+
+fn test() {
+    a();
+    b::c();
+}
+}"#,
+        "0003_paths.txt",
+    );
+}
+
+fn infer(content: &str) -> String {
+    let (db, _, file_id) = MockDatabase::with_single_file(content);
+    let source_file = db.source_file(file_id);
+    let mut acc = String::new();
+    for fn_def in source_file
+        .syntax()
+        .descendants()
+        .filter_map(ast::FnDef::cast)
+    {
+        let func = source_binder::function_from_source(&db, file_id, fn_def)
+            .unwrap()
+            .unwrap();
+        let inference_result = func.infer(&db).unwrap();
+        for (syntax_ptr, ty) in &inference_result.type_of {
+            let node = syntax_ptr.resolve(&source_file);
+            write!(
+                acc,
+                "{} '{}': {}\n",
+                syntax_ptr.range(),
+                ellipsize(node.text().to_string().replace("\n", " "), 15),
+                ty
+            )
+            .unwrap();
+        }
+    }
+    acc
+}
+
+fn check_inference(content: &str, data_file: impl AsRef<Path>) {
+    let data_file_path = test_data_dir().join(data_file);
+    let result = infer(content);
+
+    if !data_file_path.exists() {
+        println!("File with expected result doesn't exist, creating...\n");
+        println!("{}\n{}", content, result);
+        fs::write(&data_file_path, &result).unwrap();
+        panic!("File {:?} with expected result was created", data_file_path);
+    }
+
+    let expected = read_text(&data_file_path);
+    assert_eq_text!(&expected, &result);
+}
+
+fn ellipsize(mut text: String, max_len: usize) -> String {
+    if text.len() <= max_len {
+        return text;
+    }
+    let ellipsis = "...";
+    let e_len = ellipsis.len();
+    let mut prefix_len = (max_len - e_len) / 2;
+    while !text.is_char_boundary(prefix_len) {
+        prefix_len += 1;
+    }
+    let mut suffix_len = max_len - e_len - prefix_len;
+    while !text.is_char_boundary(text.len() - suffix_len) {
+        suffix_len += 1;
+    }
+    text.replace_range(prefix_len..text.len() - suffix_len, ellipsis);
+    text
+}
+
+fn test_data_dir() -> PathBuf {
+    project_dir().join("crates/ra_hir/src/ty/tests/data")
+}
diff --git a/crates/ra_hir/src/ty/tests/data/0001_basics.txt b/crates/ra_hir/src/ty/tests/data/0001_basics.txt
new file mode 100644
index 000000000..0c46f243a
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/0001_basics.txt
@@ -0,0 +1,13 @@
+[33; 34) 'd': [unknown]
+[88; 94) '1isize': [unknown]
+[48; 49) 'a': u32
+[55; 56) 'b': isize
+[112; 118) '1.0f32': [unknown]
+[76; 82) '1usize': [unknown]
+[9; 10) 'a': u32
+[27; 28) 'c': !
+[62; 63) 'c': !
+[17; 18) 'b': isize
+[100; 106) '"test"': [unknown]
+[42; 121) '{     ...f32; }': ()
+[69; 70) 'd': [unknown]
diff --git a/crates/ra_hir/src/ty/tests/data/0002_let.txt b/crates/ra_hir/src/ty/tests/data/0002_let.txt
new file mode 100644
index 000000000..2d0d1f57b
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/0002_let.txt
@@ -0,0 +1,7 @@
+[21; 22) 'a': [unknown]
+[52; 53) '1': [unknown]
+[11; 71) '{     ...= b; }': ()
+[63; 64) 'c': usize
+[25; 31) '1isize': [unknown]
+[41; 42) 'b': usize
+[67; 68) 'b': usize
diff --git a/crates/ra_hir/src/ty/tests/data/0003_paths.txt b/crates/ra_hir/src/ty/tests/data/0003_paths.txt
new file mode 100644
index 000000000..dcb5456ae
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/0003_paths.txt
@@ -0,0 +1,9 @@
+[15; 20) '{ 1 }': [unknown]
+[17; 18) '1': [unknown]
+[50; 51) '1': [unknown]
+[48; 53) '{ 1 }': [unknown]
+[82; 88) 'b::c()': u32
+[67; 91) '{     ...c(); }': ()
+[73; 74) 'a': fn() -> u32
+[73; 76) 'a()': u32
+[82; 86) 'b::c': fn() -> u32