[AST] Introduce AvailabilityContext to wrap VersionRange.

This is the beginning of the extension of the availability model
introduced in Swift 2.0 to support two interesting things: inlineable
code and binary frameworks not tied to an OS. The former is critical
to having a stable standard library that isn't shipped with a client app.

(For more information on both of these, see docs/LibraryEvolution.rst.)

The existing availability model enforces that API is not used unless
the developer has already guaranteed its existence. We want to reuse
this logic for these new purposes. Additionally, certain queries about
the AST are dependent on this type of information as well, e.g. "can I
assume this enum will not grow any additional cases?" If the enum comes
from the module being compiled, the answer is usually "yes", but not if
the code asking the question may be inlined into another binary!

(This latter purpose is currently served by ResilienceExpansion down at
the SIL level; my goal is to replace ResilienceExpansion with
AvailabilityContext. It's a bit heavier but would also allow additional
optimization in the future.)

This commit does not change any logic; it only wraps existing uses of
VersionRange in AvailabilityContext if they're not strictly referring to
the OS version.

Author: jrose-apple

include/swift/AST/Availability.h

@@ -225,6 +225,97 @@ class UnavailabilityReason {
   }
 };
 
+/// Represents everything that a particular chunk of code may assume about its
+/// runtime environment.
+///
+/// The AvailabilityContext structure forms a [lattice][], which allows it to
+/// have meaningful union and intersection operations ("join" and "meet"),
+/// which use conservative approximations to prevent availability violations.
+/// See #unionWith, #intersectWith, and #constrainWith.
+///
+/// [lattice]: http://mathworld.wolfram.com/Lattice.html
+class AvailabilityContext {
+  VersionRange OSVersion;
+public:
+  /// Creates a context that requires certain versions of the target OS.
+  explicit AvailabilityContext(VersionRange OSVersion) : OSVersion(OSVersion) {}
+
+  /// Creates a context that imposes no constraints.
+  ///
+  /// \see isAlwaysAvailable
+  static AvailabilityContext alwaysAvailable() {
+    return AvailabilityContext(VersionRange::all());
+  }
+
+  /// Creates a context that can never actually occur.
+  ///
+  /// \see isKnownUnreachable
+  static AvailabilityContext neverAvailable() {
+    return AvailabilityContext(VersionRange::empty());
+  }
+
+  /// Returns the range of possible OS versions required by this context.
+  VersionRange getOSVersion() const { return OSVersion; }
+
+  /// Returns true if \p other makes stronger guarantees than this context.
+  ///
+  /// That is, `a.isContainedIn(b)` implies `a.union(b) == b`.
+  bool isContainedIn(AvailabilityContext other) const {
+    return OSVersion.isContainedIn(other.OSVersion);
+  }
+
+  /// Returns true if this context has constraints that make it impossible to
+  /// actually occur.
+  ///
+  /// For example, the else branch of a `#available` check for iOS 8.0 when the
+  /// containing function already requires iOS 9.
+  bool isKnownUnreachable() const {
+    return OSVersion.isEmpty();
+  }
+
+  /// Returns true if there are no constraints on this context; that is,
+  /// nothing can be assumed.
+  bool isAlwaysAvailable() const {
+    return OSVersion.isAll();
+  }
+
+  /// Produces an under-approximation of the intersection of the two
+  /// availability contexts.
+  ///
+  /// That is, if the intersection can't be represented exactly, prefer
+  /// treating some valid deployment environments as unavailable. This is the
+  /// "meet" operation of the lattice.
+  ///
+  /// As an example, this is used when figuring out the required availability
+  /// for a type that references multiple nominal decls.
+  void intersectWith(AvailabilityContext other) {
+    OSVersion.intersectWith(other.getOSVersion());
+  }
+
+  /// Produces an over-approximation of the intersection of the two
+  /// availability contexts.
+  ///
+  /// That is, if the intersection can't be represented exactly, prefer
+  /// treating some invalid deployment environments as available.
+  ///
+  /// As an example, this is used for the true branch of `#available`.
+  void constrainWith(AvailabilityContext other) {
+    OSVersion.constrainWith(other.getOSVersion());
+  }
+
+  /// Produces an over-approximation of the union of two availability contexts.
+  ///
+  /// That is, if the union can't be represented exactly, prefer treating
+  /// some invalid deployment environments as available. This is the "join"
+  /// operation of the lattice.
+  ///
+  /// As an example, this is used for the else branch of a conditional with
+  /// multiple `#available` checks.
+  void unionWith(AvailabilityContext other) {
+    OSVersion.unionWith(other.getOSVersion());
+  }
+};
+
 
 class AvailabilityInference {
 public:
@@ -236,17 +327,17 @@ class AvailabilityInference {
                                  ArrayRef<const Decl *> InferredFromDecls,
                                  ASTContext &Context);
 
-  static VersionRange inferForType(Type t);
+  static AvailabilityContext inferForType(Type t);
 
-  /// \brief Returns the version range on which a declaration is available
+  /// \brief Returns the context where a declaration is available
   ///  We assume a declaration without an annotation is always available.
-  static VersionRange availableRange(const Decl *D, ASTContext &C);
+  static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
-  /// \brief Returns the version range for which the declaration
+  /// \brief Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.
-  static Optional<VersionRange> annotatedAvailableRange(const Decl *D,
-                                                        ASTContext &C);
+  static Optional<AvailabilityContext> annotatedAvailableRange(const Decl *D,
+                                                               ASTContext &C);
 
 };
 

include/swift/AST/TypeRefinementContext.h

@@ -153,35 +153,35 @@ class TypeRefinementContext {
 
   SourceRange SrcRange;
 
-  VersionRange PotentialVersions;
+  AvailabilityContext AvailabilityInfo;
 
   std::vector<TypeRefinementContext *> Children;
 
   TypeRefinementContext(ASTContext &Ctx, IntroNode Node,
                         TypeRefinementContext *Parent, SourceRange SrcRange,
-                        const VersionRange &Versions);
+                        const AvailabilityContext &Info);
 
 public:
 
   /// Create the root refinement context for the given SourceFile.
   static TypeRefinementContext *createRoot(SourceFile *SF,
-                                           const VersionRange &Versions);
+                                           const AvailabilityContext &Info);
 
   /// Create a refinement context for the given declaration.
   static TypeRefinementContext *createForDecl(ASTContext &Ctx, Decl *D,
                                               TypeRefinementContext *Parent,
-                                              const VersionRange &Versions,
+                                              const AvailabilityContext &Info,
                                               SourceRange SrcRange);
 
   /// Create a refinement context for the Then branch of the given IfStmt.
   static TypeRefinementContext *
   createForIfStmtThen(ASTContext &Ctx, IfStmt *S, TypeRefinementContext *Parent,
-                      const VersionRange &Versions);
+                      const AvailabilityContext &Info);
 
   /// Create a refinement context for the Else branch of the given IfStmt.
   static TypeRefinementContext *
   createForIfStmtElse(ASTContext &Ctx, IfStmt *S, TypeRefinementContext *Parent,
-                      const VersionRange &Versions);
+                      const AvailabilityContext &Info);
 
   /// Create a refinement context for the true-branch control flow to
   /// further StmtConditionElements following a #available() query in
@@ -190,26 +190,26 @@ class TypeRefinementContext {
   createForConditionFollowingQuery(ASTContext &Ctx, PoundAvailableInfo *PAI,
                                    const StmtConditionElement &LastElement,
                                    TypeRefinementContext *Parent,
-                                   const VersionRange &Versions);
+                                   const AvailabilityContext &Info);
 
   /// Create a refinement context for the fallthrough of a GuardStmt.
   static TypeRefinementContext *
   createForGuardStmtFallthrough(ASTContext &Ctx, GuardStmt *RS,
                                   BraceStmt *ContainingBraceStmt,
                                   TypeRefinementContext *Parent,
-                                  const VersionRange &Versions);
+                                  const AvailabilityContext &Info);
 
   /// Create a refinement context for the else branch of a GuardStmt.
   static TypeRefinementContext *
   createForGuardStmtElse(ASTContext &Ctx, GuardStmt *RS,
                          TypeRefinementContext *Parent,
-                         const VersionRange &Versions);
+                         const AvailabilityContext &Info);
 
   /// Create a refinement context for the body of a WhileStmt.
   static TypeRefinementContext *
   createForWhileStmtBody(ASTContext &Ctx, WhileStmt *WS,
                          TypeRefinementContext *Parent,
-                          const VersionRange &Versions);
+                         const AvailabilityContext &Info);
 
   /// Returns the reason this context was introduced.
   Reason getReason() const;
@@ -229,9 +229,11 @@ class TypeRefinementContext {
   /// Returns the source range on which this context refines types.
   SourceRange getSourceRange() const { return SrcRange; }
 
-  /// Returns a version range representing the range of operating system
-  /// versions on which the code contained in this context may run.
-  const VersionRange &getPotentialVersions() const { return PotentialVersions; }
+  /// Returns the information on what can be assumed present at run time when
+  /// running code contained in this context.
+  const AvailabilityContext &getAvailabilityInfo() const {
+    return AvailabilityInfo;
+  }
 
   /// Adds a child refinement context.
   void addChild(TypeRefinementContext *Child) {

lib/AST/Availability.cpp

@@ -121,9 +121,9 @@ void AvailabilityInference::applyInferredAvailableAttrs(
   }
 }
 
-Optional<VersionRange>
+Optional<AvailabilityContext>
 AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
-  Optional<VersionRange> AnnotatedRange;
+  Optional<AvailabilityContext> AnnotatedRange;
 
   for (auto Attr : D->getAttrs()) {
     auto *AvailAttr = dyn_cast<AvailableAttr>(Attr);
@@ -132,8 +132,8 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
       continue;
     }
 
-    VersionRange AttrRange =
-        VersionRange::allGTE(AvailAttr->Introduced.getValue());
+    AvailabilityContext AttrRange{
+        VersionRange::allGTE(AvailAttr->Introduced.getValue())};
 
     // If we have multiple introduction versions, we will conservatively
     // assume the worst case scenario. We may want to be more precise here
@@ -149,9 +149,10 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
   return AnnotatedRange;
 }
 
-VersionRange AvailabilityInference::availableRange(const Decl *D,
-                                                   ASTContext &Ctx) {
-  Optional<VersionRange> AnnotatedRange = annotatedAvailableRange(D, Ctx);
+AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
+                                                          ASTContext &Ctx) {
+  Optional<AvailabilityContext> AnnotatedRange =
+      annotatedAvailableRange(D, Ctx);
   if (AnnotatedRange.hasValue()) {
     return AnnotatedRange.getValue();
   }
@@ -173,21 +174,21 @@ VersionRange AvailabilityInference::availableRange(const Decl *D,
   }
 
   // Treat unannotated declarations as always available.
-  return VersionRange::all();
+  return AvailabilityContext::alwaysAvailable();
 }
 
 namespace {
 /// Infers the availability required to access a type.
 class AvailabilityInferenceTypeWalker : public TypeWalker {
 public:
   ASTContext &AC;
-  VersionRange AvailableRange = VersionRange::all();
+  AvailabilityContext AvailabilityInfo = AvailabilityContext::alwaysAvailable();
 
   AvailabilityInferenceTypeWalker(ASTContext &AC) : AC(AC) {}
 
   virtual Action walkToTypePre(Type ty) {
     if (auto *nominalDecl = ty.getCanonicalTypeOrNull().getAnyNominal()) {
-      AvailableRange.intersectWith(
+      AvailabilityInfo.intersectWith(
           AvailabilityInference::availableRange(nominalDecl, AC));
     }
 
@@ -197,8 +198,8 @@ class AvailabilityInferenceTypeWalker : public TypeWalker {
 };
 
 
-VersionRange AvailabilityInference::inferForType(Type t) {
+AvailabilityContext AvailabilityInference::inferForType(Type t) {
   AvailabilityInferenceTypeWalker walker(t->getASTContext());
   t.walk(walker);
-  return walker.AvailableRange;
+  return walker.AvailabilityInfo;
 }