Don't suppress access-control or invalid-type diagnostics from a

declarator just because we were able to build an invalid decl
for it.  The invalid-type diagnostics, in particular, are still useful
to know, and may indicate something about why the decl is invalid.

Also, recover from an illegal pointer/reference-to-unqualified-retainable
type using __strong instead of __autoreleasing;  in general, a random
object is much more likely to be __strong, so this avoids unnecessary
cascading errors in the most common case.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@149074 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index b15ad0ddd156613926a53264a77487a7c1559c6d..bdf95fa5828b8501c103473e0891c84e4bb661e4 100644 (file)
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -4033,7 +4033,7 @@ void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
 
   // We only want to actually emit delayed diagnostics when we
   // successfully parsed a decl.
-  if (decl && !decl->isInvalidDecl()) {
+  if (decl) {
     // We emit all the active diagnostics, not just those starting
     // from the saved state.  The idea is this:  we get one push for a
     // decl spec and another for each declarator;  in a decl group like:
@@ -4048,7 +4048,9 @@ void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
 
       switch (diag.Kind) {
       case DelayedDiagnostic::Deprecation:
-        S.HandleDelayedDeprecationCheck(diag, decl);
+        // Don't bother giving deprecation diagnostics if the decl is invalid.
+        if (!decl->isInvalidDecl())
+          S.HandleDelayedDeprecationCheck(diag, decl);
         break;
 
       case DelayedDiagnostic::Access:

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index e7b899278f551a87f5d661a45c4b21b252d4ae42..866cd225dbb95c9dec6be1bd915b387bab3f73e8 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -1062,7 +1062,9 @@ static QualType inferARCLifetimeForPointee(Sema &S, QualType type,
   } else if (S.ExprEvalContexts.back().Context == Sema::Unevaluated) {
     return type;
 
-  // If that failed, give an error and recover using __autoreleasing.
+  // If that failed, give an error and recover using __strong.  __strong
+  // is the option most likely to prevent spurious second-order diagnostics,
+  // like when binding a reference to a field.
   } else {
     // These types can show up in private ivars in system headers, so
     // we need this to not be an error in those cases.  Instead we
@@ -1074,7 +1076,7 @@ static QualType inferARCLifetimeForPointee(Sema &S, QualType type,
     } else {
       S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
     }
-    implicitLifetime = Qualifiers::OCL_Autoreleasing;
+    implicitLifetime = Qualifiers::OCL_Strong;
   }
   assert(implicitLifetime && "didn't infer any lifetime!");
 

diff --git a/test/SemaObjC/arc-decls.m b/test/SemaObjC/arc-decls.m
index 4b7eb8fb54d0f37c0ac9cdb2a07bd7e49208c656..314e532a4768865ca9e7b19f67e6e9a52c712d96 100644 (file)
--- a/test/SemaObjC/arc-decls.m
+++ b/test/SemaObjC/arc-decls.m
@@ -86,3 +86,14 @@ void func()
 - (id)not_ret:(id) b __attribute((ns_returns_retained)); // expected-error {{overriding method has mismatched ns_returns_retained attributes}}
 - (id)both__returns_not_retained:(id) b __attribute((ns_returns_not_retained));
 @end
+
+// Test that we give a good diagnostic here that mentions the missing
+// ownership qualifier.  We don't want this to get suppressed because
+// of an invalid conversion.
+void test7(void) {
+  id x;
+  id *px = &x; // expected-error {{pointer to non-const type 'id' with no explicit ownership}}
+
+  I *y;
+  J **py = &y; // expected-error {{pointer to non-const type 'J *' with no explicit ownership}} expected-warning {{incompatible pointer types initializing}}
+}