PVS-Studio 8.00: analyzers for JavaScript, TypeScript, and Go, plugins for WebStorm and GoLand, and more

PVS-Studio 8.00 has been released. This version features new analyzers for JavaScript, TypeScript and Go projects, new IDE plugins for WebStorm and GoLand, expanded support for MISRA C++ 2023, and much more.

New analyzers and IDE plugins

The major PVS-Studio 8 release introduces new analyzers for JavaScript, TypeScript, and Go.

This version provides the analyzers with a basic set of diagnostic rules, a CLI for each analyzer, and plugins for the IDEs (WebStorm and GoLand).

The PVS-Studio plugin for Visual Studio Code has also major changes. It now supports the new analyzers and allows you to configure each analyzer from the options panel.

pvs-settings.toml configuration files

A new TOML-based configuration file format is now used to configure the new analyzers, the new IDE plugins, and the updated Visual Studio Code extension.

During its development, we aimed to cover all possible scenarios to provide the most user-friendly experience.

See more about new configuration files in the documentation.

MISRA C++ 2023

We continue to enhance the support of the MISRA C++ 2023 standard.

We've adapted sixteen existing diagnostic rules of the MISRA group to the MISRA C++ 2023 standard.

Additional information on MISRA support is available in the documentation.

Compiler support

In the release, we have also expanded the list of C and C++ compilers that are compatible with the PVS-Studio analyzer for these languages.

On Linux, the pvs-studio-analyzer utility supports the x86_64-pc-linux-gnu-c++ compiler.

The TI C2000-CGT compiler is also supported on all platforms via compilation monitoring and tracing.

Plugin for Qt Creator 20

The PVS-Studio plugin now supports Qt Creator 20.x. Now you can run analysis, view warnings, and work with code directly in the development environment.

The plugin for Qt Creator 14.x is no longer supported. We aim to maintain backward compatibility between the latest plugin versions and all Qt Creator versions released over the past two years.

See more about the plugin in the documentation.

Extended logging system for MSBuild projects

We continue to implement a new logging system, which will make it easier for us to detect issues that arise when running PVS-Studio analyzers.

Previously, we added extended logging to the cross-platform analyzer for C and C++ projects, but now it's also available for analyzer of C++ and C# projects based on MSBuild.

You can read more about the new logging system in the documentation.

Breaking changes

These changes are not backward compatible with earlier versions of the analyzer. You may need to alter the way how you use the analyzer due to these changes.

For Unreal Engine projects, the //V_USE_OLD_PARSER flag in the .pvsconfig file is now ignored. The new C++ parser has advanced enough to be recommended as the default for all analyzed projects. It now applies by default to projects using older Unreal Engine versions as well, regardless of whether the engine source code still contains the //V_USE_OLD_PARSER flag.
The Java analyzer now sorts the contents of suppress files. The update does not affect analysis results, but it may cause substantial changes to suppress files stored under version control the next time they are updated.
The messages issued for diagnostic rules V2558 and V547 have been updated for specific cases. Warnings that were previously suppressed may reappear in analysis reports.
Due to significant changes made to the Visual Studio Code extension to support the new PVS-Studio analyzers, the minimum supported Visual Studio Code version required to use the extension is being increased from 1.74 (November 2022) to 1.100 (April 2025).

New diagnostic rules

Java

V6136. Values of bit flags are duplicated.

JavaScript and TypeScript

V7001. Operands of a binary operator are equivalent.
V7002. The body of a function is fully equivalent to the body of another function.
V7003. A condition is equivalent to a condition in an 'else if' statement, making it unreachable.
V7004. The 'then' statement is equivalent to the 'else' statement.
V7005. A variable is assigned to itself.
V7006. An exception is created but never used. The 'throw' keyword may be missing.
V7007. The '|' and '&' operators bypass short-circuit evaluation. The right-hand operand will be evaluated even when the left operand is false.
V7008. Two or more 'case' branches perform the same actions.
V7009. A parameter is not used in a function, constructor, or method.
V7010. The return value of the function is required to be utilized.
V7011. Comparison with 'NaN' is incorrect. Use 'isNaN()' or 'Number.isNaN()' method instead.
V7012. The conditional expression always returns the same value.
V7013. Suspicious assignment in the condition. A comparison may have been intended.
V7014. An identical expression to the left and to the right of a compound assignment.
V7015. Suspicious formatting of assignment and unary operators.
V7016. Suspicious access to a collection element by a constant index inside a loop.
V7017. A loop counter is not used for collection indexing in the inner loop.
V7018. The expression 'A || (A && B)' is redundant and always evaluates to 'A'.
V7019. A variable is used as a counter for both inner and outer loops.
V7020. Suspicious code formatting. Curly brackets may be missing.
V7021. The postfix increment or decrement has no effect because the variable is overwritten.
V7022. It is possible that this 'else' branch should belong to the previous 'if' statement.
V7023. Suspicious use of a variable in similar code fragments. This may be a typo, and a different variable was intended.
V7024. Suspicious sub-expression in sequence of similar comparisons.
V7025. It is possible that an assigned variable should be checked in the following condition. Consider checking for a typo.
V7026. A stray semicolon after the condition of an if, for or while statement.
V7027. An object is passed as an argument to its own method.
V7028. A user-defined mathematical constant is used instead of a built-in constant. The resulting value may be inaccurate.
V7029. The line may have been commented out improperly, resulting in altered control flow.
V7030. Suspicious code formatting. The 'else' keyword may be missing.
V7031. A suspicious label was found inside a 'switch' statement. This may be a typo, and a different label was intended.
V7032. The loop counter is compared to its own initial value.
V7033. Suspicious similar comparisons. A typo may be present inside the expression.
V7034. The method in the child class does not override or implement the method of the ancestor class. A typo may be present in the name of the child class method.
V7035. Suspicious property implementation. Another field should probably be returned or assigned instead.
V7036. Suspicious precise comparison. Consider using a comparison with defined precision.
V7037. The nested loop counter is initialized with the outer loop counter.
V7038. The loop condition may be incorrect. The condition and update expression of the loop use different variables.
V7039. Unreachable code detected. Control flow never reaches this statement.
V7040. Infinite recursion detected.
V5801. OWASP. Code contains invisible characters that may alter its logic. Consider enabling the display of invisible characters in the code editor.

Go

V8001. Identical sub-expressions to the left and to the right of the 'foo' operator.
V8002. A variable is assigned to itself.
V8003. Consider inspecting the expression. Probably one of the operators should be used here: '-=', '+=' or '!='.
V8004. The use of 'if A {...} else if A {...}' pattern was detected. A potential logical error is present.
V8005. The 'then' statement is equivalent to the 'else' statement.
V8006. Unconditional 'break/continue/return/goto' within a loop.
V8007. Calling the 'recover' function inside the anonymous function that is not deferred will not recover execution from panic.
V8008. Suspicious access to a collection element by a constant index inside a loop.
V8009. Two or more 'case' branches perform the same actions.
V8010. Two or more 'case' branches have equivalent expressions.
V8011. An identical expression to the left and to the right of a compound assignment.
V8012. A function always returns the same value. Consider inspecting the program logic.
V8013. Incorrect format. A different number of format items is expected.
V8014. Two 'if' statements have identical conditions. The first 'if' statement contains function return, making the second 'if' redundant, or the code contains a logical error.
V8015. Suspicious use of the bitwise XOR operator '^'. The exponentiation operation may have been intended here.
V8016. The loop may be executed incorrectly or its condition will never be met. Inspect initial and final values in the 'for' loop.
V8017. The conditions of two adjacent 'if' statements are equivalent.
V8018. Comparison with 'math.NaN()' is meaningless. Use the 'math.IsNaN()' function instead.
V8019. Two or more equivalent expressions are specified inside the case expression list.
V8020. Recurring check. This condition was already verified on a previous line.
V8021. Using a unary operator several times is meaningless or reverses the result.
V8022. A parameter is not used in a function or method.
V8023. It is possible that a wrong variable of the 'error' type is checked for 'nil'.
V8024. Redundant type assertion. The type of a variable already embeds the type that is checked using type assertion.
V8025. The case in a type switch is unreachable. A previous case already covers this type.
V8026. The counter is not used inside the body of the nested loop.
V8027. Suspicious sub-expression in sequence of similar comparisons.
V8028. The outer loop counter is modified in the post statement of the inner loop. Perhaps the inner loop counter should be modified instead.
V8029. The outer loop counter is used in the condition of the inner loop. Perhaps the inner loop counter should be used instead.
V8030. The outer loop counter is used in the init statement of the inner loop. Perhaps a different variable should be used as a counter instead.
V8031. Using the call of the 'len' function as an index will result in an off-by-one error.
V8032. The return value of the function is required to be used.
V8033. Two similar code fragments were found. A second fragment may contain a typo.
V8034. Potentially incorrect order of arguments passed to a function.
V8035. Type assertion is always false. Check interfaces used in type assertion, as they contain methods with incompatible signatures.
V8036. A meaningless comparison with a variable of an unsigned type.
V8037. The same argument was passed to a function multiple times. A different argument may have been intended.
V8038. Parameter is always rewritten in the function body before being used.
V8039. Suspicious leading or trailing whitespace in the value used to identify an element.
V8040. The value of the variable is overwritten before it is used.
V5901. OWASP. Code contains invisible characters that may alter its logic. Consider enabling the display of invisible characters in the code editor.

Articles

Now it's time for some useful content: articles from our blog! Over the past two months, we've checked the OrcaSlicer projects, searched for bugs in BotSharp, tested the quality of Quarkus, discussed the new features of ES2026, recapped the JavaScript history, looked at subtle bugs in Go, and that's not all! You can see more in the list below.

C and C++

Csharp

Inside BotSharp: Finding bugs in the .NET AI platform's code

Java

Inside cloud-native Java: Exploring Quarkus

JavaScript and TypeScript

Go

One mistake no one has ever made. Right?

GameDev

Webinars

Let's make a programming language. AST

We're continuing our webinar series on building your own programming language in C++!

In the previous webinar, we created a parser that analyzes code and outputs parsing results to the console. Now it's time for the next important step building an AST (Abstract Syntax Tree).

In this video, we'll explain how ASTs work, build one step by step, and create a printer to visualize and inspect parsed code. This session will lay the groundwork for everything that comes next in our language implementation journey — semantic analysis, evaluation, and beyond.