VB: Recognize and check an unmanaged constraint

src/Compilers/CSharp/Portable/Symbols/BaseTypeAnalysis.cs

@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Symbols;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -122,7 +123,9 @@ private static void StructDependsClosure(NamedTypeSymbol type, HashSet<Symbol> p
         /// </summary>
         internal static ManagedKind GetManagedKind(NamedTypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
-            var (isManaged, hasGenerics) = IsManagedTypeHelper(type);
+            // The code below should be kept in sync with NamedTypeSymbol.GetManagedKind in VB
+
+            var (isManaged, hasGenerics) = INamedTypeSymbolInternal.Helpers.IsManagedTypeHelper(type);
             var definitelyManaged = isManaged == ThreeState.True;
             if (isManaged == ThreeState.Unknown)
             {
@@ -201,7 +204,7 @@ internal static ManagedKind GetManagedKind(NamedTypeSymbol type, ref CompoundUse
                         }
                         else
                         {
-                            var result = IsManagedTypeHelper(fieldNamedType);
+                            var result = INamedTypeSymbolInternal.Helpers.IsManagedTypeHelper(fieldNamedType);
                             hasGenerics = hasGenerics || result.hasGenerics;
                             // NOTE: don't use ManagedKind.get on a NamedTypeSymbol - that could lead
                             // to infinite recursion.
@@ -235,60 +238,5 @@ internal static ManagedKind GetManagedKind(NamedTypeSymbol type, ref CompoundUse
 
         internal static TypeSymbol NonPointerType(this FieldSymbol field) =>
             field.HasPointerType ? null : field.Type;
-
-        /// <summary>
-        /// Returns True or False if we can determine whether the type is managed
-        /// without looking at its fields and Unknown otherwise.
-        /// Also returns whether or not the given type is generic.
-        /// </summary>
-        private static (ThreeState isManaged, bool hasGenerics) IsManagedTypeHelper(NamedTypeSymbol type)
-        {
-            // To match dev10, we treat enums as their underlying types.
-            if (type.IsEnumType())
-            {
-                type = type.GetEnumUnderlyingType();
-            }
-
-            // Short-circuit common cases.
-            switch (type.SpecialType)
-            {
-                case SpecialType.System_Void:
-                case SpecialType.System_Boolean:
-                case SpecialType.System_Char:
-                case SpecialType.System_SByte:
-                case SpecialType.System_Byte:
-                case SpecialType.System_Int16:
-                case SpecialType.System_UInt16:
-                case SpecialType.System_Int32:
-                case SpecialType.System_UInt32:
-                case SpecialType.System_Int64:
-                case SpecialType.System_UInt64:
-                case SpecialType.System_Decimal:
-                case SpecialType.System_Single:
-                case SpecialType.System_Double:
-                case SpecialType.System_IntPtr:
-                case SpecialType.System_UIntPtr:
-                case SpecialType.System_ArgIterator:
-                case SpecialType.System_RuntimeArgumentHandle:
-                    return (ThreeState.False, false);
-                case SpecialType.System_TypedReference:
-                    return (ThreeState.True, false);
-                case SpecialType.None:
-                default:
-                    // CONSIDER: could provide cases for other common special types.
-                    break; // Proceed with additional checks.
-            }
-
-            bool hasGenerics = type.IsGenericType;
-            switch (type.TypeKind)
-            {
-                case TypeKind.Enum:
-                    return (ThreeState.False, hasGenerics);
-                case TypeKind.Struct:
-                    return (ThreeState.Unknown, hasGenerics);
-                default:
-                    return (ThreeState.True, hasGenerics);
-            }
-        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PETypeParameterSymbol.cs

@@ -230,7 +230,7 @@ private ImmutableArray<TypeWithAnnotations> GetDeclaredConstraintTypes(ConsList<
                 }
 
                 // - presence of unmanaged pattern has to be matched with `valuetype`
-                // - IsUnmanagedAttribute is allowed iff there is an unmanaged pattern
+                // - IsUnmanagedAttribute is allowed if there is an unmanaged pattern
                 if (hasUnmanagedModreqPattern && (_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0 ||
                     hasUnmanagedModreqPattern != peModule.HasIsUnmanagedAttribute(_handle))
                 {

src/Compilers/CSharp/Test/Emit2/Emit/UnmanagedTypeModifierTests.cs

@@ -282,6 +282,70 @@ public static void Main()
                 );
         }
 
+        [Fact]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/75681")]
+        public void LoadingUnmanagedTypeModifier_ModreqGeneric()
+        {
+            var ilSource = IsUnmanagedAttributeIL + @"
+.class public auto ansi beforefieldinit TestRef
+       extends [mscorlib]System.Object
+{
+  .method public hidebysig instance void
+          M1<valuetype .ctor (class [mscorlib]System.ValueType modreq(System.Runtime.InteropServices.UnmanagedType`1)) T>() cil managed
+  {
+    .param type T
+    .custom instance void System.Runtime.CompilerServices.IsUnmanagedAttribute::.ctor() = ( 01 00 00 00 )
+    // Code size       2 (0x2)
+    .maxstack  8
+    IL_0000:  nop
+    IL_0001:  ret
+  } // end of method TestRef::M1
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    // Code size       8 (0x8)
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
+    IL_0006:  nop
+    IL_0007:  ret
+  } // end of method TestRef::.ctor
+}
+
+.class public auto ansi beforefieldinit System.Runtime.InteropServices.UnmanagedType`1<T>
+    extends [mscorlib]System.Object
+{
+    .method public hidebysig specialname rtspecialname 
+        instance void .ctor () cil managed 
+    {
+        .maxstack 8
+
+        IL_0000: ldarg.0
+        IL_0001: call instance void [mscorlib]System.Object::.ctor()
+        IL_0006: ret
+    }
+}
+";
+
+            var reference = CompileIL(ilSource, prependDefaultHeader: false);
+
+            var code = @"
+public class Test
+{
+    public static void Main()
+    {
+        var obj = new TestRef();
+
+        obj.M1<int>();
+    }
+}";
+
+            CreateCompilation(code, references: new[] { reference }).VerifyDiagnostics(
+                // An error is expected here, see https://github.com/dotnet/roslyn/issues/75681
+                );
+        }
+
         [Fact]
         public void LoadingUnmanagedTypeModifier_AttributeWithoutModreq()
         {

src/Compilers/Core/Portable/Binding/UseSiteInfo.cs

@@ -270,14 +270,21 @@ public void AddDiagnostics(ICollection<DiagnosticInfo>? diagnostics)
 
                 foreach (var diagnosticInfo in diagnostics)
                 {
-                    if (_diagnostics.Add(diagnosticInfo) && diagnosticInfo?.Severity == DiagnosticSeverity.Error)
-                    {
-                        RecordPresenceOfAnError();
-                    }
+                    AccumulateDiagnosticInfoAndRecordPresenceOfAnError(diagnosticInfo);
                 }
             }
         }
 
+        private void AccumulateDiagnosticInfoAndRecordPresenceOfAnError(DiagnosticInfo diagnosticInfo)
+        {
+            Debug.Assert(_diagnostics is not null);
+
+            if (_diagnostics.Add(diagnosticInfo) && diagnosticInfo?.Severity == DiagnosticSeverity.Error)
+            {
+                RecordPresenceOfAnError();
+            }
+        }
+
         public void AddDiagnostics(IReadOnlyCollection<DiagnosticInfo>? diagnostics)
         {
             if (!AccumulatesDiagnostics)
@@ -291,10 +298,7 @@ public void AddDiagnostics(IReadOnlyCollection<DiagnosticInfo>? diagnostics)
 
                 foreach (var diagnosticInfo in diagnostics)
                 {
-                    if (_diagnostics.Add(diagnosticInfo) && diagnosticInfo?.Severity == DiagnosticSeverity.Error)
-                    {
-                        RecordPresenceOfAnError();
-                    }
+                    AccumulateDiagnosticInfoAndRecordPresenceOfAnError(diagnosticInfo);
                 }
             }
         }
@@ -312,14 +316,23 @@ public void AddDiagnostics(ImmutableArray<DiagnosticInfo> diagnostics)
 
                 foreach (var diagnosticInfo in diagnostics)
                 {
-                    if (_diagnostics.Add(diagnosticInfo) && diagnosticInfo?.Severity == DiagnosticSeverity.Error)
-                    {
-                        RecordPresenceOfAnError();
-                    }
+                    AccumulateDiagnosticInfoAndRecordPresenceOfAnError(diagnosticInfo);
                 }
             }
         }
 
+        public void AddDiagnosticInfo(DiagnosticInfo diagnosticInfo)
+        {
+            if (!AccumulatesDiagnostics)
+            {
+                return;
+            }
+
+            _diagnostics ??= new HashSet<DiagnosticInfo>();
+
+            AccumulateDiagnosticInfoAndRecordPresenceOfAnError(diagnosticInfo);
+        }
+
         public void AddDependencies(UseSiteInfo<TAssemblySymbol> info)
         {
             if (!_hasErrors && AccumulatesDependencies)

src/Compilers/Core/Portable/Symbols/INamedTypeSymbolInternal.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.Symbols
 {
@@ -16,5 +17,69 @@ internal interface INamedTypeSymbolInternal : ITypeSymbolInternal
 
         ImmutableArray<ISymbolInternal> GetMembers();
         ImmutableArray<ISymbolInternal> GetMembers(string name);
+
+        /// <summary>
+        /// True if this type or some containing type has type parameters.
+        /// </summary>
+        bool IsGenericType { get; }
+
+        internal static class Helpers
+        {
+            /// <summary>
+            /// Returns True or False if we can determine whether the type is managed
+            /// without looking at its fields and Unknown otherwise.
+            /// Also returns whether or not the given type is generic.
+            /// </summary>
+            public static (ThreeState isManaged, bool hasGenerics) IsManagedTypeHelper(INamedTypeSymbolInternal type)
+            {
+                // To match dev10, we treat enums as their underlying types.
+                if (type.TypeKind == TypeKind.Enum)
+                {
+                    Debug.Assert(type.EnumUnderlyingType is not null);
+                    type = type.EnumUnderlyingType;
+                }
+
+                // Short-circuit common cases.
+                switch (type.SpecialType)
+                {
+                    case SpecialType.System_Void:
+                    case SpecialType.System_Boolean:
+                    case SpecialType.System_Char:
+                    case SpecialType.System_SByte:
+                    case SpecialType.System_Byte:
+                    case SpecialType.System_Int16:
+                    case SpecialType.System_UInt16:
+                    case SpecialType.System_Int32:
+                    case SpecialType.System_UInt32:
+                    case SpecialType.System_Int64:
+                    case SpecialType.System_UInt64:
+                    case SpecialType.System_Decimal:
+                    case SpecialType.System_Single:
+                    case SpecialType.System_Double:
+                    case SpecialType.System_IntPtr:
+                    case SpecialType.System_UIntPtr:
+                    case SpecialType.System_ArgIterator:
+                    case SpecialType.System_RuntimeArgumentHandle:
+                        return (ThreeState.False, false);
+                    case SpecialType.System_TypedReference:
+                        return (ThreeState.True, false);
+                    case SpecialType.None:
+                    default:
+                        // CONSIDER: could provide cases for other common special types.
+                        break; // Proceed with additional checks.
+                }
+
+                bool hasGenerics = type.IsGenericType;
+                switch (type.TypeKind)
+                {
+                    case TypeKind.Enum:
+                        return (ThreeState.False, hasGenerics);
+                    case TypeKind.Struct:
+                        return (ThreeState.Unknown, hasGenerics);
+                    default:
+                        return (ThreeState.True, hasGenerics);
+                }
+            }
+        }
     }
 }

src/Compilers/Core/RebuildTest/BasicDeterministicKeyBuilderTests.cs

@@ -220,7 +220,7 @@ public void BasicPathMapWindows(string filePath, string workingDirectory, string
       ""specifiedLanguageVersion"": ""VisualBasic15"",
       ""preprocessorSymbols"": {
         ""TARGET"": ""exe"",
-        ""VBC_VER"": ""16.9""
+        ""VBC_VER"": ""17.13""
       }
     }
   }
@@ -360,7 +360,7 @@ public void FeatureFlag()
         ""specifiedLanguageVersion"": ""Default"",
         ""preprocessorSymbols"": {{
           ""TARGET"": ""library"",
-          ""VBC_VER"": ""16.9"",
+          ""VBC_VER"": ""17.13"",
           ""_MYTYPE"": ""Empty""
         }}
       }}
@@ -385,7 +385,7 @@ public void FeatureFlag()
           ""specifiedLanguageVersion"": ""Default"",
           ""preprocessorSymbols"": {{
             ""TARGET"": ""library"",
-            ""VBC_VER"": ""16.9"",
+            ""VBC_VER"": ""17.13"",
             ""_MYTYPE"": ""Empty""
           }}
         }}

src/Compilers/Test/Utilities/VisualBasic/BasicTestSource.vb

@@ -43,12 +43,17 @@ Public Structure BasicTestSource
 
         Dim source = TryCast(Value, String)
         If source IsNot Nothing Then
-            Return New SyntaxTree() {VisualBasicSyntaxTree.ParseText(SourceText.From(source, encoding:=Nothing, SourceHashAlgorithms.Default), parseOptions)}
+            Return New SyntaxTree() _
+            {
+                VisualBasicSyntaxTree.ParseText(
+                    SourceText.From(source, encoding:=Nothing, SourceHashAlgorithms.Default),
+                    If(parseOptions, TestOptions.RegularLatest))
+            }
         End If
 
         Dim sources = TryCast(Value, String())
         If sources IsNot Nothing Then
-            Return sources.Select(Function(s) VisualBasicSyntaxTree.ParseText(SourceText.From(s, encoding:=Nothing, SourceHashAlgorithms.Default), parseOptions)).ToArray()
+            Return sources.Select(Function(s) VisualBasicSyntaxTree.ParseText(SourceText.From(s, encoding:=Nothing, SourceHashAlgorithms.Default), If(parseOptions, TestOptions.RegularLatest))).ToArray()
         End If
 
         Dim tree = TryCast(Value, SyntaxTree)

src/Compilers/Test/Utilities/VisualBasic/CompilationTestUtils.vb

@@ -651,7 +651,7 @@ Friend Module CompilationUtils
         MarkupTestFile.GetSpans(codeWithMarker, codeWithoutMarker, spans)
 
         Dim text = SourceText.From(codeWithoutMarker, Encoding.UTF8)
-        Return (VisualBasicSyntaxTree.ParseText(text, parseOptions, If(programElement.@name, "")), spans)
+        Return (VisualBasicSyntaxTree.ParseText(text, If(parseOptions, TestOptions.RegularLatest), If(programElement.@name, "")), spans)
     End Function
 
     ' Find a node inside a tree.

src/Compilers/Test/Utilities/VisualBasic/Extensions.vb

@@ -344,12 +344,12 @@ Friend Module Extensions
 
     <Extension>
     Friend Function ReduceExtensionMethod(this As MethodSymbol, instanceType As TypeSymbol) As MethodSymbol
-        Return this.ReduceExtensionMethod(instanceType, CompoundUseSiteInfo(Of AssemblySymbol).Discarded)
+        Return this.ReduceExtensionMethod(instanceType, CompoundUseSiteInfo(Of AssemblySymbol).Discarded, LanguageVersion.Latest)
     End Function
 
     <Extension>
     Friend Function ReduceExtensionMethod(this As MethodSymbol, instanceType As TypeSymbol, proximity As Integer) As MethodSymbol
-        Return this.ReduceExtensionMethod(instanceType, proximity, CompoundUseSiteInfo(Of AssemblySymbol).Discarded)
+        Return this.ReduceExtensionMethod(instanceType, proximity, CompoundUseSiteInfo(Of AssemblySymbol).Discarded, LanguageVersion.Latest)
     End Function
 
     <Extension>

src/Compilers/Test/Utilities/VisualBasic/ParserTestUtilities.vb

@@ -110,7 +110,7 @@ Friend Module ParserTestUtilities
             encoding = Encoding.UTF8
         End If
 
-        Dim tree = VisualBasicSyntaxTree.ParseText(SourceText.From(source, encoding), options:=If(options, VisualBasicParseOptions.Default), path:=fileName)
+        Dim tree = VisualBasicSyntaxTree.ParseText(SourceText.From(source, encoding), options:=If(options, TestOptions.RegularLatest), path:=fileName)
         Dim root = tree.GetRoot()
         ' Verify FullText
         Assert.Equal(source, root.ToFullString)