diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt index cb62428ec94..8c55721c4ac 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt @@ -30,7 +30,7 @@ fun KtPsiFactory(project: Project?, markGenerated: Boolean = true): KtPsiFactory fun KtPsiFactory(elementForProject: PsiElement, markGenerated: Boolean = true): KtPsiFactory = KtPsiFactory(elementForProject.project, markGenerated) -private val DO_NOT_ANALYZE_NOTIFICATION = "This file was created by KtPsiFactory and should not be analyzed\n" + +private const val DO_NOT_ANALYZE_NOTIFICATION = "This file was created by KtPsiFactory and should not be analyzed\n" + "Use createAnalyzableFile to create file that can be analyzed\n" var KtFile.doNotAnalyze: String? by UserDataProperty(Key.create("DO_NOT_ANALYZE")) @@ -54,7 +54,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return property.valOrVarKeyword } - private fun doCreateExpression(text: String): KtExpression? { + private fun doCreateExpression(@NonNls text: String): KtExpression? { //NOTE: '\n' below is important - some strange code indenting problems appear without it return createProperty("val x =\n$text").initializer } @@ -67,7 +67,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return expression } - fun createExpressionIfPossible(text: String): KtExpression? { + fun createExpressionIfPossible(@NonNls text: String): KtExpression? { val expression = doCreateExpression(text) ?: return null return if (expression.text == text) expression else null } @@ -75,22 +75,22 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m fun createThisExpression() = (createExpression("this.x") as KtQualifiedExpression).receiverExpression as KtThisExpression - fun createThisExpression(qualifier: String) = + fun createThisExpression(@NonNls qualifier: String) = (createExpression("this@$qualifier.x") as KtQualifiedExpression).receiverExpression as KtThisExpression - fun createCallArguments(text: String): KtValueArgumentList { + fun createCallArguments(@NonNls text: String): KtValueArgumentList { val property = createProperty("val x = foo $text") return (property.initializer as KtCallExpression).valueArgumentList!! } - fun createTypeArguments(text: String): KtTypeArgumentList { + fun createTypeArguments(@NonNls text: String): KtTypeArgumentList { val property = createProperty("val x = foo$text()") return (property.initializer as KtCallExpression).typeArgumentList!! } - fun createTypeArgument(text: String) = createTypeArguments("<$text>").arguments.first() + fun createTypeArgument(@NonNls text: String) = createTypeArguments("<$text>").arguments.first() - fun createType(type: String): KtTypeReference { + fun createType(@NonNls type: String): KtTypeReference { val typeReference = createTypeIfPossible(type) if (typeReference == null || typeReference.text != type) { throw IllegalArgumentException("Incorrect type: $type") @@ -100,7 +100,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m fun createType(typeElement: KtTypeElement) = createType("X").apply { this.typeElement!!.replace(typeElement) } - fun createTypeIfPossible(type: String): KtTypeReference? { + fun createTypeIfPossible(@NonNls type: String): KtTypeReference? { val typeReference = createProperty("val x : $type").typeReference return if (typeReference?.text == type) typeReference else null } @@ -114,11 +114,11 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m .apply { this.typeReference!!.replace(typeReference) } } - fun createTypeAlias(name: String, typeParameters: List, typeElement: KtTypeElement): KtTypeAlias { + fun createTypeAlias(@NonNls name: String, typeParameters: List, typeElement: KtTypeElement): KtTypeAlias { return createTypeAlias(name, typeParameters, "X").apply { getTypeReference()!!.replace(createType(typeElement)) } } - fun createTypeAlias(name: String, typeParameters: List, body: String): KtTypeAlias { + fun createTypeAlias(@NonNls name: String, typeParameters: List, @NonNls body: String): KtTypeAlias { val typeParametersText = if (typeParameters.isNotEmpty()) typeParameters.joinToString(prefix = "<", postfix = ">") else "" return createDeclaration("typealias $name$typeParametersText = $body") } @@ -157,7 +157,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createWhiteSpace(" ") } - fun createWhiteSpace(text: String): PsiElement { + fun createWhiteSpace(@NonNls text: String): PsiElement { return createProperty("val${text}x: Int").findElementAt(3)!! } @@ -174,7 +174,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createDeclaration(text) } - fun createObject(text: String): KtObjectDeclaration { + fun createObject(@NonNls text: String): KtObjectDeclaration { return createDeclaration(text) } @@ -182,23 +182,23 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createCompanionObject("companion object {\n}") } - fun createCompanionObject(text: String): KtObjectDeclaration { + fun createCompanionObject(@NonNls text: String): KtObjectDeclaration { return createClass("class A {\n $text\n}").companionObjects.first() } - fun createFileAnnotation(annotationText: String): KtAnnotationEntry { + fun createFileAnnotation(@NonNls annotationText: String): KtAnnotationEntry { return createFileAnnotationListWithAnnotation(annotationText).annotationEntries.first() } - fun createFileAnnotationListWithAnnotation(annotationText: String): KtFileAnnotationList { + fun createFileAnnotationListWithAnnotation(@NonNls annotationText: String): KtFileAnnotationList { return createFile("@file:$annotationText").fileAnnotationList!! } - fun createFile(text: String): KtFile { + fun createFile(@NonNls text: String): KtFile { return createFile("dummy.kt", text) } - private fun doCreateFile(fileName: String, text: String): KtFile { + private fun doCreateFile(@NonNls fileName: String, @NonNls text: String): KtFile { return PsiFileFactory.getInstance(project).createFileFromText( fileName, KotlinFileType.INSTANCE, @@ -209,7 +209,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m ) as KtFile } - fun createFile(fileName: String, text: String): KtFile { + fun createFile(@NonNls fileName: String, @NonNls text: String): KtFile { val file = doCreateFile(fileName, text) file.doNotAnalyze = DO_NOT_ANALYZE_NOTIFICATION @@ -217,19 +217,19 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return file } - fun createAnalyzableFile(fileName: String, text: String, contextToAnalyzeIn: PsiElement): KtFile { + fun createAnalyzableFile(@NonNls fileName: String, @NonNls text: String, contextToAnalyzeIn: PsiElement): KtFile { val file = doCreateFile(fileName, text) file.analysisContext = contextToAnalyzeIn return file } - fun createFileWithLightClassSupport(fileName: String, text: String, contextToAnalyzeIn: PsiElement): KtFile { + fun createFileWithLightClassSupport(@NonNls fileName: String, @NonNls text: String, contextToAnalyzeIn: PsiElement): KtFile { val file = createPhysicalFile(fileName, text) file.analysisContext = contextToAnalyzeIn return file } - fun createPhysicalFile(fileName: String, text: String): KtFile { + fun createPhysicalFile(@NonNls fileName: String, @NonNls text: String): KtFile { return PsiFileFactory.getInstance(project).createFileFromText( fileName, KotlinFileType.INSTANCE, @@ -239,18 +239,24 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m ) as KtFile } - fun createProperty(modifiers: String?, name: String, type: String?, isVar: Boolean, initializer: String?): KtProperty { + fun createProperty( + @NonNls modifiers: String?, + @NonNls name: String, + @NonNls type: String?, + isVar: Boolean, + @NonNls initializer: String? + ): KtProperty { val text = modifiers.let { "$it " } + (if (isVar) " var " else " val ") + name + - (if (type != null) ":" + type else "") + (if (initializer == null) "" else " = " + initializer) + (if (type != null) ":$type" else "") + (if (initializer == null) "" else " = $initializer") return createProperty(text) } - fun createProperty(name: String, type: String?, isVar: Boolean, initializer: String?): KtProperty { + fun createProperty(@NonNls name: String, @NonNls type: String?, isVar: Boolean, @NonNls initializer: String?): KtProperty { return createProperty(null, name, type, isVar, initializer) } - fun createProperty(name: String, type: String?, isVar: Boolean): KtProperty { + fun createProperty(@NonNls name: String, @NonNls type: String?, isVar: Boolean): KtProperty { return createProperty(name, type, isVar, null) } @@ -281,7 +287,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m bodyExpression.replace(expression) return setter } - + fun createPropertyDelegate(expression: KtExpression): KtPropertyDelegate { val property = createProperty("val x by lazy { 1 }") val delegate = property.delegate!! @@ -290,11 +296,11 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return delegate } - fun createDestructuringDeclaration(text: String): KtDestructuringDeclaration { + fun createDestructuringDeclaration(@NonNls text: String): KtDestructuringDeclaration { return createFunction("fun foo() {$text}").bodyBlockExpression!!.statements.first() as KtDestructuringDeclaration } - fun createDestructuringParameter(text: String): KtParameter { + fun createDestructuringParameter(@NonNls text: String): KtParameter { val dummyFun = createFunction("fun foo() = { $text -> }") return (dummyFun.bodyExpression as KtLambdaExpression).functionLiteral.valueParameters.first() } @@ -312,19 +318,19 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return declarations.first() as TDeclaration } - fun createNameIdentifier(name: String) = createNameIdentifierIfPossible(name)!! + fun createNameIdentifier(@NonNls name: String) = createNameIdentifierIfPossible(name)!! - fun createNameIdentifierIfPossible(name: String) = createProperty(name, null, false).nameIdentifier + fun createNameIdentifierIfPossible(@NonNls name: String) = createProperty(name, null, false).nameIdentifier - fun createSimpleName(name: String): KtSimpleNameExpression { + fun createSimpleName(@NonNls name: String): KtSimpleNameExpression { return createProperty(name, null, false, name).initializer as KtSimpleNameExpression } - fun createOperationName(name: String): KtSimpleNameExpression { + fun createOperationName(@NonNls name: String): KtSimpleNameExpression { return (createExpression("0 $name 0") as KtBinaryExpression).operationReference } - fun createIdentifier(name: String): PsiElement { + fun createIdentifier(@NonNls name: String): PsiElement { return createSimpleName(name).getIdentifier()!! } @@ -332,9 +338,9 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createDeclaration(funDecl) } - fun createCallableReferenceExpression(text: String) = createExpression(text) as? KtCallableReferenceExpression + fun createCallableReferenceExpression(@NonNls text: String) = createExpression(text) as? KtCallableReferenceExpression - fun createSecondaryConstructor(decl: String): KtSecondaryConstructor { + fun createSecondaryConstructor(@NonNls decl: String): KtSecondaryConstructor { return createClass("class Foo {\n $decl \n}").secondaryConstructors.first() } @@ -342,8 +348,8 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createModifierList(modifier.value) } - fun createModifierList(text: String): KtModifierList { - return createProperty(text + " val x").modifierList!! + fun createModifierList(@NonNls text: String): KtModifierList { + return createProperty("$text val x").modifierList!! } fun createEmptyModifierList() = createModifierList(KtTokens.PRIVATE_KEYWORD).apply { firstChild.delete() } @@ -352,7 +358,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createModifierList(modifier.value).getModifier(modifier)!! } - fun createAnnotationEntry(text: String): KtAnnotationEntry { + fun createAnnotationEntry(@NonNls text: String): KtAnnotationEntry { val modifierList = createProperty(text + " val x").modifierList return modifierList!!.annotationEntries.first() } @@ -369,33 +375,33 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createClass("class A(){}").getBody()!! } - fun createParameter(text: String): KtParameter { + fun createParameter(@NonNls text: String): KtParameter { return createClass("class A($text)").primaryConstructorParameters.first() } - fun createLoopParameter(text: String): KtParameter { + fun createLoopParameter(@NonNls text: String): KtParameter { return (createExpression("for ($text in list) {}") as KtForExpression).loopParameter!! } - fun createParameterList(text: String): KtParameterList { + fun createParameterList(@NonNls text: String): KtParameterList { return createFunction("fun foo$text{}").valueParameterList!! } - fun createTypeParameterList(text: String) = createClass("class Foo$text").typeParameterList!! + fun createTypeParameterList(@NonNls text: String) = createClass("class Foo$text").typeParameterList!! - fun createTypeParameter(text: String) = createTypeParameterList("<$text>").parameters.first()!! + fun createTypeParameter(@NonNls text: String) = createTypeParameterList("<$text>").parameters.first()!! - fun createLambdaParameterListIfAny(text: String) = + fun createLambdaParameterListIfAny(@NonNls text: String) = createLambdaExpression(text, "0").functionLiteral.valueParameterList - fun createLambdaParameterList(text: String) = createLambdaParameterListIfAny(text)!! + fun createLambdaParameterList(@NonNls text: String) = createLambdaParameterListIfAny(text)!! - fun createLambdaExpression(parameters: String, body: String): KtLambdaExpression = + fun createLambdaExpression(@NonNls parameters: String, @NonNls body: String): KtLambdaExpression = (if (parameters.isNotEmpty()) createExpression("{ $parameters -> $body }") else createExpression("{ $body }")) as KtLambdaExpression - fun createEnumEntry(text: String): KtEnumEntry { + fun createEnumEntry(@NonNls text: String): KtEnumEntry { return createDeclaration("enum class E {$text}").declarations[0] as KtEnumEntry } @@ -403,7 +409,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return createEnumEntry("Entry()").initializerList!! } - fun createWhenEntry(entryText: String): KtWhenEntry { + fun createWhenEntry(@NonNls entryText: String): KtWhenEntry { val function = createFunction("fun foo() { when(12) { $entryText } }") val whenEntry = PsiTreeUtil.findChildOfType(function, KtWhenEntry::class.java) @@ -413,7 +419,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return whenEntry } - fun createWhenCondition(conditionText: String): KtWhenCondition { + fun createWhenCondition(@NonNls conditionText: String): KtWhenCondition { val whenEntry = createWhenEntry("$conditionText -> {}") return whenEntry.conditions[0] } @@ -424,17 +430,17 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return stringTemplateExpression.entries[0] as KtStringTemplateEntryWithExpression } - fun createSimpleNameStringTemplateEntry(name: String): KtSimpleNameStringTemplateEntry { + fun createSimpleNameStringTemplateEntry(@NonNls name: String): KtSimpleNameStringTemplateEntry { val stringTemplateExpression = createExpression("\"\$$name\"") as KtStringTemplateExpression return stringTemplateExpression.entries[0] as KtSimpleNameStringTemplateEntry } - fun createLiteralStringTemplateEntry(literal: String): KtLiteralStringTemplateEntry { + fun createLiteralStringTemplateEntry(@NonNls literal: String): KtLiteralStringTemplateEntry { val stringTemplateExpression = createExpression("\"$literal\"") as KtStringTemplateExpression return stringTemplateExpression.entries[0] as KtLiteralStringTemplateEntry } - fun createStringTemplate(content: String) = createExpression("\"$content\"") as KtStringTemplateExpression + fun createStringTemplate(@NonNls content: String) = createExpression("\"$content\"") as KtStringTemplateExpression fun createPackageDirective(fqName: FqName): KtPackageDirective { return createFile("package ${fqName.asString()}").packageDirective!! @@ -482,28 +488,28 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m fun createClassKeyword(): PsiElement = createClass("class A").getClassKeyword()!! - fun createPrimaryConstructor(text: String = ""): KtPrimaryConstructor { + fun createPrimaryConstructor(@NonNls text: String = ""): KtPrimaryConstructor { return createClass(if (text.isNotEmpty()) "class A $text" else "class A()").primaryConstructor!! } - fun createPrimaryConstructorWithModifiers(modifiers: String?): KtPrimaryConstructor { + fun createPrimaryConstructorWithModifiers(@NonNls modifiers: String?): KtPrimaryConstructor { return modifiers?.let { createPrimaryConstructor("$it constructor()") } ?: createPrimaryConstructor() } fun createConstructorKeyword(): PsiElement = createClass("class A constructor()").primaryConstructor!!.getConstructorKeyword()!! - fun createLabeledExpression(labelName: String): KtLabeledExpression = createExpression("$labelName@ 1") as KtLabeledExpression + fun createLabeledExpression(@NonNls labelName: String): KtLabeledExpression = createExpression("$labelName@ 1") as KtLabeledExpression - fun createTypeCodeFragment(text: String, context: PsiElement?): KtTypeCodeFragment { + fun createTypeCodeFragment(@NonNls text: String, context: PsiElement?): KtTypeCodeFragment { return KtTypeCodeFragment(project, "fragment.kt", text, context) } - fun createExpressionCodeFragment(text: String, context: PsiElement?): KtExpressionCodeFragment { + fun createExpressionCodeFragment(@NonNls text: String, context: PsiElement?): KtExpressionCodeFragment { return KtExpressionCodeFragment(project, "fragment.kt", text, null, context) } - fun createBlockCodeFragment(text: String, context: PsiElement?): KtBlockCodeFragment { + fun createBlockCodeFragment(@NonNls text: String, context: PsiElement?): KtBlockCodeFragment { return KtBlockCodeFragment(project, "fragment.kt", text, null, context) } @@ -540,17 +546,17 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return argumentList.arguments.single() } - fun createArgument(text: String) = createCallArguments("($text)").arguments.first()!! + fun createArgument(@NonNls text: String) = createCallArguments("($text)").arguments.first()!! - fun createSuperTypeCallEntry(text: String): KtSuperTypeCallEntry { + fun createSuperTypeCallEntry(@NonNls text: String): KtSuperTypeCallEntry { return createClass("class A: $text").superTypeListEntries.first() as KtSuperTypeCallEntry } - fun createSuperTypeEntry(text: String): KtSuperTypeEntry { + fun createSuperTypeEntry(@NonNls text: String): KtSuperTypeEntry { return createClass("class A: $text").superTypeListEntries.first() as KtSuperTypeEntry } - fun creareDelegatedSuperTypeEntry(text: String): KtConstructorDelegationCall { + fun creareDelegatedSuperTypeEntry(@NonNls text: String): KtConstructorDelegationCall { val colonOrEmpty = if (text.isEmpty()) "" else ": " return createClass("class A { constructor()$colonOrEmpty$text {}").secondaryConstructors.first().getDelegationCall() } @@ -569,7 +575,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m private val sb = StringBuilder() private var state = State.MODIFIERS - fun modifier(modifier: String): ClassHeaderBuilder { + fun modifier(@NonNls modifier: String): ClassHeaderBuilder { assert(state == State.MODIFIERS) sb.append(modifier) @@ -589,7 +595,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m } - fun name(name: String): ClassHeaderBuilder { + fun name(@NonNls name: String): ClassHeaderBuilder { placeKeyword() sb.append(name) @@ -613,7 +619,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun baseClass(name: String, typeArguments: Collection, isInterface: Boolean): ClassHeaderBuilder { + fun baseClass(@NonNls name: String, typeArguments: Collection, isInterface: Boolean): ClassHeaderBuilder { assert(state == State.BASE_CLASS) sb.append(" : $name") @@ -722,7 +728,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun receiver(receiverType: String): CallableBuilder { + fun receiver(@NonNls receiverType: String): CallableBuilder { assert(state == State.RECEIVER) sb.append(receiverType).append(".") @@ -731,7 +737,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun name(name: String = CONSTRUCTOR_NAME): CallableBuilder { + fun name(@NonNls name: String = CONSTRUCTOR_NAME): CallableBuilder { assert(state == State.NAME || state == State.RECEIVER) assert(name != CONSTRUCTOR_NAME || target == Target.CONSTRUCTOR) @@ -748,7 +754,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun param(name: String, type: String, defaultValue: String? = null): CallableBuilder { + fun param(@NonNls name: String, @NonNls type: String, @NonNls defaultValue: String? = null): CallableBuilder { assert(target == Target.FUNCTION || target == Target.CONSTRUCTOR) assert(state == State.FIRST_PARAM || state == State.REST_PARAMS) @@ -766,7 +772,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun returnType(type: String): CallableBuilder { + fun returnType(@NonNls type: String): CallableBuilder { closeParams() sb.append(": ").append(type) @@ -790,7 +796,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun superDelegation(argumentList: String): CallableBuilder { + fun superDelegation(@NonNls argumentList: String): CallableBuilder { assert(state == State.TYPE_CONSTRAINTS && target == Target.CONSTRUCTOR) sb.append(": super").append(argumentList) @@ -799,7 +805,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun blockBody(body: String): CallableBuilder { + fun blockBody(@NonNls body: String): CallableBuilder { assert(state == State.BODY || state == State.TYPE_CONSTRAINTS) sb.append(bodyPrefix()).append(" {\n").append(body).append("\n}") @@ -808,7 +814,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun getterExpression(expression: String, breakLine: Boolean = true): CallableBuilder { + fun getterExpression(@NonNls expression: String, breakLine: Boolean = true): CallableBuilder { assert(target == Target.READ_ONLY_PROPERTY) assert(state == State.BODY || state == State.TYPE_CONSTRAINTS) @@ -818,7 +824,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun initializer(body: String): CallableBuilder { + fun initializer(@NonNls body: String): CallableBuilder { assert(target == Target.READ_ONLY_PROPERTY && (state == State.BODY || state == State.TYPE_CONSTRAINTS)) sb.append(" = ").append(body) @@ -827,7 +833,7 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m return this } - fun lazyBody(body: String): CallableBuilder { + fun lazyBody(@NonNls body: String): CallableBuilder { assert(target == Target.READ_ONLY_PROPERTY && (state == State.BODY || state == State.TYPE_CONSTRAINTS)) sb.append(" by kotlin.lazy {\n").append(body).append("\n}") @@ -847,17 +853,21 @@ class KtPsiFactory @JvmOverloads constructor(private val project: Project, val m } } - fun createBlock(bodyText: String): KtBlockExpression { + fun createBlock(@NonNls bodyText: String): KtBlockExpression { return createFunction("fun foo() {\n$bodyText\n}").bodyBlockExpression!! } - fun createSingleStatementBlock(statement: KtExpression, prevComment: String? = null, nextComment: String? = null): KtBlockExpression { + fun createSingleStatementBlock( + statement: KtExpression, + @NonNls prevComment: String? = null, + @NonNls nextComment: String? = null + ): KtBlockExpression { val prev = if (prevComment == null) "" else " $prevComment " val next = if (nextComment == null) "" else " $nextComment " return createDeclarationByPattern("fun foo() {\n$prev$0$next\n}", statement).bodyBlockExpression!! } - fun createComment(text: String): PsiComment { + fun createComment(@NonNls text: String): PsiComment { val file = createFile(text) val comments = file.children.filterIsInstance() val comment = comments.single()