angelolloqui / swiftkotlin Goto Github PK

View Code? Open in Web Editor NEW

2.9K 92.0 197.0 2.47 MB

A tool to convert Swift code to Kotlin.

License: MIT License

Swift 88.66% Kotlin 11.34%

swiftkotlin's Introduction

swiftkotlin's People

Contributors

Stargazers

Watchers

Forkers

dotkebi jonnermut albodelu carabina fairyfeather d553296416 honeybeeswinging cww1987521 repoforks xiaoruiling ranjitdhiman1990 onekyle linecode gabrielpeart arrmac liam-i conqs khose supercomputra yangyouyong alvincrisuy fish-red mohsinalimat mherod rickie1219 shaufi10 joseph-hurtado nar9 hhy5277 kamirana4 khlljm tomdwipo nlory-ma rambolouis albinekcom johndpope hiddengithub pigherot patriciadumontier victorlaerte fabian7593 chaoboyan massimiliano76 krmao ithoughts up1 jn7163 misanyrock johnxianwenhua xiaocc phonex34 birowo levi7754 devenlu matrixy developerit05 socialdiabetes xubojoy programming086 nvhungiph codetalks-new jianfang-kso nighthearter iamwee marinehero bobbyski swifth riugduso nitikorndev mdabbagh88 manuelgon47 tritus hushizhi123 aiephoenix sd10 hlineholm lmick002 mhtranbn johankool xujun05 ranapnea noor0302 reversescale msdgwzhy6 pradeeppappuato l3bel yanyan1119 mjasa kalpeshtalkar viocode shubhamhackz appimuqtadir jeevanpandey andyfangjunjie aboazozxavi6 franklichao qaavi ggrell renesugar myashesh

swiftkotlin's Issues

Kotlin to Swift?

Is there a plan to develop a Kotlin -> Swift tool?

get/set property in protocol

Swift:

    var isPromotionLoading: Bool { get set }

Translated:

    var isPromotionLoading: Boolean {
        get
        set
    }

Correct translated

var isPromotionLoading: Boolean

Switch cases with where clauses not translated properly

In Swift, switch cases can contain where clauses like the following:

switch exception {
case .generic(let error) where error != nil:
    trackError(name: "generic", message: error!)
default:
    trackError(name: "generic", message: R.string.localizable.generic_error())
}

Currently, SwiftKotlin generates:

when (exception) {
    .generic where error != null -> trackError(name = "generic", message = error!!)
    else -> trackError(name = "generic", message = R.string.localizable.generic_error())
}

But that is incorrect Kotlin. It should instead remove the variable from the when and use expressions for the cases. Like:

when {
    exception is Exception.generic && error != null -> trackError(name = "generic", message = error!!)
    else -> trackError(name = "generic", message = R.string.localizable.generic_error())
}

Static constants not properly mapped to Companion objects

This Swift:

public struct VoucherCampaign {
    public static let inviteFriendsId = VoucherCampaignId("INVITE_FRIENDS")
}

Translates to:

public data class VoucherCampaign(
public val inviteFriendsId = VoucherCampaignId("INVITE_FRIENDS")
) {}

But should have a companion object with the static constant:

public data class VoucherCampaign {
    object Companion {
        val inviteFriendsId = VoucherCampaignId("INVITE_FRIENDS")
    }
}

update docs for gaurd clauses in kotlin

you can replace

val data = someOptional
if(data == null) return

with

val data = someOptional ?: return

Add support for string interpolation

String interpolation in Swift

"An error \(error) occurred"

could be converted to

"An error $error occurred"

Translate complex enums to Sealed classes

When an enum in Swift contains tuples must be transltated to Sealed classes, which is the closest in Kotlin.

Example:

Swift:

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(named: String)
    case empty
}

Koltin:

sealed class Barcode {
   data class upc(val v1: Int, val v2: Int, val v3: Int, val v4: Int) : Barcode()
   data class qrCode(val named: String) : Barcode()
   object empty : Barcode()
}

Hey there!
I am a Swift developer who is studying Android development.
As a mobile application developer, I was impressed with your work.
I would like to introduce these good works to Koreans.
Is there any chance that I can help translate Readme.md to Korean?

Remove unecessary {} on method definitions

When body is empty, Kotlin allows to remove the {}

Example:

class A {
    init() {}
    func test() {}
}

Translates to:

class A {
    constructor() {}
    fun test() {}
}

But could be:

class A {
    constructor()
    fun test()
}

Switch cases with tuple decomposition values does not translate properly

This Swift code:

switch exception {
case .qrCode(let name):
    trackCode(name: name)
default:
    trackError(name: "generic")
}

Translates to right now to:

when (exception) {
    .qrCode -> trackCode(name = name)
    else -> trackError(name = "generic")
}

However, the name variable in Swift has been decomposed from the tuple, and hence the Kotlin version should prefix its usage with the variable in the when expression. In this case:

when (exception) {
    .qrCode -> trackCode(name = exception.name)
    else -> trackError(name = "generic")
}

Switch cases with multiple lines not properly indented by {}

This Swift switch:

switch exception {
            case .network(_, _, let serverMessage):
                if let message = serverMessage {
                    trackError(name: message.status, message: message.message)
                } else {
                    trackError(name: "network", message: R.string.localizable.network_error())
                }
            case .generic(let error):
                trackError(name: "generic", message: error)
            default:
                trackError(name: "generic", message: R.string.localizable.generic_error())
            }

Translates to:

when (exception) {
    .network -> val message = serverMessage
    if (message != null) {
        trackError(name = message.status, message = message.message)
    } else {
        trackError(name = "network", message = R.string.localizable.network_error())
    }
    .generic -> trackError(name = "generic", message = error)
    else -> trackError(name = "generic", message = R.string.localizable.generic_error())
}

But should add {} like:

when (exception) {
    .network -> {
        val message = serverMessage
        if (message != null) {
            trackError(name = message.status, message = message.message)
        } else {
            trackError(name = "network", message = R.string.localizable.network_error())
        }
    }
    .generic -> trackError(name = "generic", message = error)
    else -> trackError(name = "generic", message = R.string.localizable.generic_error())
}

SwiftKotlinApp changes text selection while writing

When using SwiftKotlinApp, if you type new text into the Swift text area input, the translator runs for every key pressed, formatting the written text, and hence making the text selection invalid. As a result, typing on the text area is unusable.

Possible solutions:

Try to keep the focus on the proper place: This might be difficult considering that the format will be dynamically changed, so the position could not be identical after running.
Do not run the translator until some time passes: Only when idle, run the translator. The problem will still happen but less frequently, probably making the solution "good enough" for usage
Add a button to "format" the Swift code, and apply that as a manual action. Word highlighting will not be shown until the format happens.

Optimize single line body methods

Kotlin allows for = methods instead of { return.

Example:

func mapToUserItem(user: User) -> UserItem {
    return UserItem(name: user.fullName)
}

Translates to:

fun mapToUserItem(user: User) : UserItem {
    return UserItem(name = user.fullName)
}

But could be:

fun mapToUserItem(user: User)  =
    UserItem(name = user.fullName)

Generic parameter clause in methods not properly placed

This Swift:

public func whenAll<T>(promises: [Promise<T>]) -> Promise<[T]> {
	return Promise<T>()
}

translates to:

public fun whenAll<T>(promises: List<Promise<T>>) : Promise<List<T>> {
    return Promise<T>()
}

However, the place of <T> is wrong, and should be at the beginning like:

public fun <T> whenAll(promises: List<Promise<T>>) : Promise<List<T>> {
    return Promise<T>()
}

Transform uppercased()

Swift:
stringVar.uppercased()

Kotlin:
stringVar.toUpperCase()

Use invoke when calling an optional lambda

In Swift, this is possible:

let optionalLambda: (() -> Void)? = nil
...
optionalLambda?()

But in Kotlin, it should be:

val optionalLambda: (() -> Unit)? = null 
...
optionalLambda?.invoke()

Allow Semicolons in Swift Code

I'm brand new to Kotlin. I'm actually hoping to learn quite a lot about Kotlin by looking at translations created by SwiftKotlin. I put the following very basic swift class definition into SwiftKotlin 0.1.0 and nothing happened. No output. No error messages. It seems like this swift code cannot be translated.

class Person {

    private let name: String;

    init(name: String) {
        self.name = name;
    }

    func getName() -> String {
        return self.name;
    }

}

What to do?

Add plugin with basic support for UIKit -> Android widget conversions

Optional plugin that could transform some types:

UIView -> View
UITextField -> EditText
UIButton -> Button
UILabel -> Label
UITableView -> RecyclerView
UIScrollView -> ScrollView
UIImageView -> ImageView
...

Then, as part of the same or other plugin, we could also make use of Butterknife (http://jakewharton.github.io/butterknife/) to map @IBOutlet to @BindView(R.id.<variable_name>) and @IBAction to @OnClick(), which is not always the event we want but most of the times.

Resulting code will be far from funcional, but of a good starting point when converting UIKIt views to Android views.

Format Variable Number Of Arguments

Varargs in Swift are:

func sumOf(_ numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf(42, 597, 12)

And in Kotlin:

fun sumOf(vararg numbers: Int): Int {
    var sum = 0
    for (number in numbers) {
        sum += number
    }
    return sum
}
sumOf(42, 597, 12)

Any plans for Kotlin <-> Swift?

Hi there,

Are there any plans for implementing similar conversion the other way, from Kotlin to Swift?

If not, are you aware of any libraries like SwiftFormat for Kotlin or have any advice on how one would approach this task?

Thanks for the great work!

Preserve original comments

Current version transforms Swift code to an AST and then back to Kotlin, but the initial comments get removed.

A possible solution would be to look for all comments (contained in the TopDeclaration) and look for the closest node in the Swift code and place it next to the first corresponding Kotlin token. This strategy could result in comments wrongly placed in some circumstances, but should work OK on most cases.

Download page?

Hi there, you mention binaries are available for download on the info page but don't see any downloads enabled in GitHub. Mind please adding the release do that we don't have to build from sources for it?

Thx!

Optimize guard unwrapping expressions

Kotlin allows ternary operators to return.

This code:

func showTenants() {
    guard let intent = coordinator.tenantsIntent() else {
        return
    }
    navigationManager.show(intent, animation: .push)
}

Translates to

fun showTenants() {
    val intent = coordinator.tenantsIntent()
    if (intent == null) {
        return
    }
    navigationManager.show(intent, animation = .push)
}

But could be

fun showTenants() {
    val intent = coordinator.tenantsIntent() ?: return
    navigationManager.show(intent, animation = .push)
}

Add feedback error messages when Swift is incorrect

When the Swift code can not be parsed and error message should be displayed.

Convert basic operators

Swift allows for custom operators. In Kotlin, operators are restricted to:
https://kotlinlang.org/docs/reference/operator-overloading.html

Transform the operators that have a Kotlin counterpart. Example:

public func + (left: Price, right: Price) -> Price {
    return Price(amount: left.amount + right.amount, currency: left.currency)
}
public func - (left: Price, right: Price) -> Price {
    return Price(amount: left.amount - right.amount, currency: left.currency)
}

Translates to:

operator fun Price.plus(price: Price) =
        Price(amount = this.amount + price.amount, currency = this.currency)

operator fun Price.minus(price: Price) =
        Price(amount = this.amount - price.amount, currency = this.currency)

Remove underscore assignments

In Swift, when not using a method/function result, it is common to write:

        _ = service.refresh(cart: cart)

However, in Kotlin the resulting code:

_ = service.refresh(cart = cart)

Is not valid because underscore is reserved for lambdas.

It should just be removed like:

service.refresh(cart = cart)

reduce function

Swift:

            .reduce(0, +)

Translated:

            .reduce(0, +)

Should be translated to:

                .fold(0.0) { total, next ->
                    total + next
                }

Consider using an AST based parser

Hi Angel!

Just stumbled upon this project, very cool implementation you've got. Figured I'd suggest considering an AST based parser since implementing type specific conversions like the array append/add limitation listed in your Readme should be easier than with your current tokenizer. SwiftLint leverages SourceKit for this reason.

Transform foundation methods

List of some methods that could be transformed.

On List:

list.first --> list.firstOrNull()
list.last --> list.lastOrNull()
list.count --> list.size
list.isEmpty --> list.isEmpty()
list.index(of: a) --> list.indexOf(a)
list.append(element) --> list.add(element)
list.remove(at: index) --> list.removeAt(index)
list.sorted(by: lambda) --> sortedWith(comparator = Comparator(lambda))
list.joined(separator: joiner) --> elements. joinToString(separator = joiner)

On String:

string.count --> string.length
string.uppercased() --> string.toUpperCase()
string.lowercased() --> string.toLowerCase()

typing double quotes into SwiftKotlin app becomes curly quotes

I tried typing the following into SwiftKotlin app. As I type it, the editor converts the first double quotation mark into curly quotes. Then the line cannot be translated because there is a parsing error.

let s: String = "abc"

If I copy and paste the above into SwiftKotlin app, the translation to Kotlin happens successfully.

Removed unnecessary annotations in Kotlin

In Swift, there are some annotations that have no meaning in Kotlin. Some examples:

@escaping
@autoclosure
@discardableResult

Remove this annotations when translating

conversion of lazy properties

This Swift

private lazy var name: String = {() -> String in
    return "abc"
}()

is translated to the following Kotlin

private lazy var name: String = {   -> 
    return "abc"
}()

I think it should result in the following Kotlin.

private val name: String by lazy {
    "abc"
}

The var, val issue is tricky. The return issue is tricky.

Remove unnecesary {} in string interpolators

Strings with simple expressions can remove the {}.

Example:

"\(day), \(date.totalTime)"

Translates to

"${day}, ${date.totalTime}"

But could be

"$day, ${date.totalTime}"

Transform ternary expression

Transform ternary expression like:

let label = x > 0 ? "Positive" : "negative"

to Kotlin:

val label = if (x > 0) "Positive" else "negative"

Translate Unicode character literals in strings

Swift "\u{016C}"
is translated to Kotlin "\u{016C}"
but should be translate to Kotlin "\u016C"

Remove @escaping annotations

This Swift:

func validate(callback: @escaping ((Voucher) -> Void))

Should be:

fun validate(callback: ((Voucher) -> Unit))

Missing Files

Unable to build. The following file are missing: Formatter.swift and Tokenizer.swift

Implement didSet and willSet observable properties

In Swift, as part of the language, a property can have a didSet and/or willSet. Example:

class A {
    var isLocating = false {
        didSet {
            delegate.set(isLocating: isLocating) 
        }
    }
}

In Kotlin there is no default way of expressing property observers but can be done with delegated properties or by writing a custom setter (https://stackoverflow.com/a/39842353/378433)

For simplicity, implement a custom setter like:

class A {
    var isLocating = false
        set(value) {
            field = value
            delegate.set(isLocating = value)
        }
}

In case of willSet, just write the code before the field = value assignment

let function inside lambda is translated to val

        if let intent = coordinator.methodName(param1: param1, param2: param2, onComplete: {
            self.view.let { self.navigationManager.dismiss(view: $0, animated: true) }
        }) {
            navigationManager.show(intent, animation: .present)
        }

Translated:

        val intent = coordinator.methodName(param1: param1, param2: param2, onComplete = {
            this.view.val { this.navigationManager.dismiss(view = it, animated = true) }
        })
        if (intent != null) {
            navigationManager.show(intent, animation = .present)
        }

Correct Translate:

        val intent = coordinator.methodName(param1: param1, param2: param2, onComplete = {
            this.view?.let { this.navigationManager.dismiss(view = it, animated = true) }
        })
        if (intent != null) {
            navigationManager.show(intent, animation = .present)
        }

miss files

:0: error: no such file or directory: '/Users/james/Desktop/download/SwiftKotlin-develop/Source/SwiftKotlinFramework/External/SwiftFormat/SwiftFormat/Tokenizer.swift'
:0: error: no such file or directory: '/Users/james/Desktop/download/SwiftKotlin-develop/Source/SwiftKotlinFramework/External/SwiftFormat/SwiftFormat/Formatter.swift'

Remove -> from lambdas when no parameter

This code:

func changePhoto(picture: Data) {
    userService.updateUser(picture: picture).always { [weak self] in
        self?.hasPhoto = true
    }
}

Translates to

fun changePhoto(picture: Data) {
    userService.updateUser(picture = picture).always {   -> 
        this?.hasPhoto = true
    }
}

But could be improved removing the ->

Kotlin -> Swift

If you can code in swift and go to kotlin, you can code in kotlin and go to swift ?

When capturing self as weak, remove ?

In Swift, it is common in lambdas to capture self in weak mode and use self? inside the lambda body.

In Kotlin, due to GC, this is unnecesary and the ? must be removed.

Example:

func changePhoto(picture: Data) {
    userService.updateUser(picture: picture).always { [weak self] in
        self?.hasPhoto = true
    }
}

Translates to:

fun changePhoto(picture: Data) {
    userService.updateUser(picture = picture).always {  
        this?.hasPhoto = true
    }
}

But must be

fun changePhoto(picture: Data) {
    userService.updateUser(picture = picture).always {  
        this.hasPhoto = true
    }
}

Optional chainning in Kotlin requires optional checks in all expressions

In Swift, the optional check can be done on the optional properties only when chaining.

Example:

Given this Swift:

struct User {
    let name: String
}
func optionalUser() -> User? {
    return nil
}

This sentence in Swift is correct:

optionalUser()?.name.count

But in Kotlin, it should be:

optionalUser()?.name?.count

(Note the carried ? on the chaining)

Add support for fatalError()

A fatal error in Swift

fatalError("An error \(error) occurred")

could be converted to

throw Exception("An error $error occurred")

Guard with more than one let

Swift:

guard array.count > row,
            let a = CustomView.viewFor(item: array1[column].array[row]), 
            let b = something(a) else {
                return UIView()
            }
           ...

Tool Return:

val a = CustomView.viewFor(item = array1[column].array[row])
val b = somethin(a)
if (array.size <= row || playerView == null || b == null) {
    return UIView()
}
...

Correct return:

if (array.size <= row) return UIView()
val a = CustomView.viewFor(item = array1[column].array[row]) ?: return UIView()
val b = somethin(a) ?: return UIView()
...

Initialize nullable properties to null

In swift, nullable properties have a default value of nil. However, in Kotlin they need explicit initialization.

Example:

This Swift:

class PaymentSelectorPresenter {
    private var selectedPaymentMethod: PaymentMethod?
}

Translates to:

class PaymentSelectorPresenter {
    private var selectedPaymentMethod: PaymentMethod?
}

But should be:

class PaymentSelectorPresenter {
    private var selectedPaymentMethod: PaymentMethod? = null
}

Error when running from xcode

Hi there, this code looks interestin. However, i get the following error when i run from xcode
"Command /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swiftc failed with exit code 1"
Grateful for any kind of help.

Translate simple enums to Kotlin

Simple Swift enums (without associated values) look like:

enum CompassPoint {
    case north
    case south
    case east
    case west
}

In Kotlin translates to:

enum class CompassPoint {
    north, south, east, west
}

Enums with inheritance not working

This swift enum:

public enum AnemoneException: Error {
    case notFound
    case network(HttpResponse, Error?)
}

Can be translated to a sealed class. However, the current version does not work because of the inheritance clause. Removing the inheritance translates to:

public sealed class AnemoneException {
    object notFound : AnemoneException()
    data class network(val v1: HttpResponse, val v2: Error?) : AnemoneException()
}

angelolloqui / swiftkotlin Goto Github PK

swiftkotlin's Introduction

SwiftKotlin

What is this?

Why use SwiftKotlin?

Why Kotlin?

Benefits over shared code across platforms

Limitations

Status

Installation

Usage

Command line tool

License

Collaboration

Credits

swiftkotlin's People

Contributors

Stargazers

Watchers

Forkers

swiftkotlin's Issues

Recommend Projects

Recommend Topics

Recommend Org