1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use borrowck::BorrowckCtxt;
12 use rustc::middle::mem_categorization as mc;
13 use rustc::middle::mem_categorization::Categorization;
14 use rustc::middle::mem_categorization::NoteClosureEnv;
15 use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
17 use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin};
20 use errors::DiagnosticBuilder;
21 use borrowck::gather_loans::gather_moves::PatternSource;
23 pub struct MoveErrorCollector<'tcx> {
24 errors: Vec<MoveError<'tcx>>
27 impl<'tcx> MoveErrorCollector<'tcx> {
28 pub fn new() -> MoveErrorCollector<'tcx> {
34 pub fn add_error(&mut self, error: MoveError<'tcx>) {
35 self.errors.push(error);
38 pub fn report_potential_errors<'a>(&self, bccx: &BorrowckCtxt<'a, 'tcx>) {
39 report_move_errors(bccx, &self.errors)
43 pub struct MoveError<'tcx> {
44 move_from: mc::cmt<'tcx>,
45 move_to: Option<MovePlace<'tcx>>
48 impl<'tcx> MoveError<'tcx> {
49 pub fn with_move_info(move_from: mc::cmt<'tcx>,
50 move_to: Option<MovePlace<'tcx>>)
60 pub struct MovePlace<'tcx> {
61 pub span: syntax_pos::Span,
63 pub pat_source: PatternSource<'tcx>,
66 pub struct GroupedMoveErrors<'tcx> {
67 move_from: mc::cmt<'tcx>,
68 move_to_places: Vec<MovePlace<'tcx>>
71 fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &Vec<MoveError<'tcx>>) {
72 let grouped_errors = group_errors_with_same_origin(errors);
73 for error in &grouped_errors {
74 let mut err = report_cannot_move_out_of(bccx, error.move_from.clone());
75 let mut is_first_note = true;
76 match error.move_to_places.get(0) {
77 Some(&MovePlace { pat_source: PatternSource::LetDecl(ref e), .. }) => {
78 // ignore patterns that are found at the top-level of a `let`;
79 // see `get_pattern_source()` for details
81 e.init.as_ref().expect("should have an initializer to get an error");
82 if let Ok(snippet) = bccx.tcx.sess.codemap().span_to_snippet(initializer.span) {
83 err.span_suggestion(initializer.span,
84 "consider using a reference instead",
85 format!("&{}", snippet));
89 for move_to in &error.move_to_places {
91 err = note_move_destination(err, move_to.span, move_to.name, is_first_note);
92 is_first_note = false;
96 if let NoteClosureEnv(upvar_id) = error.move_from.note {
97 let var_node_id = bccx.tcx.hir.hir_to_node_id(upvar_id.var_id);
98 err.span_label(bccx.tcx.hir.span(var_node_id),
99 "captured outer variable");
105 fn group_errors_with_same_origin<'tcx>(errors: &Vec<MoveError<'tcx>>)
106 -> Vec<GroupedMoveErrors<'tcx>> {
107 let mut grouped_errors = Vec::new();
108 for error in errors {
109 append_to_grouped_errors(&mut grouped_errors, error)
111 return grouped_errors;
113 fn append_to_grouped_errors<'tcx>(grouped_errors: &mut Vec<GroupedMoveErrors<'tcx>>,
114 error: &MoveError<'tcx>) {
115 let move_from_id = error.move_from.hir_id;
116 debug!("append_to_grouped_errors(move_from_id={:?})", move_from_id);
117 let move_to = if error.move_to.is_some() {
118 vec![error.move_to.clone().unwrap()]
122 for ge in &mut *grouped_errors {
123 if move_from_id == ge.move_from.hir_id && error.move_to.is_some() {
124 debug!("appending move_to to list");
125 ge.move_to_places.extend(move_to);
129 debug!("found a new move from location");
130 grouped_errors.push(GroupedMoveErrors {
131 move_from: error.move_from.clone(),
132 move_to_places: move_to
137 // (keep in sync with gather_moves::check_and_get_illegal_move_origin )
138 fn report_cannot_move_out_of<'a, 'tcx>(bccx: &'a BorrowckCtxt<'a, 'tcx>,
139 move_from: mc::cmt<'tcx>)
140 -> DiagnosticBuilder<'a> {
141 match move_from.cat {
142 Categorization::Deref(_, mc::BorrowedPtr(..)) |
143 Categorization::Deref(_, mc::UnsafePtr(..)) |
144 Categorization::StaticItem => {
145 bccx.cannot_move_out_of(
146 move_from.span, &move_from.descriptive_string(bccx.tcx), Origin::Ast)
148 Categorization::Interior(ref b, mc::InteriorElement(ik)) => {
149 bccx.cannot_move_out_of_interior_noncopy(
150 move_from.span, b.ty, Some(ik == Kind::Index), Origin::Ast)
153 Categorization::Downcast(ref b, _) |
154 Categorization::Interior(ref b, mc::InteriorField(_)) => {
156 ty::TyAdt(def, _) if def.has_dtor(bccx.tcx) => {
157 bccx.cannot_move_out_of_interior_of_drop(
158 move_from.span, b.ty, Origin::Ast)
161 span_bug!(move_from.span, "this path should not cause illegal move");
166 span_bug!(move_from.span, "this path should not cause illegal move");
171 fn note_move_destination(mut err: DiagnosticBuilder,
172 move_to_span: syntax_pos::Span,
174 is_first_note: bool) -> DiagnosticBuilder {
178 format!("hint: to prevent move, use `ref {0}` or `ref mut {0}`",
182 err.span_label(move_to_span,
183 format!("...and here (use `ref {0}` or `ref mut {0}`)",