.filter { declarationRenderer.typeParametersFilter.filter(analysisSession, it, symbol) }
                .ifEmpty { return }
            printer.printCollection(typeParameters, prefix = "<", postfix = ">") { typeParameter ->
                declarationRenderer.codeStyle.getSeparatorBetweenAnnotationAndOwner(analysisSession, typeParameter).separated(

    }

    @Override
    public void walkDir(Path rootDir, RelativePath rootPath, FileVisitor visitor, Spec<? super FileTreeElement> spec, AtomicBoolean stopFlag, boolean postfix) {
        try {
            PathVisitor pathVisitor = new PathVisitor(spec, postfix, visitor, stopFlag, rootPath, fileSystem);
            visit(rootDir, pathVisitor);
        } catch (IOException e) {

fun test(): Boolean {
    var n = 456
    <expr>n %= 45</expr>
    return n < 45
}

// IGNORE_FE10
// FE1.0 `isUsedAsExpression` considers built-in postfix inc/dec and

		e := dom.Succs[i]
		e.b.Preds[e.i].b = dom
	}

	// Try really hard to preserve statement marks attached to blocks.
	simplePos := simple.Pos
	postPos := post.Pos
	simpleStmt := simplePos.IsStmt() == src.PosIsStmt
	postStmt := postPos.IsStmt() == src.PosIsStmt

	for _, v := range simple.Values {
		v.Block = dom
	}
	for _, v := range post.Values {
		v.Block = dom
	}

            field += 45
        }

}

fun main() {
    val c = C()
    <expr>c.property -= 20</expr>
    println(C().property)
}

// IGNORE_FE10
// FE1.0 `isUsedAsExpression` considers built-in postfix inc/dec and

            val valueParameters = when (symbol) {
                is KaFunctionLikeSymbol -> symbol.valueParameters
                else -> return
            }
            printer.printCollection(valueParameters, prefix = "(", postfix = ")") {
                declarationRenderer.renderDeclaration(analysisSession, it, printer)
            }
        }
    }
}

            separator = ",\n  ",
            prefix = "{\n  ",
            postfix = "\n}"
        ) { (k, v) -> "${k?.let { stringRepresentation(it).indented() }} -> (${v?.let { stringRepresentation(it).indented() }})" }
        is Collection<*> -> if (isEmpty()) "[]" else joinToString(
            separator = ",\n  ",
            prefix = "[\n  ",
            postfix = "\n]"
        ) {

            annotationRenderer: KaAnnotationRenderer,
            printer: PrettyPrinter,
        ) {
            if (annotation.arguments.isEmpty()) return
            printer.printCollection(annotation.arguments, prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                append(KaAnnotationValueRenderer.render(argument.expression))
            }
        }
    }
}

        } else {
            type.simpleName
        }
        return if (type.arguments.isEmpty()) simpleName + nullableSuffix
        else simpleName + type.arguments.joinToString(separator = ", ", prefix = "<", postfix = ">") {
            when (val typeArgument = it.type) {
                null -> "*"
                else -> typeConversion(typeArgument)
            } + nullableSuffix
        }
    }
    print(typeConversion(type))

                        {
                            (symbol.getContainingSymbol() as? KaNamedSymbol)?.name?.let { printer.append(it.render()) }
                            printer.printCollection(symbol.valueParameters, prefix = "(", postfix = ")") {
                                declarationRenderer.typeRenderer.renderType(analysisSession, it.returnType, printer)
                            }
                        }
                    )
                }