From 7de15ec2a849d614063c8bc73661a0496555a231 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Wed, 29 Oct 2014 16:45:48 +0300 Subject: [PATCH] J2K: singletons are back --- .../jetbrains/jet/j2k/AnnotationConverter.kt | 2 +- .../org/jetbrains/jet/j2k/CodeConverter.kt | 4 ++-- .../jetbrains/jet/j2k/ConstructorConverter.kt | 14 +++++------ j2k/src/org/jetbrains/jet/j2k/Converter.kt | 14 +++++------ .../jetbrains/jet/j2k/ExpressionConverter.kt | 4 ++-- .../jetbrains/jet/j2k/StatementConverter.kt | 6 ++--- .../org/jetbrains/jet/j2k/ast/Annotation.kt | 2 +- .../jet/j2k/ast/AnonymousClassBody.kt | 2 +- j2k/src/org/jetbrains/jet/j2k/ast/Block.kt | 2 +- .../org/jetbrains/jet/j2k/ast/Constructors.kt | 2 +- j2k/src/org/jetbrains/jet/j2k/ast/Element.kt | 23 +++++++++++++------ .../org/jetbrains/jet/j2k/ast/Expression.kt | 1 - .../org/jetbrains/jet/j2k/ast/Identifier.kt | 4 ++-- .../org/jetbrains/jet/j2k/ast/Initializer.kt | 6 ++++- j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt | 2 +- .../org/jetbrains/jet/j2k/ast/Statements.kt | 5 ++-- .../jetbrains/jet/j2k/ast/TypeParameters.kt | 4 ++-- .../FieldToPropertyProcessing.kt | 2 +- 18 files changed, 55 insertions(+), 44 deletions(-) diff --git a/j2k/src/org/jetbrains/jet/j2k/AnnotationConverter.kt b/j2k/src/org/jetbrains/jet/j2k/AnnotationConverter.kt index 6140cab447d..2ca1496e668 100644 --- a/j2k/src/org/jetbrains/jet/j2k/AnnotationConverter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/AnnotationConverter.kt @@ -31,7 +31,7 @@ class AnnotationConverter(private val converter: Converter) { private fun convertAnnotationsOnly(owner: PsiModifierListOwner): Annotations { val modifierList = owner.getModifierList() val annotations = modifierList?.getAnnotations()?.filter { it.getQualifiedName() !in annotationsToRemove } - if (annotations == null || annotations.isEmpty()) return Annotations.Empty() + if (annotations == null || annotations.isEmpty()) return Annotations.Empty val newLines = run { if (!modifierList!!.isInSingleLine()) { diff --git a/j2k/src/org/jetbrains/jet/j2k/CodeConverter.kt b/j2k/src/org/jetbrains/jet/j2k/CodeConverter.kt index 70c2ed91840..d863f0c4dbf 100644 --- a/j2k/src/org/jetbrains/jet/j2k/CodeConverter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/CodeConverter.kt @@ -68,7 +68,7 @@ class CodeConverter(public val converter: Converter, = CodeConverter(converter, expressionConverter, statementConverter, methodReturnType) public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean = true, statementFilter: (PsiStatement) -> Boolean = { true }): Block { - if (block == null) return Block.Empty() + if (block == null) return Block.Empty val lBrace = LBrace().assignPrototype(block.getLBrace()) val rBrace = RBrace().assignPrototype(block.getRBrace()) @@ -103,7 +103,7 @@ class CodeConverter(public val converter: Converter, } public fun convertExpression(expression: PsiExpression?, expectedType: PsiType?): Expression { - if (expression == null) return Identifier.Empty() + if (expression == null) return Identifier.Empty var convertedExpression = convertExpression(expression) if (expectedType == null || expectedType == PsiType.VOID) return convertedExpression diff --git a/j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt b/j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt index 7fe694949c4..7bdd8df2187 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt @@ -166,7 +166,7 @@ class ConstructorConverter(private val psiClass: PsiClass, val params = converter.convertParameterList(constructor.getParameterList()) val containingClass = constructor.getContainingClass() val typeParameterList = converter.convertTypeParameterList(containingClass?.getTypeParameterList()) - val factoryFunctionType = ClassType(ReferenceElement(containingClass?.declarationIdentifier() ?: Identifier.Empty(), typeParameterList.parameters).assignNoPrototype(), + val factoryFunctionType = ClassType(ReferenceElement(containingClass?.declarationIdentifier() ?: Identifier.Empty, typeParameterList.parameters).assignNoPrototype(), Nullability.NotNull, converter.settings).assignNoPrototype() @@ -254,7 +254,7 @@ class ConstructorConverter(private val psiClass: PsiClass, } } else { - { it -> Block.Empty() } + { it -> Block.Empty } } // we need to replace renamed parameter usages in base class constructor arguments and in default values @@ -359,11 +359,11 @@ class ConstructorConverter(private val psiClass: PsiClass, Parameter(property.identifier, property.type, varValModifier, property.annotations, property.modifiers.filter { it in ACCESS_MODIFIERS }).assignPrototypesFrom(property) } - val modifiers = Modifiers.Empty() + val modifiers = Modifiers.Empty //TODO: we can generate it private when secondary constructors are supported by Kotlin //val modifiers = Modifiers(listOf(Modifier.PRIVATE)).assignNoPrototype() val parameterList = ParameterList(parameters).assignNoPrototype() - val constructorSignature = PrimaryConstructorSignature(Annotations.Empty(), modifiers, parameterList).assignNoPrototype() + val constructorSignature = PrimaryConstructorSignature(Annotations.Empty, modifiers, parameterList).assignNoPrototype() val updatedMembers = classBody.members.filter { !propertiesToInitialize.contains(it) } return ClassBody(constructorSignature, classBody.baseClassParams, updatedMembers, classBody.classObjectMembers, classBody.factoryFunctions, classBody.lBrace, classBody.rBrace) } @@ -395,7 +395,7 @@ class ConstructorConverter(private val psiClass: PsiClass, statements[i] = ReturnStatement(constructorCall).assignNoPrototype() return statements } - val localVar = LocalVariable(tempValIdentifier(), Annotations.Empty(), Modifiers.Empty(), null, constructorCall, true).assignNoPrototype() + val localVar = LocalVariable(tempValIdentifier(), Annotations.Empty, Modifiers.Empty, null, constructorCall, true).assignNoPrototype() statements[i] = DeclarationStatement(listOf(localVar)).assignNoPrototype() statements.add(ReturnStatement(tempValIdentifier()).assignNoPrototype()) return statements @@ -439,8 +439,8 @@ class ConstructorConverter(private val psiClass: PsiClass, val initializer = MethodCallExpression.buildNotNull(null, className, arguments).assignNoPrototype() if (statements.isNotEmpty()) { val localVar = LocalVariable(tempValIdentifier(), - Annotations.Empty(), - Modifiers.Empty(), + Annotations.Empty, + Modifiers.Empty, null, initializer, true).assignNoPrototype() diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.kt b/j2k/src/org/jetbrains/jet/j2k/Converter.kt index e5a51853be2..ab37983a7dd 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.kt @@ -236,7 +236,7 @@ class Converter private(private val elementToConvert: PsiElement, annotationConverter.convertAnnotationMethodDefault(method)).assignPrototype(method, noBlankLinesInheritance) } val parameterList = ParameterList(parameters).assignNoPrototype() - val constructorSignature = PrimaryConstructorSignature(Annotations.Empty(), Modifiers.Empty(), parameterList).assignNoPrototype() + val constructorSignature = PrimaryConstructorSignature(Annotations.Empty, Modifiers.Empty, parameterList).assignNoPrototype() // to convert fields and nested types - they are not allowed in Kotlin but we convert them and let user refactor code var classBody = ClassBodyConverter(psiClass, this, false).convertBody() @@ -246,7 +246,7 @@ class Converter private(private val elementToConvert: PsiElement, return Class(psiClass.declarationIdentifier(), convertAnnotations(psiClass) + Annotations(listOf(annotationAnnotation)), convertModifiers(psiClass).without(Modifier.ABSTRACT), - TypeParameterList.Empty(), + TypeParameterList.Empty, listOf(), listOf(), listOf(), @@ -331,8 +331,8 @@ class Converter private(private val elementToConvert: PsiElement, for (parameter in method.getParameterList().getParameters()) { if (parameter.hasWriteAccesses(referenceSearcher, method)) { val variable = LocalVariable(parameter.declarationIdentifier(), - Annotations.Empty(), - Modifiers.Empty(), + Annotations.Empty, + Modifiers.Empty, null, parameter.declarationIdentifier(), false).assignNoPrototype() @@ -479,7 +479,7 @@ class Converter private(private val elementToConvert: PsiElement, public fun convertParameter(parameter: PsiParameter, nullability: Nullability = Nullability.Default, varValModifier: Parameter.VarValModifier = Parameter.VarValModifier.None, - modifiers: Modifiers = Modifiers.Empty(), + modifiers: Modifiers = Modifiers.Empty, defaultValue: DeferredElement? = null): Parameter { var type = typeConverter.convertVariableType(parameter) when (nullability) { @@ -491,7 +491,7 @@ class Converter private(private val elementToConvert: PsiElement, } public fun convertIdentifier(identifier: PsiIdentifier?): Identifier { - if (identifier == null) return Identifier.Empty() + if (identifier == null) return Identifier.Empty return Identifier(identifier.getText()!!).assignPrototype(identifier) } @@ -513,7 +513,7 @@ class Converter private(private val elementToConvert: PsiElement, val types = throwsList.getReferencedTypes() val refElements = throwsList.getReferenceElements() assert(types.size == refElements.size) - if (types.isEmpty()) return Annotations.Empty() + if (types.isEmpty()) return Annotations.Empty val arguments = types.indices.map { index -> val convertedType = typeConverter.convertType(types[index], Nullability.NotNull) null to deferredElement { MethodCallExpression.buildNotNull(null, "javaClass", listOf(), listOf(convertedType)).assignPrototype(refElements[index]) } diff --git a/j2k/src/org/jetbrains/jet/j2k/ExpressionConverter.kt b/j2k/src/org/jetbrains/jet/j2k/ExpressionConverter.kt index 07b2e13f59d..7257868138b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ExpressionConverter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ExpressionConverter.kt @@ -398,13 +398,13 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter { override fun visitSuperExpression(expression: PsiSuperExpression) { val psiQualifier = expression.getQualifier() val qualifier = psiQualifier?.getReferenceName() - result = SuperExpression(if (qualifier != null) Identifier(qualifier).assignPrototype(psiQualifier) else Identifier.Empty()) + result = SuperExpression(if (qualifier != null) Identifier(qualifier).assignPrototype(psiQualifier) else Identifier.Empty) } override fun visitThisExpression(expression: PsiThisExpression) { val psiQualifier = expression.getQualifier() val qualifier = psiQualifier?.getReferenceName() - result = ThisExpression(if (qualifier != null) Identifier(qualifier).assignPrototype(psiQualifier) else Identifier.Empty()) + result = ThisExpression(if (qualifier != null) Identifier(qualifier).assignPrototype(psiQualifier) else Identifier.Empty) } override fun visitTypeCastExpression(expression: PsiTypeCastExpression) { diff --git a/j2k/src/org/jetbrains/jet/j2k/StatementConverter.kt b/j2k/src/org/jetbrains/jet/j2k/StatementConverter.kt index 51cb8001628..e5bc7c769e4 100644 --- a/j2k/src/org/jetbrains/jet/j2k/StatementConverter.kt +++ b/j2k/src/org/jetbrains/jet/j2k/StatementConverter.kt @@ -65,7 +65,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter { override fun visitBreakStatement(statement: PsiBreakStatement) { if (statement.getLabelIdentifier() == null) { - result = BreakStatement(Identifier.Empty()) + result = BreakStatement(Identifier.Empty) } else { result = BreakStatement(converter.convertIdentifier(statement.getLabelIdentifier())) @@ -74,7 +74,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter { override fun visitContinueStatement(statement: PsiContinueStatement) { if (statement.getLabelIdentifier() == null) { - result = ContinueStatement(Identifier.Empty()) + result = ContinueStatement(Identifier.Empty) } else { result = ContinueStatement(converter.convertIdentifier(statement.getLabelIdentifier())) @@ -190,7 +190,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter { convertedType, Parameter.VarValModifier.None, annotations, - Modifiers.Empty()).assignPrototype(parameter) + Modifiers.Empty).assignPrototype(parameter) catches.add(CatchStatement(convertedParameter, blockConverted).assignNoPrototype()) } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Annotation.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Annotation.kt index 52a4d42a1f1..5c3e8ba9306 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Annotation.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Annotation.kt @@ -65,7 +65,7 @@ class Annotations(val annotations: List) : Element() { fun plus(other: Annotations) = Annotations(annotations + other.annotations).assignNoPrototype() class object { - fun Empty() = Annotations(listOf()) + val Empty = Annotations(listOf()) } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClassBody.kt b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClassBody.kt index 1c4fd847be3..2691210e640 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClassBody.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClassBody.kt @@ -19,7 +19,7 @@ package org.jetbrains.jet.j2k.ast import org.jetbrains.jet.j2k.CodeBuilder class AnonymousClassBody(body: ClassBody, val extendsTrait: Boolean) -: Class(Identifier.Empty(), Annotations.Empty(), Modifiers.Empty(), TypeParameterList.Empty(), listOf(), listOf(), listOf(), body) { +: Class(Identifier.Empty, Annotations.Empty, Modifiers.Empty, TypeParameterList.Empty, listOf(), listOf(), listOf(), body) { override fun generateCode(builder: CodeBuilder) { body.append(builder) } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt index 35a77d5e286..15b417ffe06 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Block.kt @@ -32,7 +32,7 @@ class Block(val statements: List, val lBrace: LBrace, val rBrace: RBr } class object { - fun Empty() = Block(listOf(), LBrace(), RBrace()) + val Empty = Block(listOf(), LBrace(), RBrace()) } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt index 5bfa163c0bc..f01a1000290 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt @@ -28,7 +28,7 @@ class PrimaryConstructor(annotations: Annotations, override fun generateCode(builder: CodeBuilder) { throw IncorrectOperationException() } public fun initializer(): Initializer - = Initializer(body, Modifiers.Empty()).assignPrototypesFrom(this, CommentsAndSpacesInheritance(commentsBefore = false)) + = Initializer(body, Modifiers.Empty).assignPrototypesFrom(this, CommentsAndSpacesInheritance(commentsBefore = false)) public fun createSignature(converter: Converter): PrimaryConstructorSignature { val signature = PrimaryConstructorSignature(annotations, modifiers, parameterList) diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt index 75fc1d3d6ea..558c61ee46a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Element.kt @@ -57,7 +57,18 @@ fun Element.canonicalCode(): String { } abstract class Element { - public open var prototypes: List? = null + public var prototypes: List? = null + set(value) { + // do not assign prototypes to singleton instances + if (canBeSingleton) { + $prototypes = listOf() + return + } + $prototypes = value + } + + protected open val canBeSingleton: Boolean + get() = isEmpty public var createdAt: String? = if (saveCreationStacktraces) @@ -75,7 +86,6 @@ abstract class Element { object Empty : Element() { override fun generateCode(builder: CodeBuilder) { } override val isEmpty: Boolean get() = true - override var prototypes: List? by EmptyElementPrototypes // to not hold references to psi } class object { @@ -83,11 +93,6 @@ abstract class Element { } } -object EmptyElementPrototypes { - public fun get(thisRef: Element, desc: PropertyMetadata): List? = null - public fun set(thisRef: Element, desc: PropertyMetadata, value: List?) { } -} - // this class should never be created directly - Converter.deferredElement() should be used! class DeferredElement( private var generator: (CodeConverter) -> TResult, @@ -100,6 +105,10 @@ class DeferredElement( assignNoPrototype() } + // need to override it to not use isEmpty + override val canBeSingleton: Boolean + get() = false + public fun unfold(codeConverter: CodeConverter) { assert(result == null) result = generator(codeConverter) diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt index 04705e34a3c..716178b0e20 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.kt @@ -25,6 +25,5 @@ abstract class Expression() : Statement() { object Empty : Expression() { override fun generateCode(builder: CodeBuilder) {} override val isEmpty: Boolean get() = true - override var prototypes: List? by EmptyElementPrototypes // to not hold references to psi } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt index 42d6dc9ba3e..b12a0b44099 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.kt @@ -22,7 +22,7 @@ import org.jetbrains.jet.j2k.CodeConverter fun PsiNameIdentifierOwner.declarationIdentifier(): Identifier { val name = getName() - return if (name != null) Identifier(name, false).assignPrototype(getNameIdentifier()!!) else Identifier.Empty() + return if (name != null) Identifier(name, false).assignPrototype(getNameIdentifier()!!) else Identifier.Empty } class Identifier( @@ -51,7 +51,7 @@ class Identifier( override fun toString() = if (isNullable) "$name?" else name class object { - fun Empty() = Identifier("") + val Empty = Identifier("") val ONLY_KOTLIN_KEYWORDS: Set = setOf( "package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This" diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt index 0aee67021ef..69ad466d3ac 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.kt @@ -18,11 +18,15 @@ package org.jetbrains.jet.j2k.ast import org.jetbrains.jet.j2k.* -class Initializer(val body: DeferredElement, modifiers: Modifiers) : Member(Annotations.Empty(), modifiers) { +class Initializer(val body: DeferredElement, modifiers: Modifiers) : Member(Annotations.Empty, modifiers) { override fun generateCode(builder: CodeBuilder) { builder.append(body) } override val isEmpty: Boolean get() = body.isEmpty + + // need to override it to not use isEmpty + override val canBeSingleton: Boolean + get() = false } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt index 2e0230b3183..27f6d277ddf 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.kt @@ -60,7 +60,7 @@ class Modifiers(val modifiers: Collection) : Element() { fun accessModifier(): Modifier? = modifiers.firstOrNull { it in ACCESS_MODIFIERS } class object { - fun Empty() = Modifiers(listOf()) + val Empty = Modifiers(listOf()) } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt index 435aedc2bf8..53239479901 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt @@ -23,7 +23,6 @@ abstract class Statement() : Element() { object Empty : Statement() { override fun generateCode(builder: CodeBuilder) { } override val isEmpty: Boolean get() = true - override var prototypes: List? by EmptyElementPrototypes // to not hold references to psi } } @@ -106,13 +105,13 @@ class ForeachStatement( } } -class BreakStatement(val label: Identifier = Identifier.Empty()) : Statement() { +class BreakStatement(val label: Identifier = Identifier.Empty) : Statement() { override fun generateCode(builder: CodeBuilder) { builder.append("break").appendWithPrefix(label, "@") } } -class ContinueStatement(val label: Identifier = Identifier.Empty()) : Statement() { +class ContinueStatement(val label: Identifier = Identifier.Empty) : Statement() { override fun generateCode(builder: CodeBuilder) { builder.append("continue").appendWithPrefix(label, "@") } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt index 8d539404bb5..49a27260a23 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt @@ -56,7 +56,7 @@ class TypeParameterList(val parameters: List) : Element() { private fun hasWhere(): Boolean = parameters.any { it.hasWhere() } class object { - fun Empty() = TypeParameterList(listOf()) + val Empty = TypeParameterList(listOf()) } } @@ -69,5 +69,5 @@ fun Converter.convertTypeParameterList(typeParameterList: PsiTypeParameterList?) return if (typeParameterList != null) TypeParameterList(typeParameterList.getTypeParameters()!!.toList().map { convertTypeParameter(it) }).assignPrototype(typeParameterList) else - TypeParameterList.Empty() + TypeParameterList.Empty } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/usageProcessing/FieldToPropertyProcessing.kt b/j2k/src/org/jetbrains/jet/j2k/usageProcessing/FieldToPropertyProcessing.kt index ad879b41803..447fc335d27 100644 --- a/j2k/src/org/jetbrains/jet/j2k/usageProcessing/FieldToPropertyProcessing.kt +++ b/j2k/src/org/jetbrains/jet/j2k/usageProcessing/FieldToPropertyProcessing.kt @@ -39,7 +39,7 @@ class FieldToPropertyProcessing(val field: PsiField, val propertyName: String, v if (refExpr.resolve() == null) identifier else - QualifiedExpression(ThisExpression(Identifier.Empty()).assignNoPrototype(), identifier) //TODO: this is not correct in case of nested/anonymous classes + QualifiedExpression(ThisExpression(Identifier.Empty).assignNoPrototype(), identifier) //TODO: this is not correct in case of nested/anonymous classes } } }