The import for extension types is not added using swiftpoet 1.3.1.

FileSpec.builder("file")
  .addExtension(
    ExtensionSpec.builder(DeclaredTypeName.typeName("RxSwift.Observable"))
      .build()
  )
  .build()

The generated code is:

extension RxSwift.Observable {
}

But it should be:

import RxSwift

extension RxSwift.Observable {
}

To create lambda type i use FunctionTypeName.get but in all variants i can't pass escaping = true and as i see in sources - here no ways to change value after creation and also we can't use constructor from outside. so @escaping lamda can't be created, but logic for write this lambda - already done. need to add some way to change/set escaping flag

Declaring a function parameter with the same value for argumentLabel and parameterSpec produces a warning in xcode (often treated as error if the compiler setting is enabled). We should handle this while emitting code and only adding the argumentLabel when its value is different from parameterName

SwiftPoet implementation checks if the TypeSpec is a protocol when adding a nested type, however that rule is not 100% correct.

Here is a few scenarios that the current code can't handle correctly:

Scenario A: The nested type is a typealias

Protocols are allowed to have type aliases as nested types. Since TypeAliasSpec is a subclass of AnyTypeSpec the current implementation doesn't allow that. The following is a valid construct in Swift that cannot be built with SwiftPoet:

protocol MyProtocol {

  typealias NestedTypeAlias = String

}

Scenario B: Protocol is a nested type of a struct/class/enum

Protocols can't have nested types (other than type aliases) and cannot in any scenario be a nested type of another construct. The Swift compiler in such scenarios is Protocol 'Nested' cannot be nested inside another declaration. Therefore, the following code is possible to be built using SwiftPoet but it's invalid:

struct MyStruct {

  protocol MyNestedProtocol {
  }

}

Hey, just tried to generate a class only protocol:

protocol Test: class { ... }

but i think this is not supported (correct me if i'm wrong) since swiftpoet treats the class keyword as a reserved keyword.

If you wan't i can put a PR together to fix this - Some thoughts: We could just remove class from the reserved keywords and it would be possible but i first wanted to check with you if there would be a more elegant way to do it. Another thought i had was to add a val unsafe: Boolean to the DeclaredTypeName constructor to skip the keyword check.

What do you think?

SwiftPoet 1.4.1 causes this crash. As the code base is very complex and I can't toString the FileSpec I can't easily share a reproducer, but from the stacktrace it's pretty clear what happens. This worked fine in 1.4.0 and is caused by this change: 6da6707818e10677c3738b9dbe8435572eb15e5c

Caused by: java.lang.IndexOutOfBoundsException: Empty list doesn't contain element at index 0.
	at kotlin.collections.EmptyList.get(Collections.kt:36)
	at kotlin.collections.EmptyList.get(Collections.kt:24)
	at io.outfoxx.swiftpoet.CodeWriter.emitTypeVariables(CodeWriter.kt:159)
	at io.outfoxx.swiftpoet.FunctionSpec.emitSignature(FunctionSpec.kt:115)
	at io.outfoxx.swiftpoet.FunctionSpec.emit$swiftpoet(FunctionSpec.kt:62)
	at io.outfoxx.swiftpoet.FunctionSpec.emit$swiftpoet$default(FunctionSpec.kt:42)
	at io.outfoxx.swiftpoet.ExtensionSpec.emit$swiftpoet(ExtensionSpec.kt:95)
	at io.outfoxx.swiftpoet.FileMemberSpec.emit$swiftpoet(FileMemberSpec.kt:41)
	at io.outfoxx.swiftpoet.FileSpec.emit(FileSpec.kt:96)
	at io.outfoxx.swiftpoet.FileSpec.writeTo(FileSpec.kt:52)
	at io.outfoxx.swiftpoet.FileSpec.writeTo(FileSpec.kt:68)
	at io.outfoxx.swiftpoet.FileSpec.writeTo(FileSpec.kt:73)

Consider the following code

TypeSpec
        .structBuilder("TestStruct")
        .addTypeVariable(
            TypeVariableName.typeVariable(
                "T",
                TypeVariableName.bound(Bound1),
                TypeVariableName.bound(Bound2)
            ),
        )
        .build()

the generated struct will be:

struct TestStruct<T> where T : Bound1 where T : Bound2 {
}

but expected:

struct TestStruct<T> where T : Bound1, T : Bound2 {
}

An enum with no cases is valid in Swift, and such a definition is sometimes useful to provide "namespacing", such as:

enum Foo {
	struct Bar {…}
}

If the string starts with "switch " then do not automatically indent. Downside: we would have to maintain a boolean stack of calls to beginControlFlow such that on symmetric calls to nextControlFlow/endControlFlow know whether or not to unindent. As a result, this may not be worth doing! And that's fine.

This syntactical formatting oddity offends me, but apparently it's idiomatic. I just ported all my use of beginControlFlow for switch to addCode. I'm perfectly fine leaving it like that, but figured I'd file and see what others thought.

This is probably an insane feature to support fully, but perhaps we can distill targeted usage.

My sole use case is wrapping an entire extension like:

#if !FEATURE
extension Foo : Bar {}
#endif

When trying to create the property, the name is first checked to be valid so ones like "extension" fail.

https://github.com/outfoxx/swiftpoet/blob/9d7a1bbb90cb5eaf17d05ccf4297515d375caf19/src/main/java/io/outfoxx/swiftpoet/PropertySpec.kt#L167

If I switch to manually backticking the name I get past this check but then upon emit it's has an additional set of backticks added to it.

https://github.com/outfoxx/swiftpoet/blob/9d7a1bbb90cb5eaf17d05ccf4297515d375caf19/src/main/java/io/outfoxx/swiftpoet/PropertySpec.kt#L45

This produces something like

struct Foo {
  let ``extension``: String
}

It seems like one or the other behaviors need removed. Either a property allows all names and then escapes with backticks if necessary, or it still does validation on the way in and then does not escape when emitting.

• ~References to Kotlin files and other incorrect terminology need to be updated or removed.~
• All classes need have at least basic documentation.
• README should have more/better examples of Swift generation.

Since the members of a class/struct/enum are emitted in a particular order, "MARK" comments could be produced between the sections to aid in navigation in xcode.

Something like

class Foo {

  // MARK Public Properties

  public var bar: Bar

  // MARK Private properties

  var baz: Baz

  // MARK Initializers

  ..

  // MARK Public functions

  ..

  // MARK Private functions

  ..
}