Suggest a similarly-spelled identifier on undefined-identifier errors

Add a 'did you mean ...?' note to E30015 when a close in-scope name
exists, using a new StringUtil::calcLevenshteinDistance helper.
Conservative: scales the allowed edit distance with name length and
excludes core-module builtins so it stays quiet in normal code.

Fixes #9124.

Author: expipiplus1

source/core/slang-string-util.cpp

@@ -975,4 +975,41 @@ int StringUtil::parseIntAndAdvancePos(UnownedStringSlice text, Index& pos)
     return result;
 }
 
+Index StringUtil::calcLevenshteinDistance(const UnownedStringSlice& a, const UnownedStringSlice& b)
+{
+    const Index lenA = a.getLength();
+    const Index lenB = b.getLength();
+    if (lenA == 0)
+        return lenB;
+    if (lenB == 0)
+        return lenA;
+
+    // Classic dynamic-programming Levenshtein using two rolling rows so the
+    // working set is O(lenB) rather than O(lenA * lenB).
+    List<Index> prevRow;
+    List<Index> currRow;
+    prevRow.setCount(lenB + 1);
+    currRow.setCount(lenB + 1);
+
+    for (Index j = 0; j <= lenB; ++j)
+        prevRow[j] = j;
+
+    for (Index i = 1; i <= lenA; ++i)
+    {
+        currRow[0] = i;
+        const char ca = a[i - 1];
+        for (Index j = 1; j <= lenB; ++j)
+        {
+            const Index cost = (ca == b[j - 1]) ? 0 : 1;
+            const Index deletion = prevRow[j] + 1;
+            const Index insertion = currRow[j - 1] + 1;
+            const Index substitution = prevRow[j - 1] + cost;
+            currRow[j] = Math::Min(deletion, insertion, substitution);
+        }
+        prevRow.swapWith(currRow);
+    }
+
+    return prevRow[lenB];
+}
+
 } // namespace Slang

source/core/slang-string-util.h

@@ -198,6 +198,13 @@ struct StringUtil
     /// Modifies pos to the position where parsing ends.
     /// Returns parsed integer.
     static int parseIntAndAdvancePos(UnownedStringSlice text, Index& pos);
+
+    /// Compute the Levenshtein edit distance between `a` and `b`: the minimum number of
+    /// single-character insertions, deletions, or substitutions needed to turn one string
+    /// into the other. Used, for example, to suggest the closest known identifier for a
+    /// misspelled name ("did you mean ...?"). The comparison is case-sensitive; lower-case
+    /// the inputs beforehand for a case-insensitive distance.
+    static Index calcLevenshteinDistance(const UnownedStringSlice& a, const UnownedStringSlice& b);
 };
 
 /* A helper class that allows parsing of lines from text with iteration. Uses

source/slang/slang-check-expr.cpp

@@ -12,6 +12,7 @@
 // * `slang-check-conversion.cpp` is responsible for the logic of handling type conversion/coercion
 
 #include "../core/slang-math.h"
+#include "../core/slang-string-util.h"
 #include "core/slang-char-util.h"
 #include "slang-ast-decl.h"
 #include "slang-ast-natural-layout.h"
@@ -5053,6 +5054,87 @@ Expr* SemanticsExprVisitor::visitInvokeExpr(InvokeExpr* expr)
     return checkedExpr;
 }
 
+// Find the in-scope identifier whose spelling is closest to `name`, to power a
+// "did you mean ...?" suggestion when `name` failed to resolve. Walks the scope
+// chain (and each scope's sibling chain) collecting the names of direct members,
+// computes the case-insensitive Levenshtein distance to each, and returns the
+// single closest candidate within a small distance threshold. Returns nullptr if
+// nothing is close enough, so the caller can simply omit the suggestion. Only
+// direct members are considered (not inherited/extension members); that is the
+// common typo case and keeps this off the hot path of successful lookups.
+static Name* findClosestInScopeName(Name* name, Scope* scope)
+{
+    if (!name)
+        return nullptr;
+
+    const UnownedStringSlice target = getUnownedStringSliceText(name);
+    if (target.getLength() == 0)
+        return nullptr;
+
+    // Lower-case the target once for a case-insensitive comparison.
+    StringBuilder targetLowerBuilder;
+    for (auto c : target)
+        targetLowerBuilder.appendChar(CharUtil::toLower(c));
+    const String targetLower = targetLowerBuilder.produceString();
+
+    // Scale the allowed edit distance with the identifier length and cap it, so
+    // that we only offer genuinely-close names (e.g. `lenght` -> `length`, or
+    // `f_a` -> `f_b`) and never a wildly different one (e.g. the keyword `case`
+    // -> the module `core`, a distance-2 edit on a 4-char name). Roughly one edit
+    // per three characters with a floor of one, matching the heuristic used by
+    // other compilers. Names shorter than 3 chars are too short to suggest against.
+    if (target.getLength() < 3)
+        return nullptr;
+    const Index maxDistance = Math::Min<Index>(3, Math::Max<Index>(1, target.getLength() / 3));
+
+    Name* best = nullptr;
+    Index bestDistance = maxDistance + 1;
+
+    for (Scope* s = scope; s; s = s->parent)
+    {
+        for (Scope* sib = s; sib; sib = sib->nextSibling)
+        {
+            auto containerDecl = sib->containerDecl;
+            if (!containerDecl)
+                continue;
+
+            for (auto candidateDecl : containerDecl->getDirectMemberDecls())
+            {
+                Name* candidateName = candidateDecl->getName();
+                if (!candidateName || candidateName == name)
+                    continue;
+
+                // Don't suggest names from the core module. Its global scope holds
+                // thousands of builtins, so almost any identifier finds a spurious
+                // close match there (e.g. `instance` -> `distance`); restricting to
+                // user-written declarations keeps suggestions quiet and relevant.
+                if (isFromCoreModule(candidateDecl))
+                    continue;
+
+                const UnownedStringSlice candidateText = getUnownedStringSliceText(candidateName);
+                if (candidateText.getLength() == 0)
+                    continue;
+
+                StringBuilder candidateLowerBuilder;
+                for (auto c : candidateText)
+                    candidateLowerBuilder.appendChar(CharUtil::toLower(c));
+                const String candidateLower = candidateLowerBuilder.produceString();
+
+                const Index distance = StringUtil::calcLevenshteinDistance(
+                    targetLower.getUnownedSlice(),
+                    candidateLower.getUnownedSlice());
+                if (distance < bestDistance)
+                {
+                    bestDistance = distance;
+                    best = candidateName;
+                }
+            }
+        }
+    }
+
+    return (bestDistance <= maxDistance) ? best : nullptr;
+}
+
 Expr* SemanticsExprVisitor::visitVarExpr(VarExpr* expr)
 {
     // If we've already resolved this expression, don't try again.
@@ -5097,8 +5179,18 @@ Expr* SemanticsExprVisitor::visitVarExpr(VarExpr* expr)
     }
 
     if (!diagnosed)
-        getSink()->diagnose(
-            Diagnostics::UndefinedIdentifier{.name = expr->name, .location = expr->loc});
+    {
+        // If a similarly-spelled identifier is in scope, attach a "did you mean
+        // 'length'?" note to the error; this turns a bare "undefined identifier
+        // 'lenght'" into an actionable hint. The note only renders when
+        // `suggestionLocation` is valid, so a null suggestion is harmless.
+        auto suggestion = findClosestInScopeName(expr->name, expr->scope);
+        getSink()->diagnose(Diagnostics::UndefinedIdentifier{
+            .name = expr->name,
+            .suggestion = suggestion,
+            .location = expr->loc,
+            .suggestionLocation = suggestion ? expr->loc : SourceLoc{}});
+    }
 
     return resultExpr;
 }

source/slang/slang-diagnostics.lua

@@ -1130,7 +1130,10 @@ err(
     "undefined-identifier",
     30015,
     "undefined identifier",
-    span { loc = "location", message = "undefined identifier '~name:Name'." }
+    span { loc = "location", message = "undefined identifier '~name:Name'." },
+    -- Optional "did you mean ...?" note, rendered only when `suggestionLocation`
+    -- is set to a valid location by the caller (i.e. a close in-scope name exists).
+    note { message = "did you mean '~suggestion:Name'?", span { loc = "suggestionLocation" } }
 )
 
 err(

tests/diagnostics/autodiff-custom-diff-unresolved.slang

@@ -12,6 +12,7 @@ void __d_f(float x, float.Differential dout)
 /*CHECK:
                     ^^^^^ undefined identifier
                     ^^^^^ undefined identifier '__d_g'.
+                    ^^^^^ did you mean '__d_f'?
  ^^^^^^^^^^^^^^^^^^ cannot resolve derivative function
  ^^^^^^^^^^^^^^^^^^ cannot resolve the custom derivative function
 */

tests/diagnostics/did-you-mean-identifier.slang

@@ -0,0 +1,20 @@
+// Test for issue #9124: an undefined identifier that is a close misspelling of
+// an in-scope name produces a "did you mean ...?" suggestion note.
+
+//DIAGNOSTIC_TEST:SIMPLE(diag=CHECK):-target spirv
+
+float closeMatch(float myVariable)
+{
+    return myVariabl;
+//CHECK:   ^^^^^^^^^ undefined identifier
+//CHECK:   ^^^^^^^^^ undefined identifier 'myVariabl'.
+//CHECK:   ^^^^^^^^^ did you mean 'myVariable'?
+}
+
+// A name with no nearby candidate must NOT produce a suggestion note.
+float noMatch()
+{
+    return zzzzqqq;
+//CHECK:   ^^^^^^^ undefined identifier
+//CHECK:   ^^^^^^^ undefined identifier 'zzzzqqq'.
+}

tests/diagnostics/transitive-namespace-import.slang/test.slang

@@ -22,6 +22,7 @@ namespace ns
         f_a(); // Error.
 //CHECK:^^^ undefined identifier
 //CHECK:^^^ undefined identifier 'f_a'.
+//CHECK:^^^ did you mean 'f_b'?
     }
 }
 
@@ -35,5 +36,6 @@ namespace ns2
         f_a(); // Error.
 //CHECK:^^^ undefined identifier
 //CHECK:^^^ undefined identifier 'f_a'.
+//CHECK:^^^ did you mean 'f_b'?
     }
 }

tools/slang-unit-test/unit-test-string-util.cpp

@@ -296,3 +296,34 @@ SLANG_UNIT_TEST(stringUtilAppendFormat)
     StringUtil::appendFormat(buf, " v=%d", 7);
     SLANG_CHECK(buf.produceString() == "prefix: v=7");
 }
+
+// -- Levenshtein edit distance ----------------------------------------
+
+SLANG_UNIT_TEST(stringUtilLevenshteinDistance)
+{
+    // Identical strings have distance 0.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("length"), toSlice("length")) == 0);
+
+    // Either side empty: distance is the length of the other.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice(""), toSlice("abc")) == 3);
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("abc"), toSlice("")) == 3);
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice(""), toSlice("")) == 0);
+
+    // Single insertion / deletion.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("color"), toSlice("colour")) == 1);
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("colour"), toSlice("color")) == 1);
+    // Single substitution.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("cat"), toSlice("cot")) == 1);
+    // Two adjacent substitutions (`in` -> `di`).
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("instance"), toSlice("distance")) == 2);
+    // A transposition counts as two edits under plain Levenshtein.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("lenght"), toSlice("length")) == 2);
+
+    // Classic textbook example.
+    SLANG_CHECK(StringUtil::calcLevenshteinDistance(toSlice("kitten"), toSlice("sitting")) == 3);
+
+    // Symmetry.
+    SLANG_CHECK(
+        StringUtil::calcLevenshteinDistance(toSlice("abcdef"), toSlice("azced")) ==
+        StringUtil::calcLevenshteinDistance(toSlice("azced"), toSlice("abcdef")));
+}