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

Refactor converter:

Browse Source 
Minor: Replace *to* naming convention by convert* convention
This commit is contained in:
Pavel Talanov
2013-12-01 18:47:41 +04:00
committed by Pavel V. Talanov
parent ffbbbc8529
commit d7e1c1f0a2
10 changed files with 186 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java
+1 -1
View File
@@ -133,7 +133,7 @@ public class JavaToKotlinActionUtil {
if (psiFile instanceof PsiJavaFile && virtualFile != null) { if (psiFile instanceof PsiJavaFile && virtualFile != null) {
String result = ""; String result = "";
try { try {
result = converter.fileToFile((PsiJavaFile) psiFile).toKotlin(); result = converter.convertFile((PsiJavaFile) psiFile).toKotlin();
} catch (Exception e) { } catch (Exception e) {
//noinspection CallToPrintStackTrace //noinspection CallToPrintStackTrace
e.printStackTrace(); e.printStackTrace();
j2k/src/org/jetbrains/jet/j2k/Converter.kt
+79 -79
View File
@@ -55,27 +55,27 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
} }
public fun elementToKotlin(element: PsiElement): String { public fun elementToKotlin(element: PsiElement): String {
val kElement = topElementToElement(element) val kElement = convertTopElement(element)
return kElement?.toKotlin() ?: "" return kElement?.toKotlin() ?: ""
} }
public fun topElementToElement(element: PsiElement?): Node? = when(element) { public fun convertTopElement(element: PsiElement?): Node? = when(element) {
is PsiJavaFile -> fileToFile(element) is PsiJavaFile -> convertFile(element)
is PsiClass -> classToClass(element) is PsiClass -> convertClass(element)
is PsiMethod -> methodToFunction(element) is PsiMethod -> convertMethod(element)
is PsiField -> fieldToField(element, element.getContainingClass()) is PsiField -> convertField(element, element.getContainingClass())
is PsiStatement -> statementToStatement(element) is PsiStatement -> convertStatement(element)
is PsiExpression -> expressionToExpression(element) is PsiExpression -> convertExpression(element)
is PsiComment -> Comment(element.getText()!!) is PsiComment -> Comment(element.getText()!!)
is PsiImportList -> importsToImportList(element) is PsiImportList -> convertImportList(element)
is PsiImportStatementBase -> importToImport(element) is PsiImportStatementBase -> convertImport(element)
else -> null else -> null
} }
public fun fileToFile(javaFile: PsiJavaFile): File { public fun convertFile(javaFile: PsiJavaFile): File {
val body = ArrayList<Node>() val body = ArrayList<Node>()
for (element in javaFile.getChildren()) { for (element in javaFile.getChildren()) {
val node = topElementToElement(element) val node = convertTopElement(element)
if (node != null) { if (node != null) {
body.add(node) body.add(node)
} }
@@ -83,14 +83,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return File(quoteKeywords(javaFile.getPackageName()), body, createMainFunction(javaFile)) return File(quoteKeywords(javaFile.getPackageName()), body, createMainFunction(javaFile))
} }
public fun anonymousClassToAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass { public fun convertAnonymousClass(anonymousClass: PsiAnonymousClass): AnonymousClass {
return AnonymousClass(this, getMembers(anonymousClass)) return AnonymousClass(this, getMembers(anonymousClass))
} }
private fun getMembers(psiClass: PsiClass): List<Node> { private fun getMembers(psiClass: PsiClass): List<Node> {
val members = ArrayList<Node>() val members = ArrayList<Node>()
for (e in psiClass.getChildren()) { for (e in psiClass.getChildren()) {
val converted = memberToMember(e, psiClass) val converted = convertMember(e, psiClass)
if (converted != null) members.add(converted) if (converted != null) members.add(converted)
} }
return members return members
@@ -101,22 +101,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return if (psiDocComment != null) Comment(psiDocComment.getText()!!) else null return if (psiDocComment != null) Comment(psiDocComment.getText()!!) else null
} }
private fun memberToMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) { private fun convertMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) {
is PsiMethod -> methodToFunction(e, true) is PsiMethod -> convertMethod(e, true)
is PsiField -> fieldToField(e, containingClass) is PsiField -> convertField(e, containingClass)
is PsiClass -> classToClass(e) is PsiClass -> convertClass(e)
is PsiClassInitializer -> initializerToInitializer(e) is PsiClassInitializer -> convertInitializer(e)
is PsiDocComment -> null is PsiDocComment -> null
is PsiComment -> Comment(e.getText()!!) is PsiComment -> Comment(e.getText()!!)
else -> null else -> null
} }
private fun classToClass(psiClass: PsiClass): Class { private fun convertClass(psiClass: PsiClass): Class {
val modifiers = modifiersListToModifiersSet(psiClass.getModifierList()) val modifiers = convertModifierList(psiClass.getModifierList())
val fields = fieldsToFieldList(psiClass.getFields(), psiClass) val fields = convertFields(psiClass.getFields(), psiClass)
val typeParameters = typeParameterListToTypeParameterList(psiClass.getTypeParameterList()) val typeParameters = convertTypeParameterList(psiClass.getTypeParameterList())
val implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes()) val implementsTypes = convertToNotNullableTypes(psiClass.getImplementsListTypes())
val extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes()) val extendsTypes = convertToNotNullableTypes(psiClass.getExtendsListTypes())
val name: Identifier = Identifier(psiClass.getName()!!) val name: Identifier = Identifier(psiClass.getName()!!)
val baseClassParams = ArrayList<Expression>() val baseClassParams = ArrayList<Expression>()
val members = ArrayList(getMembers(psiClass)) val members = ArrayList(getMembers(psiClass))
@@ -125,7 +125,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters
if (resolvedSuperCallParameters.size() == 1) { if (resolvedSuperCallParameters.size() == 1) {
val psiExpressionList = resolvedSuperCallParameters.iterator().next() val psiExpressionList = resolvedSuperCallParameters.iterator().next()
baseClassParams.addAll(expressionsToExpressionList(psiExpressionList.getExpressions())) baseClassParams.addAll(convertExpressions(psiExpressionList.getExpressions()))
} }
if (!psiClass.isEnum() && !psiClass.isInterface() && psiClass.getConstructors().size > 1 && if (!psiClass.isEnum() && !psiClass.isInterface() && psiClass.getConstructors().size > 1 &&
@@ -186,25 +186,25 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return Class(this, name, getDocComment(psiClass), modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members) return Class(this, name, getDocComment(psiClass), modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members)
} }
private fun initializerToInitializer(i: PsiClassInitializer): Initializer { private fun convertInitializer(i: PsiClassInitializer): Initializer {
return Initializer(blockToBlock(i.getBody(), true), modifiersListToModifiersSet(i.getModifierList())) return Initializer(convertBlock(i.getBody(), true), convertModifierList(i.getModifierList()))
} }
private fun fieldsToFieldList(fields: Array<PsiField>, psiClass: PsiClass): List<Field> { private fun convertFields(fields: Array<PsiField>, psiClass: PsiClass): List<Field> {
return fields.map { fieldToField(it, psiClass) } return fields.map { convertField(it, psiClass) }
} }
private fun fieldToField(field: PsiField, psiClass: PsiClass?): Field { private fun convertField(field: PsiField, psiClass: PsiClass?): Field {
val modifiers = modifiersListToModifiersSet(field.getModifierList()) val modifiers = convertModifierList(field.getModifierList())
if (field is PsiEnumConstant) { if (field is PsiEnumConstant) {
return EnumConstant(Identifier(field.getName()!!), return EnumConstant(Identifier(field.getName()!!),
getDocComment(field), getDocComment(field),
modifiers, modifiers,
typeToType(field.getType()), convertType(field.getType()),
elementToElement(field.getArgumentList())) convertElement(field.getArgumentList()))
} }
var kType = typeToType(field.getType(), isAnnotatedAsNotNull(field.getModifierList())) var kType = convertType(field.getType(), isAnnotatedAsNotNull(field.getModifierList()))
if (field.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(field.getInitializer())) { if (field.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(field.getInitializer())) {
kType = kType.convertedToNotNull(); kType = kType.convertedToNotNull();
} }
@@ -213,15 +213,15 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
getDocComment(field), getDocComment(field),
modifiers, modifiers,
kType, kType,
expressionToExpression(field.getInitializer(), field.getType()), convertExpression(field.getInitializer(), field.getType()),
countWritingAccesses(field, psiClass)) countWritingAccesses(field, psiClass))
} }
private fun methodToFunction(method: PsiMethod): Function { private fun convertMethod(method: PsiMethod): Function {
return methodToFunction(method, true) return convertMethod(method, true)
} }
private fun methodToFunction(method: PsiMethod, notEmpty: Boolean): Function { private fun convertMethod(method: PsiMethod, notEmpty: Boolean): Function {
if (directlyOverridesMethodFromObject(method)) { if (directlyOverridesMethodFromObject(method)) {
dispatcher.expressionVisitor = ExpressionVisitorForDirectObjectInheritors(this) dispatcher.expressionVisitor = ExpressionVisitorForDirectObjectInheritors(this)
} }
@@ -230,12 +230,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
} }
methodReturnType = method.getReturnType() methodReturnType = method.getReturnType()
val identifier: Identifier = Identifier(method.getName()) val identifier: Identifier = Identifier(method.getName())
val returnType: Type = typeToType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList())) val returnType: Type = convertType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList()))
val body = blockToBlock(method.getBody(), notEmpty) val body = convertBlock(method.getBody(), notEmpty)
val params: Element = createFunctionParameters(method) val params: Element = createFunctionParameters(method)
val typeParameterList = typeParameterListToTypeParameterList(method.getTypeParameterList()) val typeParameterList = convertTypeParameterList(method.getTypeParameterList())
val modifiers = modifiersListToModifiersSet(method.getModifierList()) val modifiers = convertModifierList(method.getModifierList())
if (isOverride(method)) { if (isOverride(method)) {
modifiers.add(Modifier.OVERRIDE) modifiers.add(Modifier.OVERRIDE)
} }
@@ -261,33 +261,33 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
val result = ArrayList<Parameter>() val result = ArrayList<Parameter>()
for (parameter : PsiParameter? in method.getParameterList().getParameters()) { for (parameter : PsiParameter? in method.getParameterList().getParameters()) {
result.add(Parameter(Identifier(parameter?.getName()!!), result.add(Parameter(Identifier(parameter?.getName()!!),
typeToType(parameter?.getType(), convertType(parameter?.getType(),
isAnnotatedAsNotNull(parameter?.getModifierList())), isAnnotatedAsNotNull(parameter?.getModifierList())),
isReadOnly(parameter, method.getBody()))) isReadOnly(parameter, method.getBody())))
} }
return ParameterList(result) return ParameterList(result)
} }
public fun blockToBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block { public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block {
if (block == null) if (block == null)
return Block.EMPTY_BLOCK return Block.EMPTY_BLOCK
return Block(statementsToStatementList(block.getChildren()), notEmpty) return Block(convertStatements(block.getChildren()), notEmpty)
} }
public fun blockToBlock(block: PsiCodeBlock?): Block { public fun convertBlock(block: PsiCodeBlock?): Block {
return blockToBlock(block, true) return convertBlock(block, true)
} }
public fun statementsToStatementList(statements: Array<PsiElement>): List<Element> { public fun convertStatements(statements: Array<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) } return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) }
} }
public fun statementsToStatementList(statements: List<PsiElement>): List<Element> { public fun convertStatements(statements: List<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) } return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) }
} }
public fun statementToStatement(s: PsiElement?): Element { public fun convertStatement(s: PsiElement?): Element {
if (s == null) if (s == null)
return Statement.EMPTY_STATEMENT return Statement.EMPTY_STATEMENT
@@ -296,14 +296,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return statementVisitor.getResult() return statementVisitor.getResult()
} }
public fun expressionsToExpressionList(expressions: Array<PsiExpression>): List<Expression> { public fun convertExpressions(expressions: Array<PsiExpression>): List<Expression> {
val result = ArrayList<Expression>() val result = ArrayList<Expression>()
for (e : PsiExpression? in expressions) for (e : PsiExpression? in expressions)
result.add(expressionToExpression(e)) result.add(convertExpression(e))
return result return result
} }
public fun expressionToExpression(e: PsiExpression?): Expression { public fun convertExpression(e: PsiExpression?): Expression {
if (e == null) if (e == null)
return Expression.EMPTY_EXPRESSION return Expression.EMPTY_EXPRESSION
@@ -312,7 +312,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return expressionVisitor.getResult() return expressionVisitor.getResult()
} }
public fun elementToElement(e: PsiElement?): Element { public fun convertElement(e: PsiElement?): Element {
if (e == null) if (e == null)
return Element.EMPTY_ELEMENT return Element.EMPTY_ELEMENT
@@ -321,22 +321,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return elementVisitor.getResult() return elementVisitor.getResult()
} }
public fun elementsToElementList(elements: Array<out PsiElement?>): List<Element> { public fun convertElements(elements: Array<out PsiElement?>): List<Element> {
val result = ArrayList<Element>() val result = ArrayList<Element>()
for (element in elements) { for (element in elements) {
result.add(elementToElement(element)) result.add(convertElement(element))
} }
return result return result
} }
public fun typeElementToTypeElement(element: PsiTypeElement?): TypeElement { public fun convertTypeElement(element: PsiTypeElement?): TypeElement {
return TypeElement(if (element == null) return TypeElement(if (element == null)
EmptyType() EmptyType()
else else
typeToType(element.getType())) convertType(element.getType()))
} }
public fun typeToType(`type`: PsiType?): Type { public fun convertType(`type`: PsiType?): Type {
if (`type` == null) if (`type` == null)
return EmptyType() return EmptyType()
@@ -345,12 +345,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return typeVisitor.getResult() return typeVisitor.getResult()
} }
public fun typesToTypeList(types: Array<PsiType>): List<Type> { public fun convertTypes(types: Array<PsiType>): List<Type> {
return types.map { typeToType(it) } return types.map { convertType(it) }
} }
public fun typeToType(`type`: PsiType?, notNull: Boolean): Type { public fun convertType(`type`: PsiType?, notNull: Boolean): Type {
val result: Type = typeToType(`type`) val result: Type = convertType(`type`)
if (notNull) { if (notNull) {
return result.convertedToNotNull() return result.convertedToNotNull()
} }
@@ -358,25 +358,25 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return result return result
} }
private fun typesToNotNullableTypeList(types: Array<out PsiType?>): List<Type> { private fun convertToNotNullableTypes(types: Array<out PsiType?>): List<Type> {
val result = ArrayList<Type>() val result = ArrayList<Type>()
for (aType in types) { for (aType in types) {
result.add(typeToType(aType).convertedToNotNull()) result.add(convertType(aType).convertedToNotNull())
} }
return result return result
} }
public fun parametersToParameterList(parameters: Array<PsiParameter>): List<Parameter?> { public fun convertParameterList(parameters: Array<PsiParameter>): List<Parameter?> {
return parameters.map { parameterToParameter(it) } return parameters.map { convertParameter(it) }
} }
public fun parameterToParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter { public fun convertParameter(parameter: PsiParameter, forceNotNull: Boolean = false): Parameter {
return Parameter(Identifier(parameter.getName()!!), return Parameter(Identifier(parameter.getName()!!),
typeToType(parameter.getType(), convertType(parameter.getType(),
forceNotNull || isAnnotatedAsNotNull(parameter.getModifierList())), true) forceNotNull || isAnnotatedAsNotNull(parameter.getModifierList())), true)
} }
public fun argumentsToExpressionList(expression: PsiCallExpression): List<Expression> { public fun convertArguments(expression: PsiCallExpression): List<Expression> {
val argumentList: PsiExpressionList? = expression.getArgumentList() val argumentList: PsiExpressionList? = expression.getArgumentList()
val arguments: Array<PsiExpression> = (if (argumentList != null) val arguments: Array<PsiExpression> = (if (argumentList != null)
argumentList.getExpressions() argumentList.getExpressions()
@@ -391,21 +391,21 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
} }
if (arguments.size == expectedTypes.size()) { if (arguments.size == expectedTypes.size()) {
for (i in 0..expectedTypes.size() - 1) result.add(expressionToExpression(arguments[i], expectedTypes.get(i))) for (i in 0..expectedTypes.size() - 1) result.add(convertExpression(arguments[i], expectedTypes.get(i)))
} }
else { else {
for (argument : PsiExpression? in arguments) { for (argument : PsiExpression? in arguments) {
result.add(expressionToExpression(argument)) result.add(convertExpression(argument))
} }
} }
return result return result
} }
public fun expressionToExpression(argument: PsiExpression?, expectedType: PsiType?): Expression { public fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression {
if (argument == null) if (argument == null)
return Identifier.EMPTY_IDENTIFIER return Identifier.EMPTY_IDENTIFIER
var expression: Expression = expressionToExpression(argument) var expression: Expression = convertExpression(argument)
val actualType: PsiType? = argument.getType() val actualType: PsiType? = argument.getType()
val isPrimitiveTypeOrNull: Boolean = actualType == null || actualType is PsiPrimitiveType val isPrimitiveTypeOrNull: Boolean = actualType == null || actualType is PsiPrimitiveType
if (isPrimitiveTypeOrNull && expression.isNullable()) { if (isPrimitiveTypeOrNull && expression.isNullable()) {
@@ -470,14 +470,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
} }
} }
public fun identifierToIdentifier(identifier: PsiIdentifier?): Identifier { public fun convertIdentifier(identifier: PsiIdentifier?): Identifier {
if (identifier == null) if (identifier == null)
return Identifier.EMPTY_IDENTIFIER return Identifier.EMPTY_IDENTIFIER
return Identifier(identifier.getText()!!) return Identifier(identifier.getText()!!)
} }
public fun modifiersListToModifiersSet(modifierList: PsiModifierList?): MutableSet<Modifier> { public fun convertModifierList(modifierList: PsiModifierList?): MutableSet<Modifier> {
val modifiersSet: HashSet<Modifier> = hashSetOf() val modifiersSet: HashSet<Modifier> = hashSetOf()
if (modifierList != null) { if (modifierList != null) {
if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT)) if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT))
j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt
+1 -1
View File
@@ -98,7 +98,7 @@ object JavaToKotlinTranslator {
if (file is PsiJavaFile) { if (file is PsiJavaFile) {
val converter = Converter(file.getProject(), TestSettings) val converter = Converter(file.getProject(), TestSettings)
setClassIdentifiers(converter, file) setClassIdentifiers(converter, file)
return prettify(converter.fileToFile(file).toKotlin()) return prettify(converter.convertFile(file).toKotlin())
} }
return "" return ""
} }
j2k/src/org/jetbrains/jet/j2k/ast/Imports.kt
+3 -3
View File
@@ -49,10 +49,10 @@ public class ImportList(val imports: List<Import>) : Element {
override fun toKotlin() = filteredImports.toKotlin("\n") override fun toKotlin() = filteredImports.toKotlin("\n")
} }
public fun Converter.importsToImportList(importList: PsiImportList): ImportList = public fun Converter.convertImportList(importList: PsiImportList): ImportList =
ImportList(importList.getAllImportStatements() map { importToImport(it) }) ImportList(importList.getAllImportStatements() map { convertImport(it) })
public fun Converter.importToImport(i: PsiImportStatementBase): Import { public fun Converter.convertImport(i: PsiImportStatementBase): Import {
val reference = i.getImportReference() val reference = i.getImportReference()
if (reference != null) { if (reference != null) {
return Import(quoteKeywords(reference.getQualifiedName()!!) + if (i.isOnDemand()) ".*" else "") return Import(quoteKeywords(reference.getQualifiedName()!!) + if (i.isOnDemand()) ".*" else "")
j2k/src/org/jetbrains/jet/j2k/ast/TypeParameters.kt
+4 -4
View File
@@ -65,11 +65,11 @@ public class TypeParameterList(val parameters: List<TypeParameter>) : Element {
} }
} }
public fun Converter.typeParameterToTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter { public fun Converter.convertTypeParameter(psiTypeParameter: PsiTypeParameter): TypeParameter {
return elementToElement(psiTypeParameter) as TypeParameter return convertElement(psiTypeParameter) as TypeParameter
} }
public fun Converter.typeParameterListToTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList { public fun Converter.convertTypeParameterList(psiTypeParameterlist: PsiTypeParameterList?): TypeParameterList {
return if (psiTypeParameterlist == null) TypeParameterList.Empty return if (psiTypeParameterlist == null) TypeParameterList.Empty
else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { typeParameterToTypeParameter(it) }) else TypeParameterList(psiTypeParameterlist.getTypeParameters()!!.toList().map { convertTypeParameter(it) })
} }
j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt
+8 -8
View File
@@ -34,24 +34,24 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito
public override fun visitLocalVariable(variable: PsiLocalVariable?) { public override fun visitLocalVariable(variable: PsiLocalVariable?) {
val theVariable = variable!! val theVariable = variable!!
var kType = myConverter.typeToType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList())) var kType = myConverter.convertType(theVariable.getType(), isAnnotatedAsNotNull(theVariable.getModifierList()))
if (theVariable.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(theVariable.getInitializer())) { if (theVariable.hasModifierProperty(PsiModifier.FINAL) && isDefinitelyNotNull(theVariable.getInitializer())) {
kType = kType.convertedToNotNull(); kType = kType.convertedToNotNull();
} }
myResult = LocalVariable(Identifier(theVariable.getName()!!), myResult = LocalVariable(Identifier(theVariable.getName()!!),
myConverter.modifiersListToModifiersSet(theVariable.getModifierList()), myConverter.convertModifierList(theVariable.getModifierList()),
kType, kType,
myConverter.expressionToExpression(theVariable.getInitializer(), theVariable.getType()), myConverter.convertExpression(theVariable.getInitializer(), theVariable.getType()),
myConverter) myConverter)
} }
public override fun visitExpressionList(list: PsiExpressionList?) { public override fun visitExpressionList(list: PsiExpressionList?) {
myResult = ExpressionList(myConverter.expressionsToExpressionList(list!!.getExpressions())) myResult = ExpressionList(myConverter.convertExpressions(list!!.getExpressions()))
} }
public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) { public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) {
val theReference = reference!! val theReference = reference!!
val types: List<Type> = myConverter.typesToTypeList(theReference.getTypeParameters()) val types: List<Type> = myConverter.convertTypes(theReference.getTypeParameters())
if (!theReference.isQualified()) { if (!theReference.isQualified()) {
myResult = ReferenceElement(Identifier(theReference.getReferenceName()!!), types) myResult = ReferenceElement(Identifier(theReference.getReferenceName()!!), types)
} }
@@ -69,16 +69,16 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito
} }
public override fun visitTypeElement(`type`: PsiTypeElement?) { public override fun visitTypeElement(`type`: PsiTypeElement?) {
myResult = TypeElement(myConverter.typeToType(`type`!!.getType())) myResult = TypeElement(myConverter.convertType(`type`!!.getType()))
} }
public override fun visitTypeParameter(classParameter: PsiTypeParameter?) { public override fun visitTypeParameter(classParameter: PsiTypeParameter?) {
myResult = TypeParameter(Identifier(classParameter!!.getName()!!), myResult = TypeParameter(Identifier(classParameter!!.getName()!!),
classParameter.getExtendsListTypes().map { myConverter.typeToType(it) }) classParameter.getExtendsListTypes().map { myConverter.convertType(it) })
} }
public override fun visitParameterList(list: PsiParameterList?) { public override fun visitParameterList(list: PsiParameterList?) {
myResult = ParameterList(myConverter.parametersToParameterList(list!!.getParameters()).requireNoNulls()) myResult = ParameterList(myConverter.convertParameterList(list!!.getParameters()).requireNoNulls())
} }
public override fun visitComment(comment: PsiComment?) { public override fun visitComment(comment: PsiComment?) {
j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt
+38 -38
View File
@@ -41,16 +41,16 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) { public override fun visitArrayAccessExpression(expression: PsiArrayAccessExpression?) {
val assignment = PsiTreeUtil.getParentOfType(expression, javaClass<PsiAssignmentExpression>()) val assignment = PsiTreeUtil.getParentOfType(expression, javaClass<PsiAssignmentExpression>())
val lvalue = assignment != null && expression == assignment.getLExpression(); val lvalue = assignment != null && expression == assignment.getLExpression();
myResult = ArrayAccessExpression(getConverter().expressionToExpression(expression?.getArrayExpression()), myResult = ArrayAccessExpression(getConverter().convertExpression(expression?.getArrayExpression()),
getConverter().expressionToExpression(expression?.getIndexExpression()), getConverter().convertExpression(expression?.getIndexExpression()),
lvalue) lvalue)
} }
public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) { public override fun visitArrayInitializerExpression(expression: PsiArrayInitializerExpression?) {
val expressionType = getConverter().typeToType(expression?.getType()) val expressionType = getConverter().convertType(expression?.getType())
assert(expressionType is ArrayType) { "Array initializer must have array type" } assert(expressionType is ArrayType) { "Array initializer must have array type" }
myResult = ArrayInitializerExpression(expressionType as ArrayType, myResult = ArrayInitializerExpression(expressionType as ArrayType,
getConverter().expressionsToExpressionList(expression?.getInitializers()!!)) getConverter().convertExpressions(expression?.getInitializers()!!))
} }
public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) { public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) {
@@ -65,8 +65,8 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
else -> "" else -> ""
} }
val lhs = getConverter().expressionToExpression(expression?.getLExpression()!!) val lhs = getConverter().convertExpression(expression?.getLExpression()!!)
val rhs = getConverter().expressionToExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType()) val rhs = getConverter().convertExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType())
if (!secondOp.isEmpty()) { if (!secondOp.isEmpty()) {
myResult = AssignmentExpression(lhs, BinaryExpression(lhs, rhs, secondOp), "=") myResult = AssignmentExpression(lhs, BinaryExpression(lhs, rhs, secondOp), "=")
} }
@@ -76,8 +76,8 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
} }
public override fun visitBinaryExpression(expression: PsiBinaryExpression?) { public override fun visitBinaryExpression(expression: PsiBinaryExpression?) {
val lhs = getConverter().expressionToExpression(expression?.getLOperand()!!, expression?.getType()) val lhs = getConverter().convertExpression(expression?.getLOperand()!!, expression?.getType())
val rhs = getConverter().expressionToExpression(expression?.getROperand(), expression?.getType()) val rhs = getConverter().convertExpression(expression?.getROperand(), expression?.getType())
if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) { if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) {
myResult = MethodCallExpression.build(lhs, "ushr", arrayList(rhs)) myResult = MethodCallExpression.build(lhs, "ushr", arrayList(rhs))
} }
@@ -88,29 +88,29 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
} }
public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) { public override fun visitClassObjectAccessExpression(expression: PsiClassObjectAccessExpression?) {
myResult = ClassObjectAccessExpression(getConverter().typeElementToTypeElement(expression?.getOperand())) myResult = ClassObjectAccessExpression(getConverter().convertTypeElement(expression?.getOperand()))
} }
public override fun visitConditionalExpression(expression: PsiConditionalExpression?) { public override fun visitConditionalExpression(expression: PsiConditionalExpression?) {
val condition: PsiExpression? = expression?.getCondition() val condition: PsiExpression? = expression?.getCondition()
val `type`: PsiType? = condition?.getType() val `type`: PsiType? = condition?.getType()
val e: Expression = (if (`type` != null) val e: Expression = (if (`type` != null)
getConverter().expressionToExpression(condition, `type`) getConverter().convertExpression(condition, `type`)
else else
getConverter().expressionToExpression(condition)) getConverter().convertExpression(condition))
myResult = ParenthesizedExpression(IfStatement(e, myResult = ParenthesizedExpression(IfStatement(e,
getConverter().expressionToExpression(expression?.getThenExpression()), getConverter().convertExpression(expression?.getThenExpression()),
getConverter().expressionToExpression(expression?.getElseExpression()))) getConverter().convertExpression(expression?.getElseExpression())))
} }
public override fun visitExpressionList(list: PsiExpressionList?) { public override fun visitExpressionList(list: PsiExpressionList?) {
myResult = ExpressionList(getConverter().expressionsToExpressionList(list!!.getExpressions())) myResult = ExpressionList(getConverter().convertExpressions(list!!.getExpressions()))
} }
public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) { public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) {
val checkType: PsiTypeElement? = expression?.getCheckType() val checkType: PsiTypeElement? = expression?.getCheckType()
myResult = IsOperator(getConverter().expressionToExpression(expression?.getOperand()), myResult = IsOperator(getConverter().convertExpression(expression?.getOperand()),
myConverter.typeElementToTypeElement(checkType)) myConverter.convertTypeElement(checkType))
} }
public override fun visitLiteralExpression(expression: PsiLiteralExpression?) { public override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
@@ -149,10 +149,10 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
protected fun convertMethodCallExpression(expression: PsiMethodCallExpression) { protected fun convertMethodCallExpression(expression: PsiMethodCallExpression) {
if (!SuperVisitor.isSuper(expression.getMethodExpression()) || !isInsidePrimaryConstructor(expression)) { if (!SuperVisitor.isSuper(expression.getMethodExpression()) || !isInsidePrimaryConstructor(expression)) {
myResult = MethodCallExpression(getConverter().expressionToExpression(expression.getMethodExpression()), myResult = MethodCallExpression(getConverter().convertExpression(expression.getMethodExpression()),
getConverter().argumentsToExpressionList(expression), getConverter().convertArguments(expression),
getConverter().typesToTypeList(expression.getTypeArguments()), getConverter().convertTypes(expression.getTypeArguments()),
getConverter().typeToType(expression.getType()).nullable) getConverter().convertType(expression.getType()).nullable)
} }
} }
@@ -183,45 +183,45 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
array<PsiExpression>()) array<PsiExpression>())
if (constructor == null || isConstructorPrimary(constructor) || isNotConvertedClass) if (constructor == null || isConstructorPrimary(constructor) || isNotConvertedClass)
{ {
return NewClassExpression(getConverter().elementToElement(classReference), return NewClassExpression(getConverter().convertElement(classReference),
getConverter().argumentsToExpressionList(expression!!), getConverter().convertArguments(expression!!),
getConverter().expressionToExpression(expression.getQualifier()), getConverter().convertExpression(expression.getQualifier()),
(if (anonymousClass != null) (if (anonymousClass != null)
getConverter().anonymousClassToAnonymousClass(anonymousClass) getConverter().convertAnonymousClass(anonymousClass)
else else
null)) null))
} }
val reference: PsiJavaCodeReferenceElement? = expression?.getClassReference() val reference: PsiJavaCodeReferenceElement? = expression?.getClassReference()
val typeParameters: List<Type> = (if (reference != null) val typeParameters: List<Type> = (if (reference != null)
getConverter().typesToTypeList(reference.getTypeParameters()) getConverter().convertTypes(reference.getTypeParameters())
else else
Collections.emptyList<Type>()) Collections.emptyList<Type>())
return CallChainExpression(Identifier(constructor.getName(), false), return CallChainExpression(Identifier(constructor.getName(), false),
MethodCallExpression(Identifier("init"), getConverter().expressionsToExpressionList(arguments), typeParameters, false)) MethodCallExpression(Identifier("init"), getConverter().convertExpressions(arguments), typeParameters, false))
} }
private fun createNewEmptyArrayWithoutInitialization(expression: PsiNewExpression): Expression { private fun createNewEmptyArrayWithoutInitialization(expression: PsiNewExpression): Expression {
return ArrayWithoutInitializationExpression( return ArrayWithoutInitializationExpression(
getConverter().typeToType(expression.getType(), true), getConverter().convertType(expression.getType(), true),
getConverter().expressionsToExpressionList(expression.getArrayDimensions())) getConverter().convertExpressions(expression.getArrayDimensions()))
} }
private fun createNewEmptyArray(expression: PsiNewExpression?): Expression { private fun createNewEmptyArray(expression: PsiNewExpression?): Expression {
return getConverter().expressionToExpression(expression?.getArrayInitializer()) return getConverter().convertExpression(expression?.getArrayInitializer())
} }
public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) { public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) {
myResult = ParenthesizedExpression(getConverter().expressionToExpression(expression?.getExpression())) myResult = ParenthesizedExpression(getConverter().convertExpression(expression?.getExpression()))
} }
public override fun visitPostfixExpression(expression: PsiPostfixExpression?) { public override fun visitPostfixExpression(expression: PsiPostfixExpression?) {
myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!), myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!),
getConverter().expressionToExpression(expression.getOperand())) getConverter().convertExpression(expression.getOperand()))
} }
public override fun visitPrefixExpression(expression: PsiPrefixExpression?) { public override fun visitPrefixExpression(expression: PsiPrefixExpression?) {
val operand = getConverter().expressionToExpression(expression?.getOperand(), expression?.getOperand()!!.getType()) val operand = getConverter().convertExpression(expression?.getOperand(), expression?.getOperand()!!.getType())
val token = expression?.getOperationTokenType()!! val token = expression?.getOperationTokenType()!!
if (token == JavaTokenType.TILDE) { if (token == JavaTokenType.TILDE) {
myResult = MethodCallExpression.build(ParenthesizedExpression(operand), "inv", arrayList()) myResult = MethodCallExpression.build(ParenthesizedExpression(operand), "inv", arrayList())
@@ -237,7 +237,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
val hasReceiver: Boolean = isFieldReference && insideSecondaryConstructor val hasReceiver: Boolean = isFieldReference && insideSecondaryConstructor
val isThis: Boolean = isThisExpression(expression) val isThis: Boolean = isThisExpression(expression)
val notNull = isResolvedToNotNull(expression) val notNull = isResolvedToNotNull(expression)
val isNullable: Boolean = getConverter().typeToType(expression.getType(), notNull).nullable val isNullable: Boolean = getConverter().convertType(expression.getType(), notNull).nullable
val className: String = getClassNameWithConstructor(expression) val className: String = getClassNameWithConstructor(expression)
val referencedName = expression.getReferenceName()!! val referencedName = expression.getReferenceName()!!
var identifier: Expression = Identifier(referencedName, isNullable) var identifier: Expression = Identifier(referencedName, isNullable)
@@ -277,7 +277,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
} }
} }
myResult = CallChainExpression(getConverter().expressionToExpression(qualifier), identifier) myResult = CallChainExpression(getConverter().convertExpression(qualifier), identifier)
} }
private fun isResolvedToNotNull(expression: PsiReference): Boolean { private fun isResolvedToNotNull(expression: PsiReference): Boolean {
@@ -315,11 +315,11 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
val typeText = castType.getType().getCanonicalText() val typeText = castType.getType().getCanonicalText()
val typeConversion = PRIMITIVE_TYPE_CONVERSIONS[typeText] val typeConversion = PRIMITIVE_TYPE_CONVERSIONS[typeText]
if (operandType is PsiPrimitiveType && typeConversion != null) { if (operandType is PsiPrimitiveType && typeConversion != null) {
myResult = MethodCallExpression.build(getConverter().expressionToExpression(operand), typeConversion) myResult = MethodCallExpression.build(getConverter().convertExpression(operand), typeConversion)
} }
else { else {
myResult = TypeCastExpression(getConverter().typeToType(castType.getType()), myResult = TypeCastExpression(getConverter().convertType(castType.getType()),
getConverter().expressionToExpression(operand)) getConverter().convertExpression(operand))
} }
} }
} }
@@ -327,7 +327,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) { public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) {
var parameters = ArrayList<Expression>() var parameters = ArrayList<Expression>()
for (operand : PsiExpression in expression?.getOperands()!!) { for (operand : PsiExpression in expression?.getOperands()!!) {
parameters.add(getConverter().expressionToExpression(operand, expression?.getType())) parameters.add(getConverter().convertExpression(operand, expression?.getType()))
} }
myResult = PolyadicExpression(parameters, getOperatorString(expression?.getOperationTokenType()!!)) myResult = PolyadicExpression(parameters, getOperatorString(expression?.getOperationTokenType()!!))
} }
j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.kt
+1 -1
View File
@@ -30,7 +30,7 @@ public open class ExpressionVisitorForDirectObjectInheritors(converter: Converte
myResult = MethodCallExpression.build(Identifier("System", false), "identityHashCode", arrayList(Identifier("this"))) myResult = MethodCallExpression.build(Identifier("System", false), "identityHashCode", arrayList(Identifier("this")))
} }
else if (superMethodInvocation(methodExpression, "equals")) { else if (superMethodInvocation(methodExpression, "equals")) {
myResult = MethodCallExpression.build(Identifier("this", false), "identityEquals", getConverter().argumentsToExpressionList(expression!!)) myResult = MethodCallExpression.build(Identifier("this", false), "identityEquals", getConverter().convertArguments(expression!!))
} }
else if (superMethodInvocation(methodExpression, "toString")) { else if (superMethodInvocation(methodExpression, "toString")) {
myResult = DummyStringExpression(java.lang.String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())", myResult = DummyStringExpression(java.lang.String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())",
j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
+45 -45
View File
@@ -25,12 +25,12 @@ import java.util.ArrayList
public open class StatementVisitor(converter: Converter) : ElementVisitor(converter) { public open class StatementVisitor(converter: Converter) : ElementVisitor(converter) {
public override fun visitAssertStatement(statement: PsiAssertStatement?) { public override fun visitAssertStatement(statement: PsiAssertStatement?) {
myResult = AssertStatement(getConverter().expressionToExpression(statement?.getAssertCondition()), myResult = AssertStatement(getConverter().convertExpression(statement?.getAssertCondition()),
getConverter().expressionToExpression(statement?.getAssertDescription())) getConverter().convertExpression(statement?.getAssertDescription()))
} }
public override fun visitBlockStatement(statement: PsiBlockStatement?) { public override fun visitBlockStatement(statement: PsiBlockStatement?) {
myResult = getConverter().blockToBlock(statement?.getCodeBlock(), true) myResult = getConverter().convertBlock(statement?.getCodeBlock(), true)
} }
public override fun visitBreakStatement(statement: PsiBreakStatement?) { public override fun visitBreakStatement(statement: PsiBreakStatement?) {
@@ -39,7 +39,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
} }
else else
{ {
myResult = BreakStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier())) myResult = BreakStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()))
} }
} }
@@ -50,29 +50,29 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
} }
else else
{ {
myResult = ContinueStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier())) myResult = ContinueStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()))
} }
} }
public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) { public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) {
myResult = DeclarationStatement(getConverter().elementsToElementList(statement?.getDeclaredElements()!!)) myResult = DeclarationStatement(getConverter().convertElements(statement?.getDeclaredElements()!!))
} }
public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) { public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) {
val condition: PsiExpression? = statement?.getCondition() val condition: PsiExpression? = statement?.getCondition()
val expression: Expression = (if (condition != null && condition.getType() != null) val expression: Expression = (if (condition != null && condition.getType() != null)
getConverter().expressionToExpression(condition, condition.getType()) getConverter().convertExpression(condition, condition.getType())
else else
getConverter().expressionToExpression(condition)) getConverter().convertExpression(condition))
myResult = DoWhileStatement(expression, getConverter().statementToStatement(statement?.getBody())) myResult = DoWhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
} }
public override fun visitExpressionStatement(statement: PsiExpressionStatement?) { public override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
myResult = getConverter().expressionToExpression(statement?.getExpression()) myResult = getConverter().convertExpression(statement?.getExpression())
} }
public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) { public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) {
myResult = ExpressionListStatement(getConverter().expressionsToExpressionList( myResult = ExpressionListStatement(getConverter().convertExpressions(
statement?.getExpressionList()?.getExpressions()!!)) statement?.getExpressionList()?.getExpressions()!!))
} }
@@ -98,65 +98,65 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
(isPlusPlusExpression(update.getChildren()[0])) && (operationTokenType == JavaTokenType.LT || operationTokenType == JavaTokenType.LE) && (isPlusPlusExpression(update.getChildren()[0])) && (operationTokenType == JavaTokenType.LT || operationTokenType == JavaTokenType.LE) &&
initialization.getFirstChild() != null && (initialization.getFirstChild() is PsiLocalVariable) && initialization.getFirstChild() != null && (initialization.getFirstChild() is PsiLocalVariable) &&
firstChild != null && firstChild.getNameIdentifier() != null && onceWritableIterator) { firstChild != null && firstChild.getNameIdentifier() != null && onceWritableIterator) {
val end = getConverter().expressionToExpression((condition as PsiBinaryExpression).getROperand()) val end = getConverter().convertExpression((condition as PsiBinaryExpression).getROperand())
val endExpression = (if (operationTokenType == JavaTokenType.LT) val endExpression = (if (operationTokenType == JavaTokenType.LT)
BinaryExpression(end, Identifier("1"), "-") BinaryExpression(end, Identifier("1"), "-")
else else
end) end)
myResult = ForeachWithRangeStatement(Identifier(firstChild.getName()!!), myResult = ForeachWithRangeStatement(Identifier(firstChild.getName()!!),
getConverter().expressionToExpression(firstChild.getInitializer()), getConverter().convertExpression(firstChild.getInitializer()),
endExpression, endExpression,
getConverter().statementToStatement(body)) getConverter().convertStatement(body))
} }
else { else {
var forStatements = ArrayList<Element>() var forStatements = ArrayList<Element>()
forStatements.add(getConverter().statementToStatement(initialization)) forStatements.add(getConverter().convertStatement(initialization))
forStatements.add(WhileStatement( forStatements.add(WhileStatement(
if (condition == null) if (condition == null)
LiteralExpression("true") LiteralExpression("true")
else else
getConverter().expressionToExpression(condition), getConverter().convertExpression(condition),
Block(arrayListOf(getConverter().statementToStatement(body), Block(arrayListOf(getConverter().convertStatement(body),
Block(arrayListOf(getConverter().statementToStatement(update)), false)), false))) Block(arrayListOf(getConverter().convertStatement(update)), false)), false)))
myResult = Block(forStatements, false) myResult = Block(forStatements, false)
} }
} }
public override fun visitForeachStatement(statement: PsiForeachStatement?) { public override fun visitForeachStatement(statement: PsiForeachStatement?) {
val iterator = { val iterator = {
val iteratorExpr = getConverter().expressionToExpression(statement?.getIteratedValue()) val iteratorExpr = getConverter().convertExpression(statement?.getIteratedValue())
if (iteratorExpr.isNullable()) if (iteratorExpr.isNullable())
BangBangExpression(iteratorExpr) BangBangExpression(iteratorExpr)
else else
iteratorExpr iteratorExpr
}() }()
myResult = ForeachStatement(getConverter().parameterToParameter(statement?.getIterationParameter()!!), myResult = ForeachStatement(getConverter().convertParameter(statement?.getIterationParameter()!!),
iterator, iterator,
getConverter().statementToStatement(statement?.getBody())) getConverter().convertStatement(statement?.getBody()))
} }
public override fun visitIfStatement(statement: PsiIfStatement?) { public override fun visitIfStatement(statement: PsiIfStatement?) {
val condition: PsiExpression? = statement?.getCondition() val condition: PsiExpression? = statement?.getCondition()
val expression: Expression = getConverter().expressionToExpression(condition, PsiType.BOOLEAN) val expression: Expression = getConverter().convertExpression(condition, PsiType.BOOLEAN)
myResult = IfStatement(expression, myResult = IfStatement(expression,
getConverter().statementToStatement(statement?.getThenBranch()), getConverter().convertStatement(statement?.getThenBranch()),
getConverter().statementToStatement(statement?.getElseBranch())) getConverter().convertStatement(statement?.getElseBranch()))
} }
public override fun visitLabeledStatement(statement: PsiLabeledStatement?) { public override fun visitLabeledStatement(statement: PsiLabeledStatement?) {
myResult = LabelStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier()), myResult = LabelStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()),
getConverter().statementToStatement(statement?.getStatement())) getConverter().convertStatement(statement?.getStatement()))
} }
public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) { public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) {
myResult = (if (statement?.isDefaultCase()!!) myResult = (if (statement?.isDefaultCase()!!)
DefaultSwitchLabelStatement() DefaultSwitchLabelStatement()
else else
SwitchLabelStatement(getConverter().expressionToExpression(statement?.getCaseValue()))) SwitchLabelStatement(getConverter().convertExpression(statement?.getCaseValue())))
} }
public override fun visitSwitchStatement(statement: PsiSwitchStatement?) { public override fun visitSwitchStatement(statement: PsiSwitchStatement?) {
myResult = SwitchContainer(getConverter().expressionToExpression(statement?.getExpression()), myResult = SwitchContainer(getConverter().convertExpression(statement?.getExpression()),
switchBodyToCases(statement?.getBody())) switchBodyToCases(statement?.getBody()))
} }
@@ -179,21 +179,21 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
// TODO assert {(label is PsiSwitchLabelStatement?)} // TODO assert {(label is PsiSwitchLabelStatement?)}
// TODO assert("not a right index") {allSwitchStatements?.get(i) == label} // TODO assert("not a right index") {allSwitchStatements?.get(i) == label}
if (ls.size() > 1) { if (ls.size() > 1) {
pendingLabels.add(getConverter().statementToStatement(label)) pendingLabels.add(getConverter().convertStatement(label))
val slice: List<PsiElement> = ls.subList(1, (ls.size())) val slice: List<PsiElement> = ls.subList(1, (ls.size()))
if (!containsBreak(slice)) { if (!containsBreak(slice)) {
val statements = ArrayList(getConverter().statementsToStatementList(slice)) val statements = ArrayList(getConverter().convertStatements(slice))
statements.addAll(getConverter().statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size()))) statements.addAll(getConverter().convertStatements(getAllToNextBreak(allSwitchStatements, i + ls.size())))
result.add(CaseContainer(pendingLabels, statements)) result.add(CaseContainer(pendingLabels, statements))
pendingLabels = ArrayList() pendingLabels = ArrayList()
} }
else { else {
result.add(CaseContainer(pendingLabels, getConverter().statementsToStatementList(slice))) result.add(CaseContainer(pendingLabels, getConverter().convertStatements(slice)))
pendingLabels = ArrayList() pendingLabels = ArrayList()
} }
} }
else { else {
pendingLabels.add(getConverter().statementToStatement(label)) pendingLabels.add(getConverter().convertStatement(label))
} }
i += ls.size() i += ls.size()
} }
@@ -204,12 +204,12 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
} }
public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) { public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) {
myResult = SynchronizedStatement(getConverter().expressionToExpression(statement?.getLockExpression()), myResult = SynchronizedStatement(getConverter().convertExpression(statement?.getLockExpression()),
getConverter().blockToBlock(statement?.getBody())) getConverter().convertBlock(statement?.getBody()))
} }
public override fun visitThrowStatement(statement: PsiThrowStatement?) { public override fun visitThrowStatement(statement: PsiThrowStatement?) {
myResult = ThrowStatement(getConverter().expressionToExpression(statement?.getException())) myResult = ThrowStatement(getConverter().convertExpression(statement?.getException()))
} }
public override fun visitTryStatement(statement: PsiTryStatement?) { public override fun visitTryStatement(statement: PsiTryStatement?) {
@@ -217,29 +217,29 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
val catchBlocks = statement?.getCatchBlocks()!! val catchBlocks = statement?.getCatchBlocks()!!
val catchBlockParameters = statement?.getCatchBlockParameters()!! val catchBlockParameters = statement?.getCatchBlockParameters()!!
for (i in 0..catchBlocks.size - 1) { for (i in 0..catchBlocks.size - 1) {
catches.add(CatchStatement(getConverter().parameterToParameter(catchBlockParameters[i], true), catches.add(CatchStatement(getConverter().convertParameter(catchBlockParameters[i], true),
getConverter().blockToBlock(catchBlocks[i], true))) getConverter().convertBlock(catchBlocks[i], true)))
} }
myResult = TryStatement(getConverter().blockToBlock(statement?.getTryBlock(), true), myResult = TryStatement(getConverter().convertBlock(statement?.getTryBlock(), true),
catches, getConverter().blockToBlock(statement?.getFinallyBlock(), true)) catches, getConverter().convertBlock(statement?.getFinallyBlock(), true))
} }
public override fun visitWhileStatement(statement: PsiWhileStatement?) { public override fun visitWhileStatement(statement: PsiWhileStatement?) {
var condition: PsiExpression? = statement?.getCondition() var condition: PsiExpression? = statement?.getCondition()
val expression: Expression = (if (condition != null && condition?.getType() != null) val expression: Expression = (if (condition != null && condition?.getType() != null)
this.getConverter().expressionToExpression(condition, condition?.getType()) this.getConverter().convertExpression(condition, condition?.getType())
else else
getConverter().expressionToExpression(condition)) getConverter().convertExpression(condition))
myResult = WhileStatement(expression, getConverter().statementToStatement(statement?.getBody())) myResult = WhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
} }
public override fun visitReturnStatement(statement: PsiReturnStatement?) { public override fun visitReturnStatement(statement: PsiReturnStatement?) {
val returnValue: PsiExpression? = statement?.getReturnValue() val returnValue: PsiExpression? = statement?.getReturnValue()
val methodReturnType: PsiType? = getConverter().methodReturnType val methodReturnType: PsiType? = getConverter().methodReturnType
val expression: Expression = (if (returnValue != null && methodReturnType != null) val expression: Expression = (if (returnValue != null && methodReturnType != null)
this.getConverter().expressionToExpression(returnValue, methodReturnType) this.getConverter().convertExpression(returnValue, methodReturnType)
else else
getConverter().expressionToExpression(returnValue)) getConverter().convertExpression(returnValue))
myResult = ReturnStatement(expression) myResult = ReturnStatement(expression)
} }
j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt
+6 -6
View File
@@ -50,7 +50,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
public override fun visitArrayType(arrayType: PsiArrayType?): Type { public override fun visitArrayType(arrayType: PsiArrayType?): Type {
if (myResult is EmptyType) { if (myResult is EmptyType) {
myResult = ArrayType(myConverter.typeToType(arrayType?.getComponentType()), true, myConverter) myResult = ArrayType(myConverter.convertType(arrayType?.getComponentType()), true, myConverter)
} }
return myResult return myResult
@@ -76,7 +76,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
} }
} }
else { else {
myResult = ClassType(identifier, myConverter.typesToTypeList(classType.getParameters()), true, myConverter) myResult = ClassType(identifier, myConverter.convertTypes(classType.getParameters()), true, myConverter)
} }
return myResult return myResult
} }
@@ -118,7 +118,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
val superTypes = p!!.getSuperTypes() val superTypes = p!!.getSuperTypes()
val boundType: Type = (if (superTypes.size > 0) val boundType: Type = (if (superTypes.size > 0)
ClassType(Identifier(getClassTypeName(superTypes[0])), ClassType(Identifier(getClassTypeName(superTypes[0])),
myConverter.typesToTypeList(superTypes[0].getParameters()), myConverter.convertTypes(superTypes[0].getParameters()),
true, myConverter) true, myConverter)
else else
StarProjectionType()) StarProjectionType())
@@ -132,11 +132,11 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
public override fun visitWildcardType(wildcardType: PsiWildcardType?): Type { public override fun visitWildcardType(wildcardType: PsiWildcardType?): Type {
if (wildcardType!!.isExtends()) { if (wildcardType!!.isExtends()) {
myResult = OutProjectionType(myConverter.typeToType(wildcardType.getExtendsBound())) myResult = OutProjectionType(myConverter.convertType(wildcardType.getExtendsBound()))
} }
else else
if (wildcardType.isSuper()) { if (wildcardType.isSuper()) {
myResult = InProjectionType(myConverter.typeToType(wildcardType.getSuperBound())) myResult = InProjectionType(myConverter.convertType(wildcardType.getSuperBound()))
} }
else { else {
myResult = StarProjectionType() myResult = StarProjectionType()
@@ -145,7 +145,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
} }
public override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type { public override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type {
myResult = VarArg(myConverter.typeToType(ellipsisType?.getComponentType())) myResult = VarArg(myConverter.convertType(ellipsisType?.getComponentType()))
return myResult return myResult
} }