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) {
String result = "";
try {
result = converter.fileToFile((PsiJavaFile) psiFile).toKotlin();
result = converter.convertFile((PsiJavaFile) psiFile).toKotlin();
} catch (Exception e) {
//noinspection CallToPrintStackTrace
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 {
val kElement = topElementToElement(element)
val kElement = convertTopElement(element)
return kElement?.toKotlin() ?: ""
}
public fun topElementToElement(element: PsiElement?): Node? = when(element) {
is PsiJavaFile -> fileToFile(element)
is PsiClass -> classToClass(element)
is PsiMethod -> methodToFunction(element)
is PsiField -> fieldToField(element, element.getContainingClass())
is PsiStatement -> statementToStatement(element)
is PsiExpression -> expressionToExpression(element)
public fun convertTopElement(element: PsiElement?): Node? = when(element) {
is PsiJavaFile -> convertFile(element)
is PsiClass -> convertClass(element)
is PsiMethod -> convertMethod(element)
is PsiField -> convertField(element, element.getContainingClass())
is PsiStatement -> convertStatement(element)
is PsiExpression -> convertExpression(element)
is PsiComment -> Comment(element.getText()!!)
is PsiImportList -> importsToImportList(element)
is PsiImportStatementBase -> importToImport(element)
is PsiImportList -> convertImportList(element)
is PsiImportStatementBase -> convertImport(element)
else -> null
}
public fun fileToFile(javaFile: PsiJavaFile): File {
public fun convertFile(javaFile: PsiJavaFile): File {
val body = ArrayList<Node>()
for (element in javaFile.getChildren()) {
val node = topElementToElement(element)
val node = convertTopElement(element)
if (node != null) {
body.add(node)
}
@@ -83,14 +83,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
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))
}
private fun getMembers(psiClass: PsiClass): List<Node> {
val members = ArrayList<Node>()
for (e in psiClass.getChildren()) {
val converted = memberToMember(e, psiClass)
val converted = convertMember(e, psiClass)
if (converted != null) members.add(converted)
}
return members
@@ -101,22 +101,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return if (psiDocComment != null) Comment(psiDocComment.getText()!!) else null
}
private fun memberToMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) {
is PsiMethod -> methodToFunction(e, true)
is PsiField -> fieldToField(e, containingClass)
is PsiClass -> classToClass(e)
is PsiClassInitializer -> initializerToInitializer(e)
private fun convertMember(e: PsiElement?, containingClass: PsiClass): Node? = when(e) {
is PsiMethod -> convertMethod(e, true)
is PsiField -> convertField(e, containingClass)
is PsiClass -> convertClass(e)
is PsiClassInitializer -> convertInitializer(e)
is PsiDocComment -> null
is PsiComment -> Comment(e.getText()!!)
else -> null
}
private fun classToClass(psiClass: PsiClass): Class {
val modifiers = modifiersListToModifiersSet(psiClass.getModifierList())
val fields = fieldsToFieldList(psiClass.getFields(), psiClass)
val typeParameters = typeParameterListToTypeParameterList(psiClass.getTypeParameterList())
val implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes())
val extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes())
private fun convertClass(psiClass: PsiClass): Class {
val modifiers = convertModifierList(psiClass.getModifierList())
val fields = convertFields(psiClass.getFields(), psiClass)
val typeParameters = convertTypeParameterList(psiClass.getTypeParameterList())
val implementsTypes = convertToNotNullableTypes(psiClass.getImplementsListTypes())
val extendsTypes = convertToNotNullableTypes(psiClass.getExtendsListTypes())
val name: Identifier = Identifier(psiClass.getName()!!)
val baseClassParams = ArrayList<Expression>()
val members = ArrayList(getMembers(psiClass))
@@ -125,7 +125,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
val resolvedSuperCallParameters = visitor.resolvedSuperCallParameters
if (resolvedSuperCallParameters.size() == 1) {
val psiExpressionList = resolvedSuperCallParameters.iterator().next()
baseClassParams.addAll(expressionsToExpressionList(psiExpressionList.getExpressions()))
baseClassParams.addAll(convertExpressions(psiExpressionList.getExpressions()))
}
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)
}
private fun initializerToInitializer(i: PsiClassInitializer): Initializer {
return Initializer(blockToBlock(i.getBody(), true), modifiersListToModifiersSet(i.getModifierList()))
private fun convertInitializer(i: PsiClassInitializer): Initializer {
return Initializer(convertBlock(i.getBody(), true), convertModifierList(i.getModifierList()))
}
private fun fieldsToFieldList(fields: Array<PsiField>, psiClass: PsiClass): List<Field> {
return fields.map { fieldToField(it, psiClass) }
private fun convertFields(fields: Array<PsiField>, psiClass: PsiClass): List<Field> {
return fields.map { convertField(it, psiClass) }
}
private fun fieldToField(field: PsiField, psiClass: PsiClass?): Field {
val modifiers = modifiersListToModifiersSet(field.getModifierList())
private fun convertField(field: PsiField, psiClass: PsiClass?): Field {
val modifiers = convertModifierList(field.getModifierList())
if (field is PsiEnumConstant) {
return EnumConstant(Identifier(field.getName()!!),
getDocComment(field),
modifiers,
typeToType(field.getType()),
elementToElement(field.getArgumentList()))
convertType(field.getType()),
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())) {
kType = kType.convertedToNotNull();
}
@@ -213,15 +213,15 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
getDocComment(field),
modifiers,
kType,
expressionToExpression(field.getInitializer(), field.getType()),
convertExpression(field.getInitializer(), field.getType()),
countWritingAccesses(field, psiClass))
}
private fun methodToFunction(method: PsiMethod): Function {
return methodToFunction(method, true)
private fun convertMethod(method: PsiMethod): Function {
return convertMethod(method, true)
}
private fun methodToFunction(method: PsiMethod, notEmpty: Boolean): Function {
private fun convertMethod(method: PsiMethod, notEmpty: Boolean): Function {
if (directlyOverridesMethodFromObject(method)) {
dispatcher.expressionVisitor = ExpressionVisitorForDirectObjectInheritors(this)
}
@@ -230,12 +230,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
}
methodReturnType = method.getReturnType()
val identifier: Identifier = Identifier(method.getName())
val returnType: Type = typeToType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList()))
val body = blockToBlock(method.getBody(), notEmpty)
val returnType: Type = convertType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList()))
val body = convertBlock(method.getBody(), notEmpty)
val params: Element = createFunctionParameters(method)
val typeParameterList = typeParameterListToTypeParameterList(method.getTypeParameterList())
val modifiers = modifiersListToModifiersSet(method.getModifierList())
val typeParameterList = convertTypeParameterList(method.getTypeParameterList())
val modifiers = convertModifierList(method.getModifierList())
if (isOverride(method)) {
modifiers.add(Modifier.OVERRIDE)
}
@@ -261,33 +261,33 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
val result = ArrayList<Parameter>()
for (parameter : PsiParameter? in method.getParameterList().getParameters()) {
result.add(Parameter(Identifier(parameter?.getName()!!),
typeToType(parameter?.getType(),
convertType(parameter?.getType(),
isAnnotatedAsNotNull(parameter?.getModifierList())),
isReadOnly(parameter, method.getBody())))
}
return ParameterList(result)
}
public fun blockToBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block {
public fun convertBlock(block: PsiCodeBlock?, notEmpty: Boolean): Block {
if (block == null)
return Block.EMPTY_BLOCK
return Block(statementsToStatementList(block.getChildren()), notEmpty)
return Block(convertStatements(block.getChildren()), notEmpty)
}
public fun blockToBlock(block: PsiCodeBlock?): Block {
return blockToBlock(block, true)
public fun convertBlock(block: PsiCodeBlock?): Block {
return convertBlock(block, true)
}
public fun statementsToStatementList(statements: Array<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) }
public fun convertStatements(statements: Array<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) }
}
public fun statementsToStatementList(statements: List<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { statementToStatement(it) }
public fun convertStatements(statements: List<PsiElement>): List<Element> {
return statements.filterNot { it is PsiWhiteSpace }.map { convertStatement(it) }
}
public fun statementToStatement(s: PsiElement?): Element {
public fun convertStatement(s: PsiElement?): Element {
if (s == null)
return Statement.EMPTY_STATEMENT
@@ -296,14 +296,14 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return statementVisitor.getResult()
}
public fun expressionsToExpressionList(expressions: Array<PsiExpression>): List<Expression> {
public fun convertExpressions(expressions: Array<PsiExpression>): List<Expression> {
val result = ArrayList<Expression>()
for (e : PsiExpression? in expressions)
result.add(expressionToExpression(e))
result.add(convertExpression(e))
return result
}
public fun expressionToExpression(e: PsiExpression?): Expression {
public fun convertExpression(e: PsiExpression?): Expression {
if (e == null)
return Expression.EMPTY_EXPRESSION
@@ -312,7 +312,7 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return expressionVisitor.getResult()
}
public fun elementToElement(e: PsiElement?): Element {
public fun convertElement(e: PsiElement?): Element {
if (e == null)
return Element.EMPTY_ELEMENT
@@ -321,22 +321,22 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
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>()
for (element in elements) {
result.add(elementToElement(element))
result.add(convertElement(element))
}
return result
}
public fun typeElementToTypeElement(element: PsiTypeElement?): TypeElement {
public fun convertTypeElement(element: PsiTypeElement?): TypeElement {
return TypeElement(if (element == null)
EmptyType()
else
typeToType(element.getType()))
convertType(element.getType()))
}
public fun typeToType(`type`: PsiType?): Type {
public fun convertType(`type`: PsiType?): Type {
if (`type` == null)
return EmptyType()
@@ -345,12 +345,12 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return typeVisitor.getResult()
}
public fun typesToTypeList(types: Array<PsiType>): List<Type> {
return types.map { typeToType(it) }
public fun convertTypes(types: Array<PsiType>): List<Type> {
return types.map { convertType(it) }
}
public fun typeToType(`type`: PsiType?, notNull: Boolean): Type {
val result: Type = typeToType(`type`)
public fun convertType(`type`: PsiType?, notNull: Boolean): Type {
val result: Type = convertType(`type`)
if (notNull) {
return result.convertedToNotNull()
}
@@ -358,25 +358,25 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
return result
}
private fun typesToNotNullableTypeList(types: Array<out PsiType?>): List<Type> {
private fun convertToNotNullableTypes(types: Array<out PsiType?>): List<Type> {
val result = ArrayList<Type>()
for (aType in types) {
result.add(typeToType(aType).convertedToNotNull())
result.add(convertType(aType).convertedToNotNull())
}
return result
}
public fun parametersToParameterList(parameters: Array<PsiParameter>): List<Parameter?> {
return parameters.map { parameterToParameter(it) }
public fun convertParameterList(parameters: Array<PsiParameter>): List<Parameter?> {
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()!!),
typeToType(parameter.getType(),
convertType(parameter.getType(),
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 arguments: Array<PsiExpression> = (if (argumentList != null)
argumentList.getExpressions()
@@ -391,21 +391,21 @@ public class Converter(val project: Project, val settings: ConverterSettings) {
}
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 {
for (argument : PsiExpression? in arguments) {
result.add(expressionToExpression(argument))
result.add(convertExpression(argument))
}
}
return result
}
public fun expressionToExpression(argument: PsiExpression?, expectedType: PsiType?): Expression {
public fun convertExpression(argument: PsiExpression?, expectedType: PsiType?): Expression {
if (argument == null)
return Identifier.EMPTY_IDENTIFIER
var expression: Expression = expressionToExpression(argument)
var expression: Expression = convertExpression(argument)
val actualType: PsiType? = argument.getType()
val isPrimitiveTypeOrNull: Boolean = actualType == null || actualType is PsiPrimitiveType
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)
return Identifier.EMPTY_IDENTIFIER
return Identifier(identifier.getText()!!)
}
public fun modifiersListToModifiersSet(modifierList: PsiModifierList?): MutableSet<Modifier> {
public fun convertModifierList(modifierList: PsiModifierList?): MutableSet<Modifier> {
val modifiersSet: HashSet<Modifier> = hashSetOf()
if (modifierList != null) {
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) {
val converter = Converter(file.getProject(), TestSettings)
setClassIdentifiers(converter, file)
return prettify(converter.fileToFile(file).toKotlin())
return prettify(converter.convertFile(file).toKotlin())
}
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")
}
public fun Converter.importsToImportList(importList: PsiImportList): ImportList =
ImportList(importList.getAllImportStatements() map { importToImport(it) })
public fun Converter.convertImportList(importList: PsiImportList): ImportList =
ImportList(importList.getAllImportStatements() map { convertImport(it) })
public fun Converter.importToImport(i: PsiImportStatementBase): Import {
public fun Converter.convertImport(i: PsiImportStatementBase): Import {
val reference = i.getImportReference()
if (reference != null) {
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 {
return elementToElement(psiTypeParameter) as TypeParameter
public fun Converter.convertTypeParameter(psiTypeParameter: PsiTypeParameter): 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
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?) {
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())) {
kType = kType.convertedToNotNull();
}
myResult = LocalVariable(Identifier(theVariable.getName()!!),
myConverter.modifiersListToModifiersSet(theVariable.getModifierList()),
myConverter.convertModifierList(theVariable.getModifierList()),
kType,
myConverter.expressionToExpression(theVariable.getInitializer(), theVariable.getType()),
myConverter.convertExpression(theVariable.getInitializer(), theVariable.getType()),
myConverter)
}
public override fun visitExpressionList(list: PsiExpressionList?) {
myResult = ExpressionList(myConverter.expressionsToExpressionList(list!!.getExpressions()))
myResult = ExpressionList(myConverter.convertExpressions(list!!.getExpressions()))
}
public override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement?) {
val theReference = reference!!
val types: List<Type> = myConverter.typesToTypeList(theReference.getTypeParameters())
val types: List<Type> = myConverter.convertTypes(theReference.getTypeParameters())
if (!theReference.isQualified()) {
myResult = ReferenceElement(Identifier(theReference.getReferenceName()!!), types)
}
@@ -69,16 +69,16 @@ public open class ElementVisitor(val myConverter: Converter) : JavaElementVisito
}
public override fun visitTypeElement(`type`: PsiTypeElement?) {
myResult = TypeElement(myConverter.typeToType(`type`!!.getType()))
myResult = TypeElement(myConverter.convertType(`type`!!.getType()))
}
public override fun visitTypeParameter(classParameter: PsiTypeParameter?) {
myResult = TypeParameter(Identifier(classParameter!!.getName()!!),
classParameter.getExtendsListTypes().map { myConverter.typeToType(it) })
classParameter.getExtendsListTypes().map { myConverter.convertType(it) })
}
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?) {
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?) {
val assignment = PsiTreeUtil.getParentOfType(expression, javaClass<PsiAssignmentExpression>())
val lvalue = assignment != null && expression == assignment.getLExpression();
myResult = ArrayAccessExpression(getConverter().expressionToExpression(expression?.getArrayExpression()),
getConverter().expressionToExpression(expression?.getIndexExpression()),
myResult = ArrayAccessExpression(getConverter().convertExpression(expression?.getArrayExpression()),
getConverter().convertExpression(expression?.getIndexExpression()),
lvalue)
}
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" }
myResult = ArrayInitializerExpression(expressionType as ArrayType,
getConverter().expressionsToExpressionList(expression?.getInitializers()!!))
getConverter().convertExpressions(expression?.getInitializers()!!))
}
public override fun visitAssignmentExpression(expression: PsiAssignmentExpression?) {
@@ -65,8 +65,8 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
else -> ""
}
val lhs = getConverter().expressionToExpression(expression?.getLExpression()!!)
val rhs = getConverter().expressionToExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType())
val lhs = getConverter().convertExpression(expression?.getLExpression()!!)
val rhs = getConverter().convertExpression(expression?.getRExpression()!!, expression?.getLExpression()?.getType())
if (!secondOp.isEmpty()) {
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?) {
val lhs = getConverter().expressionToExpression(expression?.getLOperand()!!, expression?.getType())
val rhs = getConverter().expressionToExpression(expression?.getROperand(), expression?.getType())
val lhs = getConverter().convertExpression(expression?.getLOperand()!!, expression?.getType())
val rhs = getConverter().convertExpression(expression?.getROperand(), expression?.getType())
if (expression?.getOperationSign()?.getTokenType() == JavaTokenType.GTGTGT) {
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?) {
myResult = ClassObjectAccessExpression(getConverter().typeElementToTypeElement(expression?.getOperand()))
myResult = ClassObjectAccessExpression(getConverter().convertTypeElement(expression?.getOperand()))
}
public override fun visitConditionalExpression(expression: PsiConditionalExpression?) {
val condition: PsiExpression? = expression?.getCondition()
val `type`: PsiType? = condition?.getType()
val e: Expression = (if (`type` != null)
getConverter().expressionToExpression(condition, `type`)
getConverter().convertExpression(condition, `type`)
else
getConverter().expressionToExpression(condition))
getConverter().convertExpression(condition))
myResult = ParenthesizedExpression(IfStatement(e,
getConverter().expressionToExpression(expression?.getThenExpression()),
getConverter().expressionToExpression(expression?.getElseExpression())))
getConverter().convertExpression(expression?.getThenExpression()),
getConverter().convertExpression(expression?.getElseExpression())))
}
public override fun visitExpressionList(list: PsiExpressionList?) {
myResult = ExpressionList(getConverter().expressionsToExpressionList(list!!.getExpressions()))
myResult = ExpressionList(getConverter().convertExpressions(list!!.getExpressions()))
}
public override fun visitInstanceOfExpression(expression: PsiInstanceOfExpression?) {
val checkType: PsiTypeElement? = expression?.getCheckType()
myResult = IsOperator(getConverter().expressionToExpression(expression?.getOperand()),
myConverter.typeElementToTypeElement(checkType))
myResult = IsOperator(getConverter().convertExpression(expression?.getOperand()),
myConverter.convertTypeElement(checkType))
}
public override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
@@ -149,10 +149,10 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
protected fun convertMethodCallExpression(expression: PsiMethodCallExpression) {
if (!SuperVisitor.isSuper(expression.getMethodExpression()) || !isInsidePrimaryConstructor(expression)) {
myResult = MethodCallExpression(getConverter().expressionToExpression(expression.getMethodExpression()),
getConverter().argumentsToExpressionList(expression),
getConverter().typesToTypeList(expression.getTypeArguments()),
getConverter().typeToType(expression.getType()).nullable)
myResult = MethodCallExpression(getConverter().convertExpression(expression.getMethodExpression()),
getConverter().convertArguments(expression),
getConverter().convertTypes(expression.getTypeArguments()),
getConverter().convertType(expression.getType()).nullable)
}
}
@@ -183,45 +183,45 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
array<PsiExpression>())
if (constructor == null || isConstructorPrimary(constructor) || isNotConvertedClass)
{
return NewClassExpression(getConverter().elementToElement(classReference),
getConverter().argumentsToExpressionList(expression!!),
getConverter().expressionToExpression(expression.getQualifier()),
return NewClassExpression(getConverter().convertElement(classReference),
getConverter().convertArguments(expression!!),
getConverter().convertExpression(expression.getQualifier()),
(if (anonymousClass != null)
getConverter().anonymousClassToAnonymousClass(anonymousClass)
getConverter().convertAnonymousClass(anonymousClass)
else
null))
}
val reference: PsiJavaCodeReferenceElement? = expression?.getClassReference()
val typeParameters: List<Type> = (if (reference != null)
getConverter().typesToTypeList(reference.getTypeParameters())
getConverter().convertTypes(reference.getTypeParameters())
else
Collections.emptyList<Type>())
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 {
return ArrayWithoutInitializationExpression(
getConverter().typeToType(expression.getType(), true),
getConverter().expressionsToExpressionList(expression.getArrayDimensions()))
getConverter().convertType(expression.getType(), true),
getConverter().convertExpressions(expression.getArrayDimensions()))
}
private fun createNewEmptyArray(expression: PsiNewExpression?): Expression {
return getConverter().expressionToExpression(expression?.getArrayInitializer())
return getConverter().convertExpression(expression?.getArrayInitializer())
}
public override fun visitParenthesizedExpression(expression: PsiParenthesizedExpression?) {
myResult = ParenthesizedExpression(getConverter().expressionToExpression(expression?.getExpression()))
myResult = ParenthesizedExpression(getConverter().convertExpression(expression?.getExpression()))
}
public override fun visitPostfixExpression(expression: PsiPostfixExpression?) {
myResult = PostfixOperator(getOperatorString(expression!!.getOperationSign().getTokenType()!!),
getConverter().expressionToExpression(expression.getOperand()))
getConverter().convertExpression(expression.getOperand()))
}
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()!!
if (token == JavaTokenType.TILDE) {
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 isThis: Boolean = isThisExpression(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 referencedName = expression.getReferenceName()!!
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 {
@@ -315,11 +315,11 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
val typeText = castType.getType().getCanonicalText()
val typeConversion = PRIMITIVE_TYPE_CONVERSIONS[typeText]
if (operandType is PsiPrimitiveType && typeConversion != null) {
myResult = MethodCallExpression.build(getConverter().expressionToExpression(operand), typeConversion)
myResult = MethodCallExpression.build(getConverter().convertExpression(operand), typeConversion)
}
else {
myResult = TypeCastExpression(getConverter().typeToType(castType.getType()),
getConverter().expressionToExpression(operand))
myResult = TypeCastExpression(getConverter().convertType(castType.getType()),
getConverter().convertExpression(operand))
}
}
}
@@ -327,7 +327,7 @@ public open class ExpressionVisitor(converter: Converter) : StatementVisitor(con
public override fun visitPolyadicExpression(expression: PsiPolyadicExpression?) {
var parameters = ArrayList<Expression>()
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()!!))
}
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")))
}
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")) {
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 override fun visitAssertStatement(statement: PsiAssertStatement?) {
myResult = AssertStatement(getConverter().expressionToExpression(statement?.getAssertCondition()),
getConverter().expressionToExpression(statement?.getAssertDescription()))
myResult = AssertStatement(getConverter().convertExpression(statement?.getAssertCondition()),
getConverter().convertExpression(statement?.getAssertDescription()))
}
public override fun visitBlockStatement(statement: PsiBlockStatement?) {
myResult = getConverter().blockToBlock(statement?.getCodeBlock(), true)
myResult = getConverter().convertBlock(statement?.getCodeBlock(), true)
}
public override fun visitBreakStatement(statement: PsiBreakStatement?) {
@@ -39,7 +39,7 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
}
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
{
myResult = ContinueStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier()))
myResult = ContinueStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()))
}
}
public override fun visitDeclarationStatement(statement: PsiDeclarationStatement?) {
myResult = DeclarationStatement(getConverter().elementsToElementList(statement?.getDeclaredElements()!!))
myResult = DeclarationStatement(getConverter().convertElements(statement?.getDeclaredElements()!!))
}
public override fun visitDoWhileStatement(statement: PsiDoWhileStatement?) {
val condition: PsiExpression? = statement?.getCondition()
val expression: Expression = (if (condition != null && condition.getType() != null)
getConverter().expressionToExpression(condition, condition.getType())
getConverter().convertExpression(condition, condition.getType())
else
getConverter().expressionToExpression(condition))
myResult = DoWhileStatement(expression, getConverter().statementToStatement(statement?.getBody()))
getConverter().convertExpression(condition))
myResult = DoWhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
}
public override fun visitExpressionStatement(statement: PsiExpressionStatement?) {
myResult = getConverter().expressionToExpression(statement?.getExpression())
myResult = getConverter().convertExpression(statement?.getExpression())
}
public override fun visitExpressionListStatement(statement: PsiExpressionListStatement?) {
myResult = ExpressionListStatement(getConverter().expressionsToExpressionList(
myResult = ExpressionListStatement(getConverter().convertExpressions(
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) &&
initialization.getFirstChild() != null && (initialization.getFirstChild() is PsiLocalVariable) &&
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)
BinaryExpression(end, Identifier("1"), "-")
else
end)
myResult = ForeachWithRangeStatement(Identifier(firstChild.getName()!!),
getConverter().expressionToExpression(firstChild.getInitializer()),
getConverter().convertExpression(firstChild.getInitializer()),
endExpression,
getConverter().statementToStatement(body))
getConverter().convertStatement(body))
}
else {
var forStatements = ArrayList<Element>()
forStatements.add(getConverter().statementToStatement(initialization))
forStatements.add(getConverter().convertStatement(initialization))
forStatements.add(WhileStatement(
if (condition == null)
LiteralExpression("true")
else
getConverter().expressionToExpression(condition),
Block(arrayListOf(getConverter().statementToStatement(body),
Block(arrayListOf(getConverter().statementToStatement(update)), false)), false)))
getConverter().convertExpression(condition),
Block(arrayListOf(getConverter().convertStatement(body),
Block(arrayListOf(getConverter().convertStatement(update)), false)), false)))
myResult = Block(forStatements, false)
}
}
public override fun visitForeachStatement(statement: PsiForeachStatement?) {
val iterator = {
val iteratorExpr = getConverter().expressionToExpression(statement?.getIteratedValue())
val iteratorExpr = getConverter().convertExpression(statement?.getIteratedValue())
if (iteratorExpr.isNullable())
BangBangExpression(iteratorExpr)
else
iteratorExpr
}()
myResult = ForeachStatement(getConverter().parameterToParameter(statement?.getIterationParameter()!!),
myResult = ForeachStatement(getConverter().convertParameter(statement?.getIterationParameter()!!),
iterator,
getConverter().statementToStatement(statement?.getBody()))
getConverter().convertStatement(statement?.getBody()))
}
public override fun visitIfStatement(statement: PsiIfStatement?) {
val condition: PsiExpression? = statement?.getCondition()
val expression: Expression = getConverter().expressionToExpression(condition, PsiType.BOOLEAN)
val expression: Expression = getConverter().convertExpression(condition, PsiType.BOOLEAN)
myResult = IfStatement(expression,
getConverter().statementToStatement(statement?.getThenBranch()),
getConverter().statementToStatement(statement?.getElseBranch()))
getConverter().convertStatement(statement?.getThenBranch()),
getConverter().convertStatement(statement?.getElseBranch()))
}
public override fun visitLabeledStatement(statement: PsiLabeledStatement?) {
myResult = LabelStatement(getConverter().identifierToIdentifier(statement?.getLabelIdentifier()),
getConverter().statementToStatement(statement?.getStatement()))
myResult = LabelStatement(getConverter().convertIdentifier(statement?.getLabelIdentifier()),
getConverter().convertStatement(statement?.getStatement()))
}
public override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement?) {
myResult = (if (statement?.isDefaultCase()!!)
DefaultSwitchLabelStatement()
else
SwitchLabelStatement(getConverter().expressionToExpression(statement?.getCaseValue())))
SwitchLabelStatement(getConverter().convertExpression(statement?.getCaseValue())))
}
public override fun visitSwitchStatement(statement: PsiSwitchStatement?) {
myResult = SwitchContainer(getConverter().expressionToExpression(statement?.getExpression()),
myResult = SwitchContainer(getConverter().convertExpression(statement?.getExpression()),
switchBodyToCases(statement?.getBody()))
}
@@ -179,21 +179,21 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
// TODO assert {(label is PsiSwitchLabelStatement?)}
// TODO assert("not a right index") {allSwitchStatements?.get(i) == label}
if (ls.size() > 1) {
pendingLabels.add(getConverter().statementToStatement(label))
pendingLabels.add(getConverter().convertStatement(label))
val slice: List<PsiElement> = ls.subList(1, (ls.size()))
if (!containsBreak(slice)) {
val statements = ArrayList(getConverter().statementsToStatementList(slice))
statements.addAll(getConverter().statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size())))
val statements = ArrayList(getConverter().convertStatements(slice))
statements.addAll(getConverter().convertStatements(getAllToNextBreak(allSwitchStatements, i + ls.size())))
result.add(CaseContainer(pendingLabels, statements))
pendingLabels = ArrayList()
}
else {
result.add(CaseContainer(pendingLabels, getConverter().statementsToStatementList(slice)))
result.add(CaseContainer(pendingLabels, getConverter().convertStatements(slice)))
pendingLabels = ArrayList()
}
}
else {
pendingLabels.add(getConverter().statementToStatement(label))
pendingLabels.add(getConverter().convertStatement(label))
}
i += ls.size()
}
@@ -204,12 +204,12 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
}
public override fun visitSynchronizedStatement(statement: PsiSynchronizedStatement?) {
myResult = SynchronizedStatement(getConverter().expressionToExpression(statement?.getLockExpression()),
getConverter().blockToBlock(statement?.getBody()))
myResult = SynchronizedStatement(getConverter().convertExpression(statement?.getLockExpression()),
getConverter().convertBlock(statement?.getBody()))
}
public override fun visitThrowStatement(statement: PsiThrowStatement?) {
myResult = ThrowStatement(getConverter().expressionToExpression(statement?.getException()))
myResult = ThrowStatement(getConverter().convertExpression(statement?.getException()))
}
public override fun visitTryStatement(statement: PsiTryStatement?) {
@@ -217,29 +217,29 @@ public open class StatementVisitor(converter: Converter) : ElementVisitor(conver
val catchBlocks = statement?.getCatchBlocks()!!
val catchBlockParameters = statement?.getCatchBlockParameters()!!
for (i in 0..catchBlocks.size - 1) {
catches.add(CatchStatement(getConverter().parameterToParameter(catchBlockParameters[i], true),
getConverter().blockToBlock(catchBlocks[i], true)))
catches.add(CatchStatement(getConverter().convertParameter(catchBlockParameters[i], true),
getConverter().convertBlock(catchBlocks[i], true)))
}
myResult = TryStatement(getConverter().blockToBlock(statement?.getTryBlock(), true),
catches, getConverter().blockToBlock(statement?.getFinallyBlock(), true))
myResult = TryStatement(getConverter().convertBlock(statement?.getTryBlock(), true),
catches, getConverter().convertBlock(statement?.getFinallyBlock(), true))
}
public override fun visitWhileStatement(statement: PsiWhileStatement?) {
var condition: PsiExpression? = statement?.getCondition()
val expression: Expression = (if (condition != null && condition?.getType() != null)
this.getConverter().expressionToExpression(condition, condition?.getType())
this.getConverter().convertExpression(condition, condition?.getType())
else
getConverter().expressionToExpression(condition))
myResult = WhileStatement(expression, getConverter().statementToStatement(statement?.getBody()))
getConverter().convertExpression(condition))
myResult = WhileStatement(expression, getConverter().convertStatement(statement?.getBody()))
}
public override fun visitReturnStatement(statement: PsiReturnStatement?) {
val returnValue: PsiExpression? = statement?.getReturnValue()
val methodReturnType: PsiType? = getConverter().methodReturnType
val expression: Expression = (if (returnValue != null && methodReturnType != null)
this.getConverter().expressionToExpression(returnValue, methodReturnType)
this.getConverter().convertExpression(returnValue, methodReturnType)
else
getConverter().expressionToExpression(returnValue))
getConverter().convertExpression(returnValue))
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 {
if (myResult is EmptyType) {
myResult = ArrayType(myConverter.typeToType(arrayType?.getComponentType()), true, myConverter)
myResult = ArrayType(myConverter.convertType(arrayType?.getComponentType()), true, myConverter)
}
return myResult
@@ -76,7 +76,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
}
}
else {
myResult = ClassType(identifier, myConverter.typesToTypeList(classType.getParameters()), true, myConverter)
myResult = ClassType(identifier, myConverter.convertTypes(classType.getParameters()), true, myConverter)
}
return myResult
}
@@ -118,7 +118,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
val superTypes = p!!.getSuperTypes()
val boundType: Type = (if (superTypes.size > 0)
ClassType(Identifier(getClassTypeName(superTypes[0])),
myConverter.typesToTypeList(superTypes[0].getParameters()),
myConverter.convertTypes(superTypes[0].getParameters()),
true, myConverter)
else
StarProjectionType())
@@ -132,11 +132,11 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
public override fun visitWildcardType(wildcardType: PsiWildcardType?): Type {
if (wildcardType!!.isExtends()) {
myResult = OutProjectionType(myConverter.typeToType(wildcardType.getExtendsBound()))
myResult = OutProjectionType(myConverter.convertType(wildcardType.getExtendsBound()))
}
else
if (wildcardType.isSuper()) {
myResult = InProjectionType(myConverter.typeToType(wildcardType.getSuperBound()))
myResult = InProjectionType(myConverter.convertType(wildcardType.getSuperBound()))
}
else {
myResult = StarProjectionType()
@@ -145,7 +145,7 @@ public open class TypeVisitor(private val myConverter: Converter) : PsiTypeVisit
}
public override fun visitEllipsisType(ellipsisType: PsiEllipsisType?): Type {
myResult = VarArg(myConverter.typeToType(ellipsisType?.getComponentType()))
myResult = VarArg(myConverter.convertType(ellipsisType?.getComponentType()))
return myResult
}