[Typechecker] Do not incorrectly mark explicitly mutating methods as non-mutatingif we're in a class-constrained protocol extension

Author: theblixguy

include/swift/AST/DeclContext.h

@@ -265,6 +265,9 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// Returns whether this context has value semantics.
   bool hasValueSemantics() const;
 
+  /// Returns whether this context is an extension constrained to a class type.
+  bool isClassConstrainedProtocolExtension() 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.

lib/AST/DeclContext.cpp

@@ -1043,6 +1043,17 @@ bool DeclContext::hasValueSemantics() const {
   return false;
 }
 
+bool DeclContext::isClassConstrainedProtocolExtension() const {
+  if (auto ED = dyn_cast<ExtensionDecl>(this)) {
+    if (ED->getExtendedType()->isExistentialType()) {
+      return ED->getGenericSignature()->requiresClass(
+          ED->getSelfInterfaceType());
+    }
+  }
+
+  return false;
+}
+
 SourceLoc swift::extractNearestSourceLoc(const DeclContext *dc) {
   switch (dc->getContextKind()) {
   case DeclContextKind::AbstractFunctionDecl:

lib/Sema/TypeCheckDecl.cpp

@@ -2091,6 +2091,8 @@ llvm::Expected<SelfAccessKind>
 SelfAccessKindRequest::evaluate(Evaluator &evaluator, FuncDecl *FD) const {
   if (FD->getAttrs().getAttribute<MutatingAttr>(true)) {
     if (!FD->isInstanceMember() || !FD->getDeclContext()->hasValueSemantics()) {
+      if (FD->getDeclContext()->isClassConstrainedProtocolExtension())
+        return SelfAccessKind::Mutating;
       return SelfAccessKind::NonMutating;
     }
     return SelfAccessKind::Mutating;

test/decl/ext/extensions.swift

@@ -127,31 +127,101 @@ struct WrapperContext {
 
 // Class-constrained extension where protocol does not impose class requirement
 // SR-11298
+
 protocol DoesNotImposeClassReq_1 {}
-	
+
 class JustAClass: DoesNotImposeClassReq_1 {
   var property: String = ""
 }
 
 extension DoesNotImposeClassReq_1 where Self: JustAClass {
-  var wrappingProperty: String {
+  var wrappingProperty1: String {
     get { return property }
-    set { property = newValue }
+    set { property = newValue } // Okay
+  }
+  
+  var wrappingProperty2: String {
+    get { return property }
+    nonmutating set { property = newValue } // Okay
+  }
+  
+  var wrappingProperty3: String {
+    get { return property }
+    mutating set { property = newValue } // Okay
+  }
+  
+  mutating func foo() {
+    property = "" // Okay
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // Okay
+  }
+  
+  func bar() { // expected-note {{mark method 'mutating' to make 'self' mutable}}{{2-2=mutating }}
+    property = "" // Okay
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // expected-error {{cannot assign to property: 'self' is immutable}}
+  }
+  
+  nonmutating func baz() { // expected-note {{mark method 'mutating' to make 'self' mutable}}
+    property = "" // Okay
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // expected-error {{cannot assign to property: 'self' is immutable}}
   }
 }
-	
-let instanceOfJustAClass = JustAClass()
-instanceOfJustAClass.wrappingProperty = "" // Okay
+
+let instanceOfJustAClass1 = JustAClass() // expected-note 2{{change 'let' to 'var' to make it mutable}}
+instanceOfJustAClass1.wrappingProperty1 = "" // Okay
+instanceOfJustAClass1.wrappingProperty2 = "" // Okay
+instanceOfJustAClass1.wrappingProperty3 = "" // expected-error {{cannot assign to property: 'instanceOfJustAClass1' is a 'let' constant}}
+instanceOfJustAClass1.foo() // expected-error {{cannot use mutating member on immutable value: 'instanceOfJustAClass1' is a 'let' constant}}
+instanceOfJustAClass1.bar() // Okay
+
+var instanceOfJustAClass2 = JustAClass()
+instanceOfJustAClass2.foo() // Okay
 
 protocol DoesNotImposeClassReq_2 {
   var property: String { get set }
 }
 
 extension DoesNotImposeClassReq_2 where Self : AnyObject {
-  var wrappingProperty: String {
+  var wrappingProperty1: String {
     get { property }
     set { property = newValue } // expected-error {{cannot assign to property: 'self' is immutable}}
   }
+  
+  var wrappingProperty2: String {
+    get { property }
+    nonmutating set { property = newValue } // expected-error {{cannot assign to property: 'self' is immutable}}
+  }
+  
+  var wrappingProperty3: String {
+    get { property }
+    mutating set { property = newValue } // Okay
+  }
+  
+  mutating func foo() {
+    property = "" // Okay
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // Okay
+  }
+  
+  func bar() { // expected-note 2{{mark method 'mutating' to make 'self' mutable}}{{2-2=mutating }}
+    property = "" // expected-error {{cannot assign to property: 'self' is immutable}}
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // expected-error {{cannot assign to property: 'self' is immutable}}
+  }
+  
+  nonmutating func baz() { // expected-note 2{{mark method 'mutating' to make 'self' mutable}}
+    property = "" // expected-error {{cannot assign to property: 'self' is immutable}}
+    wrappingProperty1 = "" // Okay
+    wrappingProperty2 = "" // Okay
+    wrappingProperty3 = "" // expected-error {{cannot assign to property: 'self' is immutable}}
+  }
 }
 
 // Reject extension of nominal type via parameterized typealias