---

yaml
---
r: 326205
b: refs/heads/master-next
c: 4804444
h: refs/heads/master
i:
  326203: 3cc993d

Author: rintaro

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: f919b2ddd866dbf90a38612a4ba711253e85d280
+refs/heads/master-next: 4804444c145de553dfd23eb5a7a1b85be7181663
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/docs/CToSwiftNameTranslation.md

@@ -1,6 +1,6 @@
 # Name Translation from C to Swift
 
-This document gives a high-level description of how C and Objective-C declarations are translated to Swift, with particular focus on how names are adjusted. It is not attempting to be a *complete* description of everything the compiler does except with regards to how *names* are transformed; even there, some special cases that only apply to Apple's SDKs have been omitted.
+This document gives a high-level description of how C and Objective-C declarations are translated to Swift, with particular focus on how names are adjusted. It is not attempting to be a *complete* description of everything the compiler does except with regards to how *names* are transformed; even there, some special cases that only apply to Apple's SDKs have been omitted. The example code shown is for illustrative purposes and does not always include all parts of an imported API's interface.
 
 ## Word boundaries
 
@@ -239,4 +239,208 @@ _The original intent of the `swift_private` attribute was additionally to limit
 _For "historical reasons", the `swift_private` attribute is ignored on factory methods with no arguments imported as initializers. This is essentially matching the behavior of older Swift compilers for source compatibility in case someone has marked such a factory method as `swift_private`._
 
 
+## Custom names
+
+The `swift_name` Clang attribute can be used to control how a declaration imports into Swift. If it's valid, the value of the `swift_name` attribute always overrides any other name transformation rules (prefix-stripping, underscore-prepending, etc.)
+
+### Types and globals
+
+The `swift_name` attribute can be used to give a type or a global a custom name. In the simplest form, the value of the attribute must be a valid Swift identifier.
+
+```objc
+__attribute__((swift_name("SpacecraftCoordinates")))
+struct SPKSpacecraftCoordinates {
+  double x, y, z, t; // space and time, of course
+};
+```
+
+```swift
+struct SpacecraftCoordinates {
+  var x, y, z, t: Double
+}
+```
+
+### Import-as-member
+
+A custom name that starts with an identifier followed by a period is taken to be a member name. The identifier should be the imported Swift name of a C/Objective-C type in the same module. In this case, the type or global will be imported as a static member of the named type.
+
+```objc
+__attribute__((swift_name("SpacecraftCoordinates.earth")))
+extern const struct SPKSpacecraftCoordinates SPKSpacecraftCoordinatesEarth;
+```
+
+```swift
+extension SpacecraftCoordinates {
+  static var earth: SpacecraftCoordinates { get }
+}
+```
+
+Note that types cannot be imported as members of protocols.
+
+_The "in the same module" restriction is considered a technical limitation; a forward declaration of the base type will work around it._
+
+
+### C functions with custom names
+
+The `swift_name` attribute can be used to give a C function a custom name. The value of the attribute must be a full Swift function name, including parameter labels.
+
+```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)
+```
+
+An underscore can be used in place of an empty parameter label, as in Swift.
+
+A C function with zero arguments and a non-`void` return type can also be imported as a computed variable by using the `getter:` prefix on the name. A function with one argument and a `void` return type can optionally serve as the setter for that variable using `setter:`.
+
+```objc
+__attribute__((swift_name("getter:globalCounter()")))
+int getGlobalCounter(void);
+__attribute__((swift_name("setter:globalCounter(_:)")))
+void setGlobalCounter(int newValue);
+```
+
+```swift
+var globalCounter: Int32 { get set }
+```
+
+Note that the argument lists must still be present even though the name used is the name of the variable. (Also note the `void` parameter list to specify a C function with zero arguments. This is required!)
+
+Variables with setters and no getters are not supported.
+
+
+#### Import-as-member
+
+Like types and globals, functions can be imported as static members of types.
+
+```objc
+__attribute__((swift_name("NSSound.beep()")))
+void NSBeep(void);
+```
+
+```swift
+extension NSSound {
+  static func beep()
+}
+```
+
+However, by giving a parameter the label `self`, a function can also be imported as an instance member of a type __T__. In this case, the parameter labeled `self` must either have the type __T__ itself, or be a pointer to __T__. The latter is only valid if __T__ is imported as a value type; if the pointer is non-`const`, the resulting method will be `mutating`. If __T__ is a class, the function will be `final`.
+
+```objc
+typedef struct {
+  int value;
+} Counter;
+
+__attribute__((swift_name("Counter.printValue(self:)")))
+void CounterPrintValue(Counter c);
+__attribute__((swift_name("Counter.printValue2(self:)")))
+void CounterPrintValue2(const Counter *c);
+__attribute__((swift_name("Counter.resetValue(self:)")))
+void CounterResetValue(Counter *c);
+```
+
+```swift
+struct Counter {
+  var value: Int32 { get set }
+}
+
+extension Counter {
+  func printValue()
+  func printValue2()
+  mutating func resetValue()
+}
+```
+
+This also applies to getters and setters, to be imported as instance properties.
+
+```objc
+__attribute__((swift_name("getter:Counter.absoluteValue(self:)")))
+int CounterGetAbsoluteValue(Counter c);
+```
+
+```swift
+extension Counter {
+  var absoluteValue: Int32 { get }
+}
+```
+
+The getter/setter syntax also allows for subscripts by using the base name `subscript`.
+
+```objc
+__attribute__((swift_name("getter:LinkedListOfInts.subscript(self:_:)")))
+int LinkedListGetAtIndex(const LinkedListOfInts *head, int index);
+```
+
+```swift
+extension LinkedListOfInts {
+  subscript(_ index: Int32) -> Int32 { get }
+}
+```
+
+Finally, functions can be imported as initializers as well by using the base name `init`. These are considered "factory" initializers and are never inherited or overridable. They must not have a `self` parameter.
+
+```objc
+__attribute__((swift_name("Counter.init(initialValue:)")))
+Counter CounterCreateWithInitialValue(int value);
+```
+
+```swift
+extension Counter {
+  /* non-inherited */ init(initialValue value: Int32)
+}
+```
+
+
+### Enumerators (enum cases)
+
+The `swift_name` attribute can be used to rename enumerators. As mentioned above, not only does no further prefix-stripping occur on the resulting name, but the presence of a custom name removes the enum case from the computation of a prefix for the other cases.
+
+```
+// Actual example from Apple's SDKs; in fact, the first shipping example of
+// swift_name on an enumerator at all!
+typedef NS_ENUM(NSUInteger, NSXMLNodeKind) {
+  NSXMLInvalidKind = 0,
+  NSXMLDocumentKind,
+  NSXMLElementKind,
+  NSXMLAttributeKind,
+  NSXMLNamespaceKind,
+  NSXMLProcessingInstructionKind,
+  NSXMLCommentKind,
+  NSXMLTextKind,
+  NSXMLDTDKind NS_SWIFT_NAME(DTDKind),
+  NSXMLEntityDeclarationKind,
+  NSXMLAttributeDeclarationKind,
+  NSXMLElementDeclarationKind,
+  NSXMLNotationDeclarationKind
+};
+```
+
+```
+public enum Kind : UInt {
+  case invalid
+  case document
+  case element
+  case attribute
+  case namespace
+  case processingInstruction
+  case comment
+  case text
+  case DTDKind
+  case entityDeclaration
+  case attributeDeclaration
+  case elementDeclaration
+  case notationDeclaration
+}
+```
+
+Although enumerators always have global scope in C, they are often imported as members in Swift, and thus the `swift_name` attribute cannot be used to import them as members of another type unless the enum type is anonymous.
+
+_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)._
+
 ## More to come...

branches/master-next/include/swift/AST/Builtins.def

@@ -51,32 +51,98 @@ BUILTIN_CAST_OR_BITCAST_OPERATION(SExtOrBitCast,  "sextOrBitCast",  "n")
 #undef BUILTIN_CAST_OR_BITCAST_OPERATION
 
 /// Binary operations have type (T,T) -> T.
+///
+/// We define two different sorts of operations varying when T is static,
+/// specifically:
+///
+/// 1. Overloaded statically typed operations. E.x:
+///
+///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32.
+///
+/// 2. Polymorphic typed operations that are valid only in raw SIL. By the time
+///    diagnostic constant propagation runs, these must have as its operand a
+///    fully specialized type. If the builtin has a type that is not one of its
+///    overloaded types, diagnostic constant propagation will emit a diagnostic
+///    saying the builtin's type has not been fully resolved. Otherwise,
+///    diagnostic constant propagation will transform the builtin to the
+///    relevant static overloaded builtin form. E.x.:
+///
+///       builtin "add"(Self, Self) : Self // *error*
+///
+///         OR
+///
+///       builtin "generic_add"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
+///         ->
+///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
+///
+/// NOTE: If a polymorphic typed operation is not static by the time guaranteed
+/// constant propagation runs, we emit a diagnostic to inform the user (who is
+/// assumed to be an expert user) to tell them the value was unspecialized. The
+/// typical way this specialization occurs today is via transparent inlining
+/// since the transparent inliner devirtualizes and specializes as it goes. Of
+/// course this means mandatory inlining must /always/ occur before diagnostic
+/// constant propagation.
+///
+/// NOTE: Often times the builtin infrastructure wants to treat all
+/// binary operation builtins generic or not the same way. To ensure
+/// we support all use cases in the compiler, we do not declare the
+/// operations as part of this builtin since often times this macro is
+/// used to generic code. Instead, we stamp this out using the
+/// overloaded_static, polymorphic, and all suffixed operations.
 #ifndef BUILTIN_BINARY_OPERATION
-#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs, Overload) \
-          BUILTIN(Id, Name, Attrs)
+#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
 #endif
-BUILTIN_BINARY_OPERATION(Add,     "add",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FAdd,    "fadd",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(And,     "and",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(AShr,    "ashr",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(LShr,    "lshr",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Or,      "or",       "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FDiv,    "fdiv",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(Mul,     "mul",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FMul,    "fmul",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(SDiv,    "sdiv",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(ExactSDiv, "sdiv_exact", "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Shl,     "shl",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(SRem,    "srem",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Sub,     "sub",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FSub,    "fsub",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(UDiv,    "udiv",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(ExactUDiv, "udiv_exact", "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(URem,    "urem",     "n", Integer)
-BUILTIN_BINARY_OPERATION(FRem,    "frem",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(Xor,     "xor",      "n", IntegerOrVector)
-// This builtin is an optimizer hint and always returns the first argument.
-BUILTIN_BINARY_OPERATION(Expect, "int_expect", "n", Integer)
+
+#ifdef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
+#error "Do not define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR before including this .def file"
+#endif
+
+#define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(NAME) #NAME
+
+#ifndef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
+#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, Name, Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION(Id, Name, Attrs)
+#endif
+
+#ifndef BUILTIN_BINARY_OPERATION_POLYMORPHIC
+#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(Id, Name, Attrs) \
+  BUILTIN_BINARY_OPERATION(Id, Name, Attrs)
+#endif
+
+// TODO: This needs a better name. We stringify generic_ in *_{OVERLOADED_STATIC,POLYMORPHIC}
+#ifndef BUILTIN_BINARY_OPERATION_ALL
+#define BUILTIN_BINARY_OPERATION_ALL(Id, Name, Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(Name), Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION_POLYMORPHIC(Generic##Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(generic_##Name), Attrs)
+#endif
+
+// NOTE: Here we need our name field to be bare. We stringify them as
+// appropriately in BUILTIN_BINARY_OPERATION_{OVERLOADED_STATIC,POLYMORPHIC}.
+BUILTIN_BINARY_OPERATION_ALL(Add,     add,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FAdd,    fadd,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(And,     and,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(AShr,    ashr,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(LShr,    lshr,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Or,      or,       "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FDiv,    fdiv,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Mul,     mul,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FMul,    fmul,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(SDiv,    sdiv,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(ExactSDiv, sdiv_exact, "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Shl,     shl,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(SRem,    srem,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Sub,     sub,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FSub,    fsub,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(UDiv,    udiv,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(ExactUDiv, udiv_exact, "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(URem,    urem,     "n", Integer)
+BUILTIN_BINARY_OPERATION_ALL(FRem,    frem,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Xor,     xor,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Expect, "int_expect", "n", Integer)
+#undef BUILTIN_BINARY_OPERATION_ALL
+#undef BUILTIN_BINARY_OPERATION_POLYMORPHIC
+#undef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
+#undef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
 #undef BUILTIN_BINARY_OPERATION
 
 /// These builtins are analogous the similarly named llvm intrinsics. The

branches/master-next/include/swift/AST/Builtins.h

@@ -83,6 +83,11 @@ enum class BuiltinValueKind {
 #include "swift/AST/Builtins.def"
 };
 
+/// Returns true if this is a polymorphic builtin that is only valid
+/// in raw sil and thus must be resolved to have concrete types by the
+/// time we are in canonical SIL.
+bool isPolymorphicBuiltin(BuiltinValueKind Id);
+
 /// Decode the type list of a builtin (e.g. mul_Int32) and return the base
 /// name (e.g. "mul").
 StringRef getBuiltinBaseName(ASTContext &C, StringRef Name,

branches/master-next/include/swift/SIL/InstructionUtils.h

@@ -142,6 +142,38 @@ bool onlyUsedByAssignByWrapper(PartialApplyInst *PAI);
 void findClosuresForFunctionValue(SILValue V,
                                   TinyPtrVector<PartialApplyInst *> &results);
 
+/// Given a polymorphic builtin \p bi that may be generic and thus have in/out
+/// params, stash all of the information needed for either specializing while
+/// inlining or propagating the type in constant propagation.
+///
+/// NOTE: If we perform this transformation, our builtin will no longer have any
+/// substitutions since we only substitute to concrete static overloads.
+struct PolymorphicBuiltinSpecializedOverloadInfo {
+  Identifier staticOverloadIdentifier;
+  SmallVector<SILType, 8> argTypes;
+  SILType resultType;
+  bool hasOutParam = false;
+
+#ifndef NDEBUG
+private:
+  bool isInitialized = false;
+#endif
+
+public:
+  PolymorphicBuiltinSpecializedOverloadInfo() = default;
+
+  bool init(SILFunction *fn, BuiltinValueKind builtinKind,
+            ArrayRef<SILType> oldOperandTypes, SILType oldResultType);
+
+  bool init(BuiltinInst *bi);
+};
+
+/// Given a polymorphic builtin \p bi, analyze its types and create a builtin
+/// for the static overload that the builtin corresponds to. If \p bi is not a
+/// polymorphic builtin or does not have any available overload for these types,
+/// return SILValue().
+SILValue getStaticOverloadForSpecializedPolymorphicBuiltin(BuiltinInst *bi);
+
 } // end namespace swift
 
 #endif