From e39bcecf79a6951f528b12b47ea671f9b0328bb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Tue, 18 Jul 2017 11:41:21 -0700 Subject: [PATCH] Handle type ascription cases with a method call instead of a type --- src/librustc_resolve/lib.rs | 77 +++++++++++++++---- .../type-ascription-with-fn-call.rs | 18 +++++ .../type-ascription-with-fn-call.stderr | 13 ++++ 3 files changed, 94 insertions(+), 14 deletions(-) create mode 100644 src/test/ui/suggestions/type-ascription-with-fn-call.rs create mode 100644 src/test/ui/suggestions/type-ascription-with-fn-call.stderr diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 7754cd7366e..d7316c75b2d 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -599,19 +599,24 @@ fn visit_local(&mut self, local: &'tcx Local) { self.resolve_local(local); } fn visit_ty(&mut self, ty: &'tcx Ty) { - if let TyKind::Path(ref qself, ref path) = ty.node { - self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type); - } else if let TyKind::ImplicitSelf = ty.node { - let self_ty = keywords::SelfType.ident(); - let def = self.resolve_ident_in_lexical_scope(self_ty, TypeNS, true, ty.span) - .map_or(Def::Err, |d| d.def()); - self.record_def(ty.id, PathResolution::new(def)); - } else if let TyKind::Array(ref element, ref length) = ty.node { - self.visit_ty(element); - self.with_constant_rib(|this| { - this.visit_expr(length); - }); - return; + match ty.node { + TyKind::Path(ref qself, ref path) => { + self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type); + } + TyKind::ImplicitSelf => { + let self_ty = keywords::SelfType.ident(); + let def = self.resolve_ident_in_lexical_scope(self_ty, TypeNS, true, ty.span) + .map_or(Def::Err, |d| d.def()); + self.record_def(ty.id, PathResolution::new(def)); + } + TyKind::Array(ref element, ref length) => { + self.visit_ty(element); + self.with_constant_rib(|this| { + this.visit_expr(length); + }); + return; + } + _ => (), } visit::walk_ty(self, ty); } @@ -1221,6 +1226,9 @@ pub struct Resolver<'a> { // This table maps struct IDs into struct constructor IDs, // it's not used during normal resolution, only for better error reporting. struct_constructors: DefIdMap<(Def, ty::Visibility)>, + + // Only used for better errors on `fn(): fn()` + current_type_ascription: Vec, } pub struct ResolverArenas<'a> { @@ -1411,6 +1419,7 @@ pub fn new(session: &'a Session, struct_constructors: DefIdMap(), found_unresolved_macro: false, unused_macros: FxHashSet(), + current_type_ascription: Vec::new(), } } @@ -2495,6 +2504,7 @@ fn smart_resolve_path_fragment(&mut self, // Fallback label. if !levenshtein_worked { err.span_label(base_span, fallback_label); + this.type_ascription_suggestion(&mut err, base_span); } err }; @@ -2550,6 +2560,41 @@ fn smart_resolve_path_fragment(&mut self, resolution } + fn type_ascription_suggestion(&self, + err: &mut DiagnosticBuilder, + base_span: Span) { + debug!("type_ascription_suggetion {:?}", base_span); + let cm = self.session.codemap(); + debug!("self.current_type_ascription {:?}", self.current_type_ascription); + if let Some(sp) = self.current_type_ascription.last() { + let mut sp = *sp; + loop { // try to find the `:`, bail on first non-':'/non-whitespace + sp = sp.next_point(); + if let Ok(snippet) = cm.span_to_snippet(sp.to(sp.next_point())) { + debug!("snippet {:?}", snippet); + let line_sp = cm.lookup_char_pos(sp.hi).line; + let line_base_sp = cm.lookup_char_pos(base_span.lo).line; + debug!("{:?} {:?}", line_sp, line_base_sp); + if snippet == ":" { + err.span_label(base_span, + "expecting a type here because of type ascription"); + if line_sp != line_base_sp { + err.span_suggestion_short(sp, + "did you mean to use `;` here instead?", + ";".to_string()); + } + break; + } else if snippet.trim().len() != 0 { + debug!("tried to find type ascription `:` token, couldn't find it"); + break; + } + } else { + break; + } + } + } + } + fn self_type_is_available(&mut self, span: Span) -> bool { let binding = self.resolve_ident_in_lexical_scope(keywords::SelfType.ident(), TypeNS, false, span); @@ -3166,7 +3211,11 @@ fn resolve_expr(&mut self, expr: &Expr, parent: Option<&Expr>) { self.resolve_expr(argument, None); } } - + ExprKind::Type(ref type_expr, _) => { + self.current_type_ascription.push(type_expr.span); + visit::walk_expr(self, expr); + self.current_type_ascription.pop(); + } _ => { visit::walk_expr(self, expr); } diff --git a/src/test/ui/suggestions/type-ascription-with-fn-call.rs b/src/test/ui/suggestions/type-ascription-with-fn-call.rs new file mode 100644 index 00000000000..7c10bf98c84 --- /dev/null +++ b/src/test/ui/suggestions/type-ascription-with-fn-call.rs @@ -0,0 +1,18 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(type_ascription)] + +fn main() { + f() : + f(); +} + +fn f() {} diff --git a/src/test/ui/suggestions/type-ascription-with-fn-call.stderr b/src/test/ui/suggestions/type-ascription-with-fn-call.stderr new file mode 100644 index 00000000000..93c65c263dd --- /dev/null +++ b/src/test/ui/suggestions/type-ascription-with-fn-call.stderr @@ -0,0 +1,13 @@ +error[E0573]: expected type, found function `f` + --> $DIR/type-ascription-with-fn-call.rs:15:5 + | +14 | f() : + | - help: did you mean to use `;` here instead? +15 | f(); + | ^^^ + | | + | not a type + | expecting a type here because of type ascription + +error: aborting due to previous error + -- GitLab