---

yaml
---
r: 348732
b: refs/heads/master
c: dfe0085
h: refs/heads/master

Author: jrose-apple

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2b790a96377c496e31ffa51b914d2df6d1fe7584
+refs/heads/master: dfe0085aeabf454273d783d36c83b4ddc587805e
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/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...

trunk/include/swift/Parse/ASTGen.h

@@ -37,8 +37,9 @@ class ASTGen {
 
   // FIXME: remove when Syntax can represent all types and ASTGen can handle
   // them
-  /// Decl attributes that cannot be represented by Syntax or generated by
-  /// ASTGen.
+  /// Types that cannot be represented by Syntax or generated by ASTGen.
+  llvm::DenseMap<SourceLoc, TypeRepr *> Types;
+
   llvm::DenseMap<SourceLoc, DeclAttributes> ParsedDeclAttrs;
 
 public:
@@ -102,8 +103,7 @@ class ASTGen {
   //===--------------------------------------------------------------------===//
   // Types.
 
-  TypeRepr *generate(const syntax::TypeSyntax &Type, const SourceLoc Loc,
-                     bool IsSILFuncDecl = false);
+  TypeRepr *generate(const syntax::TypeSyntax &Type, const SourceLoc Loc);
   TypeRepr *generate(const syntax::SomeTypeSyntax &Type, const SourceLoc Loc);
   TypeRepr *generate(const syntax::CompositionTypeSyntax &Type,
                      const SourceLoc Loc);
@@ -127,19 +127,11 @@ class ASTGen {
                      const SourceLoc Loc);
   TypeRepr *generate(const syntax::ClassRestrictionTypeSyntax &Type,
                      const SourceLoc Loc);
-  TypeRepr *generate(const syntax::SILBoxTypeSyntax &Type, const SourceLoc Loc,
-                     bool IsSILFuncDecl);
-  TypeRepr *generate(const syntax::SILFunctionTypeSyntax &Type,
-                     const SourceLoc Loc, bool IsSILFuncDecl);
   TypeRepr *generate(const syntax::CodeCompletionTypeSyntax &Type,
                      const SourceLoc Loc);
   TypeRepr *generate(const syntax::UnknownTypeSyntax &Type,
                      const SourceLoc Loc);
 
-  TypeAttributes
-  generateTypeAttributes(const syntax::AttributeListSyntax &syntax,
-                         const SourceLoc Loc);
-
 private:
   TupleTypeRepr *
   generateTuple(const syntax::TokenSyntax &LParen,
@@ -204,6 +196,10 @@ class ASTGen {
   TypeRepr *lookupType(syntax::TypeSyntax Type);
 
 public:
+  void addType(TypeRepr *Type, const SourceLoc Loc);
+  bool hasType(const SourceLoc Loc) const;
+  TypeRepr *getType(const SourceLoc Loc) const;
+
   void addDeclAttributes(DeclAttributes attrs, const SourceLoc Loc);
   bool hasDeclAttributes(SourceLoc Loc) const;
   DeclAttributes getDeclAttributes(const SourceLoc Loc) const;

trunk/include/swift/Parse/ParsedRawSyntaxNode.h

@@ -119,20 +119,8 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
 
-#ifndef NDEBUG
-  bool ensureDataIsNotRecorded() {
-    if (DK != DataKind::Recorded)
-      return true;
-    llvm::dbgs() << "Leaking node: ";
-    dump(llvm::dbgs());
-    llvm::dbgs() << "\n";
-    return false;
-  }
-#endif
-
   ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
-    assert(ensureDataIsNotRecorded() &&
-           "recorded data is being destroyed by assignment");
+    assert(DK != DataKind::Recorded);
     switch (other.DK) {
     case DataKind::Null:
       break;
@@ -157,7 +145,7 @@ class ParsedRawSyntaxNode {
     *this = std::move(other);
   }
   ~ParsedRawSyntaxNode() {
-    assert(ensureDataIsNotRecorded() && "recorded data is being destructed");
+    assert(DK != DataKind::Recorded);
   }
 
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }

trunk/include/swift/Parse/Parser.h

@@ -1082,13 +1082,24 @@ class Parser {
   /// an error parsing.
   bool parseVersionTuple(llvm::VersionTuple &Version, SourceRange &Range,
                          const Diagnostic &D);
+
   bool parseTypeAttributeList(ParamDecl::Specifier &Specifier,
                               SourceLoc &SpecifierLoc,
-                              TypeAttributes &Attributes);
-  ParserStatus parseTypeAttributeListSyntax(Optional<ParsedTokenSyntax> &specifier,
-                                            Optional<ParsedAttributeListSyntax> &attrs);
-  ParsedSyntaxResult<ParsedAttributeSyntax> parseTypeAttributeSyntax();
-
+                              TypeAttributes &Attributes) {
+    if (Tok.isAny(tok::at_sign, tok::kw_inout) ||
+        (Tok.is(tok::identifier) &&
+         (Tok.getRawText().equals("__shared") ||
+          Tok.getRawText().equals("__owned"))))
+      return parseTypeAttributeListPresent(Specifier, SpecifierLoc, Attributes);
+    return false;
+  }
+  bool parseTypeAttributeListPresent(ParamDecl::Specifier &Specifier,
+                                     SourceLoc &SpecifierLoc,
+                                     TypeAttributes &Attributes);
+  bool parseTypeAttribute(TypeAttributes &Attributes, SourceLoc AtLoc,
+                          bool justChecking = false);
+  
+  
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
   ParserStatus parseInheritance(MutableArrayRef<TypeLoc> &Inherited,
@@ -1179,47 +1190,44 @@ class Parser {
   //===--------------------------------------------------------------------===//
   // Type Parsing
 
-  ParserResult<TypeRepr> parseType();
-  ParserResult<TypeRepr> parseType(Diag<> MessageID,
-                                   bool HandleCodeCompletion = true,
-                                   bool IsSILFuncDecl = false);
-  ParserStatus parseGenericArguments(llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
-                                     SourceLoc &LAngleLoc,
-                                     SourceLoc &RAngleLoc);
-  TypeRepr *applyAttributeToType(TypeRepr *Ty, const TypeAttributes &Attr,
-                                 ParamDecl::Specifier Specifier,
-                                 SourceLoc SpecifierLoc);
-  ParserResult<TypeRepr> parseAnyTypeAST();
+  using TypeASTResult = ParserResult<TypeRepr>;
+  using TypeResult = ParsedSyntaxResult<ParsedTypeSyntax>;
 
   ParsedSyntaxResult<ParsedLayoutConstraintSyntax>
   parseLayoutConstraintSyntax();
 
-  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeSyntax();
-  ParsedSyntaxResult<ParsedTypeSyntax>
-  parseTypeSyntax(Diag<> MessageID, bool HandleCodeCompletion = true,
-                  bool IsSILFuncDecl = false);
+  TypeResult parseTypeSyntax();
+  TypeResult parseTypeSyntax(Diag<> MessageID, bool HandleCodeCompletion = true,
+                             bool IsSILFuncDecl = false);
+
+  TypeASTResult parseType();
+  TypeASTResult parseType(Diag<> MessageID, bool HandleCodeCompletion = true,
+                          bool IsSILFuncDecl = false);
+  ParserStatus
+  parseGenericArgumentsAST(llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
+                           SourceLoc &LAngleLoc, SourceLoc &RAngleLoc);
+  TypeASTResult parseSILBoxType(GenericParamList *generics,
+                                const TypeAttributes &attrs,
+                                Optional<Scope> &GenericsScope);
+  TypeASTResult parseTypeSimpleOrCompositionAST(Diag<> MessageID,
+                                                bool HandleCodeCompletion);
+  TypeASTResult parseAnyTypeAST();
 
   ParsedSyntaxResult<ParsedGenericArgumentClauseSyntax>
   parseGenericArgumentClauseSyntax();
 
-  ParsedSyntaxResult<ParsedTypeSyntax>
-  parseTypeSimple(Diag<> MessageID, bool HandleCodeCompletion);
-  ParsedSyntaxResult<ParsedTypeSyntax>
-  parseTypeSimpleOrComposition(Diag<> MessageID, bool HandleCodeCompletion);
-  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeIdentifier();
-  ParsedSyntaxResult<ParsedTypeSyntax> parseAnyType();
-  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeTupleBody();
-  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeCollection();
-  ParsedSyntaxResult<ParsedTypeSyntax> parseMetatypeType(ParsedTypeSyntax Base);
-  ParsedSyntaxResult<ParsedTypeSyntax> parseOptionalType(ParsedTypeSyntax Base);
-  ParsedSyntaxResult<ParsedTypeSyntax>
-  parseImplicitlyUnwrappedOptionalType(ParsedTypeSyntax Base);
-  ParsedSyntaxResult<ParsedTypeSyntax> parseSILBoxTypeSyntax(
-      Optional<ParsedGenericParameterClauseListSyntax> genericParams);
-
-  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeArray(ParsedTypeSyntax Base,
-                                                      SourceLoc BaseLoc);
-  ParsedSyntaxResult<ParsedTypeSyntax> parseOldStyleProtocolComposition();
+  TypeResult parseTypeSimple(Diag<> MessageID, bool HandleCodeCompletion);
+  TypeResult parseTypeSimpleOrComposition(Diag<> MessageID, bool HandleCodeCompletion);
+  TypeResult parseTypeIdentifier();
+  TypeResult parseAnyType();
+  TypeResult parseTypeTupleBody();
+  TypeResult parseTypeCollection();
+  TypeResult parseMetatypeType(ParsedTypeSyntax Base);
+  TypeResult parseOptionalType(ParsedTypeSyntax Base);
+  TypeResult parseImplicitlyUnwrappedOptionalType(ParsedTypeSyntax Base);
+
+  TypeResult parseTypeArray(ParsedTypeSyntax Base, SourceLoc BaseLoc);
+  TypeResult parseOldStyleProtocolComposition();
 
   bool isOptionalToken(const Token &T) const;
   ParsedTokenSyntax consumeOptionalTokenSyntax();
@@ -1229,10 +1237,9 @@ class Parser {
   ParsedTokenSyntax consumeImplicitlyUnwrappedOptionalTokenSyntax();
   SourceLoc consumeImplicitlyUnwrappedOptionalToken();
 
-  ParsedSyntaxResult<ParsedTypeSyntax>
-  applyAttributeToTypeSyntax(ParsedSyntaxResult<ParsedTypeSyntax> &&ty,
-                             Optional<ParsedTokenSyntax> specifier,
-                             Optional<ParsedAttributeListSyntax> attrs);
+  TypeRepr *applyAttributeToType(TypeRepr *Ty, const TypeAttributes &Attr,
+                                 ParamDecl::Specifier Specifier,
+                                 SourceLoc SpecifierLoc);
 
   //===--------------------------------------------------------------------===//
   // Pattern Parsing

trunk/lib/AST/ASTMangler.cpp

@@ -1491,10 +1491,6 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
 Optional<ASTMangler::SpecialContext>
 ASTMangler::getSpecialManglingContext(const ValueDecl *decl,
                                       bool useObjCProtocolNames) {
-  #if SWIFT_BUILD_ONLY_SYNTAXPARSERLIB
-    return None; // not needed for the parser library.
-  #endif
-
   // Declarations provided by a C module have a special context mangling.
   //   known-context ::= 'So'
   //

trunk/lib/AST/Decl.cpp

@@ -6999,8 +6999,11 @@ StaticSpellingKind FuncDecl::getCorrectStaticSpelling() const {
 }
 
 Type FuncDecl::getResultInterfaceType() const {
+  if (!hasInterfaceType())
+    return nullptr;
+
   Type resultTy = getInterfaceType();
-  if (resultTy.isNull() || resultTy->is<ErrorType>())
+  if (resultTy->is<ErrorType>())
     return resultTy;
 
   if (hasImplicitSelfDecl())

trunk/lib/IRGen/IRGenSIL.cpp

@@ -1639,6 +1639,9 @@ void IRGenSILFunction::emitSILFunction() {
 
   assert(!CurSILFn->empty() && "function has no basic blocks?!");
 
+  if (CurSILFn->isThunk())
+    IGM.setHasFramePointer(CurFn, false);
+  
   if (CurSILFn->getDynamicallyReplacedFunction())
     IGM.IRGen.addDynamicReplacement(CurSILFn);