## Trademark
-The Rust programming language is an open source, community project governed
-by a core team. It is also sponsored by the Mozilla Foundation (“Mozilla”),
-which owns and protects the Rust and Cargo trademarks and logos
-(the “Rust Trademarks”).
+[The Rust Foundation][rust-foundation] owns and protects the Rust and Cargo
+trademarks and logos (the “Rust Trademarks”).
If you want to use these names or brands, please read the [media guide][media-guide].
Third-party logos may be subject to third-party copyrights and trademarks. See
[Licenses][policies-licenses] for details.
+[rust-foundation]: https://foundation.rust-lang.org/
[media-guide]: https://www.rust-lang.org/policies/media-guide
[policies-licenses]: https://www.rust-lang.org/policies/licenses
use rustc_save_analysis as save;
use rustc_save_analysis::DumpHandler;
use rustc_serialize::json::{self, ToJson};
-use rustc_session::config::nightly_options;
+use rustc_session::config::{nightly_options, CG_OPTIONS, DB_OPTIONS};
use rustc_session::config::{ErrorOutputType, Input, OutputType, PrintRequest, TrimmedDefPaths};
use rustc_session::getopts;
use rustc_session::lint::{Lint, LintId};
for option in config::rustc_optgroups() {
(option.apply)(&mut options);
}
- let matches = options
- .parse(args)
- .unwrap_or_else(|f| early_error(ErrorOutputType::default(), &f.to_string()));
+ let matches = options.parse(args).unwrap_or_else(|e| {
+ let msg = match e {
+ getopts::Fail::UnrecognizedOption(ref opt) => CG_OPTIONS
+ .iter()
+ .map(|&(name, ..)| ('C', name))
+ .chain(DB_OPTIONS.iter().map(|&(name, ..)| ('Z', name)))
+ .find(|&(_, name)| *opt == name.replace("_", "-"))
+ .map(|(flag, _)| format!("{}. Did you mean `-{} {}`?", e, flag, opt)),
+ _ => None,
+ };
+ early_error(ErrorOutputType::default(), &msg.unwrap_or_else(|| e.to_string()));
+ });
// For all options we just parsed, we check a few aspects:
//
E0627: include_str!("./error_codes/E0627.md"),
E0628: include_str!("./error_codes/E0628.md"),
E0631: include_str!("./error_codes/E0631.md"),
+E0632: include_str!("./error_codes/E0632.md"),
E0633: include_str!("./error_codes/E0633.md"),
E0634: include_str!("./error_codes/E0634.md"),
E0635: include_str!("./error_codes/E0635.md"),
// E0629, // missing 'feature' (rustc_const_unstable)
// E0630, // rustc_const_unstable attribute must be paired with stable/unstable
// attribute
- E0632, // cannot provide explicit generic arguments when `impl Trait` is
- // used in argument position
E0640, // infer outlives requirements
// E0645, // trait aliases not finished
E0667, // `impl Trait` in projections
--- /dev/null
+An explicit generic argument was provided when calling a function that
+uses `impl Trait` in argument position.
+
+Erroneous code example:
+
+```compile_fail,E0632
+fn foo<T: Copy>(a: T, b: impl Clone) {}
+
+foo::<i32>(0i32, "abc".to_string());
+```
+
+Either all generic arguments should be inferred at the call site, or
+the function definition should use an explicit generic type parameter
+instead of `impl Trait`. Example:
+
+```
+fn foo<T: Copy>(a: T, b: impl Clone) {}
+fn bar<T: Copy, U: Clone>(a: T, b: U) {}
+
+foo(0i32, "abc".to_string());
+
+bar::<i32, String>(0i32, "abc".to_string());
+bar::<_, _>(0i32, "abc".to_string());
+bar(0i32, "abc".to_string());
+```
///
/// ### Explanation
///
- /// An function with generics must have its symbol mangled to accommodate
+ /// A function with generics must have its symbol mangled to accommodate
/// the generic parameter. The [`no_mangle` attribute] has no effect in
/// this situation, and should be removed.
///
let fn_data = if let hir::ImplItemKind::Fn(ref sig, body) = ast_item.kind {
FnData {
asyncness: sig.header.asyncness,
- constness: sig.header.constness,
+ // Can be inside `impl const Trait`, so using sig.header.constness is not reliable
+ constness: if self.tcx.is_const_fn_raw(def_id) {
+ hir::Constness::Const
+ } else {
+ hir::Constness::NotConst
+ },
param_names: self.encode_fn_param_names_for_body(body),
}
} else {
};
let encl_item_id = self.tcx.hir().get_parent_item(expr.hir_id);
- let encl_item = self.tcx.hir().expect_item(encl_item_id);
- if let hir::ItemKind::Fn(..) = encl_item.kind {
+ if let Some(hir::Node::Item(hir::Item {
+ kind: hir::ItemKind::Fn(..),
+ span: encl_fn_span,
+ ..
+ }))
+ | Some(hir::Node::TraitItem(hir::TraitItem {
+ kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),
+ span: encl_fn_span,
+ ..
+ }))
+ | Some(hir::Node::ImplItem(hir::ImplItem {
+ kind: hir::ImplItemKind::Fn(..),
+ span: encl_fn_span,
+ ..
+ })) = self.tcx.hir().find(encl_item_id)
+ {
// We are inside a function body, so reporting "return statement
// outside of function body" needs an explanation.
let encl_body = self.tcx.hir().body(encl_body_id);
err.encl_body_span = Some(encl_body.value.span);
- err.encl_fn_span = Some(encl_item.span);
+ err.encl_fn_span = Some(*encl_fn_span);
}
self.tcx.sess.emit_err(err);
Ok(())
}
- #[cfg(not(no_global_oom_handling))]
fn shrink(&mut self, amount: usize) -> Result<(), TryReserveError> {
assert!(amount <= self.capacity(), "Tried to shrink to a larger capacity");
// Copy over lld if it's there
if builder.config.lld_enabled {
- let exe = exe("rust-lld", compiler.host);
- builder.copy(&src_dir.join(&exe), &dst_dir.join(&exe));
+ let rust_lld = exe("rust-lld", compiler.host);
+ builder.copy(&src_dir.join(&rust_lld), &dst_dir.join(&rust_lld));
// for `-Z gcc-ld=lld`
let gcc_lld_dir = dst_dir.join("gcc-ld");
t!(fs::create_dir(&gcc_lld_dir));
- builder.copy(&src_dir.join(&exe), &gcc_lld_dir.join(&exe));
+ builder.copy(&src_dir.join(&rust_lld), &gcc_lld_dir.join(exe("ld", compiler.host)));
}
// Copy over llvm-dwp if it's there
results_returned[fullId].lev =
Math.min(results_returned[fullId].lev, returned);
}
- if (index !== -1 || lev <= MAX_LEV_DISTANCE) {
+ if (typePassesFilter(typeFilter, ty.ty) &&
+ (index !== -1 || lev <= MAX_LEV_DISTANCE)) {
if (index !== -1 && paths.length < 2) {
lev = 0;
}
--- /dev/null
+// exact-check
+
+const QUERY = 'macro:print';
+
+const EXPECTED = {
+ 'others': [
+ { 'path': 'std', 'name': 'print' },
+ { 'path': 'std', 'name': 'eprint' },
+ { 'path': 'std', 'name': 'println' },
+ { 'path': 'std', 'name': 'eprintln' },
+ ],
+};
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0632`.
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0632`.
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0632`.
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0632`.
--- /dev/null
+// compile-flags: --llvm-args
--- /dev/null
+error: Unrecognized option: 'llvm-args'. Did you mean `-C llvm-args`?
+
--- /dev/null
+// compile-flags: --unpretty=hir
--- /dev/null
+error: Unrecognized option: 'unpretty'. Did you mean `-Z unpretty`?
+
}]
};
+struct S {}
+trait Tr {
+ fn foo();
+ fn bar() {
+ //~^ NOTE: ...not the enclosing function body
+ [(); return];
+ //~^ ERROR: return statement outside of function body [E0572]
+ //~| NOTE: the return is part of this body...
+ }
+}
+impl Tr for S {
+ fn foo() {
+ //~^ NOTE: ...not the enclosing function body
+ [(); return];
+ //~^ ERROR: return statement outside of function body [E0572]
+ //~| NOTE: the return is part of this body...
+ }
+}
+
fn main() {
//~^ NOTE: ...not the enclosing function body
[(); return || {
| |_____^
error[E0572]: return statement outside of function body
- --> $DIR/issue-86188-return-not-in-fn-body.rs:17:10
+ --> $DIR/issue-86188-return-not-in-fn-body.rs:20:14
+ |
+LL | / fn bar() {
+LL | |
+LL | | [(); return];
+ | | ^^^^^^ the return is part of this body...
+LL | |
+LL | |
+LL | | }
+ | |_____- ...not the enclosing function body
+
+error[E0572]: return statement outside of function body
+ --> $DIR/issue-86188-return-not-in-fn-body.rs:28:14
+ |
+LL | / fn foo() {
+LL | |
+LL | | [(); return];
+ | | ^^^^^^ the return is part of this body...
+LL | |
+LL | |
+LL | | }
+ | |_____- ...not the enclosing function body
+
+error[E0572]: return statement outside of function body
+ --> $DIR/issue-86188-return-not-in-fn-body.rs:36:10
|
LL | / fn main() {
LL | |
LL | | }
| |_- ...not the enclosing function body
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0572`.
--- /dev/null
+#![feature(const_trait_impl)]
+#![allow(incomplete_features)]
+
+pub trait MyTrait {
+ fn func(self);
+}
+
+pub struct NonConst;
+
+impl MyTrait for NonConst {
+ fn func(self) {
+
+ }
+}
+
+pub struct Const;
+
+impl const MyTrait for Const {
+ fn func(self) {
+
+ }
+}
--- /dev/null
+// aux-build: cross-crate.rs
+extern crate cross_crate;
+
+use cross_crate::*;
+
+fn non_const_context() {
+ NonConst.func();
+ Const.func();
+}
+
+const fn const_context() {
+ NonConst.func();
+ //~^ ERROR: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ Const.func();
+ //~^ ERROR: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+}
+
+fn main() {}
--- /dev/null
+error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/cross-crate-feature-disabled.rs:12:5
+ |
+LL | NonConst.func();
+ | ^^^^^^^^^^^^^^^
+
+error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/cross-crate-feature-disabled.rs:14:5
+ |
+LL | Const.func();
+ | ^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0015`.
--- /dev/null
+#![feature(const_trait_impl)]
+#![allow(incomplete_features)]
+
+// aux-build: cross-crate.rs
+extern crate cross_crate;
+
+use cross_crate::*;
+
+fn non_const_context() {
+ NonConst.func();
+ Const.func();
+}
+
+const fn const_context() {
+ NonConst.func();
+ //~^ ERROR: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ Const.func();
+}
+
+fn main() {}
--- /dev/null
+error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/cross-crate-feature-enabled.rs:15:5
+ |
+LL | NonConst.func();
+ | ^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0015`.
error: aborting due to 3 previous errors
+For more information about this error, try `rustc --explain E0632`.
--- /dev/null
+error[E0572]: return statement outside of function body
+ --> $DIR/issue-86721-return-expr-ice.rs:9:22
+ |
+LL | const U: usize = return;
+ | ^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0572`.
--- /dev/null
+error[E0572]: return statement outside of function body
+ --> $DIR/issue-86721-return-expr-ice.rs:15:20
+ |
+LL | fn foo(a: [(); return]);
+ | ^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0572`.
--- /dev/null
+// Regression test for the ICE described in #86721.
+
+// revisions: rev1 rev2
+#![cfg_attr(any(), rev1, rev2)]
+#![crate_type="lib"]
+
+#[cfg(any(rev1))]
+trait T {
+ const U: usize = return;
+ //[rev1]~^ ERROR: return statement outside of function body [E0572]
+}
+
+#[cfg(any(rev2))]
+trait T2 {
+ fn foo(a: [(); return]);
+ //[rev2]~^ ERROR: return statement outside of function body [E0572]
+}
projects / rust.git / commitdiff