[Sema] Build the TRC for delayed functions bodies

We used to build the full TypeRefinementContext of a source file before
parsing delayed function bodies. This can lead to availability checking
errors in delayed function bodies as the TRCs are incomplete.

Complete the TRC of each delayed function before type-checking them to
fix this.

rdar://82269657

Author: xymus

lib/Sema/TypeCheckAvailability.cpp

@@ -871,6 +871,25 @@ void TypeChecker::buildTypeRefinementContextHierarchy(SourceFile &SF) {
   }
 }
 
+void TypeChecker::buildTypeRefinementContextHierarchyDelayed(SourceFile &SF, AbstractFunctionDecl *AFD) {
+  // If there's no TRC for the file, we likely don't want this one either.
+  // RootTRC is not set when availability checking is disabled.
+  TypeRefinementContext *RootTRC = SF.getTypeRefinementContext();
+  if(!RootTRC)
+    return;
+
+  if (AFD->getBodyKind() != AbstractFunctionDecl::BodyKind::Unparsed)
+    return;
+
+  // Parse the function body.
+  AFD->getBody(/*canSynthesize=*/true);
+
+  // Build the refinement context for the function body.
+  ASTContext &Context = SF.getASTContext();
+  TypeRefinementContextBuilder Builder(RootTRC, Context);
+  Builder.build(AFD);
+}
+
 TypeRefinementContext *
 TypeChecker::getOrBuildTypeRefinementContext(SourceFile *SF) {
   TypeRefinementContext *TRC = SF->getTypeRefinementContext();

lib/Sema/TypeChecker.cpp

@@ -256,6 +256,7 @@ static void typeCheckDelayedFunctions(SourceFile &SF) {
          ++currentFunctionIdx) {
       auto *AFD = SF.DelayedFunctions[currentFunctionIdx];
       assert(!AFD->getDeclContext()->isLocalContext());
+      TypeChecker::buildTypeRefinementContextHierarchyDelayed(SF, AFD);
       (void)AFD->getTypecheckedBody();
     }
 

lib/Sema/TypeChecker.h

@@ -958,6 +958,10 @@ AvailabilityContext overApproximateAvailabilityAtLocation(
 /// Walk the AST to build the hierarchy of TypeRefinementContexts
 void buildTypeRefinementContextHierarchy(SourceFile &SF);
 
+/// Walk the AST to complete the hierarchy of TypeRefinementContexts for
+/// the delayed function body of \p AFD.
+void buildTypeRefinementContextHierarchyDelayed(SourceFile &SF, AbstractFunctionDecl *AFD);
+
 /// Build the hierarchy of TypeRefinementContexts for the entire
 /// source file, if it has not already been built. Returns the root
 /// TypeRefinementContext for the source file.

test/Sema/availability_and_delayed_parsing.swift

@@ -0,0 +1,25 @@
+/// Check for reliable availability checking in inlinable code even when
+/// skipping some function bodies. rdar://82269657
+
+// RUN: %target-swift-frontend -typecheck -dump-type-refinement-contexts %s -target x86_64-apple-macos10.12
+// RUN: %target-swift-frontend -typecheck -dump-type-refinement-contexts %s -target x86_64-apple-macos10.12 -experimental-skip-non-inlinable-function-bodies
+// RUN: %target-swift-frontend -typecheck -dump-type-refinement-contexts %s -target x86_64-apple-macos10.12 -experimental-skip-non-inlinable-function-bodies-without-types
+// RUN: %target-swift-frontend -typecheck -dump-type-refinement-contexts %s -target x86_64-apple-macos10.12 -experimental-skip-all-function-bodies
+
+// REQUIRES: OS=macosx
+
+@available(macOS 10.14, *)
+public func foo() { }
+
+@inlinable public func inlinableFunc() {
+    if #available(macOS 10.14, *) {
+        foo()
+    }
+}
+
+public func funcWithType() {
+    struct S {}
+    if #available(macOS 10.14, *) {
+        foo()
+    }
+}