---

yaml
---
r: 326107
b: refs/heads/master-next
c: fa5b0f3
h: refs/heads/master
i:
  326105: 6bdaf2f
  326103: acfbf47

Author: ravikandhadai

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: b59cc7ad6a304f2917232df6d37d3e1d1aad4b17
+refs/heads/master-next: fa5b0f30a95d140c7dd2934ddf0f6b61be560239
 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/CHANGELOG.md

@@ -26,6 +26,63 @@ CHANGELOG
 Swift Next
 ----------
 
+* [SR-11298][]:
+
+  A class-constrained protocol extension, where the extended protocol does
+  not impose a class constraint, will now infer the constraint implicitly.
+
+  ```swift
+  protocol Foo {}
+  class Bar: Foo {
+    var someProperty: Int = 0
+  }
+
+  // Even though 'Foo' does not impose a class constraint, it is automatically
+  // inferred due to the Self: Bar constraint.
+  extension Foo where Self: Bar {
+    var anotherProperty: Int {
+      get { return someProperty }
+      // As a result, the setter is now implicitly nonmutating, just like it would
+      // be if 'Foo' had a class constraint.
+      set { someProperty = newValue }
+    }
+  }
+  ```
+  
+  As a result, this could lead to code that currently compiles today to throw an error.
+  
+  ```swift
+  protocol Foo {
+    var someProperty: Int { get set }
+  }
+  
+  class Bar: Foo {
+    var someProperty = 0
+  }
+  
+  extension Foo where Self: Bar {
+    var anotherProperty1: Int {
+      get { return someProperty }
+      // This will now error, because the protocol requirement
+      // is implicitly mutating and the setter is implicitly 
+      // nonmutating.
+      set { someProperty = newValue } // Error
+    }
+  }
+  ```
+
+  **Workaround**: Define a new mutable variable inside the setter that has a reference to `self`:
+  
+  ```swift
+  var anotherProperty1: Int {
+    get { return someProperty }
+    set {
+      var mutableSelf = self
+      mutableSelf.someProperty = newValue // Okay
+    }
+  }
+```
+
 * [SE-0253][]:
 
   Values of types that declare `func callAsFunction` methods can be called
@@ -51,7 +108,7 @@ Swift Next
 
 * [SR-4206][]:
 
-  A method override is no longer allowed to have a generic signature with 
+  A method override is no longer allowed to have a generic signature with
   requirements not imposed by the base method. For example:
 
   ```
@@ -7765,3 +7822,4 @@ Swift 1.0
 [SR-8974]: <https://bugs.swift.org/browse/SR-8974>
 [SR-9043]: <https://bugs.swift.org/browse/SR-9043>
 [SR-9827]: <https://bugs.swift.org/browse/SR-9827>
+[SR-11298]: <https://bugs.swift.org/browse/SR-11298>

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

@@ -1505,12 +1505,13 @@ class alignas(8) _GenericContext {
   TrailingWhereClause *TrailingWhere = nullptr;
 
   /// The generic signature of this declaration.
-  GenericSignature *GenericSig = nullptr;
+  llvm::PointerIntPair<GenericSignature *, 1, bool> GenericSigAndBit;
 };
 
 class GenericContext : private _GenericContext, public DeclContext {
   friend class GenericParamListRequest;
-
+  friend class GenericSignatureRequest;
+  
 protected:
   GenericContext(DeclContextKind Kind, DeclContext *Parent,
                  GenericParamList *Params);
@@ -1534,7 +1535,8 @@ class GenericContext : private _GenericContext, public DeclContext {
   /// }
   /// \endcode
   bool isGeneric() const { return getGenericParams() != nullptr; }
-
+  bool hasComputedGenericSignature() const;
+  
   /// Retrieve the trailing where clause for this extension, if any.
   TrailingWhereClause *getTrailingWhereClause() const {
     return TrailingWhere;

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

@@ -261,7 +261,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
 
   /// Returns the kind of context this is.
   DeclContextKind getContextKind() const;
-  
+
+  /// Returns whether this context has value semantics.
+  bool hasValueSemantics() const;
+
   /// Determines whether this context is itself a local scope in a
   /// code block.  A context that appears in such a scope, like a
   /// local type declaration, does not itself become a local context.

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

@@ -1160,6 +1160,27 @@ class FunctionOperatorRequest :
   bool isCached() const { return true; }
 };
 
+class GenericSignatureRequest :
+    public SimpleRequest<GenericSignatureRequest,
+                         GenericSignature *(GenericContext *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+  
+private:
+  friend SimpleRequest;
+  
+  // Evaluation.
+  llvm::Expected<GenericSignature *>
+  evaluate(Evaluator &evaluator, GenericContext *value) const;
+  
+public:              
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<GenericSignature *> getCachedResult() const;
+  void cacheResult(GenericSignature *value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

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

@@ -49,6 +49,9 @@ SWIFT_REQUEST(TypeChecker, FunctionBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionOperatorRequest, OperatorDecl *(FuncDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(NameLookup, GenericSignatureRequest,
+              GenericSignature *(GenericContext *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature *(ModuleDecl *, GenericSignature *,
                                  SmallVector<GenericParamList *, 2>,

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

@@ -70,8 +70,6 @@ class HiddenLibSyntaxAction : public SyntaxParseActions {
   std::pair<size_t, OpaqueSyntaxNode>
   lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) override;
 
-  void discardRecordedNode(OpaqueSyntaxNode node) override;
-
   OpaqueSyntaxNodeKind getOpaqueKind() override {
     return ExplicitAction->getOpaqueKind();
   }

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

@@ -44,7 +44,7 @@ class LibSyntaxGenerator {
 
     auto Recorded = Recorder.recordToken(Kind, Range, LeadingTriviaPieces,
                                          TrailingTriviaPieces);
-    auto Raw = static_cast<RawSyntax *>(Recorded.takeOpaqueNode());
+    auto Raw = static_cast<RawSyntax *>(Recorded.getOpaqueNode());
     return make<TokenSyntax>(Raw);
   }
 
@@ -55,7 +55,7 @@ class LibSyntaxGenerator {
     auto Children = Node.getDeferredChildren();
 
     auto Recorded = Recorder.recordRawSyntax(Kind, Children);
-    RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.takeOpaqueNode()) };
+    RC<RawSyntax> Raw {static_cast<RawSyntax *>(Recorded.getOpaqueNode()) };
     Raw->Release(); // -1 since it's transfer of ownership.
     return make<SyntaxNode>(Raw);
   }

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

@@ -51,7 +51,7 @@ class ParsedRawSyntaxNode {
     CharSourceRange Range;
   };
   struct DeferredLayoutNode {
-    MutableArrayRef<ParsedRawSyntaxNode> Children;
+    ArrayRef<ParsedRawSyntaxNode> Children;
   };
   struct DeferredTokenNode {
     const ParsedTriviaPiece *TriviaPieces;
@@ -73,8 +73,8 @@ class ParsedRawSyntaxNode {
   bool IsMissing = false;
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k,
-                      MutableArrayRef<ParsedRawSyntaxNode> deferredNodes)
-    : DeferredLayout({deferredNodes}),
+                      ArrayRef<ParsedRawSyntaxNode> deferredNodes)
+    : DeferredLayout{deferredNodes},
       SynKind(uint16_t(k)), TokKind(uint16_t(tok::unknown)),
       DK(DataKind::DeferredLayout) {
     assert(getKind() == k && "Syntax kind with too large value!");
@@ -97,8 +97,6 @@ class ParsedRawSyntaxNode {
     assert(DeferredToken.NumTrailingTrivia == numTrailingTrivia &&
            "numLeadingTrivia is too large value!");
   }
-  ParsedRawSyntaxNode(ParsedRawSyntaxNode &other) = delete;
-  ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &other) = delete;
 
 public:
   ParsedRawSyntaxNode()
@@ -117,35 +115,6 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
 
-  ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
-    assert(DK != DataKind::Recorded);
-    switch (other.DK) {
-    case DataKind::Null:
-      break;
-    case DataKind::Recorded:
-      RecordedData = std::move(other.RecordedData);
-      break;
-    case DataKind::DeferredLayout:
-      DeferredLayout = std::move(other.DeferredLayout);
-      break;
-    case DataKind::DeferredToken:
-      DeferredToken = std::move(other.DeferredToken);
-      break;
-    }
-    SynKind = std::move(other.SynKind);
-    TokKind = std::move(other.TokKind);
-    DK = std::move(other.DK);
-    IsMissing = std::move(other.IsMissing);
-    other.reset();
-    return *this;
-  }
-  ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) : ParsedRawSyntaxNode() {
-    *this = std::move(other);
-  }
-  ~ParsedRawSyntaxNode() {
-    assert(DK != DataKind::Recorded);
-  }
-
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }
   tok getTokenKind() const { return tok(TokKind); }
 
@@ -167,36 +136,6 @@ class ParsedRawSyntaxNode {
   /// Primary used for a deferred missing token.
   bool isMissing() const { return IsMissing; }
 
-  void reset() {
-    RecordedData = {};
-    SynKind = uint16_t(syntax::SyntaxKind::Unknown);
-    TokKind = uint16_t(tok::unknown);
-    DK = DataKind::Null;
-    IsMissing = false;
- }
-
-  ParsedRawSyntaxNode unsafeCopy() const {
-    ParsedRawSyntaxNode copy;
-    switch (DK) {
-    case DataKind::DeferredLayout:
-      copy.DeferredLayout = DeferredLayout;
-      break;
-    case DataKind::DeferredToken:
-      copy.DeferredToken = DeferredToken;
-      break;
-    case DataKind::Recorded:
-      copy.RecordedData = RecordedData;
-      break;
-    case DataKind::Null:
-      break;
-    }
-    copy.SynKind = SynKind;
-    copy.TokKind = TokKind;
-    copy.DK = DK;
-    copy.IsMissing = IsMissing;
-    return copy;
-  }
-
   CharSourceRange getDeferredRange() const {
     switch (DK) { 
     case DataKind::DeferredLayout:
@@ -214,24 +153,18 @@ class ParsedRawSyntaxNode {
     assert(isRecorded());
     return RecordedData.Range;
   }
-  const OpaqueSyntaxNode &getOpaqueNode() const {
+  OpaqueSyntaxNode getOpaqueNode() const {
     assert(isRecorded());
     return RecordedData.OpaqueNode;
   }
-  OpaqueSyntaxNode takeOpaqueNode() {
-    assert(isRecorded());
-    auto opaque = RecordedData.OpaqueNode;
-    reset();
-    return opaque;
-  }
 
   // Deferred Layout Data ====================================================//
 
   CharSourceRange getDeferredLayoutRange() const {
     assert(DK == DataKind::DeferredLayout);
     assert(!DeferredLayout.Children.empty());
-    auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
-      for (auto &Child : llvm::reverse(getDeferredChildren()))
+    auto getLastNonNullChild = [this]() {
+      for (auto &&Child : llvm::reverse(getDeferredChildren()))
         if (!Child.isNull())
           return Child;
       llvm_unreachable("layout node without non-null children");
@@ -245,28 +178,6 @@ class ParsedRawSyntaxNode {
     assert(DK == DataKind::DeferredLayout);
     return DeferredLayout.Children;
   }
-  MutableArrayRef<ParsedRawSyntaxNode> getDeferredChildren() {
-    assert(DK == DataKind::DeferredLayout);
-    return DeferredLayout.Children;
-  }
-  ParsedRawSyntaxNode copyDeferred() const {
-    ParsedRawSyntaxNode copy;
-    switch (DK) {
-    case DataKind::DeferredLayout:
-      copy.DeferredLayout = DeferredLayout;
-      break;
-    case DataKind::DeferredToken:
-      copy.DeferredToken = DeferredToken;
-      break;
-    default:
-      llvm_unreachable("node not deferred");
-    }
-    copy.SynKind = SynKind;
-    copy.TokKind = TokKind;
-    copy.DK = DK;
-    copy.IsMissing = IsMissing;
-    return copy;
-  }
 
   // Deferred Token Data =====================================================//
 
@@ -303,7 +214,7 @@ class ParsedRawSyntaxNode {
 
   /// Form a deferred syntax layout node.
   static ParsedRawSyntaxNode makeDeferred(syntax::SyntaxKind k,
-                        MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
+                        ArrayRef<ParsedRawSyntaxNode> deferredNodes,
                                           SyntaxParsingContext &ctx);
 
   /// Form a deferred token node.

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

@@ -60,16 +60,14 @@ class ParsedRawSyntaxRecorder {
   /// \p kind. Missing optional elements are represented with a null
   /// ParsedRawSyntaxNode object.
   ParsedRawSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
-                                      MutableArrayRef<ParsedRawSyntaxNode> elements);
+                                     ArrayRef<ParsedRawSyntaxNode> elements);
 
   /// Record a raw syntax collecton without eny elements. \p loc can be invalid
   /// or an approximate location of where an element of the collection would be
   /// if not missing.
   ParsedRawSyntaxNode recordEmptyRawSyntaxCollection(syntax::SyntaxKind kind,
                                                      SourceLoc loc);
 
-  void discardRecordedNode(ParsedRawSyntaxNode &node);
-
   /// Used for incremental re-parsing.
   ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
                                  syntax::SyntaxKind kind);