Sema: implement isFinal using a request evaluator

Add the request evaluator `IsFinalRequest` to lazily determine if a
`ValueDecl` is final.

Author: xymus

include/swift/AST/Decl.h

@@ -2336,10 +2336,18 @@ class ValueDecl : public Decl {
     /// the declaration will go through an extra level of indirection that
     /// allows the entity to be replaced at runtime.
     unsigned isDynamic : 1;
+
+    /// Whether the "isFinal" bit has been computed yet.
+    unsigned isFinalComputed : 1;
+
+    /// Whether this declaration is 'final'. A final class can't be subclassed,
+    /// a final class member can't be overriden.
+    unsigned isFinal : 1;
   } LazySemanticInfo;
 
   friend class OverriddenDeclsRequest;
   friend class IsObjCRequest;
+  friend class IsFinalRequest;
   friend class IsDynamicRequest;
 
 protected:
@@ -2356,6 +2364,8 @@ class ValueDecl : public Decl {
     LazySemanticInfo.hasOverridden = false;
     LazySemanticInfo.isDynamicComputed = false;
     LazySemanticInfo.isDynamic = false;
+    LazySemanticInfo.isFinalComputed = false;
+    LazySemanticInfo.isFinal = false;
   }
 
   // MemberLookupTable borrows a bit from this type
@@ -2596,10 +2606,8 @@ class ValueDecl : public Decl {
   /// Note whether this declaration is known to be exposed to Objective-C.
   void setIsObjC(bool Value);
 
-  /// Is this declaration marked with 'final'?
-  bool isFinal() const {
-    return getAttrs().hasAttribute<FinalAttr>();
-  }
+  /// Is this declaration 'final'?
+  bool isFinal() const;
 
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;

include/swift/AST/TypeCheckRequests.h

@@ -187,6 +187,32 @@ class IsObjCRequest :
   void cacheResult(bool value) const;
 };
 
+/// Determine whether the given declaration is 'final'.
+class IsFinalRequest :
+    public SimpleRequest<IsFinalRequest,
+                         CacheKind::SeparatelyCached,
+                         bool,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Cycle handling
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
 /// Determine whether the given declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -19,6 +19,7 @@ SWIFT_TYPEID(SuperclassTypeRequest)
 SWIFT_TYPEID(EnumRawTypeRequest)
 SWIFT_TYPEID(OverriddenDeclsRequest)
 SWIFT_TYPEID(IsObjCRequest)
+SWIFT_TYPEID(IsFinalRequest)
 SWIFT_TYPEID(IsDynamicRequest)
 SWIFT_TYPEID(RequirementRequest)
 SWIFT_TYPEID(USRGenerationRequest)

lib/AST/ASTPrinter.cpp

@@ -970,6 +970,19 @@ void PrintAST::printAttributes(const Decl *D) {
 
   D->getAttrs().print(Printer, Options, D);
 
+  // Print the implicit 'final' attribute.
+  if (auto VD = dyn_cast<ValueDecl>(D)) {
+    auto VarD = dyn_cast<VarDecl>(D);
+    if (VD->isFinal() &&
+        !VD->getAttrs().hasAttribute<FinalAttr>() &&
+        // Don't print a redundant 'final' if printing a 'let' or 'static' decl.
+        !(VarD && VarD->isLet()) &&
+        getCorrectStaticSpelling(D) != StaticSpellingKind::KeywordStatic) {
+      Printer.printAttrName("final");
+      Printer << " ";
+    }
+  }
+
   // Explicitly print 'mutating' and 'nonmutating' before getters and setters
   // for which that is true.
   if (auto accessor = dyn_cast<AccessorDecl>(D)) {

lib/AST/Decl.cpp

@@ -2384,6 +2384,12 @@ void ValueDecl::setIsObjC(bool value) {
   LazySemanticInfo.isObjC = value;
 }
 
+bool ValueDecl::isFinal() const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           IsFinalRequest { const_cast<ValueDecl *>(this) },
+                           getAttrs().hasAttribute<FinalAttr>());
+}
+
 bool ValueDecl::isDynamic() const {
   ASTContext &ctx = getASTContext();
   return evaluateOrDefault(ctx.evaluator,

lib/AST/TypeCheckRequests.cpp

@@ -220,6 +220,36 @@ void IsObjCRequest::cacheResult(bool value) const {
   decl->setIsObjC(value);
 }
 
+//----------------------------------------------------------------------------//
+// isFinal computation.
+//----------------------------------------------------------------------------//
+
+void IsFinalRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  // FIXME: Improve this diagnostic.
+  auto decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::circular_reference);
+}
+
+void IsFinalRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  auto decl = std::get<0>(getStorage());
+  // FIXME: Customize this further.
+  diags.diagnose(decl, diag::circular_reference_through);
+}
+
+Optional<bool> IsFinalRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (decl->LazySemanticInfo.isFinalComputed)
+    return decl->LazySemanticInfo.isFinal;
+
+  return None;
+}
+
+void IsFinalRequest::cacheResult(bool value) const {
+  auto decl = std::get<0>(getStorage());
+  decl->LazySemanticInfo.isFinalComputed = true;
+  decl->LazySemanticInfo.isFinal = value;
+}
+
 //----------------------------------------------------------------------------//
 // isDynamic computation.
 //----------------------------------------------------------------------------//

lib/IDE/CodeCompletion.cpp

@@ -4167,7 +4167,7 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     if (D->shouldHideFromEditor())
       return;
 
-    if (D->getAttrs().hasAttribute<FinalAttr>() ||
+    if (D->isFinal() ||
         // A 'class' member with an initial value cannot be overriden either.
         (D->isStatic() && D->getAttrs().hasAttribute<HasInitialValueAttr>()))
       return;

lib/Sema/CodeSynthesis.cpp

@@ -367,10 +367,6 @@ createCoroutineAccessorPrototype(AbstractStorageDecl *storage,
   if (isStatic)
     accessor->setStatic();
 
-  // The accessor is final if the storage is.
-  if (storage->isFinal())
-    makeFinal(ctx, accessor);
-
   // If the storage does not provide this accessor as an opaque accessor,
   // we can't add a dynamically-dispatched method entry for the accessor,
   // so force it to be statically dispatched. ("final" would be inappropriate

lib/Sema/DerivedConformanceCodable.cpp

@@ -1039,7 +1039,7 @@ static ValueDecl *deriveDecodable_init(DerivedConformance &derived) {
   initDecl->setBodySynthesizer(&deriveBodyDecodable_init);
 
   // This constructor should be marked as `required` for non-final classes.
-  if (classDecl && !classDecl->getAttrs().hasAttribute<FinalAttr>()) {
+  if (classDecl && !classDecl->isFinal()) {
     auto *reqAttr = new (C) RequiredAttr(/*IsImplicit=*/true);
     initDecl->getAttrs().add(reqAttr);
   }