Refactor toString generation to use the standard method generation path

[sidepelican]

Motivation

Currently, the implementations for toString and toDebugString methods are handled by dedicated, hardcoded logic.
However, these methods are fundamentally identical to standard function calls in terms of their underlying mechanism.

This inconsistency makes it difficult to maintain parity with other parts of the generator. Specifically, as I work on implementing support for function calls in generic type, I find myself having to write redundant specialized logic just for toString, which adds unnecessary complexity.

Changes

Treat toString and toDebugString as ImportedFunc.
This allows them to be processed through the general method generation path.

Note

While this change also affects FFM mode, it will currently be ignored because String return values are not yet supported in that mode.

[madsodgaard]

Instead of adding these to SwiftAPIKind, perhaps we should introduce a new type SynethesizedAPI (or something) else to describe these sort of functions like toString etc?

[sidepelican]

Thank you for the feedback. Do you have a specific vision or any examples of how you'd like to implement SynthesizedAPI?

[madsodgaard]

Hm, I was just thinking of adding it to the ImportedFunc as an optional and then we would do

enum SynthesizedAPI {
  case toString
  case toDebugString

Just an idea to not pollute the SwiftAPIKind, as it seems like it should only concern itself with Swift language APIs

[sidepelican]

I believe it's important to ensure we can handle the branching logic correctly in the following locations:

swift-java/Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift

Line 986 in 292af76

switch apiKind {

swift-java/Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

Line 614 in 292af76

switch decl.apiKind {

Considering this, I think SynthesizedAPI should be integrated into SwiftAPIKind as an associated value, like this:

enum SynthesizedAPI { 
  case toString, toDebugString
}

enum SwiftAPIKind {
  case function(SynthesizedAPI?)
  case initializer
  case getter
  case setter
  case enumCase
  case subscriptGetter
  case subscriptSetter
}

Does this approach look good to you?

(In this case, SynthesizedFunction might be a better than SynthesizedAPI.)

[ktoso]

maybe it's function and synthesizedFunction(SynthesizedAPI) in that case?