Merge pull request #23932 from xymus/IsFinalRequest

Sema: implement `isFinal` using a request evaluator

Author: xymus

include/swift/AST/Decl.h

@@ -2339,10 +2339,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;
-  } LazySemanticInfo;
+
+    /// 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:
@@ -2353,12 +2361,6 @@ class ValueDecl : public Decl {
     Bits.ValueDecl.AlreadyInLookupTable = false;
     Bits.ValueDecl.CheckedRedeclaration = false;
     Bits.ValueDecl.IsUserAccessible = true;
-    LazySemanticInfo.isObjCComputed = false;
-    LazySemanticInfo.isObjC = false;
-    LazySemanticInfo.hasOverriddenComputed = false;
-    LazySemanticInfo.hasOverridden = false;
-    LazySemanticInfo.isDynamicComputed = false;
-    LazySemanticInfo.isDynamic = false;
   }
 
   // MemberLookupTable borrows a bit from this type
@@ -2599,10 +2601,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/ASTDumper.cpp

@@ -776,7 +776,8 @@ namespace {
         }
       }
 
-      if (VD->isFinal())
+      auto VarD = dyn_cast<VarDecl>(VD);
+      if (VD->isFinal() && !(VarD && VarD->isLet()))
         OS << " final";
       if (VD->isObjC())
         OS << " @objc";

lib/AST/ASTPrinter.cpp

@@ -972,6 +972,20 @@ 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 &&
+        VD->getKind() != DeclKind::Accessor) {
+      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

@@ -2411,6 +2411,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,40 @@ 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;
+
+  // Register Final in attributes, to preserve print order
+  if (value && !decl->getAttrs().hasAttribute<FinalAttr>())
+    decl->getAttrs().add(new (decl->getASTContext()) FinalAttr(/*Implicit=*/true));
+}
+
 //----------------------------------------------------------------------------//
 // isDynamic computation.
 //----------------------------------------------------------------------------//

lib/IDE/CodeCompletion.cpp

@@ -4168,7 +4168,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);
   }

lib/Sema/DerivedConformances.cpp

@@ -280,7 +280,6 @@ DerivedConformance::declareDerivedPropertyGetter(TypeChecker &tc,
                                                  VarDecl *property,
                                                  Type propertyContextType) {
   bool isStatic = property->isStatic();
-  bool isFinal = property->isFinal();
 
   auto &C = tc.Context;
   auto parentDC = property->getDeclContext();
@@ -298,11 +297,6 @@ DerivedConformance::declareDerivedPropertyGetter(TypeChecker &tc,
   getterDecl->setImplicit();
   getterDecl->setStatic(isStatic);
 
-  // If this is supposed to be a final method, mark it as such.
-  assert(isFinal || !parentDC->getSelfClassDecl());
-  if (isFinal && parentDC->getSelfClassDecl() && !getterDecl->isFinal())
-    getterDecl->getAttrs().add(new (C) FinalAttr(/*IsImplicit=*/true));
-
   // Compute the interface type of the getter.
   if (auto env = parentDC->getGenericEnvironmentOfContext())
     getterDecl->setGenericEnvironment(env);
@@ -332,11 +326,6 @@ DerivedConformance::declareDerivedProperty(Identifier name,
   propDecl->setInterfaceType(propertyInterfaceType);
   propDecl->setValidationToChecked();
 
-  // If this is supposed to be a final property, mark it as such.
-  assert(isFinal || !parentDC->getSelfClassDecl());
-  if (isFinal && parentDC->getSelfClassDecl() && !propDecl->isFinal())
-    propDecl->getAttrs().add(new (C) FinalAttr(/*IsImplicit=*/true));
-
   Pattern *propPat = new (C) NamedPattern(propDecl, /*implicit*/ true);
   propPat->setType(propertyContextType);