Auto merge of #64172 - Centril:rollup-8i8oh54, r=Centril
Rollup of 11 pull requests Successful merges: - #62848 (Use unicode-xid crate instead of libcore) - #63774 (Fix `window.hashchange is not a function`) - #63930 (Account for doc comments coming from proc macros without spans) - #64003 (place: Passing `align` = `layout.align.abi`, when also passing `layout`) - #64030 (Fix unlock ordering in SGX synchronization primitives) - #64041 (use TokenStream rather than &[TokenTree] for built-in macros) - #64051 (Add x86_64-linux-kernel target) - #64063 (Fix const_err with `-(-0.0)`) - #64083 (Point at appropriate arm on type error on if/else/match with one non-! arm) - #64100 (Fix const eval bug breaking run-pass tests in Miri) - #64157 (Opaque type locations in error message for clarity.) Failed merges: r? @ghost
This commit is contained in:
bors
commit
618768492f
79 changed files with 1006 additions and 757 deletions
|
|
@ -57,12 +57,12 @@ extern crate rustc;
|
|||
extern crate rustc_driver;
|
||||
|
||||
use syntax::parse::token::{self, Token};
|
||||
use syntax::tokenstream::TokenTree;
|
||||
use syntax::tokenstream::{TokenTree, TokenStream};
|
||||
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
|
||||
use syntax_pos::Span;
|
||||
use rustc_driver::plugin::Registry;
|
||||
|
||||
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
|
||||
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: TokenStream)
|
||||
-> Box<dyn MacResult + 'static> {
|
||||
|
||||
static NUMERALS: &'static [(&'static str, usize)] = &[
|
||||
|
|
@ -78,7 +78,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
|
|||
return DummyResult::any(sp);
|
||||
}
|
||||
|
||||
let text = match args[0] {
|
||||
let text = match args.into_trees().next().unwrap() {
|
||||
TokenTree::Token(Token { kind: token::Ident(s, _), .. }) => s.to_string(),
|
||||
_ => {
|
||||
cx.span_err(sp, "argument should be a single identifier");
|
||||
|
|
|
|||
|
|
@ -547,29 +547,6 @@ impl char {
|
|||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if this `char` satisfies the `XID_Start` Unicode property, and false
|
||||
/// otherwise.
|
||||
///
|
||||
/// `XID_Start` is a Unicode Derived Property specified in
|
||||
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
|
||||
/// mostly similar to `ID_Start` but modified for closure under `NFKx`.
|
||||
#[unstable(feature = "unicode_internals", issue = "0")]
|
||||
pub fn is_xid_start(self) -> bool {
|
||||
derived_property::XID_Start(self)
|
||||
}
|
||||
|
||||
/// Returns `true` if this `char` satisfies the `XID_Continue` Unicode property, and false
|
||||
/// otherwise.
|
||||
///
|
||||
/// `XID_Continue` is a Unicode Derived Property specified in
|
||||
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
|
||||
/// mostly similar to `ID_Continue` but modified for closure under NFKx.
|
||||
#[unstable(feature = "unicode_internals", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_xid_continue(self) -> bool {
|
||||
derived_property::XID_Continue(self)
|
||||
}
|
||||
|
||||
/// Returns `true` if this `char` is lowercase.
|
||||
///
|
||||
/// 'Lowercase' is defined according to the terms of the Unicode Derived Core
|
||||
|
|
|
|||
|
|
@ -13,8 +13,3 @@ pub mod derived_property {
|
|||
pub mod conversions {
|
||||
pub use crate::unicode::tables::conversions::{to_lower, to_upper};
|
||||
}
|
||||
|
||||
// For use in libsyntax
|
||||
pub mod property {
|
||||
pub use crate::unicode::tables::property::Pattern_White_Space;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -890,384 +890,9 @@ pub(crate) mod derived_property {
|
|||
Uppercase_table.lookup(c)
|
||||
}
|
||||
|
||||
const XID_Continue_table: &super::BoolTrie = &super::BoolTrie {
|
||||
r1: [
|
||||
0x03ff000000000000, 0x07fffffe87fffffe, 0x04a0040000000000, 0xff7fffffff7fffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000501f0003ffc3,
|
||||
0xffffffffffffffff, 0xb8dfffffffffffff, 0xfffffffbffffd7c0, 0xffbfffffffffffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffcfb, 0xffffffffffffffff,
|
||||
0xfffeffffffffffff, 0xffffffff027fffff, 0xbffffffffffe01ff, 0x000787ffffff00b6,
|
||||
0xffffffff07ff0000, 0xffffc3ffffffffff, 0xffffffffffffffff, 0x9ffffdff9fefffff,
|
||||
0xffffffffffff0000, 0xffffffffffffe7ff, 0x0003ffffffffffff, 0x243fffffffffffff
|
||||
],
|
||||
r2: [
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
|
||||
24, 25, 26, 27, 28, 29, 30, 31, 4, 32, 33, 34, 4, 4, 4, 4, 4, 35, 36, 37, 38, 39, 40,
|
||||
41, 42, 4, 4, 4, 4, 4, 4, 4, 4, 43, 44, 45, 46, 47, 4, 48, 49, 50, 51, 52, 53, 54, 55,
|
||||
56, 57, 58, 59, 60, 4, 61, 4, 62, 63, 64, 65, 66, 4, 4, 4, 67, 4, 4, 4, 4, 68, 69, 70,
|
||||
71, 72, 73, 74, 75, 76, 77, 78, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 79, 80, 4, 81, 82, 83, 84, 85, 60, 60, 60, 60, 60, 60, 60, 60, 86,
|
||||
42, 87, 88, 89, 4, 90, 91, 60, 60, 60, 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 52, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 93, 94, 4, 4, 4, 4, 95, 96, 4, 97, 98, 4, 99, 100, 101, 62, 4, 102, 103,
|
||||
104, 4, 105, 106, 107, 4, 108, 109, 110, 4, 111, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 112, 113, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 103, 4, 114,
|
||||
115, 116, 97, 117, 4, 118, 4, 4, 119, 120, 121, 122, 123, 124, 4, 125, 126, 127, 128,
|
||||
129
|
||||
],
|
||||
r3: &[
|
||||
0x00003fffffffffff, 0x000007ff0fffffff, 0x3fdfffff00000000, 0xfffffffbfff80000,
|
||||
0xffffffffffffffff, 0xfffeffcfffffffff, 0xf3c5fdfffff99fef, 0x5003ffcfb080799f,
|
||||
0xd36dfdfffff987ee, 0x003fffc05e023987, 0xf3edfdfffffbbfee, 0xfe00ffcf00013bbf,
|
||||
0xf3edfdfffff99fee, 0x0002ffcfb0c0399f, 0xc3ffc718d63dc7ec, 0x0000ffc000813dc7,
|
||||
0xe3fffdfffffddfff, 0x0000ffcf07603ddf, 0xf3effdfffffddfef, 0x0006ffcf40603ddf,
|
||||
0xfffffffffffddfef, 0xfc00ffcf80f07ddf, 0x2ffbfffffc7fffec, 0x000cffc0ff5f847f,
|
||||
0x07fffffffffffffe, 0x0000000003ff7fff, 0x3fffffaffffff7d6, 0x00000000f3ff3f5f,
|
||||
0xc2a003ff03000001, 0xfffe1ffffffffeff, 0x1ffffffffeffffdf, 0x0000000000000040,
|
||||
0xffffffffffff03ff, 0xffffffff3fffffff, 0xf7ffffffffff20bf, 0xffffffff3d7f3dff,
|
||||
0x7f3dffffffff3dff, 0xffffffffff7fff3d, 0xffffffffff3dffff, 0x0003fe00e7ffffff,
|
||||
0xffffffff0000ffff, 0x3f3fffffffffffff, 0xfffffffffffffffe, 0xffff9fffffffffff,
|
||||
0xffffffff07fffffe, 0x01ffc7ffffffffff, 0x001fffff001fdfff, 0x000ddfff000fffff,
|
||||
0x000003ff308fffff, 0xffffffff03ff3800, 0x01ffffffffffffff, 0xffff07ffffffffff,
|
||||
0x003fffffffffffff, 0x0fff0fff7fffffff, 0x001f3fffffffffc0, 0xffff0fffffffffff,
|
||||
0x0000000007ff03ff, 0xffffffff0fffffff, 0x9fffffff7fffffff, 0x3fff008003ff03ff,
|
||||
0x0000000000000000, 0x000ff80003ff0fff, 0x000fffffffffffff, 0x00ffffffffffffff,
|
||||
0x3fffffffffffe3ff, 0xe7ffffffffff01ff, 0x07fffffffff70000, 0xfbffffffffffffff,
|
||||
0xffffffff3f3fffff, 0x3fffffffaaff3f3f, 0x5fdfffffffffffff, 0x1fdc1fff0fcf1fdc,
|
||||
0x8000000000000000, 0x8002000000100001, 0x000000001fff0000, 0x0001ffe21fff0000,
|
||||
0xf3fffd503f2ffc84, 0xffffffff000043e0, 0x00000000000001ff, 0xffff7fffffffffff,
|
||||
0xffffffff7fffffff, 0x000ff81fffffffff, 0xffff20bfffffffff, 0x800080ffffffffff,
|
||||
0x7f7f7f7f007fffff, 0xffffffff7f7f7f7f, 0x1f3efffe000000e0, 0xfffffffee67fffff,
|
||||
0xf7ffffffffffffff, 0xfffeffffffffffe0, 0x07ffffff00007fff, 0xffff000000000000,
|
||||
0x0000ffffffffffff, 0x0000000000001fff, 0x3fffffffffff0000, 0x00000fffffff1fff,
|
||||
0xbff0ffffffffffff, 0x0003ffffffffffff, 0xfffffffcff800000, 0xfffffffffffff9ff,
|
||||
0xff8000000000007c, 0x000000ffffffffff, 0xe8ffffff03ff003f, 0xffff3fffffffffff,
|
||||
0x1fffffff000fffff, 0x7fffffff03ff8001, 0x007fffffffffffff, 0xfc7fffff03ff3fff,
|
||||
0x007cffff38000007, 0xffff7f7f007e7e7e, 0xffff00fff7ffffff, 0x03ff37ffffffffff,
|
||||
0xffff000fffffffff, 0x0ffffffffffff87f, 0x0000000003ffffff, 0x5f7ffdffe0f8007f,
|
||||
0xffffffffffffffdb, 0xfffffffffff80000, 0xfffffff03fffffff, 0x3fffffffffffffff,
|
||||
0xffffffffffff0000, 0xfffffffffffcffff, 0x03ff0000000000ff, 0x0018ffff0000ffff,
|
||||
0xaa8a00000000e000, 0x1fffffffffffffff, 0x87fffffe03ff0000, 0xffffffc007fffffe,
|
||||
0x7fffffffffffffff, 0x000000001cfcfcfc
|
||||
],
|
||||
r4: [
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 12, 13,
|
||||
14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
|
||||
],
|
||||
r5: &[
|
||||
0, 1, 2, 3, 4, 5, 4, 6, 4, 4, 7, 8, 9, 10, 11, 12, 2, 2, 13, 14, 15, 16, 4, 4, 2, 2, 2,
|
||||
2, 17, 18, 4, 4, 19, 20, 21, 22, 23, 4, 24, 4, 25, 26, 27, 28, 29, 30, 31, 4, 2, 32, 33,
|
||||
33, 34, 4, 4, 4, 4, 4, 4, 4, 35, 36, 4, 37, 2, 38, 3, 39, 40, 41, 2, 42, 43, 4, 44, 45,
|
||||
46, 47, 4, 4, 2, 48, 2, 49, 4, 4, 50, 51, 2, 52, 53, 54, 55, 4, 4, 4, 3, 4, 56, 57, 4,
|
||||
4, 58, 59, 60, 61, 62, 53, 4, 4, 4, 4, 63, 64, 65, 4, 66, 67, 68, 4, 4, 4, 4, 37, 4, 4,
|
||||
4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 69, 4, 2, 70, 2, 2, 2, 71, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 70, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 72, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 2, 2, 2, 2, 2, 2, 2, 2, 53, 73, 4, 74, 17, 75, 76, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2,
|
||||
4, 4, 2, 77, 78, 79, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 80, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 21, 81, 2, 2, 2, 2,
|
||||
2, 82, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 83, 84, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 85, 86, 4, 4, 87, 4, 4, 4, 4, 4, 4, 2, 88, 89, 90, 91, 92, 2, 2, 2, 2, 93, 94, 95,
|
||||
96, 97, 98, 4, 4, 4, 4, 4, 4, 4, 4, 99, 100, 101, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 102, 4, 4, 4, 103, 104, 4, 4, 4, 4, 4, 105, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 106, 2, 107, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 108, 109, 110, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 111, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 11,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 112, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 113, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 114, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 115, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
|
||||
],
|
||||
r6: &[
|
||||
0xb7ffff7fffffefff, 0x000000003fff3fff, 0xffffffffffffffff, 0x07ffffffffffffff,
|
||||
0x0000000000000000, 0x001fffffffffffff, 0x2000000000000000, 0xffffffff1fffffff,
|
||||
0x000000010001ffff, 0xffffe000ffffffff, 0x07ffffffffff07ff, 0xffffffff3fffffff,
|
||||
0x00000000003eff0f, 0xffff03ff3fffffff, 0x0fffffffff0fffff, 0xffff00ffffffffff,
|
||||
0x0000000fffffffff, 0x007fffffffffffff, 0x000000ff003fffff, 0x91bffffffffffd3f,
|
||||
0x007fffff003fffff, 0x000000007fffffff, 0x0037ffff00000000, 0x03ffffff003fffff,
|
||||
0xc0ffffffffffffff, 0x873ffffffeeff06f, 0x1fffffff00000000, 0x000000001fffffff,
|
||||
0x0000007ffffffeff, 0x003fffffffffffff, 0x0007ffff003fffff, 0x000000000003ffff,
|
||||
0x00000000000001ff, 0x0007ffffffffffff, 0x03ff00ffffffffff, 0xffff00801fffffff,
|
||||
0x000000000001ffff, 0x007fffff00000000, 0x8000ffc00000007f, 0x03ff01ffffff0000,
|
||||
0xffdfffffffffffff, 0x004fffffffff0070, 0x0000000017ff1e1f, 0x40fffffffffbffff,
|
||||
0xffff01ffbfffbd7f, 0x03ff07ffffffffff, 0xfbedfdfffff99fef, 0x001f1fcfe081399f,
|
||||
0x00000000c3ff07ff, 0x0000000003ff00bf, 0xff3fffffffffffff, 0x000000003f000001,
|
||||
0x0000000003ff0011, 0x01ffffffffffffff, 0x00000000000003ff, 0x03ff0fffe7ffffff,
|
||||
0xffffffff00000000, 0x800003ffffffffff, 0xfffffcff00000000, 0x0000001bfcffffff,
|
||||
0x7fffffffffffffff, 0xffffffffffff0080, 0x0000000023ffffff, 0xff7ffffffffffdff,
|
||||
0xfffc000003ff0001, 0x007ffefffffcffff, 0xb47ffffffffffb7f, 0xfffffdbf03ff00ff,
|
||||
0x000003ff01fb7fff, 0x0000000003ffffff, 0x00007fffffffffff, 0x000000000000000f,
|
||||
0x000000000000007f, 0x000003ff7fffffff, 0x001f3fffffff0000, 0xe0fffff803ff000f,
|
||||
0x000000000000ffff, 0xffffffffffff87ff, 0x00000000ffff80ff, 0x0000000b00000000,
|
||||
0x00ffffffffffffff, 0xffff00f000070000, 0x0fffffffffffffff, 0x1fff07ffffffffff,
|
||||
0x0000000063ff01ff, 0xf807e3e000000000, 0x00003c0000000fe7, 0x000000000000001c,
|
||||
0xffffffffffdfffff, 0xebffde64dfffffff, 0xffffffffffffffef, 0x7bffffffdfdfe7bf,
|
||||
0xfffffffffffdfc5f, 0xffffff3fffffffff, 0xf7fffffff7fffffd, 0xffdfffffffdfffff,
|
||||
0xffff7fffffff7fff, 0xfffffdfffffffdff, 0xffffffffffffcff7, 0xf87fffffffffffff,
|
||||
0x00201fffffffffff, 0x0000fffef8000010, 0x000007dbf9ffff7f, 0x3fff1fffffffffff,
|
||||
0x00000000000043ff, 0x03ffffffffffffff, 0x00000000007f001f, 0x0000000003ff0fff,
|
||||
0x0af7fe96ffffffef, 0x5ef7f796aa96ea84, 0x0ffffbee0ffffbff, 0x00000000007fffff,
|
||||
0xffff0003ffffffff, 0x00000001ffffffff, 0x000000003fffffff, 0x0000ffffffffffff
|
||||
],
|
||||
};
|
||||
|
||||
pub fn XID_Continue(c: char) -> bool {
|
||||
XID_Continue_table.lookup(c)
|
||||
}
|
||||
|
||||
const XID_Start_table: &super::BoolTrie = &super::BoolTrie {
|
||||
r1: [
|
||||
0x0000000000000000, 0x07fffffe07fffffe, 0x0420040000000000, 0xff7fffffff7fffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000501f0003ffc3,
|
||||
0x0000000000000000, 0xb8df000000000000, 0xfffffffbffffd740, 0xffbfffffffffffff,
|
||||
0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffc03, 0xffffffffffffffff,
|
||||
0xfffeffffffffffff, 0xffffffff027fffff, 0x00000000000001ff, 0x000787ffffff0000,
|
||||
0xffffffff00000000, 0xfffec000000007ff, 0xffffffffffffffff, 0x9c00c060002fffff,
|
||||
0x0000fffffffd0000, 0xffffffffffffe000, 0x0002003fffffffff, 0x043007fffffffc00
|
||||
],
|
||||
r2: [
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
|
||||
24, 23, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 34, 34, 34, 34, 35, 36, 37, 38, 39,
|
||||
40, 41, 42, 34, 34, 34, 34, 34, 34, 34, 34, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
|
||||
54, 55, 56, 57, 58, 59, 60, 3, 61, 62, 63, 64, 65, 66, 67, 68, 34, 34, 34, 3, 34, 34,
|
||||
34, 34, 69, 70, 71, 72, 3, 73, 74, 3, 75, 76, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 78,
|
||||
79, 34, 80, 81, 82, 83, 84, 3, 3, 3, 3, 3, 3, 3, 3, 85, 42, 86, 87, 88, 34, 89, 90, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 53, 3, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 91, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 92, 93, 34, 34, 34, 34, 94,
|
||||
95, 96, 91, 97, 34, 98, 99, 100, 48, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
|
||||
111, 112, 34, 113, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,
|
||||
34, 34, 34, 114, 115, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34,
|
||||
116, 34, 117, 118, 119, 120, 121, 34, 122, 34, 34, 123, 124, 125, 126, 3, 127, 34, 128,
|
||||
129, 130, 131, 132
|
||||
],
|
||||
r3: &[
|
||||
0x00000110043fffff, 0x000007ff01ffffff, 0x3fdfffff00000000, 0x0000000000000000,
|
||||
0x23fffffffffffff0, 0xfffe0003ff010000, 0x23c5fdfffff99fe1, 0x10030003b0004000,
|
||||
0x036dfdfffff987e0, 0x001c00005e000000, 0x23edfdfffffbbfe0, 0x0200000300010000,
|
||||
0x23edfdfffff99fe0, 0x00020003b0000000, 0x03ffc718d63dc7e8, 0x0000000000010000,
|
||||
0x23fffdfffffddfe0, 0x0000000307000000, 0x23effdfffffddfe1, 0x0006000340000000,
|
||||
0x27fffffffffddfe0, 0xfc00000380704000, 0x2ffbfffffc7fffe0, 0x000000000000007f,
|
||||
0x0005fffffffffffe, 0x2005ffaffffff7d6, 0x00000000f000005f, 0x0000000000000001,
|
||||
0x00001ffffffffeff, 0x0000000000001f00, 0x800007ffffffffff, 0xffe1c0623c3f0000,
|
||||
0xffffffff00004003, 0xf7ffffffffff20bf, 0xffffffffffffffff, 0xffffffff3d7f3dff,
|
||||
0x7f3dffffffff3dff, 0xffffffffff7fff3d, 0xffffffffff3dffff, 0x0000000007ffffff,
|
||||
0xffffffff0000ffff, 0x3f3fffffffffffff, 0xfffffffffffffffe, 0xffff9fffffffffff,
|
||||
0xffffffff07fffffe, 0x01ffc7ffffffffff, 0x0003ffff0003dfff, 0x0001dfff0003ffff,
|
||||
0x000fffffffffffff, 0x0000000010800000, 0xffffffff00000000, 0x01ffffffffffffff,
|
||||
0xffff05ffffffffff, 0x003fffffffffffff, 0x000000007fffffff, 0x001f3fffffff0000,
|
||||
0xffff0fffffffffff, 0x00000000000003ff, 0xffffffff007fffff, 0x00000000001fffff,
|
||||
0x0000008000000000, 0x000fffffffffffe0, 0x0000000000000fe0, 0xfc00c001fffffff8,
|
||||
0x0000003fffffffff, 0x0000000fffffffff, 0x3ffffffffc00e000, 0xe7ffffffffff01ff,
|
||||
0x046fde0000000000, 0xffffffff3f3fffff, 0x3fffffffaaff3f3f, 0x5fdfffffffffffff,
|
||||
0x1fdc1fff0fcf1fdc, 0x8002000000000000, 0x000000001fff0000, 0xf3fffd503f2ffc84,
|
||||
0xffffffff000043e0, 0x00000000000001ff, 0xffff7fffffffffff, 0xffffffff7fffffff,
|
||||
0x000c781fffffffff, 0xffff20bfffffffff, 0x000080ffffffffff, 0x7f7f7f7f007fffff,
|
||||
0x000000007f7f7f7f, 0x1f3e03fe000000e0, 0xfffffffee07fffff, 0xf7ffffffffffffff,
|
||||
0xfffeffffffffffe0, 0x07ffffff00007fff, 0xffff000000000000, 0x0000ffffffffffff,
|
||||
0x0000000000001fff, 0x3fffffffffff0000, 0x00000c00ffff1fff, 0x80007fffffffffff,
|
||||
0xffffffff3fffffff, 0xfffffffcff800000, 0xfffffffffffff9ff, 0xff8000000000007c,
|
||||
0x00000007fffff7bb, 0x000ffffffffffffc, 0x68fc000000000000, 0xffff003ffffffc00,
|
||||
0x1fffffff0000007f, 0x0007fffffffffff0, 0x7c00ffdf00008000, 0x000001ffffffffff,
|
||||
0xc47fffff00000ff7, 0x3e62ffffffffffff, 0x001c07ff38000005, 0xffff7f7f007e7e7e,
|
||||
0xffff00fff7ffffff, 0x00000007ffffffff, 0xffff000fffffffff, 0x0ffffffffffff87f,
|
||||
0xffff3fffffffffff, 0x0000000003ffffff, 0x5f7ffdffa0f8007f, 0xffffffffffffffdb,
|
||||
0x0003ffffffffffff, 0xfffffffffff80000, 0xfffffff03fffffff, 0x3fffffffffffffff,
|
||||
0xffffffffffff0000, 0xfffffffffffcffff, 0x03ff0000000000ff, 0xaa8a000000000000,
|
||||
0x1fffffffffffffff, 0x07fffffe00000000, 0xffffffc007fffffe, 0x7fffffff3fffffff,
|
||||
0x000000001cfcfcfc
|
||||
],
|
||||
r4: [
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 12, 13,
|
||||
14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
|
||||
],
|
||||
r5: &[
|
||||
0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, 4, 2, 2, 2,
|
||||
2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, 28, 29, 30, 4, 2, 31, 32,
|
||||
32, 15, 4, 4, 4, 4, 4, 4, 4, 33, 34, 4, 35, 36, 4, 37, 38, 39, 40, 41, 42, 43, 4, 44,
|
||||
20, 45, 46, 4, 4, 5, 47, 48, 49, 4, 4, 50, 51, 48, 52, 53, 4, 54, 4, 4, 4, 55, 4, 56,
|
||||
57, 4, 4, 58, 59, 60, 61, 62, 63, 4, 4, 4, 4, 64, 65, 66, 4, 67, 68, 69, 4, 4, 4, 4, 70,
|
||||
4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 71, 4, 2, 50, 2, 2, 2, 72, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 50, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 73, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 63, 20, 4, 74, 48, 75, 66, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 2, 4, 4, 2, 76, 77, 78, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 79, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
32, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 80, 2,
|
||||
2, 2, 2, 2, 81, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 82, 83, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 84, 85, 86, 87, 88, 2, 2, 2, 2, 89, 90,
|
||||
91, 92, 93, 94, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 95, 96, 4, 4, 4, 4, 4, 55, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 97, 2, 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 99, 100, 101, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 102, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 10, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 103,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 104, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 105, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
|
||||
],
|
||||
r6: &[
|
||||
0xb7ffff7fffffefff, 0x000000003fff3fff, 0xffffffffffffffff, 0x07ffffffffffffff,
|
||||
0x0000000000000000, 0x001fffffffffffff, 0xffffffff1fffffff, 0x000000000001ffff,
|
||||
0xffffe000ffffffff, 0x003fffffffff07ff, 0xffffffff3fffffff, 0x00000000003eff0f,
|
||||
0xffff00003fffffff, 0x0fffffffff0fffff, 0xffff00ffffffffff, 0x0000000fffffffff,
|
||||
0x007fffffffffffff, 0x000000ff003fffff, 0x91bffffffffffd3f, 0x007fffff003fffff,
|
||||
0x000000007fffffff, 0x0037ffff00000000, 0x03ffffff003fffff, 0xc0ffffffffffffff,
|
||||
0x003ffffffeef0001, 0x1fffffff00000000, 0x000000001fffffff, 0x0000001ffffffeff,
|
||||
0x003fffffffffffff, 0x0007ffff003fffff, 0x000000000003ffff, 0x00000000000001ff,
|
||||
0x0007ffffffffffff, 0xffff00801fffffff, 0x000000000000003f, 0x007fffff00000000,
|
||||
0x00fffffffffffff8, 0x0000fffffffffff8, 0x000001ffffff0000, 0x0000007ffffffff8,
|
||||
0x0047ffffffff0010, 0x0007fffffffffff8, 0x000000001400001e, 0x00000ffffffbffff,
|
||||
0xffff01ffbfffbd7f, 0x23edfdfffff99fe0, 0x00000003e0010000, 0x0000000080000780,
|
||||
0x0000ffffffffffff, 0x00000000000000b0, 0x00007fffffffffff, 0x000000000f000000,
|
||||
0x0000000000000010, 0x010007ffffffffff, 0x0000000007ffffff, 0x00000fffffffffff,
|
||||
0xffffffff00000000, 0x80000000ffffffff, 0xfffffcff00000000, 0x0000000a0001ffff,
|
||||
0x0407fffffffff801, 0xfffffffff0010000, 0x00000000200003ff, 0x01ffffffffffffff,
|
||||
0x00007ffffffffdff, 0xfffc000000000001, 0x000000000000ffff, 0x0001fffffffffb7f,
|
||||
0xfffffdbf00000040, 0x00000000010003ff, 0x0007ffff00000000, 0x0000000003ffffff,
|
||||
0x000000000000000f, 0x000000000000007f, 0x00003fffffff0000, 0xe0fffff80000000f,
|
||||
0x00000000000107ff, 0x00000000fff80000, 0x0000000b00000000, 0x00ffffffffffffff,
|
||||
0xffff00f000070000, 0x0fffffffffffffff, 0x1fff07ffffffffff, 0x0000000003ff01ff,
|
||||
0xffffffffffdfffff, 0xebffde64dfffffff, 0xffffffffffffffef, 0x7bffffffdfdfe7bf,
|
||||
0xfffffffffffdfc5f, 0xffffff3fffffffff, 0xf7fffffff7fffffd, 0xffdfffffffdfffff,
|
||||
0xffff7fffffff7fff, 0xfffffdfffffffdff, 0x0000000000000ff7, 0x3f801fffffffffff,
|
||||
0x0000000000004000, 0x000000000000001f, 0x000000000000080f, 0x0af7fe96ffffffef,
|
||||
0x5ef7f796aa96ea84, 0x0ffffbee0ffffbff, 0x00000000007fffff, 0xffff0003ffffffff,
|
||||
0x00000001ffffffff, 0x000000003fffffff
|
||||
],
|
||||
};
|
||||
|
||||
pub fn XID_Start(c: char) -> bool {
|
||||
XID_Start_table.lookup(c)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pub(crate) mod property {
|
||||
const Pattern_White_Space_table: &super::SmallBoolTrie = &super::SmallBoolTrie {
|
||||
r1: &[
|
||||
0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3
|
||||
],
|
||||
r2: &[
|
||||
0x0000000100003e00, 0x0000000000000000, 0x0000000000000020, 0x000003000000c000
|
||||
],
|
||||
};
|
||||
|
||||
pub fn Pattern_White_Space(c: char) -> bool {
|
||||
Pattern_White_Space_table.lookup(c)
|
||||
}
|
||||
|
||||
const White_Space_table: &super::SmallBoolTrie = &super::SmallBoolTrie {
|
||||
r1: &[
|
||||
0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
|
|
|
|||
|
|
@ -728,7 +728,7 @@ def generate_property_module(mod, grouped_categories, category_subset):
|
|||
|
||||
yield "pub(crate) mod %s {\n" % mod
|
||||
for cat in sorted(category_subset):
|
||||
if cat in ("Cc", "White_Space", "Pattern_White_Space"):
|
||||
if cat in ("Cc", "White_Space"):
|
||||
generator = generate_small_bool_trie("%s_table" % cat, grouped_categories[cat])
|
||||
else:
|
||||
generator = generate_bool_trie("%s_table" % cat, grouped_categories[cat])
|
||||
|
|
@ -841,19 +841,18 @@ def main():
|
|||
unicode_data = load_unicode_data(get_path(UnicodeFiles.UNICODE_DATA))
|
||||
load_special_casing(get_path(UnicodeFiles.SPECIAL_CASING), unicode_data)
|
||||
|
||||
want_derived = {"XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase",
|
||||
want_derived = {"Alphabetic", "Lowercase", "Uppercase",
|
||||
"Cased", "Case_Ignorable", "Grapheme_Extend"}
|
||||
derived = load_properties(get_path(UnicodeFiles.DERIVED_CORE_PROPERTIES), want_derived)
|
||||
|
||||
props = load_properties(get_path(UnicodeFiles.PROPS),
|
||||
{"White_Space", "Join_Control", "Noncharacter_Code_Point",
|
||||
"Pattern_White_Space"})
|
||||
{"White_Space", "Join_Control", "Noncharacter_Code_Point"})
|
||||
|
||||
# Category tables
|
||||
for (name, categories, category_subset) in (
|
||||
("general_category", unicode_data.general_categories, ["N", "Cc"]),
|
||||
("derived_property", derived, want_derived),
|
||||
("property", props, ["White_Space", "Pattern_White_Space"])
|
||||
("property", props, ["White_Space"])
|
||||
):
|
||||
for fragment in generate_property_module(name, categories, category_subset):
|
||||
buf.write(fragment)
|
||||
|
|
|
|||
|
|
@ -10,4 +10,4 @@ path = "lib.rs"
|
|||
|
||||
[dependencies]
|
||||
syntax_pos = { path = "../libsyntax_pos" }
|
||||
|
||||
rustc_lexer = { path = "../librustc_lexer" }
|
||||
|
|
|
|||
|
|
@ -597,12 +597,11 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Parses a word starting at the current position. A word is considered to
|
||||
/// be an alphabetic character followed by any number of alphanumeric
|
||||
/// characters.
|
||||
/// Parses a word starting at the current position. A word is the same as
|
||||
/// Rust identifier, except that it can't start with `_` character.
|
||||
fn word(&mut self) -> &'a str {
|
||||
let start = match self.cur.peek() {
|
||||
Some(&(pos, c)) if c.is_xid_start() => {
|
||||
Some(&(pos, c)) if c != '_' && rustc_lexer::is_id_start(c) => {
|
||||
self.cur.next();
|
||||
pos
|
||||
}
|
||||
|
|
@ -611,7 +610,7 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
};
|
||||
while let Some(&(pos, c)) = self.cur.peek() {
|
||||
if c.is_xid_continue() {
|
||||
if rustc_lexer::is_id_continue(c) {
|
||||
self.cur.next();
|
||||
} else {
|
||||
return &self.input[start..pos];
|
||||
|
|
|
|||
|
|
@ -1136,12 +1136,19 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
|
|||
if let Some((expected, found)) = expected_found {
|
||||
match (terr, is_simple_error, expected == found) {
|
||||
(&TypeError::Sorts(ref values), false, true) => {
|
||||
let sort_string = | a_type: Ty<'tcx> |
|
||||
if let ty::Opaque(def_id, _) = a_type.sty {
|
||||
format!(" (opaque type at {})", self.tcx.sess.source_map()
|
||||
.mk_substr_filename(self.tcx.def_span(def_id)))
|
||||
} else {
|
||||
format!(" ({})", a_type.sort_string(self.tcx))
|
||||
};
|
||||
diag.note_expected_found_extra(
|
||||
&"type",
|
||||
expected,
|
||||
found,
|
||||
&format!(" ({})", values.expected.sort_string(self.tcx)),
|
||||
&format!(" ({})", values.found.sort_string(self.tcx)),
|
||||
&sort_string(values.expected),
|
||||
&sort_string(values.found),
|
||||
);
|
||||
}
|
||||
(_, false, _) => {
|
||||
|
|
|
|||
|
|
@ -561,7 +561,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
|
|||
|
||||
let align = dest.align.restrict_for_offset(dest.layout.field(self.cx(), 0).size);
|
||||
cg_elem.val.store(&mut body_bx,
|
||||
PlaceRef::new_sized(current, cg_elem.layout, align));
|
||||
PlaceRef::new_sized_aligned(current, cg_elem.layout, align));
|
||||
|
||||
let next = body_bx.inbounds_gep(current, &[self.const_usize(1)]);
|
||||
body_bx.br(header_bx.llbb());
|
||||
|
|
|
|||
|
|
@ -349,7 +349,7 @@ impl ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
|
|||
)};
|
||||
self.const_bitcast(llval, llty)
|
||||
};
|
||||
PlaceRef::new_sized(llval, layout, alloc.align)
|
||||
PlaceRef::new_sized(llval, layout)
|
||||
}
|
||||
|
||||
fn const_ptrcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
|
|||
let name = &*tcx.item_name(def_id).as_str();
|
||||
|
||||
let llret_ty = self.layout_of(ret_ty).llvm_type(self);
|
||||
let result = PlaceRef::new_sized(llresult, fn_ty.ret.layout, fn_ty.ret.layout.align.abi);
|
||||
let result = PlaceRef::new_sized(llresult, fn_ty.ret.layout);
|
||||
|
||||
let simple = get_simple_intrinsic(self, name);
|
||||
let llval = match name {
|
||||
|
|
|
|||
|
|
@ -988,7 +988,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
|
||||
// Handle both by-ref and immediate tuples.
|
||||
if let Ref(llval, None, align) = tuple.val {
|
||||
let tuple_ptr = PlaceRef::new_sized(llval, tuple.layout, align);
|
||||
let tuple_ptr = PlaceRef::new_sized_aligned(llval, tuple.layout, align);
|
||||
for i in 0..tuple.layout.fields.count() {
|
||||
let field_ptr = tuple_ptr.project_field(bx, i);
|
||||
let field = bx.load_operand(field_ptr);
|
||||
|
|
@ -1202,7 +1202,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
let llty = bx.backend_type(src.layout);
|
||||
let cast_ptr = bx.pointercast(dst.llval, bx.type_ptr_to(llty));
|
||||
let align = src.layout.align.abi.min(dst.align);
|
||||
src.val.store(bx, PlaceRef::new_sized(cast_ptr, src.layout, align));
|
||||
src.val.store(bx, PlaceRef::new_sized_aligned(cast_ptr, src.layout, align));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -289,7 +289,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
|||
if local == mir::RETURN_PLACE && fx.fn_ty.ret.is_indirect() {
|
||||
debug!("alloc: {:?} (return place) -> place", local);
|
||||
let llretptr = bx.get_param(0);
|
||||
LocalRef::Place(PlaceRef::new_sized(llretptr, layout, layout.align.abi))
|
||||
LocalRef::Place(PlaceRef::new_sized(llretptr, layout))
|
||||
} else if memory_locals.contains(local) {
|
||||
debug!("alloc: {:?} -> place", local);
|
||||
if layout.is_unsized() {
|
||||
|
|
@ -548,7 +548,7 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
|||
let llarg = bx.get_param(llarg_idx);
|
||||
bx.set_value_name(llarg, &name);
|
||||
llarg_idx += 1;
|
||||
PlaceRef::new_sized(llarg, arg.layout, arg.layout.align.abi)
|
||||
PlaceRef::new_sized(llarg, arg.layout)
|
||||
} else if arg.is_unsized_indirect() {
|
||||
// As the storage for the indirect argument lives during
|
||||
// the whole function call, we just copy the fat pointer.
|
||||
|
|
|
|||
|
|
@ -485,7 +485,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
bx.load_operand(PlaceRef::new_sized(
|
||||
bx.cx().const_undef(bx.cx().type_ptr_to(bx.cx().backend_type(layout))),
|
||||
layout,
|
||||
layout.align.abi,
|
||||
))
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,6 +30,19 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
|
|||
pub fn new_sized(
|
||||
llval: V,
|
||||
layout: TyLayout<'tcx>,
|
||||
) -> PlaceRef<'tcx, V> {
|
||||
assert!(!layout.is_unsized());
|
||||
PlaceRef {
|
||||
llval,
|
||||
llextra: None,
|
||||
layout,
|
||||
align: layout.align.abi
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_sized_aligned(
|
||||
llval: V,
|
||||
layout: TyLayout<'tcx>,
|
||||
align: Align,
|
||||
) -> PlaceRef<'tcx, V> {
|
||||
assert!(!layout.is_unsized());
|
||||
|
|
@ -45,14 +58,13 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
|
|||
bx: &mut Bx,
|
||||
llval: V,
|
||||
layout: TyLayout<'tcx>,
|
||||
align: Align,
|
||||
) -> PlaceRef<'tcx, V> {
|
||||
assert!(!bx.cx().type_has_metadata(layout.ty));
|
||||
PlaceRef {
|
||||
llval,
|
||||
llextra: None,
|
||||
layout,
|
||||
align
|
||||
align: layout.align.abi
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -64,7 +76,7 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
|
|||
debug!("alloca({:?}: {:?})", name, layout);
|
||||
assert!(!layout.is_unsized(), "tried to statically allocate unsized place");
|
||||
let tmp = bx.alloca(bx.cx().backend_type(layout), name, layout.align.abi);
|
||||
Self::new_sized(tmp, layout, layout.align.abi)
|
||||
Self::new_sized(tmp, layout)
|
||||
}
|
||||
|
||||
/// Returns a place for an indirect reference to an unsized place.
|
||||
|
|
@ -482,7 +494,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
let llval = bx.cx().const_undef(
|
||||
bx.cx().type_ptr_to(bx.cx().backend_type(layout))
|
||||
);
|
||||
PlaceRef::new_sized(llval, layout, layout.align.abi)
|
||||
PlaceRef::new_sized(llval, layout)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -498,7 +510,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
// with a static that is an extern_type.
|
||||
let layout = cx.layout_of(self.monomorphize(&ty));
|
||||
let static_ = bx.get_static(*def_id);
|
||||
PlaceRef::new_thin_place(bx, static_, layout, layout.align.abi)
|
||||
PlaceRef::new_thin_place(bx, static_, layout)
|
||||
},
|
||||
mir::PlaceRef {
|
||||
base,
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
|||
scratch.storage_dead(&mut bx);
|
||||
}
|
||||
OperandValue::Ref(llref, None, align) => {
|
||||
let source = PlaceRef::new_sized(llref, operand.layout, align);
|
||||
let source = PlaceRef::new_sized_aligned(llref, operand.layout, align);
|
||||
base::coerce_unsized_into(&mut bx, source, dest);
|
||||
}
|
||||
OperandValue::Ref(_, Some(_), _) => {
|
||||
|
|
|
|||
|
|
@ -4,12 +4,12 @@ name = "rustc_lexer"
|
|||
version = "0.1.0"
|
||||
edition = "2018"
|
||||
|
||||
# Note that this crate purposefully does not depend on other rustc crates
|
||||
[dependencies]
|
||||
unicode-xid = { version = "0.1.0", optional = true }
|
||||
|
||||
# Note: do not remove this blank `[lib]` section.
|
||||
# This will be used when publishing this crate as `rustc-ap-rustc_lexer`.
|
||||
[lib]
|
||||
doctest = false
|
||||
name = "rustc_lexer"
|
||||
|
||||
# Note that this crate purposefully does not depend on other rustc crates
|
||||
[dependencies]
|
||||
unicode-xid = "0.2.0"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
// We want to be able to build this crate with a stable compiler, so feature
|
||||
// flags should be optional.
|
||||
#![cfg_attr(not(feature = "unicode-xid"), feature(unicode_internals))]
|
||||
// We want to be able to build this crate with a stable compiler, so no
|
||||
// `#![feature]` attributes should be added.
|
||||
|
||||
mod cursor;
|
||||
pub mod unescape;
|
||||
|
|
@ -103,6 +102,62 @@ pub fn tokenize(mut input: &str) -> impl Iterator<Item = Token> + '_ {
|
|||
})
|
||||
}
|
||||
|
||||
// See [UAX #31](http://unicode.org/reports/tr31) for definitions of these
|
||||
// classes.
|
||||
|
||||
/// True if `c` is considered a whitespace according to Rust language definition.
|
||||
pub fn is_whitespace(c: char) -> bool {
|
||||
// This is Pattern_White_Space.
|
||||
//
|
||||
// Note that this set is stable (ie, it doesn't change with different
|
||||
// Unicode versions), so it's ok to just hard-code the values.
|
||||
|
||||
match c {
|
||||
// Usual ASCII suspects
|
||||
| '\u{0009}' // \t
|
||||
| '\u{000A}' // \n
|
||||
| '\u{000B}' // vertical tab
|
||||
| '\u{000C}' // form feed
|
||||
| '\u{000D}' // \r
|
||||
| '\u{0020}' // space
|
||||
|
||||
// NEXT LINE from latin1
|
||||
| '\u{0085}'
|
||||
|
||||
// Bidi markers
|
||||
| '\u{200E}' // LEFT-TO-RIGHT MARK
|
||||
| '\u{200F}' // RIGHT-TO-LEFT MARK
|
||||
|
||||
// Dedicated whitespace characters from Unicode
|
||||
| '\u{2028}' // LINE SEPARATOR
|
||||
| '\u{2029}' // PARAGRAPH SEPARATOR
|
||||
=> true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// True if `c` is valid as a first character of an identifier.
|
||||
pub fn is_id_start(c: char) -> bool {
|
||||
// This is XID_Start OR '_' (which formally is not a XID_Start).
|
||||
// We also add fast-path for ascii idents
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && unicode_xid::UnicodeXID::is_xid_start(c))
|
||||
}
|
||||
|
||||
/// True if `c` is valid as a non-first character of an identifier.
|
||||
pub fn is_id_continue(c: char) -> bool {
|
||||
// This is exactly XID_Continue.
|
||||
// We also add fast-path for ascii idents
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| ('0' <= c && c <= '9')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && unicode_xid::UnicodeXID::is_xid_continue(c))
|
||||
}
|
||||
|
||||
|
||||
impl Cursor<'_> {
|
||||
fn advance_token(&mut self) -> Token {
|
||||
let first_char = self.bump().unwrap();
|
||||
|
|
@ -112,9 +167,9 @@ impl Cursor<'_> {
|
|||
'*' => self.block_comment(),
|
||||
_ => Slash,
|
||||
},
|
||||
c if character_properties::is_whitespace(c) => self.whitespace(),
|
||||
c if is_whitespace(c) => self.whitespace(),
|
||||
'r' => match (self.nth_char(0), self.nth_char(1)) {
|
||||
('#', c1) if character_properties::is_id_start(c1) => self.raw_ident(),
|
||||
('#', c1) if is_id_start(c1) => self.raw_ident(),
|
||||
('#', _) | ('"', _) => {
|
||||
let (n_hashes, started, terminated) = self.raw_double_quoted_string();
|
||||
let suffix_start = self.len_consumed();
|
||||
|
|
@ -159,7 +214,7 @@ impl Cursor<'_> {
|
|||
}
|
||||
_ => self.ident(),
|
||||
},
|
||||
c if character_properties::is_id_start(c) => self.ident(),
|
||||
c if is_id_start(c) => self.ident(),
|
||||
c @ '0'..='9' => {
|
||||
let literal_kind = self.number(c);
|
||||
let suffix_start = self.len_consumed();
|
||||
|
|
@ -247,8 +302,8 @@ impl Cursor<'_> {
|
|||
}
|
||||
|
||||
fn whitespace(&mut self) -> TokenKind {
|
||||
debug_assert!(character_properties::is_whitespace(self.prev()));
|
||||
while character_properties::is_whitespace(self.nth_char(0)) {
|
||||
debug_assert!(is_whitespace(self.prev()));
|
||||
while is_whitespace(self.nth_char(0)) {
|
||||
self.bump();
|
||||
}
|
||||
Whitespace
|
||||
|
|
@ -258,19 +313,19 @@ impl Cursor<'_> {
|
|||
debug_assert!(
|
||||
self.prev() == 'r'
|
||||
&& self.nth_char(0) == '#'
|
||||
&& character_properties::is_id_start(self.nth_char(1))
|
||||
&& is_id_start(self.nth_char(1))
|
||||
);
|
||||
self.bump();
|
||||
self.bump();
|
||||
while character_properties::is_id_continue(self.nth_char(0)) {
|
||||
while is_id_continue(self.nth_char(0)) {
|
||||
self.bump();
|
||||
}
|
||||
RawIdent
|
||||
}
|
||||
|
||||
fn ident(&mut self) -> TokenKind {
|
||||
debug_assert!(character_properties::is_id_start(self.prev()));
|
||||
while character_properties::is_id_continue(self.nth_char(0)) {
|
||||
debug_assert!(is_id_start(self.prev()));
|
||||
while is_id_continue(self.nth_char(0)) {
|
||||
self.bump();
|
||||
}
|
||||
Ident
|
||||
|
|
@ -315,7 +370,7 @@ impl Cursor<'_> {
|
|||
// integer literal followed by field/method access or a range pattern
|
||||
// (`0..2` and `12.foo()`)
|
||||
'.' if self.nth_char(1) != '.'
|
||||
&& !character_properties::is_id_start(self.nth_char(1)) =>
|
||||
&& !is_id_start(self.nth_char(1)) =>
|
||||
{
|
||||
// might have stuff after the ., and if it does, it needs to start
|
||||
// with a number
|
||||
|
|
@ -345,7 +400,7 @@ impl Cursor<'_> {
|
|||
fn lifetime_or_char(&mut self) -> TokenKind {
|
||||
debug_assert!(self.prev() == '\'');
|
||||
let mut starts_with_number = false;
|
||||
if (character_properties::is_id_start(self.nth_char(0))
|
||||
if (is_id_start(self.nth_char(0))
|
||||
|| self.nth_char(0).is_digit(10) && {
|
||||
starts_with_number = true;
|
||||
true
|
||||
|
|
@ -353,7 +408,7 @@ impl Cursor<'_> {
|
|||
&& self.nth_char(1) != '\''
|
||||
{
|
||||
self.bump();
|
||||
while character_properties::is_id_continue(self.nth_char(0)) {
|
||||
while is_id_continue(self.nth_char(0)) {
|
||||
self.bump();
|
||||
}
|
||||
|
||||
|
|
@ -495,66 +550,13 @@ impl Cursor<'_> {
|
|||
}
|
||||
|
||||
fn eat_literal_suffix(&mut self) {
|
||||
if !character_properties::is_id_start(self.nth_char(0)) {
|
||||
if !is_id_start(self.nth_char(0)) {
|
||||
return;
|
||||
}
|
||||
self.bump();
|
||||
|
||||
while character_properties::is_id_continue(self.nth_char(0)) {
|
||||
while is_id_continue(self.nth_char(0)) {
|
||||
self.bump();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub mod character_properties {
|
||||
// this is Pattern_White_Space
|
||||
#[cfg(feature = "unicode-xid")]
|
||||
pub fn is_whitespace(c: char) -> bool {
|
||||
match c {
|
||||
'\u{0009}' | '\u{000A}' | '\u{000B}' | '\u{000C}' | '\u{000D}' | '\u{0020}'
|
||||
| '\u{0085}' | '\u{200E}' | '\u{200F}' | '\u{2028}' | '\u{2029}' => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "unicode-xid"))]
|
||||
pub fn is_whitespace(c: char) -> bool {
|
||||
core::unicode::property::Pattern_White_Space(c)
|
||||
}
|
||||
|
||||
// this is XID_Start OR '_' (which formally is not a XID_Start)
|
||||
#[cfg(feature = "unicode-xid")]
|
||||
pub fn is_id_start(c: char) -> bool {
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && unicode_xid::UnicodeXID::is_xid_start(c))
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "unicode-xid"))]
|
||||
pub fn is_id_start(c: char) -> bool {
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && c.is_xid_start())
|
||||
}
|
||||
|
||||
// this is XID_Continue
|
||||
#[cfg(feature = "unicode-xid")]
|
||||
pub fn is_id_continue(c: char) -> bool {
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| ('0' <= c && c <= '9')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && unicode_xid::UnicodeXID::is_xid_continue(c))
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "unicode-xid"))]
|
||||
pub fn is_id_continue(c: char) -> bool {
|
||||
('a' <= c && c <= 'z')
|
||||
|| ('A' <= c && c <= 'Z')
|
||||
|| ('0' <= c && c <= '9')
|
||||
|| c == '_'
|
||||
|| (c > '\x7f' && c.is_xid_continue())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1354,7 +1354,7 @@ impl EncodeContext<'tcx> {
|
|||
let def_id = self.tcx.hir().local_def_id(macro_def.hir_id);
|
||||
Entry {
|
||||
kind: EntryKind::MacroDef(self.lazy(MacroDef {
|
||||
body: pprust::tokens_to_string(macro_def.body.clone()),
|
||||
body: pprust::tts_to_string(macro_def.body.clone()),
|
||||
legacy: macro_def.legacy,
|
||||
})),
|
||||
visibility: self.lazy(ty::Visibility::Public),
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ rustc = { path = "../librustc" }
|
|||
rustc_target = { path = "../librustc_target" }
|
||||
rustc_data_structures = { path = "../librustc_data_structures" }
|
||||
rustc_errors = { path = "../librustc_errors" }
|
||||
rustc_lexer = { path = "../librustc_lexer" }
|
||||
rustc_serialize = { path = "../libserialize", package = "serialize" }
|
||||
syntax = { path = "../libsyntax" }
|
||||
syntax_pos = { path = "../libsyntax_pos" }
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
use core::unicode::property::Pattern_White_Space;
|
||||
|
||||
use rustc::mir::*;
|
||||
use rustc::ty;
|
||||
use rustc_errors::{DiagnosticBuilder,Applicability};
|
||||
|
|
@ -526,7 +524,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
|
|||
let suggestion;
|
||||
let to_remove;
|
||||
if pat_snippet.starts_with("mut")
|
||||
&& pat_snippet["mut".len()..].starts_with(Pattern_White_Space)
|
||||
&& pat_snippet["mut".len()..].starts_with(rustc_lexer::is_whitespace)
|
||||
{
|
||||
suggestion = pat_snippet["mut".len()..].trim_start();
|
||||
to_remove = "&mut";
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
use core::unicode::property::Pattern_White_Space;
|
||||
use rustc::hir;
|
||||
use rustc::hir::Node;
|
||||
use rustc::mir::{self, BindingForm, ClearCrossCrate, Local, Location, Body};
|
||||
|
|
@ -715,7 +714,7 @@ fn annotate_struct_field(
|
|||
fn suggest_ref_mut(tcx: TyCtxt<'_>, binding_span: Span) -> Option<String> {
|
||||
let hi_src = tcx.sess.source_map().span_to_snippet(binding_span).ok()?;
|
||||
if hi_src.starts_with("ref")
|
||||
&& hi_src["ref".len()..].starts_with(Pattern_White_Space)
|
||||
&& hi_src["ref".len()..].starts_with(rustc_lexer::is_whitespace)
|
||||
{
|
||||
let replacement = format!("ref mut{}", &hi_src["ref".len()..]);
|
||||
Some(replacement)
|
||||
|
|
|
|||
|
|
@ -585,8 +585,9 @@ where
|
|||
use rustc::mir::StaticKind;
|
||||
|
||||
Ok(match place_static.kind {
|
||||
StaticKind::Promoted(promoted, _) => {
|
||||
let instance = self.frame().instance;
|
||||
StaticKind::Promoted(promoted, promoted_substs) => {
|
||||
let substs = self.subst_from_frame_and_normalize_erasing_regions(promoted_substs);
|
||||
let instance = ty::Instance::new(place_static.def_id, substs);
|
||||
self.const_eval_raw(GlobalId {
|
||||
instance,
|
||||
promoted: Some(promoted),
|
||||
|
|
|
|||
|
|
@ -405,13 +405,16 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
|||
}
|
||||
|
||||
let arg = self.eval_operand(arg, source_info)?;
|
||||
let oflo_check = self.tcx.sess.overflow_checks();
|
||||
let val = self.use_ecx(source_info, |this| {
|
||||
let prim = this.ecx.read_immediate(arg)?;
|
||||
match op {
|
||||
UnOp::Neg => {
|
||||
// Need to do overflow check here: For actual CTFE, MIR
|
||||
// generation emits code that does this before calling the op.
|
||||
if prim.to_bits()? == (1 << (prim.layout.size.bits() - 1)) {
|
||||
// We check overflow in debug mode already
|
||||
// so should only check in release mode.
|
||||
if !oflo_check
|
||||
&& prim.layout.ty.is_signed()
|
||||
&& prim.to_bits()? == (1 << (prim.layout.size.bits() - 1)) {
|
||||
throw_panic!(OverflowNeg)
|
||||
}
|
||||
}
|
||||
|
|
@ -485,7 +488,9 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
|||
Scalar::from_bool(overflow).into(),
|
||||
)
|
||||
} else {
|
||||
if overflow {
|
||||
// We check overflow in debug mode already
|
||||
// so should only check in release mode.
|
||||
if !self.tcx.sess.overflow_checks() && overflow {
|
||||
let err = err_panic!(Overflow(op)).into();
|
||||
let _: Option<()> = self.use_ecx(source_info, |_| Err(err));
|
||||
return None;
|
||||
|
|
|
|||
26
src/librustc_target/spec/linux_kernel_base.rs
Normal file
26
src/librustc_target/spec/linux_kernel_base.rs
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
use crate::spec::{LinkArgs, LinkerFlavor, PanicStrategy, RelroLevel, TargetOptions};
|
||||
use std::default::Default;
|
||||
|
||||
pub fn opts() -> TargetOptions {
|
||||
let mut pre_link_args = LinkArgs::new();
|
||||
pre_link_args.insert(
|
||||
LinkerFlavor::Gcc,
|
||||
vec!["-Wl,--as-needed".to_string(), "-Wl,-z,noexecstack".to_string()],
|
||||
);
|
||||
|
||||
TargetOptions {
|
||||
disable_redzone: true,
|
||||
panic_strategy: PanicStrategy::Abort,
|
||||
stack_probes: true,
|
||||
eliminate_frame_pointer: false,
|
||||
linker_is_gnu: true,
|
||||
position_independent_executables: true,
|
||||
needs_plt: true,
|
||||
relro_level: RelroLevel::Full,
|
||||
relocation_model: "static".to_string(),
|
||||
target_family: Some("unix".to_string()),
|
||||
pre_link_args,
|
||||
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
|
@ -53,6 +53,7 @@ mod freebsd_base;
|
|||
mod haiku_base;
|
||||
mod hermit_base;
|
||||
mod linux_base;
|
||||
mod linux_kernel_base;
|
||||
mod linux_musl_base;
|
||||
mod openbsd_base;
|
||||
mod netbsd_base;
|
||||
|
|
@ -386,6 +387,8 @@ supported_targets! {
|
|||
("thumbv7neon-linux-androideabi", thumbv7neon_linux_androideabi),
|
||||
("aarch64-linux-android", aarch64_linux_android),
|
||||
|
||||
("x86_64-linux-kernel", x86_64_linux_kernel),
|
||||
|
||||
("aarch64-unknown-freebsd", aarch64_unknown_freebsd),
|
||||
("armv6-unknown-freebsd", armv6_unknown_freebsd),
|
||||
("armv7-unknown-freebsd", armv7_unknown_freebsd),
|
||||
|
|
|
|||
31
src/librustc_target/spec/x86_64_linux_kernel.rs
Normal file
31
src/librustc_target/spec/x86_64_linux_kernel.rs
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
// This defines the amd64 target for the Linux Kernel. See the linux-kernel-base module for
|
||||
// generic Linux kernel options.
|
||||
|
||||
use crate::spec::{LinkerFlavor, Target, TargetResult};
|
||||
|
||||
pub fn target() -> TargetResult {
|
||||
let mut base = super::linux_kernel_base::opts();
|
||||
base.cpu = "x86-64".to_string();
|
||||
base.max_atomic_width = Some(64);
|
||||
base.features =
|
||||
"-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-3dnow,-3dnowa,-avx,-avx2,+soft-float"
|
||||
.to_string();
|
||||
base.code_model = Some("kernel".to_string());
|
||||
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
|
||||
|
||||
Ok(Target {
|
||||
// FIXME: Some dispute, the linux-on-clang folks think this should use "Linux"
|
||||
llvm_target: "x86_64-elf".to_string(),
|
||||
target_endian: "little".to_string(),
|
||||
target_pointer_width: "64".to_string(),
|
||||
target_c_int_width: "32".to_string(),
|
||||
data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(),
|
||||
target_os: "none".to_string(),
|
||||
target_env: "gnu".to_string(),
|
||||
target_vendor: "unknown".to_string(),
|
||||
arch: "x86_64".to_string(),
|
||||
linker_flavor: LinkerFlavor::Gcc,
|
||||
|
||||
options: base,
|
||||
})
|
||||
}
|
||||
|
|
@ -3687,6 +3687,40 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
/// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
|
||||
/// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
|
||||
/// when given code like the following:
|
||||
/// ```text
|
||||
/// if false { return 0i32; } else { 1u32 }
|
||||
/// // ^^^^ point at this instead of the whole `if` expression
|
||||
/// ```
|
||||
fn get_expr_coercion_span(&self, expr: &hir::Expr) -> syntax_pos::Span {
|
||||
if let hir::ExprKind::Match(_, arms, _) = &expr.node {
|
||||
let arm_spans: Vec<Span> = arms.iter().filter_map(|arm| {
|
||||
self.in_progress_tables
|
||||
.and_then(|tables| tables.borrow().node_type_opt(arm.body.hir_id))
|
||||
.and_then(|arm_ty| {
|
||||
if arm_ty.is_never() {
|
||||
None
|
||||
} else {
|
||||
Some(match &arm.body.node {
|
||||
// Point at the tail expression when possible.
|
||||
hir::ExprKind::Block(block, _) => block.expr
|
||||
.as_ref()
|
||||
.map(|e| e.span)
|
||||
.unwrap_or(block.span),
|
||||
_ => arm.body.span,
|
||||
})
|
||||
}
|
||||
})
|
||||
}).collect();
|
||||
if arm_spans.len() == 1 {
|
||||
return arm_spans[0];
|
||||
}
|
||||
}
|
||||
expr.span
|
||||
}
|
||||
|
||||
fn check_block_with_expected(
|
||||
&self,
|
||||
blk: &'tcx hir::Block,
|
||||
|
|
@ -3746,12 +3780,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
let coerce = ctxt.coerce.as_mut().unwrap();
|
||||
if let Some(tail_expr_ty) = tail_expr_ty {
|
||||
let tail_expr = tail_expr.unwrap();
|
||||
let cause = self.cause(tail_expr.span,
|
||||
ObligationCauseCode::BlockTailExpression(blk.hir_id));
|
||||
coerce.coerce(self,
|
||||
&cause,
|
||||
tail_expr,
|
||||
tail_expr_ty);
|
||||
let span = self.get_expr_coercion_span(tail_expr);
|
||||
let cause = self.cause(span, ObligationCauseCode::BlockTailExpression(blk.hir_id));
|
||||
coerce.coerce(self, &cause, tail_expr, tail_expr_ty);
|
||||
} else {
|
||||
// Subtle: if there is no explicit tail expression,
|
||||
// that is typically equivalent to a tail expression
|
||||
|
|
|
|||
|
|
@ -344,7 +344,7 @@ if (!DOMTokenList.prototype.remove) {
|
|||
var set_fragment = function(name) {
|
||||
if (browserSupportsHistoryApi()) {
|
||||
history.replaceState(null, null, "#" + name);
|
||||
window.hashchange();
|
||||
highlightSourceLines(null);
|
||||
} else {
|
||||
location.replace("#" + name);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ extern crate rustc_interface;
|
|||
extern crate rustc_metadata;
|
||||
extern crate rustc_target;
|
||||
extern crate rustc_typeck;
|
||||
extern crate rustc_lexer;
|
||||
extern crate serialize;
|
||||
extern crate syntax;
|
||||
extern crate syntax_pos;
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ impl<'a, 'tcx> SyntaxChecker<'a, 'tcx> {
|
|||
// We couldn't calculate the span of the markdown block that had the error, so our
|
||||
// diagnostics are going to be a bit lacking.
|
||||
let mut diag = self.cx.sess().struct_span_warn(
|
||||
super::span_of_attrs(&item.attrs),
|
||||
super::span_of_attrs(&item.attrs).unwrap_or(item.source.span()),
|
||||
"doc comment contains an invalid Rust code block",
|
||||
);
|
||||
|
||||
|
|
|
|||
|
|
@ -465,7 +465,7 @@ fn resolution_failure(
|
|||
}
|
||||
};
|
||||
let attrs = &item.attrs;
|
||||
let sp = span_of_attrs(attrs);
|
||||
let sp = span_of_attrs(attrs).unwrap_or(item.source.span());
|
||||
|
||||
let mut diag = cx.tcx.struct_span_lint_hir(
|
||||
lint::builtin::INTRA_DOC_LINK_RESOLUTION_FAILURE,
|
||||
|
|
@ -517,7 +517,7 @@ fn ambiguity_error(
|
|||
}
|
||||
};
|
||||
let attrs = &item.attrs;
|
||||
let sp = span_of_attrs(attrs);
|
||||
let sp = span_of_attrs(attrs).unwrap_or(item.source.span());
|
||||
|
||||
let mut msg = format!("`{}` is ", path_str);
|
||||
|
||||
|
|
|
|||
|
|
@ -339,7 +339,7 @@ pub fn look_for_tests<'tcx>(
|
|||
find_testable_code(&dox, &mut tests, ErrorCodes::No);
|
||||
|
||||
if check_missing_code == true && tests.found_tests == 0 {
|
||||
let sp = span_of_attrs(&item.attrs).substitute_dummy(item.source.span());
|
||||
let sp = span_of_attrs(&item.attrs).unwrap_or(item.source.span());
|
||||
let mut diag = cx.tcx.struct_span_lint_hir(
|
||||
lint::builtin::MISSING_DOC_CODE_EXAMPLES,
|
||||
hir_id,
|
||||
|
|
@ -352,20 +352,23 @@ pub fn look_for_tests<'tcx>(
|
|||
let mut diag = cx.tcx.struct_span_lint_hir(
|
||||
lint::builtin::PRIVATE_DOC_TESTS,
|
||||
hir_id,
|
||||
span_of_attrs(&item.attrs),
|
||||
span_of_attrs(&item.attrs).unwrap_or(item.source.span()),
|
||||
"Documentation test in private item");
|
||||
diag.emit();
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a span encompassing all the given attributes.
|
||||
crate fn span_of_attrs(attrs: &clean::Attributes) -> Span {
|
||||
crate fn span_of_attrs(attrs: &clean::Attributes) -> Option<Span> {
|
||||
if attrs.doc_strings.is_empty() {
|
||||
return DUMMY_SP;
|
||||
return None;
|
||||
}
|
||||
let start = attrs.doc_strings[0].span();
|
||||
if start == DUMMY_SP {
|
||||
return None;
|
||||
}
|
||||
let end = attrs.doc_strings.last().expect("No doc strings provided").span();
|
||||
start.to(end)
|
||||
Some(start.to(end))
|
||||
}
|
||||
|
||||
/// Attempts to match a range of bytes from parsed markdown to a `Span` in the source code.
|
||||
|
|
@ -391,7 +394,7 @@ crate fn source_span_for_markdown_range(
|
|||
let snippet = cx
|
||||
.sess()
|
||||
.source_map()
|
||||
.span_to_snippet(span_of_attrs(attrs))
|
||||
.span_to_snippet(span_of_attrs(attrs)?)
|
||||
.ok()?;
|
||||
|
||||
let starting_line = markdown[..md_range.start].matches('\n').count();
|
||||
|
|
@ -441,10 +444,8 @@ crate fn source_span_for_markdown_range(
|
|||
}
|
||||
}
|
||||
|
||||
let sp = span_of_attrs(attrs).from_inner(InnerSpan::new(
|
||||
Some(span_of_attrs(attrs)?.from_inner(InnerSpan::new(
|
||||
md_range.start + start_bytes,
|
||||
md_range.end + start_bytes + end_bytes,
|
||||
));
|
||||
|
||||
Some(sp)
|
||||
)))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -763,8 +763,8 @@ impl Tester for Collector {
|
|||
// We use these headings as test names, so it's good if
|
||||
// they're valid identifiers.
|
||||
let name = name.chars().enumerate().map(|(i, c)| {
|
||||
if (i == 0 && c.is_xid_start()) ||
|
||||
(i != 0 && c.is_xid_continue()) {
|
||||
if (i == 0 && rustc_lexer::is_id_start(c)) ||
|
||||
(i != 0 && rustc_lexer::is_id_continue(c)) {
|
||||
c
|
||||
} else {
|
||||
'_'
|
||||
|
|
|
|||
|
|
@ -27,8 +27,7 @@ impl Condvar {
|
|||
|
||||
pub unsafe fn wait(&self, mutex: &Mutex) {
|
||||
let guard = self.inner.lock();
|
||||
mutex.unlock();
|
||||
WaitQueue::wait(guard);
|
||||
WaitQueue::wait(guard, || mutex.unlock());
|
||||
mutex.lock()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ impl Mutex {
|
|||
let mut guard = self.inner.lock();
|
||||
if *guard.lock_var() {
|
||||
// Another thread has the lock, wait
|
||||
WaitQueue::wait(guard)
|
||||
WaitQueue::wait(guard, ||{})
|
||||
// Another thread has passed the lock to us
|
||||
} else {
|
||||
// We are just now obtaining the lock
|
||||
|
|
@ -83,7 +83,7 @@ impl ReentrantMutex {
|
|||
match guard.lock_var().owner {
|
||||
Some(tcs) if tcs != thread::current() => {
|
||||
// Another thread has the lock, wait
|
||||
WaitQueue::wait(guard);
|
||||
WaitQueue::wait(guard, ||{});
|
||||
// Another thread has passed the lock to us
|
||||
},
|
||||
_ => {
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ impl RWLock {
|
|||
if *wguard.lock_var() || !wguard.queue_empty() {
|
||||
// Another thread has or is waiting for the write lock, wait
|
||||
drop(wguard);
|
||||
WaitQueue::wait(rguard);
|
||||
WaitQueue::wait(rguard, ||{});
|
||||
// Another thread has passed the lock to us
|
||||
} else {
|
||||
// No waiting writers, acquire the read lock
|
||||
|
|
@ -62,7 +62,7 @@ impl RWLock {
|
|||
if *wguard.lock_var() || rguard.lock_var().is_some() {
|
||||
// Another thread has the lock, wait
|
||||
drop(rguard);
|
||||
WaitQueue::wait(wguard);
|
||||
WaitQueue::wait(wguard, ||{});
|
||||
// Another thread has passed the lock to us
|
||||
} else {
|
||||
// We are just now obtaining the lock
|
||||
|
|
@ -97,6 +97,7 @@ impl RWLock {
|
|||
if let Ok(mut wguard) = WaitQueue::notify_one(wguard) {
|
||||
// A writer was waiting, pass the lock
|
||||
*wguard.lock_var_mut() = true;
|
||||
wguard.drop_after(rguard);
|
||||
} else {
|
||||
// No writers were waiting, the lock is released
|
||||
rtassert!(rguard.queue_empty());
|
||||
|
|
@ -117,21 +118,26 @@ impl RWLock {
|
|||
rguard: SpinMutexGuard<'_, WaitVariable<Option<NonZeroUsize>>>,
|
||||
wguard: SpinMutexGuard<'_, WaitVariable<bool>>,
|
||||
) {
|
||||
if let Err(mut wguard) = WaitQueue::notify_one(wguard) {
|
||||
// No writers waiting, release the write lock
|
||||
*wguard.lock_var_mut() = false;
|
||||
if let Ok(mut rguard) = WaitQueue::notify_all(rguard) {
|
||||
// One or more readers were waiting, pass the lock to them
|
||||
if let NotifiedTcs::All { count } = rguard.notified_tcs() {
|
||||
*rguard.lock_var_mut() = Some(count)
|
||||
match WaitQueue::notify_one(wguard) {
|
||||
Err(mut wguard) => {
|
||||
// No writers waiting, release the write lock
|
||||
*wguard.lock_var_mut() = false;
|
||||
if let Ok(mut rguard) = WaitQueue::notify_all(rguard) {
|
||||
// One or more readers were waiting, pass the lock to them
|
||||
if let NotifiedTcs::All { count } = rguard.notified_tcs() {
|
||||
*rguard.lock_var_mut() = Some(count)
|
||||
} else {
|
||||
unreachable!() // called notify_all
|
||||
}
|
||||
rguard.drop_after(wguard);
|
||||
} else {
|
||||
unreachable!() // called notify_all
|
||||
// No readers waiting, the lock is released
|
||||
}
|
||||
} else {
|
||||
// No readers waiting, the lock is released
|
||||
},
|
||||
Ok(wguard) => {
|
||||
// There was a thread waiting for write, just pass the lock
|
||||
wguard.drop_after(rguard);
|
||||
}
|
||||
} else {
|
||||
// There was a thread waiting for write, just pass the lock
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -98,6 +98,12 @@ impl<'a, T> WaitGuard<'a, T> {
|
|||
pub fn notified_tcs(&self) -> NotifiedTcs {
|
||||
self.notified_tcs
|
||||
}
|
||||
|
||||
/// Drop this `WaitGuard`, after dropping another `guard`.
|
||||
pub fn drop_after<U>(self, guard: U) {
|
||||
drop(guard);
|
||||
drop(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T> Deref for WaitGuard<'a, T> {
|
||||
|
|
@ -140,7 +146,7 @@ impl WaitQueue {
|
|||
/// until a wakeup event.
|
||||
///
|
||||
/// This function does not return until this thread has been awoken.
|
||||
pub fn wait<T>(mut guard: SpinMutexGuard<'_, WaitVariable<T>>) {
|
||||
pub fn wait<T, F: FnOnce()>(mut guard: SpinMutexGuard<'_, WaitVariable<T>>, before_wait: F) {
|
||||
// very unsafe: check requirements of UnsafeList::push
|
||||
unsafe {
|
||||
let mut entry = UnsafeListEntry::new(SpinMutex::new(WaitEntry {
|
||||
|
|
@ -149,6 +155,7 @@ impl WaitQueue {
|
|||
}));
|
||||
let entry = guard.queue.inner.push(&mut entry);
|
||||
drop(guard);
|
||||
before_wait();
|
||||
while !entry.lock().wake {
|
||||
// don't panic, this would invalidate `entry` during unwinding
|
||||
let eventset = rtunwrap!(Ok, usercalls::wait(EV_UNPARK, WAIT_INDEFINITE));
|
||||
|
|
@ -545,7 +552,7 @@ mod tests {
|
|||
assert!(WaitQueue::notify_one(wq2.lock()).is_ok());
|
||||
});
|
||||
|
||||
WaitQueue::wait(locked);
|
||||
WaitQueue::wait(locked, ||{});
|
||||
|
||||
t1.join().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use crate::ext::base::{ExtCtxt, MacEager, MacResult};
|
|||
use crate::parse::token::{self, Token};
|
||||
use crate::ptr::P;
|
||||
use crate::symbol::kw;
|
||||
use crate::tokenstream::{TokenTree};
|
||||
use crate::tokenstream::{TokenTree, TokenStream};
|
||||
|
||||
use smallvec::smallvec;
|
||||
use syntax_pos::Span;
|
||||
|
|
@ -27,12 +27,11 @@ pub type ErrorMap = BTreeMap<Name, ErrorInfo>;
|
|||
|
||||
pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt<'_>,
|
||||
span: Span,
|
||||
token_tree: &[TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn MacResult+'cx> {
|
||||
let code = match token_tree {
|
||||
[
|
||||
TokenTree::Token(Token { kind: token::Ident(code, _), .. })
|
||||
] => code,
|
||||
assert_eq!(tts.len(), 1);
|
||||
let code = match tts.into_trees().next() {
|
||||
Some(TokenTree::Token(Token { kind: token::Ident(code, _), .. })) => code,
|
||||
_ => unreachable!()
|
||||
};
|
||||
|
||||
|
|
@ -62,20 +61,21 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt<'_>,
|
|||
|
||||
pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt<'_>,
|
||||
span: Span,
|
||||
token_tree: &[TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn MacResult+'cx> {
|
||||
let (code, description) = match token_tree {
|
||||
[
|
||||
TokenTree::Token(Token { kind: token::Ident(code, _), .. })
|
||||
] => {
|
||||
(*code, None)
|
||||
},
|
||||
[
|
||||
TokenTree::Token(Token { kind: token::Ident(code, _), .. }),
|
||||
TokenTree::Token(Token { kind: token::Comma, .. }),
|
||||
TokenTree::Token(Token { kind: token::Literal(token::Lit { symbol, .. }), ..})
|
||||
] => {
|
||||
(*code, Some(*symbol))
|
||||
assert!(tts.len() == 1 || tts.len() == 3);
|
||||
let mut cursor = tts.into_trees();
|
||||
let code = match cursor.next() {
|
||||
Some(TokenTree::Token(Token { kind: token::Ident(code, _), .. })) => code,
|
||||
_ => unreachable!()
|
||||
};
|
||||
let description = match (cursor.next(), cursor.next()) {
|
||||
(None, None) => None,
|
||||
(
|
||||
Some(TokenTree::Token(Token { kind: token::Comma, .. })),
|
||||
Some(TokenTree::Token(Token { kind: token::Literal(token::Lit { symbol, .. }), ..}))
|
||||
) => {
|
||||
Some(symbol)
|
||||
},
|
||||
_ => unreachable!()
|
||||
};
|
||||
|
|
@ -121,12 +121,12 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt<'_>,
|
|||
|
||||
pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt<'_>,
|
||||
span: Span,
|
||||
token_tree: &[TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn MacResult+'cx> {
|
||||
assert_eq!(token_tree.len(), 3);
|
||||
let ident = match &token_tree[2] {
|
||||
assert_eq!(tts.len(), 3);
|
||||
let ident = match tts.into_trees().nth(2) {
|
||||
// DIAGNOSTICS ident.
|
||||
&TokenTree::Token(Token { kind: token::Ident(name, _), span })
|
||||
Some(TokenTree::Token(Token { kind: token::Ident(name, _), span }))
|
||||
=> Ident::new(name, span),
|
||||
_ => unreachable!()
|
||||
};
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::parse::token;
|
|||
use crate::ptr::P;
|
||||
use crate::symbol::{kw, sym, Ident, Symbol};
|
||||
use crate::{ThinVec, MACRO_ARGUMENTS};
|
||||
use crate::tokenstream::{self, TokenStream, TokenTree};
|
||||
use crate::tokenstream::{self, TokenStream};
|
||||
use crate::visit::Visitor;
|
||||
|
||||
use errors::{DiagnosticBuilder, DiagnosticId};
|
||||
|
|
@ -235,18 +235,18 @@ pub trait TTMacroExpander {
|
|||
}
|
||||
|
||||
pub type MacroExpanderFn =
|
||||
for<'cx> fn(&'cx mut ExtCtxt<'_>, Span, &[tokenstream::TokenTree])
|
||||
for<'cx> fn(&'cx mut ExtCtxt<'_>, Span, TokenStream)
|
||||
-> Box<dyn MacResult+'cx>;
|
||||
|
||||
impl<F> TTMacroExpander for F
|
||||
where F: for<'cx> Fn(&'cx mut ExtCtxt<'_>, Span, &[tokenstream::TokenTree])
|
||||
where F: for<'cx> Fn(&'cx mut ExtCtxt<'_>, Span, TokenStream)
|
||||
-> Box<dyn MacResult+'cx>
|
||||
{
|
||||
fn expand<'cx>(
|
||||
&self,
|
||||
ecx: &'cx mut ExtCtxt<'_>,
|
||||
span: Span,
|
||||
input: TokenStream,
|
||||
mut input: TokenStream,
|
||||
) -> Box<dyn MacResult+'cx> {
|
||||
struct AvoidInterpolatedIdents;
|
||||
|
||||
|
|
@ -268,10 +268,8 @@ impl<F> TTMacroExpander for F
|
|||
mut_visit::noop_visit_mac(mac, self)
|
||||
}
|
||||
}
|
||||
|
||||
let input: Vec<_> =
|
||||
input.trees().map(|mut tt| { AvoidInterpolatedIdents.visit_tt(&mut tt); tt }).collect();
|
||||
(*self)(ecx, span, &input)
|
||||
AvoidInterpolatedIdents.visit_tts(&mut input);
|
||||
(*self)(ecx, span, input)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -677,7 +675,7 @@ impl SyntaxExtension {
|
|||
}
|
||||
|
||||
pub fn dummy_bang(edition: Edition) -> SyntaxExtension {
|
||||
fn expander<'cx>(_: &'cx mut ExtCtxt<'_>, span: Span, _: &[TokenTree])
|
||||
fn expander<'cx>(_: &'cx mut ExtCtxt<'_>, span: Span, _: TokenStream)
|
||||
-> Box<dyn MacResult + 'cx> {
|
||||
DummyResult::any(span)
|
||||
}
|
||||
|
|
@ -811,9 +809,8 @@ impl<'a> ExtCtxt<'a> {
|
|||
pub fn monotonic_expander<'b>(&'b mut self) -> expand::MacroExpander<'b, 'a> {
|
||||
expand::MacroExpander::new(self, true)
|
||||
}
|
||||
|
||||
pub fn new_parser_from_tts(&self, tts: &[tokenstream::TokenTree]) -> parser::Parser<'a> {
|
||||
parse::stream_to_parser(self.parse_sess, tts.iter().cloned().collect(), MACRO_ARGUMENTS)
|
||||
pub fn new_parser_from_tts(&self, stream: TokenStream) -> parser::Parser<'a> {
|
||||
parse::stream_to_parser(self.parse_sess, stream, MACRO_ARGUMENTS)
|
||||
}
|
||||
pub fn source_map(&self) -> &'a SourceMap { self.parse_sess.source_map() }
|
||||
pub fn parse_sess(&self) -> &'a parse::ParseSess { self.parse_sess }
|
||||
|
|
@ -1019,7 +1016,7 @@ pub fn expr_to_string(cx: &mut ExtCtxt<'_>, expr: P<ast::Expr>, err_msg: &str)
|
|||
/// done as rarely as possible).
|
||||
pub fn check_zero_tts(cx: &ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
name: &str) {
|
||||
if !tts.is_empty() {
|
||||
cx.span_err(sp, &format!("{} takes no arguments", name));
|
||||
|
|
@ -1030,7 +1027,7 @@ pub fn check_zero_tts(cx: &ExtCtxt<'_>,
|
|||
/// expect exactly one string literal, or emit an error and return `None`.
|
||||
pub fn get_single_str_from_tts(cx: &mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
name: &str)
|
||||
-> Option<String> {
|
||||
let mut p = cx.new_parser_from_tts(tts);
|
||||
|
|
@ -1053,7 +1050,7 @@ pub fn get_single_str_from_tts(cx: &mut ExtCtxt<'_>,
|
|||
/// parsing error, emit a non-fatal error and return `None`.
|
||||
pub fn get_exprs_from_tts(cx: &mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree]) -> Option<Vec<P<ast::Expr>>> {
|
||||
tts: TokenStream) -> Option<Vec<P<ast::Expr>>> {
|
||||
let mut p = cx.new_parser_from_tts(tts);
|
||||
let mut es = Vec::new();
|
||||
while p.token != token::Eof {
|
||||
|
|
|
|||
|
|
@ -701,7 +701,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
|
|||
path: &Path,
|
||||
span: Span,
|
||||
) -> AstFragment {
|
||||
let mut parser = self.cx.new_parser_from_tts(&toks.into_trees().collect::<Vec<_>>());
|
||||
let mut parser = self.cx.new_parser_from_tts(toks);
|
||||
match parser.parse_ast_fragment(kind, false) {
|
||||
Ok(fragment) => {
|
||||
parser.ensure_complete_parse(path, kind.name(), span);
|
||||
|
|
|
|||
|
|
@ -322,8 +322,7 @@ impl Ident {
|
|||
fn is_valid(string: &str) -> bool {
|
||||
let mut chars = string.chars();
|
||||
if let Some(start) = chars.next() {
|
||||
(start == '_' || start.is_xid_start())
|
||||
&& chars.all(|cont| cont == '_' || cont.is_xid_continue())
|
||||
rustc_lexer::is_id_start(start) && chars.all(rustc_lexer::is_id_continue)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
|
|
|
|||
|
|
@ -356,11 +356,7 @@ pub fn tt_to_string(tt: tokenstream::TokenTree) -> String {
|
|||
to_string(|s| s.print_tt(tt, false))
|
||||
}
|
||||
|
||||
pub fn tts_to_string(tts: &[tokenstream::TokenTree]) -> String {
|
||||
tokens_to_string(tts.iter().cloned().collect())
|
||||
}
|
||||
|
||||
pub fn tokens_to_string(tokens: TokenStream) -> String {
|
||||
pub fn tts_to_string(tokens: TokenStream) -> String {
|
||||
to_string(|s| s.print_tts(tokens, false))
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ crate fn matches_codepattern(a : &str, b : &str) -> bool {
|
|||
(None, None) => return true,
|
||||
(None, _) => return false,
|
||||
(Some(&a), None) => {
|
||||
if is_pattern_whitespace(a) {
|
||||
if rustc_lexer::is_whitespace(a) {
|
||||
break // trailing whitespace check is out of loop for borrowck
|
||||
} else {
|
||||
return false
|
||||
|
|
@ -72,11 +72,11 @@ crate fn matches_codepattern(a : &str, b : &str) -> bool {
|
|||
(Some(&a), Some(&b)) => (a, b)
|
||||
};
|
||||
|
||||
if is_pattern_whitespace(a) && is_pattern_whitespace(b) {
|
||||
if rustc_lexer::is_whitespace(a) && rustc_lexer::is_whitespace(b) {
|
||||
// skip whitespace for a and b
|
||||
scan_for_non_ws_or_end(&mut a_iter);
|
||||
scan_for_non_ws_or_end(&mut b_iter);
|
||||
} else if is_pattern_whitespace(a) {
|
||||
} else if rustc_lexer::is_whitespace(a) {
|
||||
// skip whitespace for a
|
||||
scan_for_non_ws_or_end(&mut a_iter);
|
||||
} else if a == b {
|
||||
|
|
@ -88,20 +88,16 @@ crate fn matches_codepattern(a : &str, b : &str) -> bool {
|
|||
}
|
||||
|
||||
// check if a has *only* trailing whitespace
|
||||
a_iter.all(is_pattern_whitespace)
|
||||
a_iter.all(rustc_lexer::is_whitespace)
|
||||
}
|
||||
|
||||
/// Advances the given peekable `Iterator` until it reaches a non-whitespace character
|
||||
fn scan_for_non_ws_or_end<I: Iterator<Item = char>>(iter: &mut Peekable<I>) {
|
||||
while iter.peek().copied().map(|c| is_pattern_whitespace(c)) == Some(true) {
|
||||
while iter.peek().copied().map(|c| rustc_lexer::is_whitespace(c)) == Some(true) {
|
||||
iter.next();
|
||||
}
|
||||
}
|
||||
|
||||
fn is_pattern_whitespace(c: char) -> bool {
|
||||
rustc_lexer::character_properties::is_whitespace(c)
|
||||
}
|
||||
|
||||
/// Identify a position in the text by the Nth occurrence of a string.
|
||||
struct Position {
|
||||
string: &'static str,
|
||||
|
|
|
|||
|
|
@ -506,7 +506,7 @@ impl Cursor {
|
|||
|
||||
impl fmt::Display for TokenStream {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.write_str(&pprust::tokens_to_string(self.clone()))
|
||||
f.write_str(&pprust::tts_to_string(self.clone()))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -18,3 +18,4 @@ rustc_target = { path = "../librustc_target" }
|
|||
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
|
||||
syntax = { path = "../libsyntax" }
|
||||
syntax_pos = { path = "../libsyntax_pos" }
|
||||
rustc_lexer = { path = "../librustc_lexer" }
|
||||
|
|
|
|||
|
|
@ -8,13 +8,12 @@ use errors::DiagnosticBuilder;
|
|||
|
||||
use syntax::ast;
|
||||
use syntax::ext::base::{self, *};
|
||||
use syntax::parse;
|
||||
use syntax::parse::token::{self, Token};
|
||||
use syntax::ptr::P;
|
||||
use syntax::symbol::{kw, sym, Symbol};
|
||||
use syntax::ast::AsmDialect;
|
||||
use syntax_pos::Span;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::{self, TokenStream};
|
||||
use syntax::{span_err, struct_span_err};
|
||||
|
||||
enum State {
|
||||
|
|
@ -43,7 +42,7 @@ const OPTIONS: &[Symbol] = &[sym::volatile, sym::alignstack, sym::intel];
|
|||
|
||||
pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
let mut inline_asm = match parse_inline_asm(cx, sp, tts) {
|
||||
Ok(Some(inline_asm)) => inline_asm,
|
||||
|
|
@ -71,20 +70,20 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
|||
fn parse_inline_asm<'a>(
|
||||
cx: &mut ExtCtxt<'a>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Result<Option<ast::InlineAsm>, DiagnosticBuilder<'a>> {
|
||||
// Split the tts before the first colon, to avoid `asm!("x": y)` being
|
||||
// parsed as `asm!(z)` with `z = "x": y` which is type ascription.
|
||||
let first_colon = tts.iter()
|
||||
let first_colon = tts.trees()
|
||||
.position(|tt| {
|
||||
match *tt {
|
||||
match tt {
|
||||
tokenstream::TokenTree::Token(Token { kind: token::Colon, .. }) |
|
||||
tokenstream::TokenTree::Token(Token { kind: token::ModSep, .. }) => true,
|
||||
_ => false,
|
||||
}
|
||||
})
|
||||
.unwrap_or(tts.len());
|
||||
let mut p = cx.new_parser_from_tts(&tts[first_colon..]);
|
||||
let mut p = cx.new_parser_from_tts(tts.trees().skip(first_colon).collect());
|
||||
let mut asm = kw::Invalid;
|
||||
let mut asm_str_style = None;
|
||||
let mut outputs = Vec::new();
|
||||
|
|
@ -110,7 +109,8 @@ fn parse_inline_asm<'a>(
|
|||
));
|
||||
}
|
||||
// Nested parser, stop before the first colon (see above).
|
||||
let mut p2 = cx.new_parser_from_tts(&tts[..first_colon]);
|
||||
let mut p2 =
|
||||
cx.new_parser_from_tts(tts.trees().take(first_colon).collect());
|
||||
|
||||
if p2.token == token::Eof {
|
||||
let mut err =
|
||||
|
|
@ -129,12 +129,8 @@ fn parse_inline_asm<'a>(
|
|||
// This is most likely malformed.
|
||||
if p2.token != token::Eof {
|
||||
let mut extra_tts = p2.parse_all_token_trees()?;
|
||||
extra_tts.extend(tts[first_colon..].iter().cloned());
|
||||
p = parse::stream_to_parser(
|
||||
cx.parse_sess,
|
||||
extra_tts.into_iter().collect(),
|
||||
Some("inline assembly"),
|
||||
);
|
||||
extra_tts.extend(tts.trees().skip(first_colon));
|
||||
p = cx.new_parser_from_tts(extra_tts.into_iter().collect());
|
||||
}
|
||||
|
||||
asm = s;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ use syntax_pos::{Span, DUMMY_SP};
|
|||
pub fn expand_assert<'cx>(
|
||||
cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Box<dyn MacResult + 'cx> {
|
||||
let Assert { cond_expr, custom_message } = match parse_assert(cx, sp, tts) {
|
||||
Ok(assert) => assert,
|
||||
|
|
@ -59,9 +59,9 @@ struct Assert {
|
|||
fn parse_assert<'a>(
|
||||
cx: &mut ExtCtxt<'a>,
|
||||
sp: Span,
|
||||
tts: &[TokenTree]
|
||||
stream: TokenStream
|
||||
) -> Result<Assert, DiagnosticBuilder<'a>> {
|
||||
let mut parser = cx.new_parser_from_tts(tts);
|
||||
let mut parser = cx.new_parser_from_tts(stream);
|
||||
|
||||
if parser.token == token::Eof {
|
||||
let mut err = cx.struct_span_err(sp, "macro requires a boolean expression as an argument");
|
||||
|
|
|
|||
|
|
@ -7,14 +7,14 @@ use errors::DiagnosticBuilder;
|
|||
use syntax::ast;
|
||||
use syntax::ext::base::{self, *};
|
||||
use syntax::attr;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
use syntax::parse::token;
|
||||
use syntax_pos::Span;
|
||||
|
||||
pub fn expand_cfg(
|
||||
cx: &mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Box<dyn base::MacResult + 'static> {
|
||||
let sp = cx.with_legacy_ctxt(sp);
|
||||
|
||||
|
|
@ -33,7 +33,7 @@ pub fn expand_cfg(
|
|||
fn parse_cfg<'a>(
|
||||
cx: &mut ExtCtxt<'a>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Result<ast::MetaItem, DiagnosticBuilder<'a>> {
|
||||
let mut p = cx.new_parser_from_tts(tts);
|
||||
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
use syntax::ext::base::{self, *};
|
||||
use syntax_pos::Span;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
|
||||
pub fn expand_compile_error<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
let var = match get_single_str_from_tts(cx, sp, tts, "compile_error!") {
|
||||
None => return DummyResult::any(sp),
|
||||
|
|
|
|||
|
|
@ -1,14 +1,14 @@
|
|||
use syntax::ast;
|
||||
use syntax::ext::base::{self, DummyResult};
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
|
||||
use std::string::String;
|
||||
|
||||
pub fn expand_syntax_ext(
|
||||
pub fn expand_concat(
|
||||
cx: &mut base::ExtCtxt<'_>,
|
||||
sp: syntax_pos::Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Box<dyn base::MacResult + 'static> {
|
||||
let es = match base::get_exprs_from_tts(cx, sp, tts) {
|
||||
Some(e) => e,
|
||||
|
|
|
|||
|
|
@ -6,21 +6,21 @@ use syntax::parse::token::{self, Token};
|
|||
use syntax::ptr::P;
|
||||
use syntax_pos::Span;
|
||||
use syntax_pos::symbol::Symbol;
|
||||
use syntax::tokenstream::TokenTree;
|
||||
use syntax::tokenstream::{TokenTree, TokenStream};
|
||||
|
||||
pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[TokenTree])
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
pub fn expand_concat_idents<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
if tts.is_empty() {
|
||||
cx.span_err(sp, "concat_idents! takes 1 or more arguments.");
|
||||
return DummyResult::any(sp);
|
||||
}
|
||||
|
||||
let mut res_str = String::new();
|
||||
for (i, e) in tts.iter().enumerate() {
|
||||
for (i, e) in tts.into_trees().enumerate() {
|
||||
if i & 1 == 1 {
|
||||
match *e {
|
||||
match e {
|
||||
TokenTree::Token(Token { kind: token::Comma, .. }) => {}
|
||||
_ => {
|
||||
cx.span_err(sp, "concat_idents! expecting comma.");
|
||||
|
|
@ -28,7 +28,7 @@ pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
|||
}
|
||||
}
|
||||
} else {
|
||||
match *e {
|
||||
match e {
|
||||
TokenTree::Token(Token { kind: token::Ident(name, _), .. }) =>
|
||||
res_str.push_str(&name.as_str()),
|
||||
_ => {
|
||||
|
|
|
|||
|
|
@ -7,13 +7,13 @@ use syntax::ast::{self, Ident, GenericArg};
|
|||
use syntax::ext::base::{self, *};
|
||||
use syntax::symbol::{kw, sym, Symbol};
|
||||
use syntax_pos::Span;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
|
||||
use std::env;
|
||||
|
||||
pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
let var = match get_single_str_from_tts(cx, sp, tts, "option_env!") {
|
||||
None => return DummyResult::any(sp),
|
||||
|
|
@ -45,7 +45,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
|||
|
||||
pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
let mut exprs = match get_exprs_from_tts(cx, sp, tts) {
|
||||
Some(ref exprs) if exprs.is_empty() => {
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use syntax::ext::base::{self, *};
|
|||
use syntax::parse::token;
|
||||
use syntax::ptr::P;
|
||||
use syntax::symbol::{Symbol, sym};
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
use syntax_pos::{MultiSpan, Span};
|
||||
|
||||
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
|
||||
|
|
@ -126,7 +126,7 @@ struct Context<'a, 'b> {
|
|||
fn parse_args<'a>(
|
||||
ecx: &mut ExtCtxt<'a>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree]
|
||||
tts: TokenStream,
|
||||
) -> Result<(P<ast::Expr>, Vec<P<ast::Expr>>, FxHashMap<Symbol, usize>), DiagnosticBuilder<'a>> {
|
||||
let mut args = Vec::<P<ast::Expr>>::new();
|
||||
let mut names = FxHashMap::<Symbol, usize>::default();
|
||||
|
|
@ -794,7 +794,7 @@ impl<'a, 'b> Context<'a, 'b> {
|
|||
fn expand_format_args_impl<'cx>(
|
||||
ecx: &'cx mut ExtCtxt<'_>,
|
||||
mut sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
nl: bool,
|
||||
) -> Box<dyn base::MacResult + 'cx> {
|
||||
sp = ecx.with_def_site_ctxt(sp);
|
||||
|
|
@ -812,7 +812,7 @@ fn expand_format_args_impl<'cx>(
|
|||
pub fn expand_format_args<'cx>(
|
||||
ecx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Box<dyn base::MacResult + 'cx> {
|
||||
expand_format_args_impl(ecx, sp, tts, false)
|
||||
}
|
||||
|
|
@ -820,7 +820,7 @@ pub fn expand_format_args<'cx>(
|
|||
pub fn expand_format_args_nl<'cx>(
|
||||
ecx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree],
|
||||
tts: TokenStream,
|
||||
) -> Box<dyn base::MacResult + 'cx> {
|
||||
expand_format_args_impl(ecx, sp, tts, true)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,12 +16,12 @@ use syntax::ext::base::{self, *};
|
|||
use syntax::parse::token;
|
||||
use syntax::ptr::P;
|
||||
use syntax_pos::Span;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
use smallvec::smallvec;
|
||||
|
||||
pub fn expand_global_asm<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree]) -> Box<dyn base::MacResult + 'cx> {
|
||||
tts: TokenStream) -> Box<dyn base::MacResult + 'cx> {
|
||||
match parse_global_asm(cx, sp, tts) {
|
||||
Ok(Some(global_asm)) => {
|
||||
MacEager::items(smallvec![P(ast::Item {
|
||||
|
|
@ -45,7 +45,7 @@ pub fn expand_global_asm<'cx>(cx: &'cx mut ExtCtxt<'_>,
|
|||
fn parse_global_asm<'a>(
|
||||
cx: &mut ExtCtxt<'a>,
|
||||
sp: Span,
|
||||
tts: &[tokenstream::TokenTree]
|
||||
tts: TokenStream
|
||||
) -> Result<Option<ast::GlobalAsm>, DiagnosticBuilder<'a>> {
|
||||
let mut p = cx.new_parser_from_tts(tts);
|
||||
|
||||
|
|
|
|||
|
|
@ -67,8 +67,8 @@ pub fn register_builtin_macros(resolver: &mut dyn syntax::ext::base::Resolver, e
|
|||
cfg: cfg::expand_cfg,
|
||||
column: source_util::expand_column,
|
||||
compile_error: compile_error::expand_compile_error,
|
||||
concat_idents: concat_idents::expand_syntax_ext,
|
||||
concat: concat::expand_syntax_ext,
|
||||
concat_idents: concat_idents::expand_concat_idents,
|
||||
concat: concat::expand_concat,
|
||||
env: env::expand_env,
|
||||
file: source_util::expand_file,
|
||||
format_args_nl: format::expand_format_args_nl,
|
||||
|
|
@ -78,7 +78,7 @@ pub fn register_builtin_macros(resolver: &mut dyn syntax::ext::base::Resolver, e
|
|||
include_str: source_util::expand_include_str,
|
||||
include: source_util::expand_include,
|
||||
line: source_util::expand_line,
|
||||
log_syntax: log_syntax::expand_syntax_ext,
|
||||
log_syntax: log_syntax::expand_log_syntax,
|
||||
module_path: source_util::expand_mod,
|
||||
option_env: env::expand_option_env,
|
||||
stringify: source_util::expand_stringify,
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
use syntax::ext::base;
|
||||
use syntax::print;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
use syntax_pos;
|
||||
|
||||
pub fn expand_syntax_ext<'cx>(_cx: &'cx mut base::ExtCtxt<'_>,
|
||||
pub fn expand_log_syntax<'cx>(_cx: &'cx mut base::ExtCtxt<'_>,
|
||||
sp: syntax_pos::Span,
|
||||
tts: &[tokenstream::TokenTree])
|
||||
tts: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'cx> {
|
||||
println!("{}", print::pprust::tts_to_string(tts));
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ use syntax::parse::{self, token, DirectoryOwnership};
|
|||
use syntax::print::pprust;
|
||||
use syntax::ptr::P;
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax::tokenstream;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
|
||||
use smallvec::SmallVec;
|
||||
use syntax_pos::{self, Pos, Span};
|
||||
|
|
@ -16,7 +16,7 @@ use rustc_data_structures::sync::Lrc;
|
|||
// a given file into the current one.
|
||||
|
||||
/// line!(): expands to the current line number
|
||||
pub fn expand_line(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_line(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
base::check_zero_tts(cx, sp, tts, "line!");
|
||||
|
||||
|
|
@ -27,7 +27,7 @@ pub fn expand_line(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree
|
|||
}
|
||||
|
||||
/* column!(): expands to the current column number */
|
||||
pub fn expand_column(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_column(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
base::check_zero_tts(cx, sp, tts, "column!");
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ pub fn expand_column(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTr
|
|||
/// file!(): expands to the current filename */
|
||||
/// The source_file (`loc.file`) contains a bunch more information we could spit
|
||||
/// out if we wanted.
|
||||
pub fn expand_file(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_file(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
base::check_zero_tts(cx, sp, tts, "file!");
|
||||
|
||||
|
|
@ -49,13 +49,13 @@ pub fn expand_file(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree
|
|||
base::MacEager::expr(cx.expr_str(topmost, Symbol::intern(&loc.file.name.to_string())))
|
||||
}
|
||||
|
||||
pub fn expand_stringify(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_stringify(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
let s = pprust::tts_to_string(tts);
|
||||
base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&s)))
|
||||
}
|
||||
|
||||
pub fn expand_mod(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_mod(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
base::check_zero_tts(cx, sp, tts, "module_path!");
|
||||
let mod_path = &cx.current_expansion.module.mod_path;
|
||||
|
|
@ -67,7 +67,7 @@ pub fn expand_mod(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]
|
|||
/// include! : parse the given file as an expr
|
||||
/// This is generally a bad idea because it's going to behave
|
||||
/// unhygienically.
|
||||
pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'cx> {
|
||||
let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
|
||||
Some(f) => f,
|
||||
|
|
@ -105,7 +105,7 @@ pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstrea
|
|||
}
|
||||
|
||||
// include_str! : read the given file, insert it as a literal string expr
|
||||
pub fn expand_include_str(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_include_str(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
|
||||
Some(f) => f,
|
||||
|
|
@ -130,7 +130,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::To
|
|||
}
|
||||
}
|
||||
|
||||
pub fn expand_include_bytes(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
pub fn expand_include_bytes(cx: &mut ExtCtxt<'_>, sp: Span, tts: TokenStream)
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
let file = match get_single_str_from_tts(cx, sp, tts, "include_bytes!") {
|
||||
Some(f) => f,
|
||||
|
|
|
|||
|
|
@ -1,20 +1,27 @@
|
|||
use syntax::ext::base::{self, ExtCtxt};
|
||||
use syntax::symbol::kw;
|
||||
use syntax_pos::Span;
|
||||
use syntax::tokenstream::TokenTree;
|
||||
use syntax::tokenstream::{TokenTree, TokenStream};
|
||||
|
||||
pub fn expand_trace_macros(cx: &mut ExtCtxt<'_>,
|
||||
sp: Span,
|
||||
tt: &[TokenTree])
|
||||
tt: TokenStream)
|
||||
-> Box<dyn base::MacResult + 'static> {
|
||||
match tt {
|
||||
[TokenTree::Token(token)] if token.is_keyword(kw::True) => {
|
||||
cx.set_trace_macros(true);
|
||||
}
|
||||
[TokenTree::Token(token)] if token.is_keyword(kw::False) => {
|
||||
cx.set_trace_macros(false);
|
||||
}
|
||||
_ => cx.span_err(sp, "trace_macros! accepts only `true` or `false`"),
|
||||
let mut cursor = tt.into_trees();
|
||||
let mut err = false;
|
||||
let value = match &cursor.next() {
|
||||
Some(TokenTree::Token(token)) if token.is_keyword(kw::True) => true,
|
||||
Some(TokenTree::Token(token)) if token.is_keyword(kw::False) => false,
|
||||
_ => {
|
||||
err = true;
|
||||
false
|
||||
},
|
||||
};
|
||||
err |= cursor.next().is_some();
|
||||
if err {
|
||||
cx.span_err(sp, "trace_macros! accepts only `true` or `false`")
|
||||
} else {
|
||||
cx.set_trace_macros(value);
|
||||
}
|
||||
|
||||
base::DummyResult::any_valid(sp)
|
||||
|
|
|
|||
20
src/test/rustdoc/auxiliary/through-proc-macro-aux.rs
Normal file
20
src/test/rustdoc/auxiliary/through-proc-macro-aux.rs
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
// force-host
|
||||
// no-prefer-dynamic
|
||||
#![crate_type = "proc-macro"]
|
||||
#![crate_name="some_macros"]
|
||||
|
||||
extern crate proc_macro;
|
||||
use proc_macro::TokenStream;
|
||||
|
||||
#[proc_macro_attribute]
|
||||
pub fn first(_attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
item // This doesn't erase the spans.
|
||||
}
|
||||
|
||||
#[proc_macro_attribute]
|
||||
pub fn second(_attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
// Make a new `TokenStream` to erase the spans:
|
||||
let mut out: TokenStream = TokenStream::new();
|
||||
out.extend(item);
|
||||
out
|
||||
}
|
||||
12
src/test/rustdoc/through-proc-macro.rs
Normal file
12
src/test/rustdoc/through-proc-macro.rs
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
// aux-build:through-proc-macro-aux.rs
|
||||
// build-aux-docs
|
||||
#![warn(intra_doc_link_resolution_failure)]
|
||||
extern crate some_macros;
|
||||
|
||||
#[some_macros::second]
|
||||
pub enum Boom {
|
||||
/// [Oooops]
|
||||
Bam,
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
@ -15,12 +15,12 @@ extern crate rustc;
|
|||
extern crate rustc_driver;
|
||||
|
||||
use syntax::parse::token::{self, Token};
|
||||
use syntax::tokenstream::TokenTree;
|
||||
use syntax::tokenstream::{TokenTree, TokenStream};
|
||||
use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
|
||||
use syntax_pos::Span;
|
||||
use rustc_driver::plugin::Registry;
|
||||
|
||||
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
|
||||
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: TokenStream)
|
||||
-> Box<dyn MacResult + 'static> {
|
||||
|
||||
static NUMERALS: &'static [(&'static str, usize)] = &[
|
||||
|
|
@ -36,7 +36,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
|
|||
return DummyResult::any(sp);
|
||||
}
|
||||
|
||||
let text = match args[0] {
|
||||
let text = match args.into_trees().next().unwrap() {
|
||||
TokenTree::Token(Token { kind: token::Ident(s, _), .. }) => s.to_string(),
|
||||
_ => {
|
||||
cx.span_err(sp, "argument should be a single identifier");
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
#![feature(rustc_attrs)]
|
||||
#![allow(exceeding_bitshifts)]
|
||||
|
||||
#![deny(const_err)]
|
||||
|
||||
fn black_box<T>(_: T) {
|
||||
|
|
@ -21,7 +22,7 @@ fn main() {
|
|||
let d = 42u8 - (42u8 + 1);
|
||||
//~^ ERROR const_err
|
||||
let _e = [5u8][1];
|
||||
//~^ ERROR const_err
|
||||
//~^ ERROR index out of bounds
|
||||
black_box(a);
|
||||
black_box(b);
|
||||
black_box(c);
|
||||
|
|
|
|||
|
|
@ -1,35 +1,35 @@
|
|||
error: this expression will panic at runtime
|
||||
--> $DIR/const-err2.rs:15:13
|
||||
--> $DIR/const-err2.rs:16:13
|
||||
|
|
||||
LL | let a = -std::i8::MIN;
|
||||
| ^^^^^^^^^^^^^ attempt to negate with overflow
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/const-err2.rs:8:9
|
||||
--> $DIR/const-err2.rs:9:9
|
||||
|
|
||||
LL | #![deny(const_err)]
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/const-err2.rs:17:13
|
||||
--> $DIR/const-err2.rs:18:13
|
||||
|
|
||||
LL | let b = 200u8 + 200u8 + 200u8;
|
||||
| ^^^^^^^^^^^^^ attempt to add with overflow
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/const-err2.rs:19:13
|
||||
--> $DIR/const-err2.rs:20:13
|
||||
|
|
||||
LL | let c = 200u8 * 4;
|
||||
| ^^^^^^^^^ attempt to multiply with overflow
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/const-err2.rs:21:13
|
||||
--> $DIR/const-err2.rs:22:13
|
||||
|
|
||||
LL | let d = 42u8 - (42u8 + 1);
|
||||
| ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
|
||||
|
||||
error: index out of bounds: the len is 1 but the index is 1
|
||||
--> $DIR/const-err2.rs:23:14
|
||||
--> $DIR/const-err2.rs:24:14
|
||||
|
|
||||
LL | let _e = [5u8][1];
|
||||
| ^^^^^^^^
|
||||
|
|
|
|||
30
src/test/ui/consts/const-err3.rs
Normal file
30
src/test/ui/consts/const-err3.rs
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
// needed because negating int::MIN will behave differently between
|
||||
// optimized compilation and unoptimized compilation and thus would
|
||||
// lead to different lints being emitted
|
||||
// compile-flags: -C overflow-checks=on -O
|
||||
|
||||
#![feature(rustc_attrs)]
|
||||
#![allow(exceeding_bitshifts)]
|
||||
|
||||
#![deny(const_err)]
|
||||
|
||||
fn black_box<T>(_: T) {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let a = -std::i8::MIN;
|
||||
//~^ ERROR const_err
|
||||
let b = 200u8 + 200u8 + 200u8;
|
||||
//~^ ERROR const_err
|
||||
let c = 200u8 * 4;
|
||||
//~^ ERROR const_err
|
||||
let d = 42u8 - (42u8 + 1);
|
||||
//~^ ERROR const_err
|
||||
let _e = [5u8][1];
|
||||
//~^ ERROR const_err
|
||||
black_box(a);
|
||||
black_box(b);
|
||||
black_box(c);
|
||||
black_box(d);
|
||||
}
|
||||
38
src/test/ui/consts/const-err3.stderr
Normal file
38
src/test/ui/consts/const-err3.stderr
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
error: attempt to negate with overflow
|
||||
--> $DIR/const-err3.rs:16:13
|
||||
|
|
||||
LL | let a = -std::i8::MIN;
|
||||
| ^^^^^^^^^^^^^
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/const-err3.rs:9:9
|
||||
|
|
||||
LL | #![deny(const_err)]
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: attempt to add with overflow
|
||||
--> $DIR/const-err3.rs:18:13
|
||||
|
|
||||
LL | let b = 200u8 + 200u8 + 200u8;
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to multiply with overflow
|
||||
--> $DIR/const-err3.rs:20:13
|
||||
|
|
||||
LL | let c = 200u8 * 4;
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: attempt to subtract with overflow
|
||||
--> $DIR/const-err3.rs:22:13
|
||||
|
|
||||
LL | let d = 42u8 - (42u8 + 1);
|
||||
| ^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: index out of bounds: the len is 1 but the index is 1
|
||||
--> $DIR/const-err3.rs:24:14
|
||||
|
|
||||
LL | let _e = [5u8][1];
|
||||
| ^^^^^^^^
|
||||
|
||||
error: aborting due to 5 previous errors
|
||||
|
||||
|
|
@ -5,7 +5,7 @@
|
|||
fn main() {
|
||||
println!("{}", 0u32 - 1);
|
||||
let _x = 0u32 - 1;
|
||||
//~^ ERROR this expression will panic at runtime [const_err]
|
||||
//~^ ERROR const_err
|
||||
println!("{}", 1/(1-1));
|
||||
//~^ ERROR attempt to divide by zero [const_err]
|
||||
//~| ERROR reaching this expression at runtime will panic or abort [const_err]
|
||||
|
|
|
|||
22
src/test/ui/consts/const-eval/promoted_errors2.rs
Normal file
22
src/test/ui/consts/const-eval/promoted_errors2.rs
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
// compile-flags: -C overflow-checks=on -O
|
||||
|
||||
#![deny(const_err)]
|
||||
|
||||
fn main() {
|
||||
println!("{}", 0u32 - 1);
|
||||
//~^ ERROR attempt to subtract with overflow
|
||||
let _x = 0u32 - 1;
|
||||
//~^ ERROR attempt to subtract with overflow
|
||||
println!("{}", 1/(1-1));
|
||||
//~^ ERROR attempt to divide by zero [const_err]
|
||||
//~| ERROR reaching this expression at runtime will panic or abort [const_err]
|
||||
let _x = 1/(1-1);
|
||||
//~^ ERROR const_err
|
||||
//~| ERROR const_err
|
||||
println!("{}", 1/(false as u32));
|
||||
//~^ ERROR attempt to divide by zero [const_err]
|
||||
//~| ERROR reaching this expression at runtime will panic or abort [const_err]
|
||||
let _x = 1/(false as u32);
|
||||
//~^ ERROR const_err
|
||||
//~| ERROR const_err
|
||||
}
|
||||
68
src/test/ui/consts/const-eval/promoted_errors2.stderr
Normal file
68
src/test/ui/consts/const-eval/promoted_errors2.stderr
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
error: attempt to subtract with overflow
|
||||
--> $DIR/promoted_errors2.rs:6:20
|
||||
|
|
||||
LL | println!("{}", 0u32 - 1);
|
||||
| ^^^^^^^^
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/promoted_errors2.rs:3:9
|
||||
|
|
||||
LL | #![deny(const_err)]
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: attempt to subtract with overflow
|
||||
--> $DIR/promoted_errors2.rs:8:14
|
||||
|
|
||||
LL | let _x = 0u32 - 1;
|
||||
| ^^^^^^^^
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/promoted_errors2.rs:10:20
|
||||
|
|
||||
LL | println!("{}", 1/(1-1));
|
||||
| ^^^^^^^
|
||||
|
||||
error: reaching this expression at runtime will panic or abort
|
||||
--> $DIR/promoted_errors2.rs:10:20
|
||||
|
|
||||
LL | println!("{}", 1/(1-1));
|
||||
| ^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/promoted_errors2.rs:13:14
|
||||
|
|
||||
LL | let _x = 1/(1-1);
|
||||
| ^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/promoted_errors2.rs:13:14
|
||||
|
|
||||
LL | let _x = 1/(1-1);
|
||||
| ^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/promoted_errors2.rs:16:20
|
||||
|
|
||||
LL | println!("{}", 1/(false as u32));
|
||||
| ^^^^^^^^^^^^^^^^
|
||||
|
||||
error: reaching this expression at runtime will panic or abort
|
||||
--> $DIR/promoted_errors2.rs:16:20
|
||||
|
|
||||
LL | println!("{}", 1/(false as u32));
|
||||
| ^^^^^^^^^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/promoted_errors2.rs:19:14
|
||||
|
|
||||
LL | let _x = 1/(false as u32);
|
||||
| ^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/promoted_errors2.rs:19:14
|
||||
|
|
||||
LL | let _x = 1/(false as u32);
|
||||
| ^^^^^^^^^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: aborting due to 10 previous errors
|
||||
|
||||
6
src/test/ui/consts/issue-64059-2.rs
Normal file
6
src/test/ui/consts/issue-64059-2.rs
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
// compile-flags: -C overflow-checks=on -O
|
||||
// run-pass
|
||||
|
||||
fn main() {
|
||||
let _ = -(-0.0);
|
||||
}
|
||||
5
src/test/ui/consts/issue-64059.rs
Normal file
5
src/test/ui/consts/issue-64059.rs
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
// run-pass
|
||||
|
||||
fn main() {
|
||||
let _ = -(-0.0);
|
||||
}
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
// compile-flags: -O
|
||||
|
||||
#![deny(const_err)]
|
||||
|
||||
use std::{isize, i8, i16, i32, i64};
|
||||
|
|
|
|||
|
|
@ -1,245 +1,245 @@
|
|||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const.rs:7:36
|
||||
--> $DIR/issue-8460-const.rs:9:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/issue-8460-const.rs:1:9
|
||||
--> $DIR/issue-8460-const.rs:3:9
|
||||
|
|
||||
LL | #![deny(const_err)]
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:7:36
|
||||
--> $DIR/issue-8460-const.rs:9:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^ attempt to divide with overflow
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const.rs:10:36
|
||||
--> $DIR/issue-8460-const.rs:12:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:10:36
|
||||
--> $DIR/issue-8460-const.rs:12:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^ attempt to divide with overflow
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const.rs:13:36
|
||||
--> $DIR/issue-8460-const.rs:15:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:13:36
|
||||
--> $DIR/issue-8460-const.rs:15:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to divide with overflow
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const.rs:16:36
|
||||
--> $DIR/issue-8460-const.rs:18:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:16:36
|
||||
--> $DIR/issue-8460-const.rs:18:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to divide with overflow
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const.rs:19:36
|
||||
--> $DIR/issue-8460-const.rs:21:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:19:36
|
||||
--> $DIR/issue-8460-const.rs:21:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to divide with overflow
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const.rs:22:36
|
||||
--> $DIR/issue-8460-const.rs:24:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:22:36
|
||||
--> $DIR/issue-8460-const.rs:24:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
|
||||
| ^^^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const.rs:25:36
|
||||
--> $DIR/issue-8460-const.rs:27:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
|
||||
| ^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:25:36
|
||||
--> $DIR/issue-8460-const.rs:27:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
|
||||
| ^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const.rs:28:36
|
||||
--> $DIR/issue-8460-const.rs:30:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:28:36
|
||||
--> $DIR/issue-8460-const.rs:30:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const.rs:31:36
|
||||
--> $DIR/issue-8460-const.rs:33:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:31:36
|
||||
--> $DIR/issue-8460-const.rs:33:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const.rs:34:36
|
||||
--> $DIR/issue-8460-const.rs:36:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:34:36
|
||||
--> $DIR/issue-8460-const.rs:36:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const.rs:37:36
|
||||
--> $DIR/issue-8460-const.rs:39:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:37:36
|
||||
--> $DIR/issue-8460-const.rs:39:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const.rs:40:36
|
||||
--> $DIR/issue-8460-const.rs:42:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:40:36
|
||||
--> $DIR/issue-8460-const.rs:42:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const.rs:43:36
|
||||
--> $DIR/issue-8460-const.rs:45:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:43:36
|
||||
--> $DIR/issue-8460-const.rs:45:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const.rs:46:36
|
||||
--> $DIR/issue-8460-const.rs:48:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:46:36
|
||||
--> $DIR/issue-8460-const.rs:48:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const.rs:49:36
|
||||
--> $DIR/issue-8460-const.rs:51:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:49:36
|
||||
--> $DIR/issue-8460-const.rs:51:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const.rs:52:36
|
||||
--> $DIR/issue-8460-const.rs:54:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:52:36
|
||||
--> $DIR/issue-8460-const.rs:54:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
|
||||
| ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const.rs:55:36
|
||||
--> $DIR/issue-8460-const.rs:57:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
|
||||
| ^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:55:36
|
||||
--> $DIR/issue-8460-const.rs:57:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
|
||||
| ^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const.rs:58:36
|
||||
--> $DIR/issue-8460-const.rs:60:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:58:36
|
||||
--> $DIR/issue-8460-const.rs:60:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const.rs:61:36
|
||||
--> $DIR/issue-8460-const.rs:63:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:61:36
|
||||
--> $DIR/issue-8460-const.rs:63:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const.rs:64:36
|
||||
--> $DIR/issue-8460-const.rs:66:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const.rs:64:36
|
||||
--> $DIR/issue-8460-const.rs:66:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
|
|
|||
59
src/test/ui/issues/issue-8460-const2.rs
Normal file
59
src/test/ui/issues/issue-8460-const2.rs
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
// compile-flags: -C overflow-checks=on -O
|
||||
|
||||
#![deny(const_err)]
|
||||
|
||||
use std::{isize, i8, i16, i32, i64};
|
||||
use std::thread;
|
||||
|
||||
fn main() {
|
||||
assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
|
||||
//~^ ERROR attempt to divide with overflow
|
||||
assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
|
||||
//~^ ERROR attempt to divide with overflow
|
||||
assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
|
||||
//~^ ERROR attempt to divide with overflow
|
||||
assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
|
||||
//~^ ERROR attempt to divide with overflow
|
||||
assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
|
||||
//~^ ERROR attempt to divide with overflow
|
||||
assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
|
||||
//~^ ERROR attempt to divide by zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
|
||||
//~^ ERROR attempt to divide by zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
|
||||
//~^ ERROR attempt to divide by zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
|
||||
//~^ ERROR attempt to divide by zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
|
||||
//~^ ERROR attempt to divide by zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with overflow
|
||||
assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with overflow
|
||||
assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with overflow
|
||||
assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with overflow
|
||||
assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with overflow
|
||||
assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with a divisor of zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with a divisor of zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with a divisor of zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with a divisor of zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
|
||||
//~^ ERROR attempt to calculate the remainder with a divisor of zero
|
||||
//~| ERROR this expression will panic at runtime
|
||||
}
|
||||
188
src/test/ui/issues/issue-8460-const2.stderr
Normal file
188
src/test/ui/issues/issue-8460-const2.stderr
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const2.rs:9:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/issue-8460-const2.rs:3:9
|
||||
|
|
||||
LL | #![deny(const_err)]
|
||||
| ^^^^^^^^^
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const2.rs:11:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const2.rs:13:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const2.rs:15:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to divide with overflow
|
||||
--> $DIR/issue-8460-const2.rs:17:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const2.rs:19:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:19:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
|
||||
| ^^^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const2.rs:22:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
|
||||
| ^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:22:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
|
||||
| ^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const2.rs:25:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:25:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const2.rs:28:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:28:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to divide by zero
|
||||
--> $DIR/issue-8460-const2.rs:31:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:31:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to divide by zero
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const2.rs:34:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const2.rs:36:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const2.rs:38:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const2.rs:40:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to calculate the remainder with overflow
|
||||
--> $DIR/issue-8460-const2.rs:42:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
|
||||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const2.rs:44:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:44:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
|
||||
| ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const2.rs:47:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
|
||||
| ^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:47:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
|
||||
| ^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const2.rs:50:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:50:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const2.rs:53:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:53:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: attempt to calculate the remainder with a divisor of zero
|
||||
--> $DIR/issue-8460-const2.rs:56:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
|
||||
| ^^^^^^^^
|
||||
|
||||
error: this expression will panic at runtime
|
||||
--> $DIR/issue-8460-const2.rs:56:36
|
||||
|
|
||||
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
|
||||
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
|
||||
|
||||
error: aborting due to 30 previous errors
|
||||
|
||||
|
|
@ -17,10 +17,10 @@ fn bar() -> impl std::fmt::Display {
|
|||
|
||||
fn baz() -> impl std::fmt::Display {
|
||||
if false {
|
||||
//~^ ERROR mismatched types
|
||||
return 0i32;
|
||||
} else {
|
||||
1u32
|
||||
//~^ ERROR mismatched types
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -33,4 +33,33 @@ fn qux() -> impl std::fmt::Display {
|
|||
}
|
||||
}
|
||||
|
||||
fn bat() -> impl std::fmt::Display {
|
||||
match 13 {
|
||||
0 => return 0i32,
|
||||
_ => 1u32,
|
||||
//~^ ERROR mismatched types
|
||||
}
|
||||
}
|
||||
|
||||
fn can() -> impl std::fmt::Display {
|
||||
match 13 {
|
||||
//~^ ERROR mismatched types
|
||||
0 => return 0i32,
|
||||
1 => 1u32,
|
||||
_ => 2u32,
|
||||
}
|
||||
}
|
||||
|
||||
fn cat() -> impl std::fmt::Display {
|
||||
match 13 {
|
||||
0 => {
|
||||
return 0i32;
|
||||
}
|
||||
_ => {
|
||||
1u32
|
||||
//~^ ERROR mismatched types
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -29,18 +29,16 @@ LL | return 1u32;
|
|||
found type `u32`
|
||||
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:19:5
|
||||
--> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:22:9
|
||||
|
|
||||
LL | fn baz() -> impl std::fmt::Display {
|
||||
| ---------------------- expected because this return type...
|
||||
LL | / if false {
|
||||
LL | |
|
||||
LL | | return 0i32;
|
||||
| | ---- ...is found to be `i32` here
|
||||
LL | | } else {
|
||||
LL | | 1u32
|
||||
LL | | }
|
||||
| |_____^ expected i32, found u32
|
||||
LL | fn baz() -> impl std::fmt::Display {
|
||||
| ---------------------- expected because this return type...
|
||||
LL | if false {
|
||||
LL | return 0i32;
|
||||
| ---- ...is found to be `i32` here
|
||||
LL | } else {
|
||||
LL | 1u32
|
||||
| ^^^^ expected i32, found u32
|
||||
|
|
||||
= note: expected type `i32`
|
||||
found type `u32`
|
||||
|
|
@ -61,6 +59,52 @@ LL | | }
|
|||
= note: expected type `i32`
|
||||
found type `u32`
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:39:14
|
||||
|
|
||||
LL | fn bat() -> impl std::fmt::Display {
|
||||
| ---------------------- expected because this return type...
|
||||
LL | match 13 {
|
||||
LL | 0 => return 0i32,
|
||||
| ---- ...is found to be `i32` here
|
||||
LL | _ => 1u32,
|
||||
| ^^^^ expected i32, found u32
|
||||
|
|
||||
= note: expected type `i32`
|
||||
found type `u32`
|
||||
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:45:5
|
||||
|
|
||||
LL | fn can() -> impl std::fmt::Display {
|
||||
| ---------------------- expected because this return type...
|
||||
LL | / match 13 {
|
||||
LL | |
|
||||
LL | | 0 => return 0i32,
|
||||
| | ---- ...is found to be `i32` here
|
||||
LL | | 1 => 1u32,
|
||||
LL | | _ => 2u32,
|
||||
LL | | }
|
||||
| |_____^ expected i32, found u32
|
||||
|
|
||||
= note: expected type `i32`
|
||||
found type `u32`
|
||||
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/point-to-type-err-cause-on-impl-trait-return.rs:59:13
|
||||
|
|
||||
LL | fn cat() -> impl std::fmt::Display {
|
||||
| ---------------------- expected because this return type...
|
||||
...
|
||||
LL | return 0i32;
|
||||
| ---- ...is found to be `i32` here
|
||||
...
|
||||
LL | 1u32
|
||||
| ^^^^ expected i32, found u32
|
||||
|
|
||||
= note: expected type `i32`
|
||||
found type `u32`
|
||||
|
||||
error: aborting due to 7 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0308`.
|
||||
|
|
|
|||
|
|
@ -10,8 +10,8 @@ LL | | thing_two()
|
|||
LL | | }.await
|
||||
| |_____- if and else have incompatible types
|
||||
|
|
||||
= note: expected type `impl std::future::Future` (opaque type)
|
||||
found type `impl std::future::Future` (opaque type)
|
||||
= note: expected type `impl std::future::Future` (opaque type at <$DIR/opaque-type-error.rs:8:19>)
|
||||
found type `impl std::future::Future` (opaque type at <$DIR/opaque-type-error.rs:12:19>)
|
||||
= note: distinct uses of `impl Trait` result in different opaque types
|
||||
= help: if both `Future`s have the same `Output` type, consider `.await`ing on both of them
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue