[cxx-interop] Add a "nonmutating" swift_attr attribute

Previously, the clang importer marked all const methods as mutating whenever a C++ record had mutable fields. This change allows overriding this behavior by using the "nonmutating" swift_attr attribute.

Fixes SR-15907.

Author: skrtks

include/swift/ClangImporter/ClangImporter.h

@@ -516,6 +516,8 @@ class ClangImporter final : public ClangModuleLoader {
 
   bool isCXXMethodMutating(const clang::CXXMethodDecl *method) override;
 
+  bool isAnnotatedWith(const clang::CXXMethodDecl *method, StringRef attr);
+
   /// Find the lookup table that corresponds to the given Clang module.
   ///
   /// \param clangModule The module, or null to indicate that we're talking

lib/ClangImporter/ClangImporter.cpp

@@ -5656,18 +5656,20 @@ ClangImporter::getCXXFunctionTemplateSpecialization(SubstitutionMap subst,
 
 bool ClangImporter::isCXXMethodMutating(const clang::CXXMethodDecl *method) {
   return isa<clang::CXXConstructorDecl>(method) || !method->isConst() ||
-         // method->getParent()->hasMutableFields() ||
-         // FIXME(rdar://91961524): figure out a way to handle mutable fields
-         // without breaking classes from the C++ standard library (e.g.
-         // `std::string` which has a mutable member in old libstdc++ version
-         // used on CentOS 7)
-         (method->hasAttrs() &&
-          llvm::any_of(method->getAttrs(), [](clang::Attr *a) {
-            if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(a)) {
-              return swiftAttr->getAttribute() == "mutating";
-            }
-            return false;
-          }));
+         (method->getParent()->hasMutableFields() &&
+          !isAnnotatedWith(method, "nonmutating")) ||
+         isAnnotatedWith(method, "mutating");
+}
+
+bool ClangImporter::isAnnotatedWith(const clang::CXXMethodDecl *method,
+                                    StringRef attr) {
+  return method->hasAttrs() &&
+         llvm::any_of(method->getAttrs(), [attr](clang::Attr *a) {
+           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(a)) {
+             return swiftAttr->getAttribute() == attr;
+           }
+           return false;
+         });
 }
 
 SwiftLookupTable *

test/Interop/Cxx/class/Inputs/mutability-annotations.h

@@ -15,4 +15,15 @@ struct HasConstMethodAnnotatedAsMutating {
   }
 };
 
+struct HasMutableProperty {
+  mutable int a;
+  int b;
+
+  int annotatedNonMutating() const __attribute__((__swift_attr__("nonmutating"))) {
+    return b;
+  }
+
+  int noAnnotation() const { return b; }
+};
+
 #endif // TEST_INTEROP_CXX_CLASS_INPUTS_MUTABILITY_ANNOTATIONS_H

test/Interop/Cxx/class/mutability-annotations-module-interface.swift

@@ -5,3 +5,10 @@
 // CHECK:   mutating func annotatedMutatingWithOtherAttrs() -> Int32
 // CHECK:   var a: Int32
 // CHECK: }
+
+// CHECK: struct HasMutableProperty {
+// CHECK:   func annotatedNonMutating() -> Int32
+// CHECK:   mutating func noAnnotation() -> Int32
+// CHECK:   var a: Int32
+// CHECK:   var b: Int32
+// CHECK: }

test/Interop/Cxx/class/mutability-annotations-typechecker.swift

@@ -1,6 +1,13 @@
-// RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop \
+// RUN:     -verify -verify-additional-file %S/Inputs/mutability-annotations.h -verify-ignore-unknown
 
 import MutabilityAnnotations
 
 let obj = HasConstMethodAnnotatedAsMutating(a: 42) // expected-note {{change 'let' to 'var' to make it mutable}}
 let i = obj.annotatedMutating() // expected-error {{cannot use mutating member on immutable value: 'obj' is a 'let' constant}}
+
+let objWMutableProperty = HasMutableProperty(a: 42, b: 21) // expected-note {{change 'let' to 'var' to make it mutable}}
+// expected-note@-1 {{change 'let' to 'var' to make it mutable}}
+
+let _ = objWMutableProperty.annotatedNonMutating()
+let _ = objWMutableProperty.noAnnotation() // expected-error {{cannot use mutating member on immutable value: 'objWMutableProperty' is a 'let' constant}}