azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

i18n: KtPsiFactory: add @NonNls to parameters

Browse Source
This commit is contained in:
Dmitry Gridin
2020-03-04 12:47:34 +07:00
parent 07861fdc6f
commit 2b8373447a
1 changed files with 88 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/psi/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt
+88 -78
View File
@@ -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<String>, typeElement: KtTypeElement): KtTypeAlias {
fun createTypeAlias(@NonNls name: String, typeParameters: List<String>, typeElement: KtTypeElement): KtTypeAlias {
return createTypeAlias(name, typeParameters, "X").apply { getTypeReference()!!.replace(createType(typeElement)) }
}
fun createTypeAlias(name: String, typeParameters: List<String>, body: String): KtTypeAlias {
fun createTypeAlias(@NonNls name: String, typeParameters: List<String>, @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<KtClass>("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<String>, isInterface: Boolean): ClassHeaderBuilder {
fun baseClass(@NonNls name: String, typeArguments: Collection<String>, 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<KtNamedFunction>("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<PsiComment>()
val comment = comments.single()