Merge pull request swiftlang#36474 from beccadax/objc-behave

[NFC] Use behavior limits to control @objc errors

Author: beccadax

include/swift/AST/DiagnosticEngine.h

@@ -29,6 +29,7 @@
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace swift {
@@ -640,6 +641,8 @@ namespace swift {
     /// Track which diagnostics should be ignored.
     llvm::BitVector ignoredDiagnostics;
 
+    friend class DiagnosticStateRAII;
+
   public:
     DiagnosticState();
 
@@ -740,6 +743,7 @@ namespace swift {
     friend class InFlightDiagnostic;
     friend class DiagnosticTransaction;
     friend class CompoundDiagnosticTransaction;
+    friend class DiagnosticStateRAII;
 
   public:
     explicit DiagnosticEngine(SourceManager &SourceMgr)
@@ -1053,6 +1057,33 @@ namespace swift {
     }
   };
 
+  /// Remember details about the state of a diagnostic engine and restore them
+  /// when the object is destroyed.
+  ///
+  /// Diagnostic engines contain state about the most recent diagnostic emitted
+  /// which influences subsequent emissions; in particular, if you try to emit
+  /// a note and the previous diagnostic was ignored, the note will be ignored
+  /// too. This can be a problem in code structured like:
+  ///
+  ///     D->diagnose(diag::an_error);
+  ///     if (conditionWhichMightEmitDiagnostics())
+  ///        D->diagnose(diag::a_note); // might be affected by diagnostics from
+  ///                                   // conditionWhichMightEmitDiagnostics()!
+  ///
+  /// To prevent this, functions which are called for their return values but
+  /// may emit diagnostics as a side effect can use \c DiagnosticStateRAII to
+  /// ensure that their changes to diagnostic engine state don't leak out and
+  /// affect the caller's diagnostics.
+  class DiagnosticStateRAII {
+    llvm::SaveAndRestore<DiagnosticBehavior> previousBehavior;
+
+  public:
+    DiagnosticStateRAII(DiagnosticEngine &diags)
+      : previousBehavior(diags.state.previousBehavior) {}
+
+    ~DiagnosticStateRAII() {}
+  };
+
   class BufferIndirectlyCausingDiagnosticRAII {
   private:
     DiagnosticEngine &Diags;

lib/Sema/TypeCheckConcurrency.cpp

@@ -902,27 +902,30 @@ static bool isConcurrentValueType(const DeclContext *dc, Type type) {
 
 static bool diagnoseNonConcurrentParameter(
     SourceLoc loc, ConcurrentReferenceKind refKind, ConcreteDeclRef declRef,
-    ParamDecl *param, Type paramType) {
+    ParamDecl *param, Type paramType, DiagnosticBehavior behavior) {
   ASTContext &ctx = declRef.getDecl()->getASTContext();
-  ctx.Diags.diagnose(loc, diag::non_concurrent_param_type, paramType);
+  ctx.Diags.diagnose(loc, diag::non_concurrent_param_type, paramType)
+      .limitBehavior(behavior);
   return false;
 }
 
 static bool diagnoseNonConcurrentResult(
     SourceLoc loc, ConcurrentReferenceKind refKind, ConcreteDeclRef declRef,
-    Type resultType) {
+    Type resultType, DiagnosticBehavior behavior) {
   ASTContext &ctx = declRef.getDecl()->getASTContext();
-  ctx.Diags.diagnose(loc, diag::non_concurrent_result_type, resultType);
+  ctx.Diags.diagnose(loc, diag::non_concurrent_result_type, resultType)
+      .limitBehavior(behavior);
   return false;
 }
 
 static bool diagnoseNonConcurrentProperty(
     SourceLoc loc, ConcurrentReferenceKind refKind, VarDecl *var,
-    Type propertyType) {
+    Type propertyType, DiagnosticBehavior behavior) {
   ASTContext &ctx = var->getASTContext();
   ctx.Diags.diagnose(loc, diag::non_concurrent_property_type,
                      var->getDescriptiveKind(), var->getName(),
-                     propertyType, var->isLocalCapture());
+                     propertyType, var->isLocalCapture())
+      .limitBehavior(behavior);
   return false;
 }
 
@@ -935,7 +938,7 @@ static bool shouldDiagnoseNonConcurrentValueViolations(
 
 bool swift::diagnoseNonConcurrentTypesInReference(
     ConcreteDeclRef declRef, const DeclContext *dc, SourceLoc loc,
-    ConcurrentReferenceKind refKind) {
+    ConcurrentReferenceKind refKind, DiagnosticBehavior behavior) {
   // Bail out immediately if we aren't supposed to do this checking.
   if (!shouldDiagnoseNonConcurrentValueViolations(dc->getASTContext().LangOpts))
     return false;
@@ -947,15 +950,16 @@ bool swift::diagnoseNonConcurrentTypesInReference(
       Type paramType = param->getInterfaceType().subst(subs);
       if (!isConcurrentValueType(dc, paramType)) {
         return diagnoseNonConcurrentParameter(
-            loc, refKind, declRef, param, paramType);
+            loc, refKind, declRef, param, paramType, behavior);
       }
     }
 
     // Check the result type of a function.
     if (auto func = dyn_cast<FuncDecl>(function)) {
       Type resultType = func->getResultInterfaceType().subst(subs);
       if (!isConcurrentValueType(dc, resultType)) {
-        return diagnoseNonConcurrentResult(loc, refKind, declRef, resultType);
+        return diagnoseNonConcurrentResult(loc, refKind, declRef, resultType,
+                                           behavior);
       }
     }
 
@@ -967,7 +971,8 @@ bool swift::diagnoseNonConcurrentTypesInReference(
         ? var->getType()
         : var->getValueInterfaceType().subst(subs);
     if (!isConcurrentValueType(dc, propertyType)) {
-      return diagnoseNonConcurrentProperty(loc, refKind, var, propertyType);
+      return diagnoseNonConcurrentProperty(loc, refKind, var, propertyType,
+                                           behavior);
     }
   }
 
@@ -976,14 +981,15 @@ bool swift::diagnoseNonConcurrentTypesInReference(
       Type paramType = param->getInterfaceType().subst(subs);
       if (!isConcurrentValueType(dc, paramType)) {
         return diagnoseNonConcurrentParameter(
-            loc, refKind, declRef, param, paramType);
+            loc, refKind, declRef, param, paramType, behavior);
       }
     }
 
     // Check the element type of a subscript.
     Type resultType = subscript->getElementInterfaceType().subst(subs);
     if (!isConcurrentValueType(dc, resultType)) {
-      return diagnoseNonConcurrentResult(loc, refKind, declRef, resultType);
+      return diagnoseNonConcurrentResult(loc, refKind, declRef, resultType,
+                                         behavior);
     }
 
     return false;

lib/Sema/TypeCheckConcurrency.h

@@ -18,6 +18,7 @@
 #define SWIFT_SEMA_TYPECHECKCONCURRENCY_H
 
 #include "swift/AST/ConcreteDeclRef.h"
+#include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/Type.h"
 #include <cassert>
 
@@ -205,7 +206,8 @@ bool contextUsesConcurrencyFeatures(const DeclContext *dc);
 /// \returns true if an problem was detected, false otherwise.
 bool diagnoseNonConcurrentTypesInReference(
     ConcreteDeclRef declRef, const DeclContext *dc, SourceLoc loc,
-    ConcurrentReferenceKind refKind);
+    ConcurrentReferenceKind refKind,
+    DiagnosticBehavior behavior = DiagnosticBehavior::Unspecified);
 
 /// How the concurrent value check should be performed.
 enum class ConcurrentValueCheck {