---

yaml
---
r: 349289
b: refs/heads/master-next
c: cf526b4
h: refs/heads/master
i:
  349287: 074de2f

Author: xymus

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 40e40103a83f39fd7a4d36a5e9263f99201a1f8f
+refs/heads/master-next: cf526b4adaa5b6ec8ceb6074ec948ada9507dd64
 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

@@ -370,6 +370,19 @@ extension Counter {
 }
 ```
 
+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

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

@@ -1678,11 +1678,7 @@ class ExtensionDecl final : public GenericContext, public Decl,
   TypeRepr *ExtendedTypeRepr;
 
   /// The nominal type being extended.
-  ///
-  /// The bit indicates whether binding has been attempted. The pointer can be
-  /// null if either no binding was attempted or if binding could not find  the
-  /// extended nominal.
-  llvm::PointerIntPair<NominalTypeDecl *, 1, bool> ExtendedNominal;
+  NominalTypeDecl *ExtendedNominal = nullptr;
 
   MutableArrayRef<TypeLoc> Inherited;
 
@@ -1742,12 +1738,6 @@ class ExtensionDecl final : public GenericContext, public Decl,
   SourceRange getBraces() const { return Braces; }
   void setBraces(SourceRange braces) { Braces = braces; }
 
-  bool hasBeenBound() const { return ExtendedNominal.getInt(); }
-
-  void setExtendedNominal(NominalTypeDecl *n) {
-    ExtendedNominal.setPointerAndInt(n, true);
-  }
-
   /// Retrieve the type being extended.
   ///
   /// Only use this entry point when the complete type, as spelled in the source,
@@ -1756,21 +1746,8 @@ class ExtensionDecl final : public GenericContext, public Decl,
   Type getExtendedType() const;
 
   /// Retrieve the nominal type declaration that is being extended.
-  /// Will  trip an assertion if the declaration has not already been computed.
-  /// In order to fail fast when type checking work is attempted
-  /// before extension binding has taken place.
-
   NominalTypeDecl *getExtendedNominal() const;
 
-  /// Compute the nominal type declaration that is being extended.
-  NominalTypeDecl *computeExtendedNominal() const;
-
-  /// \c hasBeenBound means nothing if this extension can never been bound
-  /// because it is not at the top level.
-  bool canNeverBeBound() const;
-
-  bool hasValidParent() const;
-
   /// Determine whether this extension has already been bound to a nominal
   /// type declaration.
   bool alreadyBoundToNominal() const { return NextExtension.getInt(); }

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

@@ -470,10 +470,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// AnyObject dynamic lookup.
   bool mayContainMembersAccessedByDynamicLookup() const;
 
-  /// Extensions are only allowed at the level in a file
-  /// FIXME: do this for Protocols, too someday
-  bool canBeParentOfExtension() const;
-
   /// Returns true if lookups within this context could affect downstream files.
   ///
   /// \param functionsAreNonCascading If true, functions are considered non-

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

@@ -3647,6 +3647,9 @@ ERROR(sugar_type_not_found,none,
       "broken standard library: cannot find "
       "%select{Array|Optional|ImplicitlyUnwrappedOptional|Dictionary|"
       "Error}0 type", (unsigned))
+ERROR(pointer_type_not_found,none,
+      "broken standard library: cannot find "
+      "%select{UnsafePointer|UnsafeMutablePointer}0 type", (unsigned))
 ERROR(optional_intrinsics_not_found,none,
       "broken standard library: cannot find intrinsic operations on "
       "Optional<T>", ())

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

@@ -706,12 +706,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     PointerTypeKind Ignore;
     return getAnyPointerElementType(Ignore);
   }
-
-  /// Returns a type representing a pointer to \c this.
-  ///
-  /// \p kind must not be a raw pointer kind, since that would discard the
-  /// current type.
-  Type wrapInPointer(PointerTypeKind kind);
 
   /// Determine whether the given type is "specialized", meaning that
   /// it involves generic types for which generic arguments have been provided.

branches/master-next/include/swift/Basic/ExternalUnion.h

@@ -433,27 +433,27 @@ struct MembersHelper<> {
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyConstruct(void *self, int index, const void *other) {
-    assert(false && "bad index");
+    llvm_unreachable("bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveConstruct(void *self, int index, void *other) {
-    assert(false && "bad index");
+    llvm_unreachable("bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyAssignSame(int index, void *self, const void *other) {
-    assert(false && "bad index");
+    llvm_unreachable("bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveAssignSame(int index, void *self, void *other) {
-    assert(false && "bad index");
+    llvm_unreachable("bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void destruct(int index, void *self) {
-    assert(false && "bad index");
+    llvm_unreachable("bad index");
   }
 };
 

branches/master-next/include/swift/Parse/ParsedRawSyntaxNode.h

@@ -109,12 +109,10 @@ class ParsedRawSyntaxNode {
   }
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
-                      CharSourceRange r, OpaqueSyntaxNode n,
-                      bool IsMissing = false)
+                      CharSourceRange r, OpaqueSyntaxNode n)
     : RecordedData{n, r},
       SynKind(uint16_t(k)), TokKind(uint16_t(tokKind)),
-      DK(DataKind::Recorded),
-      IsMissing(IsMissing) {
+      DK(DataKind::Recorded) {
     assert(getKind() == k && "Syntax kind with too large value!");
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
@@ -199,14 +197,12 @@ class ParsedRawSyntaxNode {
     return copy;
   }
 
-  CharSourceRange getDeferredRange(bool includeTrivia) const {
+  CharSourceRange getDeferredRange() const {
     switch (DK) { 
     case DataKind::DeferredLayout:
-      return getDeferredLayoutRange(includeTrivia);
+      return getDeferredLayoutRange();
     case DataKind::DeferredToken:
-      return includeTrivia
-        ? getDeferredTokenRangeWithTrivia()
-        : getDeferredTokenRange();
+      return getDeferredTokenRange();
     default:
       llvm_unreachable("node not deferred");
     }
@@ -231,19 +227,18 @@ class ParsedRawSyntaxNode {
 
   // Deferred Layout Data ====================================================//
 
-  CharSourceRange getDeferredLayoutRange(bool includeTrivia) const {
+  CharSourceRange getDeferredLayoutRange() const {
     assert(DK == DataKind::DeferredLayout);
-    auto HasValidRange = [includeTrivia](const ParsedRawSyntaxNode &Child) {
-      return !Child.isNull() && !Child.isMissing() &&
-        Child.getDeferredRange(includeTrivia).isValid();
+    assert(!DeferredLayout.Children.empty());
+    auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
+      for (auto &Child : llvm::reverse(getDeferredChildren()))
+        if (!Child.isNull())
+          return Child;
+      llvm_unreachable("layout node without non-null children");
     };
-    auto first = llvm::find_if(getDeferredChildren(), HasValidRange);
-    if (first == getDeferredChildren().end())
-      return CharSourceRange();
-    auto last = llvm::find_if(llvm::reverse(getDeferredChildren()),
-                              HasValidRange);
-    auto firstRange = first->getDeferredRange(includeTrivia);
-    firstRange.widen(last->getDeferredRange(includeTrivia));
+    auto firstRange = DeferredLayout.Children.front().getDeferredRange();
+    auto lastRange = getLastNonNullChild().getDeferredRange();
+    firstRange.widen(lastRange);
     return firstRange;
   }
   ArrayRef<ParsedRawSyntaxNode> getDeferredChildren() const {

branches/master-next/include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -73,10 +73,6 @@ class ParsedRawSyntaxRecorder {
   /// Used for incremental re-parsing.
   ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
                                  syntax::SyntaxKind kind);
-
-  #ifndef NDEBUG
-  static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
-  #endif
 };
 
 } // end namespace swift

branches/master-next/include/swift/Parse/ParsedSyntaxBuilders.h.gyb

@@ -62,9 +62,9 @@ public:
 %     end
 
   Parsed${node.name} build();
+  Parsed${node.name} makeDeferred();
 
 private:
-  Parsed${node.name} makeDeferred();
   Parsed${node.name} record();
   void finishLayout(bool deferred);
 };

branches/master-next/include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -43,22 +43,23 @@ struct ParsedSyntaxRecorder {
 %     end
 %     child_params = ', '.join(child_params)
 private:
-  static Parsed${node.name} record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
+  static Parsed${node.name} record${node.syntax_kind}(${child_params},
                                               ParsedRawSyntaxRecorder &rec);
-  static Parsed${node.name} defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
-                                              SyntaxParsingContext &SPCtx);
 public:
+  static Parsed${node.name} defer${node.syntax_kind}(${child_params},
+                                              SyntaxParsingContext &SPCtx);
   static Parsed${node.name} make${node.syntax_kind}(${child_params},
                                               SyntaxParsingContext &SPCtx);
 %   elif node.is_syntax_collection():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<ParsedRawSyntaxNode> layout,
+      MutableArrayRef<Parsed${node.collection_element_type}> elts,
       ParsedRawSyntaxRecorder &rec);
+
+public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<ParsedRawSyntaxNode> layout,
+      MutableArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);
-public:
   static Parsed${node.name} make${node.syntax_kind}(
       MutableArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);
@@ -68,12 +69,14 @@ public:
 %   elif node.is_unknown():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<ParsedRawSyntaxNode> layout,
+      MutableArrayRef<ParsedSyntax> elts,
       ParsedRawSyntaxRecorder &rec);
+
+public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<ParsedRawSyntaxNode> layout,
+      MutableArrayRef<ParsedSyntax> elts,
       SyntaxParsingContext &SPCtx);
-public:
+
   static Parsed${node.name} make${node.syntax_kind}(
       MutableArrayRef<ParsedSyntax> elts,
       SyntaxParsingContext &SPCtx);