Sema: Stub out PreparedOverload

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -64,6 +64,7 @@ namespace constraints {
 
 class ConstraintSystem;
 class SyntacticElementTarget;
+struct PreparedOverload;
 
 } // end namespace constraints
 
@@ -2211,6 +2212,8 @@ class ConstraintSystem {
   unsigned CountDisjunctions = 0;
 
 private:
+  bool PreparingOverload = false;
+
   /// A constraint that has failed along the current solver path.
   /// Do not set directly, call \c recordFailedConstraint instead.
   Constraint *failedConstraint = nullptr;
@@ -2752,6 +2755,7 @@ class ConstraintSystem {
   SolverState *solverState = nullptr;
 
   void recordChange(SolverTrail::Change change) {
+    ASSERT(!PreparingOverload);
     solverState->Trail.recordChange(change);
   }
 
@@ -4447,7 +4451,8 @@ class ConstraintSystem {
                           ValueDecl *decl,
                           FunctionRefInfo functionRefInfo,
                           ConstraintLocatorBuilder locator,
-                          DeclContext *useDC);
+                          DeclContext *useDC,
+                          PreparedOverload *preparedOverload);
 
   /// Return the type-of-reference of the given value.
   ///
@@ -4488,7 +4493,8 @@ class ConstraintSystem {
   DeclReferenceType getTypeOfMemberReference(
       Type baseTy, ValueDecl *decl, DeclContext *useDC, bool isDynamicLookup,
       FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
-      SmallVectorImpl<OpenedType> *replacements = nullptr);
+      SmallVectorImpl<OpenedType> *replacements = nullptr,
+      PreparedOverload *preparedOverload = nullptr);
 
   /// Retrieve a list of generic parameter types solver has "opened" (replaced
   /// with a type variable) at the given location.

include/swift/Sema/PreparedOverload.h

@@ -0,0 +1,31 @@
+//===--- PreparedOverload.h - A Choice from an Overload Set  ----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+#ifndef SWIFT_SEMA_PREPAREDOVERLOAD_H
+#define SWIFT_SEMA_PREPAREDOVERLOAD_H
+
+#include "swift/AST/AvailabilityRange.h"
+#include "swift/AST/FunctionRefInfo.h"
+#include "swift/AST/Types.h"
+#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace swift {
+namespace constraints {
+
+struct PreparedOverload {
+
+};
+
+}
+}
+
+#endif

lib/Sema/CSSimplify.cpp

@@ -16013,6 +16013,8 @@ ConstraintSystem::addConstraintImpl(ConstraintKind kind, Type first,
                                     Type second,
                                     ConstraintLocatorBuilder locator,
                                     bool isFavored) {
+  ASSERT(!PreparingOverload);
+
   assert(first && "Missing first type");
   assert(second && "Missing second type");
 

lib/Sema/ConstraintSystem.cpp

@@ -176,6 +176,8 @@ bool ConstraintSystem::hasFreeTypeVariables() {
 }
 
 void ConstraintSystem::addTypeVariable(TypeVariableType *typeVar) {
+  ASSERT(!PreparingOverload);
+
   TypeVariables.insert(typeVar);
 
   // Notify the constraint graph.

lib/Sema/TypeCheckProtocol.cpp

@@ -1224,7 +1224,7 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
       openWitnessType =
           cs->getTypeOfReference(
                 witness, FunctionRefInfo::doubleBaseNameApply(), witnessLocator,
-                /*useDC=*/nullptr)
+                /*useDC=*/nullptr, /*preparedOverload=*/nullptr)
               .adjustedReferenceType;
     }
     openWitnessType = openWitnessType->getRValueType();

lib/Sema/TypeOfReference.cpp

@@ -29,8 +29,10 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/TypeTransform.h"
 #include "swift/Sema/ConstraintSystem.h"
+#include "swift/Sema/PreparedOverload.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/Basic/Defer.h"
 
 using namespace swift;
 using namespace constraints;
@@ -932,7 +934,20 @@ DeclReferenceType
 ConstraintSystem::getTypeOfReference(ValueDecl *value,
                                      FunctionRefInfo functionRefInfo,
                                      ConstraintLocatorBuilder locator,
-                                     DeclContext *useDC) {
+                                     DeclContext *useDC,
+                                     PreparedOverload *preparedOverload) {
+  if (preparedOverload) {
+    ASSERT(!PreparingOverload);
+    PreparingOverload = true;
+  }
+
+  SWIFT_DEFER {
+    if (preparedOverload) {
+      ASSERT(PreparingOverload);
+      PreparingOverload = false;
+    }
+  };
+
   if (value->getDeclContext()->isTypeContext() && isa<FuncDecl>(value)) {
     // Unqualified lookup can find operator names within nominal types.
     auto func = cast<FuncDecl>(value);
@@ -1507,13 +1522,15 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
 DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     Type baseTy, ValueDecl *value, DeclContext *useDC, bool isDynamicLookup,
     FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
-    SmallVectorImpl<OpenedType> *replacementsPtr) {
+    SmallVectorImpl<OpenedType> *replacementsPtr,
+    PreparedOverload *preparedOverload) {
   // Figure out the instance type used for the base.
   Type resolvedBaseTy = getFixedTypeRecursive(baseTy, /*wantRValue=*/true);
 
   // If the base is a module type, just use the type of the decl.
   if (resolvedBaseTy->is<ModuleType>()) {
-    return getTypeOfReference(value, functionRefInfo, locator, useDC);
+    return getTypeOfReference(value, functionRefInfo, locator, useDC,
+                              preparedOverload);
   }
 
   // Check to see if the self parameter is applied, in which case we'll want to
@@ -2427,10 +2444,12 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
       declRefType = getTypeOfMemberReference(
           baseTy, choice.getDecl(), useDC,
           (kind == OverloadChoiceKind::DeclViaDynamic),
-          choice.getFunctionRefInfo(), locator, nullptr);
+          choice.getFunctionRefInfo(), locator, nullptr,
+          /*preparedOverload=*/nullptr);
     } else {
       declRefType = getTypeOfReference(
-          choice.getDecl(), choice.getFunctionRefInfo(), locator, useDC);
+          choice.getDecl(), choice.getFunctionRefInfo(), locator, useDC,
+          /*preparedOverload=*/nullptr);
     }
 
     openedType = declRefType.openedType;