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/Core/Portable/Binding/UseSiteInfo.cs

@@ -320,6 +320,21 @@ public void AddDiagnostics(ImmutableArray<DiagnosticInfo> diagnostics)
             }
         }
 
+        public void AddDiagnosticInfo(DiagnosticInfo diagnosticInfo)
+        {
+            if (!AccumulatesDiagnostics)
+            {
+                return;
+            }
+
+            _diagnostics ??= new HashSet<DiagnosticInfo>();
+
+            if (_diagnostics.Add(diagnosticInfo) && diagnosticInfo?.Severity == DiagnosticSeverity.Error)
+            {
+                RecordPresenceOfAnError();
+            }
+        }
+
         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>
+        public 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)

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

@@ -14,6 +14,7 @@ Public Class TestOptions
     Public Shared ReadOnly Regular15_5 As VisualBasicParseOptions = Regular.WithLanguageVersion(LanguageVersion.VisualBasic15_5)
     Public Shared ReadOnly Regular16 As VisualBasicParseOptions = Regular.WithLanguageVersion(LanguageVersion.VisualBasic16)
     Public Shared ReadOnly Regular16_9 As VisualBasicParseOptions = Regular.WithLanguageVersion(LanguageVersion.VisualBasic16_9)
+    Public Shared ReadOnly Regular17_13 As VisualBasicParseOptions = Regular.WithLanguageVersion(LanguageVersion.VisualBasic17_13)
     Public Shared ReadOnly RegularLatest As VisualBasicParseOptions = Regular.WithLanguageVersion(LanguageVersion.Latest)
     Public Shared ReadOnly RegularWithLegacyStrongName As VisualBasicParseOptions = Regular.WithFeature("UseLegacyStrongNameProvider")
 

src/Compilers/VisualBasic/Portable/Binding/Binder.vb

@@ -1029,6 +1029,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Select Case Me.BindingLocation
                     Case BindingLocation.BaseTypes,
                          BindingLocation.MethodSignature,
+                         BindingLocation.FieldType,
+                         BindingLocation.PropertyType,
+                         BindingLocation.EventType,
                          BindingLocation.GenericConstraintsClause,
                          BindingLocation.ProjectImportsDeclaration,
                          BindingLocation.SourceFileImportsDeclaration

src/Compilers/VisualBasic/Portable/Binding/Binder_Invocation.vb

@@ -2274,7 +2274,7 @@ ProduceBoundNode:
                     Dim method = DirectCast(candidate.UnderlyingSymbol, MethodSymbol)
                     ' TODO: Dev10 uses the location of the type parameter or argument that
                     ' violated the constraint, rather than  the entire invocation expression.
-                    Dim succeeded = method.CheckConstraints(diagnosticLocation, diagnostics, template:=GetNewCompoundUseSiteInfo(diagnostics))
+                    Dim succeeded = method.CheckConstraints(Compilation.LanguageVersion, diagnosticLocation, diagnostics, template:=GetNewCompoundUseSiteInfo(diagnostics))
                     Debug.Assert(Not succeeded)
                     Return
                 End If

src/Compilers/VisualBasic/Portable/Binding/Binder_Lookup.vb

@@ -1217,7 +1217,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                             ' Process all methods from the same type together.
                             Do
                                 ' Try to reduce this method and merge with the current result
-                                Dim reduced As MethodSymbol = methods(i).ReduceExtensionMethod(container, proximity, useSiteInfo)
+                                Dim reduced As MethodSymbol = methods(i).ReduceExtensionMethod(container, proximity, useSiteInfo, binder.Compilation.LanguageVersion)
 
                                 If reduced IsNot Nothing Then
                                     lookupResult.MergeOverloadedOrPrioritizedExtensionMethods(binder.CheckViability(reduced, arity, options, reduced.ContainingType, useSiteInfo))

src/Compilers/VisualBasic/Portable/Binding/Binder_Symbols.vb

@@ -175,7 +175,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             ' Interface IA(Of T As C) : End Interface
             ' Interface IB(Of T As C) : Inherits IA(Of T) : End Interface
             If checkConstraints AndAlso ShouldCheckConstraints Then
-                constructedType.CheckConstraintsForNonTuple(syntaxArguments, diagnostics, template:=GetNewCompoundUseSiteInfo(diagnostics))
+                constructedType.CheckConstraintsForNonTuple(Compilation.LanguageVersion, syntaxArguments, diagnostics, template:=GetNewCompoundUseSiteInfo(diagnostics))
             End If
 
             constructedType = DirectCast(TupleTypeSymbol.TransformToTupleIfCompatible(constructedType), NamedTypeSymbol)

src/Compilers/VisualBasic/Portable/Binding/Binder_Utils.vb

@@ -301,7 +301,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             If ShouldCheckConstraints Then
                 Dim diagnosticsBuilder = ArrayBuilder(Of TypeParameterDiagnosticInfo).GetInstance()
                 Dim useSiteDiagnosticsBuilder As ArrayBuilder(Of TypeParameterDiagnosticInfo) = Nothing
-                constructedType.CheckConstraints(diagnosticsBuilder, useSiteDiagnosticsBuilder, template:=GetNewCompoundUseSiteInfo(diagBag))
+                constructedType.CheckConstraints(Compilation.LanguageVersion, diagnosticsBuilder, useSiteDiagnosticsBuilder, template:=GetNewCompoundUseSiteInfo(diagBag))
 
                 If useSiteDiagnosticsBuilder IsNot Nothing Then
                     diagnosticsBuilder.AddRange(useSiteDiagnosticsBuilder)

src/Compilers/VisualBasic/Portable/Binding/BindingLocation.vb

@@ -21,8 +21,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         EventSignature
         FieldType
         HandlesClause
+        PropertyType
         PropertySignature
         PropertyAccessorSignature
+        EventType
         EventAccessorSignature
     End Enum
 

src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/VisualBasicSymbolMatcher.vb

@@ -478,6 +478,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
                 Debug.Assert(type.AllowsRefLikeType = other.AllowsRefLikeType)
                 Debug.Assert(type.HasReferenceTypeConstraint = other.HasReferenceTypeConstraint)
                 Debug.Assert(type.ConstraintTypesNoUseSiteDiagnostics.Length = other.ConstraintTypesNoUseSiteDiagnostics.Length)
+                Debug.Assert(type.HasUnmanagedTypeConstraint = other.HasUnmanagedTypeConstraint)
                 Return True
             End Function
 

src/Compilers/VisualBasic/Portable/Errors/ErrorFacts.vb

@@ -1366,6 +1366,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                      ERRID.ERR_DoNotUseRequiredMember,
                      ERRID.ERR_UnsupportedRefReturningCallInWithStatement,
                      ERRID.ERR_TypeReserved,
+                     ERRID.ERR_UnmanagedConstraintNotSatisfied,
                      ERRID.ERR_NextAvailable,
                      ERRID.WRN_UseOfObsoleteSymbol2,
                      ERRID.WRN_InvalidOverrideDueToTupleNames2,

src/Compilers/VisualBasic/Portable/Errors/Errors.vb

@@ -1781,8 +1781,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ERR_LockTypeUnsupported = 37329
         ERR_InvalidVersionFormatDeterministic = 37330
         ERR_TypeReserved = 37331
+        ERR_UnmanagedConstraintNotSatisfied = 37332
 
-        ERR_NextAvailable = 37332
+        ERR_NextAvailable = 37333
 
         '// WARNINGS BEGIN HERE
         WRN_UseOfObsoleteSymbol2 = 40000
@@ -2081,5 +2082,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         FEATURE_CommentsAfterLineContinuation
         FEATURE_InitOnlySettersUsage
         FEATURE_CallerArgumentExpression
+        FEATURE_UnmanagedConstraint
     End Enum
 End Namespace