// This is used to track which lifetimes have already been defined, and
// which are new in-band lifetimes that need to have a definition created
// for them.
- fn with_in_scope_lifetime_defs<T, F>(&mut self, params: &Vec<GenericParam>, f: F) -> T
+ fn with_in_scope_lifetime_defs<T, F>(&mut self, params: &[GenericParam], f: F) -> T
where
F: FnOnce(&mut LoweringContext) -> T,
{
fn lower_generic_params(
&mut self,
- params: &Vec<GenericParam>,
+ params: &[GenericParam],
add_bounds: &NodeMap<Vec<GenericBound>>,
mut itctx: ImplTraitContext,
) -> hir::HirVec<hir::GenericParam> {
pub fn hash_stable_trait_impls<'a, 'gcx, W, R>(
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>,
- blanket_impls: &Vec<DefId>,
+ blanket_impls: &[DefId],
non_blanket_impls: &HashMap<fast_reject::SimplifiedType, Vec<DefId>, R>)
where W: StableHasherResult,
R: std_hash::BuildHasher,
impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
pub fn report_fulfillment_errors(&self,
- errors: &Vec<FulfillmentError<'tcx>>,
+ errors: &[FulfillmentError<'tcx>],
body_id: Option<hir::BodyId>,
fallback_has_occurred: bool) {
#[derive(Debug)]
) -> DiagnosticBuilder<'tcx> {
let kind = if is_closure { "closure" } else { "function" };
- let args_str = |arguments: &Vec<ArgKind>, other: &Vec<ArgKind>| {
+ let args_str = |arguments: &[ArgKind], other: &[ArgKind]| {
let arg_length = arguments.len();
let distinct = match &other[..] {
&[ArgKind::Tuple(..)] => true,
move_to_places: Vec<MovePlace<'tcx>>
}
-fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &Vec<MoveError<'tcx>>) {
+fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &[MoveError<'tcx>]) {
let grouped_errors = group_errors_with_same_origin(errors);
for error in &grouped_errors {
let mut err = report_cannot_move_out_of(bccx, error.move_from.clone());
}
}
-fn group_errors_with_same_origin<'tcx>(errors: &Vec<MoveError<'tcx>>)
+fn group_errors_with_same_origin<'tcx>(errors: &[MoveError<'tcx>])
-> Vec<GroupedMoveErrors<'tcx>> {
let mut grouped_errors = Vec::new();
for error in errors {
// Runs `f` on every output file path and returns the first non-None result, or None if `f`
// returns None for every file path.
-fn check_output<F, T>(output_paths: &Vec<PathBuf>, f: F) -> Option<T>
+fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
where
F: Fn(&PathBuf) -> Option<T>,
{
None
}
-pub fn output_contains_path(output_paths: &Vec<PathBuf>, input_path: &PathBuf) -> bool {
+pub fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
let input_path = input_path.canonicalize().ok();
if input_path.is_none() {
return false;
check_output(output_paths, check).is_some()
}
-pub fn output_conflicts_with_dir(output_paths: &
Vec<PathBuf>) -> Option<PathBuf> {
+pub fn output_conflicts_with_dir(output_paths: &
[PathBuf]) -> Option<PathBuf> {
let check = |output_path: &PathBuf| {
if output_path.is_dir() {
Some(output_path.clone())
check_output(output_paths, check)
}
-fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &Vec<PathBuf>) {
+fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &[PathBuf]) {
// Write out dependency rules to the dep-info file if requested
if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
return;
pub traces: Vec<trace::Rec>,
}
-fn total_duration(traces: &Vec<trace::Rec>) -> Duration {
+fn total_duration(traces: &[trace::Rec]) -> Duration {
let mut sum : Duration = Duration::new(0,0);
for t in traces.iter() { sum += t.dur_total; }
return sum
else { (format!("< 0.1%", ), css) }
}
-fn total_duration(traces: &Vec<Rec>) -> Duration {
+fn total_duration(traces: &[Rec]) -> Duration {
let mut sum : Duration = Duration::new(0,0);
for t in traces.iter() {
sum += t.dur_total;
to_nanos(nom) as f64 / to_nanos(den) as f64
}
-fn write_traces_rec(file: &mut File, traces: &Vec<Rec>, total: Duration, depth: usize) {
+fn write_traces_rec(file: &mut File, traces: &[Rec], total: Duration, depth: usize) {
for t in traces {
let (eff_text, eff_css_classes) = html_of_effect(&t.effect);
let (dur_text, dur_css_classes) = html_of_duration(&t.start, &t.dur_total);
}
}
-fn compute_counts_rec(counts: &mut HashMap<String,QueryMetric>, traces: &Vec<Rec>) {
+fn compute_counts_rec(counts: &mut HashMap<String,QueryMetric>, traces: &[Rec]) {
for t in traces.iter() {
match t.effect {
Effect::TimeBegin(ref msg) => {
}
}
-pub fn write_traces(html_file: &mut File, counts_file: &mut File, traces: &Vec<Rec>) {
+pub fn write_traces(html_file: &mut File, counts_file: &mut File, traces: &[Rec]) {
let capacity = traces.iter().fold(0, |acc, t| acc + 1 + t.extent.len());
let mut counts : HashMap<String, QueryMetric> = HashMap::with_capacity(capacity);
compute_counts_rec(&mut counts, traces);
max
}
- fn get_max_line_num(&mut self, span: &MultiSpan, children: &Vec<SubDiagnostic>) -> usize {
+ fn get_max_line_num(&mut self, span: &MultiSpan, children: &[SubDiagnostic]) -> usize {
let mut max = 0;
let primary = self.get_multispan_max_line_num(span);
fn emit_message_default(&mut self,
msp: &MultiSpan,
- msg: &Vec<(String, Style)>,
+ msg: &[(String, Style)],
code: &Option<DiagnosticId>,
level: &Level,
max_line_num_len: usize,
fn emit_messages_default(&mut self,
level: &Level,
- message: &Vec<(String, Style)>,
+ message: &[(String, Style)],
code: &Option<DiagnosticId>,
span: &MultiSpan,
- children: &Vec<SubDiagnostic>,
+ children: &[SubDiagnostic],
suggestions: &[CodeSuggestion]) {
let max_line_num_len = if self.ui_testing {
ANONYMIZED_LINE_NUM.len()
num_overlap(a1.start_col, a1.end_col + padding, a2.start_col, a2.end_col, false)
}
-fn emit_to_destination(rendered_buffer: &Vec<Vec<StyledString>>,
+fn emit_to_destination(rendered_buffer: &[Vec<StyledString>],
lvl: &Level,
dst: &mut Destination,
short_message: bool)
impl<'w> FactWriter<'w> {
fn write_facts_to_path<T>(
&self,
- rows: &Vec<T>,
+ rows: &[T],
file_name: &str,
) -> Result<(), Box<dyn Error>>
where
self.eval_fn_call(
instance,
Some((Place::undef(), target)),
- &vec![valty],
+ &[valty],
span,
fn_sig,
)
// indices is an integer interval. If all checks pass do the replacent.
// items are Vec<Option<LocalUse, index in source array, source place for init local>>
fn check_and_patch<'tcx>(candidate: Location,
- items: &Vec<Option<(&LocalUse, u32, &Place<'tcx>)>>,
+ items: &[Option<(&LocalUse, u32, &Place<'tcx>)>],
opt_size: Option<u64>,
patch: &mut MirPatch<'tcx>,
dst_place: &Place<'tcx>) {
}
}
- fn check_late_bound_lifetime_defs(&self, params: &Vec<GenericParam>) {
+ fn check_late_bound_lifetime_defs(&self, params: &[GenericParam]) {
// Check only lifetime parameters are present and that the lifetime
// parameters that are present have no bounds.
let non_lt_param_spans: Vec<_> = params.iter().filter_map(|param| match param.kind {
}
};
let ident = Ident::new(Symbol::intern(name), span);
- self.lookup_typo_candidate(&vec![ident], MacroNS, is_macro, span)
+ self.lookup_typo_candidate(&[ident], MacroNS, is_macro, span)
});
if let Some(suggestion) = suggestion {
for it in &implementor.inner_impl().items {
if let clean::TypedefItem(ref tydef, _) = it.inner {
write!(w, "<span class=\"where fmt-newline\"> ")?;
- assoc_type(w, it, &vec![], Some(&tydef.type_), AssocItemLink::Anchor(None))?;
+ assoc_type(w, it, &[], Some(&tydef.type_), AssocItemLink::Anchor(None))?;
write!(w, ";</span>")?;
}
}
}
fn assoc_type<W: fmt::Write>(w: &mut W, it: &clean::Item,
- bounds: &Vec<clean::GenericBound>,
+ bounds: &[clean::GenericBound],
default: Option<&clean::Type>,
link: AssocItemLink) -> fmt::Result {
write!(w, "type <a href='{}' class=\"type\">{}</a>",
for it in &impl_.items {
if let clean::TypedefItem(ref tydef, _) = it.inner {
out.push_str("<span class=\"where fmt-newline\"> ");
- assoc_type(&mut out, it, &vec![],
+ assoc_type(&mut out, it, &[],
Some(&tydef.type_),
AssocItemLink::GotoSource(t_did, &FxHashSet()))?;
out.push_str(";</span>");
unsafety: ast::Unsafety,
decl: &ast::FnDecl,
name: Option<ast::Ident>,
- generic_params: &Vec<ast::GenericParam>)
+ generic_params: &[ast::GenericParam])
-> io::Result<()> {
self.ibox(INDENT_UNIT)?;
if !generic_params.is_empty() {
projects / rust.git / commitdiff