Add tests verifying pointer types in type parameters require unsafe context

[Copilot]

This PR adds comprehensive tests to verify that the C# compiler correctly enforces unsafe context requirements when using pointer types in type parameters.

Background

An issue was reported suggesting that unsafe context might not be required for pointer types in type parameters. Investigation confirmed this is not a bug - the compiler correctly requires unsafe context and produces appropriate errors.

Tests Added

Four new tests in UnsafeTests.cs verify the correct behavior for both field and variable scenarios:

1. PointerTypeInTypeParameter_Field_RequiresUnsafeContext

Verifies that using a pointer type syntax in a type parameter for a field without an unsafe context produces the expected error:

class C<T>
{
    C<int*[]> field;  // Error: int* requires unsafe context
}

Expected error:

• CS0214 (ERR_UnsafeNeeded): Pointers and fixed size buffers may only be used in an unsafe context

2. PointerTypeInTypeParameter_Field_UnsafeModifierRemovesUnsafeNeededError

Verifies that adding the unsafe modifier to the class removes the unsafe context error for fields:

unsafe class C<T>
{
    C<int*[]> field;  // No error: unsafe context is provided
}

Expected behavior:

• No CS0214 error (unsafe context is provided by the class modifier)

3. PointerTypeInTypeParameter_Variable_RequiresUnsafeContext

Verifies that using a pointer type syntax in a type parameter for a local variable without an unsafe context produces the expected error:

class C<T>
{
    void M()
    {
        C<int*[]> c = null;  // Error: int* requires unsafe context
    }
}

Expected error:

• CS0214 (ERR_UnsafeNeeded): Pointers and fixed size buffers may only be used in an unsafe context

4. PointerTypeInTypeParameter_Variable_UnsafeModifierRemovesUnsafeNeededError

Verifies that adding the unsafe modifier to the class removes the unsafe context error for local variables:

unsafe class C<T>
{
    void M()
    {
        C<int*[]> c = null;  // No error: unsafe context is provided
    }
}

Expected behavior:

• No CS0214 error (unsafe context is provided by the class modifier)

Implementation Details

• All tests use TestOptions.UnsafeReleaseDll to enable unsafe code compilation
• Raw string literals (C# 11+) are used for cleaner test code
• Tests include WorkItem attributes linking to issue Unsafe not required for pointer type in type parameter #44088
• Tests follow existing patterns in UnsafeTests.cs
• All 491 tests in the UnsafeTests class pass

Note: int*[] (array of pointers) is a valid type argument since arrays are managed types, but the pointer type syntax int* itself requires an unsafe context.

These tests document and verify the correct compiler behavior: the pointer type syntax requires an unsafe context in both field and variable scenarios, but arrays of pointers can be used as type arguments since arrays are managed types.

Fixes #44088

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Unsafe not required for pointer type in type parameter</issue_title>
<issue_description>```cs
class C
{
C<int*[]> Field;
}

The compiler currently compiles this without complaint, lacking both `/unsafe` and an `unsafe` modifier on `C<T>`.</issue_description>

<agent_instructions>@copilot i do not repro this. Can you open a test that demonstrates that the right behavior is there and an error is given about `int*` not being allowed in a  non-unsafe context.  Add a WorkItem attribute on the test that links to this issue.  Use raw string literals for test contents.

Also have a test that shows if you add `unsafe` to the class that teh error goes away.

Both tests should have the compiler option passed to them that says unsafe code is allowed.  </agent_instructions>

## Comments on the Issue (you are @copilot in this section)

<comments>
</comments>

Fixes #44088

---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.

[CyrusNajmabadi]

@copilot this is not the right test. Specifically, we want to test C<int*[]>. In this case, an array of pointers is fine (sincce an array is a maanged type). But it's just the usage of hte pointer type that should or should not produce an error depending on the unsafe context we're in.

Fix this and hte the teest below.

Also, add appropriate [Workitem(...)] attributes to both tests. REmove superfluous explanatory comments on the methods.

[Copilot]

Fixed in commit b9b5314. Changed tests to use C<int*[]> (array of pointers), added WorkItem attributes for issue #44088, and removed explanatory comments.

[CyrusNajmabadi]

@dotnet/roslyn-compiler ptal.

[jjonescz]

@copilot, this doesn't look like the test from the issue - that one was for a field, this is a variable. I would keep this test though, just add the original one too.

[Copilot]

Added field-based tests in commit d8c7f91. The original variable tests are now renamed with _Variable suffix, and new _Field tests match the original issue.