src/librustc/infer/error_reporting/note.rs

   1 // Copyright 2017 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.
   4 //
   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.
  10
  11 use infer::{self, InferCtxt, SubregionOrigin};
  12 use middle::region;
  13 use ty::{self, Region};
  14 use ty::error::TypeError;
  15 use errors::DiagnosticBuilder;
  16
  17 impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
  18     pub(super) fn note_region_origin(&self,
  19                                      err: &mut DiagnosticBuilder,
  20                                      origin: &SubregionOrigin<'tcx>) {
  21         match *origin {
  22             infer::Subtype(ref trace) => {
  23                 if let Some((expected, found)) = self.values_str(&trace.values) {
  24                     let expected = expected.content();
  25                     let found = found.content();
  26                     err.note(&format!("...so that the {}:\nexpected {}\n   found {}",
  27                                       trace.cause.as_requirement_str(),
  28                                       expected,
  29                                       found));
  30                 } else {
  31                     // FIXME: this really should be handled at some earlier stage. Our
  32                     // handling of region checking when type errors are present is
  33                     // *terrible*.
  34
  35                     err.span_note(trace.cause.span,
  36                                   &format!("...so that {}", trace.cause.as_requirement_str()));
  37                 }
  38             }
  39             infer::Reborrow(span) => {
  40                 err.span_note(span,
  41                               "...so that reference does not outlive borrowed content");
  42             }
  43             infer::ReborrowUpvar(span, ref upvar_id) => {
  44                 let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
  45                 let var_name = self.tcx.hir.name(var_node_id);
  46                 err.span_note(span,
  47                               &format!("...so that closure can access `{}`", var_name));
  48             }
  49             infer::InfStackClosure(span) => {
  50                 err.span_note(span, "...so that closure does not outlive its stack frame");
  51             }
  52             infer::InvokeClosure(span) => {
  53                 err.span_note(span,
  54                               "...so that closure is not invoked outside its lifetime");
  55             }
  56             infer::DerefPointer(span) => {
  57                 err.span_note(span,
  58                               "...so that pointer is not dereferenced outside its lifetime");
  59             }
  60             infer::FreeVariable(span, id) => {
  61                 err.span_note(span,
  62                               &format!("...so that captured variable `{}` does not outlive the \
  63                                         enclosing closure",
  64                                        self.tcx.hir.name(id)));
  65             }
  66             infer::IndexSlice(span) => {
  67                 err.span_note(span, "...so that slice is not indexed outside the lifetime");
  68             }
  69             infer::RelateObjectBound(span) => {
  70                 err.span_note(span, "...so that it can be closed over into an object");
  71             }
  72             infer::CallRcvr(span) => {
  73                 err.span_note(span,
  74                               "...so that method receiver is valid for the method call");
  75             }
  76             infer::CallArg(span) => {
  77                 err.span_note(span, "...so that argument is valid for the call");
  78             }
  79             infer::CallReturn(span) => {
  80                 err.span_note(span, "...so that return value is valid for the call");
  81             }
  82             infer::Operand(span) => {
  83                 err.span_note(span, "...so that operand is valid for operation");
  84             }
  85             infer::AddrOf(span) => {
  86                 err.span_note(span, "...so that reference is valid at the time of borrow");
  87             }
  88             infer::AutoBorrow(span) => {
  89                 err.span_note(span,
  90                               "...so that auto-reference is valid at the time of borrow");
  91             }
  92             infer::ExprTypeIsNotInScope(t, span) => {
  93                 err.span_note(span,
  94                               &format!("...so type `{}` of expression is valid during the \
  95                                         expression",
  96                                        self.ty_to_string(t)));
  97             }
  98             infer::BindingTypeIsNotValidAtDecl(span) => {
  99                 err.span_note(span,
 100                               "...so that variable is valid at time of its declaration");
 101             }
 102             infer::ParameterInScope(_, span) => {
 103                 err.span_note(span,
 104                               "...so that a type/lifetime parameter is in scope here");
 105             }
 106             infer::DataBorrowed(ty, span) => {
 107                 err.span_note(span,
 108                               &format!("...so that the type `{}` is not borrowed for too long",
 109                                        self.ty_to_string(ty)));
 110             }
 111             infer::ReferenceOutlivesReferent(ty, span) => {
 112                 err.span_note(span,
 113                               &format!("...so that the reference type `{}` does not outlive the \
 114                                         data it points at",
 115                                        self.ty_to_string(ty)));
 116             }
 117             infer::RelateParamBound(span, t) => {
 118                 err.span_note(span,
 119                               &format!("...so that the type `{}` will meet its required \
 120                                         lifetime bounds",
 121                                        self.ty_to_string(t)));
 122             }
 123             infer::RelateDefaultParamBound(span, t) => {
 124                 err.span_note(span,
 125                               &format!("...so that type parameter instantiated with `{}`, will \
 126                                         meet its declared lifetime bounds",
 127                                        self.ty_to_string(t)));
 128             }
 129             infer::RelateRegionParamBound(span) => {
 130                 err.span_note(span,
 131                               "...so that the declared lifetime parameter bounds are satisfied");
 132             }
 133             infer::SafeDestructor(span) => {
 134                 err.span_note(span,
 135                               "...so that references are valid when the destructor runs");
 136             }
 137             infer::CompareImplMethodObligation { span, .. } => {
 138                 err.span_note(span,
 139                               "...so that the definition in impl matches the definition from the \
 140                                trait");
 141             }
 142         }
 143     }
 144
 145     pub(super) fn report_concrete_failure(&self,
 146                                           region_scope_tree: &region::ScopeTree,
 147                                           origin: SubregionOrigin<'tcx>,
 148                                           sub: Region<'tcx>,
 149                                           sup: Region<'tcx>)
 150                                           -> DiagnosticBuilder<'tcx> {
 151         match origin {
 152             infer::Subtype(trace) => {
 153                 let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
 154                 let mut err = self.report_and_explain_type_error(trace, &terr);
 155                 self.tcx.note_and_explain_region(region_scope_tree, &mut err, "", sup, "...");
 156                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 157                     "...does not necessarily outlive ", sub, "");
 158                 err
 159             }
 160             infer::Reborrow(span) => {
 161                 let mut err = struct_span_err!(self.tcx.sess,
 162                                                span,
 163                                                E0312,
 164                                                "lifetime of reference outlives lifetime of \
 165                                                 borrowed content...");
 166                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 167                                                  "...the reference is valid for ",
 168                                                  sub,
 169                                                  "...");
 170                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 171                                                  "...but the borrowed content is only valid for ",
 172                                                  sup,
 173                                                  "");
 174                 err
 175             }
 176             infer::ReborrowUpvar(span, ref upvar_id) => {
 177                 let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
 178                 let var_name = self.tcx.hir.name(var_node_id);
 179                 let mut err = struct_span_err!(self.tcx.sess,
 180                                                span,
 181                                                E0313,
 182                                                "lifetime of borrowed pointer outlives lifetime \
 183                                                 of captured variable `{}`...",
 184                                                var_name);
 185                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 186                                                  "...the borrowed pointer is valid for ",
 187                                                  sub,
 188                                                  "...");
 189                 self.tcx.note_and_explain_region(
 190                     region_scope_tree,
 191                     &mut err,
 192                     &format!("...but `{}` is only valid for ", var_name),
 193                     sup,
 194                     "");
 195                 err
 196             }
 197             infer::InfStackClosure(span) => {
 198                 let mut err =
 199                     struct_span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame");
 200                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 201                                                  "...the closure must be valid for ",
 202                                                  sub,
 203                                                  "...");
 204                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 205                                                  "...but the closure's stack frame is only valid \
 206                                                   for ",
 207                                                  sup,
 208                                                  "");
 209                 err
 210             }
 211             infer::InvokeClosure(span) => {
 212                 let mut err = struct_span_err!(self.tcx.sess,
 213                                                span,
 214                                                E0315,
 215                                                "cannot invoke closure outside of its lifetime");
 216                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 217                     "the closure is only valid for ", sup, "");
 218                 err
 219             }
 220             infer::DerefPointer(span) => {
 221                 let mut err = struct_span_err!(self.tcx.sess,
 222                                                span,
 223                                                E0473,
 224                                                "dereference of reference outside its lifetime");
 225                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 226                     "the reference is only valid for ", sup, "");
 227                 err
 228             }
 229             infer::FreeVariable(span, id) => {
 230                 let mut err = struct_span_err!(self.tcx.sess,
 231                                                span,
 232                                                E0474,
 233                                                "captured variable `{}` does not outlive the \
 234                                                 enclosing closure",
 235                                                self.tcx.hir.name(id));
 236                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 237                     "captured variable is valid for ", sup, "");
 238                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 239                     "closure is valid for ", sub, "");
 240                 err
 241             }
 242             infer::IndexSlice(span) => {
 243                 let mut err = struct_span_err!(self.tcx.sess,
 244                                                span,
 245                                                E0475,
 246                                                "index of slice outside its lifetime");
 247                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 248                     "the slice is only valid for ", sup, "");
 249                 err
 250             }
 251             infer::RelateObjectBound(span) => {
 252                 let mut err = struct_span_err!(self.tcx.sess,
 253                                                span,
 254                                                E0476,
 255                                                "lifetime of the source pointer does not outlive \
 256                                                 lifetime bound of the object type");
 257                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 258                     "object type is valid for ", sub, "");
 259                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 260                                                  "source pointer is only valid for ",
 261                                                  sup,
 262                                                  "");
 263                 err
 264             }
 265             infer::RelateParamBound(span, ty) => {
 266                 let mut err = struct_span_err!(self.tcx.sess,
 267                                                span,
 268                                                E0477,
 269                                                "the type `{}` does not fulfill the required \
 270                                                 lifetime",
 271                                                self.ty_to_string(ty));
 272                 match *sub {
 273                     ty::ReStatic => {
 274                         self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 275                             "type must satisfy ", sub, "")
 276                     }
 277                     _ => {
 278                         self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 279                             "type must outlive ", sub, "")
 280                     }
 281                 }
 282                 err
 283             }
 284             infer::RelateRegionParamBound(span) => {
 285                 let mut err =
 286                     struct_span_err!(self.tcx.sess, span, E0478, "lifetime bound not satisfied");
 287                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 288                                                  "lifetime parameter instantiated with ",
 289                                                  sup,
 290                                                  "");
 291                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 292                                                  "but lifetime parameter must outlive ",
 293                                                  sub,
 294                                                  "");
 295                 err
 296             }
 297             infer::RelateDefaultParamBound(span, ty) => {
 298                 let mut err = struct_span_err!(self.tcx.sess,
 299                                                span,
 300                                                E0479,
 301                                                "the type `{}` (provided as the value of a type \
 302                                                 parameter) is not valid at this point",
 303                                                self.ty_to_string(ty));
 304                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 305                     "type must outlive ", sub, "");
 306                 err
 307             }
 308             infer::CallRcvr(span) => {
 309                 let mut err = struct_span_err!(self.tcx.sess,
 310                                                span,
 311                                                E0480,
 312                                                "lifetime of method receiver does not outlive the \
 313                                                 method call");
 314                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 315                 "the receiver is only valid for ", sup, "");
 316                 err
 317             }
 318             infer::CallArg(span) => {
 319                 let mut err = struct_span_err!(self.tcx.sess,
 320                                                span,
 321                                                E0481,
 322                                                "lifetime of function argument does not outlive \
 323                                                 the function call");
 324                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 325                                                  "the function argument is only valid for ",
 326                                                  sup,
 327                                                  "");
 328                 err
 329             }
 330             infer::CallReturn(span) => {
 331                 let mut err = struct_span_err!(self.tcx.sess,
 332                                                span,
 333                                                E0482,
 334                                                "lifetime of return value does not outlive the \
 335                                                 function call");
 336                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 337                                                  "the return value is only valid for ",
 338                                                  sup,
 339                                                  "");
 340                 err
 341             }
 342             infer::Operand(span) => {
 343                 let mut err = struct_span_err!(self.tcx.sess,
 344                                                span,
 345                                                E0483,
 346                                                "lifetime of operand does not outlive the \
 347                                                 operation");
 348                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 349                     "the operand is only valid for ", sup, "");
 350                 err
 351             }
 352             infer::AddrOf(span) => {
 353                 let mut err = struct_span_err!(self.tcx.sess,
 354                                                span,
 355                                                E0484,
 356                                                "reference is not valid at the time of borrow");
 357                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 358                     "the borrow is only valid for ", sup, "");
 359                 err
 360             }
 361             infer::AutoBorrow(span) => {
 362                 let mut err = struct_span_err!(self.tcx.sess,
 363                                                span,
 364                                                E0485,
 365                                                "automatically reference is not valid at the time \
 366                                                 of borrow");
 367                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 368                                                  "the automatic borrow is only valid for ",
 369                                                  sup,
 370                                                  "");
 371                 err
 372             }
 373             infer::ExprTypeIsNotInScope(t, span) => {
 374                 let mut err = struct_span_err!(self.tcx.sess,
 375                                                span,
 376                                                E0486,
 377                                                "type of expression contains references that are \
 378                                                 not valid during the expression: `{}`",
 379                                                self.ty_to_string(t));
 380                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 381                     "type is only valid for ", sup, "");
 382                 err
 383             }
 384             infer::SafeDestructor(span) => {
 385                 let mut err = struct_span_err!(self.tcx.sess,
 386                                                span,
 387                                                E0487,
 388                                                "unsafe use of destructor: destructor might be \
 389                                                 called while references are dead");
 390                 // FIXME (22171): terms "super/subregion" are suboptimal
 391                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 392                     "superregion: ", sup, "");
 393                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 394                     "subregion: ", sub, "");
 395                 err
 396             }
 397             infer::BindingTypeIsNotValidAtDecl(span) => {
 398                 let mut err = struct_span_err!(self.tcx.sess,
 399                                                span,
 400                                                E0488,
 401                                                "lifetime of variable does not enclose its \
 402                                                 declaration");
 403                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 404                     "the variable is only valid for ", sup, "");
 405                 err
 406             }
 407             infer::ParameterInScope(_, span) => {
 408                 let mut err = struct_span_err!(self.tcx.sess,
 409                                                span,
 410                                                E0489,
 411                                                "type/lifetime parameter not in scope here");
 412                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 413                     "the parameter is only valid for ", sub, "");
 414                 err
 415             }
 416             infer::DataBorrowed(ty, span) => {
 417                 let mut err = struct_span_err!(self.tcx.sess,
 418                                                span,
 419                                                E0490,
 420                                                "a value of type `{}` is borrowed for too long",
 421                                                self.ty_to_string(ty));
 422                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 423                     "the type is valid for ", sub, "");
 424                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 425                     "but the borrow lasts for ", sup, "");
 426                 err
 427             }
 428             infer::ReferenceOutlivesReferent(ty, span) => {
 429                 let mut err = struct_span_err!(self.tcx.sess,
 430                                                span,
 431                                                E0491,
 432                                                "in type `{}`, reference has a longer lifetime \
 433                                                 than the data it references",
 434                                                self.ty_to_string(ty));
 435                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 436                     "the pointer is valid for ", sub, "");
 437                 self.tcx.note_and_explain_region(region_scope_tree, &mut err,
 438                                                  "but the referenced data is only valid for ",
 439                                                  sup,
 440                                                  "");
 441                 err
 442             }
 443             infer::CompareImplMethodObligation { span,
 444                                                  item_name,
 445                                                  impl_item_def_id,
 446                                                  trait_item_def_id } => {
 447                 self.report_extra_impl_obligation(span,
 448                                                   item_name,
 449                                                   impl_item_def_id,
 450                                                   trait_item_def_id,
 451                                                   &format!("`{}: {}`", sup, sub))
 452             }
 453         }
 454     }
 455 }