Greatly expanded code inspections with over 100 new Clang Tidy checks

The biggest item in this release is the added support for all code checks available from Clang Tidy. Code inspections are semi-automatic checks that prompt the user when Visual Assist’s engine recognizes outdated syntax or an otherwise correctable code issue. 

For context, Visual Assist’s code inspection is based on a series of checks from LLVM Clang Tidy. And before we add support for a new check, we rigorously test it for accuracy and compatibility. This process ensures that the check will give consistent suggestions for almost all use cases. In fact, this is the process undertaken for the two new added code inspections in this release—more on them later.

What we’ve added is the ability to use unevaluated Clang Tidy checkers as Code Inspections straight from Visual Assist. This greatly expands the types of code issues that can be detected with code inspections enabled. There is a slight tradeoff in that you may need to do some manual testing when using unvetted checks. Take a look at the full documented list of Clang Tidy checks.

The latest addition to our list of vetted code inspections are for bugprone-swapped-arguments and bugprone-argument-comment. These checks look for potentially swapped arguments by looking at implicit conversions and detect typos in argument comments and suggest automated fixes for them, respectively.

Lastly, we’re also announcing that code inspection is officially out of beta and is now running on Clang engine version 15.0. The beta label is mostly a formality and all functionality should function the same. If you haven’t, we highly advise enabling code inspections.

Protip: When running comprehensive code inspection checks in a file, you can sort and group issues by level. Code inspection levels refer to an arbitrary metric representing severity given to a code check. Level one signifies critical, level five being on the level of a reminder, and zero refers to unflagged checks.

Extended Shader File Customization

Due to consistent demand and great feedback, a significant portion has also been given to further improve our support for shader files. In fact, as of this release, it is in the last phases of beta testing and will most likely be available for general support very soon.

In this release, you can now use custom shader file extensions (there are no longer extensions considered “default”). Coloring and syntax highlighting has also been drastically improved, with almost all bugs ironed out as well.

Enable support for shader file parsing by accessing Visual Assist Options ->> Game Development ->> Enable support for shader files.

Integrated-style extensions menu (pre-Visual Studio 2019)

In Visual Studio 2019, the toolbars and plugins were rearranged. Instead of being able to access your plugins in the main toolbar, you had to instead go under the Extensions menu. 

For the most part, this made sense—it’s easier to find all installed plugins and access their features correspondingly. However, for users who had one or a handful of plugins or are more comfortable using the mouse instead of shortcuts, the extra step might be bothersome (e.g. mouse users with only VAX installed).

Some users expressed interest so we’ve added the option for an integrated-style menu for extensions (similar to the pre-VS 2019 setup). 

This new menu mode can be enabled via Extensions ->> VAssistX ->> Visual Assist Options ->> Display ->> Switch to Legacy Style Main Menu.

Implement Virtual Methods context menu option to check / uncheck all.

The last of the new features in this release is a quality of life change. Inheriting from other classes is made much easier and intuitive using the Implement Virtual Methods feature.

While in the dialog, we added a small tweak that allows users to check and uncheck all possible methods using a simple checkbox. Neat little addition, we hope.

Visual Assist’s Implement Virtual Methods feature provides a neat little dialog to make inheriting from other classes quick and intuitive.

Bug Fixes

• Fixed issue where installer exe could report errors after a successful install.
• Improved auto type deduction for const, pointers and chained function calls.
• Fixed issue where Code Inspections could fail with the latest MSVC includes.
• Fixed issue where shader coloring may not be applied to the correct file extensions.
• Fixed issue where shader coloring sometimes not applied to files opened automatically on solution load.
• Fixed issues which could lead to the VA Navigation Bar being drawn incorrectly.  
• Fixed issues which could lead to missing icons.
• Improved tab completion in C# to interact better with build in tooling.
• Fixed minor visual theming issues in various VA dialogs. 

Much thanks to those who submitted their feedback and bug reports. Keep ‘em coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.2 released first appeared on Tomato Soup.

Improved parser auto type deduction for pointers

This release updates how Visual Assist handles auto type specifiers, particularly when reference is coming from a pointer. Previously, there was a change that when auto assignments are used, any flags (such as const) may be ignored. With this release, VA now has better pointer deduction avoiding such instances.

Parser support C# tuple deconstruction

This update is useful for those using the C# equivalent of the previously released tuple deconstruction for C++  to avoid verbose initialization of variables.

What this update does is that when you assign multiple variables at once using a predefined struct, VA will be able to recognize those variables. Consequently, this allows its features such as syntax highlighting and navigations to function properly. 

Add parser support for C++ 17’s structured binding from a constructor

This is a simple fix for an edge case for structured bindings that happens when a constructor is used. Similar to the last fix on tuple deconstruction, what this update does is that when you use the auto function to assign variables from a struct, it will now function properly even when a constructor is called.

Support for custom shader file extensions

When we added shader language and HLSL support, one of the most prominent user requests was to be able to enable support for non-standard/custom shader extensions. 

With 2023.1 you can now add custom files by adding the extension in a text field under Options ->> VAssistX ->> Game Development ->> General.

Better code formatting and behavior for Unreal Engine copy-paste

Users can recall that when typing Unreal-specific code, there is unintended indentation behavior as a result of VS not understanding UE specifiers such as UFUNCTION and UMACROS.  

With Visual Assist enabled, the automatic indentation present in default Visual Studio is disabled. And in this release, we’ve improved on this behavior by extending it to copy-paste. What this means is that when copying or cutting blocks of Unreal Engine code, the pasted code will still have the correct indentation in place.

New UI in Find References results

Previously, when using find references, the default scope of the search was the currently opened project or file. This update is for those who found that results shown by find references seem to be incomplete— it is now more apparent that you have the option to specify the scope of the search (ie. just the open project or the entire solution).

In this release, there is a newly added notification after every search that prompts the user to redo the operation for the whole solution.

Code inspections for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion

Lastly, we’ve added two new code inspections based on clang tidy for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion.

The first one is useful if you use std::vector and you are using remove() or erase() which often uses hard to read/type syntax. This inspection makes sure that when you use erase(), it works properly. 

The second one is useful when you have a pointer as an argument to an if statement (or anything resembling a bool). This is because it has to be dereferenced first or else it will default to a True. This check notifies the user if the pointer has not been dereferenced. 

Both of these checks are useful because in both of these instances, the code will still compile successfully—giving a false impression that everything would work as intended.

Bug Fixes

We also have a couple of bug fixes. And although they are small bugs, we hope this would be beneficial to users who encountered problems around the following:

• Fixed issue where icons may be missing in Visual Studio 2022.
• Fixed issue where folders / JSON files may be unnecessarily created when hovering the mouse cursor over symbols.
• Fixed convert suggestion listbox keyboard shortcut display to update when the shortcut is changed. Note: shortcuts shown are now dynamic.

Keep the reports coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.1 released first appeared on Tomato Soup.

If you haven’t updated yet, download the latest release here.

Parser changes

One of the highlights of this release is improvements to Visual Assist’s parser. The parser is core to how Visual Assist understands (and therefore suggests) code.

Numerous upgrades and fixes have been undertaken to make the parser smarter. This makes it recognize modern C++ code standards and practices, thereby minimizing unwanted behavior as well. Here are some of them:

• Now distinguishes between std::get and std::tuple.
• Now understands parameters declared with “out int” in C#
• Fixed parser getting confused with case’1′ inside switch statement.

Expect a steady stream of updates to parser behavior. If you encounter any bugs or errors submit a bug report on our community forums.

Support for C++17’s structured bindings

With the parser changes, VA 2022.4 also includes added support for C++17’s structured bindings. Structured bindings enable users to declare multiple variables initialized from a tuple or struct, simplifying and improving code readability.

VA’s improved parser recognizes structured bindings introduced in C++17, adding support for VA features such as code suggestion and navigation.

With this change, variables that are contained within the binding are now recognized. For example, typing a dot will now be properly colored and displayed on the navigation bar. You can also rename, search, and perform all the other actions you would expect from VA.

Continued HLSL improvement

The recently-added High Level Shading Language (HLSL) support has been augmented with coloring support for a variety of file types. This includes matrix types double4x2 and fixed3x4, and some base types such as min10float3. Because HLSL typically lacks corresponding header files, a more sophisticated understanding of code was required.

For those who are unaware, official HLSL support shipped with the previous release. HLSL and Unreal’s USF and USH files now integrate with VA’s core features.

Respecting VSCode excludes config files

Visual Assist now includes an option to consider configuration instructions similar to those used in VSCode settings .json files. This comes at the request of those who wish to skip unnecessary parsing when building solutions. 

This means that you can open a file without needing to parse an entire project or a solution, saving precious time. This is a way to essentially tell Visual Studio and Visual Assist to “open a file but do not parse anything else apart from a specific part.”

Enable the option to detect and honor exclude settings via ticking a checkbox in Visual Assist options. Here is an example of a configuration file with exclude settings:

An example configuration that VA will now recognize. Note: The actual JSON files are often configured in VS Code itself through a UI.

A new code inspection

This release also adds an inspection for bugprone-string-integer-assignment—a check based on LLVM/Clang-Tidy. It checks for easy-to-miss instances of assigning an integer to  std::basic_string<CharT> (std::string, std::wstring, etc.).

Access other code inspections by accessing the following:
(If you are not seeing options, please remember to enable code inspections!)

• Quick Actions and Refactorings menu ( Shift + Alt + Q ) 
• VAssistX ->> Code Inspection (beta) ->> VA Code Inspection Results

Minor bug fixes

• Fixed comments getting duplicated in tooltips.
• Fixed issue where VA’s tooltips would not appear if IntelliSense was disabled
• Fixed issue where VA Outline tooltip spreads across two monitors with different DPI settings could cause the system to freeze.
• Fixed issue where tomato icon may become black on hover in VS 2022
• Fixed issue where class method name that begins with “using” is missing from MIF.

For more information about the changes in this release, head on over to the documentation. We hope you find these changes useful. Happy coding!

The post Visual Assist 2022.4 now available first appeared on Tomato Soup.

Unreal Engine 5 Support

The biggest announcement in this release is the the start of official regression and other testing related to Unreal Engine 5. This also comes with some modifications to the IDE UI to make it apparent that our features work with both engines.

We’ve also updated VA’s  behavior when used alongside Unreal’s core redirect function. This adjustment allows UE devs to rename classes in their C++ code and allows their Blueprint code to find the renamed classes by editing a redirect file for them. 

Visual Studio 2022 Icon Updates

Visual Studio 2022 introduced some style and UI changes so Visual Assist’s UI (no matter how sparse) has been updated to complement those changes. Bonus: This was admittedly the most difficult part of the release according to our amazing dev team. 

Here’s what it looks like in the IDE:

More ubiquitous code assistance

A few of Visual Assist’s popular code assistance features now work in more file types by default. For example, sorting selected lines will now work in plain text files (they were only active in source files before). Spell check will have some UI prompts (shown as underlines) that will now appear by default.

Code Inspection improvements

We also added some code inspection improvements. The first checks for an easy-to-make mistake where std::move does nothing, where it should speed up copying of a type.  It will now detect and correct a few easy and potentially performance costing mistakes when using std::move.

The second check for performance-move-const-arg validates user defined move constructors to ensure they are properly marked noexcept, which would prevent them from being used.

Some notes from our dev team

This release caps some long-term items we had in our pipeline. In the future, however, we would like to revert to working on less long running tasks. This helps keep our small team’s development direction agile, and thus allows better and prompt answers to user expectations.

So, if you have any suggestions, or encounter anything that needs a fix, please send support a message or post on our user forums.

For more information about the changes in this release, please read the documentation.

Happy coding!

The post Visual Assist 2022.2 is here first appeared on Tomato Soup.

We’re really making an effort to keep blogs more instructional or industry related, but man o’ man is this release worth a few lines. Our team has been working behind the scenes for much of the year on performance improvements. And sure, we could’ve just done a few things here and there over time to make it feel like we were consistently improving (which we are), but with this release we decided we were ready to go all out.

Essentially we parse all of your source code and store that information in a database. Of course the larger your code base, the larger the database. And this can bottleneck you pretty bad in Visual Studio. So we’ve moved a portion of the database out of process decreasing the available memory we consume inside of Visual Studio and increasing the available memory. Yes, this is an over simplification of what we’ve done and doesn’t do justice to our developers, but download the latest, give it a whirl and let us know what you think.

Of course we didn’t stop there. We’ve updated our code inspection tool, LLVM/Clang, to the latest and greatest. We also added Code Inspection for performance-inefficient-algorithm clang checker. And we added more suggestions for UE4 macros. You can check out our full release notes here and be sure to download. Remember, maintenance must be current as of 2020.10.28.

Whether you’ve been using Visual Assist for a while or you’re brand new, you’re going to notice a difference with this build. Happy Coding!

The post Visual Assist Build 2393 is Here! first appeared on Tomato Soup.

The post Visual Assist Build 2366 is Available! first appeared on Tomato Soup.