Commit b5bd31ec6db6a249311888a93fc176f06dcb6aa6 | rust

CODE_OF_CONDUCT.md+1-38

...	...	@@ -1,40 +1,3 @@
1	1	# The Rust Code of Conduct
2	2
3		A version of this document [can be found online](https://www.rust-lang.org/conduct.html).
4
5		## Conduct
6
7		Contact: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org)
8
9		* We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
10		* On IRC, please avoid using overtly sexual nicknames or other nicknames that might detract from a friendly, safe and welcoming environment for all.
11		* Please be kind and courteous. There's no need to be mean or rude.
12		* Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
13		* Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
14		* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term "harassment" as including the definition in the <a href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>; if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups.
15		* Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the [Rust moderation team][mod_team] immediately. Whether you're a regular contributor or a newcomer, we care about making this community a safe place for you and we've got your back.
16		* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
17
18		## Moderation
19
20
21		These are the policies for upholding our community's standards of conduct. If you feel that a thread needs moderation, please contact the [Rust moderation team][mod_team].
22
23		1. Remarks that violate the Rust standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner.)
24		2. Remarks that moderators find inappropriate, whether listed in the code of conduct or not, are also not allowed.
25		3. Moderators will first respond to such remarks with a warning.
26		4. If the warning is unheeded, the user will be "kicked," i.e., kicked out of the communication channel to cool off.
27		5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded.
28		6. Moderators may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology.
29		7. If a moderator bans someone and you think it was unjustified, please take it up with that moderator, or with a different moderator, in private. Complaints about bans in-channel are not allowed.
30		8. Moderators are held to a higher standard than other community members. If a moderator creates an inappropriate situation, they should expect less leeway than others.
31
32		In the Rust community we strive to go the extra step to look out for each other. Don't just aim to be technically unimpeachable, try to be your best self. In particular, avoid flirting with offensive or sensitive issues, particularly if they're off-topic; this all too often leads to unnecessary fights, hurt feelings, and damaged trust; worse, it can drive people away from the community entirely.
33
34		And if someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize. Even if you feel you were misinterpreted or unfairly accused, chances are good there was something you could've communicated better — remember that it's your responsibility to make your fellow Rustaceans comfortable. Everyone wants to get along and we are all here first and foremost because we want to talk about cool technology. You will find that people will be eager to assume good intent and forgive as long as you earn their trust.
35
36		The enforcement policies listed above apply to all official Rust venues; including all communication channels (Rust Discord server, Rust Zulip server); GitHub repositories under rust-lang, rust-lang-nursery, and rust-lang-deprecated; and all forums under rust-lang.org (users.rust-lang.org, internals.rust-lang.org). For other projects adopting the Rust Code of Conduct, please contact the maintainers of those projects for enforcement. If you wish to use this code of conduct for your own project, consider explicitly mentioning your moderation policy or making a copy with your own moderation policy so as to avoid confusion.
37
38		Adapted from the [Node.js Policy on Trolling](https://blog.izs.me/2012/08/policy-on-trolling) as well as the [Contributor Covenant v1.3.0](https://www.contributor-covenant.org/version/1/3/0/).
39
40		[mod_team]: https://www.rust-lang.org/team.html#Moderation-team
	3	The Code of Conduct for this repository [can be found online](https://www.rust-lang.org/conduct.html).

src/librustc/dep_graph/graph.rs-9

...	...	@@ -9,7 +9,6 @@ use std::hash::Hash;
9	9	use std::collections::hash_map::Entry;
10	10	use std::mem;
11	11	use crate::ty::{self, TyCtxt};
12		use crate::util::common::{ProfileQueriesMsg, profq_msg};
13	12	use parking_lot::{Mutex, Condvar};
14	13
15	14	use crate::ich::{StableHashingContext, StableHashingContextProvider, Fingerprint};
...	...	@@ -256,10 +255,6 @@ impl DepGraph {
256	255	// - we can get an idea of the runtime cost.
257	256	let mut hcx = cx.get_stable_hashing_context();
258	257
259		if cfg!(debug_assertions) {
260		profq_msg(hcx.sess(), ProfileQueriesMsg::TaskBegin(key.clone()))
261		};
262
263	258	let result = if no_tcx {
264	259	task(cx, arg)
265	260	} else {
...	...	@@ -275,10 +270,6 @@ impl DepGraph {
275	270	})
276	271	};
277	272
278		if cfg!(debug_assertions) {
279		profq_msg(hcx.sess(), ProfileQueriesMsg::TaskEnd)
280		};
281
282	273	let current_fingerprint = hash_result(&mut hcx, &result);
283	274
284	275	let dep_node_index = finish_task_and_alloc_depnode(

src/librustc/error_codes.rs+11-7

...	...	@@ -466,7 +466,6 @@ fn main() {
466	466	```
467	467	"##,
468	468
469
470	469	E0139: r##"
471	470	#### Note: this error code is no longer emitted by the compiler.
472	471
...	...	@@ -1562,7 +1561,9 @@ fn transmute_lifetime<'a, T>(t: &'a (T,)) -> &'a T {
1562	1561	"##,
1563	1562
1564	1563	E0496: r##"
1565		A lifetime name is shadowing another lifetime name. Erroneous code example:
	1564	A lifetime name is shadowing another lifetime name.
	1565
	1566	Erroneous code example:
1566	1567
1567	1568	```compile_fail,E0496
1568	1569	struct Foo<'a> {
...	...	@@ -1594,8 +1595,11 @@ fn main() {
1594	1595	"##,
1595	1596
1596	1597	E0497: r##"
1597		A stability attribute was used outside of the standard library. Erroneous code
1598		example:
	1598	#### Note: this error code is no longer emitted by the compiler.
	1599
	1600	A stability attribute was used outside of the standard library.
	1601
	1602	Erroneous code example:
1599	1603
1600	1604	```compile_fail
1601	1605	#[stable] // error: stability attributes may not be used outside of the
...	...	@@ -2125,7 +2129,7 @@ rejected in your own crates.
2125	2129	// E0272, // on_unimplemented #0
2126	2130	// E0273, // on_unimplemented #1
2127	2131	// E0274, // on_unimplemented #2
2128		E0278, // requirement is not satisfied
	2132	// E0278, // requirement is not satisfied
2129	2133	E0279, // requirement is not satisfied
2130	2134	E0280, // requirement is not satisfied
2131	2135	// E0285, // overflow evaluation builtin bounds
...	...	@@ -2165,10 +2169,10 @@ rejected in your own crates.
2165	2169	E0687, // in-band lifetimes cannot be used in `fn`/`Fn` syntax
2166	2170	E0688, // in-band lifetimes cannot be mixed with explicit lifetime binders
2167	2171	E0697, // closures cannot be static
2168		E0707, // multiple elided lifetimes used in arguments of `async fn`
	2172	// E0707, // multiple elided lifetimes used in arguments of `async fn`
2169	2173	E0708, // `async` non-`move` closures with parameters are not currently
2170	2174	// supported
2171		E0709, // multiple different lifetimes used in arguments of `async fn`
	2175	// E0709, // multiple different lifetimes used in arguments of `async fn`
2172	2176	E0710, // an unknown tool name found in scoped lint
2173	2177	E0711, // a feature has been declared with conflicting stability attributes
2174	2178	// E0702, // replaced with a generic attribute input check

src/librustc/hir/mod.rs+13

...	...	@@ -1548,6 +1548,19 @@ impl Expr {
1548	1548	}
1549	1549	}
1550	1550	}
	1551
	1552	/// If `Self.kind` is `ExprKind::DropTemps(expr)`, drill down until we get a non-`DropTemps`
	1553	/// `Expr`. This is used in suggestions to ignore this `ExprKind` as it is semantically
	1554	/// silent, only signaling the ownership system. By doing this, suggestions that check the
	1555	/// `ExprKind` of any given `Expr` for presentation don't have to care about `DropTemps`
	1556	/// beyond remembering to call this function before doing analysis on it.
	1557	pub fn peel_drop_temps(&self) -> &Self {
	1558	let mut expr = self;
	1559	while let ExprKind::DropTemps(inner) = &expr.kind {
	1560	expr = inner;
	1561	}
	1562	expr
	1563	}
1551	1564	}
1552	1565
1553	1566	impl fmt::Debug for Expr {

src/librustc/lint/builtin.rs+6

...	...	@@ -368,6 +368,12 @@ pub mod parser {
368	368	Allow,
369	369	"possible meta-variable misuse at macro definition"
370	370	}
	371
	372	declare_lint! {
	373	pub INCOMPLETE_INCLUDE,
	374	Deny,
	375	"trailing content in included file"
	376	}
371	377	}
372	378
373	379	declare_lint! {

src/librustc/lint/mod.rs+2

...	...	@@ -28,6 +28,7 @@ use crate::hir::intravisit;
28	28	use crate::hir;
29	29	use crate::lint::builtin::BuiltinLintDiagnostics;
30	30	use crate::lint::builtin::parser::{ILL_FORMED_ATTRIBUTE_INPUT, META_VARIABLE_MISUSE};
	31	use crate::lint::builtin::parser::INCOMPLETE_INCLUDE;
31	32	use crate::session::{Session, DiagnosticMessageId};
32	33	use crate::ty::TyCtxt;
33	34	use crate::ty::query::Providers;
...	...	@@ -83,6 +84,7 @@ impl Lint {
83	84	match lint_id {
84	85	BufferedEarlyLintId::IllFormedAttributeInput => ILL_FORMED_ATTRIBUTE_INPUT,
85	86	BufferedEarlyLintId::MetaVariableMisuse => META_VARIABLE_MISUSE,
	87	BufferedEarlyLintId::IncompleteInclude => INCOMPLETE_INCLUDE,
86	88	}
87	89	}
88	90

src/librustc/session/config.rs-4

...	...	@@ -1316,10 +1316,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
1316	1316	"dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv)"),
1317	1317	query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
1318	1318	"enable queries of the dependency graph for regression testing"),
1319		profile_queries: bool = (false, parse_bool, [UNTRACKED],
1320		"trace and profile the queries of the incremental compilation framework"),
1321		profile_queries_and_keys: bool = (false, parse_bool, [UNTRACKED],
1322		"trace and profile the queries and keys of the incremental compilation framework"),
1323	1319	no_analysis: bool = (false, parse_bool, [UNTRACKED],
1324	1320	"parse and expand the source, but run no analysis"),
1325	1321	extra_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],

src/librustc/session/mod.rs+1-13

...	...	@@ -11,7 +11,6 @@ use crate::session::config::{OutputType, PrintRequest, SwitchWithOptPath};
11	11	use crate::session::search_paths::{PathKind, SearchPath};
12	12	use crate::util::nodemap::{FxHashMap, FxHashSet};
13	13	use crate::util::common::{duration_to_secs_str, ErrorReported};
14		use crate::util::common::ProfileQueriesMsg;
15	14
16	15	use rustc_data_structures::base_n;
17	16	use rustc_data_structures::sync::{
...	...	@@ -46,7 +45,7 @@ use std::fmt;
46	45	use std::io::Write;
47	46	use std::path::PathBuf;
48	47	use std::time::Duration;
49		use std::sync::{Arc, mpsc};
	48	use std::sync::Arc;
50	49
51	50	mod code_stats;
52	51	pub mod config;
...	...	@@ -125,9 +124,6 @@ pub struct Session {
125	124	/// `-Zquery-dep-graph` is specified.
126	125	pub cgu_reuse_tracker: CguReuseTracker,
127	126
128		/// Used by `-Z profile-queries` in `util::common`.
129		pub profile_channel: Lock<Option<mpsc::Sender<ProfileQueriesMsg>>>,
130
131	127	/// Used by `-Z self-profile`.
132	128	pub prof: SelfProfilerRef,
133	129
...	...	@@ -509,13 +505,6 @@ impl Session {
509	505	pub fn time_extended(&self) -> bool {
510	506	self.opts.debugging_opts.time_passes
511	507	}
512		pub fn profile_queries(&self) -> bool {
513		self.opts.debugging_opts.profile_queries
514		\|\| self.opts.debugging_opts.profile_queries_and_keys
515		}
516		pub fn profile_queries_and_keys(&self) -> bool {
517		self.opts.debugging_opts.profile_queries_and_keys
518		}
519	508	pub fn instrument_mcount(&self) -> bool {
520	509	self.opts.debugging_opts.instrument_mcount
521	510	}
...	...	@@ -1234,7 +1223,6 @@ fn build_session_(
1234	1223	incr_comp_session: OneThread::new(RefCell::new(IncrCompSession::NotInitialized)),
1235	1224	cgu_reuse_tracker,
1236	1225	prof: SelfProfilerRef::new(self_profiler),
1237		profile_channel: Lock::new(None),
1238	1226	perf_stats: PerfStats {
1239	1227	symbol_hash_time: Lock::new(Duration::from_secs(0)),
1240	1228	decode_def_path_tables_time: Lock::new(Duration::from_secs(0)),

src/librustc/ty/query/on_disk_cache.rs+1-1

...	...	@@ -1075,7 +1075,7 @@ where
1075	1075	let desc = &format!("encode_query_results for {}",
1076	1076	::std::any::type_name::<Q>());
1077	1077
1078		time_ext(tcx.sess.time_extended(), Some(tcx.sess), desc, \|\| {
	1078	time_ext(tcx.sess.time_extended(), desc, \|\| {
1079	1079	let shards = Q::query_cache(tcx).lock_shards();
1080	1080	assert!(shards.iter().all(\|shard\| shard.active.is_empty()));
1081	1081	for (key, entry) in shards.iter().flat_map(\|shard\| shard.results.iter()) {

src/librustc/ty/query/plumbing.rs-49

...	...	@@ -9,8 +9,6 @@ use crate::ty::query::Query;
9	9	use crate::ty::query::config::{QueryConfig, QueryDescription};
10	10	use crate::ty::query::job::{QueryJob, QueryResult, QueryInfo};
11	11
12		use crate::util::common::{profq_msg, ProfileQueriesMsg, QueryMsg};
13
14	12	use errors::DiagnosticBuilder;
15	13	use errors::Level;
16	14	use errors::Diagnostic;
...	...	@@ -62,33 +60,6 @@ impl<'tcx, M: QueryConfig<'tcx>> Default for QueryCache<'tcx, M> {
62	60	}
63	61	}
64	62
65		// If enabled, sends a message to the profile-queries thread.
66		macro_rules! profq_msg {
67		($tcx:expr, $msg:expr) => {
68		if cfg!(debug_assertions) {
69		if $tcx.sess.profile_queries() {
70		profq_msg($tcx.sess, $msg)
71		}
72		}
73		}
74		}
75
76		// If enabled, formats a key using its debug string, which can be
77		// expensive to compute (in terms of time).
78		macro_rules! profq_query_msg {
79		($query:expr, $tcx:expr, $key:expr) => {{
80		let msg = if cfg!(debug_assertions) {
81		if $tcx.sess.profile_queries_and_keys() {
82		Some(format!("{:?}", $key))
83		} else { None }
84		} else { None };
85		QueryMsg {
86		query: $query,
87		msg,
88		}
89		}}
90		}
91
92	63	/// A type representing the responsibility to execute the job in the `job` field.
93	64	/// This will poison the relevant query if dropped.
94	65	pub(super) struct JobOwner<'a, 'tcx, Q: QueryDescription<'tcx>> {
...	...	@@ -111,7 +82,6 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
111	82	loop {
112	83	let mut lock = cache.get_shard_by_value(key).lock();
113	84	if let Some(value) = lock.results.get(key) {
114		profq_msg!(tcx, ProfileQueriesMsg::CacheHit);
115	85	tcx.prof.query_cache_hit(Q::NAME);
116	86	let result = (value.value.clone(), value.index);
117	87	#[cfg(debug_assertions)]
...	...	@@ -358,13 +328,6 @@ impl<'tcx> TyCtxt<'tcx> {
358	328	key,
359	329	span);
360	330
361		profq_msg!(self,
362		ProfileQueriesMsg::QueryBegin(
363		span.data(),
364		profq_query_msg!(Q::NAME.as_str(), self, key),
365		)
366		);
367
368	331	let job = match JobOwner::try_get(self, span, &key) {
369	332	TryGetJob::NotYetStarted(job) => job,
370	333	TryGetJob::Cycle(result) => return result,
...	...	@@ -383,7 +346,6 @@ impl<'tcx> TyCtxt<'tcx> {
383	346
384	347	if Q::ANON {
385	348
386		profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
387	349	let prof_timer = self.prof.query_provider(Q::NAME);
388	350
389	351	let ((result, dep_node_index), diagnostics) = with_diagnostics(\|diagnostics\| {
...	...	@@ -395,7 +357,6 @@ impl<'tcx> TyCtxt<'tcx> {
395	357	});
396	358
397	359	drop(prof_timer);
398		profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
399	360
400	361	self.dep_graph.read_index(dep_node_index);
401	362
...	...	@@ -468,7 +429,6 @@ impl<'tcx> TyCtxt<'tcx> {
468	429	};
469	430
470	431	let result = if let Some(result) = result {
471		profq_msg!(self, ProfileQueriesMsg::CacheHit);
472	432	result
473	433	} else {
474	434	// We could not load a result from the on-disk cache, so
...	...	@@ -542,7 +502,6 @@ impl<'tcx> TyCtxt<'tcx> {
542	502	- dep-node: {:?}",
543	503	key, dep_node);
544	504
545		profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
546	505	let prof_timer = self.prof.query_provider(Q::NAME);
547	506
548	507	let ((result, dep_node_index), diagnostics) = with_diagnostics(\|diagnostics\| {
...	...	@@ -564,7 +523,6 @@ impl<'tcx> TyCtxt<'tcx> {
564	523	});
565	524
566	525	drop(prof_timer);
567		profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
568	526
569	527	if unlikely!(!diagnostics.is_empty()) {
570	528	if dep_node.kind != crate::dep_graph::DepKind::Null {
...	...	@@ -606,19 +564,12 @@ impl<'tcx> TyCtxt<'tcx> {
606	564
607	565	let _ = self.get_query::<Q>(DUMMY_SP, key);
608	566	} else {
609		profq_msg!(self, ProfileQueriesMsg::CacheHit);
610	567	self.prof.query_cache_hit(Q::NAME);
611	568	}
612	569	}
613	570
614	571	#[allow(dead_code)]
615	572	fn force_query<Q: QueryDescription<'tcx>>(self, key: Q::Key, span: Span, dep_node: DepNode) {
616		profq_msg!(
617		self,
618		ProfileQueriesMsg::QueryBegin(span.data(),
619		profq_query_msg!(Q::NAME.as_str(), self, key))
620		);
621
622	573	// We may be concurrently trying both execute and force a query.
623	574	// Ensure that only one of them runs the query.
624	575	let job = match JobOwner::try_get(self, span, &key) {

src/librustc/util/common.rs+2-73

...	...	@@ -6,11 +6,8 @@ use std::cell::Cell;
6	6	use std::fmt::Debug;
7	7	use std::time::{Duration, Instant};
8	8
9		use std::sync::mpsc::{Sender};
10		use syntax_pos::{SpanData};
11	9	use syntax::symbol::{Symbol, sym};
12	10	use rustc_macros::HashStable;
13		use crate::dep_graph::{DepNode};
14	11	use crate::session::Session;
15	12
16	13	#[cfg(test)]
...	...	@@ -26,17 +23,6 @@ pub struct ErrorReported;
26	23
27	24	thread_local!(static TIME_DEPTH: Cell<usize> = Cell::new(0));
28	25
29		/// Parameters to the `Dump` variant of type `ProfileQueriesMsg`.
30		#[derive(Clone,Debug)]
31		pub struct ProfQDumpParams {
32		/// A base path for the files we will dump.
33		pub path:String,
34		/// To ensure that the compiler waits for us to finish our dumps.
35		pub ack:Sender<()>,
36		/// Toggle dumping a log file with every `ProfileQueriesMsg`.
37		pub dump_profq_msg_log:bool,
38		}
39
40	26	#[allow(nonstandard_style)]
41	27	#[derive(Clone, Debug, PartialEq, Eq)]
42	28	pub struct QueryMsg {
...	...	@@ -44,53 +30,6 @@ pub struct QueryMsg {
44	30	pub msg: Option<String>,
45	31	}
46	32
47		/// A sequence of these messages induce a trace of query-based incremental compilation.
48		// FIXME(matthewhammer): Determine whether we should include cycle detection here or not.
49		#[derive(Clone,Debug)]
50		pub enum ProfileQueriesMsg {
51		/// Begin a timed pass.
52		TimeBegin(String),
53		/// End a timed pass.
54		TimeEnd,
55		/// Begin a task (see `dep_graph::graph::with_task`).
56		TaskBegin(DepNode),
57		/// End a task.
58		TaskEnd,
59		/// Begin a new query.
60		/// Cannot use `Span` because queries are sent to other thread.
61		QueryBegin(SpanData, QueryMsg),
62		/// Query is satisfied by using an already-known value for the given key.
63		CacheHit,
64		/// Query requires running a provider; providers may nest, permitting queries to nest.
65		ProviderBegin,
66		/// Query is satisfied by a provider terminating with a value.
67		ProviderEnd,
68		/// Dump a record of the queries to the given path.
69		Dump(ProfQDumpParams),
70		/// Halt the profiling/monitoring background thread.
71		Halt
72		}
73
74		/// If enabled, send a message to the profile-queries thread.
75		pub fn profq_msg(sess: &Session, msg: ProfileQueriesMsg) {
76		if let Some(s) = sess.profile_channel.borrow().as_ref() {
77		s.send(msg).unwrap()
78		} else {
79		// Do nothing.
80		}
81		}
82
83		/// Set channel for profile queries channel.
84		pub fn profq_set_chan(sess: &Session, s: Sender<ProfileQueriesMsg>) -> bool {
85		let mut channel = sess.profile_channel.borrow_mut();
86		if channel.is_none() {
87		*channel = Some(s);
88		true
89		} else {
90		false
91		}
92		}
93
94	33	/// Read the current depth of `time()` calls. This is used to
95	34	/// encourage indentation across threads.
96	35	pub fn time_depth() -> usize {
...	...	@@ -107,10 +46,10 @@ pub fn set_time_depth(depth: usize) {
107	46	pub fn time<T, F>(sess: &Session, what: &str, f: F) -> T where
108	47	F: FnOnce() -> T,
109	48	{
110		time_ext(sess.time_passes(), Some(sess), what, f)
	49	time_ext(sess.time_passes(), what, f)
111	50	}
112	51
113		pub fn time_ext<T, F>(do_it: bool, sess: Option<&Session>, what: &str, f: F) -> T where
	52	pub fn time_ext<T, F>(do_it: bool, what: &str, f: F) -> T where
114	53	F: FnOnce() -> T,
115	54	{
116	55	if !do_it { return f(); }
...	...	@@ -121,19 +60,9 @@ pub fn time_ext<T, F>(do_it: bool, sess: Option<&Session>, what: &str, f: F) ->
121	60	r
122	61	});
123	62
124		if let Some(sess) = sess {
125		if cfg!(debug_assertions) {
126		profq_msg(sess, ProfileQueriesMsg::TimeBegin(what.to_string()))
127		}
128		}
129	63	let start = Instant::now();
130	64	let rv = f();
131	65	let dur = start.elapsed();
132		if let Some(sess) = sess {
133		if cfg!(debug_assertions) {
134		profq_msg(sess, ProfileQueriesMsg::TimeEnd)
135		}
136		}
137	66
138	67	print_time_passes_entry(true, what, dur);
139	68

src/librustc_codegen_llvm/back/lto.rs+3-3

...	...	@@ -116,7 +116,7 @@ fn prepare_lto(cgcx: &CodegenContext<LlvmCodegenBackend>,
116	116	info!("adding bytecode {}", name);
117	117	let bc_encoded = data.data();
118	118
119		let (bc, id) = time_ext(cgcx.time_passes, None, &format!("decode {}", name), \|\| {
	119	let (bc, id) = time_ext(cgcx.time_passes, &format!("decode {}", name), \|\| {
120	120	match DecodedBytecode::new(bc_encoded) {
121	121	Ok(b) => Ok((b.bytecode(), b.identifier().to_string())),
122	122	Err(e) => Err(diag_handler.fatal(&e)),
...	...	@@ -295,7 +295,7 @@ fn fat_lto(cgcx: &CodegenContext<LlvmCodegenBackend>,
295	295	for (bc_decoded, name) in serialized_modules {
296	296	let _timer = cgcx.prof.generic_activity("LLVM_fat_lto_link_module");
297	297	info!("linking {:?}", name);
298		time_ext(cgcx.time_passes, None, &format!("ll link {:?}", name), \|\| {
	298	time_ext(cgcx.time_passes, &format!("ll link {:?}", name), \|\| {
299	299	let data = bc_decoded.data();
300	300	linker.add(&data).map_err(\|()\| {
301	301	let msg = format!("failed to load bc of {:?}", name);
...	...	@@ -590,7 +590,7 @@ pub(crate) fn run_pass_manager(cgcx: &CodegenContext<LlvmCodegenBackend>,
590	590	llvm::LLVMRustAddPass(pm, pass.unwrap());
591	591	}
592	592
593		time_ext(cgcx.time_passes, None, "LTO passes", \|\|
	593	time_ext(cgcx.time_passes, "LTO passes", \|\|
594	594	llvm::LLVMRunPassManager(pm, module.module_llvm.llmod()));
595	595
596	596	llvm::LLVMDisposePassManager(pm);

src/librustc_codegen_llvm/back/write.rs+1-3

...	...	@@ -427,7 +427,6 @@ pub(crate) unsafe fn optimize(cgcx: &CodegenContext<LlvmCodegenBackend>,
427	427	{
428	428	let _timer = cgcx.prof.generic_activity("LLVM_module_optimize_function_passes");
429	429	time_ext(config.time_passes,
430		None,
431	430	&format!("llvm function passes [{}]", module_name.unwrap()),
432	431	\|\| {
433	432	llvm::LLVMRustRunFunctionPassManager(fpm, llmod)
...	...	@@ -436,7 +435,6 @@ pub(crate) unsafe fn optimize(cgcx: &CodegenContext<LlvmCodegenBackend>,
436	435	{
437	436	let _timer = cgcx.prof.generic_activity("LLVM_module_optimize_module_passes");
438	437	time_ext(config.time_passes,
439		None,
440	438	&format!("llvm module passes [{}]", module_name.unwrap()),
441	439	\|\| {
442	440	llvm::LLVMRunPassManager(mpm, llmod)
...	...	@@ -538,7 +536,7 @@ pub(crate) unsafe fn codegen(cgcx: &CodegenContext<LlvmCodegenBackend>,
538	536	embed_bitcode(cgcx, llcx, llmod, None);
539	537	}
540	538
541		time_ext(config.time_passes, None, &format!("codegen passes [{}]", module_name.unwrap()),
	539	time_ext(config.time_passes, &format!("codegen passes [{}]", module_name.unwrap()),
542	540	\|\| -> Result<(), FatalError> {
543	541	if config.emit_ir {
544	542	let _timer = cgcx.prof.generic_activity("LLVM_module_codegen_emit_ir");

src/librustc_codegen_ssa/back/link.rs+1-1

...	...	@@ -1535,7 +1535,7 @@ fn add_upstream_rust_crates<'a, B: ArchiveBuilder<'a>>(
1535	1535	let name = cratepath.file_name().unwrap().to_str().unwrap();
1536	1536	let name = &name[3..name.len() - 5]; // chop off lib/.rlib
1537	1537
1538		time_ext(sess.time_extended(), Some(sess), &format!("altering {}.rlib", name), \|\| {
	1538	time_ext(sess.time_extended(), &format!("altering {}.rlib", name), \|\| {
1539	1539	let mut archive = <B as ArchiveBuilder>::new(sess, &dst, Some(cratepath));
1540	1540	archive.update_symbols();
1541	1541

src/librustc_incremental/persist/load.rs+1-1

...	...	@@ -160,7 +160,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
160	160	}
161	161
162	162	MaybeAsync::Async(std::thread::spawn(move \|\| {
163		time_ext(time_passes, None, "background load prev dep-graph", move \|\| {
	163	time_ext(time_passes, "background load prev dep-graph", move \|\| {
164	164	match load_data(report_incremental_info, &path) {
165	165	LoadResult::DataOutOfDate => LoadResult::DataOutOfDate,
166	166	LoadResult::Error { message } => LoadResult::Error { message },

src/librustc_interface/interface.rs+1-12

...	...	@@ -1,6 +1,5 @@
1	1	use crate::queries::Queries;
2	2	use crate::util;
3		use crate::profile;
4	3	pub use crate::passes::BoxedResolver;
5	4
6	5	use rustc::lint;
...	...	@@ -115,17 +114,7 @@ where
115	114	compiler.sess.diagnostic().print_error_count(&util::diagnostics_registry());
116	115	});
117	116
118		if compiler.sess.profile_queries() {
119		profile::begin(&compiler.sess);
120		}
121
122		let r = f(&compiler);
123
124		if compiler.sess.profile_queries() {
125		profile::dump(&compiler.sess, "profile_queries".to_string())
126		}
127
128		r
	117	f(&compiler)
129	118	}
130	119
131	120	pub fn run_compiler<F, R>(mut config: Config, f: F) -> R

src/librustc_interface/lib.rs-1

...	...	@@ -16,6 +16,5 @@ mod passes;
16	16	mod queries;
17	17	pub mod util;
18	18	mod proc_macro_decls;
19		mod profile;
20	19
21	20	pub use interface::{run_compiler, Config};

src/librustc_interface/profile/mod.rs deleted-297

...	...	@@ -1,297 +0,0 @@
1		use log::debug;
2		use rustc::dep_graph::DepNode;
3		use rustc::session::Session;
4		use rustc::util::common::{ProfQDumpParams, ProfileQueriesMsg, profq_msg, profq_set_chan};
5		use std::sync::mpsc::{Receiver};
6		use std::io::{Write};
7		use std::time::{Duration, Instant};
8
9		pub mod trace;
10
11		/// begin a profile thread, if not already running
12		pub fn begin(sess: &Session) {
13		use std::thread;
14		use std::sync::mpsc::{channel};
15		let (tx, rx) = channel();
16		if profq_set_chan(sess, tx) {
17		thread::spawn(move \|\| profile_queries_thread(rx));
18		}
19		}
20
21		/// dump files with profiling information to the given base path, and
22		/// wait for this dump to complete.
23		///
24		/// wraps the RPC (send/recv channel logic) of requesting a dump.
25		pub fn dump(sess: &Session, path: String) {
26		use std::sync::mpsc::{channel};
27		let (tx, rx) = channel();
28		let params = ProfQDumpParams {
29		path,
30		ack: tx,
31		// FIXME: Add another compiler flag to toggle whether this log
32		// is written; false for now
33		dump_profq_msg_log: true,
34		};
35		profq_msg(sess, ProfileQueriesMsg::Dump(params));
36		let _ = rx.recv().unwrap();
37		}
38
39		// State for parsing recursive trace structure in separate thread, via messages
40		#[derive(Clone, Eq, PartialEq)]
41		enum ParseState {
42		// No (local) parse state; may be parsing a tree, focused on a
43		// sub-tree that could be anything.
44		Clear,
45		// Have Query information from the last message
46		HaveQuery(trace::Query, Instant),
47		// Have "time-begin" information from the last message (doit flag, and message)
48		HaveTimeBegin(String, Instant),
49		// Have "task-begin" information from the last message
50		HaveTaskBegin(DepNode, Instant),
51		}
52		struct StackFrame {
53		pub parse_st: ParseState,
54		pub traces: Vec<trace::Rec>,
55		}
56
57		fn total_duration(traces: &[trace::Rec]) -> Duration {
58		Duration::new(0, 0) + traces.iter().map(\|t\| t.dur_total).sum()
59		}
60
61		// profiling thread; retains state (in local variables) and dump traces, upon request.
62		fn profile_queries_thread(r: Receiver<ProfileQueriesMsg>) {
63		use self::trace::*;
64		use std::fs::File;
65
66		let mut profq_msgs: Vec<ProfileQueriesMsg> = vec![];
67		let mut frame: StackFrame = StackFrame { parse_st: ParseState::Clear, traces: vec![] };
68		let mut stack: Vec<StackFrame> = vec![];
69		loop {
70		let msg = r.recv();
71		if let Err(_recv_err) = msg {
72		// FIXME: Perhaps do something smarter than simply quitting?
73		break
74		};
75		let msg = msg.unwrap();
76		debug!("profile_queries_thread: {:?}", msg);
77
78		// Meta-level versus _actual_ queries messages
79		match msg {
80		ProfileQueriesMsg::Halt => return,
81		ProfileQueriesMsg::Dump(params) => {
82		assert!(stack.is_empty());
83		assert!(frame.parse_st == ParseState::Clear);
84
85		// write log of all messages
86		if params.dump_profq_msg_log {
87		let mut log_file =
88		File::create(format!("{}.log.txt", params.path)).unwrap();
89		for m in profq_msgs.iter() {
90		writeln!(&mut log_file, "{:?}", m).unwrap()
91		};
92		}
93
94		// write HTML file, and counts file
95		let html_path = format!("{}.html", params.path);
96		let mut html_file = File::create(&html_path).unwrap();
97
98		let counts_path = format!("{}.counts.txt", params.path);
99		let mut counts_file = File::create(&counts_path).unwrap();
100
101		writeln!(html_file,
102		"<html>\n<head>\n<link rel=\"stylesheet\" type=\"text/css\" href=\"{}\">",
103		"profile_queries.css").unwrap();
104		writeln!(html_file, "<style>").unwrap();
105		trace::write_style(&mut html_file);
106		writeln!(html_file, "</style>\n</head>\n<body>").unwrap();
107		trace::write_traces(&mut html_file, &mut counts_file, &frame.traces);
108		writeln!(html_file, "</body>\n</html>").unwrap();
109
110		let ack_path = format!("{}.ack", params.path);
111		let ack_file = File::create(&ack_path).unwrap();
112		drop(ack_file);
113
114		// Tell main thread that we are done, e.g., so it can exit
115		params.ack.send(()).unwrap();
116		}
117		// Actual query message:
118		msg => {
119		// Record msg in our log
120		profq_msgs.push(msg.clone());
121		// Respond to the message, knowing that we've already handled Halt and Dump, above.
122		match (frame.parse_st.clone(), msg) {
123		(_, ProfileQueriesMsg::Halt) \| (_, ProfileQueriesMsg::Dump(_)) => {
124		unreachable!();
125		},
126		// Parse State: Clear
127		(ParseState::Clear,
128		ProfileQueriesMsg::QueryBegin(span, querymsg)) => {
129		let start = Instant::now();
130		frame.parse_st = ParseState::HaveQuery
131		(Query { span, msg: querymsg }, start)
132		},
133		(ParseState::Clear,
134		ProfileQueriesMsg::CacheHit) => {
135		panic!("parse error: unexpected CacheHit; expected QueryBegin")
136		},
137		(ParseState::Clear,
138		ProfileQueriesMsg::ProviderBegin) => {
139		panic!("parse error: expected QueryBegin before beginning a provider")
140		},
141		(ParseState::Clear,
142		ProfileQueriesMsg::ProviderEnd) => {
143		let provider_extent = frame.traces;
144		match stack.pop() {
145		None =>
146		panic!("parse error: expected a stack frame; found an empty stack"),
147		Some(old_frame) => {
148		match old_frame.parse_st {
149		ParseState::HaveQuery(q, start) => {
150		let duration = start.elapsed();
151		frame = StackFrame{
152		parse_st: ParseState::Clear,
153		traces: old_frame.traces
154		};
155		let dur_extent = total_duration(&provider_extent);
156		let trace = Rec {
157		effect: Effect::QueryBegin(q, CacheCase::Miss),
158		extent: Box::new(provider_extent),
159		start: start,
160		dur_self: duration - dur_extent,
161		dur_total: duration,
162		};
163		frame.traces.push( trace );
164		},
165		_ => panic!("internal parse error: malformed parse stack")
166		}
167		}
168		}
169		},
170		(ParseState::Clear,
171		ProfileQueriesMsg::TimeBegin(msg)) => {
172		let start = Instant::now();
173		frame.parse_st = ParseState::HaveTimeBegin(msg, start);
174		stack.push(frame);
175		frame = StackFrame{parse_st: ParseState::Clear, traces: vec![]};
176		},
177		(_, ProfileQueriesMsg::TimeBegin(_)) => {
178		panic!("parse error; did not expect time begin here");
179		},
180		(ParseState::Clear,
181		ProfileQueriesMsg::TimeEnd) => {
182		let provider_extent = frame.traces;
183		match stack.pop() {
184		None =>
185		panic!("parse error: expected a stack frame; found an empty stack"),
186		Some(old_frame) => {
187		match old_frame.parse_st {
188		ParseState::HaveTimeBegin(msg, start) => {
189		let duration = start.elapsed();
190		frame = StackFrame{
191		parse_st: ParseState::Clear,
192		traces: old_frame.traces
193		};
194		let dur_extent = total_duration(&provider_extent);
195		let trace = Rec {
196		effect: Effect::TimeBegin(msg),
197		extent: Box::new(provider_extent),
198		start: start,
199		dur_total: duration,
200		dur_self: duration - dur_extent,
201		};
202		frame.traces.push( trace );
203		},
204		_ => panic!("internal parse error: malformed parse stack")
205		}
206		}
207		}
208		},
209		(_, ProfileQueriesMsg::TimeEnd) => {
210		panic!("parse error")
211		},
212		(ParseState::Clear,
213		ProfileQueriesMsg::TaskBegin(key)) => {
214		let start = Instant::now();
215		frame.parse_st = ParseState::HaveTaskBegin(key, start);
216		stack.push(frame);
217		frame = StackFrame{ parse_st: ParseState::Clear, traces: vec![] };
218		},
219		(_, ProfileQueriesMsg::TaskBegin(_)) => {
220		panic!("parse error; did not expect time begin here");
221		},
222		(ParseState::Clear,
223		ProfileQueriesMsg::TaskEnd) => {
224		let provider_extent = frame.traces;
225		match stack.pop() {
226		None =>
227		panic!("parse error: expected a stack frame; found an empty stack"),
228		Some(old_frame) => {
229		match old_frame.parse_st {
230		ParseState::HaveTaskBegin(key, start) => {
231		let duration = start.elapsed();
232		frame = StackFrame{
233		parse_st: ParseState::Clear,
234		traces: old_frame.traces
235		};
236		let dur_extent = total_duration(&provider_extent);
237		let trace = Rec {
238		effect: Effect::TaskBegin(key),
239		extent: Box::new(provider_extent),
240		start: start,
241		dur_total: duration,
242		dur_self: duration - dur_extent,
243		};
244		frame.traces.push( trace );
245		},
246		_ => panic!("internal parse error: malformed parse stack")
247		}
248		}
249		}
250		},
251		(_, ProfileQueriesMsg::TaskEnd) => {
252		panic!("parse error")
253		},
254		// Parse State: HaveQuery
255		(ParseState::HaveQuery(q,start),
256		ProfileQueriesMsg::CacheHit) => {
257		let duration = start.elapsed();
258		let trace : Rec = Rec{
259		effect: Effect::QueryBegin(q, CacheCase::Hit),
260		extent: Box::new(vec![]),
261		start: start,
262		dur_self: duration,
263		dur_total: duration,
264		};
265		frame.traces.push( trace );
266		frame.parse_st = ParseState::Clear;
267		},
268		(ParseState::HaveQuery(_, _),
269		ProfileQueriesMsg::ProviderBegin) => {
270		stack.push(frame);
271		frame = StackFrame{ parse_st: ParseState::Clear, traces: vec![] };
272		},
273
274		// Parse errors:
275
276		(ParseState::HaveQuery(q, _),
277		ProfileQueriesMsg::ProviderEnd) => {
278		panic!("parse error: unexpected ProviderEnd; \
279		expected something else to follow BeginQuery for {:?}", q)
280		},
281		(ParseState::HaveQuery(q1, _),
282		ProfileQueriesMsg::QueryBegin(span2, querymsg2)) => {
283		panic!("parse error: unexpected QueryBegin; \
284		earlier query is unfinished: {:?} and now {:?}",
285		q1, Query{span:span2, msg: querymsg2})
286		},
287		(ParseState::HaveTimeBegin(_, _), _) => {
288		unreachable!()
289		},
290		(ParseState::HaveTaskBegin(_, _), _) => {
291		unreachable!()
292		},
293		}
294		}
295		}
296		}
297		}

src/librustc_interface/profile/trace.rs deleted-304

...	...	@@ -1,304 +0,0 @@
1		use super::*;
2		use syntax_pos::SpanData;
3		use rustc_data_structures::fx::FxHashMap;
4		use rustc::util::common::QueryMsg;
5		use std::fs::File;
6		use std::time::{Duration, Instant};
7		use rustc::dep_graph::{DepNode};
8
9		#[derive(Debug, Clone, Eq, PartialEq)]
10		pub struct Query {
11		pub span: SpanData,
12		pub msg: QueryMsg,
13		}
14		pub enum Effect {
15		QueryBegin(Query, CacheCase),
16		TimeBegin(String),
17		TaskBegin(DepNode),
18		}
19		pub enum CacheCase {
20		Hit, Miss
21		}
22		/// Recursive trace structure
23		pub struct Rec {
24		pub effect: Effect,
25		pub start: Instant,
26		pub dur_self: Duration,
27		pub dur_total: Duration,
28		pub extent: Box<Vec<Rec>>,
29		}
30		pub struct QueryMetric {
31		pub count: usize,
32		pub dur_self: Duration,
33		pub dur_total: Duration,
34		}
35
36		fn cons(s: &str) -> String {
37		let first = s.split(\|d\| d == '(' \|\| d == '{').next();
38		assert!(first.is_some() && first != Some(""));
39		first.unwrap().to_owned()
40		}
41
42		pub fn cons_of_query_msg(q: &trace::Query) -> String {
43		cons(&format!("{:?}", q.msg))
44		}
45
46		pub fn cons_of_key(k: &DepNode) -> String {
47		cons(&format!("{:?}", k))
48		}
49
50		// First return value is text; second return value is a CSS class
51		pub fn html_of_effect(eff: &Effect) -> (String, String) {
52		match *eff {
53		Effect::TimeBegin(ref msg) => {
54		(msg.clone(),
55		"time-begin".to_string())
56		},
57		Effect::TaskBegin(ref key) => {
58		let cons = cons_of_key(key);
59		(cons.clone(), format!("{} task-begin", cons))
60		},
61		Effect::QueryBegin(ref qmsg, ref cc) => {
62		let cons = cons_of_query_msg(qmsg);
63		(cons.clone(),
64		format!("{} {}",
65		cons,
66		match *cc {
67		CacheCase::Hit => "hit",
68		CacheCase::Miss => "miss",
69		}))
70		}
71		}
72		}
73
74		// First return value is text; second return value is a CSS class
75		fn html_of_duration(_start: &Instant, dur: &Duration) -> (String, String) {
76		use rustc::util::common::duration_to_secs_str;
77		(duration_to_secs_str(dur.clone()), String::new())
78		}
79
80		fn html_of_fraction(frac: f64) -> (String, &'static str) {
81		let css = {
82		if frac > 0.50 { "frac-50" }
83		else if frac > 0.40 { "frac-40" }
84		else if frac > 0.30 { "frac-30" }
85		else if frac > 0.20 { "frac-20" }
86		else if frac > 0.10 { "frac-10" }
87		else if frac > 0.05 { "frac-05" }
88		else if frac > 0.02 { "frac-02" }
89		else if frac > 0.01 { "frac-01" }
90		else if frac > 0.001 { "frac-001" }
91		else { "frac-0" }
92		};
93		let percent = frac * 100.0;
94
95		if percent > 0.1 {
96		(format!("{:.1}%", percent), css)
97		} else {
98		("< 0.1%".to_string(), css)
99		}
100		}
101
102		fn total_duration(traces: &[Rec]) -> Duration {
103		Duration::new(0, 0) + traces.iter().map(\|t\| t.dur_total).sum()
104		}
105
106		fn duration_div(nom: Duration, den: Duration) -> f64 {
107		fn to_nanos(d: Duration) -> u64 {
108		d.as_secs() * 1_000_000_000 + d.subsec_nanos() as u64
109		}
110
111		to_nanos(nom) as f64 / to_nanos(den) as f64
112		}
113
114		fn write_traces_rec(file: &mut File, traces: &[Rec], total: Duration, depth: usize) {
115		for t in traces {
116		let (eff_text, eff_css_classes) = html_of_effect(&t.effect);
117		let (dur_text, dur_css_classes) = html_of_duration(&t.start, &t.dur_total);
118		let fraction = duration_div(t.dur_total, total);
119		let percent = fraction * 100.0;
120		let (frc_text, frc_css_classes) = html_of_fraction(fraction);
121		writeln!(file, "<div class=\"trace depth-{} extent-{}{} {} {} {}\">",
122		depth,
123		t.extent.len(),
124		/* Heuristic for 'important' CSS class: */
125		if t.extent.len() > 5 \|\| percent >= 1.0 { " important" } else { "" },
126		eff_css_classes,
127		dur_css_classes,
128		frc_css_classes,
129		).unwrap();
130		writeln!(file, "<div class=\"eff\">{}</div>", eff_text).unwrap();
131		writeln!(file, "<div class=\"dur\">{}</div>", dur_text).unwrap();
132		writeln!(file, "<div class=\"frc\">{}</div>", frc_text).unwrap();
133		write_traces_rec(file, &t.extent, total, depth + 1);
134		writeln!(file, "</div>").unwrap();
135		}
136		}
137
138		fn compute_counts_rec(counts: &mut FxHashMap<String,QueryMetric>, traces: &[Rec]) {
139		counts.reserve(traces.len());
140		for t in traces.iter() {
141		match t.effect {
142		Effect::TimeBegin(ref msg) => {
143		let qm = match counts.get(msg) {
144		Some(_qm) => panic!("TimeBegin with non-unique, repeat message"),
145		None => QueryMetric {
146		count: 1,
147		dur_self: t.dur_self,
148		dur_total: t.dur_total,
149		}
150		};
151		counts.insert(msg.clone(), qm);
152		},
153		Effect::TaskBegin(ref key) => {
154		let cons = cons_of_key(key);
155		let qm = match counts.get(&cons) {
156		Some(qm) =>
157		QueryMetric {
158		count: qm.count + 1,
159		dur_self: qm.dur_self + t.dur_self,
160		dur_total: qm.dur_total + t.dur_total,
161		},
162		None => QueryMetric {
163		count: 1,
164		dur_self: t.dur_self,
165		dur_total: t.dur_total,
166		}
167		};
168		counts.insert(cons, qm);
169		},
170		Effect::QueryBegin(ref qmsg, ref _cc) => {
171		let qcons = cons_of_query_msg(qmsg);
172		let qm = match counts.get(&qcons) {
173		Some(qm) =>
174		QueryMetric {
175		count: qm.count + 1,
176		dur_total: qm.dur_total + t.dur_total,
177		dur_self: qm.dur_self + t.dur_self
178		},
179		None => QueryMetric {
180		count: 1,
181		dur_total: t.dur_total,
182		dur_self: t.dur_self,
183		}
184		};
185		counts.insert(qcons, qm);
186		}
187		}
188		compute_counts_rec(counts, &t.extent)
189		}
190		}
191
192		pub fn write_counts(count_file: &mut File, counts: &mut FxHashMap<String, QueryMetric>) {
193		use rustc::util::common::duration_to_secs_str;
194		use std::cmp::Reverse;
195
196		let mut data = counts.iter().map(\|(ref cons, ref qm)\|
197		(cons.clone(), qm.count.clone(), qm.dur_total.clone(), qm.dur_self.clone())
198		).collect::<Vec<_>>();
199
200		data.sort_by_key(\|k\| Reverse(k.3));
201		for (cons, count, dur_total, dur_self) in data {
202		writeln!(count_file, "{}, {}, {}, {}",
203		cons, count,
204		duration_to_secs_str(dur_total),
205		duration_to_secs_str(dur_self)
206		).unwrap();
207		}
208		}
209
210		pub fn write_traces(html_file: &mut File, counts_file: &mut File, traces: &[Rec]) {
211		let capacity = traces.iter().fold(0, \|acc, t\| acc + 1 + t.extent.len());
212		let mut counts = FxHashMap::with_capacity_and_hasher(capacity, Default::default());
213		compute_counts_rec(&mut counts, traces);
214		write_counts(counts_file, &mut counts);
215
216		let total: Duration = total_duration(traces);
217		write_traces_rec(html_file, traces, total, 0)
218		}
219
220		pub fn write_style(html_file: &mut File) {
221		write!(html_file, "{}", "
222		body {
223		font-family: sans-serif;
224		background: black;
225		}
226		.trace {
227		color: black;
228		display: inline-block;
229		border-style: solid;
230		border-color: red;
231		border-width: 1px;
232		border-radius: 5px;
233		padding: 0px;
234		margin: 1px;
235		font-size: 0px;
236		}
237		.task-begin {
238		border-width: 1px;
239		color: white;
240		border-color: #ff8;
241		font-size: 0px;
242		}
243		.miss {
244		border-color: red;
245		border-width: 1px;
246		}
247		.extent-0 {
248		padding: 2px;
249		}
250		.time-begin {
251		border-width: 4px;
252		font-size: 12px;
253		color: white;
254		border-color: #afa;
255		}
256		.important {
257		border-width: 3px;
258		font-size: 12px;
259		color: white;
260		border-color: #f77;
261		}
262		.hit {
263		padding: 0px;
264		border-color: blue;
265		border-width: 3px;
266		}
267		.eff {
268		color: #fff;
269		display: inline-block;
270		}
271		.frc {
272		color: #7f7;
273		display: inline-block;
274		}
275		.dur {
276		display: none
277		}
278		.frac-50 {
279		padding: 10px;
280		border-width: 10px;
281		font-size: 32px;
282		}
283		.frac-40 {
284		padding: 8px;
285		border-width: 8px;
286		font-size: 24px;
287		}
288		.frac-30 {
289		padding: 6px;
290		border-width: 6px;
291		font-size: 18px;
292		}
293		.frac-20 {
294		padding: 4px;
295		border-width: 6px;
296		font-size: 16px;
297		}
298		.frac-10 {
299		padding: 2px;
300		border-width: 6px;
301		font-size: 14px;
302		}
303		").unwrap();
304		}

src/librustc_lint/error_codes.rs+1-1

...	...	@@ -1,4 +1,4 @@
1	1	syntax::register_diagnostics! {
2	2	;
3		E0721, // `await` keyword
	3	// E0721, // `await` keyword
4	4	}

src/librustc_mir/error_codes.rs+1-1

...	...	@@ -953,7 +953,7 @@ https://doc.rust-lang.org/std/cell/
953	953	"##,
954	954
955	955	E0388: r##"
956		E0388 was removed and is no longer issued.
	956	#### Note: this error code is no longer emitted by the compiler.
957	957	"##,
958	958
959	959	E0389: r##"

src/librustc_passes/error_codes.rs+21-4

...	...	@@ -1,12 +1,15 @@
1	1	syntax::register_diagnostics! {
2		/*
3	2	E0014: r##"
	3	#### Note: this error code is no longer emitted by the compiler.
	4
4	5	Constants can only be initialized by a constant value or, in a future
5	6	version of Rust, a call to a const function. This error indicates the use
6	7	of a path (like a::b, or x) denoting something other than one of these
7		allowed items. Erroneous code xample:
	8	allowed items.
8	9
9		```compile_fail
	10	Erroneous code example:
	11
	12	```
10	13	const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function!
11	14	```
12	15
...	...	@@ -18,10 +21,10 @@ const FOO: i32 = { const X : i32 = 0; X };
18	21	const FOO2: i32 = { 0 }; // but brackets are useless here
19	22	```
20	23	"##,
21		*/
22	24
23	25	E0130: r##"
24	26	You declared a pattern as an argument in a foreign function declaration.
	27
25	28	Erroneous code example:
26	29
27	30	```compile_fail
...	...	@@ -57,6 +60,20 @@ extern {
57	60	E0136: r##"
58	61	A binary can only have one entry point, and by default that entry point is the
59	62	function `main()`. If there are multiple such functions, please rename one.
	63
	64	Erroneous code example:
	65
	66	```compile_fail,E0136
	67	fn main() {
	68	// ...
	69	}
	70
	71	// ...
	72
	73	fn main() { // error!
	74	// ...
	75	}
	76	```
60	77	"##,
61	78
62	79	E0137: r##"

src/librustc_privacy/error_codes.rs+17-6

...	...	@@ -1,8 +1,9 @@
1	1	syntax::register_diagnostics! {
2	2
3	3	E0445: r##"
4		A private trait was used on a public type parameter bound. Erroneous code
5		examples:
	4	A private trait was used on a public type parameter bound.
	5
	6	Erroneous code examples:
6	7
7	8	```compile_fail,E0445
8	9	#![deny(private_in_public)]
...	...	@@ -32,7 +33,9 @@ pub fn foo<T: Foo> (t: T) {} // ok!
32	33	"##,
33	34
34	35	E0446: r##"
35		A private type was used in a public type signature. Erroneous code example:
	36	A private type was used in a public type signature.
	37
	38	Erroneous code example:
36	39
37	40	```compile_fail,E0446
38	41	#![deny(private_in_public)]
...	...	@@ -65,7 +68,9 @@ mod Foo {
65	68	E0447: r##"
66	69	#### Note: this error code is no longer emitted by the compiler.
67	70
68		The `pub` keyword was used inside a function. Erroneous code example:
	71	The `pub` keyword was used inside a function.
	72
	73	Erroneous code example:
69	74
70	75	```
71	76	fn foo() {
...	...	@@ -79,7 +84,11 @@ is invalid.
79	84	"##,
80	85
81	86	E0448: r##"
82		The `pub` keyword was used inside a public enum. Erroneous code example:
	87	#### Note: this error code is no longer emitted by the compiler.
	88
	89	The `pub` keyword was used inside a public enum.
	90
	91	Erroneous code example:
83	92
84	93	```compile_fail
85	94	pub enum Foo {
...	...	@@ -106,7 +115,9 @@ pub enum Foo {
106	115	"##,
107	116
108	117	E0451: r##"
109		A struct constructor with private fields was invoked. Erroneous code example:
	118	A struct constructor with private fields was invoked.
	119
	120	Erroneous code example:
110	121
111	122	```compile_fail,E0451
112	123	mod Bar {

src/librustc_resolve/diagnostics.rs+20-18

...	...	@@ -20,7 +20,7 @@ use syntax_pos::{BytePos, Span, MultiSpan};
20	20
21	21	use crate::resolve_imports::{ImportDirective, ImportDirectiveSubclass, ImportResolver};
22	22	use crate::{path_names_to_string, KNOWN_TOOLS};
23		use crate::{BindingError, CrateLint, LegacyScope, Module, ModuleOrUniformRoot};
	23	use crate::{BindingError, CrateLint, HasGenericParams, LegacyScope, Module, ModuleOrUniformRoot};
24	24	use crate::{PathResult, ParentScope, ResolutionError, Resolver, Scope, ScopeSet, Segment};
25	25
26	26	type Res = def::Res<ast::NodeId>;
...	...	@@ -102,7 +102,7 @@ impl<'a> Resolver<'a> {
102	102	&self, span: Span, resolution_error: ResolutionError<'_>
103	103	) -> DiagnosticBuilder<'_> {
104	104	match resolution_error {
105		ResolutionError::GenericParamsFromOuterFunction(outer_res) => {
	105	ResolutionError::GenericParamsFromOuterFunction(outer_res, has_generic_params) => {
106	106	let mut err = struct_span_err!(self.session,
107	107	span,
108	108	E0401,
...	...	@@ -148,22 +148,24 @@ impl<'a> Resolver<'a> {
148	148	}
149	149	}
150	150
151		// Try to retrieve the span of the function signature and generate a new message
152		// with a local type or const parameter.
153		let sugg_msg = &format!("try using a local generic parameter instead");
154		if let Some((sugg_span, new_snippet)) = cm.generate_local_type_param_snippet(span) {
155		// Suggest the modification to the user
156		err.span_suggestion(
157		sugg_span,
158		sugg_msg,
159		new_snippet,
160		Applicability::MachineApplicable,
161		);
162		} else if let Some(sp) = cm.generate_fn_name_span(span) {
163		err.span_label(sp,
164		format!("try adding a local generic parameter in this method instead"));
165		} else {
166		err.help(&format!("try using a local generic parameter instead"));
	151	if has_generic_params == HasGenericParams::Yes {
	152	// Try to retrieve the span of the function signature and generate a new
	153	// message with a local type or const parameter.
	154	let sugg_msg = &format!("try using a local generic parameter instead");
	155	if let Some((sugg_span, snippet)) = cm.generate_local_type_param_snippet(span) {
	156	// Suggest the modification to the user
	157	err.span_suggestion(
	158	sugg_span,
	159	sugg_msg,
	160	snippet,
	161	Applicability::MachineApplicable,
	162	);
	163	} else if let Some(sp) = cm.generate_fn_name_span(span) {
	164	err.span_label(sp,
	165	format!("try adding a local generic parameter in this method instead"));
	166	} else {
	167	err.help(&format!("try using a local generic parameter instead"));
	168	}
167	169	}
168	170
169	171	err

src/librustc_resolve/late.rs+116-139

...	...	@@ -5,7 +5,6 @@
5	5	//! If you wonder why there's no `early.rs`, that's because it's split into three files -
6	6	//! `build_reduced_graph.rs`, `macros.rs` and `resolve_imports.rs`.
7	7
8		use GenericParameters::*;
9	8	use RibKind::*;
10	9
11	10	use crate::{path_names_to_string, BindingError, CrateLint, LexicalScopeBinding};
...	...	@@ -46,16 +45,6 @@ struct BindingInfo {
46	45	binding_mode: BindingMode,
47	46	}
48	47
49		#[derive(Copy, Clone)]
50		enum GenericParameters<'a, 'b> {
51		NoGenericParams,
52		HasGenericParams(// Type parameters.
53		&'b Generics,
54
55		// The kind of the rib used for type parameters.
56		RibKind<'a>),
57		}
58
59	48	#[derive(Copy, Clone, PartialEq, Eq, Debug)]
60	49	enum PatternSource {
61	50	Match,
...	...	@@ -85,6 +74,10 @@ enum PatBoundCtx {
85	74	Or,
86	75	}
87	76
	77	/// Does this the item (from the item rib scope) allow generic parameters?
	78	#[derive(Copy, Clone, Debug, Eq, PartialEq)]
	79	crate enum HasGenericParams { Yes, No }
	80
88	81	/// The rib kind restricts certain accesses,
89	82	/// e.g. to a `Res::Local` of an outer item.
90	83	#[derive(Copy, Clone, Debug)]
...	...	@@ -103,7 +96,7 @@ crate enum RibKind<'a> {
103	96	FnItemRibKind,
104	97
105	98	/// We passed through an item scope. Disallow upvars.
106		ItemRibKind,
	99	ItemRibKind(HasGenericParams),
107	100
108	101	/// We're in a constant item. Can't refer to dynamic stuff.
109	102	ConstantItemRibKind,
...	...	@@ -134,7 +127,7 @@ impl RibKind<'_> {
134	127	\| ModuleRibKind(_)
135	128	\| MacroDefinition(_) => false,
136	129	AssocItemRibKind
137		\| ItemRibKind
	130	\| ItemRibKind(_)
138	131	\| ForwardTyParamBanRibKind
139	132	\| TyParamAsConstParamTy => true,
140	133	}
...	...	@@ -406,17 +399,21 @@ impl<'a, 'tcx> Visitor<'tcx> for LateResolutionVisitor<'a, '_> {
406	399	visit::walk_poly_trait_ref(self, tref, m);
407	400	}
408	401	fn visit_foreign_item(&mut self, foreign_item: &'tcx ForeignItem) {
409		let generic_params = match foreign_item.kind {
	402	match foreign_item.kind {
410	403	ForeignItemKind::Fn(_, ref generics) => {
411		HasGenericParams(generics, ItemRibKind)
	404	self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), \|this\| {
	405	visit::walk_foreign_item(this, foreign_item);
	406	});
412	407	}
413		ForeignItemKind::Static(..) => NoGenericParams,
414		ForeignItemKind::Ty => NoGenericParams,
415		ForeignItemKind::Macro(..) => NoGenericParams,
416		};
417		self.with_generic_param_rib(generic_params, \|this\| {
418		visit::walk_foreign_item(this, foreign_item);
419		});
	408	ForeignItemKind::Static(..) => {
	409	self.with_item_rib(HasGenericParams::No, \|this\| {
	410	visit::walk_foreign_item(this, foreign_item);
	411	});
	412	}
	413	ForeignItemKind::Ty \| ForeignItemKind::Macro(..) => {
	414	visit::walk_foreign_item(self, foreign_item);
	415	}
	416	}
420	417	}
421	418	fn visit_fn(&mut self, fn_kind: FnKind<'tcx>, declaration: &'tcx FnDecl, _: Span, _: NodeId) {
422	419	debug!("(resolving function) entering function");
...	...	@@ -660,7 +657,7 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
660	657	fn resolve_adt(&mut self, item: &Item, generics: &Generics) {
661	658	debug!("resolve_adt");
662	659	self.with_current_self_item(item, \|this\| {
663		this.with_generic_param_rib(HasGenericParams(generics, ItemRibKind), \|this\| {
	660	this.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), \|this\| {
664	661	let item_def_id = this.r.definitions.local_def_id(item.id);
665	662	this.with_self_rib(Res::SelfTy(None, Some(item_def_id)), \|this\| {
666	663	visit::walk_item(this, item);
...	...	@@ -719,10 +716,8 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
719	716	ItemKind::TyAlias(_, ref generics) \|
720	717	ItemKind::OpaqueTy(_, ref generics) \|
721	718	ItemKind::Fn(_, _, ref generics, _) => {
722		self.with_generic_param_rib(
723		HasGenericParams(generics, ItemRibKind),
724		\|this\| visit::walk_item(this, item)
725		);
	719	self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes),
	720	\|this\| visit::walk_item(this, item));
726	721	}
727	722
728	723	ItemKind::Enum(_, ref generics) \|
...	...	@@ -740,7 +735,7 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
740	735
741	736	ItemKind::Trait(.., ref generics, ref bounds, ref trait_items) => {
742	737	// Create a new rib for the trait-wide type parameters.
743		self.with_generic_param_rib(HasGenericParams(generics, ItemRibKind), \|this\| {
	738	self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), \|this\| {
744	739	let local_def_id = this.r.definitions.local_def_id(item.id);
745	740	this.with_self_rib(Res::SelfTy(Some(local_def_id), None), \|this\| {
746	741	this.visit_generics(generics);
...	...	@@ -748,35 +743,32 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
748	743
749	744	for trait_item in trait_items {
750	745	this.with_trait_items(trait_items, \|this\| {
751		let generic_params = HasGenericParams(
752		&trait_item.generics,
753		AssocItemRibKind,
754		);
755		this.with_generic_param_rib(generic_params, \|this\| {
756		match trait_item.kind {
757		TraitItemKind::Const(ref ty, ref default) => {
758		this.visit_ty(ty);
759
760		// Only impose the restrictions of
761		// ConstRibKind for an actual constant
762		// expression in a provided default.
763		if let Some(ref expr) = *default{
764		this.with_constant_rib(\|this\| {
765		this.visit_expr(expr);
766		});
	746	this.with_generic_param_rib(&trait_item.generics, AssocItemRibKind,
	747	\|this\| {
	748	match trait_item.kind {
	749	TraitItemKind::Const(ref ty, ref default) => {
	750	this.visit_ty(ty);
	751
	752	// Only impose the restrictions of
	753	// ConstRibKind for an actual constant
	754	// expression in a provided default.
	755	if let Some(ref expr) = *default{
	756	this.with_constant_rib(\|this\| {
	757	this.visit_expr(expr);
	758	});
	759	}
767	760	}
768		}
769		TraitItemKind::Method(_, _) => {
770		visit::walk_trait_item(this, trait_item)
771		}
772		TraitItemKind::Type(..) => {
773		visit::walk_trait_item(this, trait_item)
774		}
775		TraitItemKind::Macro(_) => {
776		panic!("unexpanded macro in resolve!")
777		}
778		};
779		});
	761	TraitItemKind::Method(_, _) => {
	762	visit::walk_trait_item(this, trait_item)
	763	}
	764	TraitItemKind::Type(..) => {
	765	visit::walk_trait_item(this, trait_item)
	766	}
	767	TraitItemKind::Macro(_) => {
	768	panic!("unexpanded macro in resolve!")
	769	}
	770	};
	771	});
780	772	});
781	773	}
782	774	});
...	...	@@ -785,7 +777,7 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
785	777
786	778	ItemKind::TraitAlias(ref generics, ref bounds) => {
787	779	// Create a new rib for the trait-wide type parameters.
788		self.with_generic_param_rib(HasGenericParams(generics, ItemRibKind), \|this\| {
	780	self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), \|this\| {
789	781	let local_def_id = this.r.definitions.local_def_id(item.id);
790	782	this.with_self_rib(Res::SelfTy(Some(local_def_id), None), \|this\| {
791	783	this.visit_generics(generics);
...	...	@@ -803,7 +795,7 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
803	795	ItemKind::Static(ref ty, _, ref expr) \|
804	796	ItemKind::Const(ref ty, ref expr) => {
805	797	debug!("resolve_item ItemKind::Const");
806		self.with_item_rib(\|this\| {
	798	self.with_item_rib(HasGenericParams::No, \|this\| {
807	799	this.visit_ty(ty);
808	800	this.with_constant_rib(\|this\| {
809	801	this.visit_expr(expr);
...	...	@@ -824,91 +816,75 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
824	816	}
825	817	}
826	818
827		fn with_generic_param_rib<'c, F>(&'c mut self, generic_params: GenericParameters<'a, 'c>, f: F)
	819	fn with_generic_param_rib<'c, F>(&'c mut self, generics: &'c Generics, kind: RibKind<'a>, f: F)
828	820	where F: FnOnce(&mut Self)
829	821	{
830	822	debug!("with_generic_param_rib");
831		match generic_params {
832		HasGenericParams(generics, rib_kind) => {
833		let mut function_type_rib = Rib::new(rib_kind);
834		let mut function_value_rib = Rib::new(rib_kind);
835		let mut seen_bindings = FxHashMap::default();
836		// We also can't shadow bindings from the parent item
837		if let AssocItemRibKind = rib_kind {
838		let mut add_bindings_for_ns = \|ns\| {
839		let parent_rib = self.ribs[ns].iter()
840		.rfind(\|rib\| if let ItemRibKind = rib.kind { true } else { false })
841		.expect("associated item outside of an item");
842		seen_bindings.extend(
843		parent_rib.bindings.iter().map(\|(ident, _)\| (*ident, ident.span)),
844		);
845		};
846		add_bindings_for_ns(ValueNS);
847		add_bindings_for_ns(TypeNS);
848		}
849		for param in &generics.params {
850		match param.kind {
851		GenericParamKind::Lifetime { .. } => {}
852		GenericParamKind::Type { .. } => {
853		let ident = param.ident.modern();
854		debug!("with_generic_param_rib: {}", param.id);
855
856		if seen_bindings.contains_key(&ident) {
857		let span = seen_bindings.get(&ident).unwrap();
858		let err = ResolutionError::NameAlreadyUsedInParameterList(
859		ident.name,
860		*span,
861		);
862		self.r.report_error(param.ident.span, err);
863		}
864		seen_bindings.entry(ident).or_insert(param.ident.span);
865
866		// Plain insert (no renaming).
867		let res = Res::Def(
868		DefKind::TyParam,
869		self.r.definitions.local_def_id(param.id),
870		);
871		function_type_rib.bindings.insert(ident, res);
872		self.r.record_partial_res(param.id, PartialRes::new(res));
873		}
874		GenericParamKind::Const { .. } => {
875		let ident = param.ident.modern();
876		debug!("with_generic_param_rib: {}", param.id);
877
878		if seen_bindings.contains_key(&ident) {
879		let span = seen_bindings.get(&ident).unwrap();
880		let err = ResolutionError::NameAlreadyUsedInParameterList(
881		ident.name,
882		*span,
883		);
884		self.r.report_error(param.ident.span, err);
885		}
886		seen_bindings.entry(ident).or_insert(param.ident.span);
887
888		let res = Res::Def(
889		DefKind::ConstParam,
890		self.r.definitions.local_def_id(param.id),
891		);
892		function_value_rib.bindings.insert(ident, res);
893		self.r.record_partial_res(param.id, PartialRes::new(res));
894		}
895		}
896		}
897		self.ribs[ValueNS].push(function_value_rib);
898		self.ribs[TypeNS].push(function_type_rib);
	823	let mut function_type_rib = Rib::new(kind);
	824	let mut function_value_rib = Rib::new(kind);
	825	let mut seen_bindings = FxHashMap::default();
	826
	827	// We also can't shadow bindings from the parent item
	828	if let AssocItemRibKind = kind {
	829	let mut add_bindings_for_ns = \|ns\| {
	830	let parent_rib = self.ribs[ns].iter()
	831	.rfind(\|r\| if let ItemRibKind(_) = r.kind { true } else { false })
	832	.expect("associated item outside of an item");
	833	seen_bindings.extend(
	834	parent_rib.bindings.iter().map(\|(ident, _)\| (*ident, ident.span)),
	835	);
	836	};
	837	add_bindings_for_ns(ValueNS);
	838	add_bindings_for_ns(TypeNS);
	839	}
	840
	841	for param in &generics.params {
	842	if let GenericParamKind::Lifetime { .. } = param.kind {
	843	continue;
899	844	}
900	845
901		NoGenericParams => {
902		// Nothing to do.
	846	let def_kind = match param.kind {
	847	GenericParamKind::Type { .. } => DefKind::TyParam,
	848	GenericParamKind::Const { .. } => DefKind::ConstParam,
	849	_ => unreachable!(),
	850	};
	851
	852	let ident = param.ident.modern();
	853	debug!("with_generic_param_rib: {}", param.id);
	854
	855	if seen_bindings.contains_key(&ident) {
	856	let span = seen_bindings.get(&ident).unwrap();
	857	let err = ResolutionError::NameAlreadyUsedInParameterList(
	858	ident.name,
	859	*span,
	860	);
	861	self.r.report_error(param.ident.span, err);
	862	}
	863	seen_bindings.entry(ident).or_insert(param.ident.span);
	864
	865	// Plain insert (no renaming).
	866	let res = Res::Def(def_kind, self.r.definitions.local_def_id(param.id));
	867
	868	match param.kind {
	869	GenericParamKind::Type { .. } => {
	870	function_type_rib.bindings.insert(ident, res);
	871	self.r.record_partial_res(param.id, PartialRes::new(res));
	872	}
	873	GenericParamKind::Const { .. } => {
	874	function_value_rib.bindings.insert(ident, res);
	875	self.r.record_partial_res(param.id, PartialRes::new(res));
	876	}
	877	_ => unreachable!(),
903	878	}
904	879	}
905	880
	881	self.ribs[ValueNS].push(function_value_rib);
	882	self.ribs[TypeNS].push(function_type_rib);
	883
906	884	f(self);
907	885
908		if let HasGenericParams(..) = generic_params {
909		self.ribs[TypeNS].pop();
910		self.ribs[ValueNS].pop();
911		}
	886	self.ribs[TypeNS].pop();
	887	self.ribs[ValueNS].pop();
912	888	}
913	889
914	890	fn with_label_rib(&mut self, kind: RibKind<'a>, f: impl FnOnce(&mut Self)) {
...	...	@@ -917,8 +893,9 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
917	893	self.label_ribs.pop();
918	894	}
919	895
920		fn with_item_rib(&mut self, f: impl FnOnce(&mut Self)) {
921		self.with_rib(ValueNS, ItemRibKind, \|this\| this.with_rib(TypeNS, ItemRibKind, f))
	896	fn with_item_rib(&mut self, has_generic_params: HasGenericParams, f: impl FnOnce(&mut Self)) {
	897	let kind = ItemRibKind(has_generic_params);
	898	self.with_rib(ValueNS, kind, \|this\| this.with_rib(TypeNS, kind, f))
922	899	}
923	900
924	901	fn with_constant_rib(&mut self, f: impl FnOnce(&mut Self)) {
...	...	@@ -1023,7 +1000,7 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
1023	1000	impl_items: &[ImplItem]) {
1024	1001	debug!("resolve_implementation");
1025	1002	// If applicable, create a rib for the type parameters.
1026		self.with_generic_param_rib(HasGenericParams(generics, ItemRibKind), \|this\| {
	1003	self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), \|this\| {
1027	1004	// Dummy self type for better errors if `Self` is used in the trait path.
1028	1005	this.with_self_rib(Res::SelfTy(None, None), \|this\| {
1029	1006	// Resolve the trait reference, if necessary.
...	...	@@ -1044,9 +1021,9 @@ impl<'a, 'b> LateResolutionVisitor<'a, '_> {
1044	1021	debug!("resolve_implementation with_self_rib_ns(ValueNS, ...)");
1045	1022	for impl_item in impl_items {
1046	1023	// We also need a new scope for the impl item type parameters.
1047		let generic_params = HasGenericParams(&impl_item.generics,
1048		AssocItemRibKind);
1049		this.with_generic_param_rib(generic_params, \|this\| {
	1024	this.with_generic_param_rib(&impl_item.generics,
	1025	AssocItemRibKind,
	1026	\|this\| {
1050	1027	use crate::ResolutionError::*;
1051	1028	match impl_item.kind {
1052	1029	ImplItemKind::Const(..) => {

src/librustc_resolve/lib.rs+25-21

...	...	@@ -61,7 +61,7 @@ use rustc_data_structures::fx::FxIndexMap;
61	61
62	62	use diagnostics::{Suggestion, ImportSuggestion};
63	63	use diagnostics::{find_span_of_binding_until_next_binding, extend_span_to_previous_binding};
64		use late::{PathSource, Rib, RibKind::*};
	64	use late::{HasGenericParams, PathSource, Rib, RibKind::*};
65	65	use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver};
66	66	use macros::{LegacyBinding, LegacyScope};
67	67
...	...	@@ -178,7 +178,7 @@ impl Ord for BindingError {
178	178
179	179	enum ResolutionError<'a> {
180	180	/// Error E0401: can't use type or const parameters from outer function.
181		GenericParamsFromOuterFunction(Res),
	181	GenericParamsFromOuterFunction(Res, HasGenericParams),
182	182	/// Error E0403: the name is already used for a type or const parameter in this generic
183	183	/// parameter list.
184	184	NameAlreadyUsedInParameterList(Name, Span),
...	...	@@ -2156,7 +2156,7 @@ impl<'a> Resolver<'a> {
2156	2156	ForwardTyParamBanRibKind \| TyParamAsConstParamTy => {
2157	2157	// Nothing to do. Continue.
2158	2158	}
2159		ItemRibKind \| FnItemRibKind \| AssocItemRibKind => {
	2159	ItemRibKind(_) \| FnItemRibKind \| AssocItemRibKind => {
2160	2160	// This was an attempt to access an upvar inside a
2161	2161	// named function item. This is not allowed, so we
2162	2162	// report an error.
...	...	@@ -2184,22 +2184,23 @@ impl<'a> Resolver<'a> {
2184	2184	}
2185	2185	Res::Def(DefKind::TyParam, _) \| Res::SelfTy(..) => {
2186	2186	for rib in ribs {
2187		match rib.kind {
	2187	let has_generic_params = match rib.kind {
2188	2188	NormalRibKind \| AssocItemRibKind \|
2189	2189	ModuleRibKind(..) \| MacroDefinition(..) \| ForwardTyParamBanRibKind \|
2190	2190	ConstantItemRibKind \| TyParamAsConstParamTy => {
2191	2191	// Nothing to do. Continue.
	2192	continue;
2192	2193	}
2193		ItemRibKind \| FnItemRibKind => {
2194		// This was an attempt to use a type parameter outside its scope.
2195		if record_used {
2196		self.report_error(
2197		span, ResolutionError::GenericParamsFromOuterFunction(res)
2198		);
2199		}
2200		return Res::Err;
2201		}
	2194	// This was an attempt to use a type parameter outside its scope.
	2195	ItemRibKind(has_generic_params) => has_generic_params,
	2196	FnItemRibKind => HasGenericParams::Yes,
	2197	};
	2198
	2199	if record_used {
	2200	self.report_error(span, ResolutionError::GenericParamsFromOuterFunction(
	2201	res, has_generic_params));
2202	2202	}
	2203	return Res::Err;
2203	2204	}
2204	2205	}
2205	2206	Res::Def(DefKind::ConstParam, _) => {
...	...	@@ -2211,15 +2212,18 @@ impl<'a> Resolver<'a> {
2211	2212	ribs.next();
2212	2213	}
2213	2214	for rib in ribs {
2214		if let ItemRibKind \| FnItemRibKind = rib.kind {
2215		// This was an attempt to use a const parameter outside its scope.
2216		if record_used {
2217		self.report_error(
2218		span, ResolutionError::GenericParamsFromOuterFunction(res)
2219		);
2220		}
2221		return Res::Err;
	2215	let has_generic_params = match rib.kind {
	2216	ItemRibKind(has_generic_params) => has_generic_params,
	2217	FnItemRibKind => HasGenericParams::Yes,
	2218	_ => continue,
	2219	};
	2220
	2221	// This was an attempt to use a const parameter outside its scope.
	2222	if record_used {
	2223	self.report_error(span, ResolutionError::GenericParamsFromOuterFunction(
	2224	res, has_generic_params));
2222	2225	}
	2226	return Res::Err;
2223	2227	}
2224	2228	}
2225	2229	_ => {}

src/librustc_typeck/check/demand.rs+4

...	...	@@ -115,6 +115,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
115	115	Err(e) => e
116	116	};
117	117
	118	let expr = expr.peel_drop_temps();
118	119	let cause = self.misc(expr.span);
119	120	let expr_ty = self.resolve_type_vars_with_obligations(checked_ty);
120	121	let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e);
...	...	@@ -355,6 +356,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
355	356	};
356	357	let is_macro = sp.from_expansion() && !is_desugaring;
357	358
	359	// `ExprKind::DropTemps` is semantically irrelevant for these suggestions.
	360	let expr = expr.peel_drop_temps();
	361
358	362	match (&expr.kind, &expected.kind, &checked_ty.kind) {
359	363	(_, &ty::Ref(_, exp, _), &ty::Ref(_, check, _)) => match (&exp.kind, &check.kind) {
360	364	(&ty::Str, &ty::Array(arr, _)) \|

src/librustc_typeck/check/expr.rs+1-5

...	...	@@ -87,12 +87,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
87	87	}
88	88
89	89	if let Some(mut err) = self.demand_suptype_diag(expr.span, expected_ty, ty) {
	90	let expr = expr.peel_drop_temps();
90	91	self.suggest_ref_or_into(&mut err, expr, expected_ty, ty);
91
92		let expr = match &expr.kind {
93		ExprKind::DropTemps(expr) => expr,
94		_ => expr,
95		};
96	92	extend_err(&mut err);
97	93	// Error possibly reported in `check_assign` so avoid emitting error again.
98	94	err.emit_unless(self.is_assign_to_bool(expr, expected_ty));

src/librustc_typeck/check/method/suggest.rs+19-6

...	...	@@ -538,13 +538,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
538	538	}
539	539	}
540	540
	541	let mut fallback_span = true;
	542	let msg = "remove this method call";
541	543	if item_name.as_str() == "as_str" && actual.peel_refs().is_str() {
542		// FIXME: the span is not quite correct, it should point to ".as_str()" instead
543		// of just "as_str".
544		err.span_label(
545		span,
546		"try removing `as_str`"
547		);
	544	if let SelfSource::MethodCall(expr) = source {
	545	let call_expr = self.tcx.hir().expect_expr(
	546	self.tcx.hir().get_parent_node(expr.hir_id),
	547	);
	548	if let Some(span) = call_expr.span.trim_start(expr.span) {
	549	err.span_suggestion(
	550	span,
	551	msg,
	552	String::new(),
	553	Applicability::MachineApplicable,
	554	);
	555	fallback_span = false;
	556	}
	557	}
	558	if fallback_span {
	559	err.span_label(span, msg);
	560	}
548	561	} else if let Some(lev_candidate) = lev_candidate {
549	562	let def_kind = lev_candidate.def_kind();
550	563	err.span_suggestion(

src/librustc_typeck/check/mod.rs+5-4

...	...	@@ -4216,20 +4216,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
4216	4216	pub fn suggest_mismatched_types_on_tail(
4217	4217	&self,
4218	4218	err: &mut DiagnosticBuilder<'tcx>,
4219		expression: &'tcx hir::Expr,
	4219	expr: &'tcx hir::Expr,
4220	4220	expected: Ty<'tcx>,
4221	4221	found: Ty<'tcx>,
4222	4222	cause_span: Span,
4223	4223	blk_id: hir::HirId,
4224	4224	) -> bool {
4225		self.suggest_missing_semicolon(err, expression, expected, cause_span);
	4225	let expr = expr.peel_drop_temps();
	4226	self.suggest_missing_semicolon(err, expr, expected, cause_span);
4226	4227	let mut pointing_at_return_type = false;
4227	4228	if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
4228	4229	pointing_at_return_type = self.suggest_missing_return_type(
4229	4230	err, &fn_decl, expected, found, can_suggest);
4230	4231	}
4231		self.suggest_ref_or_into(err, expression, expected, found);
4232		self.suggest_boxing_when_appropriate(err, expression, expected, found);
	4232	self.suggest_ref_or_into(err, expr, expected, found);
	4233	self.suggest_boxing_when_appropriate(err, expr, expected, found);
4233	4234	pointing_at_return_type
4234	4235	}
4235	4236

src/librustc_typeck/error_codes.rs+15-17

...	...	@@ -1873,13 +1873,14 @@ This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1873	1873	differs from the behavior for `&T`, which is always `Copy`).
1874	1874	"##,
1875	1875
1876		/*
1877	1876	E0205: r##"
	1877	#### Note: this error code is no longer emitted by the compiler.
	1878
1878	1879	An attempt to implement the `Copy` trait for an enum failed because one of the
1879	1880	variants does not implement `Copy`. To fix this, you must implement `Copy` for
1880	1881	the mentioned variant. Note that this may not be possible, as in the example of
1881	1882
1882		```compile_fail,E0205
	1883	```compile_fail,E0204
1883	1884	enum Foo {
1884	1885	Bar(Vec<u32>),
1885	1886	Baz,
...	...	@@ -1892,7 +1893,7 @@ This fails because `Vec<T>` does not implement `Copy` for any `T`.
1892	1893
1893	1894	Here's another example that will fail:
1894	1895
1895		```compile_fail,E0205
	1896	```compile_fail,E0204
1896	1897	#[derive(Copy)]
1897	1898	enum Foo<'a> {
1898	1899	Bar(&'a mut bool),
...	...	@@ -1903,7 +1904,6 @@ enum Foo<'a> {
1903	1904	This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1904	1905	differs from the behavior for `&T`, which is always `Copy`).
1905	1906	"##,
1906		*/
1907	1907
1908	1908	E0206: r##"
1909	1909	You can only implement `Copy` for a struct or enum. Both of the following
...	...	@@ -2126,8 +2126,9 @@ For information on the design of the orphan rules, see [RFC 1023].
2126	2126	[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
2127	2127	"##,
2128	2128
2129		/*
2130	2129	E0211: r##"
	2130	#### Note: this error code is no longer emitted by the compiler.
	2131
2131	2132	You used a function or type which doesn't fit the requirements for where it was
2132	2133	used. Erroneous code examples:
2133	2134
...	...	@@ -2174,7 +2175,7 @@ extern "rust-intrinsic" {
2174	2175	}
2175	2176	```
2176	2177
2177		The second case example is a bit particular : the main function must always
	2178	The second case example is a bit particular: the main function must always
2178	2179	have this definition:
2179	2180
2180	2181	```compile_fail
...	...	@@ -2206,7 +2207,6 @@ impl Foo {
2206	2207	}
2207	2208	```
2208	2209	"##,
2209		*/
2210	2210
2211	2211	E0220: r##"
2212	2212	You used an associated type which isn't defined in the trait.
...	...	@@ -2727,14 +2727,9 @@ impl<T, U> CoerceUnsized<MyType<U>> for MyType<T>
2727	2727	[`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html
2728	2728	"##,
2729	2729
2730		/*
2731		// Associated consts can now be accessed through generic type parameters, and
2732		// this error is no longer emitted.
2733		//
2734		// FIXME: consider whether to leave it in the error index, or remove it entirely
2735		// as associated consts is not stabilized yet.
2736
2737	2730	E0329: r##"
	2731	#### Note: this error code is no longer emitted by the compiler.
	2732
2738	2733	An attempt was made to access an associated constant through either a generic
2739	2734	type parameter or `Self`. This is not supported yet. An example causing this
2740	2735	error is shown below:
...	...	@@ -2765,12 +2760,15 @@ trait Foo {
2765	2760
2766	2761	struct MyStruct;
2767	2762
	2763	impl Foo for MyStruct {
	2764	const BAR: f64 = 0f64;
	2765	}
	2766
2768	2767	fn get_bar_good() -> f64 {
2769	2768	<MyStruct as Foo>::BAR
2770	2769	}
2771	2770	```
2772	2771	"##,
2773		*/
2774	2772
2775	2773	E0366: r##"
2776	2774	An attempt was made to implement `Drop` on a concrete specialization of a
...	...	@@ -4973,7 +4971,7 @@ and the pin is required to keep it in the same place in memory.
4973	4971	// between structures with the same definition
4974	4972	// E0558, // replaced with a generic attribute input check
4975	4973	// E0563, // cannot determine a type for this `impl Trait` removed in 6383de15
4976		E0564, // only named lifetimes are allowed in `impl Trait`,
	4974	// E0564, // only named lifetimes are allowed in `impl Trait`,
4977	4975	// but `{}` was found in the type `{}`
4978	4976	E0587, // type has conflicting packed and align representation hints
4979	4977	E0588, // packed type cannot transitively contain a `[repr(align)]` type
...	...	@@ -4986,7 +4984,7 @@ and the pin is required to keep it in the same place in memory.
4986	4984	E0634, // type has conflicting packed representaton hints
4987	4985	E0640, // infer outlives requirements
4988	4986	E0641, // cannot cast to/from a pointer with an unknown kind
4989		E0645, // trait aliases not finished
	4987	// E0645, // trait aliases not finished
4990	4988	E0719, // duplicate values for associated type binding
4991	4989	E0722, // Malformed `#[optimize]` attribute
4992	4990	E0724, // `#[ffi_returns_twice]` is only allowed in foreign functions

src/libsyntax/early_buffered_lints.rs+1

...	...	@@ -11,6 +11,7 @@ use syntax_pos::MultiSpan;
11	11	pub enum BufferedEarlyLintId {
12	12	IllFormedAttributeInput,
13	13	MetaVariableMisuse,
	14	IncompleteInclude,
14	15	}
15	16
16	17	/// Stores buffered lint info which can later be passed to `librustc`.

src/libsyntax_ext/source_util.rs+11-1

...	...	@@ -5,6 +5,7 @@ use syntax::print::pprust;
5	5	use syntax::ptr::P;
6	6	use syntax::symbol::Symbol;
7	7	use syntax::tokenstream::TokenStream;
	8	use syntax::early_buffered_lints::BufferedEarlyLintId;
8	9
9	10	use smallvec::SmallVec;
10	11	use syntax_pos::{self, Pos, Span};
...	...	@@ -83,7 +84,16 @@ pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
83	84	}
84	85	impl<'a> base::MacResult for ExpandResult<'a> {
85	86	fn make_expr(mut self: Box<ExpandResult<'a>>) -> Option<P<ast::Expr>> {
86		Some(panictry!(self.p.parse_expr()))
	87	let r = panictry!(self.p.parse_expr());
	88	if self.p.token != token::Eof {
	89	self.p.sess.buffer_lint(
	90	BufferedEarlyLintId::IncompleteInclude,
	91	self.p.token.span,
	92	ast::CRATE_NODE_ID,
	93	"include macro expected single expression in source",
	94	);
	95	}
	96	Some(r)
87	97	}
88	98
89	99	fn make_items(mut self: Box<ExpandResult<'a>>) -> Option<SmallVec<[P<ast::Item>; 1]>> {

src/test/ui/if/if-no-match-bindings.stderr+4-4

...	...	@@ -29,7 +29,7 @@ LL \| if &true {}
29	29	\| ^^^^^
30	30	\| \|
31	31	\| expected bool, found &bool
32		\| help: consider dereferencing the borrow: `*&true`
	32	\| help: consider removing the borrow: `true`
33	33	\|
34	34	= note: expected type `bool`
35	35	found type `&bool`
...	...	@@ -41,7 +41,7 @@ LL \| if &mut true {}
41	41	\| ^^^^^^^^^
42	42	\| \|
43	43	\| expected bool, found &mut bool
44		\| help: consider dereferencing the borrow: `*&mut true`
	44	\| help: consider removing the borrow: `true`
45	45	\|
46	46	= note: expected type `bool`
47	47	found type `&mut bool`
...	...	@@ -77,7 +77,7 @@ LL \| while &true {}
77	77	\| ^^^^^
78	78	\| \|
79	79	\| expected bool, found &bool
80		\| help: consider dereferencing the borrow: `*&true`
	80	\| help: consider removing the borrow: `true`
81	81	\|
82	82	= note: expected type `bool`
83	83	found type `&bool`
...	...	@@ -89,7 +89,7 @@ LL \| while &mut true {}
89	89	\| ^^^^^^^^^
90	90	\| \|
91	91	\| expected bool, found &mut bool
92		\| help: consider dereferencing the borrow: `*&mut true`
	92	\| help: consider removing the borrow: `true`
93	93	\|
94	94	= note: expected type `bool`
95	95	found type `&mut bool`

src/test/ui/include-single-expr-helper-1.rs created+5

...	...	@@ -0,0 +1,5 @@
	1	// ignore-test auxiliary file for include-single-expr.rs
	2
	3	0
	4
	5	// trailing comment permitted

src/test/ui/include-single-expr-helper.rs created+5

...	...	@@ -0,0 +1,5 @@
	1	// ignore-test auxiliary file for include-single-expr.rs
	2
	3	0
	4	10
	5	100

src/test/ui/include-single-expr.rs created+6

...	...	@@ -0,0 +1,6 @@
	1	// error-pattern include macro expected single expression
	2
	3	fn main() {
	4	include!("include-single-expr-helper.rs");
	5	include!("include-single-expr-helper-1.rs");
	6	}

src/test/ui/include-single-expr.stderr created+10

...	...	@@ -0,0 +1,10 @@
	1	error: include macro expected single expression in source
	2	--> $DIR/include-single-expr-helper.rs:4:1
	3	\|
	4	LL \| 10
	5	\| ^^
	6	\|
	7	= note: `#[deny(incomplete_include)]` on by default
	8
	9	error: aborting due to previous error
	10

src/test/ui/inner-static-type-parameter.stderr+1-3

...	...	@@ -2,9 +2,7 @@ error[E0401]: can't use generic parameters from outer function
2	2	--> $DIR/inner-static-type-parameter.rs:6:19
3	3	\|
4	4	LL \| fn foo<T>() {
5		\| --- - type parameter from outer function
6		\| \|
7		\| try adding a local generic parameter in this method instead
	5	\| - type parameter from outer function
8	6	LL \| static a: Bar<T> = Bar::What;
9	7	\| ^ use of generic parameter from outer function
10	8

src/test/ui/resolve/issue-65025-extern-static-parent-generics.rs created+10

...	...	@@ -0,0 +1,10 @@
	1	unsafe fn foo<A>() {
	2	extern "C" {
	3	static baz: *const A;
	4	//~^ ERROR can't use generic parameters from outer function
	5	}
	6
	7	let bar: *const u64 = core::mem::transmute(&baz);
	8	}
	9
	10	fn main() { }

src/test/ui/resolve/issue-65025-extern-static-parent-generics.stderr created+12

...	...	@@ -0,0 +1,12 @@
	1	error[E0401]: can't use generic parameters from outer function
	2	--> $DIR/issue-65025-extern-static-parent-generics.rs:3:28
	3	\|
	4	LL \| unsafe fn foo<A>() {
	5	\| - type parameter from outer function
	6	LL \| extern "C" {
	7	LL \| static baz: *const A;
	8	\| ^ use of generic parameter from outer function
	9
	10	error: aborting due to previous error
	11
	12	For more information about this error, try `rustc --explain E0401`.

src/test/ui/resolve/issue-65035-static-with-parent-generics.rs created+29

...	...	@@ -0,0 +1,29 @@
	1	#![feature(const_generics)]
	2	//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
	3
	4	fn f<T>() {
	5	extern "C" {
	6	static a: *const T;
	7	//~^ ERROR can't use generic parameters from outer function
	8	}
	9	}
	10
	11	fn g<T: Default>() {
	12	static a: *const T = Default::default();
	13	//~^ ERROR can't use generic parameters from outer function
	14	}
	15
	16	fn h<const N: usize>() {
	17	extern "C" {
	18	static a: [u8; N];
	19	//~^ ERROR can't use generic parameters from outer function
	20	}
	21	}
	22
	23	fn i<const N: usize>() {
	24	static a: [u8; N] = [0; N];
	25	//~^ ERROR can't use generic parameters from outer function
	26	//~^^ ERROR can't use generic parameters from outer function
	27	}
	28
	29	fn main() {}

src/test/ui/resolve/issue-65035-static-with-parent-generics.stderr created+53

...	...	@@ -0,0 +1,53 @@
	1	error[E0401]: can't use generic parameters from outer function
	2	--> $DIR/issue-65035-static-with-parent-generics.rs:6:26
	3	\|
	4	LL \| fn f<T>() {
	5	\| - type parameter from outer function
	6	LL \| extern "C" {
	7	LL \| static a: *const T;
	8	\| ^ use of generic parameter from outer function
	9
	10	error[E0401]: can't use generic parameters from outer function
	11	--> $DIR/issue-65035-static-with-parent-generics.rs:12:22
	12	\|
	13	LL \| fn g<T: Default>() {
	14	\| - type parameter from outer function
	15	LL \| static a: *const T = Default::default();
	16	\| ^ use of generic parameter from outer function
	17
	18	error[E0401]: can't use generic parameters from outer function
	19	--> $DIR/issue-65035-static-with-parent-generics.rs:18:24
	20	\|
	21	LL \| fn h<const N: usize>() {
	22	\| - const parameter from outer function
	23	LL \| extern "C" {
	24	LL \| static a: [u8; N];
	25	\| ^ use of generic parameter from outer function
	26
	27	error[E0401]: can't use generic parameters from outer function
	28	--> $DIR/issue-65035-static-with-parent-generics.rs:24:20
	29	\|
	30	LL \| fn i<const N: usize>() {
	31	\| - const parameter from outer function
	32	LL \| static a: [u8; N] = [0; N];
	33	\| ^ use of generic parameter from outer function
	34
	35	error[E0401]: can't use generic parameters from outer function
	36	--> $DIR/issue-65035-static-with-parent-generics.rs:24:29
	37	\|
	38	LL \| fn i<const N: usize>() {
	39	\| - const parameter from outer function
	40	LL \| static a: [u8; N] = [0; N];
	41	\| ^ use of generic parameter from outer function
	42
	43	warning: the feature `const_generics` is incomplete and may cause the compiler to crash
	44	--> $DIR/issue-65035-static-with-parent-generics.rs:1:12
	45	\|
	46	LL \| #![feature(const_generics)]
	47	\| ^^^^^^^^^^^^^^
	48	\|
	49	= note: `#[warn(incomplete_features)]` on by default
	50
	51	error: aborting due to 5 previous errors
	52
	53	For more information about this error, try `rustc --explain E0401`.

src/test/ui/rfc-2497-if-let-chains/disallowed-positions.stderr+2-2

...	...	@@ -520,7 +520,7 @@ LL \| if &let 0 = 0 {}
520	520	\| ^^^^^^^^^^
521	521	\| \|
522	522	\| expected bool, found &bool
523		\| help: consider dereferencing the borrow: `*&let 0 = 0`
	523	\| help: consider removing the borrow: `let 0 = 0`
524	524	\|
525	525	= note: expected type `bool`
526	526	found type `&bool`
...	...	@@ -708,7 +708,7 @@ LL \| while &let 0 = 0 {}
708	708	\| ^^^^^^^^^^
709	709	\| \|
710	710	\| expected bool, found &bool
711		\| help: consider dereferencing the borrow: `*&let 0 = 0`
	711	\| help: consider removing the borrow: `let 0 = 0`
712	712	\|
713	713	= note: expected type `bool`
714	714	found type `&bool`

src/test/ui/suggestions/remove-as_str.stderr+4-4

...	...	@@ -2,25 +2,25 @@ error[E0599]: no method named `as_str` found for type `&str` in the current scop
2	2	--> $DIR/remove-as_str.rs:2:7
3	3	\|
4	4	LL \| s.as_str();
5		\| ^^^^^^ try removing `as_str`
	5	\| -^^^^^^-- help: remove this method call
6	6
7	7	error[E0599]: no method named `as_str` found for type `&'a str` in the current scope
8	8	--> $DIR/remove-as_str.rs:7:7
9	9	\|
10	10	LL \| s.as_str();
11		\| ^^^^^^ try removing `as_str`
	11	\| -^^^^^^-- help: remove this method call
12	12
13	13	error[E0599]: no method named `as_str` found for type `&mut str` in the current scope
14	14	--> $DIR/remove-as_str.rs:12:7
15	15	\|
16	16	LL \| s.as_str();
17		\| ^^^^^^ try removing `as_str`
	17	\| -^^^^^^-- help: remove this method call
18	18
19	19	error[E0599]: no method named `as_str` found for type `&&str` in the current scope
20	20	--> $DIR/remove-as_str.rs:17:7
21	21	\|
22	22	LL \| s.as_str();
23		\| ^^^^^^ try removing `as_str`
	23	\| -^^^^^^-- help: remove this method call
24	24
25	25	error: aborting due to 4 previous errors
26	26

src/tools/error_index_generator/build.rs+1-1

...	...	@@ -15,7 +15,7 @@ fn main() {
15	15	println!("cargo:rerun-if-changed={}", entry.path().to_str().unwrap());
16	16	let file = fs::read_to_string(entry.path()).unwrap()
17	17	.replace("syntax::register_diagnostics!", "register_diagnostics!");
18		let contents = format!("(\|\| {{\n{}\n}})();", file);
	18	let contents = format!("(\|\| {{\n{}\n}})()", file);
19	19
20	20	fs::write(&out_dir.join(&format!("error_{}.rs", idx)), &contents).unwrap();
21	21

src/tools/tidy/src/error_codes_check.rs created+137

...	...	@@ -0,0 +1,137 @@
	1	//! Checks that all error codes have at least one test to prevent having error
	2	//! codes that are silently not thrown by the compiler anymore.
	3
	4	use std::collections::HashMap;
	5	use std::ffi::OsStr;
	6	use std::path::Path;
	7
	8	// A few of those error codes can't be tested but all the others can and should be tested!
	9	const WHITELIST: &[&str] = &[
	10	"E0183",
	11	"E0227",
	12	"E0279",
	13	"E0280",
	14	"E0311",
	15	"E0313",
	16	"E0314",
	17	"E0315",
	18	"E0377",
	19	"E0456",
	20	"E0461",
	21	"E0462",
	22	"E0464",
	23	"E0465",
	24	"E0472",
	25	"E0473",
	26	"E0474",
	27	"E0475",
	28	"E0476",
	29	"E0479",
	30	"E0480",
	31	"E0481",
	32	"E0482",
	33	"E0483",
	34	"E0484",
	35	"E0485",
	36	"E0486",
	37	"E0487",
	38	"E0488",
	39	"E0489",
	40	"E0514",
	41	"E0519",
	42	"E0523",
	43	"E0526",
	44	"E0554",
	45	"E0570",
	46	"E0629",
	47	"E0630",
	48	"E0640",
	49	"E0717",
	50	"E0727",
	51	"E0729",
	52	];
	53
	54	fn extract_error_codes(f: &str, error_codes: &mut HashMap<String, bool>) {
	55	let mut reached_no_explanation = false;
	56	let mut last_error_code = None;
	57
	58	for line in f.lines() {
	59	let s = line.trim();
	60	if s.starts_with('E') && s.ends_with(": r##\"") {
	61	if let Some(err_code) = s.splitn(2, ':').next() {
	62	let err_code = err_code.to_owned();
	63	last_error_code = Some(err_code.clone());
	64	if !error_codes.contains_key(&err_code) {
	65	error_codes.insert(err_code, false);
	66	}
	67	}
	68	} else if s.starts_with("```") && s.contains("compile_fail") && s.contains('E') {
	69	if let Some(err_code) = s.splitn(2, 'E').skip(1).next() {
	70	if let Some(err_code) = err_code.splitn(2, ',').next() {
	71	let nb = error_codes.entry(format!("E{}", err_code)).or_insert(false);
	72	*nb = true;
	73	}
	74	}
	75	} else if s == ";" {
	76	reached_no_explanation = true;
	77	} else if reached_no_explanation && s.starts_with('E') {
	78	if let Some(err_code) = s.splitn(2, ',').next() {
	79	let err_code = err_code.to_owned();
	80	if !error_codes.contains_key(&err_code) { // this check should never fail!
	81	error_codes.insert(err_code, false);
	82	}
	83	}
	84	} else if s.starts_with("#### Note: this error code is no longer emitted by the compiler") {
	85	if let Some(last) = last_error_code {
	86	error_codes.get_mut(&last).map(\|x\| *x = true);
	87	}
	88	last_error_code = None;
	89	}
	90	}
	91	}
	92
	93	fn extract_error_codes_from_tests(f: &str, error_codes: &mut HashMap<String, bool>) {
	94	for line in f.lines() {
	95	let s = line.trim();
	96	if s.starts_with("error[E") \|\| s.starts_with("warning[E") {
	97	if let Some(err_code) = s.splitn(2, ']').next() {
	98	if let Some(err_code) = err_code.splitn(2, '[').skip(1).next() {
	99	let nb = error_codes.entry(err_code.to_owned()).or_insert(false);
	100	*nb = true;
	101	}
	102	}
	103	}
	104	}
	105	}
	106
	107	pub fn check(path: &Path, bad: &mut bool) {
	108	println!("Checking which error codes lack tests...");
	109	let mut error_codes: HashMap<String, bool> = HashMap::new();
	110	super::walk(path,
	111	&mut \|path\| super::filter_dirs(path),
	112	&mut \|entry, contents\| {
	113	let file_name = entry.file_name();
	114	if file_name == "error_codes.rs" {
	115	extract_error_codes(contents, &mut error_codes);
	116	} else if entry.path().extension() == Some(OsStr::new("stderr")) {
	117	extract_error_codes_from_tests(contents, &mut error_codes);
	118	}
	119	});
	120	println!("Found {} error codes", error_codes.len());
	121
	122	let mut errors = Vec::new();
	123	for (err_code, nb) in &error_codes {
	124	if !*nb && !WHITELIST.contains(&err_code.as_str()) {
	125	errors.push(format!("Error code {} needs to have at least one UI test!", err_code));
	126	}
	127	}
	128	errors.sort();
	129	for err in &errors {
	130	eprintln!("{}", err);
	131	}
	132	println!("Found {} error codes with no tests", errors.len());
	133	if !errors.is_empty() {
	134	*bad = true;
	135	}
	136	println!("Done!");
	137	}

src/tools/tidy/src/lib.rs+1

...	...	@@ -41,6 +41,7 @@ pub mod extdeps;
41	41	pub mod ui_tests;
42	42	pub mod unit_tests;
43	43	pub mod unstable_book;
	44	pub mod error_codes_check;
44	45
45	46	fn filter_dirs(path: &Path) -> bool {
46	47	let skip = [

src/tools/tidy/src/main.rs+1

...	...	@@ -35,6 +35,7 @@ fn main() {
35	35	deps::check_whitelist(&path, &cargo, &mut bad);
36	36	extdeps::check(&path, &mut bad);
37	37	ui_tests::check(&path, &mut bad);
	38	error_codes_check::check(&path, &mut bad);
38	39
39	40	if bad {
40	41	eprintln!("some tidy checks failed");

author	bors <bors@rust-lang.org> 2019-10-08 21:32:07 UTC
committer	bors <bors@rust-lang.org> 2019-10-08 21:32:07 UTC
log	b5bd31ec6db6a249311888a93fc176f06dcb6aa6
tree	8d6c88672d85193d1a53f3a72c703f886b501071
parent	2748a9fd93dd1a00a4521f4f16de5befbf77f6cd
parent	ff51611c42d160f95a01d556045d32f0539d8989

Auto merge of #65223 - Centril:rollup-5sdvdni, r=Centril