Summary

This PR fixes an inaccurate error message that occurs when a user supplies type arguments to a type name that has both generic and non-generic versions.

Problem

When attempting to use a type with the wrong number of type arguments, if both a generic and non-generic version exist with the same name, the compiler incorrectly reports an error about the non-generic version instead of the generic one.

For example, consider this code:

class MyExpression { }
class MyExpression<T> { }

class Test
{
    void M()
    {
        MyExpression<int, string> x;  // Using 2 type arguments
    }
}

Before this fix, the compiler reported:

error CS0308: The non-generic type 'MyExpression' cannot be used with type arguments

This is confusing because:

• A generic version MyExpression<T> does exist
• The user is clearly trying to use it with type arguments
• The error message mentions the wrong type

After this fix, the compiler reports:

error CS0305: Using the generic type 'MyExpression<T>' requires 1 type arguments

This is much clearer because:

• It mentions the correct generic type
• It tells the user exactly how many type arguments are needed (1)
• The user can clearly see they provided 2 but only 1 is expected

Implementation

The fix modifies the lookup result merging logic in LookupResult.MergeEqual(SingleLookupResult) to add special handling for WrongArity results. When both a generic type (arity > 0) and a non-generic type (arity == 0) are found with wrong arity, the logic now prefers reporting the error about the generic type.

The implementation is minimal and surgical:

• Added a preferGenericOverNonGeneric static local function to determine which symbol to prefer
• Modified the MergeEqual method to use this logic when both results have LookupResultKind.WrongArity
• The logic prefers ANY generic type over non-generic types; it does not select the "closest match" by arity count

Testing

• Added 7 comprehensive test cases in BindingTests.cs covering:

  • Generic and non-generic types with wrong arity
  • Generic types only with wrong arity
  • Non-generic types only (preserves existing behavior)
  • Correct arity (no error)
  • Multiple generic types with different arities
  • Generic type used with no type arguments when both generic and non-generic exist (binds to non-generic successfully)
  • Generic type only used with no type arguments (reports arity error)

• Updated 1 existing test in BindingTests.cs that was validating the old behavior

• All existing arity-related tests pass (1,293 tests)

• No regressions found in semantic error tests

Fixes #24406

Fixes #24406

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.