Merge pull request swiftlang#28442 from slavapestov/revert-sf-synthesized-decls

Revert "Eagerly TypeCheck Synthesized Decls"

Author: slavapestov

include/swift/AST/SourceFile.h

@@ -147,6 +147,11 @@ class SourceFile final : public FileUnit {
   /// A set of synthesized declarations that need to be type checked.
   llvm::SmallVector<Decl *, 8> SynthesizedDecls;
 
+  /// We might perform type checking on the same source file more than once,
+  /// if its the main file or a REPL instance, so keep track of the last
+  /// checked synthesized declaration to avoid duplicating work.
+  unsigned LastCheckedSynthesizedDecl = 0;
+
   /// A mapping from Objective-C selectors to the methods that have
   /// those selectors.
   llvm::DenseMap<ObjCSelector, llvm::TinyPtrVector<AbstractFunctionDecl *>>

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -1251,10 +1251,7 @@ static ValueDecl *deriveHashable_hashValue(DerivedConformance &derived) {
       C, StaticSpellingKind::None, hashValuePat, /*InitExpr*/ nullptr,
       parentDC);
 
-  // If any of the members we synthesized didn't typecheck, bail out.
-  if (derived.addMembersToConformanceContext({hashValueDecl, patDecl})) {
-    return nullptr;
-  }
+  derived.addMembersToConformanceContext({hashValueDecl, patDecl});
 
   return hashValueDecl;
 }

lib/Sema/DerivedConformances.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/AST/Types.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "DerivedConformances.h"
@@ -35,16 +36,15 @@ DeclContext *DerivedConformance::getConformanceContext() const {
   return cast<DeclContext>(ConformanceDecl);
 }
 
-bool DerivedConformance::addMembersToConformanceContext(
+void DerivedConformance::addMembersToConformanceContext(
     ArrayRef<Decl *> children) {
   auto IDC = cast<IterableDeclContext>(ConformanceDecl);
-  bool anyInvalid = false;
+  auto *SF = ConformanceDecl->getDeclContext()->getParentSourceFile();
   for (auto child : children) {
     IDC->addMember(child);
-    TypeChecker::typeCheckDecl(child);
-    anyInvalid |= child->isInvalid();
+    if (SF)
+      SF->SynthesizedDecls.push_back(child);
   }
-  return anyInvalid;
 }
 
 Type DerivedConformance::getProtocolType() const {
@@ -285,28 +285,38 @@ DerivedConformance::createSelfDeclRef(AbstractFunctionDecl *fn) {
 AccessorDecl *DerivedConformance::
 addGetterToReadOnlyDerivedProperty(VarDecl *property,
                                    Type propertyContextType) {
+  auto getter =
+    declareDerivedPropertyGetter(property, propertyContextType);
+
+  property->setImplInfo(StorageImplInfo::getImmutableComputed());
+  property->setAccessors(SourceLoc(), {getter}, SourceLoc());
+
+  return getter;
+}
+
+AccessorDecl *
+DerivedConformance::declareDerivedPropertyGetter(VarDecl *property,
+                                                 Type propertyContextType) {
   auto &C = property->getASTContext();
   auto parentDC = property->getDeclContext();
   ParameterList *params = ParameterList::createEmpty(C);
 
   Type propertyInterfaceType = property->getInterfaceType();
-
-  auto getter = AccessorDecl::create(C,
+  
+  auto getterDecl = AccessorDecl::create(C,
     /*FuncLoc=*/SourceLoc(), /*AccessorKeywordLoc=*/SourceLoc(),
     AccessorKind::Get, property,
     /*StaticLoc=*/SourceLoc(), StaticSpellingKind::None,
     /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
     /*GenericParams=*/nullptr, params,
     TypeLoc::withoutLoc(propertyInterfaceType), parentDC);
-  getter->setImplicit();
-  getter->setIsTransparent(false);
+  getterDecl->setImplicit();
+  getterDecl->setIsTransparent(false);
 
-  getter->copyFormalAccessFrom(property);
+  getterDecl->copyFormalAccessFrom(property);
 
-  property->setImplInfo(StorageImplInfo::getImmutableComputed());
-  property->setAccessors(SourceLoc(), {getter}, SourceLoc());
 
-  return getter;
+  return getterDecl;
 }
 
 std::pair<VarDecl *, PatternBindingDecl *>

lib/Sema/DerivedConformances.h

@@ -46,10 +46,7 @@ class DerivedConformance {
   DeclContext *getConformanceContext() const;
 
   /// Add \c children as members of the context that declares the conformance.
-  ///
-  /// \returns True if any of the added members were found to be invalid after type
-  /// checking.
-  bool addMembersToConformanceContext(ArrayRef<Decl *> children);
+  void addMembersToConformanceContext(ArrayRef<Decl *> children);
 
   /// Get the declared type of the protocol that this is conformance is for.
   Type getProtocolType() const;
@@ -200,7 +197,12 @@ class DerivedConformance {
   /// Add a getter to a derived property.  The property becomes read-only.
   static AccessorDecl *
   addGetterToReadOnlyDerivedProperty(VarDecl *property,
-                                            Type propertyContextType);
+                                     Type propertyContextType);
+
+  /// Declare a getter for a derived property.
+  /// The getter will not be added to the property yet.
+  static AccessorDecl *declareDerivedPropertyGetter(VarDecl *property,
+                                                    Type propertyContextType);
 
   /// Build a reference to the 'self' decl of a derived function.
   static DeclRefExpr *createSelfDeclRef(AbstractFunctionDecl *fn);

lib/Sema/TypeCheckDecl.cpp

@@ -1550,7 +1550,6 @@ bool TypeChecker::isAvailabilitySafeForConformance(
 // Returns 'nullptr' if this is the setter's 'newValue' parameter;
 // otherwise, returns the corresponding parameter of the subscript
 // declaration.
-
 static ParamDecl *getOriginalParamFromAccessor(AbstractStorageDecl *storage,
                                                AccessorDecl *accessor,
                                                ParamDecl *param) {

lib/Sema/TypeChecker.cpp

@@ -289,6 +289,7 @@ static void bindExtensions(SourceFile &SF) {
 
 static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC) {
   unsigned currentFunctionIdx = 0;
+  unsigned currentSynthesizedDecl = SF.LastCheckedSynthesizedDecl;
   do {
     // Type check the body of each of the function in turn.  Note that outside
     // functions must be visited before nested functions for type-checking to
@@ -300,7 +301,18 @@ static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC)
 
       TypeChecker::typeCheckAbstractFunctionBody(AFD);
     }
-  } while (currentFunctionIdx < TC.definedFunctions.size());
+
+    // Type check synthesized functions and their bodies.
+    for (unsigned n = SF.SynthesizedDecls.size();
+         currentSynthesizedDecl != n;
+         ++currentSynthesizedDecl) {
+      auto decl = SF.SynthesizedDecls[currentSynthesizedDecl];
+      TypeChecker::typeCheckDecl(decl);
+    }
+
+  } while (currentFunctionIdx < TC.definedFunctions.size() ||
+           currentSynthesizedDecl < SF.SynthesizedDecls.size());
+
 
   for (AbstractFunctionDecl *FD : llvm::reverse(TC.definedFunctions)) {
     TypeChecker::computeCaptures(FD);

test/Sema/enum_conformance_synthesis.swift

@@ -61,7 +61,7 @@ func customHashable() {
 enum InvalidCustomHashable {
   case A, B
 
-  var hashValue: String { return "" } // expected-note 2 {{previously declared here}}
+  var hashValue: String { return "" } // expected-note {{previously declared here}}
 }
 func ==(x: InvalidCustomHashable, y: InvalidCustomHashable) -> String {
   return ""
@@ -72,7 +72,7 @@ func invalidCustomHashable() {
   s = InvalidCustomHashable.A.hashValue
   _ = s
   var _: Int = InvalidCustomHashable.A.hashValue
-  InvalidCustomHashable.A.hash(into: &hasher) // expected-error {{value of type 'InvalidCustomHashable' has no member 'hash'}}
+  InvalidCustomHashable.A.hash(into: &hasher)
 }
 
 // Check use of an enum's synthesized members before the enum is actually declared.