nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 23:12:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #80867 - JohnTitor:rollup-tvqw555, r=JohnTitor

Browse Source 
Rollup of 9 pull requests

Successful merges:

 - #79502 (Implement From<char> for u64 and u128.)
 - #79968 (Improve core::ptr::drop_in_place debuginfo)
 - #80774 (Fix safety comment)
 - #80801 (Use correct span for structured suggestion)
 - #80803 (Remove useless `fill_in` function)
 - #80820 (Support `download-ci-llvm` on NixOS)
 - #80825 (Remove under-used ImplPolarity enum)
 - #80850 (Allow #[rustc_builtin_macro = "name"])
 - #80857 (Add comment to `Vec::truncate` explaining `>` vs `>=`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2021-01-10 08:01:12 +00:00
commit 34628e5b53
45 changed files with 298 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_builtin_macros/src/lib.rs
View File

@ -48,7 +48,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand, edition: Editi
let mut register = |name, kind| {
resolver.register_builtin_macro(
Ident::with_dummy_span(name),
SyntaxExtension { is_builtin: true, ..SyntaxExtension::default(kind, edition) },
SyntaxExtension::default(kind, edition),
)
};
macro register_bang($($name:ident: $f:expr,)*) {

14
compiler/rustc_expand/src/base.rs
View File

@ -728,9 +728,7 @@ pub struct SyntaxExtension {
pub edition: Edition,
/// Built-in macros have a couple of special properties like availability
/// in `#[no_implicit_prelude]` modules, so we have to keep this flag.
pub is_builtin: bool,
/// We have to identify macros providing a `Copy` impl early for compatibility reasons.
pub is_derive_copy: bool,
pub builtin_name: Option<Symbol>,
}
impl SyntaxExtension {
@ -758,8 +756,7 @@ impl SyntaxExtension {
deprecation: None,
helper_attrs: Vec::new(),
edition,
is_builtin: false,
is_derive_copy: false,
builtin_name: None,
kind,
}
}
@ -785,7 +782,9 @@ impl SyntaxExtension {
}
}
let is_builtin = sess.contains_name(attrs, sym::rustc_builtin_macro);
let builtin_name = sess
.find_by_name(attrs, sym::rustc_builtin_macro)
.map(|a| a.value_str().unwrap_or(name));
let (stability, const_stability) = attr::find_stability(&sess, attrs, span);
if const_stability.is_some() {
sess.parse_sess
@ -803,8 +802,7 @@ impl SyntaxExtension {
deprecation: attr::find_deprecation(&sess, attrs).map(|(d, _)| d),
helper_attrs,
edition,
is_builtin,
is_derive_copy: is_builtin && name == sym::Copy,
builtin_name,
}
}

2
compiler/rustc_feature/src/builtin_attrs.rs
View File

@ -442,7 +442,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
// Internal attributes, Macro related:
// ==========================================================================
rustc_attr!(rustc_builtin_macro, AssumedUsed, template!(Word), IMPL_DETAIL),
rustc_attr!(rustc_builtin_macro, AssumedUsed, template!(Word, NameValueStr: "name"), IMPL_DETAIL),
rustc_attr!(rustc_proc_macro_decls, Normal, template!(Word), INTERNAL_UNSTABLE),
rustc_attr!(
rustc_macro_transparency, AssumedUsed,

26
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -398,20 +398,30 @@ impl<'a> Resolver<'a> {
err.help("use the `|| { ... }` closure form instead");
err
}
ResolutionError::AttemptToUseNonConstantValueInConstant(ident, sugg) => {
ResolutionError::AttemptToUseNonConstantValueInConstant(ident, sugg, current) => {
let mut err = struct_span_err!(
self.session,
span,
E0435,
"attempt to use a non-constant value in a constant"
);
err.span_suggestion(
ident.span,
&sugg,
"".to_string(),
Applicability::MaybeIncorrect,
);
err.span_label(span, "non-constant value");
// let foo =...
// ^^^ given this Span
// ------- get this Span to have an applicable suggestion
let sp =
self.session.source_map().span_extend_to_prev_str(ident.span, current, true);
if sp.lo().0 == 0 {
err.span_label(ident.span, &format!("this would need to be a `{}`", sugg));
} else {
let sp = sp.with_lo(BytePos(sp.lo().0 - current.len() as u32));
err.span_suggestion(
sp,
&format!("consider using `{}` instead of `{}`", sugg, current),
format!("{} {}", sugg, ident),
Applicability::MaybeIncorrect,
);
err.span_label(span, "non-constant value");
}
err
}
ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => {

25
compiler/rustc_resolve/src/lib.rs
View File

@ -210,7 +210,11 @@ enum ResolutionError<'a> {
/// Error E0434: can't capture dynamic environment in a fn item.
CannotCaptureDynamicEnvironmentInFnItem,
/// Error E0435: attempt to use a non-constant value in a constant.
AttemptToUseNonConstantValueInConstant(Ident, String),
AttemptToUseNonConstantValueInConstant(
Ident,
/* suggestion */ &'static str,
/* current */ &'static str,
),
/// Error E0530: `X` bindings cannot shadow `Y`s.
BindingShadowsSomethingUnacceptable(&'static str, Symbol, &'a NameBinding<'a>),
/// Error E0128: type parameters with a default cannot use forward-declared identifiers.
@ -1443,7 +1447,7 @@ impl<'a> Resolver<'a> {
}
fn is_builtin_macro(&mut self, res: Res) -> bool {
self.get_macro(res).map_or(false, |ext| ext.is_builtin)
self.get_macro(res).map_or(false, |ext| ext.builtin_name.is_some())
}
fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId {
@ -2010,7 +2014,7 @@ impl<'a> Resolver<'a> {
// The macro is a proc macro derive
if let Some(def_id) = module.expansion.expn_data().macro_def_id {
let ext = self.get_macro_by_def_id(def_id);
if !ext.is_builtin
if ext.builtin_name.is_none()
&& ext.macro_kind() == MacroKind::Derive
&& parent.expansion.outer_expn_is_descendant_of(span.ctxt())
{
@ -2614,18 +2618,19 @@ impl<'a> Resolver<'a> {
ConstantItemKind::Const => "const",
ConstantItemKind::Static => "static",
};
let sugg = format!(
"consider using `let` instead of `{}`",
kind_str
);
(span, AttemptToUseNonConstantValueInConstant(ident, sugg))
(
span,
AttemptToUseNonConstantValueInConstant(
ident, "let", kind_str,
),
)
} else {
let sugg = "consider using `const` instead of `let`";
(
rib_ident.span,
AttemptToUseNonConstantValueInConstant(
original_rib_ident_def,
sugg.to_string(),
"const",
"let",
),
)
};

6
compiler/rustc_resolve/src/macros.rs
View File

@ -285,7 +285,7 @@ impl<'a> ResolverExpand for Resolver<'a> {
helper_attrs.extend(
ext.helper_attrs.iter().map(|name| Ident::new(*name, span)),
);
if ext.is_derive_copy {
if ext.builtin_name == Some(sym::Copy) {
self.containers_deriving_copy.insert(invoc_id);
}
ext
@ -1089,9 +1089,9 @@ impl<'a> Resolver<'a> {
edition,
);
if result.is_builtin {
if let Some(builtin_name) = result.builtin_name {
// The macro was marked with `#[rustc_builtin_macro]`.
if let Some(builtin_macro) = self.builtin_macros.get_mut(&item.ident.name) {
if let Some(builtin_macro) = self.builtin_macros.get_mut(&builtin_name) {
// The macro is a built-in, replace its expander function
// while still taking everything else from the source code.
// If we already loaded this builtin macro, give a better error message than 'no such builtin macro'.

4
compiler/rustc_span/src/source_map.rs
View File

@ -671,7 +671,9 @@ impl SourceMap {
let pat = pat.to_owned() + ws;
if let Ok(prev_source) = self.span_to_prev_source(sp) {
let prev_source = prev_source.rsplit(&pat).next().unwrap_or("").trim_start();
if !prev_source.is_empty() && (!prev_source.contains('\n') || accept_newlines) {
if prev_source.is_empty() && sp.lo().0 != 0 {
return sp.with_lo(BytePos(sp.lo().0 - 1));
} else if !prev_source.contains('\n') || accept_newlines {
return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32));
}
}

10
compiler/rustc_symbol_mangling/src/legacy.rs
View File

@ -56,7 +56,15 @@ pub(super) fn mangle(
let hash = get_symbol_hash(tcx, instance, instance_ty, instantiating_crate);
let mut printer = SymbolPrinter { tcx, path: SymbolPath::new(), keep_within_component: false }
.print_def_path(def_id, &[])
.print_def_path(
def_id,
if let ty::InstanceDef::DropGlue(_, _) = instance.def {
// Add the name of the dropped type to the symbol name
&*instance.substs
} else {
&[]
},
)
.unwrap();
if let ty::InstanceDef::VtableShim(..) = instance.def {

3
library/alloc/src/vec/mod.rs
View File

@ -990,6 +990,9 @@ impl<T, A: Allocator> Vec<T, A> {
// such that no value will be dropped twice in case `drop_in_place`
// were to panic once (if it panics twice, the program aborts).
unsafe {
// Note: It's intentional that this is `>` and not `>=`.
// Changing it to `>=` has negative performance
// implications in some cases. See #78884 for more.
if len > self.len {
return;
}

42
library/core/src/char/convert.rs
View File

@ -113,6 +113,48 @@ impl From<char> for u32 {
}
}
#[stable(feature = "more_char_conversions", since = "1.51.0")]
impl From<char> for u64 {
/// Converts a [`char`] into a [`u64`].
///
/// # Examples
///
/// ```
/// use std::mem;
///
/// let c = '👤';
/// let u = u64::from(c);
/// assert!(8 == mem::size_of_val(&u))
/// ```
#[inline]
fn from(c: char) -> Self {
// The char is casted to the value of the code point, then zero-extended to 64 bit.
// See [https://doc.rust-lang.org/reference/expressions/operator-expr.html#semantics]
c as u64
}
}
#[stable(feature = "more_char_conversions", since = "1.51.0")]
impl From<char> for u128 {
/// Converts a [`char`] into a [`u128`].
///
/// # Examples
///
/// ```
/// use std::mem;
///
/// let c = '⚙';
/// let u = u128::from(c);
/// assert!(16 == mem::size_of_val(&u))
/// ```
#[inline]
fn from(c: char) -> Self {
// The char is casted to the value of the code point, then zero-extended to 128 bit.
// See [https://doc.rust-lang.org/reference/expressions/operator-expr.html#semantics]
c as u128
}
}
/// Maps a byte in 0x00..=0xFF to a `char` whose code point has the same value, in U+0000..=U+00FF.
///
/// Unicode is designed such that this effectively decodes bytes

5
library/std/src/alloc.rs
View File

@ -166,8 +166,9 @@ impl System {
match old_layout.size() {
0 => self.alloc_impl(new_layout, zeroed),
// SAFETY: `new_size` is non-zero as `old_size` is greater than or equal to `new_size`
// as required by safety conditions. Other conditions must be upheld by the caller
// SAFETY: `new_size` is non-zero as `new_size` is greater than or equal to `old_size`
// as required by safety conditions and the `old_size == 0` case was handled in the
// previous match arm. Other conditions must be upheld by the caller
old_size if old_layout.align() == new_layout.align() => unsafe {
let new_size = new_layout.size();

23
src/bootstrap/bootstrap.py
View File

@ -413,7 +413,7 @@ class RustBuild(object):
lib_dir = "{}/lib".format(self.bin_root())
for lib in os.listdir(lib_dir):
if lib.endswith(".so"):
self.fix_bin_or_dylib("{}/{}".format(lib_dir, lib))
self.fix_bin_or_dylib(os.path.join(lib_dir, lib), rpath_libz=True)
with output(self.rustc_stamp()) as rust_stamp:
rust_stamp.write(self.date)
@ -451,10 +451,15 @@ class RustBuild(object):
"{}/src/bootstrap/download-ci-llvm-stamp".format(top_level),
]).decode(sys.getdefaultencoding()).strip()
llvm_assertions = self.get_toml('assertions', 'llvm') == 'true'
llvm_root = self.llvm_root()
llvm_lib = os.path.join(llvm_root, "lib")
if self.program_out_of_date(self.llvm_stamp(), llvm_sha + str(llvm_assertions)):
self._download_ci_llvm(llvm_sha, llvm_assertions)
for binary in ["llvm-config", "FileCheck"]:
self.fix_bin_or_dylib("{}/bin/{}".format(self.llvm_root(), binary))
self.fix_bin_or_dylib(os.path.join(llvm_root, "bin", binary), rpath_libz=True)
for lib in os.listdir(llvm_lib):
if lib.endswith(".so"):
self.fix_bin_or_dylib(os.path.join(llvm_lib, lib), rpath_libz=True)
with output(self.llvm_stamp()) as llvm_stamp:
llvm_stamp.write(llvm_sha + str(llvm_assertions))
@ -501,7 +506,7 @@ class RustBuild(object):
match="rust-dev",
verbose=self.verbose)
def fix_bin_or_dylib(self, fname):
def fix_bin_or_dylib(self, fname, rpath_libz=False):
"""Modifies the interpreter section of 'fname' to fix the dynamic linker,
or the RPATH section, to fix the dynamic library search path
@ -571,20 +576,22 @@ class RustBuild(object):
self.nix_deps_dir = nix_deps_dir
patchelf = "{}/patchelf/bin/patchelf".format(nix_deps_dir)
patchelf_args = []
if fname.endswith(".so"):
# Dynamic library, patch RPATH to point to system dependencies.
if rpath_libz:
# Patch RPATH to add `zlib` dependency that stems from LLVM
dylib_deps = ["zlib"]
rpath_entries = [
# Relative default, all binary and dynamic libraries we ship
# appear to have this (even when `../lib` is redundant).
"$ORIGIN/../lib",
] + ["{}/{}/lib".format(nix_deps_dir, dep) for dep in dylib_deps]
patchelf_args = ["--set-rpath", ":".join(rpath_entries)]
else:
patchelf_args += ["--set-rpath", ":".join(rpath_entries)]
if not fname.endswith(".so"):
# Finally, set the corret .interp for binaries
bintools_dir = "{}/stdenv.cc.bintools".format(nix_deps_dir)
with open("{}/nix-support/dynamic-linker".format(bintools_dir)) as dynamic_linker:
patchelf_args = ["--set-interpreter", dynamic_linker.read().rstrip()]
patchelf_args += ["--set-interpreter", dynamic_linker.read().rstrip()]
try:
subprocess.check_output([patchelf] + patchelf_args + [fname])

8
src/librustdoc/clean/auto_trait.rs
View File

@ -84,14 +84,14 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
new_generics
});
let polarity;
let negative_polarity;
let new_generics = match result {
AutoTraitResult::PositiveImpl(new_generics) => {
polarity = None;
negative_polarity = false;
new_generics
}
AutoTraitResult::NegativeImpl => {
polarity = Some(ImplPolarity::Negative);
negative_polarity = true;
// For negative impls, we use the generic params, but *not* the predicates,
// from the original type. Otherwise, the displayed impl appears to be a
@ -130,7 +130,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
trait_: Some(trait_ref.clean(self.cx).get_trait_type().unwrap()),
for_: ty.clean(self.cx),
items: Vec::new(),
polarity,
negative_polarity,
synthetic: true,
blanket_impl: None,
}),

2
src/librustdoc/clean/blanket_impl.rs
View File

@ -131,7 +131,7 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
.in_definition_order()
.collect::<Vec<_>>()
.clean(self.cx),
polarity: None,
negative_polarity: false,
synthetic: false,
blanket_impl: Some(trait_ref.self_ty().clean(self.cx)),
}),

89
src/librustdoc/clean/inline.rs
View File

@ -438,7 +438,7 @@ crate fn build_impl(
trait_,
for_,
items: trait_items,
polarity: Some(polarity.clean(cx)),
negative_polarity: polarity.clean(cx),
synthetic: false,
blanket_impl: None,
}),
@ -451,60 +451,51 @@ crate fn build_impl(
fn build_module(cx: &DocContext<'_>, did: DefId, visited: &mut FxHashSet<DefId>) -> clean::Module {
let mut items = Vec::new();
fill_in(cx, did, &mut items, visited);
return clean::Module { items, is_crate: false };
fn fill_in(
cx: &DocContext<'_>,
did: DefId,
items: &mut Vec<clean::Item>,
visited: &mut FxHashSet<DefId>,
) {
// If we're re-exporting a re-export it may actually re-export something in
// two namespaces, so the target may be listed twice. Make sure we only
// visit each node at most once.
for &item in cx.tcx.item_children(did).iter() {
if item.vis == ty::Visibility::Public {
if let Some(def_id) = item.res.mod_def_id() {
if did == def_id || !visited.insert(def_id) {
continue;
}
// If we're re-exporting a re-export it may actually re-export something in
// two namespaces, so the target may be listed twice. Make sure we only
// visit each node at most once.
for &item in cx.tcx.item_children(did).iter() {
if item.vis == ty::Visibility::Public {
if let Some(def_id) = item.res.mod_def_id() {
if did == def_id || !visited.insert(def_id) {
continue;
}
if let Res::PrimTy(p) = item.res {
// Primitive types can't be inlined so generate an import instead.
items.push(clean::Item {
name: None,
attrs: clean::Attributes::default(),
source: clean::Span::dummy(),
def_id: DefId::local(CRATE_DEF_INDEX),
visibility: clean::Public,
kind: box clean::ImportItem(clean::Import::new_simple(
item.ident.name,
clean::ImportSource {
path: clean::Path {
global: false,
res: item.res,
segments: vec![clean::PathSegment {
name: clean::PrimitiveType::from(p).as_sym(),
args: clean::GenericArgs::AngleBracketed {
args: Vec::new(),
bindings: Vec::new(),
},
}],
},
did: None,
}
if let Res::PrimTy(p) = item.res {
// Primitive types can't be inlined so generate an import instead.
items.push(clean::Item {
name: None,
attrs: clean::Attributes::default(),
source: clean::Span::dummy(),
def_id: DefId::local(CRATE_DEF_INDEX),
visibility: clean::Public,
kind: box clean::ImportItem(clean::Import::new_simple(
item.ident.name,
clean::ImportSource {
path: clean::Path {
global: false,
res: item.res,
segments: vec![clean::PathSegment {
name: clean::PrimitiveType::from(p).as_sym(),
args: clean::GenericArgs::AngleBracketed {
args: Vec::new(),
bindings: Vec::new(),
},
}],
},
true,
)),
});
} else if let Some(i) =
try_inline(cx, did, item.res, item.ident.name, None, visited)
{
items.extend(i)
}
did: None,
},
true,
)),
});
} else if let Some(i) = try_inline(cx, did, item.res, item.ident.name, None, visited) {
items.extend(i)
}
}
}
clean::Module { items, is_crate: false }
}
crate fn print_inlined_const(cx: &DocContext<'_>, did: DefId) -> String {

11
src/librustdoc/clean/mod.rs
View File

@ -2069,13 +2069,14 @@ impl Clean<Item> for hir::Variant<'_> {
}
}
impl Clean<ImplPolarity> for ty::ImplPolarity {
fn clean(&self, _: &DocContext<'_>) -> ImplPolarity {
impl Clean<bool> for ty::ImplPolarity {
/// Returns whether the impl has negative polarity.
fn clean(&self, _: &DocContext<'_>) -> bool {
match self {
&ty::ImplPolarity::Positive |
// FIXME: do we want to do something else here?
&ty::ImplPolarity::Reservation => ImplPolarity::Positive,
&ty::ImplPolarity::Negative => ImplPolarity::Negative,
&ty::ImplPolarity::Reservation => false,
&ty::ImplPolarity::Negative => true,
}
}
}
@ -2116,7 +2117,7 @@ fn clean_impl(impl_: &hir::Item<'_>, cx: &DocContext<'_>) -> Vec<Item> {
trait_,
for_,
items,
polarity: Some(cx.tcx.impl_polarity(def_id).clean(cx)),
negative_polarity: cx.tcx.impl_polarity(def_id).clean(cx),
synthetic: false,
blanket_impl: None,
});

15
src/librustdoc/clean/types.rs
View File

@ -175,9 +175,11 @@ impl Item {
}
crate fn is_crate(&self) -> bool {
matches!(*self.kind,
matches!(
*self.kind,
StrippedItem(box ModuleItem(Module { is_crate: true, .. }))
| ModuleItem(Module { is_crate: true, .. }))
| ModuleItem(Module { is_crate: true, .. })
)
}
crate fn is_mod(&self) -> bool {
self.type_() == ItemType::Module
@ -1226,6 +1228,7 @@ crate enum Type {
BareFunction(Box<BareFunctionDecl>),
Tuple(Vec<Type>),
Slice(Box<Type>),
/// The `String` field is about the size or the constant representing the array's length.
Array(Box<Type>, String),
Never,
RawPointer(Mutability, Box<Type>),
@ -1857,12 +1860,6 @@ crate struct Constant {
crate is_literal: bool,
}
#[derive(Clone, PartialEq, Debug)]
crate enum ImplPolarity {
Positive,
Negative,
}
#[derive(Clone, Debug)]
crate struct Impl {
crate unsafety: hir::Unsafety,
@ -1871,7 +1868,7 @@ crate struct Impl {
crate trait_: Option<Type>,
crate for_: Type,
crate items: Vec<Item>,
crate polarity: Option<ImplPolarity>,
crate negative_polarity: bool,
crate synthetic: bool,
crate blanket_impl: Option<Type>,
}

2
src/librustdoc/html/format.rs
View File

@ -870,7 +870,7 @@ impl clean::Impl {
}
if let Some(ref ty) = self.trait_ {
if self.polarity == Some(clean::ImplPolarity::Negative) {
if self.negative_polarity {
write!(f, "!")?;
}

11
src/librustdoc/html/render/mod.rs
View File

@ -4327,16 +4327,15 @@ fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
let mut ret = impls
.iter()
.filter_map(|i| {
let is_negative_impl = is_negative_impl(i.inner_impl());
if let Some(ref i) = i.inner_impl().trait_ {
.filter_map(|it| {
if let Some(ref i) = it.inner_impl().trait_ {
let i_display = format!("{:#}", i.print());
let out = Escape(&i_display);
let encoded = small_url_encode(&format!("{:#}", i.print()));
let generated = format!(
"<a href=\"#impl-{}\">{}{}</a>",
encoded,
if is_negative_impl { "!" } else { "" },
if it.inner_impl().negative_polarity { "!" } else { "" },
out
);
if links.insert(generated.clone()) { Some(generated) } else { None }
@ -4503,10 +4502,6 @@ fn extract_for_impl_name(item: &clean::Item) -> Option<(String, String)> {
}
}
fn is_negative_impl(i: &clean::Impl) -> bool {
i.polarity == Some(clean::ImplPolarity::Negative)
}
fn sidebar_trait(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, t: &clean::Trait) {
let mut sidebar = String::new();

4
src/librustdoc/json/conversions.rs
View File

@ -422,7 +422,7 @@ impl From<clean::Impl> for Impl {
trait_,
for_,
items,
polarity,
negative_polarity,
synthetic,
blanket_impl,
} = impl_;
@ -436,7 +436,7 @@ impl From<clean::Impl> for Impl {
trait_: trait_.map(Into::into),
for_: for_.into(),
items: ids(items),
negative: polarity == Some(clean::ImplPolarity::Negative),
negative: negative_polarity,
synthetic,
blanket_impl: blanket_impl.map(Into::into),
}

5
src/librustdoc/theme.rs
View File

@ -70,7 +70,10 @@ impl Events {
}
fn is_comment(&self) -> bool {
matches!(self, Events::StartLineComment(_) | Events::StartComment(_) | Events::EndComment(_))
matches!(
self,
Events::StartLineComment(_) | Events::StartComment(_) | Events::EndComment(_)
)
}
}

6
src/test/ui/error-codes/E0435.fixed Normal file
View File

@ -0,0 +1,6 @@
// run-rustfix
fn main () {
#[allow(non_upper_case_globals)]
const foo: usize = 42;
let _: [u8; foo]; //~ ERROR E0435
}

4
src/test/ui/error-codes/E0435.rs
View File

@ -1,4 +1,6 @@
// run-rustfix
fn main () {
let foo = 42u32;
#[allow(non_upper_case_globals)]
let foo: usize = 42;
let _: [u8; foo]; //~ ERROR E0435
}

6
src/test/ui/error-codes/E0435.stderr
View File

@ -1,8 +1,8 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/E0435.rs:3:17
--> $DIR/E0435.rs:5:17
|
LL | let foo = 42u32;
| --- help: consider using `const` instead of `let`
LL | let foo: usize = 42;
| ------- help: consider using `const` instead of `let`: `const foo`
LL | let _: [u8; foo];
| ^^^ non-constant value

24
src/test/ui/impl-trait/bindings.stderr
View File

@ -2,33 +2,33 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/bindings.rs:5:29
|
LL | const foo: impl Clone = x;
| --- ^ non-constant value
| |
| help: consider using `let` instead of `const`
| --------- ^ non-constant value
| |
| help: consider using `let` instead of `const`: `let foo`
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/bindings.rs:11:33
|
LL | const foo: impl Clone = x;
| --- ^ non-constant value
| |
| help: consider using `let` instead of `const`
| --------- ^ non-constant value
| |
| help: consider using `let` instead of `const`: `let foo`
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/bindings.rs:18:33
|
LL | const foo: impl Clone = x;
| --- ^ non-constant value
| |
| help: consider using `let` instead of `const`
| --------- ^ non-constant value
| |
| help: consider using `let` instead of `const`: `let foo`
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/bindings.rs:25:33
|
LL | const foo: impl Clone = x;
| --- ^ non-constant value
| |
| help: consider using `let` instead of `const`
| --------- ^ non-constant value
| |
| help: consider using `let` instead of `const`: `let foo`
warning: the feature `impl_trait_in_bindings` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/bindings.rs:1:12

7
src/test/ui/issues/issue-27433.fixed Normal file
View File

@ -0,0 +1,7 @@
// run-rustfix
fn main() {
let foo = 42u32;
#[allow(unused_variables, non_snake_case)]
let FOO : u32 = foo;
//~^ ERROR attempt to use a non-constant value in a constant
}

2
src/test/ui/issues/issue-27433.rs
View File

@ -1,5 +1,7 @@
// run-rustfix
fn main() {
let foo = 42u32;
#[allow(unused_variables, non_snake_case)]
const FOO : u32 = foo;
//~^ ERROR attempt to use a non-constant value in a constant
}

8
src/test/ui/issues/issue-27433.stderr
View File

@ -1,10 +1,10 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-27433.rs:3:23
--> $DIR/issue-27433.rs:5:23
|
LL | const FOO : u32 = foo;
| --- ^^^ non-constant value
| |
| help: consider using `let` instead of `const`
| --------- ^^^ non-constant value
| |
| help: consider using `let` instead of `const`: `let FOO`
error: aborting due to previous error

9
src/test/ui/issues/issue-3521-2.fixed Normal file
View File

@ -0,0 +1,9 @@
// run-rustfix
fn main() {
let foo = 100;
let y: isize = foo + 1;
//~^ ERROR attempt to use a non-constant value in a constant
println!("{}", y);
}

1
src/test/ui/issues/issue-3521-2.rs
View File

@ -1,3 +1,4 @@
// run-rustfix
fn main() {
let foo = 100;

8
src/test/ui/issues/issue-3521-2.stderr
View File

@ -1,10 +1,10 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-3521-2.rs:4:23
--> $DIR/issue-3521-2.rs:5:23
|
LL | static y: isize = foo + 1;
| - ^^^ non-constant value
| |
| help: consider using `let` instead of `static`
| -------- ^^^ non-constant value
| |
| help: consider using `let` instead of `static`: `let y`
error: aborting due to previous error

13
src/test/ui/issues/issue-3521.fixed Normal file
View File

@ -0,0 +1,13 @@
// run-rustfix
fn main() {
#[allow(non_upper_case_globals)]
const foo: isize = 100;
#[derive(Debug)]
enum Stuff {
Bar = foo
//~^ ERROR attempt to use a non-constant value in a constant
}
println!("{:?}", Stuff::Bar);
}

4
src/test/ui/issues/issue-3521.rs
View File

@ -1,5 +1,7 @@
// run-rustfix
fn main() {
let foo = 100;
#[allow(non_upper_case_globals)]
let foo: isize = 100;
#[derive(Debug)]
enum Stuff {

6
src/test/ui/issues/issue-3521.stderr
View File

@ -1,8 +1,8 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-3521.rs:6:15
--> $DIR/issue-3521.rs:8:15
|
LL | let foo = 100;
| --- help: consider using `const` instead of `let`
LL | let foo: isize = 100;
| ------- help: consider using `const` instead of `let`: `const foo`
...
LL | Bar = foo
| ^^^ non-constant value

8
src/test/ui/issues/issue-3668-2.fixed Normal file
View File

@ -0,0 +1,8 @@
// run-rustfix
#![allow(unused_variables, dead_code)]
fn f(x:isize) {
let child: isize = x + 1;
//~^ ERROR attempt to use a non-constant value in a constant
}
fn main() {}

2
src/test/ui/issues/issue-3668-2.rs
View File

@ -1,3 +1,5 @@
// run-rustfix
#![allow(unused_variables, dead_code)]
fn f(x:isize) {
static child: isize = x + 1;
//~^ ERROR attempt to use a non-constant value in a constant

8
src/test/ui/issues/issue-3668-2.stderr
View File

@ -1,10 +1,10 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-3668-2.rs:2:27
--> $DIR/issue-3668-2.rs:4:27
|
LL | static child: isize = x + 1;
| ----- ^ non-constant value
| |
| help: consider using `let` instead of `static`
| ------------ ^ non-constant value
| |
| help: consider using `let` instead of `static`: `let child`
error: aborting due to previous error

6
src/test/ui/issues/issue-3668.stderr
View File

@ -2,9 +2,9 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-3668.rs:8:34
|
LL | static childVal: Box<P> = self.child.get();
| -------- ^^^^ non-constant value
| |
| help: consider using `let` instead of `static`
| --------------- ^^^^ non-constant value
| |
| help: consider using `let` instead of `static`: `let childVal`
error: aborting due to previous error

4
src/test/ui/issues/issue-42060.stderr
View File

@ -2,7 +2,7 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-42060.rs:3:23
|
LL | let thing = ();
| ----- help: consider using `const` instead of `let`
| --------- help: consider using `const` instead of `let`: `const thing`
LL | let other: typeof(thing) = thing;
| ^^^^^ non-constant value
@ -10,7 +10,7 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-42060.rs:9:13
|
LL | let q = 1;
| - help: consider using `const` instead of `let`
| ----- help: consider using `const` instead of `let`: `const q`
LL | <typeof(q)>::N
| ^ non-constant value

11
src/test/ui/issues/issue-44239.fixed Normal file
View File

@ -0,0 +1,11 @@
// run-rustfix
#![allow(dead_code, non_upper_case_globals)]
fn main() {
const n: usize = 0;
struct Foo;
impl Foo {
const N: usize = n;
//~^ ERROR attempt to use a non-constant value
}
}

4
src/test/ui/issues/issue-44239.rs
View File

@ -1,5 +1,7 @@
// run-rustfix
#![allow(dead_code, non_upper_case_globals)]
fn main() {
let n = 0;
let n: usize = 0;
struct Foo;
impl Foo {

6
src/test/ui/issues/issue-44239.stderr
View File

@ -1,8 +1,8 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/issue-44239.rs:6:26
--> $DIR/issue-44239.rs:8:26
|
LL | let n = 0;
| - help: consider using `const` instead of `let`
LL | let n: usize = 0;
| ----- help: consider using `const` instead of `let`: `const n`
...
LL | const N: usize = n;
| ^ non-constant value

4
src/test/ui/non-constant-expr-for-arr-len.stderr
View File

@ -2,9 +2,9 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/non-constant-expr-for-arr-len.rs:5:22
|
LL | fn bar(n: usize) {
| - help: consider using `const` instead of `let`
| - this would need to be a `const`
LL | let _x = [0; n];
| ^ non-constant value
| ^
error: aborting due to previous error

2
src/test/ui/repeat_count.stderr
View File

@ -2,7 +2,7 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/repeat_count.rs:5:17
|
LL | let n = 1;
| - help: consider using `const` instead of `let`
| ----- help: consider using `const` instead of `let`: `const n`
LL | let a = [0; n];
| ^ non-constant value

6
src/test/ui/type/type-dependent-def-issue-49241.stderr
View File

@ -2,9 +2,9 @@ error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/type-dependent-def-issue-49241.rs:3:22
|
LL | const l: usize = v.count();
| - ^ non-constant value
| |
| help: consider using `let` instead of `const`
| ------- ^ non-constant value
| |
| help: consider using `let` instead of `const`: `let l`
error: aborting due to previous error