Rust language support in Atom - LOOKING FOR MAINTAINER, see #144
License: MIT License
Adds syntax highlighting and snippets to Rust files in Atom.
Install the package language-rust in Atom (Preferences->Packages) or Atom's package manager from a shell:
$ apm install language-rustGrammar rules were written from scratch. They seem to work for most cases. However there are most certainly still a few cases that result in wrong syntax highlighting. Feel free to fix it and send a pull request, or open an issue to report it.
https://github.com/abaez/ta-rust/blob/master/snippets.lua
https://github.com/freebroccolo/rust-snippets/blob/master/rust-snippets.el
https://github.com/darookee/vim-snippets/blob/master/UltiSnips/rust.snippets
https://github.com/rust-lang/sublime-rust/tree/master/snippets
Maybe you can add the missing snippets from other editors and implement it in your project.
It's common to see type signatures like: Option<Box<Iterator<Item=u64>>>. It'd be helpful when a cursor is higlighted over one < or > to match its matching 'pointy bracket' like (, ), {, and } do.
This is explained best by example, where the pipe character | marks the cursor positions:
fn main() {
let gt_forty_two = (0..100)
.filter(|&x| x > 42)
.collect::<Vec<_>>();| // cursor starts here, pressing [⏎ enter]
| // this is where it ends up
| // this is where I expect it to end up, only one line above of course
println!("{:?}", gt_forty_two)
}After an expression (or unfinished statement) - so no ; at the end - the cursor aligning with the previous line is actually a good thing. Example: pressing ⏎ enter after the .filter(…) brings you to the same indentation level as the . in a new line, wonderful. But if it's a closed and finished statement, than this makes no sense.
I'm new to atom, so I don't know on which level this is handled. Is this an issue of this language package?
What I mean is that when we have a very long one liner:
try!(self.nodes.get(index).ok_or_else(|| "The index is out of bounds")).as_ref().ok_or_else(|| format!("The requested node {} is None", index))The standard convention is to spill it on several lines, but each one should be indented one more level:
try!(self.nodes.get(index)
.ok_or_else(|| "The index is out of bounds")).as_ref()
.ok_or_else(|| format!("The requested node {} is None", index))Currently it gets indented as:
try!(self.nodes.get(index)
.ok_or_else(|| "The index is out of bounds")).as_ref()
.ok_or_else(|| format!("The requested node {} is None", index))The left shift operator << prevents further syntax highlighting except the mut keyword.
I noticed this earlier today, but my regex skills are not up to solving it on my own:
For the first impl, the type should be identified (as it is when following struct). For the second, both type (MyObject) and trait (Clone) should be identified, and "for" should not be confused as the control structure keyword for.
Store package settings files in the settings/ directory instead of scoped-properties/
Package.loadSettings (/Applications/Atom.app/Contents/Resources/app.asar/src/package.js:584:9)
<unknown> (/Applications/Atom.app/Contents/Resources/app.asar/src/package.js:186:43)
Package.measure (/Applications/Atom.app/Contents/Resources/app.asar/src/package.js:165:15)
Package.load (/Applications/Atom.app/Contents/Resources/app.asar/src/package.js:179:12)
PackageManager.loadPackage (/Applications/Atom.app/Contents/Resources/app.asar/src/package-manager.js:372:14)
PackageManager.loadPackages (/Applications/Atom.app/Contents/Resources/app.asar/src/package-manager.js:336:14)
Edit: nvm, corrupt Atom
In Rust, we can have something like this,
Here, Foobar is another trait which is aliased along with a static lifetime. Shouldn't that 'static lifetime be colored?
I found interesting font Fira Code with ligatures, but I found that ligature for operator "=>" is not displayed correctly. So, I tried to fix this. I was getting correct ligature if I changed 'match' for operators section form this:
# Operators
{
'comment': 'Operator'
'name': 'keyword.operator.rust'
'match': '(\\+|-|/|\\*|=|<=|>=|\\^|&|\\||!|%|::|\\bas\\b|<<|>>|>|<)'
}to this (added |=>| ):
# Operators (Good)
{
'comment': 'Operator'
'name': 'keyword.operator.rust'
'match': '(\\+|-|/|\\*|=>|=|<=|>=|\\^|&|\\||!|%|::|\\bas\\b|<<|>>|>|<)'
}
| Correct | Incorrect |
|---|---|
 |
 |
So, is my fix correct?
(Sorry for my poor English)
It might be possible to utilize the markdown+atom plugin grammar into this rust+atom plugin.
A similar example to this would be CSS or JS syntax highlighting within HTML documents https://github.com/atom/language-html
While this looks fine on most fonts, this breaks fonts like FiraCode that use ligatures.
Example of incorrect display:
Correct display (manually merged through the inspector):
This issue is also present with == and != -- they're emitted as separate .operator spans and thus the ligature is prevented.
FWIW, -> is not treated as a token and is emitted as text, which causes it to display correctly.
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
let mut board: Vec<Vec> = Vec::new();
the second Vec won't be highlighted.
I tested this with different types and it seems that it only affects the std_types
Box|Option|Path|PathBuf|Result|String|Vec
When using fonts that support ligatures, the rust grammar breaks them as seen in the figure above. The ligature appear correctly only in the comment section. If i select Plain Text, the ligatures appear correctly in both cases.
This is an issue in other languages also (for example ruby), you can check the discussion in
tonsky/FiraCode#63
and the solution
atom/language-ruby#117
It should have an easy fix, by adding something like the following before the operators match
{
'match': '->|=>'
'name': 'keyword.operator.rust'
}
Not sure though if this is the best way to address the issue
In stylesheets/rust.less: Use the atom-text-editor tag instead of the editor class.
It seems that known types, (structs) are not being highlighted when used as a type in another struct:
In this example, I would expect the String of BString, Vec<Bencode> of BList and BTreeMap<BString, Bencode> of BDict to be highlighted, since they are all known types.
In the Bencode struct, BInt, BString, BList and BDict are also all known types and I would expect them to be highlighted but they're not.
It would be nice if types provided in the std crate were all able to be highlighted, such as Arc, Mutex, Rc, Sender, Receiver, etc...
It's especially helpful when declaring and passing variables that are something like, Arc<Mutex<Vec<String>>>
I'd be happy to submit a pull request with the stuff in there, but I didn't know if there was a reason, other than there are a vast number of them, that they were not included and wanted to check if such a pull request would be welcomed before doing it...
When a file has a struct declaration, followed by a function with the < operator in the body, syntax highlighting breaks. Here's the simplest example I could come up with:
And here's the raw program text:
struct Foo { x: i32 }
fn greater_than_five(n: i32) -> bool {
5 < n
}
// Highlighting is now broken :(
fn main() {
let foo = Foo { x: 6 };
let n : i32 = foo.x;
println!("is {} > 5? {}", n, greater_than_five(n));
}Also, a few things I noticed:
< operator fixes the problemu32, isize, etc) are still highlighted properly> later on kind of breaks everything even more (as seen above with the runaway string)For example in the Rust source code.
For example, in match statements where a comma follows, or in a closure where a paren-semicolon follows. Neither of those have correct indentation, as they both report one level more than they should. Moving the following characters onto their own line corrects the issue.
While typing it will work fine most of the time, but when pasting code with "Auto Indent on Paste" set to true it causes quite a few incorrect indents.
Below is an example of what happens: (Note the last brace ends the function, not the match statement.)
Edit: Hmm, it's a bit more complicated than that, it seems that sometimes (like in let bindings) it works fine, even if the ending brace has a semicolon after it. And sometimes it works fine in if statements, and other times it doesn't. The source I'm using to test is https://github.com/gfx-rs/gfx-rs/tree/master/examples/deferred
A line like this:
#[doc="Foo[]"]breaks syntax highlighting for everything coming out of it. It looks like the interior ] completes the attribute, and the next quote is interpreted as the opening quote for a string.
/**/ is valid block_comment but language-rust doesn't support it.
Right now regular multiline comments are continued just fine and when you hit return it will add the double forward slashes. Documentation comments, however, which use the tripple forward slashes are not continued. Rather it enters two forward slashes.
fn foo<'' // typing a single `'` produces a second `'` incorrectlyNot sure what triggers it, but here is an example -
Rust has recently changed the integer type shorthand
e.g
10i => 10is
10u => 10us
Everything after the first << loses its color.
Here, Option is a known type, and pub is a known keyword.
Edit: ::<> syntax is known has turbofish apparently.
Syntax example:
/* simplest example
// correct
func();
// not correct
func::<u8>();
*/
// working example
let result = "hello, world"
// correctly highlighted
.split(", ")
// not correctly highlighted
.collect::<Vec<_>>();
Explanation of problem: All functions and methods are highlighted a the same color (blue here), but adding :: (or anything else) before () will change the color back to default variable color (white).
syntax and macros are explained here.
format! // described above
write! // first argument is a &mut io::Write, the destination
writeln! // same as write but appends a newline
print! // the format string is printed to the standard output
println! // same as print but appends a newline
format_args! // described below.we could match all macro calls starting with format…, write…, and print…, so people can define their own, and maybe also the stuff from the log crate, i.e. log!, error!, warn!, debug!, info!, trace!
Atom Version: 1.8.0
System: Microsoft Windows 7 Enterprise
Thrown From: language-rust package, v0.4.6
Uncaught InvalidCharacterError: Failed to execute 'add' on 'DOMTokenList': The token provided ('icon-ion ion-hammer') contains HTML space characters, which are not valid in tokens.
At /C:/Users/Thomas/.atom/packages/tool-bar/lib/tool-bar-button-view.js:45
Error: Failed to execute 'add' on 'DOMTokenList': The token provided ('icon-ion ion-hammer') contains HTML space characters, which are not valid in tokens.
at Error (native)
at new ToolBarButtonView (C:/Users/Thomas/.atom/packages/tool-bar/lib/tool-bar-button-view.js:36:31)
at ToolBarManager.addButton (C:/Users/Thomas/.atom/packages/tool-bar/lib/tool-bar-manager.js:14:20)
at Object.module.exports.Tokamak.consumeToolBar (file:///C:/Users/Thomas/.atom/packages/tokamak/lib/tokamak.coffee:124:14)
at Provider.module.exports.Provider.provide (C:\Users\Thomas\AppData\Local\atom\app-1.8.0\resources\app.asar\node_modules\service-hub\lib\provider.js:30:52)
at C:\Users\Thomas\AppData\Local\atom\app-1.8.0\resources\app.asar\node_modules\service-hub\lib\service-hub.js:55:26
at doNTCallback0 (node.js:443:9)
at process._tickCallback (node.js:372:13)
-0:59.2.0 settings-view:open (atom-text-editor.editor.is-focused)
-0:53.1.0 core:confirm (atom-text-editor.editor.mini.is-focused)
-0:46.6.0 core:backspace (atom-text-editor.editor.mini.is-focused)
2x -0:46.1.0 core:confirm (atom-text-editor.editor.mini.is-focused)
5x -0:28.6.0 core:backspace (atom-text-editor.editor.mini.is-focused)
-0:24.8.0 core:confirm (atom-text-editor.editor.mini.is-focused)
{
"core": {
"disabledPackages": [
"atom-python-run",
"git-control"
]
}
}# User
language-rust, v0.4.6
linter, v1.11.14
linter-rust, v0.4.6
tokamak, v0.2.7
tool-bar, v1.0.0
# Dev
No dev packagesStore package style sheets in the styles/ directory instead of stylesheets/ in the language-rust package
Package.getStylesheetsPath (/Applications/Atom.app/Contents/Resources/app/src/package.js:448:9)
Package.getStylesheetPaths (/Applications/Atom.app/Contents/Resources/app/src/package.js:459:32)
This is where the syntax should be highlighting where but doesn't ( based on this: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md definition ). (in short they can appear besides impl, fn, trait, struct.)
impl Foo<A,B>
where ...
{ }
impl Foo<A,B> for C
where ...
{ }
impl Foo<A,B> for C
{
fn foo<A,B> -> C
where ...
{ }
}
fn foo<A,B> -> C
where ...
{ }
struct Foo<A,B>
where ...
{ }
trait Foo<A,B> : C
where ...
{ }
Ironically, currently where seems to highlight everywhere but in the only cases where it should be used.
Store package style sheets in the styles/ directory instead of stylesheets/ in the language-rust package Package.getStylesheetsPath c: Users Roland AppData Local atom app-0.189.0 resources app src package.js:448:9 Package.getStylesheetPaths c: Users Roland AppData Local atom app-0.189.0 resources app src package.js:459:32
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:
Would anyone be interested in this if its possible? Doc comments begin with /// and are generally much longer.
I'm partial towards making doc comments lighter and collapsible. Although collapsible may be difficult as they are single-line comments.
(from Deprecation Cop)
stylesheets\rust.less
Use the atom-text-editor tag instead of the editor class.
Style elements within text editors using the atom-text-editor::shadow selector or the .atom-text-editor.less file extension. If you want to target overlay elements, target them directly or as descendants of atom-overlay elements.
When creating a channel:
let (tx, rx): (Sender<Vec<u8>>, Receiver<Vec<u8>>) = channel();The brackets are not highlighted the same. Sender's are blank while the Receiver's get highlighted.
test.rb was just a quick hack to check syntax highlighting. We should create real grammar specs like Atom's built-in language-* packages (e.g. in language-ruby)
Hi,
if you have a semicolon anywhere in the type signature before the -> characters the arrow ligature will not appear.
This works:
fn function(a: u32) -> u32
This one is not:
fn function(a: [u32; 2]) -> u32
Would it be possible to enhance impl so that it includes the fn's from the trait your implementing? For instance consider this:
pub trait FooPrimitive {
fn read<R: Read>(cursor: &mut R) -> Self;
fn write(&self) -> Vec<u8>;
}
impl FooPrimitive for String{
fn read<R: Read>(cursor: &mut R) -> Self{
}
fn write(&self) -> Vec<u8>{
}
}
Now if i type impl and fill in FooPrimitive it would be nice if it copied these fn's automatically for me so I don't have to keep copy pasting them. :)
Example:
let value = r#" "
"#;Anything after this is now considered inside a string.
This will work fine however:
let value = r#" " "#;Whenever I save a file, I get this error pop up. I assume that the package is unable to find my installed cargo at /usr/local/bin/cargo for whatever reason. I can't see any settings in the package for setting a PATH, so I don't know where it's looking.
I often want to select a part of a variable name. Consider the variable name "line_index" with the cursor right before the 'l' ([cursor]line_index). In order to select "line", I currently need to move to the end of "line" (either by hitting the "right arrow" key four times or clicking it with the mouse shudders) and hit control+shift+left to select to the beginning of the word. Adding '_' to the 'Non Word Characters' list in the package settings allows me to select "line" by hitting ctrl+shift+right. This emulates Sublime Text's alt+shift+right behavior.
Perhaps a too complex example, but at least it is actually a 'real world' use case.
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.