[Sema] Don't check availability in assigned properties initializers

For a non-public property where the type is defined by an assignment, like
`internal var internalAssigned = NewStruct()`, type-checking the type's
availability is done via checking the initializer expression.

In -check-api-availaiblity-only mode, pass down a flag to not check
availability in expressions for initializer expressions of such
non-public properties.

rdar://84389825

Author: xymus

include/swift/Sema/ConstraintSystem.h

@@ -5890,7 +5890,8 @@ bool hasExplicitResult(ClosureExpr *closure);
 /// Emit diagnostics for syntactic restrictions within a given solution
 /// application target.
 void performSyntacticDiagnosticsForTarget(
-    const SolutionApplicationTarget &target, bool isExprStmt);
+    const SolutionApplicationTarget &target,
+    bool isExprStmt,bool disableExprAvailabiltyChecking = false);
 
 /// Given a member of a protocol, check whether `Self` type of that
 /// protocol is contextually bound to some concrete type via same-type

lib/Sema/MiscDiagnostics.cpp

@@ -4732,7 +4732,8 @@ void swift::checkPatternBindingDeclAsyncUsage(PatternBindingDecl *decl) {
 /// Emit diagnostics for syntactic restrictions on a given expression.
 void swift::performSyntacticExprDiagnostics(const Expr *E,
                                             const DeclContext *DC,
-                                            bool isExprStmt) {
+                                            bool isExprStmt,
+                                            bool disableExprAvailabiltyChecking) {
   auto &ctx = DC->getASTContext();
   TypeChecker::diagnoseSelfAssignment(E);
   diagSyntacticUseRestrictions(E, DC, isExprStmt);
@@ -4744,7 +4745,7 @@ void swift::performSyntacticExprDiagnostics(const Expr *E,
   diagnoseComparisonWithNaN(E, DC);
   if (!ctx.isSwiftVersionAtLeast(5))
     diagnoseDeprecatedWritableKeyPath(E, DC);
-  if (!ctx.LangOpts.DisableAvailabilityChecking)
+  if (!ctx.LangOpts.DisableAvailabilityChecking && !disableExprAvailabiltyChecking)
     diagnoseExprAvailability(E, const_cast<DeclContext*>(DC));
   if (ctx.LangOpts.EnableObjCInterop)
     diagDeprecatedObjCSelectors(DC, E);

lib/Sema/MiscDiagnostics.h

@@ -34,8 +34,9 @@ namespace swift {
   class ValueDecl;
 
 /// Emit diagnostics for syntactic restrictions on a given expression.
-void performSyntacticExprDiagnostics(const Expr *E, const DeclContext *DC,
-                                     bool isExprStmt);
+void performSyntacticExprDiagnostics(
+    const Expr *E, const DeclContext *DC,
+    bool isExprStmt, bool disableExprAvailabiltyChecking = false);
 
 /// Emit diagnostics for a given statement.
 void performStmtDiagnostics(const Stmt *S, DeclContext *DC);

lib/Sema/TypeCheckAccess.cpp

@@ -1640,19 +1640,6 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
   // "name: TheType" form, we can get better results by diagnosing the TypeRepr.
   UNINTERESTING(Var)
 
-  static bool shouldCheck(Decl *D) {
-    if (D && D->getASTContext().LangOpts.CheckAPIAvailabilityOnly) {
-      // Skip whole decl if not API-public.
-      if (auto valueDecl = dyn_cast<const ValueDecl>(D)) {
-        AccessScope scope =
-          valueDecl->getFormalAccessScope(/*useDC*/nullptr,
-                                          /*treatUsableFromInlineAsPublic*/true);
-        if (!scope.isPublic())
-          return false;
-      }
-    }
-    return true;
-  }
 
   /// \see visitPatternBindingDecl
   void checkNamedPattern(const NamedPattern *NP,
@@ -1699,7 +1686,7 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
   }
 
   void visitPatternBindingDecl(PatternBindingDecl *PBD) {
-    if (!shouldCheck(PBD->getAnchoringVarDecl(0)))
+    if (!shouldCheckAvailability(PBD->getAnchoringVarDecl(0)))
       return;
 
     llvm::DenseSet<const VarDecl *> seenVars;
@@ -1969,8 +1956,22 @@ void swift::checkAccessControl(Decl *D) {
   if (where.isImplicit())
     return;
 
-  if (!DeclAvailabilityChecker::shouldCheck(D))
+  if (!shouldCheckAvailability(D))
     return;
 
   DeclAvailabilityChecker(where).visit(D);
 }
+
+bool swift::shouldCheckAvailability(const Decl *D) {
+  if (D && D->getASTContext().LangOpts.CheckAPIAvailabilityOnly) {
+    // Skip whole decl if not API-public.
+    if (auto valueDecl = dyn_cast<const ValueDecl>(D)) {
+      AccessScope scope =
+        valueDecl->getFormalAccessScope(/*useDC*/nullptr,
+                                        /*treatUsableFromInlineAsPublic*/true);
+      if (!scope.isPublic())
+        return false;
+    }
+  }
+  return true;
+}

lib/Sema/TypeCheckAvailability.h

@@ -265,6 +265,10 @@ bool diagnoseExplicitUnavailability(
 /// Check if \p decl has a introduction version required by -require-explicit-availability
 void checkExplicitAvailability(Decl *decl);
 
+/// Check if \p D needs to be checked for correct availability depending on the
+/// flag -check-api-availability-only.
+bool shouldCheckAvailability(const Decl *D);
+
 } // namespace swift
 
 #endif // SWIFT_SEMA_TYPE_CHECK_AVAILABILITY_H

lib/Sema/TypeCheckConstraints.cpp

@@ -18,6 +18,7 @@
 
 #include "MiscDiagnostics.h"
 #include "TypeChecker.h"
+#include "TypeCheckAvailability.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticSuppression.h"
@@ -272,12 +273,14 @@ class FunctionSyntacticDiagnosticWalker : public ASTWalker {
 } // end anonymous namespace
 
 void constraints::performSyntacticDiagnosticsForTarget(
-    const SolutionApplicationTarget &target, bool isExprStmt) {
+    const SolutionApplicationTarget &target,
+    bool isExprStmt, bool disableExprAvailabiltyChecking) {
   auto *dc = target.getDeclContext();
   switch (target.kind) {
   case SolutionApplicationTarget::Kind::expression: {
     // First emit diagnostics for the main expression.
-    performSyntacticExprDiagnostics(target.getAsExpr(), dc, isExprStmt);
+    performSyntacticExprDiagnostics(target.getAsExpr(), dc,
+                                    isExprStmt, disableExprAvailabiltyChecking);
 
     // If this is a for-in statement, we also need to check the where clause if
     // present.
@@ -400,7 +403,9 @@ TypeChecker::typeCheckExpression(
   // expression now.
   if (!cs.shouldSuppressDiagnostics()) {
     bool isExprStmt = options.contains(TypeCheckExprFlags::IsExprStmt);
-    performSyntacticDiagnosticsForTarget(*resultTarget, isExprStmt);
+    performSyntacticDiagnosticsForTarget(
+        *resultTarget, isExprStmt,
+        options.contains(TypeCheckExprFlags::DisableExprAvailabilityChecking));
   }
 
   resultTarget->setExpr(result);
@@ -428,8 +433,19 @@ bool TypeChecker::typeCheckBinding(
             initializer, DC, patternType, pattern,
             /*bindPatternVarsOneWay=*/false);
 
+  auto options = TypeCheckExprOptions();
+  if (DC->getASTContext().LangOpts.CheckAPIAvailabilityOnly &&
+      PBD && !DC->getAsDecl()) {
+    // Skip checking the initializer for non-public decls when
+    // checking the API only.
+    auto VD = PBD->getAnchoringVarDecl(0);
+    if (!swift::shouldCheckAvailability(VD)) {
+      options |= TypeCheckExprFlags::DisableExprAvailabilityChecking;
+    }
+  }
+
   // Type-check the initializer.
-  auto resultTarget = typeCheckExpression(target);
+  auto resultTarget = typeCheckExpression(target, options);
 
   if (resultTarget) {
     initializer = resultTarget->getAsExpr();

lib/Sema/TypeChecker.h

@@ -134,6 +134,9 @@ enum class TypeCheckExprFlags {
   /// unchecked. This is used by source tooling functionalities such as code
   /// completion.
   LeaveClosureBodyUnchecked = 0x04,
+
+  /// Don't type check expressions for correct availability.
+  DisableExprAvailabilityChecking = 0x08,
 };
 
 using TypeCheckExprOptions = OptionSet<TypeCheckExprFlags>;

test/Sema/api-availability-only-ok.swift

@@ -11,6 +11,9 @@
 @available(macOS 11.0, *)
 public protocol NewProto {}
 
+@available(macOS 11.0, *)
+public struct NewStruct {}
+
 @available(macOS 11.0, *)
 public func newFunc() {}
 
@@ -58,6 +61,10 @@ public struct Struct {
   private var privateVar: NewProto
   fileprivate var fileprivateVar: NewProto
 
+  internal var internalAssigned = NewStruct()
+  private var privateAssigned = NewStruct()
+  fileprivate var fileprivateAssigned = NewStruct()
+
   @available(macOS 11.0, *)
   public typealias PubTA = NewProto
   private typealias PrivateTA = NewProto

test/Sema/api-availability-only.swift

@@ -8,6 +8,11 @@
 @available(macOS 11.0, *)
 public protocol NewProto {}
 
+@available(macOS 11.0, *)
+public struct NewStruct {
+    public init() {}
+}
+
 @available(macOS 11.0, *)
 public func newFunc() {}
 
@@ -23,14 +28,25 @@ public func apiFunc(s : NewProto) { // expected-error {{'NewProto' is only avail
   newFunc()
 }
 
-// expected-note @+1 3 {{add @available attribute to enclosing}}
+// expected-note @+1 6 {{add @available attribute to enclosing}}
 @inlinable func inlinable(s : NewProto) { // expected-error {{'NewProto' is only available in macOS 11.0 or newer}}
 
   // expected-note @+1 {{add 'if #available' version check}}
   let _: NewProto // expected-error {{'NewProto' is only available in macOS 11.0 or newer}}
 
   // expected-note @+1 {{add 'if #available' version check}}
   newFunc() // expected-error {{'newFunc()' is only available in macOS 11.0 or newer}}
+
+  // expected-note @+1 {{add 'if #available' version check}}
+  let _ = NewStruct() // expected-error {{'NewStruct' is only available in macOS 11.0 or newer}}
+
+  // expected-note @+2 {{add 'if #available' version check}}
+  // expected-warning @+1 {{initialization of immutable value 'a' was never used}}
+  let a = NewStruct() // expected-error {{'NewStruct' is only available in macOS 11.0 or newer}}
+
+  // expected-note @+2 {{add 'if #available' version check}}
+  // expected-warning @+1 {{result of 'NewStruct' initializer is unused}}
+  NewStruct() // expected-error {{'NewStruct' is only available in macOS 11.0 or newer}}
 }
 
 // expected-note @+1 {{add @available attribute to enclosing}}
@@ -54,13 +70,18 @@ fileprivate func fileprivateFunc(s : NewProto) {
   newFunc()
 }
 
-// expected-note @+1 7 {{add @available attribute to enclosing struct}}
+// expected-note @+1 8 {{add @available attribute to enclosing struct}}
 public struct Struct {
   public var publicVar: NewProto // expected-error {{'NewProto' is only available in macOS 11.0 or newer}}
   internal var internalVar: NewProto
   private var privateVar: NewProto
   fileprivate var fileprivateVar: NewProto
 
+  public var publicAssigned = NewStruct() // expected-error {{'NewStruct' is only available in macOS 11.0 or newer}}
+  internal var internalAssigned = NewStruct()
+  private var privateAssigned = NewStruct()
+  fileprivate var fileprivateAssigned = NewStruct()
+
   // expected-note @+1 {{add @available attribute to enclosing}}
   public typealias PubTA = NewProto // expected-error {{'NewProto' is only available in macOS 11.0 or newer}}
   private typealias PrivateTA = NewProto