Porting a third-party dependency (Ifrit)

[dfabulich]

I'm looking to add https://github.com/ukushu/Ifrit to my transpiled Skip app. It has zero dependencies of its own, and it's green on https://swift-everywhere.org/.

Initially, I tried just adding it as a package dependency. That sort of worked, but I could only use Ifrit in #if !SKIP blocks. I want to use it (use the same API) in Kotlin (transpiled from Swift), too.

I've read https://skip.tools/docs/porting/ but I'm still pretty stumped.

At the current latest commit ukushu/Ifrit@e6d21b0 I can run swift build and swift test. skip android build succeeds. skip android test mostly passes, with a few failures in performance tests and features that I don't think I need to use.

The porting guide says, "Once all your tests pass, you’ve successfully brought your Swift package to Android!" … but how do I actually use this "ported" library in my transpiled Skip app?

https://skip.tools/docs/dependencies/ says that when my transpiled app adds a dependency on "Pure Swift Package Manager Dependencies,"

Skip will see that the dependency does not have a Skip/skip.yml file and exclude it from the Android build.

So, now what? I guess I could fork the dependency and add a Skip/skip.yml file…? Is that what I'm supposed to do?

I also tried skip init --native skip-ifrit Ifrit and copying sources into the Sources directory.

To my surprise, I found that Ifrit failed to compile, with this error:

Sources/Ifrit/Ifrit/Levenstain/FuzzyFind/FuzzyResultSegment.swift:8:10 This release does not yet support bridging Character

Sure enough, Character is on the ❌ list on https://skip.tools/docs/bridging/. Key paths are also on the ❌ list; Ifrit uses a bunch of those.

I don't understand how Ifrit could possibly be green on https://swift-everywhere.org/ with this build error. Similarly, I don't understand how skip android build could succeed.

What's the difference between what skip android build does and what a --native framework build does?

[marcprux]

This comes down to the distinction between the native and transpiled modes. By default Skip runs in pure transpiled mode, but packages need to all be "Skip-aware", in that they use the skipstone plugin themselves (which Ifrit does not).

The native mode is newer, and enables you to use pure non-transpiled Swift that is compiled directly for Android. This gives you the power to access any Swift package, provided it can build for Android (e.g., it passes on https://swift-everywhere.org/).

In this particular case, you could run something like this:

skip init --native --appid=xyz.skip.Demo demo-app-native DemoApp DemoModule:ukushu/[email protected]/Ifrit:skip-foundation/SkipFoundation:skip-fuse/SkipFuse

This would create a Package.swift like:

// swift-tools-version: 5.9
// This is a Skip (https://skip.tools) package,
// containing a Swift Package Manager project
// that will use the Skip build plugin to transpile the
// Swift Package, Sources, and Tests into an
// Android Gradle Project with Kotlin sources and JUnit tests.
import PackageDescription

let package = Package(
    name: "demo-app-native",
    defaultLocalization: "en",
    platforms: [.iOS(.v17), .macOS(.v14), .tvOS(.v17), .watchOS(.v10), .macCatalyst(.v17)],
    products: [
        .library(name: "DemoAppApp", type: .dynamic, targets: ["DemoApp"]),
        .library(name: "DemoModule", type: .dynamic, targets: ["DemoModule"]),
    ],
    dependencies: [
        .package(url: "https://source.skip.tools/skip.git", from: "1.3.8"),
        .package(url: "https://source.skip.tools/skip-ui.git", from: "1.0.0"),
        .package(url: "https://github.com/skiptools/skip-foundation.git", from: "1.0.0"),
        .package(url: "https://github.com/skiptools/skip-fuse.git", from: "1.0.0"),
        .package(url: "https://github.com/ukushu/Ifrit.git", from: "2.0.0")
    ],
    targets: [
        .target(name: "DemoApp", dependencies: [
            "DemoModule",
            .product(name: "SkipUI", package: "skip-ui")
        ], resources: [.process("Resources")], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .testTarget(name: "DemoAppTests", dependencies: [
            "DemoApp",
            .product(name: "SkipTest", package: "skip")
        ], resources: [.process("Resources")], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .target(name: "DemoModule", dependencies: [
            .product(name: "SkipFoundation", package: "skip-foundation"),
            .product(name: "SkipFuse", package: "skip-fuse"),
            .product(name: "Ifrit", package: "Ifrit")
        ], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .testTarget(name: "DemoModuleTests", dependencies: [
            "DemoModule",
            .product(name: "SkipTest", package: "skip")
        ], plugins: [.plugin(name: "skipstone", package: "skip")]),
    ]
)

The DemoApp target is traditional transpiled Swift, but the DemoModule target is a pure native package, which is bridged using SkipFuse. From the DemoModule code, you will be able to access any native Swift package that compiles for Android, such as Ifrit.

Hopefully that makes sense. The native mode is relatively new for Skip, and so it isn't completely represented in the documentation. But it is a focus of much of our current efforts, so if you encounter issues with it, please do raise them with us.