mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ca9faa52f5
rust/src/test/run-pass/lexer-crlf-line-endings-string-literal-doc-comment.rs

42 lines
1.0 KiB
Rust
Raw Normal View History

tests: Add missing run-pass annotations
2019-07-26 16:54:25 -05:00
// run-pass
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
// ignore-tidy-cr ignore-license
// ignore-tidy-cr (repeated again because of tidy bug)
// license is ignored because tidy can't handle the CRLF here properly.
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
// http://rust-lang.org/COPYRIGHT.
//
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Various minor/cosmetic improvements to code
2018-11-26 20:59:49 -06:00
// N.B., this file needs CRLF line endings. The .gitattributes file in
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
// this directory should enforce it.
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Fix some pretty printing tests
2016-10-12 12:54:41 -05:00
// ignore-pretty issue #37195
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
/// Doc comment that ends in CRLF
pub fn foo() {}
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
/** Block doc comment that
* contains CRLF characters
*/
pub fn bar() {}
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
fn main() {
let s = "string
literal";
assert_eq!(s, "string\nliteral");
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
let s = "literal with \
escaped newline";
assert_eq!(s, "literal with escaped newline");
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
let s = r"string
literal";
assert_eq!(s, "string\nliteral");
Add test for raw byte CRLF translation
2019-06-09 07:15:31 -05:00
let s = br"byte string
literal";
assert_eq!(s, "byte string\nliteral".as_bytes());
Restore line endings in a test In #28864, @aarzee submitted some whitespace fixes. I r+'d it. But @retp998 noticed[1] that this file is explicitly a test of this kind of whitespace, and so I shouldn't have changed it. This restores the old line endings. 1: https://github.com/rust-lang/rust/pull/28864#discussion_r41332279
2015-10-06 20:59:49 -05:00
Handle CRLF properly in the lexer The lexer already ignores CRLF in between tokens, but it doesn't properly handle carriage returns inside strings and doc comments. Teach it to treat CRLF as LF inside these tokens, and to disallow carriage returns that are not followed by linefeeds. This includes handling an escaped CRLF inside a regular string token the same way it handles an escaped LF. This is technically a breaking change, as bare carriage returns are no longer allowed, and CRLF sequences are now treated as LF inside strings and doc comments, but it's very unlikely to actually affect any real-world code. This change is necessary to have Rust code compile on Windows the same way it does on Unix. The mozilla/rust repository explicitly sets eol=lf for Rust source files, but other Rust repositories don't. Notably, rust-http cannot be compiled on Windows without converting the CRLF line endings back to LF. [breaking-change]
2014-05-24 03:13:59 -05:00
// validate that our source file has CRLF endings
let source = include_str!("lexer-crlf-line-endings-string-literal-doc-comment.rs");
assert!(source.contains("string\r\nliteral"));
}
Reference in New Issue Copy Permalink