this allows fonts like Fira Code and Monoid to render all rust operators with a ligature.

“=>” is an operator used in matching, so it makes sense to include it

In rust 1.27 a new "dyn" keyword was introduced: https://blog.rust-lang.org/2018/06/21/Rust-1.27.html#dyn-trait This keyword is used in similar places as the mut keyword.

From @D101101 on January 20, 2016 17:1

Syntax highlighting for Rust works well, but in some places it is clearly not completed yet.

Copied from original issue: Microsoft/vscode#2130

Maintainers of Visual Studio Code asked me to open this PR. The PR in Visual Studio Code's repository: https://github.com/Microsoft/vscode/pull/19574

It fixes the case:

#[
//
/* */
derive(Debug)]
struct D {}

Rust has recently changed the integer type shorthand e.g 10i => 10is 10u => 10us

See https://github.com/rust-lang/rfcs/pull/544#issuecomment-68760871

Currently running rustfmt on a project produces a number of back up files *.rs.bk, which are your old rust files - rustfmt saves a cleaned up version to where the files were previously. I think it's a good idea to include rs.bk files into this grammar because it is still rust code.

Is that possible to do in the grammar file itself?

Depending on the regular expression engine used, \h does not always mean the same. With a PCRE engine, it matches white spaces, whereas, with a Oniguruma engine, it matches hexademical digit characters. Atom uses an Oniguruma engine, but github.com relies on a PCRE engine.

The construction {,n} in regular expressions is only supported by Oniguruma (which is used by TextMate). This TextMate bundle is used to highlight Rust code on github.com. However, github.com is using a PCRE-based engine for regexes.

This pull request fixes that by using explicit count modifiers.

The following error message is returned: Unable to download https://www.atom.io/api/packages/language-rust/versions/0.4.7/tarball: 404

I tried to install the package from the terminal and atom itself. Both fail.

I'm not sure if this has any impact on this plugin, but just in case - we're currently discussing making the switch to the new error format. If you're parsing the errors for the user, this may impact you.

This change will also enable a json mode, if you want something more structured to parse.

Could you please publish the rust module to npm? We are using the same highlighting engine as Atom now, and would love to add your grammar:

https://www.npmjs.com/package/polyglot-readme

It appears that the contents of the char literal are incorrectly interpreted as a lifetime specifier with a spurious single quote on the end rather than a reference to a char.

From @ExoticMatter in https://github.com/microsoft/vscode/issues/95782

VSCode Version: 1.44.2

When raw string literals that use ##s appear in attributes in a Rust file, syntax highlighting breaks.

Steps to Reproduce:

1. Copy the following code into a Rust source file:

#[cfg(feature = r#"""#)]
const _: () = ();

You will get something similar to the following:

Does this issue occur when all extensions are disabled?: Yes

Updates reserved keywords. Most are removals. For instance, proc was removed here

List: https://doc.rust-lang.org/reference/keywords.html#reserved-keywords

Proof: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=16ceeadb190d1804eab3cf5e8439c1bc (keywords are outdated at the playground as well, but the point is it compiles)

Now that Rust 1.39.0 supports attributes on parameters, the grammar should be updated to allow attributes when parsing function definitions.

Example:

#[attr(foo = "bar")]
fn foo(#[attr(foo = "bar")] p: u32) {
    println!("hi");
}

Notice that "bar" is not highlighted as a string, which is an included pattern in the attribute grammar.

Additionally, parsing breaks when the attribute string has characters that are interpreted as Rust tokens:

#[attr(foo = "bar")]
fn foo(#[attr(foo = "{")] p: u32) {
  println!("hi");
}

Note that here { is being matched as the opening bracket of the function, causing the closing " to be matched as the start of a string (the remainder of the function is considered to be in the string).

From @rustka in https://github.com/microsoft/vscode/issues/81085

Rust's syntax highlighting breaks after using impl keyword as a raw identifier.

• VSCode version: 1.38.1
• OS version: Linux x64

Steps to reproduce:

1. Open the editor;
2. Set language mode to Rust;
3. Paste the following code:

use r#impl;
fn main() {}

4. Comment the first line by prefixing it with //; 4.1. This failure could also be prevented by replacing r#impl with r#impl {}, but this is not the real solution for that case.
5. The syntax highlighting works properly back again.

P.S.: I did test it on Atom editor (v1.40.1) and it seemed to work correctly.