Sema: Teach ExportContext to compute whether we're inside an implicit declaration

Author: slavapestov

lib/Sema/TypeCheckAccess.cpp

@@ -1541,8 +1541,8 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
   }
 
 public:
-  explicit DeclAvailabilityChecker(Decl *D)
-    : Where(ExportContext::forDeclSignature(D)) {}
+  explicit DeclAvailabilityChecker(ExportContext where)
+    : Where(where) {}
 
   // Force all kinds to be handled at a lower level.
   void visitDecl(Decl *D) = delete;
@@ -1857,9 +1857,12 @@ void swift::checkAccessControl(Decl *D) {
     checkExtensionGenericParamAccess(ED);
   }
 
-  //ExportabilityChecker().visit(D);
-  if (D->isImplicit() || isa<AccessorDecl>(D))
+  if (isa<AccessorDecl>(D))
     return;
 
-  DeclAvailabilityChecker(D).visit(D);
+  auto where = ExportContext::forDeclSignature(D);
+  if (where.isImplicit())
+    return;
+
+  DeclAvailabilityChecker(where).visit(D);
 }

lib/Sema/TypeCheckAttr.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "MiscDiagnostics.h"
+#include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
 #include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
@@ -1980,6 +1981,9 @@ SynthesizeMainFunctionRequest::evaluate(Evaluator &evaluator,
     mainFunction = viableCandidates[0];
   }
 
+  auto where = ExportContext::forDeclSignature(D);
+  diagnoseDeclAvailability(mainFunction, attr->getRange(), where, None);
+
   auto *const func = FuncDecl::createImplicit(
       context, StaticSpellingKind::KeywordStatic,
       DeclName(context, DeclBaseName(context.Id_MainEntryPoint),

lib/Sema/TypeCheckAvailability.cpp

@@ -38,10 +38,12 @@
 using namespace swift;
 
 ExportContext::ExportContext(DeclContext *DC, FragileFunctionKind kind,
-                             bool spi, bool exported, bool deprecated)
+                             bool spi, bool exported, bool implicit,
+                             bool deprecated)
     : DC(DC), FragileKind(kind) {
   SPI = spi;
   Exported = exported;
+  Implicit = implicit;
   Deprecated = deprecated;
   Reason = ExportabilityReason::General;
 }
@@ -180,12 +182,10 @@ ExportContext ExportContext::forDeclSignature(Decl *D) {
 
   bool exported = ::isExported(D);
 
-  return ExportContext(DC, fragileKind, spi, exported, deprecated);
+  return ExportContext(DC, fragileKind, spi, exported, implicit, deprecated);
 }
 
 ExportContext ExportContext::forFunctionBody(DeclContext *DC) {
-  assert(DC && "Use ExportContext::forImplicit() for implicit decls");
-
   bool implicit = false;
   bool deprecated = false;
   forEachOuterDecl(DC,
@@ -204,12 +204,7 @@ ExportContext ExportContext::forFunctionBody(DeclContext *DC) {
     assert(fragileKind.kind == FragileFunctionKind::None);
   }
 
-  return ExportContext(DC, fragileKind, spi, exported, deprecated);
-}
-
-ExportContext ExportContext::forImplicit() {
-  return ExportContext(nullptr, FragileFunctionKind(),
-                       false, false, false);
+  return ExportContext(DC, fragileKind, spi, exported, implicit, deprecated);
 }
 
 ExportContext ExportContext::withReason(ExportabilityReason reason) const {
@@ -1700,29 +1695,6 @@ someEnclosingDeclMatches(SourceRange ReferenceRange,
   return Pred(abstractSyntaxDeclForAvailableAttribute(DeclToSearch));
 }
 
-/// Returns true if the reference or any of its parents is an
-/// implicit function.
-static bool isInsideImplicitFunction(SourceRange ReferenceRange,
-                                     const DeclContext *DC) {
-  auto IsInsideImplicitFunc = [](const Decl *D) {
-    auto *AFD = dyn_cast<AbstractFunctionDecl>(D);
-    return AFD && AFD->isImplicit();
-  };
-
-  return someEnclosingDeclMatches(ReferenceRange, DC, IsInsideImplicitFunc);
-}
-
-/// Returns true if the reference or any of its parents is an
-/// unavailable (or obsoleted) declaration.
-static bool isInsideUnavailableDeclaration(SourceRange ReferenceRange,
-                                           const DeclContext *ReferenceDC) {
-  auto IsUnavailable = [](const Decl *D) {
-    return D->getAttrs().getUnavailable(D->getASTContext());
-  };
-
-  return someEnclosingDeclMatches(ReferenceRange, ReferenceDC, IsUnavailable);
-}
-
 /// Returns true if the reference or any of its parents is an
 /// unconditional unavailable declaration for the same platform.
 static bool isInsideCompatibleUnavailableDeclaration(
@@ -2135,21 +2107,14 @@ void TypeChecker::diagnoseIfDeprecated(SourceRange ReferenceRange,
   if (!Attr)
     return;
 
-  auto *ReferenceDC = Where.getDeclContext();
-
-  // We don't want deprecated declarations to trigger warnings
-  // in synthesized code.
-  if (ReferenceRange.isInvalid() &&
-      isInsideImplicitFunction(ReferenceRange, ReferenceDC)) {
-    return;
-  }
   // We match the behavior of clang to not report deprecation warnings
   // inside declarations that are themselves deprecated on all deployment
   // targets.
   if (Where.isDeprecated()) {
     return;
   }
 
+  auto *ReferenceDC = Where.getDeclContext();
   auto &Context = ReferenceDC->getASTContext();
   if (!Context.LangOpts.DisableAvailabilityChecking) {
     AvailabilityContext RunningOSVersions =
@@ -2351,16 +2316,6 @@ bool swift::diagnoseExplicitUnavailability(
   if (!Attr)
     return false;
 
-  // Suppress the diagnostic if we are in synthesized code inside
-  // a synthesized function and the reference is lexically
-  // contained in a declaration that is itself marked unavailable.
-  // The right thing to do here is to not synthesize that code in the
-  // first place. rdar://problem/20491640
-  if (R.isInvalid() && isInsideImplicitFunction(R, DC) &&
-      isInsideUnavailableDeclaration(R, DC)) {
-    return false;
-  }
-
   // Calling unavailable code from within code with the same
   // unavailability is OK -- the eventual caller can't call the
   // enclosing code in the same situations it wouldn't be able to
@@ -2512,20 +2467,6 @@ class AvailabilityWalker : public ASTWalker {
   SmallVector<const Expr *, 16> ExprStack;
   ExportContext Where;
 
-  /// Returns true if DC is an \c init(rawValue:) declaration and it is marked
-  /// implicit.
-  bool inSynthesizedInitRawValue() {
-    auto *DC = Where.getDeclContext();
-    auto init = dyn_cast_or_null<ConstructorDecl>(
-                    DC->getInnermostDeclarationDeclContext());
-
-    return init &&
-           init->isImplicit() &&
-           init->getParameters()->size() == 1 &&
-           init->getParameters()->get(0)->getArgumentName() ==
-                   Context.Id_rawValue;
-  }
-
 public:
   AvailabilityWalker(ExportContext Where)
     : Context(Where.getDeclContext()->getASTContext()), Where(Where) {}
@@ -2548,20 +2489,8 @@ class AvailabilityWalker : public ASTWalker {
     };
 
     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
-      DeclAvailabilityFlags flags = None;
-      if (inSynthesizedInitRawValue())
-        // HACK: If a raw-value enum has cases with `@available(introduced:)`
-        // attributes, the auto-derived `init(rawValue:)` will contain
-        // DeclRefExprs which reference those cases. It will also contain
-        // appropriate `guard #available` statements to keep them from running
-        // on older versions, but the availability checker can't verify that
-        // because the synthesized code uses invalid SourceLocs. Don't diagnose
-        // these errors; instead, take it on faith that
-        // DerivedConformanceRawRepresentable will do the right thing.
-        flags |= DeclAvailabilityFlag::AllowPotentiallyUnavailable;
-
       diagAvailability(DR->getDeclRef(), DR->getSourceRange(),
-                       getEnclosingApplyExpr(), flags);
+                       getEnclosingApplyExpr(), None);
       maybeDiagStorageAccess(DR->getDecl(), DR->getSourceRange(), DC);
     }
     if (auto MR = dyn_cast<MemberRefExpr>(E)) {
@@ -2861,9 +2790,6 @@ AvailabilityWalker::diagAvailability(ConcreteDeclRef declRef, SourceRange R,
   if (!isAccessorWithDeprecatedStorage)
     TypeChecker::diagnoseIfDeprecated(R, Where, D, call);
 
-  if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailable))
-    return false;
-
   if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol)
         && isa<ProtocolDecl>(D))
     return false;
@@ -3041,7 +2967,10 @@ AvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
 
 /// Diagnose uses of unavailable declarations.
 void swift::diagAvailability(const Expr *E, DeclContext *DC) {
-  AvailabilityWalker walker(ExportContext::forFunctionBody(DC));
+  auto where = ExportContext::forFunctionBody(DC);
+  if (where.isImplicit())
+    return;
+  AvailabilityWalker walker(where);
   const_cast<Expr*>(E)->walk(walker);
 }
 
@@ -3051,8 +2980,8 @@ class StmtAvailabilityWalker : public ASTWalker {
   ExportContext Where;
 
 public:
-  explicit StmtAvailabilityWalker(DeclContext *DC)
-    : Where(ExportContext::forFunctionBody(DC)) {}
+  explicit StmtAvailabilityWalker(ExportContext where)
+    : Where(where) {}
 
   /// We'll visit the expression from performSyntacticExprDiagnostics().
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
@@ -3079,7 +3008,11 @@ void swift::diagAvailability(const Stmt *S, DeclContext *DC) {
   if (isa<BraceStmt>(S))
     return;
 
-  StmtAvailabilityWalker walker(DC);
+  auto where = ExportContext::forFunctionBody(DC);
+  if (where.isImplicit())
+    return;
+
+  StmtAvailabilityWalker walker(where);
   const_cast<Stmt*>(S)->walk(walker);
 }
 
@@ -3281,6 +3214,7 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *Decl,
                                      ExportContext Where,
                                      DeclAvailabilityFlags Flags)
 {
+  assert(!Where.isImplicit());
   AvailabilityWalker AW(Where);
   return AW.diagAvailability(const_cast<ValueDecl *>(Decl), R, nullptr, Flags);
 }

lib/Sema/TypeCheckAvailability.h

@@ -49,13 +49,9 @@ enum class DeclAvailabilityFlag : uint8_t {
   /// is inout and both the getter and setter must be available.
   ForInout = 1 << 2,
 
-  /// Do not diagnose uses of declarations in versions before they were
-  /// introduced. Used to work around availability-checker bugs.
-  AllowPotentiallyUnavailable = 1 << 3,
-
   /// If an error diagnostic would normally be emitted, demote the error to a
   /// warning. Used for ObjC key path components.
-  ForObjCKeyPath = 1 << 4
+  ForObjCKeyPath = 1 << 3
 };
 using DeclAvailabilityFlags = OptionSet<DeclAvailabilityFlag>;
 
@@ -98,10 +94,12 @@ class ExportContext {
   unsigned SPI : 1;
   unsigned Exported : 1;
   unsigned Deprecated : 1;
+  unsigned Implicit : 1;
   ExportabilityReason Reason;
 
   ExportContext(DeclContext *DC, FragileFunctionKind kind,
-                bool spi, bool exported, bool deprecated);
+                bool spi, bool exported, bool implicit,
+                bool deprecated);
 
 public:
 
@@ -121,11 +119,6 @@ class ExportContext {
   /// it can reference anything.
   static ExportContext forFunctionBody(DeclContext *DC);
 
-  /// Produce a new context describing an implicit declaration. Implicit code
-  /// does not have source locations. We simply trust the compiler synthesizes
-  /// implicit declarations correctly, and skip the checks.
-  static ExportContext forImplicit();
-
   /// Produce a new context with the same properties as this one, except
   /// changing the ExportabilityReason. This only affects diagnostics.
   ExportContext withReason(ExportabilityReason reason) const;
@@ -138,17 +131,14 @@ class ExportContext {
   /// That is, this will perform a 'bitwise and' on the 'exported' bit.
   ExportContext withExported(bool exported) const;
 
-  DeclContext *getDeclContext() const {
-    assert(DC != nullptr && "This is an implicit context");
-    return DC;
-  }
+  DeclContext *getDeclContext() const { return DC; }
 
   /// If not 'None', the context has the inlinable function body restriction.
   FragileFunctionKind getFragileFunctionKind() const { return FragileKind; }
 
   /// If true, the context is part of a synthesized declaration, and
   /// availability checking should be disabled.
-  bool isImplicit() const { return DC == nullptr; }
+  bool isImplicit() const { return Implicit; }
 
   /// If true, the context is SPI and can reference SPI declarations.
   bool isSPI() const { return SPI; }

test/Sema/implementation-only-import-in-decls.swift

@@ -73,7 +73,6 @@ public protocol TestAssocTypeWhereClause {
 
 public enum TestRawType: IntLike { // expected-error {{cannot use struct 'IntLike' here; 'BADLibrary' has been imported as implementation-only}}
   case x = 1
-  // FIXME: expected-error@-1 {{cannot use conformance of 'IntLike' to 'Equatable' here; 'BADLibrary' has been imported as implementation-only}}
 }
 
 public class TestSubclass: BadClass { // expected-error {{cannot use class 'BadClass' here; 'BADLibrary' has been imported as implementation-only}}

test/Sema/spi-in-decls.swift

@@ -107,7 +107,6 @@ public protocol TestAssocTypeWhereClause {
 
 public enum TestRawType: IntLike { // expected-error {{cannot use struct 'IntLike' here; it is SPI}}
   case x = 1
-  // FIXME: expected-error@-1 {{cannot use conformance of 'IntLike' to 'Equatable' here; the conformance is declared as SPI}}
 }
 
 public class TestSubclass: BadClass { // expected-error {{cannot use class 'BadClass' here; it is SPI}}