Substitute generic parameter decl refs

Author: csyonghe

source/slang/slang-ast-decl-ref.cpp

@@ -8,14 +8,62 @@
 namespace Slang
 {
 
+DeclRefBase* _getDeclRefFromVal(Val* val);
+
+static DeclRefBase* _maybeSubstituteGenericParamDeclRef(
+    DeclRefBase* paramDeclRef,
+    SubstitutionSet subst,
+    int* ioDiff)
+{
+    // Type and value substitution can replace a generic parameter with an arbitrary value, but
+    // decl-ref substitution can only preserve that replacement when the argument itself still has
+    // declaration identity.
+    auto paramDecl = paramDeclRef->getDecl();
+    if (!isGenericParam(paramDecl))
+        return nullptr;
+
+    auto outerGeneric = as<GenericDecl>(paramDecl->parentDecl);
+    if (!outerGeneric)
+        return nullptr;
+
+    auto genAppArgs = subst.findGenericAppDeclRef(outerGeneric);
+    if (!genAppArgs)
+        return nullptr;
+
+    auto args = genAppArgs->getArgs();
+    Count argCount = args.getCount();
+    Count argIndex = 0;
+    for (auto member : outerGeneric->getDirectMemberDecls())
+    {
+        if (argIndex >= argCount)
+            return nullptr;
+
+        if (member == paramDecl)
+        {
+            if (auto substDeclRef = _getDeclRefFromVal(args[argIndex]))
+            {
+                (*ioDiff)++;
+                return substDeclRef;
+            }
+            return nullptr;
+        }
+        else if (isGenericParam(member))
+        {
+            argIndex++;
+        }
+    }
+
+    return nullptr;
+}
+
 DeclRefBase* DirectDeclRef::_substituteImplOverride(
     ASTBuilder* astBuilder,
     SubstitutionSet subst,
     int* ioDiff)
 {
     SLANG_UNUSED(astBuilder);
-    SLANG_UNUSED(subst);
-    SLANG_UNUSED(ioDiff);
+    if (auto substDeclRef = _maybeSubstituteGenericParamDeclRef(this, subst, ioDiff))
+        return substDeclRef;
     return this;
 }
 

source/slang/slang-check-decl.cpp

@@ -5794,9 +5794,11 @@ bool SemanticsVisitor::doesGenericSignatureMatchRequirement(
     //
 
     auto getNonEmptyConstraintTargetDeclRef =
-        [&](NonEmptyPackConstraintDecl* constraintDecl) -> DeclRef<Decl>
+        [&](DeclRef<NonEmptyPackConstraintDecl> const& constraintDeclRef) -> DeclRef<Decl>
     {
-        if (auto declRefExpr = as<DeclRefExpr>(constraintDecl->packExpr))
+        auto packExpr =
+            constraintDeclRef.substitute(m_astBuilder, constraintDeclRef.getDecl()->packExpr);
+        if (auto declRefExpr = packExpr.as<DeclRefExpr>())
             return getDeclRef(m_astBuilder, declRefExpr);
         return DeclRef<Decl>();
     };
@@ -6044,30 +6046,6 @@ bool SemanticsVisitor::doesGenericSignatureMatchRequirement(
         }
     }
 
-    // Constraint checks below compare declarations after the required signature has been aligned to
-    // the satisfying signature. Some substituted decl refs still point at the original required
-    // binder, so treat paired generic parameters as equivalent when they occupy the same signature
-    // slot and the structural parameter checks above have already matched their kinds.
-    auto areGenericSignatureDeclRefsAligned = [&](DeclRef<Decl> requiredDeclRef,
-                                                  DeclRef<Decl> satisfyingDeclRef) -> bool
-    {
-        if (requiredDeclRef.equals(satisfyingDeclRef))
-            return true;
-        if (!requiredDeclRef || !satisfyingDeclRef)
-            return false;
-
-        for (Index i = 0; i < requiredParams.getCount(); i++)
-        {
-            if (requiredParams[i].getDecl() == requiredDeclRef.getDecl() &&
-                satisfyingParams[i].getDecl() == satisfyingDeclRef.getDecl())
-            {
-                return true;
-            }
-        }
-
-        return false;
-    };
-
     for (Index i = 0; i < requiredConstraints.getCount(); i++)
     {
         auto requiredMemberDeclRef = requiredConstraints[i];
@@ -6282,10 +6260,10 @@ bool SemanticsVisitor::doesGenericSignatureMatchRequirement(
                 return false;
 
             auto requiredPackTarget =
-                getNonEmptyConstraintTargetDeclRef(specializedRequiredConstraintDeclRef.getDecl());
+                getNonEmptyConstraintTargetDeclRef(specializedRequiredConstraintDeclRef);
             auto satisfyingPackTarget =
-                getNonEmptyConstraintTargetDeclRef(satisfyingConstraintDeclRef.getDecl());
-            if (!areGenericSignatureDeclRefsAligned(requiredPackTarget, satisfyingPackTarget))
+                getNonEmptyConstraintTargetDeclRef(satisfyingConstraintDeclRef);
+            if (!requiredPackTarget.equals(satisfyingPackTarget))
             {
                 return false;
             }
@@ -6316,7 +6294,7 @@ bool SemanticsVisitor::doesGenericSignatureMatchRequirement(
                 specializedRequiredConstraintDeclRef);
             auto satisfyingPackTarget =
                 getPackCountConstraintTargetDeclRef(m_astBuilder, satisfyingConstraintDeclRef);
-            if (!areGenericSignatureDeclRefsAligned(requiredPackTarget, satisfyingPackTarget))
+            if (!requiredPackTarget.equals(satisfyingPackTarget))
             {
                 return false;
             }