Qodana 2022.3 EAP Is Out: Qodana for .NET and Go and 100+ New Inspections
Tags: java, kotlin, news, releases
Published: 2022-11-03 09:36:34

---
title: Qodana 2022.3 EAP Is Out: Qodana for .NET and Go and 100+ New Inspections
published: true
date: 2022-11-02 11:22:28 UTC
tags: java,kotlin,news,releases
canonical_url: https://blog.jetbrains.com/qodana/2022/11/qodana-2022-3/
---

We’re delighted to announce the release of Qodana 2022.3 EAP. This version of the platform brings support for NET. and Go, and over 100 new inspections for cleaner code. However, please, note that Qodana 2022.2 images are more stable, as Qodana 2022.3 EAP is still in its infancy.

Read on to learn more and become an early adopter of some exciting new features!

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/Featured_image_1280x600_Qodana.png)

[GET STARTED WITH QODANA](https://www.jetbrains.com/qodana "GET STARTED WITH QODANA")

Our brand new linters bring all of the smarts from [Rider](https://www.jetbrains.com/rider/) and [GoLand](https://www.jetbrains.com/go/) to enable you to spot anomalous code and potential bugs, eliminate dead code, improve the overall code structure, and introduce coding best practices across all of your .NET and Go projects!

## Qodana for .NET

Qodana supports almost all .NET inspections provided by Rider. Since there’s a long list of them, check out the [Rider documentation](https://www.jetbrains.com/help/rider/Code_Analysis__Code_Inspections.html) to learn more about all of the inspections. Meanwhile, a few examples of the .NET inspections that Qodana can run are below.

**Inconsistent lock ordering**

One of the main issues when using locks to achieve thread safety is avoiding deadlocks, i.e. when threads simultaneously block each other from continuing execution, so no progress is made. With this new inspection, Qodana will highlight cycles leading to possible deadlocks at runtime.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/1-NET-order-of-locks.png)

**Access to modified captured variable**

Qodana for .NET detects access to the captured variable from an anonymous method when the variable is modified externally.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/2-NET-access-to-modified.png)

**Avoid using ‘async’ lambda when delegate type returns ‘void’**

This inspection spots the usage of ‘async’ lambda expressions: any exceptions unhandled by the lambda will never affect the caller thread and will not be caught with the catch clause.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/3-NET-Avoid-async-lambda.png)

**Type check and casts can be merged**

The type-testing `is` operator in its classical form `(Expression is Type)` returns `true` only when the runtime type of `Expression` is compatible with `Type` and the result of `Expression` is not `null`.

When we use `is` to check the compatibility before casting, like in the example below, we encounter at least two problems:

- We perform the type check twice for no reason, which can affect performance if we do it inside a loop.
- The fact that the program execution will not get into the `if` statement if `obj` is `null` is not immediately clear to those who read this code.

Qodana will spot this issue and suggest you fix it right in Rider.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/4-NET-Merge-cast.png)

**Lambda expression/anonymous method should not have captures of the containing context**

The lambda expression/anonymous method passed to a parameter annotated by the ‘[RequireStaticDelegate]’ attribute must not have captures of the containing context (local variables, local functions, ‘this’ reference) to avoid heap allocations.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/5-NET-Lambda.png)

To configure the linter for .NET and run analysis, please refer to the [Qodana documentation](https://www.jetbrains.com/help/qodana/2022.3/qodana-dotnet-docker-readme.html).

## Qodana for Go

Qodana 2022.3 is designed to support all inspections provided by GoLand. To see the exhaustive list, please refer to the [GoLand documentation](https://www.jetbrains.com/help/go/code-inspections-in-go.html). Below are examples of some of the Go inspections that Qodana now supports.

**Placeholder argument ‘d.DeletedCount’ has the wrong type ‘int64’ (%s)**

This inspection reports incorrect usages of `fmt.Printf`, `fmt.Println`, and similar formatting and printing functions.

In their format strings, formatting functions use formatting verbs, like `%s`, `%d`, `%v`, and others.

If formatting verbs are used incorrectly, the result of a formatting function will contain an error.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/6-Go-placeholder.png)

**Unhandled error**

This inspection reports calls to functions and methods that do not handle the call result of the `error` type.

An API of such functions imply that their execution might finish unsuccessfully and they would return an error. Calls that do not handle the error result could be an indication of misuse of the API.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/7-Go-Unhandled.png)

**Unused dependency**

This inspection reports unused dependencies on your project. It’s good practice to scan for unused dependencies on a regular basis, as it reduces the library size of your project and improves maintainability.

![](https://blog.jetbrains.com/wp-content/uploads/2022/11/8-Go-unused.png)

To see Qodana in action and play around with these new inspections, feel free to jump into our documentation and see how to configure linters for [Go](https://www.jetbrains.com/help/qodana/2022.3/qodana-go-docker-readme.html).

## New inspections

Besides adding new linters for .NET and Go, Qodana 2022.3 also brings you over 100 new inspections for the existing linters. Let’s take a look at the most prominent examples of inspections for Java, Kotlin, and Python.

### Java and Kotlin inspections

We’ve added over 40 new inspections to Qodana for JVM Community and Qodana for JVM.

**DataFlowIssue**

This inspection reports code constructs that always violate nullability contracts, may throw exceptions, or are redundant, based on data flow analysis.

**EscapedSpace**

Java 15 introduced the string escape sequence \s to make trailing whitespace in text-blocks visible. In most other contexts, especially in regular expressions, this escape sequence can easily be confused with the `\s` of a regular expression meaning whitespace. In Java string literals it has to be written as `"\\s"` instead.

**MismatchedJavadocCode**

This inspection reports cases in which the Javadoc of a method obviously contradicts the method signature, such as the comment saying “returns true” when the method returns a string.

**Destructure**

This inspection reports declarations in Kotlin that can be destructured.

**UnresolvedRestParam**

Now Qodana can detect inconsistent method declarations in REST services (such as `@PathParam` parameters that don’t match a placeholder from the `@Get `annotation), as these would throw exceptions at runtime. 

**ReactiveStreamsThrowInOperator**

This new inspection spots `throw` statements in Reactor/RxJava operator code instead of returning designated error values, which prevents the errors from being processed further. For example, it ignores them or replaces them with a fallback value.

 

Please, note that this version of Qodana also brings all of the new inspections for Android from IntelliJ IDEA 2022.3 and Android Studio – Electric Eel | 2022.1.1.

### Python inspections

We’ve also added some inspections for the Google App Engine to Qodana for Python that will highlight issues before they cause failures in production environments. For example, now you can spot:

- GQL queries that  do not comply with restrictions for queries allowed on the Google App Engine server.
- GQL queries without indexes.
- Usages of Python features that are restricted by the Google App Engine sandbox.
- Сases when threadsafe is not enabled with the CGI handler.

To exclude certain inspections from your analysis, you can customize your default inspection profile or create a brand new one. You may also want to ​​enforce inspections that are important to your coding guidelines. Check out our [Qodana documentation](https://www.jetbrains.com/help/qodana/qodana-yaml.html#Include+an+inspection+into+the+analysis+scope) for more information.

That’s everything about Qodana 2022.3 EAP! We hope you enjoy this new release. If you have any suggestions for future blog topics or if you want to learn more about how Qodana can help you and your business, post a comment here, tag us on [Twitter](https://twitter.com/Qodana), or contact us at _qodana-support@jetbrains.com_.

Happy developing and keep your code clean!

_Your Qodana team_