---

yaml
---
r: 349290
b: refs/heads/master-next
c: 91e4c0e
h: refs/heads/master

Author: xymus

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: cf526b4adaa5b6ec8ceb6074ec948ada9507dd64
+refs/heads/master-next: 91e4c0e9234fc9f6d177955190f5e1261ac555fa
 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,19 +370,6 @@ 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,7 +1678,11 @@ class ExtensionDecl final : public GenericContext, public Decl,
   TypeRepr *ExtendedTypeRepr;
 
   /// The nominal type being extended.
-  NominalTypeDecl *ExtendedNominal = nullptr;
+  ///
+  /// 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;
 
   MutableArrayRef<TypeLoc> Inherited;
 
@@ -1738,6 +1742,12 @@ 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,
@@ -1746,8 +1756,21 @@ 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,6 +470,10 @@ 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,9 +3647,6 @@ 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,6 +706,12 @@ 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) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveConstruct(void *self, int index, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyAssignSame(int index, void *self, const void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveAssignSame(int index, void *self, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void destruct(int index, void *self) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 };
 

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

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

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

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