Merge pull request #31159 from CodaFi/track-star

Remove Fallback Infrastructure For Evaluator-Based Dependencies

Author: CodaFi

include/swift/AST/SourceFile.h

@@ -138,7 +138,6 @@ class SourceFile final : public FileUnit {
   TypeRefinementContext *TRC = nullptr;
 
   /// If non-null, used to track name lookups that happen within this file.
-  Optional<ReferencedNameTracker> ReferencedNames;
   Optional<ReferencedNameTracker> RequestReferencedNames;
 
   /// The class in this file marked \@NS/UIApplicationMain.
@@ -452,13 +451,6 @@ class SourceFile final : public FileUnit {
 
   virtual bool walk(ASTWalker &walker) override;
 
-  ReferencedNameTracker *getLegacyReferencedNameTracker() {
-    return ReferencedNames ? ReferencedNames.getPointer() : nullptr;
-  }
-  const ReferencedNameTracker *getLegacyReferencedNameTracker() const {
-    return ReferencedNames ? ReferencedNames.getPointer() : nullptr;
-  }
-
   ReferencedNameTracker *getRequestBasedReferencedNameTracker() {
     return RequestReferencedNames ? RequestReferencedNames.getPointer() : nullptr;
   }
@@ -472,8 +464,7 @@ class SourceFile final : public FileUnit {
   /// else reference dependencies will not be registered.
   void createReferencedNameTracker();
 
-  /// Retrieves the name tracker instance corresponding to
-  /// \c EnableRequestBasedIncrementalDependencies
+  /// Retrieves the appropriate referenced name tracker instance.
   ///
   /// If incremental dependencies tracking is not enabled or \c createReferencedNameTracker()
   /// has not been invoked on this source file, the result is \c nullptr.

include/swift/Basic/LangOptions.h

@@ -347,9 +347,6 @@ namespace swift {
     /// Enable verification when every SubstitutionMap is constructed.
     bool VerifyAllSubstitutionMaps = false;
 
-    /// If set to \c false, fall back to the legacy manual reference name tracking code.
-    bool EnableRequestBasedIncrementalDependencies = true;
-
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

lib/AST/Module.cpp

@@ -1279,10 +1279,6 @@ OperatorType *LookupOperatorRequest<OperatorType>::evaluate(
   if (!result.hasValue())
     return nullptr;
 
-  if (!result.getValue() ||
-      result.getValue()->getDeclContext()->getModuleScopeContext() != file) {
-    namelookup::recordLookupOfTopLevelName(file, desc.name, desc.isCascading);
-  }
   if (!result.getValue()) {
     result = lookupOperatorDeclForName<OperatorType>(file->getParentModule(),
                                                      desc.diagLoc, desc.name,
@@ -2605,19 +2601,13 @@ void SourceFile::setTypeRefinementContext(TypeRefinementContext *Root) {
 }
 
 void SourceFile::createReferencedNameTracker() {
-  assert(!ReferencedNames && "This file already has a name tracker.");
   assert(!RequestReferencedNames && "This file already has a name tracker.");
-  ReferencedNames.emplace(ReferencedNameTracker());
   RequestReferencedNames.emplace(ReferencedNameTracker());
 }
 
 const ReferencedNameTracker *
 SourceFile::getConfiguredReferencedNameTracker() const {
-  if (getASTContext().LangOpts.EnableRequestBasedIncrementalDependencies) {
-    return getRequestBasedReferencedNameTracker();
-  } else {
-    return getLegacyReferencedNameTracker();
-  }
+  return getRequestBasedReferencedNameTracker();
 }
 
 ArrayRef<OpaqueTypeDecl *> SourceFile::getOpaqueReturnTypeDecls() {

lib/AST/NameLookup.cpp

@@ -707,20 +707,6 @@ void namelookup::filterForDiscriminator(SmallVectorImpl<Result> &results,
 template void namelookup::filterForDiscriminator<LookupResultEntry>(
     SmallVectorImpl<LookupResultEntry> &results, DebuggerClient *debugClient);
 
-// FIXME(Evaluator Incremental Dependencies): Remove this function. It is
-// obviated by ModuleQualifiedLookupRequest and LookupInModuleRequest, which
-// both automatically register edges into the request-based name tracker.
-void namelookup::recordLookupOfTopLevelName(DeclContext *topLevelContext,
-                                            DeclName name, bool isCascading) {
-  auto SF = dyn_cast<SourceFile>(topLevelContext);
-  if (!SF)
-    return;
-  auto *nameTracker = SF->getLegacyReferencedNameTracker();
-  if (!nameTracker)
-    return;
-  nameTracker->addTopLevelName(name.getBaseName(), isCascading);
-}
-
 namespace {
   /// Whether we're looking up outer results or not.
   enum class LookupOuterResults {
@@ -1370,51 +1356,6 @@ void ClassDecl::recordObjCMethod(AbstractFunctionDecl *method,
   vec.push_back(method);
 }
 
-/// Configure name lookup for the given declaration context and options.
-///
-/// This utility is used by qualified name lookup.
-static void configureLookup(const DeclContext *dc,
-                            NLOptions options,
-                            ReferencedNameTracker *&tracker,
-                            bool &isLookupCascading) {
-  // Find the dependency tracker we'll need for this lookup.
-  tracker = nullptr;
-  if (auto containingSourceFile =
-          dyn_cast<SourceFile>(dc->getModuleScopeContext())) {
-    tracker = containingSourceFile->getLegacyReferencedNameTracker();
-  }
-
-  auto checkLookupCascading = [dc, options]() -> Optional<bool> {
-    switch (static_cast<unsigned>(options & NL_KnownDependencyMask)) {
-    case 0:
-      return dc->isCascadingContextForLookup(
-               /*functionsAreNonCascading=*/false);
-    case NL_KnownNonCascadingDependency:
-      return false;
-    case NL_KnownCascadingDependency:
-      return true;
-    case NL_KnownNoDependency:
-      return None;
-    default:
-      // FIXME: Use llvm::CountPopulation_64 when that's declared constexpr.
-#if defined(__clang__) || defined(__GNUC__)
-      static_assert(__builtin_popcountll(NL_KnownDependencyMask) == 2,
-                    "mask should only include four values");
-#endif
-      llvm_unreachable("mask only includes four values");
-    }
-  };
-
-  // Determine whether a lookup here will cascade.
-  isLookupCascading = false;
-  if (tracker) {
-    if (auto maybeLookupCascade = checkLookupCascading())
-      isLookupCascading = maybeLookupCascade.getValue();
-    else
-      tracker = nullptr;
-  }
-}
-
 /// Determine whether the given declaration is an acceptable lookup
 /// result when searching from the given DeclContext.
 static bool isAcceptableLookupResult(const DeclContext *dc,
@@ -1580,11 +1521,6 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
   using namespace namelookup;
   QualifiedLookupResult decls;
 
-  // Configure lookup and dig out the tracker.
-  ReferencedNameTracker *tracker = nullptr;
-  bool isLookupCascading;
-  configureLookup(DC, options, tracker, isLookupCascading);
-
   // Tracking for the nominal types we'll visit.
   SmallVector<NominalTypeDecl *, 4> stack;
   llvm::SmallPtrSet<NominalTypeDecl *, 4> visited;
@@ -1617,11 +1553,6 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     auto current = stack.back();
     stack.pop_back();
 
-    // FIXME(Evaluator Incremental Dependencies): Remove this. Each direct
-    // lookup in the stack registers this edge automatically.
-    if (tracker)
-      tracker->addUsedMember({current, member.getBaseName()},isLookupCascading);
-
     // Make sure we've resolved property wrappers, if we need them.
     installPropertyWrapperMembersIfNeeded(current, member);
 
@@ -1721,20 +1652,11 @@ ModuleQualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
   using namespace namelookup;
   QualifiedLookupResult decls;
 
-  // Configure lookup and dig out the tracker.
-  ReferencedNameTracker *tracker = nullptr;
-  bool isLookupCascading;
-  configureLookup(DC, options, tracker, isLookupCascading);
-
   auto kind = (options & NL_OnlyTypes
                ? ResolutionKind::TypesOnly
                : ResolutionKind::Overloadable);
   auto topLevelScope = DC->getModuleScopeContext();
   if (module == topLevelScope->getParentModule()) {
-    if (tracker) {
-      recordLookupOfTopLevelName(topLevelScope, member.getFullName(),
-                                 isLookupCascading);
-    }
     lookupInModule(module, member.getFullName(), decls,
                    NLKind::QualifiedLookup, kind, topLevelScope);
   } else {
@@ -1773,15 +1695,6 @@ AnyObjectLookupRequest::evaluate(Evaluator &evaluator, const DeclContext *dc,
   using namespace namelookup;
   QualifiedLookupResult decls;
 
-  // Configure lookup and dig out the tracker.
-  ReferencedNameTracker *tracker = nullptr;
-  bool isLookupCascading;
-  configureLookup(dc, options, tracker, isLookupCascading);
-
-  // Record this lookup.
-  if (tracker)
-    tracker->addDynamicLookupName(member.getBaseName(), isLookupCascading);
-
   // Type-only lookup won't find anything on AnyObject.
   if (options & NL_OnlyTypes)
     return decls;

lib/AST/UnqualifiedLookup.cpp

@@ -1048,7 +1048,6 @@ void UnqualifiedLookupFactory::setAsideUnavailableResults(
 
 void UnqualifiedLookupFactory::recordDependencyOnTopLevelName(
     DeclContext *topLevelContext, DeclNameRef name, bool isCascadingUse) {
-  recordLookupOfTopLevelName(topLevelContext, Name.getFullName(), isCascadingUse);
   recordedSF = dyn_cast<SourceFile>(topLevelContext);
   recordedIsCascadingUse = isCascadingUse;
 }

lib/Frontend/CompilerInvocation.cpp

@@ -402,10 +402,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   }
 
   Opts.DisableParserLookup |= Args.hasArg(OPT_disable_parser_lookup);
-  Opts.EnableRequestBasedIncrementalDependencies =
-      Args.hasFlag(OPT_enable_request_based_incremental_dependencies,
-                   OPT_disable_request_based_incremental_dependencies,
-                   Opts.EnableRequestBasedIncrementalDependencies);
   Opts.EnableASTScopeLookup =
       Args.hasFlag(options::OPT_enable_astscope_lookup,
                    options::OPT_disable_astscope_lookup, Opts.EnableASTScopeLookup) ||

lib/Sema/CSApply.cpp

@@ -91,7 +91,7 @@ Solution::computeSubstitutions(GenericSignature sig,
     // FIXME: Retrieve the conformance from the solution itself.
     return TypeChecker::conformsToProtocol(replacement, protoType,
                                            getConstraintSystem().DC,
-                                           ConformanceCheckFlags::InExpression);
+                                           None);
   };
 
   return SubstitutionMap::get(sig,
@@ -499,9 +499,7 @@ namespace {
           // the protocol requirement with Self == the concrete type, and SILGen
           // (or later) can devirtualize as appropriate.
           auto conformance =
-            TypeChecker::conformsToProtocol(
-                      baseTy, proto, cs.DC,
-                      ConformanceCheckFlags::InExpression);
+            TypeChecker::conformsToProtocol(baseTy, proto, cs.DC, None);
           if (conformance.isConcrete()) {
             if (auto witness = conformance.getConcrete()->getWitnessDecl(decl)) {
               bool isMemberOperator = witness->getDeclContext()->isTypeContext();
@@ -2137,7 +2135,7 @@ namespace {
         = TypeChecker::conformsToProtocol(valueType,
                                           bridgedProto,
                                           cs.DC,
-                                          ConformanceCheckFlags::InExpression);
+                                          None);
 
       FuncDecl *fn = nullptr;
 
@@ -2397,8 +2395,7 @@ namespace {
       ProtocolDecl *protocol = TypeChecker::getProtocol(
           ctx, expr->getLoc(), KnownProtocolKind::ExpressibleByStringLiteral);
 
-      if (!TypeChecker::conformsToProtocol(
-              type, protocol, cs.DC, ConformanceCheckFlags::InExpression)) {
+      if (!TypeChecker::conformsToProtocol(type, protocol, cs.DC, None)) {
         // If the type does not conform to ExpressibleByStringLiteral, it should
         // be ExpressibleByExtendedGraphemeClusterLiteral.
         protocol = TypeChecker::getProtocol(
@@ -2407,8 +2404,7 @@ namespace {
         isStringLiteral = false;
         isGraphemeClusterLiteral = true;
       }
-      if (!TypeChecker::conformsToProtocol(
-              type, protocol, cs.DC, ConformanceCheckFlags::InExpression)) {
+      if (!TypeChecker::conformsToProtocol(type, protocol, cs.DC, None)) {
         // ... or it should be ExpressibleByUnicodeScalarLiteral.
         protocol = TypeChecker::getProtocol(
             cs.getASTContext(), expr->getLoc(),
@@ -2523,8 +2519,7 @@ namespace {
         assert(proto && "Missing string interpolation protocol?");
 
         auto conformance =
-          TypeChecker::conformsToProtocol(type, proto, cs.DC,
-                                          ConformanceCheckFlags::InExpression);
+          TypeChecker::conformsToProtocol(type, proto, cs.DC, None);
         assert(conformance && "string interpolation type conforms to protocol");
 
         DeclName constrName(ctx, DeclBaseName::createConstructor(), argLabels);
@@ -2630,8 +2625,7 @@ namespace {
       auto proto = TypeChecker::getLiteralProtocol(cs.getASTContext(), expr);
       assert(proto && "Missing object literal protocol?");
       auto conformance =
-        TypeChecker::conformsToProtocol(conformingType, proto, cs.DC,
-                                        ConformanceCheckFlags::InExpression);
+        TypeChecker::conformsToProtocol(conformingType, proto, cs.DC, None);
       assert(conformance && "object literal type conforms to protocol");
 
       auto constrName = TypeChecker::getObjectLiteralConstructorName(ctx, expr);
@@ -3336,8 +3330,7 @@ namespace {
       assert(arrayProto && "type-checked array literal w/o protocol?!");
 
       auto conformance =
-        TypeChecker::conformsToProtocol(arrayTy, arrayProto, cs.DC,
-                                        ConformanceCheckFlags::InExpression);
+        TypeChecker::conformsToProtocol(arrayTy, arrayProto, cs.DC, None);
       assert(conformance && "Type does not conform to protocol?");
 
       DeclName name(ctx, DeclBaseName::createConstructor(),
@@ -3382,7 +3375,7 @@ namespace {
 
       auto conformance =
         TypeChecker::conformsToProtocol(dictionaryTy, dictionaryProto, cs.DC,
-                                        ConformanceCheckFlags::InExpression);
+                                        None);
       if (conformance.isInvalid())
         return nullptr;
 
@@ -4121,8 +4114,7 @@ namespace {
           // Special handle for literals conditional checked cast when they can
           // be statically coerced to the cast type.
           if (protocol && TypeChecker::conformsToProtocol(
-                              toType, protocol, cs.DC,
-                              ConformanceCheckFlags::InExpression)) {
+                              toType, protocol, cs.DC, None)) {
             ctx.Diags
                 .diagnose(expr->getLoc(),
                           diag::literal_conditional_downcast_to_coercion,
@@ -4999,8 +4991,7 @@ namespace {
         // verified by the solver, we just need to get it again
         // with all of the generic parameters resolved.
         auto hashableConformance =
-          TypeChecker::conformsToProtocol(indexType, hashable, cs.DC,
-                                          ConformanceCheckFlags::InExpression);
+          TypeChecker::conformsToProtocol(indexType, hashable, cs.DC, None);
         assert(hashableConformance);
 
         conformances.push_back(hashableConformance);
@@ -5324,7 +5315,7 @@ collectExistentialConformances(Type fromType, Type toType,
   SmallVector<ProtocolConformanceRef, 4> conformances;
   for (auto proto : layout.getProtocols()) {
     conformances.push_back(TypeChecker::containsProtocol(
-        fromType, proto->getDecl(), DC, ConformanceCheckFlags::InExpression));
+        fromType, proto->getDecl(), DC, None));
   }
 
   return toType->getASTContext().AllocateCopy(conformances);
@@ -6490,8 +6481,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       auto hashable = ctx.getProtocol(KnownProtocolKind::Hashable);
       auto conformance =
         TypeChecker::conformsToProtocol(
-                        cs.getType(expr), hashable, cs.DC,
-                        ConformanceCheckFlags::InExpression);
+                        cs.getType(expr), hashable, cs.DC, None);
       assert(conformance && "must conform to Hashable");
 
       return cs.cacheType(
@@ -7026,7 +7016,7 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
   // initialize via the builtin protocol.
   if (builtinProtocol) {
     auto builtinConformance = TypeChecker::conformsToProtocol(
-        type, builtinProtocol, cs.DC, ConformanceCheckFlags::InExpression);
+        type, builtinProtocol, cs.DC, None);
     if (builtinConformance) {
       // Find the witness that we'll use to initialize the type via a builtin
       // literal.
@@ -7058,8 +7048,7 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
 
   // This literal type must conform to the (non-builtin) protocol.
   assert(protocol && "requirements should have stopped recursion");
-  auto conformance = TypeChecker::conformsToProtocol(type, protocol, cs.DC,
-                                           ConformanceCheckFlags::InExpression);
+  auto conformance = TypeChecker::conformsToProtocol(type, protocol, cs.DC, None);
   assert(conformance && "must conform to literal protocol");
 
   // Dig out the literal type and perform a builtin literal conversion to it.
@@ -7196,8 +7185,7 @@ ExprRewriter::buildDynamicCallable(ApplyExpr *apply, SelectedOverload selected,
     auto dictLitProto =
         ctx.getProtocol(KnownProtocolKind::ExpressibleByDictionaryLiteral);
     auto conformance =
-        TypeChecker::conformsToProtocol(argumentType, dictLitProto, cs.DC,
-                                        ConformanceCheckFlags::InExpression);
+        TypeChecker::conformsToProtocol(argumentType, dictLitProto, cs.DC, None);
     auto keyType = conformance.getTypeWitnessByName(argumentType, ctx.Id_Key);
     auto valueType =
         conformance.getTypeWitnessByName(argumentType, ctx.Id_Value);
@@ -8468,8 +8456,7 @@ ProtocolConformanceRef Solution::resolveConformance(
     // itself rather than another conforms-to-protocol check.
     Type substConformingType = simplifyType(conformingType);
     return TypeChecker::conformsToProtocol(
-        substConformingType, proto, constraintSystem->DC,
-        ConformanceCheckFlags::InExpression);
+        substConformingType, proto, constraintSystem->DC, None);
   }
 
   return ProtocolConformanceRef::forInvalid();