[docs] CToSwift: Finish swift_name section

Struct/union fields, ObjC properties, ObjC methods

Author: jrose-apple

docs/CToSwiftNameTranslation.md

@@ -252,6 +252,8 @@ __attribute__((swift_name("SpacecraftCoordinates")))
 struct SPKSpacecraftCoordinates {
   double x, y, z, t; // space and time, of course
 };
+
+// Usually seen as NS_SWIFT_NAME.
 ```
 
 ```swift
@@ -287,12 +289,10 @@ The `swift_name` attribute can be used to give a C function a custom name. The v
 ```objc
 __attribute__((swift_name("doSomething(to:bar:)")))
 void doSomethingToFoo(Foo *foo, int bar);
-
-// Usually seen as NS_SWIFT_NAME.
 ```
 
 ```swift
-func doSomething(foo: UnsafeMutablePointer<Foo>, bar: Int32)
+func doSomething(to foo: UnsafeMutablePointer<Foo>, bar: Int32)
 ```
 
 An underscore can be used in place of an empty parameter label, as in Swift.
@@ -430,4 +430,86 @@ Although enumerators always have global scope in C, they are often imported as m
 
 _Currently, `swift_name` does not even allow importing an enum case as a member of the enum type itself, even if the enum is not recognized as an `@objc` enum, error code enum, or option set (i.e. the situation where a case is imported as a global constant)._
 
+
+### Fields of structs and unions; Objective-C properties
+
+The `swift_name` attribute can be applied to rename a struct or union field or an Objective-C property (whether on a class or a protocol). The value of the attribute must be a valid Swift identifier.
+
+```objc
+struct SPKSpaceflightBooking {
+  const SPKLocation * _Nullable destination;
+  bool roundTrip __attribute__((swift_name("isRoundTrip")));
+};
+```
+
+```swift
+struct SPKSpaceflightBooking {
+  var destination: UnsafePointer<SPKLocation>?
+  var isRoundTrip: Bool
+}
+```
+
+
+### Objective-C methods
+
+The `swift_name` attribute can be used to give an Objective-C method a custom name. The value of the attribute must be a full Swift function name, including parameter labels.
+
+```objc
+- (void)doSomethingToFoo:(Foo *)foo bar:(int)bar
+  __attribute__((swift_name("doSomethingImportant(to:bar:)")));
+```
+
+```swift
+func doSomethingImportant(to foo: UnsafeMutablePointer<Foo>, bar: Int32)
+```
+
+As with functions, an underscore can be used to represent an empty parameter label.
+
+Methods that follow the NSError out-parameter convention may provide one fewer parameter label than the number of parameters in the original method to indicate that a parameter should be dropped, but they do not have to. The `swift_error` attribute is still respected even when using a custom name for purposes of transforming an NSError out-parameter and the method return type.
+
+```objc
+- (BOOL)doSomethingRiskyAndReturnError:(NSError **)error
+  __attribute__((swift_name("doSomethingRisky()")));
+- (BOOL)doSomethingContrived:(NSString *)action error:(NSError **)outError
+  __attribute__((swift_name("doSomethingContrived(_:error:)")));
+```
+
+```swift
+func doSomethingRisky() throws
+func doSomethingContrived(_ action: String, error: ()) throws
+```
+
+A base name of "init" can be used on a *class* method that returns `instancetype` or the containing static type in order to import that method as an initializer. Any other custom name *prevents* a class method from being imported as an initializer even if it would normally be inferred as one.
+
+```objc
++ (Action *)makeActionWithHandler:(void(^)(void))handler
+  __attribute__((swift_name("init(handler:)")));
++ (instancetype)makeActionWithName:(NSString *)name
+  __attribute__((swift_name("init(name:)")));
+```
+
+```swift
+/* non-inherited */ init(handler: () -> Void)
+init(name: String)
+```
+
+A no-argument method imported as an initializer can be given a dummy argument label to disambiguate it from the no-argument `init()`, whether the method is an init-family instance method or a factory class method in Objective-C.
+
+```objc
+- (instancetype)initSafely
+  __attribute__((swift_name("init(safe:)")));
++ (instancetype)makeDefaultAction
+  __attribute__((swift_name("init(default:)")));
+```
+
+```swift
+init(safe: ())
+init(default: ())
+```
+
+A custom name on an instance method with one of Objective-C's subscript selectors (`objectAtIndexedSubscript:`, `objectForKeyedSubscript:`, `setObject:atIndexedSubscript:`, or `setObject:forKeyedSubscript:`) prevents that method from being imported as a subscript or used as the accessor for another subscript.
+
+_Currently, this only works if *both* methods in a read/write subscript are given custom names; if just one is, a read/write subscript will still be formed. A read-only subscript only has one method to rename._
+
+
 ## More to come...