1901 lines
77 KiB
Rust
1901 lines
77 KiB
Rust
// Copyright 2012-2013 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 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! Error Reporting Code for the inference engine
|
|
//!
|
|
//! Because of the way inference, and in particular region inference,
|
|
//! works, it often happens that errors are not detected until far after
|
|
//! the relevant line of code has been type-checked. Therefore, there is
|
|
//! an elaborate system to track why a particular constraint in the
|
|
//! inference graph arose so that we can explain to the user what gave
|
|
//! rise to a particular error.
|
|
//!
|
|
//! The basis of the system are the "origin" types. An "origin" is the
|
|
//! reason that a constraint or inference variable arose. There are
|
|
//! different "origin" enums for different kinds of constraints/variables
|
|
//! (e.g., `TypeOrigin`, `RegionVariableOrigin`). An origin always has
|
|
//! a span, but also more information so that we can generate a meaningful
|
|
//! error message.
|
|
//!
|
|
//! Having a catalogue of all the different reasons an error can arise is
|
|
//! also useful for other reasons, like cross-referencing FAQs etc, though
|
|
//! we are not really taking advantage of this yet.
|
|
//!
|
|
//! # Region Inference
|
|
//!
|
|
//! Region inference is particularly tricky because it always succeeds "in
|
|
//! the moment" and simply registers a constraint. Then, at the end, we
|
|
//! can compute the full graph and report errors, so we need to be able to
|
|
//! store and later report what gave rise to the conflicting constraints.
|
|
//!
|
|
//! # Subtype Trace
|
|
//!
|
|
//! Determining whether `T1 <: T2` often involves a number of subtypes and
|
|
//! subconstraints along the way. A "TypeTrace" is an extended version
|
|
//! of an origin that traces the types and other values that were being
|
|
//! compared. It is not necessarily comprehensive (in fact, at the time of
|
|
//! this writing it only tracks the root values being compared) but I'd
|
|
//! like to extend it to include significant "waypoints". For example, if
|
|
//! you are comparing `(T1, T2) <: (T3, T4)`, and the problem is that `T2
|
|
//! <: T4` fails, I'd like the trace to include enough information to say
|
|
//! "in the 2nd element of the tuple". Similarly, failures when comparing
|
|
//! arguments or return types in fn types should be able to cite the
|
|
//! specific position, etc.
|
|
//!
|
|
//! # Reality vs plan
|
|
//!
|
|
//! Of course, there is still a LOT of code in typeck that has yet to be
|
|
//! ported to this system, and which relies on string concatenation at the
|
|
//! time of error detection.
|
|
|
|
use self::FreshOrKept::*;
|
|
|
|
use super::InferCtxt;
|
|
use super::TypeTrace;
|
|
use super::SubregionOrigin;
|
|
use super::RegionVariableOrigin;
|
|
use super::ValuePairs;
|
|
use super::region_inference::RegionResolutionError;
|
|
use super::region_inference::ConcreteFailure;
|
|
use super::region_inference::SubSupConflict;
|
|
use super::region_inference::GenericBoundFailure;
|
|
use super::region_inference::GenericKind;
|
|
use super::region_inference::ProcessedErrors;
|
|
use super::region_inference::ProcessedErrorOrigin;
|
|
use super::region_inference::SameRegions;
|
|
|
|
use std::collections::HashSet;
|
|
|
|
use hir::map as ast_map;
|
|
use hir;
|
|
use hir::print as pprust;
|
|
|
|
use lint;
|
|
use hir::def::Def;
|
|
use hir::def_id::DefId;
|
|
use infer::{self, TypeOrigin};
|
|
use middle::region;
|
|
use ty::{self, TyCtxt, TypeFoldable};
|
|
use ty::{Region, ReFree};
|
|
use ty::error::TypeError;
|
|
|
|
use std::cell::{Cell, RefCell};
|
|
use std::char::from_u32;
|
|
use std::fmt;
|
|
use syntax::ast;
|
|
use syntax::parse::token;
|
|
use syntax::ptr::P;
|
|
use syntax_pos::{self, Pos, Span};
|
|
use errors::DiagnosticBuilder;
|
|
|
|
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|
pub fn note_and_explain_region(self,
|
|
err: &mut DiagnosticBuilder,
|
|
prefix: &str,
|
|
region: &'tcx ty::Region,
|
|
suffix: &str) {
|
|
fn item_scope_tag(item: &hir::Item) -> &'static str {
|
|
match item.node {
|
|
hir::ItemImpl(..) => "impl",
|
|
hir::ItemStruct(..) => "struct",
|
|
hir::ItemUnion(..) => "union",
|
|
hir::ItemEnum(..) => "enum",
|
|
hir::ItemTrait(..) => "trait",
|
|
hir::ItemFn(..) => "function body",
|
|
_ => "item"
|
|
}
|
|
}
|
|
|
|
fn explain_span<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
|
heading: &str, span: Span)
|
|
-> (String, Option<Span>) {
|
|
let lo = tcx.sess.codemap().lookup_char_pos_adj(span.lo);
|
|
(format!("the {} at {}:{}", heading, lo.line, lo.col.to_usize()),
|
|
Some(span))
|
|
}
|
|
|
|
let (description, span) = match *region {
|
|
ty::ReScope(scope) => {
|
|
let new_string;
|
|
let unknown_scope = || {
|
|
format!("{}unknown scope: {:?}{}. Please report a bug.",
|
|
prefix, scope, suffix)
|
|
};
|
|
let span = match scope.span(&self.region_maps, &self.map) {
|
|
Some(s) => s,
|
|
None => {
|
|
err.note(&unknown_scope());
|
|
return;
|
|
}
|
|
};
|
|
let tag = match self.map.find(scope.node_id(&self.region_maps)) {
|
|
Some(ast_map::NodeBlock(_)) => "block",
|
|
Some(ast_map::NodeExpr(expr)) => match expr.node {
|
|
hir::ExprCall(..) => "call",
|
|
hir::ExprMethodCall(..) => "method call",
|
|
hir::ExprMatch(.., hir::MatchSource::IfLetDesugar { .. }) => "if let",
|
|
hir::ExprMatch(.., hir::MatchSource::WhileLetDesugar) => "while let",
|
|
hir::ExprMatch(.., hir::MatchSource::ForLoopDesugar) => "for",
|
|
hir::ExprMatch(..) => "match",
|
|
_ => "expression",
|
|
},
|
|
Some(ast_map::NodeStmt(_)) => "statement",
|
|
Some(ast_map::NodeItem(it)) => item_scope_tag(&it),
|
|
Some(_) | None => {
|
|
err.span_note(span, &unknown_scope());
|
|
return;
|
|
}
|
|
};
|
|
let scope_decorated_tag = match self.region_maps.code_extent_data(scope) {
|
|
region::CodeExtentData::Misc(_) => tag,
|
|
region::CodeExtentData::CallSiteScope { .. } => {
|
|
"scope of call-site for function"
|
|
}
|
|
region::CodeExtentData::ParameterScope { .. } => {
|
|
"scope of function body"
|
|
}
|
|
region::CodeExtentData::DestructionScope(_) => {
|
|
new_string = format!("destruction scope surrounding {}", tag);
|
|
&new_string[..]
|
|
}
|
|
region::CodeExtentData::Remainder(r) => {
|
|
new_string = format!("block suffix following statement {}",
|
|
r.first_statement_index);
|
|
&new_string[..]
|
|
}
|
|
};
|
|
explain_span(self, scope_decorated_tag, span)
|
|
}
|
|
|
|
ty::ReFree(ref fr) => {
|
|
let prefix = match fr.bound_region {
|
|
ty::BrAnon(idx) => {
|
|
format!("the anonymous lifetime #{} defined on", idx + 1)
|
|
}
|
|
ty::BrFresh(_) => "an anonymous lifetime defined on".to_owned(),
|
|
_ => {
|
|
format!("the lifetime {} as defined on",
|
|
fr.bound_region)
|
|
}
|
|
};
|
|
|
|
match self.map.find(fr.scope.node_id(&self.region_maps)) {
|
|
Some(ast_map::NodeBlock(ref blk)) => {
|
|
let (msg, opt_span) = explain_span(self, "block", blk.span);
|
|
(format!("{} {}", prefix, msg), opt_span)
|
|
}
|
|
Some(ast_map::NodeItem(it)) => {
|
|
let tag = item_scope_tag(&it);
|
|
let (msg, opt_span) = explain_span(self, tag, it.span);
|
|
(format!("{} {}", prefix, msg), opt_span)
|
|
}
|
|
Some(_) | None => {
|
|
// this really should not happen, but it does:
|
|
// FIXME(#27942)
|
|
(format!("{} unknown free region bounded by scope {:?}",
|
|
prefix, fr.scope), None)
|
|
}
|
|
}
|
|
}
|
|
|
|
ty::ReStatic => ("the static lifetime".to_owned(), None),
|
|
|
|
ty::ReEmpty => ("the empty lifetime".to_owned(), None),
|
|
|
|
ty::ReEarlyBound(ref data) => (data.name.to_string(), None),
|
|
|
|
// FIXME(#13998) ReSkolemized should probably print like
|
|
// ReFree rather than dumping Debug output on the user.
|
|
//
|
|
// We shouldn't really be having unification failures with ReVar
|
|
// and ReLateBound though.
|
|
ty::ReSkolemized(..) |
|
|
ty::ReVar(_) |
|
|
ty::ReLateBound(..) |
|
|
ty::ReErased => {
|
|
(format!("lifetime {:?}", region), None)
|
|
}
|
|
};
|
|
let message = format!("{}{}{}", prefix, description, suffix);
|
|
if let Some(span) = span {
|
|
err.span_note(span, &message);
|
|
} else {
|
|
err.note(&message);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
|
pub fn report_region_errors(&self,
|
|
errors: &Vec<RegionResolutionError<'tcx>>) {
|
|
debug!("report_region_errors(): {} errors to start", errors.len());
|
|
|
|
// try to pre-process the errors, which will group some of them
|
|
// together into a `ProcessedErrors` group:
|
|
let processed_errors = self.process_errors(errors);
|
|
let errors = processed_errors.as_ref().unwrap_or(errors);
|
|
|
|
debug!("report_region_errors: {} errors after preprocessing", errors.len());
|
|
|
|
for error in errors {
|
|
match error.clone() {
|
|
ConcreteFailure(origin, sub, sup) => {
|
|
self.report_concrete_failure(origin, sub, sup).emit();
|
|
}
|
|
|
|
GenericBoundFailure(kind, param_ty, sub) => {
|
|
self.report_generic_bound_failure(kind, param_ty, sub);
|
|
}
|
|
|
|
SubSupConflict(var_origin,
|
|
sub_origin, sub_r,
|
|
sup_origin, sup_r) => {
|
|
self.report_sub_sup_conflict(var_origin,
|
|
sub_origin, sub_r,
|
|
sup_origin, sup_r);
|
|
}
|
|
|
|
ProcessedErrors(ref origins,
|
|
ref same_regions) => {
|
|
if !same_regions.is_empty() {
|
|
self.report_processed_errors(origins, same_regions);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This method goes through all the errors and try to group certain types
|
|
// of error together, for the purpose of suggesting explicit lifetime
|
|
// parameters to the user. This is done so that we can have a more
|
|
// complete view of what lifetimes should be the same.
|
|
// If the return value is an empty vector, it means that processing
|
|
// failed (so the return value of this method should not be used).
|
|
//
|
|
// The method also attempts to weed out messages that seem like
|
|
// duplicates that will be unhelpful to the end-user. But
|
|
// obviously it never weeds out ALL errors.
|
|
fn process_errors(&self, errors: &Vec<RegionResolutionError<'tcx>>)
|
|
-> Option<Vec<RegionResolutionError<'tcx>>> {
|
|
debug!("process_errors()");
|
|
let mut origins = Vec::new();
|
|
|
|
// we collect up ConcreteFailures and SubSupConflicts that are
|
|
// relating free-regions bound on the fn-header and group them
|
|
// together into this vector
|
|
let mut same_regions = Vec::new();
|
|
|
|
// here we put errors that we will not be able to process nicely
|
|
let mut other_errors = Vec::new();
|
|
|
|
// we collect up GenericBoundFailures in here.
|
|
let mut bound_failures = Vec::new();
|
|
|
|
for error in errors {
|
|
match *error {
|
|
ConcreteFailure(ref origin, sub, sup) => {
|
|
debug!("processing ConcreteFailure");
|
|
match free_regions_from_same_fn(self.tcx, sub, sup) {
|
|
Some(ref same_frs) => {
|
|
origins.push(
|
|
ProcessedErrorOrigin::ConcreteFailure(
|
|
origin.clone(),
|
|
sub,
|
|
sup));
|
|
append_to_same_regions(&mut same_regions, same_frs);
|
|
}
|
|
_ => {
|
|
other_errors.push(error.clone());
|
|
}
|
|
}
|
|
}
|
|
SubSupConflict(ref var_origin, _, sub_r, _, sup_r) => {
|
|
debug!("processing SubSupConflict sub: {:?} sup: {:?}", sub_r, sup_r);
|
|
match free_regions_from_same_fn(self.tcx, sub_r, sup_r) {
|
|
Some(ref same_frs) => {
|
|
origins.push(
|
|
ProcessedErrorOrigin::VariableFailure(
|
|
var_origin.clone()));
|
|
append_to_same_regions(&mut same_regions, same_frs);
|
|
}
|
|
None => {
|
|
other_errors.push(error.clone());
|
|
}
|
|
}
|
|
}
|
|
GenericBoundFailure(ref origin, ref kind, region) => {
|
|
bound_failures.push((origin.clone(), kind.clone(), region));
|
|
}
|
|
ProcessedErrors(..) => {
|
|
bug!("should not encounter a `ProcessedErrors` yet: {:?}", error)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ok, let's pull together the errors, sorted in an order that
|
|
// we think will help user the best
|
|
let mut processed_errors = vec![];
|
|
|
|
// first, put the processed errors, if any
|
|
if !same_regions.is_empty() {
|
|
let common_scope_id = same_regions[0].scope_id;
|
|
for sr in &same_regions {
|
|
// Since ProcessedErrors is used to reconstruct the function
|
|
// declaration, we want to make sure that they are, in fact,
|
|
// from the same scope
|
|
if sr.scope_id != common_scope_id {
|
|
debug!("returning empty result from process_errors because
|
|
{} != {}", sr.scope_id, common_scope_id);
|
|
return None;
|
|
}
|
|
}
|
|
assert!(origins.len() > 0);
|
|
let pe = ProcessedErrors(origins, same_regions);
|
|
debug!("errors processed: {:?}", pe);
|
|
processed_errors.push(pe);
|
|
}
|
|
|
|
// next, put the other misc errors
|
|
processed_errors.extend(other_errors);
|
|
|
|
// finally, put the `T: 'a` errors, but only if there were no
|
|
// other errors. otherwise, these have a very high rate of
|
|
// being unhelpful in practice. This is because they are
|
|
// basically secondary checks that test the state of the
|
|
// region graph after the rest of inference is done, and the
|
|
// other kinds of errors indicate that the region constraint
|
|
// graph is internally inconsistent, so these test results are
|
|
// likely to be meaningless.
|
|
if processed_errors.is_empty() {
|
|
for (origin, kind, region) in bound_failures {
|
|
processed_errors.push(GenericBoundFailure(origin, kind, region));
|
|
}
|
|
}
|
|
|
|
// we should always wind up with SOME errors, unless there were no
|
|
// errors to start
|
|
assert!(if errors.len() > 0 {processed_errors.len() > 0} else {true});
|
|
|
|
return Some(processed_errors);
|
|
|
|
#[derive(Debug)]
|
|
struct FreeRegionsFromSameFn {
|
|
sub_fr: ty::FreeRegion,
|
|
sup_fr: ty::FreeRegion,
|
|
scope_id: ast::NodeId
|
|
}
|
|
|
|
impl FreeRegionsFromSameFn {
|
|
fn new(sub_fr: ty::FreeRegion,
|
|
sup_fr: ty::FreeRegion,
|
|
scope_id: ast::NodeId)
|
|
-> FreeRegionsFromSameFn {
|
|
FreeRegionsFromSameFn {
|
|
sub_fr: sub_fr,
|
|
sup_fr: sup_fr,
|
|
scope_id: scope_id
|
|
}
|
|
}
|
|
}
|
|
|
|
fn free_regions_from_same_fn<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
|
sub: &'tcx Region,
|
|
sup: &'tcx Region)
|
|
-> Option<FreeRegionsFromSameFn> {
|
|
debug!("free_regions_from_same_fn(sub={:?}, sup={:?})", sub, sup);
|
|
let (scope_id, fr1, fr2) = match (sub, sup) {
|
|
(&ReFree(fr1), &ReFree(fr2)) => {
|
|
if fr1.scope != fr2.scope {
|
|
return None
|
|
}
|
|
assert!(fr1.scope == fr2.scope);
|
|
(fr1.scope.node_id(&tcx.region_maps), fr1, fr2)
|
|
},
|
|
_ => return None
|
|
};
|
|
let parent = tcx.map.get_parent(scope_id);
|
|
let parent_node = tcx.map.find(parent);
|
|
match parent_node {
|
|
Some(node) => match node {
|
|
ast_map::NodeItem(item) => match item.node {
|
|
hir::ItemFn(..) => {
|
|
Some(FreeRegionsFromSameFn::new(fr1, fr2, scope_id))
|
|
},
|
|
_ => None
|
|
},
|
|
ast_map::NodeImplItem(..) |
|
|
ast_map::NodeTraitItem(..) => {
|
|
Some(FreeRegionsFromSameFn::new(fr1, fr2, scope_id))
|
|
},
|
|
_ => None
|
|
},
|
|
None => {
|
|
debug!("no parent node of scope_id {}", scope_id);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
fn append_to_same_regions(same_regions: &mut Vec<SameRegions>,
|
|
same_frs: &FreeRegionsFromSameFn) {
|
|
debug!("append_to_same_regions(same_regions={:?}, same_frs={:?})",
|
|
same_regions, same_frs);
|
|
let scope_id = same_frs.scope_id;
|
|
let (sub_fr, sup_fr) = (same_frs.sub_fr, same_frs.sup_fr);
|
|
for sr in same_regions.iter_mut() {
|
|
if sr.contains(&sup_fr.bound_region) && scope_id == sr.scope_id {
|
|
sr.push(sub_fr.bound_region);
|
|
return
|
|
}
|
|
}
|
|
same_regions.push(SameRegions {
|
|
scope_id: scope_id,
|
|
regions: vec!(sub_fr.bound_region, sup_fr.bound_region)
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Adds a note if the types come from similarly named crates
|
|
fn check_and_note_conflicting_crates(&self,
|
|
err: &mut DiagnosticBuilder,
|
|
terr: &TypeError<'tcx>,
|
|
sp: Span) {
|
|
let report_path_match = |err: &mut DiagnosticBuilder, did1: DefId, did2: DefId| {
|
|
// Only external crates, if either is from a local
|
|
// module we could have false positives
|
|
if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
|
|
let exp_path = self.tcx.item_path_str(did1);
|
|
let found_path = self.tcx.item_path_str(did2);
|
|
// We compare strings because DefPath can be different
|
|
// for imported and non-imported crates
|
|
if exp_path == found_path {
|
|
let crate_name = self.tcx.sess.cstore.crate_name(did1.krate);
|
|
err.span_note(sp, &format!("Perhaps two different versions \
|
|
of crate `{}` are being used?",
|
|
crate_name));
|
|
}
|
|
}
|
|
};
|
|
match *terr {
|
|
TypeError::Sorts(ref exp_found) => {
|
|
// if they are both "path types", there's a chance of ambiguity
|
|
// due to different versions of the same crate
|
|
match (&exp_found.expected.sty, &exp_found.found.sty) {
|
|
(&ty::TyAdt(exp_adt, _), &ty::TyAdt(found_adt, _)) => {
|
|
report_path_match(err, exp_adt.did, found_adt.did);
|
|
},
|
|
_ => ()
|
|
}
|
|
},
|
|
TypeError::Traits(ref exp_found) => {
|
|
report_path_match(err, exp_found.expected, exp_found.found);
|
|
},
|
|
_ => () // FIXME(#22750) handle traits and stuff
|
|
}
|
|
}
|
|
|
|
fn note_error_origin(&self,
|
|
err: &mut DiagnosticBuilder<'tcx>,
|
|
origin: &TypeOrigin)
|
|
{
|
|
match origin {
|
|
&TypeOrigin::MatchExpressionArm(_, arm_span, source) => match source {
|
|
hir::MatchSource::IfLetDesugar {..} => {
|
|
err.span_note(arm_span, "`if let` arm with an incompatible type");
|
|
}
|
|
_ => {
|
|
err.span_note(arm_span, "match arm with an incompatible type");
|
|
}
|
|
},
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
pub fn note_type_err(&self,
|
|
diag: &mut DiagnosticBuilder<'tcx>,
|
|
origin: TypeOrigin,
|
|
secondary_span: Option<(Span, String)>,
|
|
values: Option<ValuePairs<'tcx>>,
|
|
terr: &TypeError<'tcx>)
|
|
{
|
|
let expected_found = match values {
|
|
None => None,
|
|
Some(values) => match self.values_str(&values) {
|
|
Some((expected, found)) => Some((expected, found)),
|
|
None => {
|
|
// Derived error. Cancel the emitter.
|
|
self.tcx.sess.diagnostic().cancel(diag);
|
|
return
|
|
}
|
|
}
|
|
};
|
|
|
|
let span = origin.span();
|
|
|
|
if let Some((expected, found)) = expected_found {
|
|
let is_simple_error = if let &TypeError::Sorts(ref values) = terr {
|
|
values.expected.is_primitive() && values.found.is_primitive()
|
|
} else {
|
|
false
|
|
};
|
|
|
|
if !is_simple_error {
|
|
if expected == found {
|
|
if let &TypeError::Sorts(ref values) = terr {
|
|
diag.note_expected_found_extra(
|
|
&"type", &expected, &found,
|
|
&format!(" ({})", values.expected.sort_string(self.tcx)),
|
|
&format!(" ({})", values.found.sort_string(self.tcx)));
|
|
} else {
|
|
diag.note_expected_found(&"type", &expected, &found);
|
|
}
|
|
} else {
|
|
diag.note_expected_found(&"type", &expected, &found);
|
|
}
|
|
}
|
|
}
|
|
|
|
diag.span_label(span, &terr);
|
|
if let Some((sp, msg)) = secondary_span {
|
|
diag.span_label(sp, &msg);
|
|
}
|
|
|
|
self.note_error_origin(diag, &origin);
|
|
self.check_and_note_conflicting_crates(diag, terr, span);
|
|
self.tcx.note_and_explain_type_err(diag, terr, span);
|
|
}
|
|
|
|
pub fn report_and_explain_type_error(&self,
|
|
trace: TypeTrace<'tcx>,
|
|
terr: &TypeError<'tcx>)
|
|
-> DiagnosticBuilder<'tcx>
|
|
{
|
|
// FIXME: do we want to use a different error code for each origin?
|
|
let mut diag = struct_span_err!(
|
|
self.tcx.sess, trace.origin.span(), E0308,
|
|
"{}", trace.origin.as_failure_str()
|
|
);
|
|
self.note_type_err(&mut diag, trace.origin, None, Some(trace.values), terr);
|
|
diag
|
|
}
|
|
|
|
/// Returns a string of the form "expected `{}`, found `{}`".
|
|
fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<(String, String)> {
|
|
match *values {
|
|
infer::Types(ref exp_found) => self.expected_found_str(exp_found),
|
|
infer::TraitRefs(ref exp_found) => self.expected_found_str(exp_found),
|
|
infer::PolyTraitRefs(ref exp_found) => self.expected_found_str(exp_found),
|
|
}
|
|
}
|
|
|
|
fn expected_found_str<T: fmt::Display + TypeFoldable<'tcx>>(
|
|
&self,
|
|
exp_found: &ty::error::ExpectedFound<T>)
|
|
-> Option<(String, String)>
|
|
{
|
|
let exp_found = self.resolve_type_vars_if_possible(exp_found);
|
|
if exp_found.references_error() {
|
|
return None;
|
|
}
|
|
|
|
Some((format!("{}", exp_found.expected), format!("{}", exp_found.found)))
|
|
}
|
|
|
|
fn report_generic_bound_failure(&self,
|
|
origin: SubregionOrigin<'tcx>,
|
|
bound_kind: GenericKind<'tcx>,
|
|
sub: &'tcx Region)
|
|
{
|
|
// FIXME: it would be better to report the first error message
|
|
// with the span of the parameter itself, rather than the span
|
|
// where the error was detected. But that span is not readily
|
|
// accessible.
|
|
|
|
let labeled_user_string = match bound_kind {
|
|
GenericKind::Param(ref p) =>
|
|
format!("the parameter type `{}`", p),
|
|
GenericKind::Projection(ref p) =>
|
|
format!("the associated type `{}`", p),
|
|
};
|
|
|
|
let mut err = match *sub {
|
|
ty::ReFree(ty::FreeRegion {bound_region: ty::BrNamed(..), ..}) => {
|
|
// Does the required lifetime have a nice name we can print?
|
|
let mut err = struct_span_err!(self.tcx.sess,
|
|
origin.span(),
|
|
E0309,
|
|
"{} may not live long enough",
|
|
labeled_user_string);
|
|
err.help(&format!("consider adding an explicit lifetime bound `{}: {}`...",
|
|
bound_kind,
|
|
sub));
|
|
err
|
|
}
|
|
|
|
ty::ReStatic => {
|
|
// Does the required lifetime have a nice name we can print?
|
|
let mut err = struct_span_err!(self.tcx.sess,
|
|
origin.span(),
|
|
E0310,
|
|
"{} may not live long enough",
|
|
labeled_user_string);
|
|
err.help(&format!("consider adding an explicit lifetime \
|
|
bound `{}: 'static`...",
|
|
bound_kind));
|
|
err
|
|
}
|
|
|
|
_ => {
|
|
// If not, be less specific.
|
|
let mut err = struct_span_err!(self.tcx.sess,
|
|
origin.span(),
|
|
E0311,
|
|
"{} may not live long enough",
|
|
labeled_user_string);
|
|
err.help(&format!("consider adding an explicit lifetime bound for `{}`",
|
|
bound_kind));
|
|
self.tcx.note_and_explain_region(
|
|
&mut err,
|
|
&format!("{} must be valid for ", labeled_user_string),
|
|
sub,
|
|
"...");
|
|
err
|
|
}
|
|
};
|
|
|
|
self.note_region_origin(&mut err, &origin);
|
|
err.emit();
|
|
}
|
|
|
|
fn report_concrete_failure(&self,
|
|
origin: SubregionOrigin<'tcx>,
|
|
sub: &'tcx Region,
|
|
sup: &'tcx Region)
|
|
-> DiagnosticBuilder<'tcx> {
|
|
match origin {
|
|
infer::Subtype(trace) => {
|
|
let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
|
|
self.report_and_explain_type_error(trace, &terr)
|
|
}
|
|
infer::Reborrow(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0312,
|
|
"lifetime of reference outlives \
|
|
lifetime of borrowed content...");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"...the reference is valid for ",
|
|
sub,
|
|
"...");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"...but the borrowed content is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::ReborrowUpvar(span, ref upvar_id) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0313,
|
|
"lifetime of borrowed pointer outlives \
|
|
lifetime of captured variable `{}`...",
|
|
self.tcx.local_var_name_str(upvar_id.var_id));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"...the borrowed pointer is valid for ",
|
|
sub,
|
|
"...");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
&format!("...but `{}` is only valid for ",
|
|
self.tcx.local_var_name_str(upvar_id.var_id)),
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::InfStackClosure(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0314,
|
|
"closure outlives stack frame");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"...the closure must be valid for ",
|
|
sub,
|
|
"...");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"...but the closure's stack frame is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::InvokeClosure(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0315,
|
|
"cannot invoke closure outside of its lifetime");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the closure is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::DerefPointer(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0473,
|
|
"dereference of reference outside its lifetime");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the reference is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::FreeVariable(span, id) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0474,
|
|
"captured variable `{}` does not outlive the enclosing closure",
|
|
self.tcx.local_var_name_str(id));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"captured variable is valid for ",
|
|
sup,
|
|
"");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"closure is valid for ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::IndexSlice(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0475,
|
|
"index of slice outside its lifetime");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the slice is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::RelateObjectBound(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0476,
|
|
"lifetime of the source pointer does not outlive \
|
|
lifetime bound of the object type");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"object type is valid for ",
|
|
sub,
|
|
"");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"source pointer is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::RelateParamBound(span, ty) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0477,
|
|
"the type `{}` does not fulfill the required lifetime",
|
|
self.ty_to_string(ty));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"type must outlive ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::RelateRegionParamBound(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0478,
|
|
"lifetime bound not satisfied");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"lifetime parameter instantiated with ",
|
|
sup,
|
|
"");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"but lifetime parameter must outlive ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::RelateDefaultParamBound(span, ty) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0479,
|
|
"the type `{}` (provided as the value of \
|
|
a type parameter) is not valid at this point",
|
|
self.ty_to_string(ty));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"type must outlive ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::CallRcvr(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0480,
|
|
"lifetime of method receiver does not outlive \
|
|
the method call");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the receiver is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::CallArg(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0481,
|
|
"lifetime of function argument does not outlive \
|
|
the function call");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the function argument is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::CallReturn(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0482,
|
|
"lifetime of return value does not outlive \
|
|
the function call");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the return value is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::Operand(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0483,
|
|
"lifetime of operand does not outlive \
|
|
the operation");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the operand is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::AddrOf(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0484,
|
|
"reference is not valid at the time of borrow");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the borrow is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::AutoBorrow(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0485,
|
|
"automatically reference is not valid \
|
|
at the time of borrow");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the automatic borrow is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::ExprTypeIsNotInScope(t, span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0486,
|
|
"type of expression contains references \
|
|
that are not valid during the expression: `{}`",
|
|
self.ty_to_string(t));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"type is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::SafeDestructor(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0487,
|
|
"unsafe use of destructor: destructor might be called \
|
|
while references are dead");
|
|
// FIXME (22171): terms "super/subregion" are suboptimal
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"superregion: ",
|
|
sup,
|
|
"");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"subregion: ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::BindingTypeIsNotValidAtDecl(span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0488,
|
|
"lifetime of variable does not enclose its declaration");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the variable is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
infer::ParameterInScope(_, span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0489,
|
|
"type/lifetime parameter not in scope here");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the parameter is only valid for ",
|
|
sub,
|
|
"");
|
|
err
|
|
}
|
|
infer::DataBorrowed(ty, span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0490,
|
|
"a value of type `{}` is borrowed for too long",
|
|
self.ty_to_string(ty));
|
|
self.tcx.note_and_explain_region(&mut err, "the type is valid for ", sub, "");
|
|
self.tcx.note_and_explain_region(&mut err, "but the borrow lasts for ", sup, "");
|
|
err
|
|
}
|
|
infer::ReferenceOutlivesReferent(ty, span) => {
|
|
let mut err = struct_span_err!(self.tcx.sess, span, E0491,
|
|
"in type `{}`, reference has a longer lifetime \
|
|
than the data it references",
|
|
self.ty_to_string(ty));
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"the pointer is valid for ",
|
|
sub,
|
|
"");
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"but the referenced data is only valid for ",
|
|
sup,
|
|
"");
|
|
err
|
|
}
|
|
}
|
|
}
|
|
|
|
fn report_sub_sup_conflict(&self,
|
|
var_origin: RegionVariableOrigin,
|
|
sub_origin: SubregionOrigin<'tcx>,
|
|
sub_region: &'tcx Region,
|
|
sup_origin: SubregionOrigin<'tcx>,
|
|
sup_region: &'tcx Region) {
|
|
let mut err = self.report_inference_failure(var_origin);
|
|
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"first, the lifetime cannot outlive ",
|
|
sup_region,
|
|
"...");
|
|
|
|
self.note_region_origin(&mut err, &sup_origin);
|
|
|
|
self.tcx.note_and_explain_region(&mut err,
|
|
"but, the lifetime must be valid for ",
|
|
sub_region,
|
|
"...");
|
|
|
|
self.note_region_origin(&mut err, &sub_origin);
|
|
err.emit();
|
|
}
|
|
|
|
fn report_processed_errors(&self,
|
|
origins: &[ProcessedErrorOrigin<'tcx>],
|
|
same_regions: &[SameRegions]) {
|
|
for (i, origin) in origins.iter().enumerate() {
|
|
let mut err = match *origin {
|
|
ProcessedErrorOrigin::VariableFailure(ref var_origin) =>
|
|
self.report_inference_failure(var_origin.clone()),
|
|
ProcessedErrorOrigin::ConcreteFailure(ref sr_origin, sub, sup) =>
|
|
self.report_concrete_failure(sr_origin.clone(), sub, sup),
|
|
};
|
|
|
|
// attach the suggestion to the last such error
|
|
if i == origins.len() - 1 {
|
|
self.give_suggestion(&mut err, same_regions);
|
|
}
|
|
|
|
err.emit();
|
|
}
|
|
}
|
|
|
|
fn give_suggestion(&self, err: &mut DiagnosticBuilder, same_regions: &[SameRegions]) {
|
|
let scope_id = same_regions[0].scope_id;
|
|
let parent = self.tcx.map.get_parent(scope_id);
|
|
let parent_node = self.tcx.map.find(parent);
|
|
let taken = lifetimes_in_scope(self.tcx, scope_id);
|
|
let life_giver = LifeGiver::with_taken(&taken[..]);
|
|
let node_inner = match parent_node {
|
|
Some(ref node) => match *node {
|
|
ast_map::NodeItem(ref item) => {
|
|
match item.node {
|
|
hir::ItemFn(ref fn_decl, unsafety, constness, _, ref gen, _) => {
|
|
Some((fn_decl, gen, unsafety, constness, item.name, item.span))
|
|
},
|
|
_ => None
|
|
}
|
|
}
|
|
ast_map::NodeImplItem(item) => {
|
|
match item.node {
|
|
hir::ImplItemKind::Method(ref sig, _) => {
|
|
Some((&sig.decl,
|
|
&sig.generics,
|
|
sig.unsafety,
|
|
sig.constness,
|
|
item.name,
|
|
item.span))
|
|
}
|
|
_ => None,
|
|
}
|
|
},
|
|
ast_map::NodeTraitItem(item) => {
|
|
match item.node {
|
|
hir::MethodTraitItem(ref sig, Some(_)) => {
|
|
Some((&sig.decl,
|
|
&sig.generics,
|
|
sig.unsafety,
|
|
sig.constness,
|
|
item.name,
|
|
item.span))
|
|
}
|
|
_ => None
|
|
}
|
|
}
|
|
_ => None
|
|
},
|
|
None => None
|
|
};
|
|
let (fn_decl, generics, unsafety, constness, name, span)
|
|
= node_inner.expect("expect item fn");
|
|
let rebuilder = Rebuilder::new(self.tcx, fn_decl, generics, same_regions, &life_giver);
|
|
let (fn_decl, generics) = rebuilder.rebuild();
|
|
self.give_expl_lifetime_param(
|
|
err, &fn_decl, unsafety, constness, name, &generics, span);
|
|
}
|
|
|
|
pub fn issue_32330_warnings(&self, span: Span, issue32330s: &[ty::Issue32330]) {
|
|
for issue32330 in issue32330s {
|
|
match *issue32330 {
|
|
ty::Issue32330::WontChange => { }
|
|
ty::Issue32330::WillChange { fn_def_id, region_name } => {
|
|
self.tcx.sess.add_lint(
|
|
lint::builtin::HR_LIFETIME_IN_ASSOC_TYPE,
|
|
ast::CRATE_NODE_ID,
|
|
span,
|
|
format!("lifetime parameter `{0}` declared on fn `{1}` \
|
|
appears only in the return type, \
|
|
but here is required to be higher-ranked, \
|
|
which means that `{0}` must appear in both \
|
|
argument and return types",
|
|
region_name,
|
|
self.tcx.item_path_str(fn_def_id)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct RebuildPathInfo<'a> {
|
|
path: &'a hir::Path,
|
|
// indexes to insert lifetime on path.lifetimes
|
|
indexes: Vec<u32>,
|
|
// number of lifetimes we expect to see on the type referred by `path`
|
|
// (e.g., expected=1 for struct Foo<'a>)
|
|
expected: u32,
|
|
anon_nums: &'a HashSet<u32>,
|
|
region_names: &'a HashSet<ast::Name>
|
|
}
|
|
|
|
struct Rebuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
|
|
tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
|
fn_decl: &'a hir::FnDecl,
|
|
generics: &'a hir::Generics,
|
|
same_regions: &'a [SameRegions],
|
|
life_giver: &'a LifeGiver,
|
|
cur_anon: Cell<u32>,
|
|
inserted_anons: RefCell<HashSet<u32>>,
|
|
}
|
|
|
|
enum FreshOrKept {
|
|
Fresh,
|
|
Kept
|
|
}
|
|
|
|
impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> {
|
|
fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
|
fn_decl: &'a hir::FnDecl,
|
|
generics: &'a hir::Generics,
|
|
same_regions: &'a [SameRegions],
|
|
life_giver: &'a LifeGiver)
|
|
-> Rebuilder<'a, 'gcx, 'tcx> {
|
|
Rebuilder {
|
|
tcx: tcx,
|
|
fn_decl: fn_decl,
|
|
generics: generics,
|
|
same_regions: same_regions,
|
|
life_giver: life_giver,
|
|
cur_anon: Cell::new(0),
|
|
inserted_anons: RefCell::new(HashSet::new()),
|
|
}
|
|
}
|
|
|
|
fn rebuild(&self) -> (hir::FnDecl, hir::Generics) {
|
|
let mut inputs = self.fn_decl.inputs.clone();
|
|
let mut output = self.fn_decl.output.clone();
|
|
let mut ty_params = self.generics.ty_params.clone();
|
|
let where_clause = self.generics.where_clause.clone();
|
|
let mut kept_lifetimes = HashSet::new();
|
|
for sr in self.same_regions {
|
|
self.cur_anon.set(0);
|
|
self.offset_cur_anon();
|
|
let (anon_nums, region_names) =
|
|
self.extract_anon_nums_and_names(sr);
|
|
let (lifetime, fresh_or_kept) = self.pick_lifetime(®ion_names);
|
|
match fresh_or_kept {
|
|
Kept => { kept_lifetimes.insert(lifetime.name); }
|
|
_ => ()
|
|
}
|
|
inputs = self.rebuild_args_ty(&inputs[..], lifetime,
|
|
&anon_nums, ®ion_names);
|
|
output = self.rebuild_output(&output, lifetime, &anon_nums, ®ion_names);
|
|
ty_params = self.rebuild_ty_params(ty_params, lifetime,
|
|
®ion_names);
|
|
}
|
|
let fresh_lifetimes = self.life_giver.get_generated_lifetimes();
|
|
let all_region_names = self.extract_all_region_names();
|
|
let generics = self.rebuild_generics(self.generics,
|
|
&fresh_lifetimes,
|
|
&kept_lifetimes,
|
|
&all_region_names,
|
|
ty_params,
|
|
where_clause);
|
|
let new_fn_decl = hir::FnDecl {
|
|
inputs: inputs,
|
|
output: output,
|
|
variadic: self.fn_decl.variadic
|
|
};
|
|
(new_fn_decl, generics)
|
|
}
|
|
|
|
fn pick_lifetime(&self,
|
|
region_names: &HashSet<ast::Name>)
|
|
-> (hir::Lifetime, FreshOrKept) {
|
|
if !region_names.is_empty() {
|
|
// It's not necessary to convert the set of region names to a
|
|
// vector of string and then sort them. However, it makes the
|
|
// choice of lifetime name deterministic and thus easier to test.
|
|
let mut names = Vec::new();
|
|
for rn in region_names {
|
|
let lt_name = rn.to_string();
|
|
names.push(lt_name);
|
|
}
|
|
names.sort();
|
|
let name = token::intern(&names[0]);
|
|
return (name_to_dummy_lifetime(name), Kept);
|
|
}
|
|
return (self.life_giver.give_lifetime(), Fresh);
|
|
}
|
|
|
|
fn extract_anon_nums_and_names(&self, same_regions: &SameRegions)
|
|
-> (HashSet<u32>, HashSet<ast::Name>) {
|
|
let mut anon_nums = HashSet::new();
|
|
let mut region_names = HashSet::new();
|
|
for br in &same_regions.regions {
|
|
match *br {
|
|
ty::BrAnon(i) => {
|
|
anon_nums.insert(i);
|
|
}
|
|
ty::BrNamed(_, name, _) => {
|
|
region_names.insert(name);
|
|
}
|
|
_ => ()
|
|
}
|
|
}
|
|
(anon_nums, region_names)
|
|
}
|
|
|
|
fn extract_all_region_names(&self) -> HashSet<ast::Name> {
|
|
let mut all_region_names = HashSet::new();
|
|
for sr in self.same_regions {
|
|
for br in &sr.regions {
|
|
match *br {
|
|
ty::BrNamed(_, name, _) => {
|
|
all_region_names.insert(name);
|
|
}
|
|
_ => ()
|
|
}
|
|
}
|
|
}
|
|
all_region_names
|
|
}
|
|
|
|
fn inc_cur_anon(&self, n: u32) {
|
|
let anon = self.cur_anon.get();
|
|
self.cur_anon.set(anon+n);
|
|
}
|
|
|
|
fn offset_cur_anon(&self) {
|
|
let mut anon = self.cur_anon.get();
|
|
while self.inserted_anons.borrow().contains(&anon) {
|
|
anon += 1;
|
|
}
|
|
self.cur_anon.set(anon);
|
|
}
|
|
|
|
fn inc_and_offset_cur_anon(&self, n: u32) {
|
|
self.inc_cur_anon(n);
|
|
self.offset_cur_anon();
|
|
}
|
|
|
|
fn track_anon(&self, anon: u32) {
|
|
self.inserted_anons.borrow_mut().insert(anon);
|
|
}
|
|
|
|
fn rebuild_ty_params(&self,
|
|
ty_params: hir::HirVec<hir::TyParam>,
|
|
lifetime: hir::Lifetime,
|
|
region_names: &HashSet<ast::Name>)
|
|
-> hir::HirVec<hir::TyParam> {
|
|
ty_params.into_iter().map(|ty_param| {
|
|
let bounds = self.rebuild_ty_param_bounds(ty_param.bounds,
|
|
lifetime,
|
|
region_names);
|
|
hir::TyParam {
|
|
name: ty_param.name,
|
|
id: ty_param.id,
|
|
bounds: bounds,
|
|
default: ty_param.default,
|
|
span: ty_param.span,
|
|
pure_wrt_drop: ty_param.pure_wrt_drop,
|
|
}
|
|
}).collect()
|
|
}
|
|
|
|
fn rebuild_ty_param_bounds(&self,
|
|
ty_param_bounds: hir::TyParamBounds,
|
|
lifetime: hir::Lifetime,
|
|
region_names: &HashSet<ast::Name>)
|
|
-> hir::TyParamBounds {
|
|
ty_param_bounds.iter().map(|tpb| {
|
|
match tpb {
|
|
&hir::RegionTyParamBound(lt) => {
|
|
// FIXME -- it's unclear whether I'm supposed to
|
|
// substitute lifetime here. I suspect we need to
|
|
// be passing down a map.
|
|
hir::RegionTyParamBound(lt)
|
|
}
|
|
&hir::TraitTyParamBound(ref poly_tr, modifier) => {
|
|
let tr = &poly_tr.trait_ref;
|
|
let last_seg = tr.path.segments.last().unwrap();
|
|
let mut insert = Vec::new();
|
|
let lifetimes = last_seg.parameters.lifetimes();
|
|
for (i, lt) in lifetimes.iter().enumerate() {
|
|
if region_names.contains(<.name) {
|
|
insert.push(i as u32);
|
|
}
|
|
}
|
|
let rebuild_info = RebuildPathInfo {
|
|
path: &tr.path,
|
|
indexes: insert,
|
|
expected: lifetimes.len() as u32,
|
|
anon_nums: &HashSet::new(),
|
|
region_names: region_names
|
|
};
|
|
let new_path = self.rebuild_path(rebuild_info, lifetime);
|
|
hir::TraitTyParamBound(hir::PolyTraitRef {
|
|
bound_lifetimes: poly_tr.bound_lifetimes.clone(),
|
|
trait_ref: hir::TraitRef {
|
|
path: new_path,
|
|
ref_id: tr.ref_id,
|
|
},
|
|
span: poly_tr.span,
|
|
}, modifier)
|
|
}
|
|
}
|
|
}).collect()
|
|
}
|
|
|
|
fn rebuild_generics(&self,
|
|
generics: &hir::Generics,
|
|
add: &Vec<hir::Lifetime>,
|
|
keep: &HashSet<ast::Name>,
|
|
remove: &HashSet<ast::Name>,
|
|
ty_params: hir::HirVec<hir::TyParam>,
|
|
where_clause: hir::WhereClause)
|
|
-> hir::Generics {
|
|
let mut lifetimes = Vec::new();
|
|
for lt in add {
|
|
lifetimes.push(hir::LifetimeDef {
|
|
lifetime: *lt,
|
|
bounds: hir::HirVec::new(),
|
|
pure_wrt_drop: false,
|
|
});
|
|
}
|
|
for lt in &generics.lifetimes {
|
|
if keep.contains(<.lifetime.name) ||
|
|
!remove.contains(<.lifetime.name) {
|
|
lifetimes.push((*lt).clone());
|
|
}
|
|
}
|
|
hir::Generics {
|
|
lifetimes: lifetimes.into(),
|
|
ty_params: ty_params,
|
|
where_clause: where_clause,
|
|
span: generics.span,
|
|
}
|
|
}
|
|
|
|
fn rebuild_args_ty(&self,
|
|
inputs: &[hir::Arg],
|
|
lifetime: hir::Lifetime,
|
|
anon_nums: &HashSet<u32>,
|
|
region_names: &HashSet<ast::Name>)
|
|
-> hir::HirVec<hir::Arg> {
|
|
let mut new_inputs = Vec::new();
|
|
for arg in inputs {
|
|
let new_ty = self.rebuild_arg_ty_or_output(&arg.ty, lifetime,
|
|
anon_nums, region_names);
|
|
let possibly_new_arg = hir::Arg {
|
|
ty: new_ty,
|
|
pat: arg.pat.clone(),
|
|
id: arg.id
|
|
};
|
|
new_inputs.push(possibly_new_arg);
|
|
}
|
|
new_inputs.into()
|
|
}
|
|
|
|
fn rebuild_output(&self, ty: &hir::FunctionRetTy,
|
|
lifetime: hir::Lifetime,
|
|
anon_nums: &HashSet<u32>,
|
|
region_names: &HashSet<ast::Name>) -> hir::FunctionRetTy {
|
|
match *ty {
|
|
hir::Return(ref ret_ty) => hir::Return(
|
|
self.rebuild_arg_ty_or_output(&ret_ty, lifetime, anon_nums, region_names)
|
|
),
|
|
hir::DefaultReturn(span) => hir::DefaultReturn(span),
|
|
}
|
|
}
|
|
|
|
fn rebuild_arg_ty_or_output(&self,
|
|
ty: &hir::Ty,
|
|
lifetime: hir::Lifetime,
|
|
anon_nums: &HashSet<u32>,
|
|
region_names: &HashSet<ast::Name>)
|
|
-> P<hir::Ty> {
|
|
let mut new_ty = P(ty.clone());
|
|
let mut ty_queue = vec!(ty);
|
|
while !ty_queue.is_empty() {
|
|
let cur_ty = ty_queue.remove(0);
|
|
match cur_ty.node {
|
|
hir::TyRptr(lt_opt, ref mut_ty) => {
|
|
let rebuild = match lt_opt {
|
|
Some(lt) => region_names.contains(<.name),
|
|
None => {
|
|
let anon = self.cur_anon.get();
|
|
let rebuild = anon_nums.contains(&anon);
|
|
if rebuild {
|
|
self.track_anon(anon);
|
|
}
|
|
self.inc_and_offset_cur_anon(1);
|
|
rebuild
|
|
}
|
|
};
|
|
if rebuild {
|
|
let to = hir::Ty {
|
|
id: cur_ty.id,
|
|
node: hir::TyRptr(Some(lifetime), mut_ty.clone()),
|
|
span: cur_ty.span
|
|
};
|
|
new_ty = self.rebuild_ty(new_ty, P(to));
|
|
}
|
|
ty_queue.push(&mut_ty.ty);
|
|
}
|
|
hir::TyPath(ref maybe_qself, ref path) => {
|
|
match self.tcx.expect_def(cur_ty.id) {
|
|
Def::Enum(did) | Def::TyAlias(did) |
|
|
Def::Struct(did) | Def::Union(did) => {
|
|
let generics = self.tcx.lookup_generics(did);
|
|
|
|
let expected =
|
|
generics.regions.len() as u32;
|
|
let lifetimes =
|
|
path.segments.last().unwrap().parameters.lifetimes();
|
|
let mut insert = Vec::new();
|
|
if lifetimes.is_empty() {
|
|
let anon = self.cur_anon.get();
|
|
for (i, a) in (anon..anon+expected).enumerate() {
|
|
if anon_nums.contains(&a) {
|
|
insert.push(i as u32);
|
|
}
|
|
self.track_anon(a);
|
|
}
|
|
self.inc_and_offset_cur_anon(expected);
|
|
} else {
|
|
for (i, lt) in lifetimes.iter().enumerate() {
|
|
if region_names.contains(<.name) {
|
|
insert.push(i as u32);
|
|
}
|
|
}
|
|
}
|
|
let rebuild_info = RebuildPathInfo {
|
|
path: path,
|
|
indexes: insert,
|
|
expected: expected,
|
|
anon_nums: anon_nums,
|
|
region_names: region_names
|
|
};
|
|
let new_path = self.rebuild_path(rebuild_info, lifetime);
|
|
let qself = maybe_qself.as_ref().map(|qself| {
|
|
hir::QSelf {
|
|
ty: self.rebuild_arg_ty_or_output(&qself.ty, lifetime,
|
|
anon_nums, region_names),
|
|
position: qself.position
|
|
}
|
|
});
|
|
let to = hir::Ty {
|
|
id: cur_ty.id,
|
|
node: hir::TyPath(qself, new_path),
|
|
span: cur_ty.span
|
|
};
|
|
new_ty = self.rebuild_ty(new_ty, P(to));
|
|
}
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
hir::TyPtr(ref mut_ty) => {
|
|
ty_queue.push(&mut_ty.ty);
|
|
}
|
|
hir::TySlice(ref ty) |
|
|
hir::TyArray(ref ty, _) => {
|
|
ty_queue.push(&ty);
|
|
}
|
|
hir::TyTup(ref tys) => ty_queue.extend(tys.iter().map(|ty| &**ty)),
|
|
_ => {}
|
|
}
|
|
}
|
|
new_ty
|
|
}
|
|
|
|
fn rebuild_ty(&self,
|
|
from: P<hir::Ty>,
|
|
to: P<hir::Ty>)
|
|
-> P<hir::Ty> {
|
|
|
|
fn build_to(from: P<hir::Ty>,
|
|
to: &mut Option<P<hir::Ty>>)
|
|
-> P<hir::Ty> {
|
|
if Some(from.id) == to.as_ref().map(|ty| ty.id) {
|
|
return to.take().expect("`to` type found more than once during rebuild");
|
|
}
|
|
from.map(|hir::Ty {id, node, span}| {
|
|
let new_node = match node {
|
|
hir::TyRptr(lifetime, mut_ty) => {
|
|
hir::TyRptr(lifetime, hir::MutTy {
|
|
mutbl: mut_ty.mutbl,
|
|
ty: build_to(mut_ty.ty, to),
|
|
})
|
|
}
|
|
hir::TyPtr(mut_ty) => {
|
|
hir::TyPtr(hir::MutTy {
|
|
mutbl: mut_ty.mutbl,
|
|
ty: build_to(mut_ty.ty, to),
|
|
})
|
|
}
|
|
hir::TySlice(ty) => hir::TySlice(build_to(ty, to)),
|
|
hir::TyArray(ty, e) => {
|
|
hir::TyArray(build_to(ty, to), e)
|
|
}
|
|
hir::TyTup(tys) => {
|
|
hir::TyTup(tys.into_iter().map(|ty| build_to(ty, to)).collect())
|
|
}
|
|
other => other
|
|
};
|
|
hir::Ty { id: id, node: new_node, span: span }
|
|
})
|
|
}
|
|
|
|
build_to(from, &mut Some(to))
|
|
}
|
|
|
|
fn rebuild_path(&self,
|
|
rebuild_info: RebuildPathInfo,
|
|
lifetime: hir::Lifetime)
|
|
-> hir::Path
|
|
{
|
|
let RebuildPathInfo {
|
|
path,
|
|
indexes,
|
|
expected,
|
|
anon_nums,
|
|
region_names,
|
|
} = rebuild_info;
|
|
|
|
let last_seg = path.segments.last().unwrap();
|
|
let new_parameters = match last_seg.parameters {
|
|
hir::ParenthesizedParameters(..) => {
|
|
last_seg.parameters.clone()
|
|
}
|
|
|
|
hir::AngleBracketedParameters(ref data) => {
|
|
let mut new_lts = Vec::new();
|
|
if data.lifetimes.is_empty() {
|
|
// traverse once to see if there's a need to insert lifetime
|
|
let need_insert = (0..expected).any(|i| {
|
|
indexes.contains(&i)
|
|
});
|
|
if need_insert {
|
|
for i in 0..expected {
|
|
if indexes.contains(&i) {
|
|
new_lts.push(lifetime);
|
|
} else {
|
|
new_lts.push(self.life_giver.give_lifetime());
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (i, lt) in data.lifetimes.iter().enumerate() {
|
|
if indexes.contains(&(i as u32)) {
|
|
new_lts.push(lifetime);
|
|
} else {
|
|
new_lts.push(*lt);
|
|
}
|
|
}
|
|
}
|
|
let new_types = data.types.iter().map(|t| {
|
|
self.rebuild_arg_ty_or_output(&t, lifetime, anon_nums, region_names)
|
|
}).collect();
|
|
let new_bindings = data.bindings.iter().map(|b| {
|
|
hir::TypeBinding {
|
|
id: b.id,
|
|
name: b.name,
|
|
ty: self.rebuild_arg_ty_or_output(&b.ty,
|
|
lifetime,
|
|
anon_nums,
|
|
region_names),
|
|
span: b.span
|
|
}
|
|
}).collect();
|
|
hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
|
|
lifetimes: new_lts.into(),
|
|
types: new_types,
|
|
bindings: new_bindings,
|
|
})
|
|
}
|
|
};
|
|
let new_seg = hir::PathSegment {
|
|
name: last_seg.name,
|
|
parameters: new_parameters
|
|
};
|
|
let mut new_segs = Vec::new();
|
|
new_segs.extend_from_slice(path.segments.split_last().unwrap().1);
|
|
new_segs.push(new_seg);
|
|
hir::Path {
|
|
span: path.span,
|
|
global: path.global,
|
|
segments: new_segs.into()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
|
fn give_expl_lifetime_param(&self,
|
|
err: &mut DiagnosticBuilder,
|
|
decl: &hir::FnDecl,
|
|
unsafety: hir::Unsafety,
|
|
constness: hir::Constness,
|
|
name: ast::Name,
|
|
generics: &hir::Generics,
|
|
span: Span) {
|
|
let suggested_fn = pprust::fun_to_string(decl, unsafety, constness, name, generics);
|
|
let msg = format!("consider using an explicit lifetime \
|
|
parameter as shown: {}", suggested_fn);
|
|
err.span_help(span, &msg[..]);
|
|
}
|
|
|
|
fn report_inference_failure(&self,
|
|
var_origin: RegionVariableOrigin)
|
|
-> DiagnosticBuilder<'tcx> {
|
|
let br_string = |br: ty::BoundRegion| {
|
|
let mut s = br.to_string();
|
|
if !s.is_empty() {
|
|
s.push_str(" ");
|
|
}
|
|
s
|
|
};
|
|
let var_description = match var_origin {
|
|
infer::MiscVariable(_) => "".to_string(),
|
|
infer::PatternRegion(_) => " for pattern".to_string(),
|
|
infer::AddrOfRegion(_) => " for borrow expression".to_string(),
|
|
infer::Autoref(_) => " for autoref".to_string(),
|
|
infer::Coercion(_) => " for automatic coercion".to_string(),
|
|
infer::LateBoundRegion(_, br, infer::FnCall) => {
|
|
format!(" for lifetime parameter {}in function call",
|
|
br_string(br))
|
|
}
|
|
infer::LateBoundRegion(_, br, infer::HigherRankedType) => {
|
|
format!(" for lifetime parameter {}in generic type", br_string(br))
|
|
}
|
|
infer::LateBoundRegion(_, br, infer::AssocTypeProjection(type_name)) => {
|
|
format!(" for lifetime parameter {}in trait containing associated type `{}`",
|
|
br_string(br), type_name)
|
|
}
|
|
infer::EarlyBoundRegion(_, name) => {
|
|
format!(" for lifetime parameter `{}`",
|
|
name)
|
|
}
|
|
infer::BoundRegionInCoherence(name) => {
|
|
format!(" for lifetime parameter `{}` in coherence check",
|
|
name)
|
|
}
|
|
infer::UpvarRegion(ref upvar_id, _) => {
|
|
format!(" for capture of `{}` by closure",
|
|
self.tcx.local_var_name_str(upvar_id.var_id).to_string())
|
|
}
|
|
};
|
|
|
|
struct_span_err!(self.tcx.sess, var_origin.span(), E0495,
|
|
"cannot infer an appropriate lifetime{} \
|
|
due to conflicting requirements",
|
|
var_description)
|
|
}
|
|
|
|
fn note_region_origin(&self, err: &mut DiagnosticBuilder, origin: &SubregionOrigin<'tcx>) {
|
|
match *origin {
|
|
infer::Subtype(ref trace) => {
|
|
if let Some((expected, found)) = self.values_str(&trace.values) {
|
|
// FIXME: do we want a "the" here?
|
|
err.span_note(
|
|
trace.origin.span(),
|
|
&format!("...so that {} (expected {}, found {})",
|
|
trace.origin.as_requirement_str(), expected, found));
|
|
} else {
|
|
// FIXME: this really should be handled at some earlier stage. Our
|
|
// handling of region checking when type errors are present is
|
|
// *terrible*.
|
|
|
|
err.span_note(
|
|
trace.origin.span(),
|
|
&format!("...so that {}",
|
|
trace.origin.as_requirement_str()));
|
|
}
|
|
}
|
|
infer::Reborrow(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that reference does not outlive \
|
|
borrowed content");
|
|
}
|
|
infer::ReborrowUpvar(span, ref upvar_id) => {
|
|
err.span_note(
|
|
span,
|
|
&format!(
|
|
"...so that closure can access `{}`",
|
|
self.tcx.local_var_name_str(upvar_id.var_id)
|
|
.to_string()));
|
|
}
|
|
infer::InfStackClosure(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that closure does not outlive its stack frame");
|
|
}
|
|
infer::InvokeClosure(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that closure is not invoked outside its lifetime");
|
|
}
|
|
infer::DerefPointer(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that pointer is not dereferenced \
|
|
outside its lifetime");
|
|
}
|
|
infer::FreeVariable(span, id) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so that captured variable `{}` \
|
|
does not outlive the enclosing closure",
|
|
self.tcx.local_var_name_str(id)));
|
|
}
|
|
infer::IndexSlice(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that slice is not indexed outside the lifetime");
|
|
}
|
|
infer::RelateObjectBound(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that it can be closed over into an object");
|
|
}
|
|
infer::CallRcvr(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that method receiver is valid for the method call");
|
|
}
|
|
infer::CallArg(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that argument is valid for the call");
|
|
}
|
|
infer::CallReturn(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that return value is valid for the call");
|
|
}
|
|
infer::Operand(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that operand is valid for operation");
|
|
}
|
|
infer::AddrOf(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that reference is valid \
|
|
at the time of borrow");
|
|
}
|
|
infer::AutoBorrow(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that auto-reference is valid \
|
|
at the time of borrow");
|
|
}
|
|
infer::ExprTypeIsNotInScope(t, span) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so type `{}` of expression is valid during the \
|
|
expression",
|
|
self.ty_to_string(t)));
|
|
}
|
|
infer::BindingTypeIsNotValidAtDecl(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that variable is valid at time of its declaration");
|
|
}
|
|
infer::ParameterInScope(_, span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that a type/lifetime parameter is in scope here");
|
|
}
|
|
infer::DataBorrowed(ty, span) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so that the type `{}` is not borrowed for too long",
|
|
self.ty_to_string(ty)));
|
|
}
|
|
infer::ReferenceOutlivesReferent(ty, span) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so that the reference type `{}` \
|
|
does not outlive the data it points at",
|
|
self.ty_to_string(ty)));
|
|
}
|
|
infer::RelateParamBound(span, t) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so that the type `{}` \
|
|
will meet its required lifetime bounds",
|
|
self.ty_to_string(t)));
|
|
}
|
|
infer::RelateDefaultParamBound(span, t) => {
|
|
err.span_note(
|
|
span,
|
|
&format!("...so that type parameter \
|
|
instantiated with `{}`, \
|
|
will meet its declared lifetime bounds",
|
|
self.ty_to_string(t)));
|
|
}
|
|
infer::RelateRegionParamBound(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that the declared lifetime parameter bounds \
|
|
are satisfied");
|
|
}
|
|
infer::SafeDestructor(span) => {
|
|
err.span_note(
|
|
span,
|
|
"...so that references are valid when the destructor \
|
|
runs");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn lifetimes_in_scope<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
|
scope_id: ast::NodeId)
|
|
-> Vec<hir::LifetimeDef> {
|
|
let mut taken = Vec::new();
|
|
let parent = tcx.map.get_parent(scope_id);
|
|
let method_id_opt = match tcx.map.find(parent) {
|
|
Some(node) => match node {
|
|
ast_map::NodeItem(item) => match item.node {
|
|
hir::ItemFn(.., ref gen, _) => {
|
|
taken.extend_from_slice(&gen.lifetimes);
|
|
None
|
|
},
|
|
_ => None
|
|
},
|
|
ast_map::NodeImplItem(ii) => {
|
|
match ii.node {
|
|
hir::ImplItemKind::Method(ref sig, _) => {
|
|
taken.extend_from_slice(&sig.generics.lifetimes);
|
|
Some(ii.id)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
_ => None
|
|
},
|
|
None => None
|
|
};
|
|
if let Some(method_id) = method_id_opt {
|
|
let parent = tcx.map.get_parent(method_id);
|
|
if let Some(node) = tcx.map.find(parent) {
|
|
match node {
|
|
ast_map::NodeItem(item) => match item.node {
|
|
hir::ItemImpl(_, _, ref gen, ..) => {
|
|
taken.extend_from_slice(&gen.lifetimes);
|
|
}
|
|
_ => ()
|
|
},
|
|
_ => ()
|
|
}
|
|
}
|
|
}
|
|
return taken;
|
|
}
|
|
|
|
// LifeGiver is responsible for generating fresh lifetime names
|
|
struct LifeGiver {
|
|
taken: HashSet<String>,
|
|
counter: Cell<usize>,
|
|
generated: RefCell<Vec<hir::Lifetime>>,
|
|
}
|
|
|
|
impl LifeGiver {
|
|
fn with_taken(taken: &[hir::LifetimeDef]) -> LifeGiver {
|
|
let mut taken_ = HashSet::new();
|
|
for lt in taken {
|
|
let lt_name = lt.lifetime.name.to_string();
|
|
taken_.insert(lt_name);
|
|
}
|
|
LifeGiver {
|
|
taken: taken_,
|
|
counter: Cell::new(0),
|
|
generated: RefCell::new(Vec::new()),
|
|
}
|
|
}
|
|
|
|
fn inc_counter(&self) {
|
|
let c = self.counter.get();
|
|
self.counter.set(c+1);
|
|
}
|
|
|
|
fn give_lifetime(&self) -> hir::Lifetime {
|
|
let lifetime;
|
|
loop {
|
|
let mut s = String::from("'");
|
|
s.push_str(&num_to_string(self.counter.get()));
|
|
if !self.taken.contains(&s) {
|
|
lifetime = name_to_dummy_lifetime(token::intern(&s[..]));
|
|
self.generated.borrow_mut().push(lifetime);
|
|
break;
|
|
}
|
|
self.inc_counter();
|
|
}
|
|
self.inc_counter();
|
|
return lifetime;
|
|
|
|
// 0 .. 25 generates a .. z, 26 .. 51 generates aa .. zz, and so on
|
|
fn num_to_string(counter: usize) -> String {
|
|
let mut s = String::new();
|
|
let (n, r) = (counter/26 + 1, counter % 26);
|
|
let letter: char = from_u32((r+97) as u32).unwrap();
|
|
for _ in 0..n {
|
|
s.push(letter);
|
|
}
|
|
s
|
|
}
|
|
}
|
|
|
|
fn get_generated_lifetimes(&self) -> Vec<hir::Lifetime> {
|
|
self.generated.borrow().clone()
|
|
}
|
|
}
|
|
|
|
fn name_to_dummy_lifetime(name: ast::Name) -> hir::Lifetime {
|
|
hir::Lifetime { id: ast::DUMMY_NODE_ID,
|
|
span: syntax_pos::DUMMY_SP,
|
|
name: name }
|
|
}
|