}

    private fun Fe10AnalysisContext.renderOrdinaryType(type: SimpleType, printer: PrettyPrinter) {
        val nestedType = KaFe10JvmTypeMapperContext.getNestedType(type)
        renderTypeSegment(nestedType.root, printer)
        printer.printCollectionIfNotEmpty(nestedType.nested, separator = ".", prefix = ".", postfix = "") {
            renderTypeSegment(it, printer)
        }
    }

     *
     * Example: to get `foo.bar` from `foo.bar.Baz.Inner`, you need to drop 2 qualifiers (`Inner` and `Baz`).
     */
    private fun countQualifiersToDrop(wholeType: KtUserType, nestedType: KtUserType): Int {
        val qualifierIndex = generateSequence(wholeType) { it.qualifier }.indexOf(nestedType)

        given:
        buildFile << """
            interface NestedType {
                @Input
                Property<String> getProp()
            }

            abstract class MyTask extends DefaultTask {
                @Nested
                abstract NestedType getNested()

                void nested(Action<NestedType> action) {
                    action.execute(nested)
                }

This pattern is useful when a custom type has a nested complex type which has the same lifecycle.
If the lifecycle is different, consider using `Property<NestedType>` instead.

Here is an example of a task type with a `resource` property.
The `Resource` type is also a custom Gradle type and defines some managed properties:

[source,java]
.Download.java
----

                private final ${testedType} mutableProperty = ${init};

                // getter and setter
                @InputFiles @PathSensitive(PathSensitivity.NONE)
                public ${testedType} getMutablePropertyWithSetter() { return mutableProperty; }
                public void setMutablePropertyWithSetter(${testedType} value) {}

                // just getter