When I hit { and then enter, the next line should be indented.

I tested the module parser with this file: https://github.com/PistonDevelopers/image/blob/master/src/lib.rs and it returned no referenced modules. I think it's confused by the pub use statements.

Autocompletion icons we currently use are kinda shabby. It would be nice to have something nicer.

On the VS Gallery page as well as the GitHub Readme, please include screenshots so people can see what it looks like. I've found that people don't download extensions when they don't at least have a visual indication of what to expect.

Many smart operations (and not only smart, e. g. #11) within true IDE (not text editor with macroses) requare knowledge about AST.

Is there any plans for realizing rust AST?

Good open source example of AST is Roslyn (https://roslyn.codeplex.com/)

... and add option for choosing location of racer and rust source.
This is an intermittent solution for 0.1 until #67 is done.

We moved from .vsix to .msi (#24). This is an improvement, but the current solution installer script is not the greatest. When running .msi installer, as one of the actions, we find VsixInstaller.exe (part of VS) and run it on unpacked VisualRust.vsix. There are few bugs and deficiencies related to this:

• VisualRust.vsix is left lying in Program Files/VisualRust
• User can uninstall extension from "Extensions and Updates" window without going through installer
  The above can be solved by going though immense fun of "manually" (using normal WIX means) installing and uninstalling vs packages and templates and marking vsix with InstalledByMsi="true".

Also, two small problems:

• Wrong License is being displayed
• No version choice in the installer (though that touches #21)

Should be fairly easy. There's ready-made Wix element for this.

Currently, we are shipping racer binaries. Better solution would be to add racer submodule and .rsproj project that builds it.
I'm not sure how possible it's at the moment but with project pages not being yet implemented that will require manual work with .rsproj.
Also, this will probably require adding support for loading project from nested path (currently we only allow crate root module to be <location of project.rsproj>\src\main.rs or <location of project.rsproj>\src\lib.rs, but if we are to use submodules we will want support for <location of project.rsproj>\arbitrary\nested\path\to\src\main.rs)

To my mind, We need add VisualRust where we already can add some simple but useful commands. For instance:

• open official Rust docs site with search by word on cursor position
• add/remove selected lines comments
  and so on

Is it even possible? if so it'd be really great.

iirc iron python seems to work on express editions if that's any indication of likelyhood to work

There is IVsTextViewCreationListener, which seems to be able to tie into the ContentType quite nicely, but in order to perform editor operations, an ITextView is needed. Figure out:

1. Why the event listener is never getting called
2. Whether this is the right thing to do at all

We probably should associate with vs version chooser. Check how other extensions do it.

Add a template with a wizard for creating .rsprojs from existing codebase.
Wait with this for cargo support as most of the existing projects are cargo-backed.

The lexer grammar we are currently using is few months old. Get updated version from Rust and check it for missing rules (mainly keywords).

Running a project with Control+F5 usually allows the program to run without a debugger and keeps the command window open until the user closes it. Currently, the program just runs as usual when using the Control modifier.

• Adding dependencies
• Updating the lockfile
• Build the project
• Run tests
• Run benchmarks

To my opinion, it should be easy to add code snippets to VisualRust, but very usefull for users.

Description of Code snippets

See http://msdn.microsoft.com/en-us/library/bb165662.aspx. It seems to do a lot for you? But looking at the Python Tools for Visual Studio extension, it seems they don't really use it, and just stub stuff out.

However, this seems to be the only way to get Rust into the "Text Editor" part of the options dialog? It also seems to provide things like brace matching, which is what I would expect. It's possible that providing a LanguageService is the right thing to do, and that the "walkthroughs" on how to implement brace matching etc are just examples of using the APIs and aren't really for production use.

I'm trying to get this to build (I have never tinkered with extensions before) and I'm getting an error saying it's missing VisualRustPackage.cs in the VisualRust project.

Any chance of getting a quick setup guide in the README? I had to download the Visual Studio SDK to open the project, which might be worth mentioning.

It claims to be line-by-line, but that certainly can't work, even in C#!

Use Racer as a source for statement completion. It is exceedingly awesome at what it does, absolutely no reason to duplicate it.

As it is now, when Visual Studio asks out implementation of smart indentation we can end up lexing whole document.
This is not very good. Mostly because we are lexing whole document already. It happens inside RustClassifier.cs.
proper implementation of our smart indention should connect to the output of RustClassifier, cache information about lexed braces and parens, and finally use that cached information inside VisualRustSmartIndent. This might require some thinking of how exactly share that information between indenter and classifier and when to flush the cache, but should be fairly straightforward.

The generated installation package VisualRust.msi is missing VisualRust.Shared.dll that is required for VisualRust.Build.dll to run. This results in this exception during build:

------ Build started: Project: RustApplication2, Configuration: Debug AnyCPU ------
C:\Program Files (x86)\MSBuild\VisualRust\VisualRust.Rust.targets(19,5): error : Could not load file or assembly 'VisualRust.Shared, Version=1.0.0.0, Culture=neutral, PublicKeyToken=401f5d177ee7d4a2' or one of its dependencies. The system cannot find the file specified.
   at VisualRust.Build.Rustc.ExecuteInner()
   at VisualRust.Build.Rustc.Execute()
Done building project "RustApplication2.rsproj" -- FAILED.

VIsualRust build used:
https://ci.appveyor.com/project/vosen/visualrust/build/job/ubhcib4nvxt95i72/artifacts

Building VisualRust.Shared manually and additing to C:\Program Files (x86)\MSBuild\VisualRust\ helps.

Currently we use MPF to manage project files (.rsproj). It saves us writing a lot of boilerplate and figuring all the minute details of VS COM interfaces. It would be much nicer to base everything off Cargo.toml but that would take considerable effort (we'd lose most of the MPF niceties). In case if someone is interested in this, any work on this from my side will happen in "no-msbuild" branch in my fork (if I ever actually get around to start implementing this).

In Visual Studio 2013 (don't know about VS2012, I can't check it), when you use autocomplition in cases like this :

self.foo(self.|);

in secound case method boo() is substituted
you will get result

self.foo(self.)boo())

or

SomeGreateEnum::|,

SomeGreateEnum::,Value,

We are currently building only for VS2013, it should be a matter of changing definitions in .vsixmanifest and actually testing generated .vsix. Since both 2012 and 2013 version targets .Net 4.5 it won't affect the code.

We currently target commercial versions of VS, but some language plugins (PyTools, F# Tools) can run under Isolated Shell and Express edition. It'd be really nice to achieve the same compatibility in VisualRust.

This is of course predicated on rustc emitting debuginfo (pdb?) that Visual Studio can understand, but there's nothing nicer than Visual Studio's debugger.

Multiline comments are not parsed/highlighted correctly when they actually span multiple lines. Probably an ANTLR grammar problem.

Edit (clarification): I'm talking about block comments /* ... */

This is something that came up during racer PR (#66).
In a nutshell: we rely on rustc.exe, racer.exe and %RUST_SRC_PATH% being set up correctly and being compatible with each other. This is very rarely going to happen.
This is why we need to double check our environment and tell the user how can he fix that.

Copy-pasting from #66, this is how I see it being done:

• Check if rustc is in %PATH% (or in our settings). If it is not present, offer to download and run nightly installer.
• Check if racer.exe is in %PATH% (or in our settings). If it is present, sanity check it by starting racer.exe. If it's not present fall back to racer we ship ourselves (with libgcc_s_dw2-1.dll and rust libraries). If our racer crashes suggest that it might be incompatible with rustc and tell user to compile it himself.
  AFAIK linking to rust libraries is ABI compatible. So if you link to syntax-4e7c5e5c.dll, next time binary incompatible libsyntax is compiled it'll be named syntax-<some_other_hash>.dll. If we want to make sure, we can always check with dumpbin.
• Check if there's env var (or in our settings) pointing to something that looks like rust source. If we have nothing like that, offer to the user to git clone rust sources (we can get commit hash from rustc --version verbose).

As for the UI we should do it the same way Git Extensions (https://code.google.com/p/gitextensions/) does it. First time .rs or .rsproj file is opened run above checks and if something is wrong present an UI that shows what's wrong at the first glance and suggests fixes. Screen of window that shows broken settings with Git Extensions.

As mentioned in #95, handle commenting/uncommenting from Edit/Advanced/Comment Selection (Uncomment too).
Consider handling other editor commands that require language support too.

I already tried to Flush the Visual Studio Template Cache, but it didn't work. Maybe it's a problem that I have a VS2013 with german language pack?

EDIT: I also used this installer.

Including files/folders show by "Show all files" was disabled in #117 due to huge bugginess.
It'd be nice to have this functionality back.

Depending on which side of the brace you are on, it may or may not highlight. There also seems to be some weirdness with jump-to-matching-brace (Ctrl-]) if the caret is after the brace.

• Recognize rust projects
• Add project template for application (equivalent to cargo new)
• Add project template for binary (equivalent to cargo new --bin)
• Add project template for creating projects from existing codebase
• Add support for adding .rs items to projects
• Support build/rebuild/clean
• Get rid of "Add references"
• Add property pages
• Force proper project structure

This is perhaps only in Ultimate, but add support for profiling Rust programs. Probably blocked on #13.

Currently we ship extension using .vsix packages. Unfortunately .vsix packages doesn't support adding custom system-wide msbuild .targets. We need this to properly support building rust code (there are alternatives, but they are all horrible).
We are using WiX Toolset (version 3.9), since it has some support for vsix.
This blocks #4.

We now have a simple smart indent implementation in VisualSRustSmartIndent.cs.
This is good, but slightly annoying when it comes to right paren/right bracket insertions
For example, without auto dedention:

fn foo() {
····bar();
····baz();

now inserting } at the end of the file leads to

fn foo() {
····bar();
····baz();
····}

Auto dedention should correct it to

fn foo() {
····bar();
····baz();
}

Note, that autodedention should know know the difference between } and ) and auto-dedent to the "level" of the right token.

• Make it token based, not textual (may require some infrastructure work to expose lexing of lines)
• Don't look as far back for opening { (only keep looking if prevLines are only whitespace)
• Handle things like breaking function calls on multiple lines (should align with first argument)
• Dedent on }

Compilation errors/warnings/etc should put squiggles in the buffer and perhaps a glyph in the margin.

While testing #112 I found at least one case, where the current RegEx for error messages does not work correctly. Given this rustc output

main.rs:118:22: 118:26 error: mismatched types:
 expected `&mut [u8]`,
    found `&[u8; 2]`
(values differ in mutability) [E0308]
main.rs:118     match stdin.read(&buf) {
                                 ^~~~

the RegEx will only extract the first line and discard the additional information, resulting in the error message mismatched types:

I'm not sure how this should be fixed.

It would be nice if we could overwrite the behavior of the "Show Error Help" command in the context menu of the error pane (see this example image) to open the page http://doc.rust-lang.org/error-index.html with the appropriate anchor (e.g. this for E0297). We already forward the error codes, but probably something needs to be done within the actual VS extension (as opposed to the MSBuild module, which only outputs text that is then automatically parsed by VS).

Take the following code:

fn main() {
    println!("Hello world!");
}

fn fn 

Now erase the last line and an error should pop up in VS asking to check [MyVSPath]/ActivityLog.xml, which contains the following entry occurring last:

  <entry>
    <record>840</record>
    <time>2014/09/12 21:28:51.934</time>
    <type>Error</type>
    <source>Editor or Editor Extension</source>
    <description>System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values.&#x000D;&#x000A;Parameter name: index&#x000D;&#x000A;   at Microsoft.VisualStudio.Text.Implementation.SimpleStringRebuilder.get_Item(Int32 index)&#x000D;&#x000A;   at Microsoft.VisualStudio.Text.Implementation.TextSnapshot.get_Item(Int32 position)&#x000D;&#x000A;   at ArkeIndustries.VisualRust.RustBraceMatcher.&lt;GetTags&gt;d__6.MoveNext()&#x000D;&#x000A;   at Microsoft.VisualStudio.Text.Tagging.Implementation.TagAggregator`1.&lt;GetTagsForBuffer&gt;d__5.MoveNext()</description>
  </entry>

Currently, auto-completion is slow. There might be several reasons for that: text manipulation costs, racer.exe launch time, something else?
We should also try running stuff asynchronously.

The current lexer creates separate tokens for float suffixes (like f32). This breaks the mapping from ANTLR tokens to VS tags (try a file with Vec<f32> for example). I submitted a pull request to Rust (rust-lang/rust#17625), we should just sync the file when that is accepted.

Most commonly, for languages like C#, F# or C++ you pass the list of files to compile and leave it to the compiler to sort everything out. Rust is different in that it compiles from a single entry point file (main.rs or lib.rs most commonly) and follows modules from source code. So the default mode of operation of MSBuild doesn't quite fit here. The solution will be to not so subtly force user to follow proper layout.

• Load module-referenced files after project files are loaded (roots are .rs files and the entry point).
• Track module additions/removals to file (might create new subtrees or roots).
• Visually mark roots that are not the entry point.

This is part of #4, but it's quite complicated so I split it to a different issue.

For example, Tools > Options > Text Editor > C# has a bunch of knobs to tweak. Figure out how to get in that list.

I tried version from Visual Studio extension gallery but it is very incomplete, it has only syntax highlightning, there is even no compilation (or I wasn't able to figure out how to make it work). Therefore I downloaded and compiled latest master but installer fails with this error:
"There is a problem with Windows package. A program run as part of the setup did not finish as expected."
It doesn't provide more details.

Currently, when building rust project build errors appear in error list. Double clicking on them should bring up the document that contains the error

This behaviour can be fixed by passing and instance of DocumentTask instead of ErrorTask in IDEBuildLogger. This shouldn't be too complicated, but in case something is unclear you can check Visual F# to see how they are doing it.

I think it also provides squiggles.