cleanups

Author: ktoso

include/swift/AST/Decl.h

@@ -2258,9 +2258,6 @@ class ValueDecl : public Decl {
     /// Whether this declaration produces an implicitly unwrapped
     /// optional result.
     unsigned isIUO : 1;
-//
-//    /// Whether this declaration is a witness to an ad-hoc requirement.
-//    unsigned isAdHocRequirementWitness : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
@@ -2598,14 +2595,6 @@ class ValueDecl : public Decl {
   /// Returns true if this decl can be found by id-style dynamic lookup.
   bool canBeAccessedByDynamicLookup() const;
 
-//  /// Set whether this declaration is a witness to an ad-hoc requirement or not.
-//  void setIsAdHocRequirementWitness(bool value);
-//
-//  /// Whether this declaration is a witness to an ad-hoc requirement.
-//  bool isAdHocRequirementWitness() const {
-//    return LazySemanticInfo.isAdHocRequirementWitness;
-//  }
-
   /// Returns true if this declaration has an implicitly unwrapped optional
   /// result. The precise meaning depends on the declaration kind:
   /// - for properties, the value is IUO

include/swift/AST/DiagnosticsParse.def

@@ -680,6 +680,8 @@ ERROR(expected_sil_function_type, none,
       "sil function expected to have SIL function type", ())
 ERROR(sil_dynamically_replaced_func_not_found,none,
       "dynamically replaced function not found %0", (Identifier))
+ERROR(sil_adhoc_requirement_witness_func_not_found,none,
+      "ad-hoc requirement witness function not found %0", (Identifier))
 ERROR(sil_specialize_target_func_not_found,none,
       "_specialize target function not found %0", (Identifier))
 ERROR(sil_availability_expected_version,none,

include/swift/SIL/SILDeclRef.h

@@ -555,12 +555,7 @@ struct SILDeclRef {
 
   bool canBeDynamicReplacement() const;
 
-//  /// True if the function was a witness to an ad-hoc requirement.
-//  /// Useful in order to e.g. not optimize away the function even
-//  /// if it seems not-used to the optimizer based on information in SIL.
-//  bool isAdHocRequirementWitness() const;
-
-    bool isAutoDiffDerivativeFunction() const {
+  bool isAutoDiffDerivativeFunction() const {
     return pointer.is<AutoDiffDerivativeFunctionIdentifier *>() &&
            pointer.get<AutoDiffDerivativeFunctionIdentifier *>() != nullptr;
   }

include/swift/SIL/SILFunction.h

@@ -55,10 +55,6 @@ enum IsDynamicallyReplaceable_t {
   IsNotDynamic,
   IsDynamic
 };
-//enum IsAdHocRequirementWitness_t {
-//  IsNotAdHocWitness,
-//  IsAdHocWitness
-//};
 enum IsExactSelfClass_t {
   IsNotExactSelfClass,
   IsExactSelfClass,
@@ -216,14 +212,16 @@ class SILFunction
   /// @_dynamicReplacement(for:) function.
   SILFunction *ReplacedFunction = nullptr;
 
-  /// Ad-hoc requirements may need to be retained explicitly, such that they
-  /// do not get optimized away as it might seem tha they are un-used.
+  /// This SILFunction REFerences an ad-hoc protocol requirement witness in
+  /// order to keep it alive, such that it main be obtained in IRGen. Without
+  /// this explicit reference, the witness would seem not-used, and not be
+  /// accessible for IRGen.
   ///
-  /// Specifically, e.g. the DistributedTargetInvocationDecoder's
-  /// 'decodeNextArgument' must be retained, as it is only used from IRGen
+  /// Specifically, one such case is the DistributedTargetInvocationDecoder's
+  /// 'decodeNextArgument' which must be retained, as it is only used from IRGen
   /// and such, appears as-if unused in SIL and would get optimized away.
-  // TODO: rename: referenced ad hoc requirement witnesses
-  SILFunction *AdHocRequirementFunction = nullptr;
+  // TODO: Consider making this a general "references adhoc functions" and make it an array?
+  SILFunction *RefAdHocRequirementFunction = nullptr;
 
   Identifier ObjCReplacementFor;
 
@@ -363,9 +361,6 @@ class SILFunction
   /// The function is in a statically linked module.
   unsigned IsStaticallyLinked : 1;
 
-//  /// The function is a witness to an ad-hoc requirement.
-//  unsigned IsAdHocRequirementWitness : 1;
-
   static void
   validateSubclassScope(SubclassScope scope, IsThunk_t isThunk,
                         const GenericSpecializationInformation *genericInfo) {
@@ -490,28 +485,25 @@ class SILFunction
     ReplacedFunction = nullptr;
   }
 
-  SILFunction *getUsedAdHocRequirementWitnessFunction() const {
-    return AdHocRequirementFunction;
+  SILFunction *getReferencedAdHocRequirementWitnessFunction() const {
+    return RefAdHocRequirementFunction;
   }
   // Marks that this `SILFunction` uses the passed in ad-hoc protocol
   // requirement witness `f` and therefore must retain it explicitly,
   // otherwise we might not be able to get a reference to it.
-  void setUsedAdHocRequirementWitnessFunction(SILFunction *f) {
-    assert(AdHocRequirementFunction == nullptr && "already set");
-
-    fprintf(stderr, "[%s:%d] (%s) SET AD HOC WITNESS [%s] ON [%s]\n", __FILE__, __LINE__, __FUNCTION__, f->getName().str().c_str(), this->getName().str().c_str());
-    f->dump();
+  void setReferencedAdHocRequirementWitnessFunction(SILFunction *f) {
+    assert(RefAdHocRequirementFunction == nullptr && "already set");
 
     if (f == nullptr)
       return;
-    AdHocRequirementFunction = f;
-    AdHocRequirementFunction->incrementRefCount();
+    RefAdHocRequirementFunction = f;
+    RefAdHocRequirementFunction->incrementRefCount();
   }
-  void dropAdHocRequirementFunction() {
-    if (!AdHocRequirementFunction)
+  void dropReferencedAdHocRequirementWitnessFunction() {
+    if (!RefAdHocRequirementFunction)
       return;
-    AdHocRequirementFunction->decrementRefCount();
-    AdHocRequirementFunction = nullptr;
+    RefAdHocRequirementFunction->decrementRefCount();
+    RefAdHocRequirementFunction = nullptr;
   }
 
   bool hasObjCReplacement() const {
@@ -789,15 +781,6 @@ class SILFunction
     assert(!Transparent || !IsDynamicReplaceable);
   }
 
-  /// Returns whether this function implementation can be dynamically replaced.
-//  IsAdHocRequirementWitness_t isAdHocRequirementWitness() const {
-//    return IsAdHocRequirementWitness_t(IsAdHocRequirementWitness);
-//  }
-//  void setIsAdHocRequirementWitness(IsAdHocRequirementWitness_t value = IsAdHocWitness) {
-//    IsAdHocRequirementWitness = value;
-//    assert(!IsDynamicReplaceable);
-//  }
-    
   IsExactSelfClass_t isExactSelfClass() const {
     return IsExactSelfClass_t(ExactSelfClass);
   }

lib/AST/Decl.cpp

@@ -3167,10 +3167,6 @@ void ValueDecl::setIsDynamic(bool value) {
   LazySemanticInfo.isDynamic = value;
 }
 
-//void ValueDecl::setIsAdHocRequirementWitness(bool value) {
-//  LazySemanticInfo.isAdHocRequirementWitness = true;
-//}
-
 ValueDecl *ValueDecl::getDynamicallyReplacedDecl() const {
   return evaluateOrDefault(getASTContext().evaluator,
                            DynamicallyReplacedDeclRequest{

lib/SIL/IR/SILDeclRef.cpp

@@ -1382,14 +1382,6 @@ bool SILDeclRef::canBeDynamicReplacement() const {
   return true;
 }
 
-//bool SILDeclRef::isAdHocRequirementWitness() const {
-//  auto decl = getDecl();
-//  if (!decl)
-//    return false;
-//
-//  return decl->isAdHocRequirementWitness();
-//}
-
 bool SILDeclRef::isDynamicallyReplaceable() const {
   // The non-foreign entry of a @dynamicReplacement(for:) of @objc method in a
   // generic class can't be a dynamically replaced.

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -223,9 +223,6 @@ void SILFunctionBuilder::addFunctionAttributes(
   }
 
   if (constant.isDistributedThunk()) {
-    fprintf(stderr, "[%s:%d] (%s) IS DIST THUNK!\n", __FILE__, __LINE__, __FUNCTION__);
-    constant.dump();
-
     auto *actor = decl->getDeclContext()->getSelfNominalTypeDecl();
     if (actor && actor->isDistributedActor()) {
       auto &C = decl->getASTContext();
@@ -241,9 +238,7 @@ void SILFunctionBuilder::addFunctionAttributes(
           decoderTy->getAnyNominal());
       auto decodeRef = SILDeclRef(decodeFunc);
       auto *adHocWitness = getOrCreateDeclaration(decodeFunc, decodeRef);
-      F->setUsedAdHocRequirementWitnessFunction(adHocWitness);
-
-      F->dump();
+      F->setReferencedAdHocRequirementWitnessFunction(adHocWitness);
     }
   }
 }

lib/SIL/IR/SILModule.cpp

@@ -138,7 +138,7 @@ SILModule::~SILModule() {
   for (SILFunction &F : *this) {
     F.dropAllReferences();
     F.dropDynamicallyReplacedFunction();
-    F.dropAdHocRequirementFunction();
+    F.dropReferencedAdHocRequirementWitnessFunction();
     F.clearSpecializeAttrs();
   }
 
@@ -468,7 +468,7 @@ void SILModule::eraseFunction(SILFunction *F) {
   // (References are not needed anymore.)
   F->clear();
   F->dropDynamicallyReplacedFunction();
-  F->dropAdHocRequirementFunction();
+  F->dropReferencedAdHocRequirementWitnessFunction();
   // Drop references for any _specialize(target:) functions.
   F->clearSpecializeAttrs();
 }

lib/SIL/IR/SILPrinter.cpp

@@ -2983,11 +2983,10 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
     OS << "\"] ";
   }
 
-  if (auto *usedFunc = getUsedAdHocRequirementWitnessFunction()) {
-    OS << "[used_adhoc_requirement_witness \"";
+  if (auto *usedFunc = getReferencedAdHocRequirementWitnessFunction()) {
+    OS << "[ref_adhoc_requirement_witness \"";
     OS << usedFunc->getName();
     OS << "\"] ";
-    fprintf(stderr, "[%s:%d] (%s) PRINTED THE used_adhoc_requirement_witness...\n", __FILE__, __LINE__, __FUNCTION__);
   }
 
   if (hasObjCReplacement()) {

lib/SIL/Parser/ParseSIL.cpp

@@ -1090,8 +1090,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
 
       SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
       continue;
-    } else if (usedAdHocRequirementWitness && SP.P.Tok.getText() == "used_adhoc_requirement_witness") {
-      fprintf(stderr, "[%s:%d] (%s) PARSING THE... used_adhoc_requirement_witness\n", __FILE__, __LINE__, __FUNCTION__);
+    } else if (usedAdHocRequirementWitness && SP.P.Tok.getText() == "ref_adhoc_requirement_witness") {
       SP.P.consumeToken(tok::identifier);
       if (SP.P.Tok.getKind() != tok::string_literal) {
         SP.P.diagnose(SP.P.Tok, diag::expected_in_attribute_list);
@@ -1102,7 +1101,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
       SILFunction *Func = M.lookUpFunction(witnessFunc.str());
       if (!Func) {
         Identifier Id = SP.P.Context.getIdentifier(witnessFunc);
-        SP.P.diagnose(SP.P.Tok, diag::sil_dynamically_replaced_func_not_found, // FIXME: bettererror
+        SP.P.diagnose(SP.P.Tok, diag::sil_adhoc_requirement_witness_func_not_found,
                       Id);
         return true;
       }
@@ -6401,10 +6400,7 @@ bool SILParserState::parseDeclSIL(Parser &P) {
     FunctionState.F->setIsExactSelfClass(isExactSelfClass);
     FunctionState.F->setDynamicallyReplacedFunction(
         DynamicallyReplacedFunction);
-    if (AdHocWitnessFunction) {
-      fprintf(stderr, "[%s:%d] (%s) PARSED AdHocWitnessFunction\n", __FILE__, __LINE__, __FUNCTION__);
-    }
-    FunctionState.F->setUsedAdHocRequirementWitnessFunction(
+    FunctionState.F->setReferencedAdHocRequirementWitnessFunction(
         AdHocWitnessFunction);
     if (!objCReplacementFor.empty())
       FunctionState.F->setObjCReplacement(objCReplacementFor);