7 files changed, 144 insertions, 49 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 89fc1d1a1..66a58efed 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -318,8 +318,8 @@ pub struct StructField {
 
 #[derive(Debug)]
 pub enum FieldSource {
-    Named(ast::NamedFieldDef),
-    Pos(ast::PosFieldDef),
+    Named(ast::RecordFieldDef),
+    Pos(ast::TupleFieldDef),
 }
 
 impl StructField {
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index f6240830f..475dd5766 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -79,7 +79,7 @@ impl<'a> DiagnosticSink<'a> {
 #[derive(Debug)]
 pub struct NoSuchField {
     pub file: HirFileId,
-    pub field: AstPtr<ast::NamedField>,
+    pub field: AstPtr<ast::RecordField>,
 }
 
 impl Diagnostic for NoSuchField {
@@ -118,7 +118,7 @@ impl Diagnostic for UnresolvedModule {
 #[derive(Debug)]
 pub struct MissingFields {
     pub file: HirFileId,
-    pub field_list: AstPtr<ast::NamedFieldList>,
+    pub field_list: AstPtr<ast::RecordFieldList>,
     pub missed_fields: Vec<Name>,
 }
 
@@ -135,11 +135,39 @@ impl Diagnostic for MissingFields {
 }
 
 impl AstDiagnostic for MissingFields {
-    type AST = ast::NamedFieldList;
+    type AST = ast::RecordFieldList;
 
     fn ast(&self, db: &impl HirDatabase) -> Self::AST {
         let root = db.parse_or_expand(self.source().file_id).unwrap();
         let node = self.source().ast.to_node(&root);
-        ast::NamedFieldList::cast(node).unwrap()
+        ast::RecordFieldList::cast(node).unwrap()
+    }
+}
+
+#[derive(Debug)]
+pub struct MissingOkInTailExpr {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for MissingOkInTailExpr {
+    fn message(&self) -> String {
+        "wrap return expression in Ok".to_string()
+    }
+    fn source(&self) -> Source<SyntaxNodePtr> {
+        Source { file_id: self.file, ast: self.expr.into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+impl AstDiagnostic for MissingOkInTailExpr {
+    type AST = ast::Expr;
+
+    fn ast(&self, db: &impl HirDatabase) -> Self::AST {
+        let root = db.parse_or_expand(self.file).unwrap();
+        let node = self.source().ast.to_node(&root);
+        ast::Expr::cast(node).unwrap()
     }
 }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 328d635d4..7cdc7555c 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -60,7 +60,7 @@ pub struct BodySourceMap {
     expr_map_back: ArenaMap<ExprId, SyntaxNodePtr>,
     pat_map: FxHashMap<PatPtr, PatId>,
     pat_map_back: ArenaMap<PatId, PatPtr>,
-    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::NamedField>>,
+    field_map: FxHashMap<(ExprId, usize), AstPtr<ast::RecordField>>,
 }
 
 type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
@@ -148,7 +148,7 @@ impl BodySourceMap {
         self.pat_map.get(&Either::A(AstPtr::new(node))).cloned()
     }
 
-    pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::NamedField> {
+    pub(crate) fn field_syntax(&self, expr: ExprId, field: usize) -> AstPtr<ast::RecordField> {
         self.field_map[&(expr, field)]
     }
 }
@@ -210,9 +210,9 @@ pub enum Expr {
     Return {
         expr: Option<ExprId>,
     },
-    StructLit {
+    RecordLit {
         path: Option<Path>,
-        fields: Vec<StructLitField>,
+        fields: Vec<RecordLitField>,
         spread: Option<ExprId>,
     },
     Field {
@@ -316,7 +316,7 @@ pub struct MatchArm {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct StructLitField {
+pub struct RecordLitField {
     pub name: Name,
     pub expr: ExprId,
 }
@@ -388,7 +388,7 @@ impl Expr {
                     f(*expr);
                 }
             }
-            Expr::StructLit { fields, spread, .. } => {
+            Expr::RecordLit { fields, spread, .. } => {
                 for field in fields {
                     f(field.expr);
                 }
@@ -474,7 +474,7 @@ impl BindingAnnotation {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct FieldPat {
+pub struct RecordFieldPat {
     pub(crate) name: Name,
     pub(crate) pat: PatId,
 }
@@ -487,7 +487,7 @@ pub enum Pat {
     Tuple(Vec<PatId>),
     Struct {
         path: Option<Path>,
-        args: Vec<FieldPat>,
+        args: Vec<RecordFieldPat>,
         // FIXME: 'ellipsis' option
     },
     Range {
@@ -746,14 +746,14 @@ where
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Return { expr }, syntax_ptr)
             }
-            ast::Expr::StructLit(e) => {
+            ast::Expr::RecordLit(e) => {
                 let path = e.path().and_then(Path::from_ast);
                 let mut field_ptrs = Vec::new();
-                let struct_lit = if let Some(nfl) = e.named_field_list() {
+                let record_lit = if let Some(nfl) = e.record_field_list() {
                     let fields = nfl
                         .fields()
                         .inspect(|field| field_ptrs.push(AstPtr::new(field)))
-                        .map(|field| StructLitField {
+                        .map(|field| RecordLitField {
                             name: field
                                 .name_ref()
                                 .map(|nr| nr.as_name())
@@ -776,12 +776,12 @@ where
                         })
                         .collect();
                     let spread = nfl.spread().map(|s| self.collect_expr(s));
-                    Expr::StructLit { path, fields, spread }
+                    Expr::RecordLit { path, fields, spread }
                 } else {
-                    Expr::StructLit { path, fields: Vec::new(), spread: None }
+                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
                 };
 
-                let res = self.alloc_expr(struct_lit, syntax_ptr);
+                let res = self.alloc_expr(record_lit, syntax_ptr);
                 for (i, ptr) in field_ptrs.into_iter().enumerate() {
                     self.source_map.field_map.insert((res, i), ptr);
                 }
@@ -994,25 +994,25 @@ where
                 Pat::Tuple(args)
             }
             ast::Pat::PlaceholderPat(_) => Pat::Wild,
-            ast::Pat::StructPat(p) => {
+            ast::Pat::RecordPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
-                let field_pat_list =
-                    p.field_pat_list().expect("every struct should have a field list");
-                let mut fields: Vec<_> = field_pat_list
+                let record_field_pat_list =
+                    p.record_field_pat_list().expect("every struct should have a field list");
+                let mut fields: Vec<_> = record_field_pat_list
                     .bind_pats()
                     .filter_map(|bind_pat| {
                         let ast_pat =
                             ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat");
                         let pat = self.collect_pat(ast_pat);
                         let name = bind_pat.name()?.as_name();
-                        Some(FieldPat { name, pat })
+                        Some(RecordFieldPat { name, pat })
                     })
                     .collect();
-                let iter = field_pat_list.field_pats().filter_map(|f| {
+                let iter = record_field_pat_list.record_field_pats().filter_map(|f| {
                     let ast_pat = f.pat()?;
                     let pat = self.collect_pat(ast_pat);
                     let name = f.name()?.as_name();
-                    Some(FieldPat { name, pat })
+                    Some(RecordFieldPat { name, pat })
                 });
                 fields.extend(iter);
 
@@ -1020,6 +1020,7 @@ where
             }
 
             // FIXME: implement
+            ast::Pat::BoxPat(_) => Pat::Missing,
             ast::Pat::LiteralPat(_) => Pat::Missing,
             ast::Pat::SlicePat(_) | ast::Pat::RangePat(_) => Pat::Missing,
         };
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index 82a06ca25..5d9d59ff8 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -1,16 +1,19 @@
 use rustc_hash::FxHashSet;
 use std::sync::Arc;
 
-use ra_syntax::ast::{AstNode, StructLit};
+use ra_syntax::ast::{AstNode, RecordLit};
 
-use super::{Expr, ExprId, StructLitField};
+use super::{Expr, ExprId, RecordLitField};
 use crate::{
     adt::AdtDef,
-    diagnostics::{DiagnosticSink, MissingFields},
+    diagnostics::{DiagnosticSink, MissingFields, MissingOkInTailExpr},
     expr::AstPtr,
-    ty::InferenceResult,
-    Function, HasSource, HirDatabase, Name, Path,
+    name,
+    path::{PathKind, PathSegment},
+    ty::{ApplicationTy, InferenceResult, Ty, TypeCtor},
+    Function, HasSource, HirDatabase, ModuleDef, Name, Path, PerNs, Resolution,
 };
+use ra_syntax::ast;
 
 pub(crate) struct ExprValidator<'a, 'b: 'a> {
     func: Function,
@@ -29,18 +32,24 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
 
     pub(crate) fn validate_body(&mut self, db: &impl HirDatabase) {
         let body = self.func.body(db);
+
         for e in body.exprs() {
-            if let (id, Expr::StructLit { path, fields, spread }) = e {
-                self.validate_struct_literal(id, path, fields, *spread, db);
+            if let (id, Expr::RecordLit { path, fields, spread }) = e {
+                self.validate_record_literal(id, path, fields, *spread, db);
             }
         }
+
+        let body_expr = &body[body.body_expr()];
+        if let Expr::Block { statements: _, tail: Some(t) } = body_expr {
+            self.validate_results_in_tail_expr(*t, db);
+        }
     }
 
-    fn validate_struct_literal(
+    fn validate_record_literal(
         &mut self,
         id: ExprId,
         _path: &Option<Path>,
-        fields: &[StructLitField],
+        fields: &[RecordLitField],
         spread: Option<ExprId>,
         db: &impl HirDatabase,
     ) {
@@ -76,8 +85,8 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         if let Some(field_list_node) = source_map
             .expr_syntax(id)
             .map(|ptr| ptr.to_node(source_file.syntax()))
-            .and_then(StructLit::cast)
-            .and_then(|lit| lit.named_field_list())
+            .and_then(RecordLit::cast)
+            .and_then(|lit| lit.record_field_list())
         {
             let field_list_ptr = AstPtr::new(&field_list_node);
             self.sink.push(MissingFields {
@@ -87,4 +96,42 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             })
         }
     }
+
+    fn validate_results_in_tail_expr(&mut self, id: ExprId, db: &impl HirDatabase) {
+        let mismatch = match self.infer.type_mismatch_for_expr(id) {
+            Some(m) => m,
+            None => return,
+        };
+
+        let std_result_path = Path {
+            kind: PathKind::Abs,
+            segments: vec![
+                PathSegment { name: name::STD, args_and_bindings: None },
+                PathSegment { name: name::RESULT_MOD, args_and_bindings: None },
+                PathSegment { name: name::RESULT_TYPE, args_and_bindings: None },
+            ],
+        };
+
+        let resolver = self.func.resolver(db);
+        let std_result_enum =
+            match resolver.resolve_path_segments(db, &std_result_path).into_fully_resolved() {
+                PerNs { types: Some(Resolution::Def(ModuleDef::Enum(e))), .. } => e,
+                _ => return,
+            };
+
+        let std_result_ctor = TypeCtor::Adt(AdtDef::Enum(std_result_enum));
+        let params = match &mismatch.expected {
+            Ty::Apply(ApplicationTy { ctor, parameters }) if ctor == &std_result_ctor => parameters,
+            _ => return,
+        };
+
+        if params.len() == 2 && &params[0] == &mismatch.actual {
+            let source_map = self.func.body_source_map(db);
+            let file_id = self.func.source(db).file_id;
+
+            if let Some(expr) = source_map.expr_syntax(id).and_then(|n| n.cast::<ast::Expr>()) {
+                self.sink.push(MissingOkInTailExpr { file: file_id, expr });
+            }
+        }
+    }
 }
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 6d14eea8e..9c4822d91 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -120,6 +120,8 @@ pub(crate) const TRY: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"Try")
 pub(crate) const OK: Name = Name::new(SmolStr::new_inline_from_ascii(2, b"Ok"));
 pub(crate) const FUTURE_MOD: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"future"));
 pub(crate) const FUTURE_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Future"));
+pub(crate) const RESULT_MOD: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"result"));
+pub(crate) const RESULT_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Result"));
 pub(crate) const OUTPUT: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Output"));
 
 fn resolve_name(text: &SmolStr) -> SmolStr {
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index e86716d74..56ff7da3a 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -278,13 +278,13 @@ impl SourceAnalyzer {
         self.infer.as_ref()?.field_resolution(expr_id)
     }
 
-    pub fn resolve_struct_literal(&self, struct_lit: &ast::StructLit) -> Option<crate::VariantDef> {
-        let expr_id = self.body_source_map.as_ref()?.node_expr(&struct_lit.clone().into())?;
+    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
+        let expr_id = self.body_source_map.as_ref()?.node_expr(&record_lit.clone().into())?;
         self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
     }
 
-    pub fn resolve_struct_pattern(&self, struct_pat: &ast::StructPat) -> Option<crate::VariantDef> {
-        let pat_id = self.body_source_map.as_ref()?.node_pat(&struct_pat.clone().into())?;
+    pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<crate::VariantDef> {
+        let pat_id = self.body_source_map.as_ref()?.node_pat(&record_pat.clone().into())?;
         self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
     }
 
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index cca59538a..d94e8154b 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -37,8 +37,8 @@ use crate::{
     code_model::{ModuleDef::Trait, TypeAlias},
     diagnostics::DiagnosticSink,
     expr::{
-        self, Array, BinaryOp, BindingAnnotation, Body, Expr, ExprId, FieldPat, Literal, Pat,
-        PatId, Statement, UnaryOp,
+        self, Array, BinaryOp, BindingAnnotation, Body, Expr, ExprId, Literal, Pat, PatId,
+        RecordFieldPat, Statement, UnaryOp,
     },
     generics::{GenericParams, HasGenericParams},
     name,
@@ -106,6 +106,13 @@ impl Default for BindingMode {
     }
 }
 
+/// A mismatch between an expected and an inferred type.
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct TypeMismatch {
+    pub expected: Ty,
+    pub actual: Ty,
+}
+
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
@@ -120,6 +127,7 @@ pub struct InferenceResult {
     diagnostics: Vec<InferenceDiagnostic>,
     pub(super) type_of_expr: ArenaMap<ExprId, Ty>,
     pub(super) type_of_pat: ArenaMap<PatId, Ty>,
+    pub(super) type_mismatches: ArenaMap<ExprId, TypeMismatch>,
 }
 
 impl InferenceResult {
@@ -141,6 +149,9 @@ impl InferenceResult {
     pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<ImplItem> {
         self.assoc_resolutions.get(&id.into()).copied()
     }
+    pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch> {
+        self.type_mismatches.get(expr)
+    }
     pub(crate) fn add_diagnostics(
         &self,
         db: &impl HirDatabase,
@@ -705,10 +716,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         ty
     }
 
-    fn infer_struct_pat(
+    fn infer_record_pat(
         &mut self,
         path: Option<&Path>,
-        subpats: &[FieldPat],
+        subpats: &[RecordFieldPat],
         expected: &Ty,
         default_bm: BindingMode,
         id: PatId,
@@ -800,7 +811,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.infer_tuple_struct_pat(p.as_ref(), subpats, expected, default_bm)
             }
             Pat::Struct { path: ref p, args: ref fields } => {
-                self.infer_struct_pat(p.as_ref(), fields, expected, default_bm, pat)
+                self.infer_record_pat(p.as_ref(), fields, expected, default_bm, pat)
             }
             Pat::Path(path) => {
                 // FIXME use correct resolver for the surrounding expression
@@ -1103,7 +1114,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 }
                 Ty::simple(TypeCtor::Never)
             }
-            Expr::StructLit { path, fields, spread } => {
+            Expr::RecordLit { path, fields, spread } => {
                 let (ty, def_id) = self.resolve_variant(path.as_ref());
                 if let Some(variant) = def_id {
                     self.write_variant_resolution(tgt_expr.into(), variant);
@@ -1345,9 +1356,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         };
         // use a new type variable if we got Ty::Unknown here
         let ty = self.insert_type_vars_shallow(ty);
-        self.unify(&ty, &expected.ty);
+        let could_unify = self.unify(&ty, &expected.ty);
         let ty = self.resolve_ty_as_possible(&mut vec![], ty);
         self.write_expr_ty(tgt_expr, ty.clone());
+        if !could_unify {
+            self.result.type_mismatches.insert(
+                tgt_expr,
+                TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
+            );
+        }
         ty
     }