Fix cache.

Author: csyonghe

source/slang/slang-check-impl.h

@@ -301,10 +301,28 @@ struct OverloadCandidate
     SubstitutionSet subst;
 };
 
+struct ResolvedOperatorOverload
+{
+    // The resolved decl.
+    Decl* decl;
+
+    // The cached overload candidate in the current TypeCheckingCache.
+    // Note that a `OverloadCandidate` object is not migratable over different
+    // Linkages (compile sessions), so we will need to use `cacheVersion` to track
+    // if this `candidate` is valid for the current session. If not, we will
+    // recreate it from `decl`.
+    OverloadCandidate candidate;
+    // The version of the TypeCheckingCache for which the cached candidate is valid.
+    int cacheVersion;
+};
+
 struct TypeCheckingCache : public RefObject
 {
-    Dictionary<OperatorOverloadCacheKey, OverloadCandidate> resolvedOperatorOverloadCache;
+    Dictionary<OperatorOverloadCacheKey, ResolvedOperatorOverload> resolvedOperatorOverloadCache;
     Dictionary<BasicTypeKeyPair, ConversionCost> conversionCostCache;
+
+    // The version used to invalidate the cached declRefs in ResolvedOperatorOverload entries.
+    int version = 0;
 };
 
 enum class CoercionSite

source/slang/slang-check-overload.cpp

@@ -2509,28 +2509,6 @@ String SemanticsVisitor::getCallSignatureString(OverloadResolveContext& context)
 Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr)
 {
     OverloadResolveContext context;
-    // check if this is a core module operator call, if so we want to use cached results
-    // to speed up compilation
-    bool shouldAddToCache = false;
-    OperatorOverloadCacheKey key;
-    TypeCheckingCache* typeCheckingCache = getLinkage()->getTypeCheckingCache();
-    if (auto opExpr = as<OperatorExpr>(expr))
-    {
-        if (key.fromOperatorExpr(opExpr))
-        {
-            key.isGLSLMode = getShared()->glslModuleDecl != nullptr;
-            OverloadCandidate candidate;
-            if (typeCheckingCache->resolvedOperatorOverloadCache.tryGetValue(key, candidate))
-            {
-                context.bestCandidateStorage = candidate;
-                context.bestCandidate = &context.bestCandidateStorage;
-            }
-            else
-            {
-                shouldAddToCache = true;
-            }
-        }
-    }
 
     // Look at the base expression for the call, and figure out how to invoke it.
     auto funcExpr = expr->functionExpr;
@@ -2570,6 +2548,43 @@ Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr)
     context.loc = expr->loc;
     context.sourceScope = m_outerScope;
     context.baseExpr = GetBaseExpr(funcExpr);
+
+    // check if this is a core module operator call, if so we want to use cached results
+    // to speed up compilation
+    bool shouldAddToCache = false;
+    OperatorOverloadCacheKey key;
+    TypeCheckingCache* typeCheckingCache = getLinkage()->getTypeCheckingCache();
+    if (auto opExpr = as<OperatorExpr>(expr))
+    {
+        if (key.fromOperatorExpr(opExpr))
+        {
+            key.isGLSLMode = getShared()->glslModuleDecl != nullptr;
+            ResolvedOperatorOverload candidate;
+            if (typeCheckingCache->resolvedOperatorOverloadCache.tryGetValue(key, candidate))
+            {
+                // We should only use the cached candidate if it is persistent direct declref created
+                // from GlobalSession's ASTBuilder, or it is created in the current Linkage.
+                if (candidate.cacheVersion == typeCheckingCache->version ||
+                    as<DirectDeclRef>(candidate.candidate.item.declRef.declRefBase))
+                {
+                    context.bestCandidateStorage = candidate.candidate;
+                    context.bestCandidate = &context.bestCandidateStorage;
+                }
+                else
+                {
+                    LookupResultItem overloadCandidate = {};
+                    overloadCandidate.declRef = getOuterGenericOrSelf(candidate.decl);
+                    AddDeclRefOverloadCandidates(overloadCandidate, context, 0);
+                    shouldAddToCache = true;
+                }
+            }
+            else
+            {
+                shouldAddToCache = true;
+            }
+        }
+    }
+
     // We run a special case here where an `InvokeExpr`
     // with a single argument where the base/func expression names
     // a type should always be treated as an explicit type coercion
@@ -2737,7 +2752,11 @@ Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr)
                 getShared()->glslModuleDecl ==
                     getModuleDecl(context.bestCandidate->item.declRef.getDecl()))
             {
-                typeCheckingCache->resolvedOperatorOverloadCache[key] = *context.bestCandidate;
+                ResolvedOperatorOverload overloadResult;
+                overloadResult.candidate = *context.bestCandidate;
+                overloadResult.decl = context.bestCandidate->item.declRef.getDecl();
+                overloadResult.cacheVersion = typeCheckingCache->version;
+                typeCheckingCache->resolvedOperatorOverloadCache[key] = overloadResult;
             }
         }