From 5664283a3010668906c4d39dec6b2c831afee852 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Fri, 1 Jun 2012 15:37:15 +0200 Subject: [PATCH] comments processing finished --- src/org/jetbrains/jet/j2k/Converter.kt | 62 ++++++++++++------- src/org/jetbrains/jet/j2k/ast/Block.kt | 2 +- src/org/jetbrains/jet/j2k/ast/Class.kt | 8 +-- src/org/jetbrains/jet/j2k/ast/Constructor.kt | 3 +- src/org/jetbrains/jet/j2k/ast/EnumConstant.kt | 4 +- src/org/jetbrains/jet/j2k/ast/Field.kt | 4 +- src/org/jetbrains/jet/j2k/ast/Function.kt | 25 ++++---- src/org/jetbrains/jet/j2k/ast/Statements.kt | 24 +++---- .../jet/j2k/visitors/ElementVisitor.kt | 2 +- .../jet/j2k/visitors/ExpressionVisitor.kt | 6 +- .../jet/j2k/visitors/StatementVisitor.kt | 52 ++++++---------- tests/testData/ast/issues/file/comments.jav | 12 +++- tests/testData/ast/issues/file/comments.kt | 13 ++++ 13 files changed, 124 insertions(+), 93 deletions(-) diff --git a/src/org/jetbrains/jet/j2k/Converter.kt b/src/org/jetbrains/jet/j2k/Converter.kt index c7b3f0bebb2..0114bd8191a 100644 --- a/src/org/jetbrains/jet/j2k/Converter.kt +++ b/src/org/jetbrains/jet/j2k/Converter.kt @@ -93,21 +93,32 @@ public open class Converter() { } public open fun anonymousClassToAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass { - return AnonymousClass(this, getMembers(anonymousClass, false)) + return AnonymousClass(this, getMembers(anonymousClass)) } - private fun getMembers(psiClass: PsiClass, takeDocComments: Boolean): List { + private fun getMembers(psiClass: PsiClass): List { val members: List = arrayList() val lbraceOffset = psiClass.getLBrace()?.getTextRange()?.getStartOffset() ?: 0 for (e : PsiElement? in psiClass.getChildren()) { val isDocComment = e?.getTextRange()?.getStartOffset() ?: 0 < lbraceOffset - if (isDocComment != takeDocComments) continue + if (isDocComment) continue val converted = memberToMember(e, psiClass) if (converted != null) members.add(converted) } return members } + private fun getDocComments(element: PsiElement): List { + val comments: List = arrayList() + val textOffset = element.getTextOffset() + for (e : PsiElement? in element.getChildren()) { + if (e is PsiComment && e.getTextRange()?.getStartOffset() ?: 0 < textOffset) { + comments.add(Comment(e.getText()!!)); + } + } + return comments + } + private fun memberToMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) { is PsiMethod -> methodToFunction(e, true) is PsiField -> fieldToField(e, containingClass) @@ -125,8 +136,8 @@ public open class Converter() { val extendsTypes: List = typesToNotNullableTypeList(psiClass.getExtendsListTypes()) val name: Identifier = Identifier(psiClass.getName()!!) val baseClassParams: List = arrayList() - val members: List = getMembers(psiClass, false) - val docComments = getMembers(psiClass, true) + val members: List = getMembers(psiClass) + val docComments = getDocComments(psiClass) val visitor: SuperVisitor = SuperVisitor() psiClass.accept(visitor) val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters @@ -146,8 +157,8 @@ public open class Converter() { val init: String = getDefaultInitializer(fo) initializers.put(fo.identifier.toKotlin(), init) } - val newStatements: List = arrayList() - for (s : Statement? in m.block!!.statements) { + val newStatements: List = arrayList() + for (s in m.block!!.statements) { var isRemoved: Boolean = false if (s is AssignmentExpression) { val assignee = s.left @@ -165,7 +176,7 @@ public open class Converter() { } if (!isRemoved) { - newStatements.add(s!!) + newStatements.add(s) } } @@ -174,7 +185,7 @@ public open class Converter() { } } } - members.add(Constructor(Identifier.EMPTY_IDENTIFIER, Collections.emptySet()!!, + members.add(Constructor(Identifier.EMPTY_IDENTIFIER, arrayList(), Collections.emptySet()!!, ClassType(name, Collections.emptyList()!!, false), Collections.emptyList()!!, ParameterList(createParametersFromFields(finalOrWithEmptyInitializer)), @@ -203,14 +214,17 @@ public open class Converter() { private fun fieldToField(field: PsiField, psiClass: PsiClass?): Field { val modifiers: Set = modifiersListToModifiersSet(field.getModifierList()) - if (field is PsiEnumConstant?) { + val docComments = getDocComments(field) + if (field is PsiEnumConstant) { return EnumConstant(Identifier(field.getName()!!), + docComments, modifiers, typeToType(field.getType()), elementToElement(field.getArgumentList())) } return Field(Identifier(field.getName()!!), + docComments, modifiers, typeToType(field.getType()), expressionToExpression(field.getInitializer(), field.getType()), @@ -237,8 +251,9 @@ public open class Converter() { blockToBlock(method.getBody(), notEmpty)) val params: Element = createFunctionParameters(method) - val typeParameters: List = elementsToElementList(method.getTypeParameters()) - val modifiers: Set = modifiersListToModifiersSet(method.getModifierList()) + val typeParameters = elementsToElementList(method.getTypeParameters()) + val modifiers = modifiersListToModifiersSet(method.getModifierList()) + val docComments = getDocComments(method) if (isOverrideAnyMethodExceptMethodsFromObject(method)) { modifiers.add(Modifier.OVERRIDE) } @@ -254,10 +269,11 @@ public open class Converter() { if (method.isConstructor()) { val isPrimary: Boolean = isConstructorPrimary(method) - return Constructor(identifier, modifiers, returnType, typeParameters, params, Block(removeEmpty(body.statements), false), isPrimary) + return Constructor(identifier, docComments, modifiers, returnType, typeParameters, params, + Block(removeEmpty(body.statements), false), isPrimary) } - return Function(identifier, modifiers, returnType, typeParameters, params, body) + return Function(identifier, docComments, modifiers, returnType, typeParameters, params, body) } private fun createFunctionParameters(method: PsiMethod): ParameterList { @@ -303,22 +319,22 @@ public open class Converter() { if (block == null) return Block.EMPTY_BLOCK - return Block(statementsToStatementList(block.getStatements()), notEmpty) + return Block(block.getChildren().map { statementToStatement(it) }, notEmpty) } public open fun blockToBlock(block: PsiCodeBlock?): Block { return blockToBlock(block, true) } - public open fun statementsToStatementList(statements: Array): List { + public open fun statementsToStatementList(statements: Array): List { return statements.map { statementToStatement(it) } } - public open fun statementsToStatementList(statements: List): List { + public open fun statementsToStatementList(statements: List): List { return statements.map { statementToStatement(it) } } - public open fun statementToStatement(s: PsiStatement?): Statement { + public open fun statementToStatement(s: PsiElement?): Element { if (s == null) return Statement.EMPTY_STATEMENT @@ -487,8 +503,8 @@ public open class Converter() { return fields.map { Parameter(Identifier("_" + it.identifier.name), it.`type`, true) } } - private fun createInitStatementsFromFields(fields: List): List { - val result: List = arrayList() + private fun createInitStatementsFromFields(fields: List): List { + val result: List = arrayList() for (f : Field in fields) { val identifierToKotlin: String? = f.identifier.toKotlin() result.add(DummyStringExpression(identifierToKotlin + " = " + "_" + identifierToKotlin)) @@ -545,8 +561,10 @@ public open class Converter() { return false } - private fun removeEmpty(statements: List): List { - return statements.filterNot { it == Statement.EMPTY_STATEMENT || it == Expression.EMPTY_EXPRESSION } + private fun removeEmpty(statements: List): List { + return statements.filterNot { it == Statement.EMPTY_STATEMENT || + it == Expression.EMPTY_EXPRESSION || + it == Element.EMPTY_ELEMENT } } private fun isNotOpenMethod(method: PsiMethod): Boolean { diff --git a/src/org/jetbrains/jet/j2k/ast/Block.kt b/src/org/jetbrains/jet/j2k/ast/Block.kt index 1c4c1f598fc..37a950fb356 100644 --- a/src/org/jetbrains/jet/j2k/ast/Block.kt +++ b/src/org/jetbrains/jet/j2k/ast/Block.kt @@ -3,7 +3,7 @@ package org.jetbrains.jet.j2k.ast import java.util.LinkedList import java.util.List -public open class Block(val statements: List, val notEmpty: Boolean = false): Statement() { +public open class Block(val statements: List, val notEmpty: Boolean = false): Statement() { public override fun isEmpty(): Boolean { return !notEmpty && statements.size() == 0 } diff --git a/src/org/jetbrains/jet/j2k/ast/Class.kt b/src/org/jetbrains/jet/j2k/ast/Class.kt index 739671afca3..4ccc1762d34 100644 --- a/src/org/jetbrains/jet/j2k/ast/Class.kt +++ b/src/org/jetbrains/jet/j2k/ast/Class.kt @@ -62,13 +62,13 @@ public open class Class(converter : Converter, private fun constructorToInit(f: Function): Function { val modifiers : Set = HashSet(f.getModifiers()) modifiers.add(Modifier.STATIC) - val statements : List = f.block?.statements ?: arrayList() + val statements : List = f.block?.statements ?: arrayList() statements.add(ReturnStatement(Identifier("__"))) - val block : Block = Block(statements) + val block = Block(statements) val constructorTypeParameters : List = arrayList() constructorTypeParameters.addAll(typeParameters) constructorTypeParameters.addAll(f.typeParameters) - return Function(Identifier("init"), modifiers, ClassType(name, constructorTypeParameters, false), + return Function(Identifier("init"), arrayList(), modifiers, ClassType(name, constructorTypeParameters, false), constructorTypeParameters, f.params, block) } @@ -83,7 +83,7 @@ public open class Class(converter : Converter, } open fun implementTypesToKotlin() : String { - val allTypes : List = arrayList() + val allTypes : List = arrayList() allTypes.addAll(baseClassSignatureWithParams()) allTypes.addAll(implementsTypes.map { it.toKotlin() }) return if (allTypes.size() == 0) diff --git a/src/org/jetbrains/jet/j2k/ast/Constructor.kt b/src/org/jetbrains/jet/j2k/ast/Constructor.kt index acb9ae47fba..2f376b20970 100644 --- a/src/org/jetbrains/jet/j2k/ast/Constructor.kt +++ b/src/org/jetbrains/jet/j2k/ast/Constructor.kt @@ -5,12 +5,13 @@ import java.util.Set import org.jetbrains.jet.j2k.ast.types.Type public open class Constructor(identifier : Identifier, + docComments: List, modifiers : Set, `type` : Type, typeParameters : List, params : Element, block : Block, - val isPrimary : Boolean) : Function(identifier, modifiers, `type`, typeParameters, params, block) { + val isPrimary : Boolean) : Function(identifier, docComments, modifiers, `type`, typeParameters, params, block) { public open fun primarySignatureToKotlin() : String { return "(" + params.toKotlin() + ")" diff --git a/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt b/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt index bd20a39e5cb..4fc3bc589f4 100644 --- a/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt +++ b/src/org/jetbrains/jet/j2k/ast/EnumConstant.kt @@ -2,11 +2,13 @@ package org.jetbrains.jet.j2k.ast import org.jetbrains.jet.j2k.ast.types.Type import java.util.Set +import java.util.List public open class EnumConstant(identifier : Identifier, + docComments: List, modifiers : Set, `type` : Type, - params : Element) : Field(identifier, modifiers, `type`.convertedToNotNull(), params, 0) { + params : Element) : Field(identifier, docComments, modifiers, `type`.convertedToNotNull(), params, 0) { public override fun toKotlin() : String { if (initializer.toKotlin().isEmpty()) { diff --git a/src/org/jetbrains/jet/j2k/ast/Field.kt b/src/org/jetbrains/jet/j2k/ast/Field.kt index 67595b21956..858fc26da0a 100644 --- a/src/org/jetbrains/jet/j2k/ast/Field.kt +++ b/src/org/jetbrains/jet/j2k/ast/Field.kt @@ -7,6 +7,7 @@ import java.util.Set import org.jetbrains.jet.j2k.Converter public open class Field(val identifier : Identifier, + val docComments: List, modifiers : Set, val `type` : Type, val initializer : Element, @@ -37,7 +38,8 @@ public open class Field(val identifier : Identifier, } public override fun toKotlin() : String { - val declaration : String? = modifiersToKotlin() + identifier.toKotlin() + " : " + `type`.toKotlin() + val declaration : String = docComments.toKotlin("\n", "", "\n") + + modifiersToKotlin() + identifier.toKotlin() + " : " + `type`.toKotlin() if (initializer.isEmpty()) { return declaration + ((if (isVal() && !isStatic() && writingAccesses == 1) "" diff --git a/src/org/jetbrains/jet/j2k/ast/Function.kt b/src/org/jetbrains/jet/j2k/ast/Function.kt index 725b76ceec1..ea6d18bf863 100644 --- a/src/org/jetbrains/jet/j2k/ast/Function.kt +++ b/src/org/jetbrains/jet/j2k/ast/Function.kt @@ -6,6 +6,7 @@ import java.util.Set import org.jetbrains.jet.j2k.ast.types.Type public open class Function(val name : Identifier, + val docComments: List, modifiers : Set, val `type` : Type, val typeParameters : List, @@ -33,18 +34,15 @@ public open class Function(val name : Identifier, open fun modifiersToKotlin() : String { val modifierList: List = arrayList() val accessModifier : String = accessModifier() - if (!accessModifier.isEmpty()) - { + if (!accessModifier.isEmpty()) { modifierList.add(accessModifier) } - if (isAbstract()) - { + if (isAbstract()) { modifierList.add(Modifier.ABSTRACT) } - if (myModifiers.contains(Modifier.OVERRIDE)) - { + if (myModifiers.contains(Modifier.OVERRIDE)) { modifierList.add(Modifier.OVERRIDE) } @@ -56,13 +54,11 @@ public open class Function(val name : Identifier, modifierList.add(Modifier.OPEN) } - if (myModifiers.contains(Modifier.NOT_OPEN)) - { + if (myModifiers.contains(Modifier.NOT_OPEN)) { modifierList.remove(Modifier.OPEN) } - if (modifierList.size() > 0) - { + if (modifierList.size() > 0) { return modifierList.makeString(" ") + " " } @@ -70,7 +66,12 @@ public open class Function(val name : Identifier, } public override fun toKotlin() : String { - return modifiersToKotlin() + "fun " + name.toKotlin() + typeParametersToKotlin() + "(" + params.toKotlin() + ") : " + `type`.toKotlin() + " "+ typeParameterWhereToKotlin() + block?.toKotlin() + return docComments.toKotlin("\n", "", "\n") + + modifiersToKotlin() + + "fun " + name.toKotlin() + + typeParametersToKotlin() + + "(" + params.toKotlin() + ") : " + + `type`.toKotlin() + " "+ typeParameterWhereToKotlin() + + block?.toKotlin() } - } diff --git a/src/org/jetbrains/jet/j2k/ast/Statements.kt b/src/org/jetbrains/jet/j2k/ast/Statements.kt index 4cae30727ae..8ee4c839b89 100644 --- a/src/org/jetbrains/jet/j2k/ast/Statements.kt +++ b/src/org/jetbrains/jet/j2k/ast/Statements.kt @@ -28,7 +28,7 @@ public open class ExpressionListStatement(val expressions: List): Ex public override fun toKotlin() = expressions.toKotlin("\n") } -public open class LabelStatement(val name: Identifier, val statement: Statement): Statement() { +public open class LabelStatement(val name: Identifier, val statement: Element): Statement() { public override fun toKotlin(): String = "@" + name.toKotlin() + " " + statement.toKotlin() } @@ -36,7 +36,9 @@ public open class ReturnStatement(val expression: Expression): Statement() { public override fun toKotlin() = "return " + expression.toKotlin() } -public open class IfStatement(val condition: Expression, val thenStatement: Statement, val elseStatement: Statement): Expression() { +public open class IfStatement(val condition: Expression, + val thenStatement: Element, + val elseStatement: Element): Expression() { public override fun toKotlin(): String { val result: String = "if (" + condition.toKotlin() + ")\n" + thenStatement.toKotlin() + "\n" if (elseStatement != Statement.EMPTY_STATEMENT) { @@ -49,25 +51,25 @@ public open class IfStatement(val condition: Expression, val thenStatement: Stat // Loops -------------------------------------------------------------------------------------------------- -public open class WhileStatement(val condition: Expression, val statement: Statement): Statement() { - public override fun toKotlin() = "while (" + condition.toKotlin() + ")\n" + statement.toKotlin() +public open class WhileStatement(val condition: Expression, val body: Element): Statement() { + public override fun toKotlin() = "while (" + condition.toKotlin() + ")\n" + body.toKotlin() } -public open class DoWhileStatement(condition: Expression, statement: Statement): WhileStatement(condition, statement) { - public override fun toKotlin() = "do\n" + statement.toKotlin() + "\nwhile (" + condition.toKotlin() + ")" +public open class DoWhileStatement(condition: Expression, body: Element): WhileStatement(condition, body) { + public override fun toKotlin() = "do\n" + body.toKotlin() + "\nwhile (" + condition.toKotlin() + ")" } public open class ForeachStatement(val variable: Parameter, val expression: Expression, - val statement: Statement): Statement() { + val body: Element): Statement() { public override fun toKotlin() = "for (" + variable.toKotlin() + " in " + - expression.toKotlin() + ")\n" + statement.toKotlin() + expression.toKotlin() + ")\n" + body.toKotlin() } public open class ForeachWithRangeStatement(val identifier: Identifier, val start: Expression, val end: Expression, - val body: Statement): Statement() { + val body: Element): Statement() { public override fun toKotlin() = "for (" + identifier.toKotlin() + " in " + start.toKotlin() + ".." + end.toKotlin() + ") " + body.toKotlin() } @@ -105,11 +107,11 @@ public open class SwitchContainer(val expression: Expression, val caseContainers public override fun toKotlin() = "when (" + expression.toKotlin() + ") {\n" + caseContainers.toKotlin("\n") + "\n}" } -public open class CaseContainer(val caseStatement: List, statements: List): Statement() { +public open class CaseContainer(val caseStatement: List, statements: List): Statement() { private val myBlock: Block { - val newStatements: List = statements.filterNot { it is BreakStatement || it is ContinueStatement } + val newStatements = statements.filterNot { it is BreakStatement || it is ContinueStatement } myBlock = Block(newStatements, false) } diff --git a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt index aee18c2c023..f82f2d87875 100644 --- a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt +++ b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt @@ -8,7 +8,7 @@ import java.util.List import org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull public open class ElementVisitor(val myConverter : Converter) : JavaElementVisitor() { - private var myResult : Element = Element.EMPTY_ELEMENT + protected var myResult : Element = Element.EMPTY_ELEMENT public fun getConverter() : Converter { return myConverter diff --git a/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt index d46ce18f1ad..6ed75ea0b45 100644 --- a/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt +++ b/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt @@ -14,14 +14,12 @@ import java.util.List import com.intellij.psi.CommonClassNames.* public open class ExpressionVisitor(converter: Converter): StatementVisitor(converter) { - var myResult: Expression = Expression.EMPTY_EXPRESSION - - public override fun visitExpression(expression: PsiExpression?): Unit { + { myResult = Expression.EMPTY_EXPRESSION } public override fun getResult(): Expression { - return myResult + return myResult as Expression } public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?): Unit { diff --git a/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt index f46680c6d6b..712c105cba2 100644 --- a/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt +++ b/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt @@ -12,20 +12,13 @@ import java.util.List import org.jetbrains.jet.j2k.ConverterUtil.countWritingAccesses public open class StatementVisitor(converter: Converter): ElementVisitor(converter) { - private var myResult: Statement = Statement.EMPTY_STATEMENT - - public override fun getResult(): Statement { - return myResult - } - public override fun visitAssertStatement(statement: PsiAssertStatement?): Unit { myResult = AssertStatement(getConverter().expressionToExpression(statement?.getAssertCondition()), getConverter().expressionToExpression(statement?.getAssertDescription())) } public override fun visitBlockStatement(statement: PsiBlockStatement?): Unit { - val statements: Array = statement?.getCodeBlock()?.getStatements()!! - myResult = Block(getConverter().statementsToStatementList(statements), true) + myResult = myConverter.blockToBlock(statement?.getCodeBlock(), true) } public override fun visitBreakStatement(statement: PsiBreakStatement?): Unit { @@ -104,7 +97,7 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert getConverter().statementToStatement(body)) } else { - var forStatements: List = arrayList() + var forStatements: List = arrayList() forStatements.add(getConverter().statementToStatement(initialization)) forStatements.add(WhileStatement(getConverter().expressionToExpression(condition), Block(arrayList(getConverter().statementToStatement(body), @@ -145,23 +138,23 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert } private open fun switchBodyToCases(body: PsiCodeBlock?): List { - val cases: List> = splitToCases(body) - val allSwitchStatements: List = arrayList() + val cases: List> = splitToCases(body) + val allSwitchStatements: List = arrayList() if (body != null) { // TODO Arrays.asList() for(s in body.getStatements()) allSwitchStatements.add(s) } val result: List = arrayList() - var pendingLabels: List = arrayList() + var pendingLabels: List = arrayList() var i: Int = 0 - for (ls : List in cases) { + for (ls in cases) { // TODO assert {(ls?.size()).sure() > 0} - var label: PsiStatement? = ls[0] + var label = ls[0] // TODO assert {(label is PsiSwitchLabelStatement?)} // TODO assert("not a right index") {allSwitchStatements?.get(i) == label} if (ls.size() > 1) { pendingLabels.add(getConverter().statementToStatement(label)) - val slice: List = ls.subList(1, (ls.size())) + val slice: List = ls.subList(1, (ls.size())) if (!containsBreak(slice)) { val statements = getConverter().statementsToStatementList(slice) statements.addAll(getConverter().statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size()))) @@ -227,20 +220,12 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert (psiElement is PsiPrefixExpression && psiElement.getOperationTokenType() == JavaTokenType.PLUSPLUS) } - private open fun containsBreak(slice: List): Boolean { - for (s : PsiStatement? in slice) - if ((s is PsiBreakStatement?)) - { - return true - } + private fun containsBreak(slice: List) = slice.any { it is PsiBreakStatement } - return false - } - - private open fun getAllToNextBreak(allStatements: List, start: Int): List { - var result: List = LinkedList() + private open fun getAllToNextBreak(allStatements: List, start: Int): List { + val result: List = arrayList() for (i in start..allStatements.size() - 1) { - var s: PsiStatement? = allStatements.get(i) + val s = allStatements.get(i) if (s is PsiBreakStatement || s is PsiReturnStatement) { return result } @@ -253,19 +238,20 @@ public open class StatementVisitor(converter: Converter): ElementVisitor(convert return result } - private open fun splitToCases(body: PsiCodeBlock?): List> { - val cases: List> = arrayList() - var currentCaseStatements: List = arrayList() + private open fun splitToCases(body: PsiCodeBlock?): List> { + val cases: List> = arrayList() + var currentCaseStatements: List = arrayList() var isFirst: Boolean = true if (body != null) { - for (s : PsiStatement? in body.getStatements()) { - if ((s is PsiSwitchLabelStatement?)) { + for (s in body.getChildren()) { + if (s !is PsiStatement && s !is PsiComment) continue + if (s is PsiSwitchLabelStatement) { if (isFirst) { isFirst = false } else { cases.add(currentCaseStatements) - currentCaseStatements = LinkedList() + currentCaseStatements = arrayList() } } diff --git a/tests/testData/ast/issues/file/comments.jav b/tests/testData/ast/issues/file/comments.jav index 95ca19a6442..74978823f3e 100644 --- a/tests/testData/ast/issues/file/comments.jav +++ b/tests/testData/ast/issues/file/comments.jav @@ -6,9 +6,17 @@ This is a block comment class C { - // This is a comment + // This is a class comment + /** + * This is a field doc comment. + */ + private int i; + + /** + * This is a function doc comment. + */ public void foo() { - /* This is a comment */ + /* This is a function comment */ } } diff --git a/tests/testData/ast/issues/file/comments.kt b/tests/testData/ast/issues/file/comments.kt index cc169a6b8cb..536f6f45847 100644 --- a/tests/testData/ast/issues/file/comments.kt +++ b/tests/testData/ast/issues/file/comments.kt @@ -2,3 +2,16 @@ /* This is a block comment */ +open class C() { +// This is a class comment +/** + * This is a field doc comment. + */ +private var i : Int = 0 +/** + * This is a function doc comment. + */ +public open fun foo() : Unit { +/* This is a function comment */ +} +} \ No newline at end of file