> For the complete documentation index, see [llms.txt](https://docs.konsist.lemonappdev.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.konsist.lemonappdev.com/verifying-codebase/verify-properties.md).

# Verify Properties

Properties can be checked for proper access modifiers, type declarations, and initialization patterns.

To verify properties start by querying all properties present in the project:

```kotlin
Konsist
.scopeFromProject()
.properties()
...
```

In practical scenarios you'll typically want to verify a specific subset of properties - such as those defined inside classes:

```kotlin
Konsist
.scopeFromProject()
.classes()
.properties()
...
```

Konsist allows you to verify multiple aspects of properties. For the complete list of available APIs, explore `KoPropertyDeclaration` in your IDE (code completion and KDoc).

Let's look at a few examples.

## **Verify Name**

Property names can be validated to ensure they follow project naming conventions and patterns.

Check if `Boolean` property has name starting with `is`:

```kotlin
...
.filter { it.type?.name == "Boolean" }
.assertTrue { 
    it.hasNameStartingWith("is")
}
```

## **Verify Type**

Property types can be validated to ensure type safety and conventions:

```kotlin
...
.assertTrue { 
    it.type?.name == "LocalDateTime"
}
```

## **Verify Modifiers**

Property modifiers can be validated to ensure proper encapsulation:

```kotlin
...
.assertTrue { 
    it.hasLateinitModifier
}
```

## **Verify Annotations**

Property annotations can be verified for presence and correct usage:

```kotlin
...
.assertTrue { 
    it.hasAnnotationOf(JsonProperty::class)
}
```

## **Verify Accessors**

Getter and setter presence and implementation can be validated:

Check if property has `getter`:

```kotlin
...
.assertTrue { 
    it.hasGetter
}
```

Check if property has `setter`:

```kotlin
...
.assertTrue { 
    it.hasSetter
}
```

## **Verify Initialization**

Property initialization can be verified:

```kotlin
...
.assertTrue { 
    it.isInitialized
}
```

## **Verify Delegates**

Property delegates can be verified. Built-in delegate checks are available since Konsist `1.0.0-beta.1`.

Check if property has `lazy` delegate (matches `lazy { }`, `lazy<T> { }` and `lazy(mode) { }`):

```kotlin
...
.assertTrue { 
    it.hasLazyDelegate() 
}
```

Check if property has `lazy` delegate with a given thread safety mode (`lazy` without an explicit mode uses `LazyThreadSafetyMode.SYNCHRONIZED`):

```kotlin
...
.assertTrue { 
    it.hasLazyDelegate(LazyThreadSafetyMode.NONE) 
}
```

Check if property does not use `Delegates.observable` or `Delegates.vetoable` delegate:

```kotlin
Konsist
    .scopeFromProject()
    .properties()
    .withDelegate()
    .assertFalse { 
        it.hasObservableDelegate || it.hasVetoableDelegate 
    }
```

Check if `lazy` properties using `LazyThreadSafetyMode.NONE` or `LazyThreadSafetyMode.PUBLICATION` are `private`:

```kotlin
Konsist
    .scopeFromProject()
    .properties()
    .withLazyDelegate(LazyThreadSafetyMode.NONE, LazyThreadSafetyMode.PUBLICATION)
    .assertTrue { 
        it.hasPrivateModifier 
    }
```

Available built-in delegate checks and list filters:

| Member                         | List filters                                                            | Matches                                        |
| ------------------------------ | ----------------------------------------------------------------------- | ---------------------------------------------- |
| `hasLazyDelegate(mode)`        | `withLazyDelegate(vararg modes)`, `withoutLazyDelegate(vararg modes)`   | `lazy { }`, `lazy<T> { }`, `lazy(mode) { }`    |
| `hasObservableDelegate`        | `withObservableDelegate()`, `withoutObservableDelegate()`               | `Delegates.observable(...)`                    |
| `hasVetoableDelegate`          | `withVetoableDelegate()`, `withoutVetoableDelegate()`                   | `Delegates.vetoable(...)`                      |
| `hasNotNullDelegate`           | `withNotNullDelegate()`, `withoutNotNullDelegate()`                     | `Delegates.notNull()`                          |
| `hasPropertyReferenceDelegate` | `withPropertyReferenceDelegate()`, `withoutPropertyReferenceDelegate()` | `by ::otherProperty`, `by this::otherProperty` |

`withLazyDelegate()` with no modes keeps properties with any `lazy` delegate. With modes, it keeps properties whose `lazy` delegate uses any of the given modes. `withoutLazyDelegate(modes)` removes only those properties, so non-`lazy` properties are kept. Both filters also accept a `Collection<LazyThreadSafetyMode>`.

Custom delegates can be verified using `hasDelegate("delegateName")`.

{% hint style="info" %}
Delegate checks match the delegate text, not resolved types:

* `observable(...)`, `vetoable(...)` and `notNull()` imported directly (without the `Delegates.` prefix) are not detected.
* `by map` delegation is not supported by built-in checks - use `hasDelegate("map")`.
* `hasLazyDelegate(mode)` returns `false` when the mode is not a literal constant, e.g. `lazy(lock) { }` or `lazy(modeVariable) { }`. `hasLazyDelegate()` (no mode) still returns `true`. For the same reason `withLazyDelegate(modes)` drops and `withoutLazyDelegate(modes)` keeps such properties.
* Interface delegation (`class Foo : Bar by baz`) inherits these members. They are designed for property delegates. For interface delegates they check the delegate expression text the same way (usually `false`).
  {% endhint %}

## **Verify Explicit Backing Field**

Property [explicit backing field](https://kotlinlang.org/docs/properties.html) (`field = ...`) can be verified:

Check if property has explicit backing field:

```kotlin
...
.assertTrue { 
    it.hasExplicitBackingField
}
```

The explicit backing field declaration (`explicitBackingField`) provides access to its `type` (e.g. `field: MutableStateFlow<Int> = ...`), `tacitType` and `value`.

## **Verify Visibility**

Property visibility scope can be validated:

Check if property has `internal` modifier:

```kotlin
...
.assertTrue { 
    it.hasInternalModifier
}
```

## **Verify Mutability**

Property mutability can be checked.

Check if property is immutable:

```kotlin
...
.assertTrue { 
    it.isVal
}
```

Check if property is mutable:

```kotlin
...
.assertTrue { 
    it.isVar
}
```

Check if public property does not expose a mutable type (e.g. `MutableList`, `ArrayList`, `Array` or a class with a `var` property), including type arguments (e.g. `List<MutableList<String>>`):

```kotlin
Konsist
    .scopeFromProject()
    .properties()
    .withPublicOrDefaultModifier()
    .assertFalse {
        it.type?.isMutableType == true || it.type?.hasMutableTypeArgument == true
    }
```

Check if property in a data class has an immutable type (e.g. `String`, `List<String>`, `java.time.LocalDate` or a final project class without mutable properties):

```kotlin
Konsist
    .scopeFromProject()
    .classes()
    .withDataModifier()
    .properties()
    .assertTrue {
        it.type?.isImmutableType
    }
```

`isMutableType` and `isImmutableType` check only the type itself (for `List<MutableList<String>>` `isImmutableType` is `true`); use `hasMutableTypeArgument` and `hasImmutableTypeArgument` to check type arguments at any nesting level. Type aliases and import aliases are resolved to the type they point to. List filters are available: `withMutableType()`, `withImmutableType()`, `withMutableTypeArgument()`, `withImmutableTypeArgument()` and their `without...` counterparts.

{% hint style="info" %}
A type can be neither mutable nor immutable. When mutability cannot be determined, `isImmutableType` returns `false` (and `isMutableType` returns `false` unless the type itself is mutable), e.g. for type parameters (`T`), function types, external types not known to be immutable (e.g. `java.util.Date`), Kotlin types commonly implemented by mutable types (`Any`, `Comparable`, `CharSequence`, `Number`), and interfaces, open, abstract or sealed classes declared in the project. To verify that a type is not mutable, use `assertFalse { it.type?.isMutableType == true }` instead of checking `isImmutableType`.
{% endhint %}

## **Verify Context Parameters**

Property [context parameters](https://kotlinlang.org/docs/context-parameters.html) can be verified:

```kotlin
// Code Snippet
context(logger: Logger)
val Order.summary: String
    get() = ...
```

Check if property has no context parameters:

```kotlin
...
.assertFalse {
    it.hasContextParameters()
}
```

Check if property has `Logger` context parameter:

```kotlin
...
.assertTrue {
    it.hasContextParameter { contextParameter -> contextParameter.hasTypeOf(Logger::class) }
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.konsist.lemonappdev.com/verifying-codebase/verify-properties.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
