Inspectopedia Help

New Inspections in This Release




Check .NET source code coverage

Reports methods, classes and files whose coverage is below a certain threshold.





Reports a discrepancy detected by the Stylelint linter.

W3C CSS validator

Reports a discrepancy detected by the W3C CSS Validator.




Incorrect CLI syntax

Reports the problems if the arguments of the command you type in the console are not in the proper order.




Duplicate element

Reports duplicated elements inside a node.

Invalid property type

Reports properties with invalid type.

Invalid property value (const)

Reports const properties with invalid values.

Invalid property value (enum)

Reports enum properties with invalid values.

Required properties

Reports missing required properties.

Undeclared property

Reports undeclared properties.




Broken line comment

Reports #} line comment ends in Django templates that do not have a matching line comment start.

Django endblock name doesn't match the block name

Reports incorrect names of the closing blocks.

Django {% url %} tag arguments are unresolved

Reports a missing url in the url tag.

Duplicated block names

Reports duplicated block names in Django templates.

Incompatible code in Django templates

Reports features that are not available in the current Django version.

Incorrect arguments in the ' {% url %}' tag

Reports missing parameters in the template file if the url() function has parameters in its URL path.

Incorrect comparison expression in Django templates

Reports missing whitespaces before and after comparison operators in Django templates.

Mismatched opening and closing tags

Reports cases when opening tags in Django templates are not correctly matched by closing tags.

Misplaced {% extends %} tag

Reports the {% extends %} tag that is not the first tag in a Django template.

Unresolved filter

Reports unresolved filters in Django templates.

Unresolved library inspection

Reports unresolved references in Django load tags.

Unresolved static reference

Reports unresolved references to static resources.

Unresolved tag

Reports unresolved tags in Django templates.

Unresolved template reference

Reports unresolved file references in string literals of extends> and include> Django tags.




Built-in errors

Reports FreeMarker language errors.




Standard library functions validation

Reports invalid GitHub Actions Expression language standard library function calls For more information on GitHub Actions Expression language, see the GitHub documentation.




Conflicting properties

Reports conflicting properties in an HCL block.

Deprecated blocks/properties

Reports deprecated blocks or properties.

Duplicated output

Reports duplicate outputs.

Duplicated property

Reports duplicate properties inside one block.

Duplicated provider

Reports duplicate providers.

Duplicated variable

Reports duplicate variables.

HIL expression can be converted to HCL2

Reports old style HCL expressions and suggests converting them to HCL2 expressions.

Illegal interpolation

Reports illegal interpolations.

Incorrect .tfvars content

Reports errors in vars files.

Incorrect variable type

Reports incorrect variable type.

Invalid block names

Reports invalid block labels or incorrect number of labels according to the schema.

Invalid string and number literal

Reports string and number invalid literals.

Missing required property

Reports blocks with missing required properties.

Suboptimal expression

Reports suboptimal HCL2 expressions and suggests simplifications.

Terraform isn't initialized

Reports if terraform was not initialized in the current working directory.

Unknown block type

Reports blocks with unknown type (first literal).

Unresolved module

Reports unresolved modules and suggests running terraform get to update the modules.




Operation argument type mismatch

Reports operations incorrect argument types.

Unavailable scope

Reports usage of unavailable scopes, e.g.

Unknown resource types referenced

Reports unknown (non-used in module) resource type usage.




Unresolved Markdown reference

Highlights unresolved references in Writerside XML topics as errors.

Http request



Inappropriate HTTP Protocol usage

Reports inappropriate usage of HTTP protocol keyword, e.g.




ActionUpdateThread is missing

Reports actions, action groups and other ActionUpdateThreadAware classes that implicitly state the deprecated and costly ActionUpdateThread.OLD_EDT mode.

Component/Action not registered

Reports plugin components and actions that are not registered in a plugin.xml descriptor.

Extension class should be final and non-public

Reports extension classes that are non-final or public.

JUnit API usage from multiple versions in a single TestCase

Reports JUnit annotated methods when used in a test case from a different JUnit version.

Light service must be final

Reports classes annotated with the @com.intellij.openapi.components.Service annotation that are not final.

Mismatch between light service level and its constructor

Reports mismatches between light service levels and its constructors.




'while' can be replaced with 'do while'

Reports while loops that could be more effectively written as do-while loops.

Copy of existing static method body

Reports fragments of Java code which are identical to the existing static methods suggesting to reuse these static methods.

Empty '' file

Reports an empty file, indicating unresolved module dependencies.

Expected exception never thrown in test method body

Reports checked exceptions expected by a JUnit 4 test-method that are never thrown inside the method body.

Explicit class declaration can be converted into implicitly declared class

Reports ordinary classes, which can be converted into implicitly declared classes Example: public class Sample { public static void main(String[] args) { System.out.println("Hello, world!"); } } After the quick-fix is applied: public static void main(String[] args) { System.out.println("Hello, world!"); }.

Implicitly declared class can be replaced with ordinary class

Reports implicitly declared classes and suggests replacing them with regular classes.

Injection Annotation not applicable

Reports when a @Language annotation is applied to an element with a type other than String or String[].

Java annotator

Allows viewing the problems reported by the Java annotator: compilation problems, unresolved by IDEA references, and so on.

Java sanity

Reports unresolved references in Java code.

Language mismatch

Reports when the language of a reference does not match the expected language of the usage context.

Mapping call before count()

Reports redundant Stream API calls like map(), or boxed() right before the count() call.

Missorted imports

Reports import statements which are not arranged according to the current code style (see Settings|Editor|Code Style).

Multiple exceptions declared on test method

Reports JUnit test method throws clauses with more than one exception.

Non-annotated Method overrides @Pattern Method

Reports when a method without any @Pattern annotation overrides a @Pattern annotated method.

Old style JUnit test method in JUnit 4 class

Reports JUnit 3 style test methods that are located inside a class that does not extend the JUnit 3 TestCase class and contains JUnit 4 or JUnit 5 @Test annotated methods.

Parameterized test class without data provider method

Reports JUnit 4 parameterized test classes that are annotated with @RunWith(Parameterized.class) but either do not include a data provider method annotated with @Parameterized.Parameters or this method has an incorrect signature.

Pattern Annotation not applicable

Reports when a @Pattern annotation is applied to an element with a type other than String.

Standard 'hashCode()' method can be used

Reports bitwise operations that can be replaced with a call to the Long.hashCode() or Double.hashCode() methods.

Unknown Language ID

Reports when the ID of the language used in a @Language annotation is unknown.

Unreachable code

Reports the code which is never reached according to data flow analysis.

Usage of obsolete 'junit.framework.Assert' method

Reports any calls to methods from the junit.framework.Assert class.

Using PsiElement string representation to generate new expression is incorrect

Reports direct usage of PsiElement and PsiType in strings.

Using static import for lombok generated methods

Reports usages of static imports for Lombok's generated methods.

Validate annotated patterns

Reports expressions passed as arguments for @Pattern parameters and returned from @Pattern-annotated methods that do not match the specified pattern.




Missed locally stored library for HTTP link

Reports missed locally stored library.

Module is not installed in importmap

Reports not installed module and suggests to run "importmap:require" or "importmap:install" command.




Auth configuration validation

Reports Auth configuration the following problems in HTTP Client environment files: Missing properties in Auth configuration Auth/Security configuration placed in private environment file.

Missing request separator in JSON body

Reports possible requests in injected JSON body where request separator ### is missing.

Unknown inspection id in meta information

Reports unknown inspection ids in metaInformation.json files.

Unreal Engine json inspection





Companion object in extensions

Reports incorrect companion objects' usage in extensions.

Forbidden in suspend context method usage

Reports inappropriate usages of methods in Kotlin coroutines, which uses threading context (annotated with @RequiresBlockingContext).

Generate implementation

Reports absent of implementation for the entity.

Kotlin object registered as extension

Reports Kotlin objects that are registered as plugin extensions.

Kotlin sanity

Reports unresolved references in Kotlin code.

Obsolete version of entity implementation

Reports existence of the obsolete implementation for the entity.

Unsupported 'var' field in entity

Detects unsupported var fields in the inheritors of WorkspaceEntity interface Interface implementing WorkspaceEntity have to have only val fields because it's immutable.

Use ''

Reports usages of Process.waitFor() and Process.onExit() in coroutine context.

Uses of <code>{0}</code> should probably be replaced with more robust logging

Reports usages of print or println.




TargetFramework tag checks





Check dependency licenses

Check dependencies licenses for possible problems: missing or prohibited licenses, or other compliance issues.

Check module licenses

Check module licenses for possible problems: missing licenses or other compliance issues.

Check third party software list

Check project for possible problems: user's third party software list does not match the collected project metadata.

Possibly template file

Detects Terraform Template files without the standard extension (*.tftpl) that do not have an associated data language and suggests choosing one from the list of possible candidates.

Unresolved reference

Reports unresolved references.

Unsatisfied package requirements

Reports packages mentioned in requirements files (for example, requirements.txt or Pipfile) but not installed, or imported but not mentioned in requirements files.

Vulnerable imported dependency

Reports vulnerabilities in Gradle and Maven dependencies imported into your project.




Interprocedural analysis

Interprocedural summary-based static code analysis.




Assertion can be simplified

Reports assertion call to be replaced with more specific analogue.

Cannot infer DQL model class to enable completion

Reports $entityManager->createQueryBuilder()->from($model, $expr) when PhpStorm cannot resolve $model to a class.

Method is deprecated in PHPUnit 11

Reports calls to the PHPUnit test case methods that are removed in PHPUnit 11.

Symfony annotation can be replaced with attribute

Suggests replacing Symfony annotations with attributes.

Words in Pest dataset names should be separated by spaces

Reports invalid names for pest dataset cases.




Pointcut expression errors

Reports issues in AOP pointcut expressions.




Message format validation in properties files

Reports the following MessageFormat problems in property values: Unknown format types MessageFormat supports only these format types: number date time choice Other format types will be reported.




A byte literal contains a non-ASCII character

Reports characters in byte literals that are outside ASCII range.

Accessing a protected member of a class or a module

Reports cases when a protected member is accessed outside the class, a descendant of the class where it is defined, or a module.

An instance attribute is defined outside `__init__`

Reports a problem when instance attribute definition is outside __init__ method.

An invalid interpreter

Reports problems if there is no Python interpreter configured for the project or if the interpreter is invalid.

Assigning function calls that don't return anything

Reports cases when an assignment is done on a function that does not return anything.

Assignment can be replaced with augmented assignment

Reports assignments that can be replaced with augmented assignments.

Assignments to 'for' loop or 'with' statement parameter

Reports the cases when you rewrite a loop variable with an inner loop.

Attempt to call a non-callable object

Reports a problem when you are trying to call objects that are not callable, like, for example, properties:.

Check Python source code coverage

Reports methods, classes and files whose coverage is below a certain threshold.

Class has no `__init__` method

Reports cases in Python 2 when a class has no __init__ method, neither its parent classes.

Class must implement all abstract methods

Reports cases when not all abstract properties or methods are defined in a subclass.

Class-specific decorator is used outside the class

Reports usages of @classmethod or @staticmethod decorators in methods outside a class.

Classic style class usage

Reports classic style classes usage.

Code is incompatible with specific Python versions

Reports incompatibility with the specified versions of Python.

Deprecated function, class, or module

Reports usages of Python functions, or methods that are marked as deprecated and raise the DeprecationWarning or PendingDeprecationWarning warning.

Dictionary contains duplicate keys

Reports using the same value as the dictionary key twice.

Dictionary creation can be rewritten by dictionary literal

Reports situations when you can rewrite dictionary creation by using a dictionary literal.

Django ORM error

Reports several methods that may not be called due to some ORM reasons.

Errors in string formatting operations

Reports errors in string formatting operations.

Exceptions do not inherit from standard 'Exception' class

Reports cases when a custom exception class is raised but does not inherit from the builtin Exception class.

File contains non-ASCII character

Reports cases in Python 2 when a file contains non-ASCII characters and does not have an encoding declaration at the top.

First argument of the method is reassigned

Reports cases when the first parameter, such as self or cls, is reassigned in a method.

Fixture is not requested by test functions

Reports if a fixture is used without being passed to test function parameters or to @pytest.mark.usefixtures decorator.

Function call can be replaced with set literal

Reports calls to the set function that can be replaced with the set literal.

Global variable is not defined at the module level

Reports problems when a variable defined through the global statement is not defined in the module scope.

Improper first parameter

Reports methods that lack the first parameter that is usually named self.

Improper position of from __future__ import

Reports from __future__ import statements that are used not at the beginning of a file.

Inappropriate access to properties

Reports cases when properties are accessed inappropriately: Read-only properties are set Write-only properties are read Non-deletable properties are deleted Example: class MyClass: @property def read_only(self): return None def __write_only_setter(self, value): pass write_only = property(None, __write_only_setter) a = MyClass() a.read_only = 10 # property cannot be set del a.read_only # property cannot be deleted print(a.write_only) # property cannot be read.

Incompatible signatures of __new__ and __init__

Reports incompatible signatures of the __new__ and __init__ methods.

Incompatible stub packages

Reports stub packages that do not support the version of the corresponding runtime package.

Inconsistent indentation

Reports inconsistent indentation in Python source files when, for example, you use a mixture of tabs and spaces in your code.

Incorrect arguments in @pytest.mark.parametrize

Reports functions that are decorated with @pytest.mark.parametrize but do not have arguments to accept parameters of the decorator.

Incorrect call arguments

Reports discrepancies between declared parameters and actual arguments, as well as incorrect arguments, for example, duplicate named arguments, and incorrect argument order.

Incorrect docstring

Reports mismatched parameters in a docstring.

Incorrect property definition

Reports problems with the arguments of property() and functions annotated with @property.

Incorrect type

Reports type errors in function call expressions, targets, and return values.

Invalid TypedDict definition and usages

Reports invalid definition and usage of TypedDict.

Invalid definition and usage of Data Classes

Reports invalid definitions and usages of classes created with dataclasses or attr modules.

Invalid definition of 'typing.NamedTuple'

Reports invalid definition of a typing.NamedTuple.

Invalid protocol definitions and usages

Reports invalid definitions and usages of protocols introduced in PEP-544.

Invalid type hints definitions and usages

Reports invalid usages of type hints.

Invalid usage of ClassVar variables

Reports invalid usages of ClassVar annotations.

Invalid usage of new-style type parameters and type aliases

Reports invalid usage of PEP 695 type parameter syntax.

Invalid usages of @override decorator

Reports when a method decorated with @override doesn't have a matching method in its ancestor classes.

Invalid usages of classes with '__slots__' definitions

Reports invalid usages of a class with __slots__ definitions.

Invalid usages of final classes, methods, and variables

Reports invalid usages of final classes, methods and variables.

Method Series.to_list() is recommended

Reports redundant list in list(Series.values) statement for pandas and polars libraries.

Method is not declared static

Reports any methods that do not require a class instance creation and can be made static.

Method signature does not match signature of overridden method

Reports inconsistencies in overriding method signatures.

Missed call to '__init__' of the super class

Reports cases when a call to the super constructor in a class is missed.

Missing `await` syntax in coroutine calls

Reports coroutines that were called without using the await syntax.

Missing or empty docstring

Reports missing and empty docstrings.

Missing type hinting for function definition

Reports missing type hints for function declaration in one of the two formats: parameter annotations or a type comment.

No encoding specified for file

Reports a missing encoding comment in Python 2.

Non-optimal list declaration

Reports cases when a list declaration can be rewritten with a list literal.

Old-style class contains new-style class features

Reports occurrences of new-style class features in old-style classes.

Overloads in regular Python files

Reports cases when overloads in regular Python files are placed after the implementation or when their signatures are not compatible with the implementation.

PEP 8 coding style violation

Reports violations of the PEP 8 coding style guide by running the bundled tool.

PEP 8 naming convention violation

Reports violations of the PEP8 naming conventions.

Problematic nesting of decorators

Reports problems with nesting decorators.

Prohibited trailing semicolon in a statement

Reports trailing semicolons in statements.

Redeclared names without usages

Reports unconditional redeclarations of names without being used in between.

Redundant boolean variable check

Reports equality comparison with a boolean literal.

Redundant parentheses

Reports about redundant parentheses in expressions.

Shadowing built-in names

Reports shadowing built-in names, such as len or list.

Shadowing names from outer scopes

Reports shadowing names defined in outer scopes.

Single quoted docstring

Reports docstrings that do not adhere to the triple double-quoted string format.

Statement has no effect

Reports statements that have no effect.

Stub packages advertiser

Reports availability of stub packages.

Suspicious relative imports

Reports usages of relative imports inside plain directories, for example, directories neither containing nor explicitly marked as namespace packages.

The default argument is mutable

Reports a problem when a mutable value as a list or dictionary is detected in a default value for an argument.

The function argument is equal to the default parameter value

Reports a problem when an argument passed to the function is equal to the default parameter value.

Too complex chained comparisons

Reports chained comparisons that can be simplified.

Tuple assignment balance is incorrect

Reports cases when the number of expressions on the right-hand side and targets on the left-hand side are not the same.

Tuple item assignment is prohibited

Reports assignments to a tuple item.

Type in docstring does not match inferred type

Reports types in docstring that do not match dynamically inferred types.

Unbound local variables

Reports local variables referenced before assignment.

Unclear exception clauses

Reports exception clauses that do not provide specific information about the problem.

Unnecessary backslash

Reports backslashes in places where line continuation is implicit inside (), [], and {}.

Unresolved columns

Reports attempts to access PySpark DataFrame columns that do not exist in the schema.

Unused local symbols

Reports local variables, parameters, and functions that are locally defined, but not used name in a function.

Using equality operators to compare with None

Reports comparisons with None.

Vulnerable API usage

Reports usages of Vulnerable APIs of imported dependencies.

Wrong arguments to call super

Reports cases when any call to super(A, B) does not meet the following requirements:.

Wrong order of 'except' clauses

Reports cases when except clauses are not in the proper order, from the more specific to the more generic, or one exception class is caught twice.

__init__ method that returns a value

Reports occurrences of return statements with a return value inside __init__ methods of classes.




Requirement is not satisfied

Reports packages mentioned in requirements files (for example, requirements.txt, or dependencies section in pyproject.toml files) but not installed, or imported but not mentioned in requirements files.




Role is not defined

Reports undefined roles in reStructuredText files.




No template data language selected

Reports Terraform Template files with no data language selected.




Poetry package versions

Reports outdated versions of packages in [tool.poetry.dependencies] and [] sections of pyproject.toml.




'@RunWith' annotation already exists in a parent class

Reports when parent and child classes in a JUnit test hierarchy are annotated with @RunWith.

'ProcessCanceledException' handled incorrectly

Reports ProcessCanceledExceptions handled in an incorrect way.

'assertEquals()' called on array

Reports JUnit assertEquals() calls with arguments of an array type.

'assertEquals()' may be 'assertSame()'

Reports JUnit assertEquals() calls that can be replaced with an equivalent assertSame() call.

@PreFilter/@PreAuthorize/@PostFilter self-invocation method calls

Using @PreFilter/@PostFilter/@PreAuthorize: In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted.

A service can be converted to a light one

Reports classes that can be marked as light services using the @com.intellij.openapi.components.Service annotation instead of being registered as services in plugin.xml A service that is not intended for overriding is not required to be registered in the plugin.xml file.

Accessible context is missing

Reports Swing components that do not provide accessibility context.

Application service assigned to a static final field or immutable property

Reports assignments of application services to static final fields / immutable properties.

Calling method should be annotated with @RequiresBlockingContext

Highlights calls of method annotated with @RequiresBlockingMethod inside non-annotated method.

Cancellation check in loops

Reports loops, forEach-like methods, and ContainerUtil.process() with missing cancellation checks.

Check Kotlin and Java source code coverage

Reports methods and classes whose coverage is below a certain threshold.

Component type mismatch

Reports incorrect registration of plugin components (Actions and Components).

Eager creation of action presentation

Reports any actions that are registered in the plugin.xml file and instantiate the com.intellij.openapi.actionSystem.Presentation object in their constructors.

Extension registered as service/component

Reports extension implementation being additionally registered as a service/component.

Field blocks intention preview

Reports fields in LocalQuickFix and IntentionAction implementations that prevent intention preview action from functioning properly.

File.equals() usage

Reports usages of methods.

Incorrect parentDisposable parameter

Reports using Application or Project as a parent Disposable in plugin code.

Incorrect service retrieving

Reports the following problems when retrieving services: Attempts to retrieve an unregistered service.

Inspection description checker

Reports inspections that are missing an HTML description file, i.e.

Intention description checker

Reports intentions that are missing an HTML description file, before.template file or after.template file.

Invalid icon path in @Presentation

Reports invalid and deprecated value for icon attribute in com.intellij.ide.presentation.Presentation annotation.

JUnit 3 'super.tearDown()' is not called from 'finally' block

Reports calls of the JUnit 3's super.tearDown() method that are not performed inside a finally block.

JUnit 3 test can be JUnit 4

Reports JUnit 3 test classes that can be converted to JUnit 4 test classes.

JUnit 4 test can be JUnit 5

Reports JUnit 4 tests that can be automatically migrated to JUnit 5.

JUnit 5 obsolete assertions

Reports any calls to methods from the junit.framework.Assert, org.junit.Assert, or org.junit.Assume classes inside JUnit 5 tests.

JUnit assertion can be 'assertThat()' call

Reports calls to Assert.assertEquals(), Assert.assertTrue(), etc.

JUnit malformed declaration

Reports JUnit test member declarations that are malformed and are likely not recognized by the JUnit test framework.

JUnit test annotated with '@Ignore'/'@Disabled'

Reports usages of JUnit 4's @Ignore or JUnit 5's @Disabled annotations.

Listener implementation implements 'Disposable'

Reports listener implementations that implement com.intellij.openapi.Disposable.

Map key may leak

Reports using Language or FileType as a map key in plugin code.

Migrate to getOptionPane()

Reports createOptionsPanel() methods in inspection implementation, which can be automatically converted to getOptionsPane().

Non-default constructor in serializable class

Reports non-default constructor in serializable classes.

Non-default constructors for service and extension class

Reports extension/service class having a non-default (empty) constructor.

Non-distinguishable logging calls

Reports SLF4J, Log4j2 logging calls in one class, such as"message: {}", key) with similar log messages.

Non-platform TokenSet declared in ParserDefinition

Reports TokenSet field declarations referencing non-platform element types in ParserDefinition classes.

Postfix template description checker

Reports postfix templates missing an HTML description file, before.template file or after.template file.

QuickFix's getFamilyName() implementation must not depend on a specific context

Reports QuickFix#getFamilyName() using contextual information.

Simplifiable service retrieving

Reports service getting calls that can be replaced with a calls to an existing static getInstance() or getInstance(Project) methods.

Stateful extension

Reports extensions and quick-fixes holding potentially leaking state.

Static initialization in extension point implementations

Reports static initialization in extension point implementations.

Threading and concurrency problems

Reports threading and concurrency issues in code using information from com.intellij.util.concurrency.annotations annotations.

UElement as PsiElement usage

Reports usage of UAST UElement as PsiElement.

Undesirable class usage

Reports usages of undesirable classes (mostly Swing components).

Unresolved plugin configuration reference

Reports unresolved references to plugin configuration elements.

Unsafe VFS recursion

Reports usage of VirtualFile.getChildren() inside recursive methods.

Unsafe return statements visitor

Reports unsafe use of JavaRecursiveElementVisitor.visitReturnStatement().

Unspecified action place

Reports passing unspecified place parameter for ActionManager.createActionToolbar() and ActionManager.createActionPopupMenu().

Usage of IntelliJ API not available in older IDEs

Reports usages of IntelliJ Platform API introduced in a version newer than the one specified in <idea-version> @since-build in plugin.xml.

Use 'PluginId#equals(Object)'

Reports comparing PluginId instances using ==.

Use 'PsiType#equals(Object)' with primitive types

Reports comparing PsiPrimitiveType instances using ==.

Use 'VirtualFile#equals(Object)'

Reports comparing VirtualFile instances using ==.

Use DPI-aware borders

Reports usages of javax.swing.border.EmptyBorder and JBUI.Borders.emptyXyz() that can be simplified.

Use DPI-aware insets

Reports usages of java.awt.Insets and JBUI.insetsXyz() that can be simplified.

Use Darcula aware JBColor

Reports usages of java.awt.Color.

Using new Color(a,a,a)

Reports usages of java.awt.Color to create gray colors.




Extension class is a Kotlin object

Reports extensions which are instantiated by the IntelliJ Platform, but are declared as Kotlin objects.

Missing request separator in HTML/XML body

Reports possible requests in injected XML/HTML body where request separator ### is missing.

Plugin.xml dynamic plugin verification

Reports dynamic plugin problems.

Plugin.xml extension registration

Reports problems with extension registration in plugin.xml.

Plugin.xml i18n verification

Reports hardcoded texts in plugin.xml.

Plugin.xml text capitalization

Reports text capitalization problems in plugin.xml.

Plugin.xml validity

Reports problems in plugin.xml.

Unresolved references

Reports an unresolved references in XML.




Invalid OpenRewrite YAML recipe

Reports OpenRewrite YAML recipe problems.

Invalid action parameters

Reports the absence of mandatory parameters that do not have a default value for an action.

Missing request separator in YAML body

Reports possible requests in injected YAML body where request separator ### is missing.

Undefined action parameters

Reports the presence of parameters which are not defined in an action.

Undefined action reference

Detects unresolved action references in GitHub action and workflow files.

Last modified: 18 June 2024