src/Compilers/VisualBasic/Portable/Symbols/Symbol.vb - main - githubmirror/roslyn

src/Compilers/VisualBasic/Portable/Symbols/Symbol.vb
1 402 строки65 KB
Jan Jones
Unsafe evolution: fix name of ISymbol public API (#84784)
10 авг 2026, 21:28
10 авг 2026, 21:28e8346d2
' Licensed to the .NET Foundation under one or more agreements.
' The .NET Foundation licenses this file to you under the MIT license.
' See the LICENSE file in the project root for more information.

Imports System.Collections.Immutable
Imports System.Globalization
Imports System.Runtime.InteropServices
Imports System.Threading
Imports Microsoft.CodeAnalysis
Imports Microsoft.CodeAnalysis.Collections
Imports Microsoft.CodeAnalysis.PooledObjects
Imports Microsoft.CodeAnalysis.Symbols
Imports Microsoft.CodeAnalysis.Text
Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
Imports Display = Microsoft.CodeAnalysis.VisualBasic.SymbolDisplay

Namespace Microsoft.CodeAnalysis.VisualBasic

    ''' <summary>
    ''' The base class for all symbols (namespaces, classes, method, parameters, etc.) that are 
    ''' exposed by the compiler.
    ''' </summary>
    <DebuggerDisplay("{GetDebuggerDisplay(), nq}")>
    Friend MustInherit Class Symbol
        Implements ISymbol, ISymbolInternal, IFormattable

        ' !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        ' Changes to the public interface of this class should remain synchronized with the C# version of Symbol.
        ' Do not make any changes to the public interface without making the corresponding change
        ' to the C# version.
        ' !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        ''' <summary>
        ''' Gets the name of this symbol.
        ''' </summary>
        ''' <returns>Returns the name of this symbol. Symbols without a name return the empty string;
        ''' Nothing is never returned.</returns>
        Public Overridable ReadOnly Property Name As String
            Get
                Return String.Empty
            End Get
        End Property

        ''' <summary>
        ''' Gets the name of a symbol as it appears in metadata. Most of the time, this
        ''' is the same as the Name property, with the following exceptions:
        ''' 1) The metadata name of generic types includes the "`1", "`2" etc. suffix that
        ''' indicates the number of type parameters (it does not include, however, names of
        ''' containing types or namespaces).
        ''' 2) The metadata name of methods that overload or override methods with the same
        ''' case-insensitive name but different case-sensitive names are adjusted so that
        ''' the overrides and overloads always have the same name in a case-sensitive way.
        ''' 
        ''' It should be noted that Visual Basic merges namespace declaration from source
        ''' and/or metadata with different casing into a single namespace symbol. Thus, for
        ''' namespace symbols this property may return incorrect information if multiple declarations
        ''' with different casing were found.
        ''' </summary>
        Public Overridable ReadOnly Property MetadataName As String Implements ISymbol.MetadataName, ISymbolInternal.MetadataName
            Get
                Return Name
            End Get
        End Property

        ''' <summary>
        ''' Gets the token for this symbol as it appears in metadata. Most of the time this Is 0,
        ''' as it Is when the symbol Is Not loaded from metadata.
        ''' </summary>
        Public Overridable ReadOnly Property MetadataToken As Integer Implements ISymbol.MetadataToken, ISymbolInternal.MetadataToken
            Get
                Return 0
            End Get
        End Property

        Public ReadOnly Property MetadataVisibility As Microsoft.Cci.TypeMemberVisibility Implements ISymbolInternal.MetadataVisibility
            Get
                '
                ' We need to relax visibility of members in interactive submissions since they might be emitted into multiple assemblies.
                '
                ' Top-level:
                '   private                       -> public
                '   family                        -> public (compiles with a warning)
                '   public
                '   friend                        -> public
                '
                ' In a nested class:
                '
                '   private
                '   family
                '   public
                '   friend                        -> public
                '
                Select Case DeclaredAccessibility
                    Case Accessibility.Public
                        Return Microsoft.Cci.TypeMemberVisibility.Public

                    Case Accessibility.Private
                        If ContainingType.TypeKind = TypeKind.Submission Then
                            Return Microsoft.Cci.TypeMemberVisibility.Public
                        Else
                            Return Microsoft.Cci.TypeMemberVisibility.Private
                        End If

                    Case Accessibility.Friend
                        If ContainingAssembly.IsInteractive Then
                            Return Microsoft.Cci.TypeMemberVisibility.Public
                        Else
                            Return Microsoft.Cci.TypeMemberVisibility.Assembly
                        End If

                    Case Accessibility.Protected
                        If ContainingType.TypeKind = TypeKind.Submission Then
                            Return Microsoft.Cci.TypeMemberVisibility.Public
                        Else
                            Return Microsoft.Cci.TypeMemberVisibility.Family
                        End If

                    Case Accessibility.ProtectedAndFriend
                        Debug.Assert(ContainingType.TypeKind <> TypeKind.Submission)
                        Return Microsoft.Cci.TypeMemberVisibility.FamilyAndAssembly

                    Case Accessibility.ProtectedOrFriend
                        If ContainingAssembly.IsInteractive Then
                            Return Microsoft.Cci.TypeMemberVisibility.Public
                        Else
                            Return Microsoft.Cci.TypeMemberVisibility.FamilyOrAssembly
                        End If
                    Case Else
                        Throw ExceptionUtilities.UnexpectedValue(DeclaredAccessibility)
                End Select
            End Get
        End Property

        ''' <summary>
        ''' Set the metadata name for this symbol.
        ''' Called from <see cref="OverloadingHelper.SetMetadataNameForAllOverloads"/> for each symbol of the same name in a type.
        ''' </summary>
        Friend Overridable Sub SetMetadataName(metadataName As String)
            ' only user defined methods and properties can have their name changed
            Throw ExceptionUtilities.Unreachable
        End Sub

        ''' <summary>
        ''' Gets the kind of this symbol.
        ''' </summary>
        Public MustOverride ReadOnly Property Kind As SymbolKind

        ''' <summary>
        ''' Get the symbol that logically contains this symbol. 
        ''' </summary>
        Public MustOverride ReadOnly Property ContainingSymbol As Symbol

        ''' <summary>
        ''' Gets the nearest enclosing namespace for this namespace or type. For a nested type,
        ''' returns the namespace that contains its container.
        ''' </summary>
        Public ReadOnly Property ContainingNamespace As NamespaceSymbol
            Get
                Dim container = Me.ContainingSymbol
                While container IsNot Nothing
                    Dim ns = TryCast(container, NamespaceSymbol)
                    If ns IsNot Nothing Then
                        Return ns
                    End If
                    container = container.ContainingSymbol
                End While
                Return Nothing
            End Get
        End Property

        ''' <summary>
        ''' Returns the nearest lexically enclosing type, or Nothing if there is none.
        ''' </summary>
        Public Overridable ReadOnly Property ContainingType As NamedTypeSymbol
            Get
                Dim container As Symbol = Me.ContainingSymbol

                Dim containerAsType As NamedTypeSymbol = TryCast(container, NamedTypeSymbol)

                ' NOTE: container could be null, so we do not check 
                '       whether containerAsType is not null, but 
                '       instead check if it did not change after 
                '       the cast.
                If containerAsType Is container Then
                    ' this should be relatively uncommon
                    ' most symbols that may be contained in a type
                    ' know their containing type and can override ContainingType
                    ' with a more precise implementation
                    Return containerAsType
                End If

                ' this is recursive, but recursion should be very short 
                ' before we reach symbol that definitely knows its containing type.
                Return container.ContainingType
            End Get
        End Property

        ''' <summary>
        ''' Returns the containing type or namespace, if this symbol is immediately contained by it.
        ''' Otherwise returns Nothing.
        ''' </summary>
        Friend ReadOnly Property ContainingNamespaceOrType As NamespaceOrTypeSymbol
            Get
                Dim container = Me.ContainingSymbol

                If container IsNot Nothing Then
                    Select Case container.Kind
                        Case SymbolKind.Namespace
                            Return DirectCast(ContainingSymbol, NamespaceSymbol)
                        Case SymbolKind.NamedType
                            Return DirectCast(ContainingSymbol, NamedTypeSymbol)
                    End Select
                End If

                Return Nothing
            End Get
        End Property

        ''' <summary>
        ''' Returns the assembly containing this symbol. If this symbol is shared
        ''' across multiple assemblies, or doesn't belong to an assembly, returns Nothing.
        ''' </summary>
        Public Overridable ReadOnly Property ContainingAssembly As AssemblySymbol
            Get
                ' Default implementation gets the containers assembly.
                Dim container As Symbol = Me.ContainingSymbol
                If container IsNot Nothing Then
                    Return container.ContainingAssembly
                Else
                    Return Nothing
                End If
            End Get
        End Property

        ''' <summary>
        ''' For a source assembly, the associated compilation.
        ''' For any other assembly, null.
        ''' For a source module, the DeclaringCompilation of the associated source assembly.
        ''' For any other module, null.
        ''' For any other symbol, the DeclaringCompilation of the associated module.
        ''' </summary>
        ''' <remarks>
        ''' We're going through the containing module, rather than the containing assembly,
        ''' because of /addmodule (symbols in such modules should return null).
        ''' 
        ''' Remarks, not "ContainingCompilation" because it isn't transitive.
        ''' </remarks>
        Friend Overridable ReadOnly Property DeclaringCompilation As VisualBasicCompilation
            Get
                Select Case Me.Kind
                    Case SymbolKind.ErrorType
                        Return Nothing
                    Case SymbolKind.Assembly
                        Debug.Assert(Not (TypeOf Me Is SourceAssemblySymbol), "SourceAssemblySymbol must override DeclaringCompilation")
                        Return Nothing
                    Case SymbolKind.NetModule
                        Debug.Assert(Not (TypeOf Me Is SourceModuleSymbol), "SourceModuleSymbol must override DeclaringCompilation")
                        Return Nothing
                End Select

                Dim sourceModuleSymbol = TryCast(Me.ContainingModule, SourceModuleSymbol)
                Return If(sourceModuleSymbol Is Nothing, Nothing, sourceModuleSymbol.DeclaringCompilation)
            End Get
        End Property

        ReadOnly Property ISymbolInternal_DeclaringCompilation As Compilation Implements ISymbolInternal.DeclaringCompilation
            Get
                Return DeclaringCompilation
            End Get
        End Property

        ''' <summary>
        ''' Returns the module containing this symbol. If this symbol is shared
        ''' across multiple modules, or doesn't belong to a module, returns Nothing.
        ''' </summary>
        Public Overridable ReadOnly Property ContainingModule As ModuleSymbol
            Get
                ' Default implementation gets the containers module.

                Dim container As Symbol = Me.ContainingSymbol

                If (container IsNot Nothing) Then
                    Return container.ContainingModule
                Else
                    Return Nothing
                End If
            End Get
        End Property

        ''' <summary>
        ''' Get the original definition of this symbol. If this symbol is derived from another
        ''' symbol by (say) type substitution, this gets the original symbol, as it was defined
        ''' in source or metadata.
        ''' </summary>
        Public ReadOnly Property OriginalDefinition As Symbol
            Get
                Return OriginalSymbolDefinition
            End Get
        End Property

        Protected Overridable ReadOnly Property OriginalSymbolDefinition As Symbol
            Get
                ' Default implements returns Me.
                Return Me
            End Get
        End Property

        ''' <summary>
        ''' Returns true if this is the original definition of this symbol.
        ''' </summary>
        Public ReadOnly Property IsDefinition As Boolean
            Get
                ' TODO: Is "Is" or "Equals" correct here?
                Return OriginalDefinition Is Me
            End Get
        End Property

        ''' <summary>
        ''' <para>
        ''' Get a source location key for sorting. For performance, it's important that this
        ''' be able to be returned from a symbol without doing any additional allocations (even
        ''' if nothing is cached yet.)
        ''' </para>
        ''' <para>
        ''' Only (original) source symbols and namespaces that can be merged
        ''' need override this function if they want to do so for efficiency.
        ''' </para>
        ''' </summary>
        Friend Overridable Function GetLexicalSortKey() As LexicalSortKey
            Dim locations = Me.Locations
            Dim declaringCompilation = Me.DeclaringCompilation
            Debug.Assert(declaringCompilation IsNot Nothing) ' require that it is a source symbol
            Return If(locations.Length > 0, New LexicalSortKey(locations(0), declaringCompilation), LexicalSortKey.NotInSource)
        End Function

        ''' <summary>
        ''' Gets the locations where this symbol was originally defined, either in source
        ''' or metadata. Some symbols (for example, partial classes) may be defined in more
        ''' than one location.
        ''' </summary>
        Public MustOverride ReadOnly Property Locations As ImmutableArray(Of Location)

        Public Function GetFirstLocation() As Location Implements ISymbolInternal.GetFirstLocation
            Dim locations = Me.Locations
            If locations.Length = 0 Then
                Throw New InvalidOperationException("Symbol has no locations")
            End If

            Return locations(0)
        End Function

        Public Function GetFirstLocationOrNone() As Location Implements ISymbolInternal.GetFirstLocationOrNone
            Return If(Me.Locations.IsEmpty, Location.None, GetFirstLocation())
        End Function

        ''' <summary>
        ''' Get the syntax node(s) where this symbol was declared in source. Some symbols (for example,
        ''' partial classes) may be defined in more than one location. This property should return
        ''' one or more syntax nodes only if the symbol was declared in source code and also was
        ''' not implicitly declared (see the IsImplicitlyDeclared property). 
        ''' 
        ''' Note that for namespace symbol, the declaring syntax might be declaring a nested namespace.
        ''' For example, the declaring syntax node for N1 in "Namespace N1.N2" is the 
        ''' NamespaceDeclarationSyntax for N1.N2. For the project namespace, the declaring syntax will
        ''' be the CompilationUnitSyntax.
        ''' </summary>
        ''' <returns>
        ''' The syntax node(s) that declared the symbol. If the symbol was declared in metadata
        ''' or was implicitly declared, returns an empty read-only array.
        ''' </returns>
        ''' <remarks>
        ''' To go the opposite direction (from syntax node to symbol), see <see cref="VBSemanticModel.GetDeclaredSymbol"/>.
        ''' </remarks>
        Public MustOverride ReadOnly Property DeclaringSyntaxReferences As ImmutableArray(Of SyntaxReference)

        ''' <summary> 
        ''' Helper for implementing DeclaringSyntaxNodes for derived classes that store a location but not a  SyntaxNode or SyntaxReference. 
        ''' </summary>
        Friend Shared Function GetDeclaringSyntaxNodeHelper(Of TNode As VisualBasicSyntaxNode)(locations As ImmutableArray(Of Location)) As ImmutableArray(Of VisualBasicSyntaxNode)
            If locations.IsEmpty Then
                Return ImmutableArray(Of VisualBasicSyntaxNode).Empty
            Else
                Dim builder As ArrayBuilder(Of VisualBasicSyntaxNode) = ArrayBuilder(Of VisualBasicSyntaxNode).GetInstance()
                For Each location In locations
                    If location.IsInSource AndAlso location.SourceTree IsNot Nothing Then
                        Dim token = CType(location.SourceTree.GetRoot().FindToken(location.SourceSpan.Start), SyntaxToken)
                        If token.Kind <> SyntaxKind.None Then
                            Dim node As VisualBasicSyntaxNode = token.Parent.FirstAncestorOrSelf(Of TNode)()
                            If node IsNot Nothing Then
                                builder.Add(node)
                            End If
                        End If
                    End If
                Next

                Return builder.ToImmutableAndFree()
            End If
        End Function

        ''' <summary> 
        ''' Helper for implementing DeclaringSyntaxNodes for derived classes that store a location but not a  SyntaxNode or SyntaxReference. 
        ''' </summary>
        Friend Shared Function GetDeclaringSyntaxReferenceHelper(Of TNode As VisualBasicSyntaxNode)(locations As ImmutableArray(Of Location)) As ImmutableArray(Of SyntaxReference)
            Dim nodes = GetDeclaringSyntaxNodeHelper(Of TNode)(locations)

            If nodes.IsEmpty Then
                Return ImmutableArray(Of SyntaxReference).Empty
            Else
                Dim builder As ArrayBuilder(Of SyntaxReference) = ArrayBuilder(Of SyntaxReference).GetInstance()
                For Each node In nodes
                    builder.Add(node.GetReference())
                Next

                Return builder.ToImmutableAndFree()
            End If
        End Function

        ''' <summary> 
        ''' Helper for implementing DeclaringSyntaxNodes for derived classes that store SyntaxReferences. 
        ''' </summary>
        Friend Shared Function GetDeclaringSyntaxReferenceHelper(references As ImmutableArray(Of SyntaxReference)) As ImmutableArray(Of SyntaxReference)

            ' Optimize for the very common case of just one reference
            If references.Length = 1 Then
                Return GetDeclaringSyntaxReferenceHelper(references(0))
            End If

            Dim builder As ArrayBuilder(Of SyntaxReference) = ArrayBuilder(Of SyntaxReference).GetInstance()
            For Each reference In references
                Dim tree = reference.SyntaxTree
                If Not tree.IsEmbeddedOrMyTemplateTree() Then
                    builder.Add(New BeginOfBlockSyntaxReference(reference))
                End If
            Next

            Return builder.ToImmutableAndFree()
        End Function

        Friend Shared Function GetDeclaringSyntaxReferenceHelper(reference As SyntaxReference) As ImmutableArray(Of SyntaxReference)
            If reference IsNot Nothing Then
                Dim tree = reference.SyntaxTree
                If Not tree.IsEmbeddedOrMyTemplateTree() Then
                    Return ImmutableArray.Create(Of SyntaxReference)(New BeginOfBlockSyntaxReference(reference))
                End If
            End If

            Return ImmutableArray(Of SyntaxReference).Empty
        End Function

        ''' <summary>
        ''' Get this accessibility that was declared on this symbol. For symbols that do
        ''' not have accessibility declared on them, returns NotApplicable.
        ''' </summary>
        Public MustOverride ReadOnly Property DeclaredAccessibility As Accessibility

        ''' <summary>
        ''' Returns true if this symbol is "shared"; i.e., declared with the "Shared"
        ''' modifier or implicitly always shared.
        ''' </summary>
        Public MustOverride ReadOnly Property IsShared As Boolean

        ''' <summary>
        ''' Returns true if this member is overridable, has an implementation,
        ''' and does not override a base class member; i.e., declared with the "Overridable"
        ''' modifier. Does not return true for members declared as MustOverride or Overrides.
        ''' </summary>
        Public MustOverride ReadOnly Property IsOverridable As Boolean

        ''' <summary>
        ''' Returns true if this symbol was declared to override a base class members; i.e., declared
        ''' with the "Overrides" modifier. Still returns true if the members was declared
        ''' to override something, but (erroneously) no member to override exists.
        ''' </summary>
        Public MustOverride ReadOnly Property IsOverrides As Boolean

        ''' <summary>
        ''' Returns true if this symbol was declared as requiring an override; i.e., declared
        ''' with the "MustOverride" modifier. Never returns true for types. 
        ''' Also methods, properties and events declared in interface are considered to have MustOverride.
        ''' </summary>
        Public MustOverride ReadOnly Property IsMustOverride As Boolean

        ''' <summary>
        ''' Returns true if this symbol was declared to override a base class members and was
        ''' also restricted from further overriding; i.e., declared with the "NotOverridable"
        ''' modifier. Never returns true for types.
        ''' </summary>
        Public MustOverride ReadOnly Property IsNotOverridable As Boolean

        ''' <summary>
        ''' Returns true if this symbol was automatically created by the compiler, and does not
        ''' have an explicit corresponding source code declaration.  
        ''' </summary>
        ''' <remarks>
        ''' This is intended for symbols that are ordinary symbols in the language sense,
        ''' and may be used by code, but that are simply declared implicitly rather than
        ''' with explicit language syntax.
        ''' 
        ''' Examples include (this list is not exhaustive):
        '''   the default constructor for a class or struct that is created if one is not provided,
        '''   the BeginInvoke/Invoke/EndInvoke methods for a delegate,
        '''   the generated backing field for an auto property or a field-like event,
        '''   the "this" parameter for non-static methods,
        '''   the "value" parameter for a property setter,
        '''   the parameters on indexer accessor methods (not on the indexer itself),
        '''   methods in anonymous types
        ''' </remarks>
        Public Overridable ReadOnly Property IsImplicitlyDeclared As Boolean
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' True if this symbol has been marked with the Obsolete attribute. 
        ''' This property returns Unknown if the Obsolete Attribute hasn't been cracked yet.
        ''' </summary>
        Friend ReadOnly Property ObsoleteState As ThreeState
            Get
                Select Case ObsoleteKind
                    Case ObsoleteAttributeKind.None, ObsoleteAttributeKind.WindowsExperimental, ObsoleteAttributeKind.Experimental
                        Return ThreeState.False
                    Case ObsoleteAttributeKind.Uninitialized
                        Return ThreeState.Unknown
                    Case Else
                        Return ThreeState.True
                End Select
            End Get
        End Property

        ''' <summary>
        ''' True if this symbol has been marked with the Experimental attribute. 
        ''' This property returns Unknown if the Experimental attribute hasn't been cracked yet.
        ''' </summary>
        Friend ReadOnly Property ExperimentalState As ThreeState
            Get
                Select Case ObsoleteKind
                    Case ObsoleteAttributeKind.Experimental
                        Return ThreeState.True
                    Case ObsoleteAttributeKind.Uninitialized
                        Return ThreeState.Unknown
                    Case Else
                        Return ThreeState.False
                End Select
            End Get
        End Property

        Friend ReadOnly Property ObsoleteKind As ObsoleteAttributeKind
            Get
                Dim data = Me.ObsoleteAttributeData
                Return If(data Is Nothing, ObsoleteAttributeKind.None, data.Kind)
            End Get
        End Property

        ''' <summary>
        ''' Returns data decoded from Obsolete/Experimental attribute or null if there is no Obsolete/Experimental attribute.
        ''' This property returns ObsoleteAttributeData.Uninitialized if attribute arguments haven't been decoded yet.
        ''' </summary>
        Friend MustOverride ReadOnly Property ObsoleteAttributeData As ObsoleteAttributeData

        ''' <summary>
        ''' Returns the symbol that implicitly defined this symbol, or Nothing if this
        ''' symbol was declared explicitly. Examples of implicit symbols are property
        ''' accessors and the backing field for an automatically implemented property.
        ''' 
        ''' NOTE: there are scenarios in which ImplicitlyDefinedBy is called while bound members 
        '''       are not yet published. This typically happens if ImplicitlyDefinedBy while binding members.
        '''       In such case, if callee needs to refer to a member of enclosing type it must 
        '''       do that in the context of unpublished members that caller provides 
        '''       (asking encompassing type for members will cause infinite recursion).
        ''' 
        ''' NOTE: There could be several threads trying to bind and publish members, only one will succeed.
        '''       Reporting ImplicitlyDefinedBy within the set of members known to the caller guarantees
        '''       that if particular thread succeeds it will not have information that refers to something
        '''       built by another thread and discarded.
        ''' </summary>
        Friend Overridable ReadOnly Property ImplicitlyDefinedBy(Optional membersInProgress As Dictionary(Of String, ArrayBuilder(Of Symbol)) = Nothing) As Symbol
            Get
                Return Nothing
            End Get
        End Property

        ''' <summary> 
        ''' Returns true if 'Shadows' is explicitly specified on the declaration if the symbol is from
        ''' source, or in cases of synthesized symbols, if 'Shadows' is specified on the associated
        ''' source symbol. (For instance, ShadowsExplicitly will be set on the backing fields and
        ''' accessors for properties and events based on the value from the property or event.)
        ''' Returns false in all other cases, in particular, for symbols not from source.
        ''' </summary>
        Friend Overridable ReadOnly Property ShadowsExplicitly As Boolean
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' Returns true if this symbol can be referenced by its name in code. Examples of symbols
        ''' that cannot be referenced by name are:
        '''    constructors, operators, 
        '''    accessor methods for properties and events.
        ''' </summary>
        Public ReadOnly Property CanBeReferencedByName As Boolean
            Get
                Select Case Me.Kind
                    Case SymbolKind.Local
                        Return If(Me.Name?.Length, 0) > 0

                    Case SymbolKind.Label,
                         SymbolKind.Alias
                        ' Can't be imported, but might have syntax errors in which case we use an empty name:
                        Return Me.Name.Length > 0

                    Case SymbolKind.Namespace,
                         SymbolKind.Field,
                         SymbolKind.RangeVariable,
                         SymbolKind.Property,
                         SymbolKind.Event,
                         SymbolKind.Parameter,
                         SymbolKind.TypeParameter,
                         SymbolKind.ErrorType,
                         SymbolKind.Preprocessing
                        Exit Select

                    Case SymbolKind.NamedType
                        If DirectCast(Me, NamedTypeSymbol).IsSubmissionClass Then
                            Return False
                        End If
                        Exit Select

                    Case SymbolKind.Method
                        Select Case DirectCast(Me, MethodSymbol).MethodKind
                            Case MethodKind.Ordinary, MethodKind.DeclareMethod, MethodKind.ReducedExtension
                                Exit Select
                            Case MethodKind.DelegateInvoke, MethodKind.UserDefinedOperator, MethodKind.Conversion
                                Return True
                            Case Else
                                Return False
                        End Select

                    Case SymbolKind.Assembly, SymbolKind.NetModule, SymbolKind.ArrayType
                        Return False

                    Case Else
                        Throw ExceptionUtilities.UnexpectedValue(Me.Kind)
                End Select

                ' If we are from source, only need to check the first character, because all special
                ' names we create in source have a bad first character.
                ' NOTE: usually, the distinction we want to make is between the "current" compilation and another
                ' compilation, rather than between source and non-source.  In this case, however, it suffices
                ' to know that the symbol came from any compilation because we are just optimizing based on whether
                ' or not previous validation occurred.
                If Me.Dangerous_IsFromSomeCompilationIncludingRetargeting Then
                    Return Not String.IsNullOrEmpty(Me.Name) AndAlso SyntaxFacts.IsIdentifierStartCharacter(Me.Name(0))
                Else
                    Return SyntaxFacts.IsValidIdentifier(Me.Name)
                End If
            End Get
        End Property

        ''' <summary>
        ''' As an optimization, viability checking in the lookup code should use this property instead
        ''' of CanBeReferencedByName.
        ''' </summary>
        ''' <remarks>
        ''' This property exists purely for performance reasons.
        ''' </remarks>
        Friend ReadOnly Property CanBeReferencedByNameIgnoringIllegalCharacters As Boolean
            Get
                If Me.Kind = SymbolKind.Method Then
                    Select Case (DirectCast(Me, MethodSymbol)).MethodKind
                        Case MethodKind.Ordinary, MethodKind.DeclareMethod, MethodKind.ReducedExtension, MethodKind.DelegateInvoke, MethodKind.UserDefinedOperator, MethodKind.Conversion
                            Return True
                        Case Else
                            Return False
                    End Select
                End If
                Return True
            End Get
        End Property

        ''' <summary>
        ''' Is this a symbol that is generated by the compiler and
        ''' automatically added to the compilation? Note that
        ''' only source symbols may be embedded symbols. 
        ''' 
        ''' Namespace symbol is considered to be an embedded symbol
        ''' if at least one of its declarations are embedded symbols.
        ''' </summary>
        Friend ReadOnly Property IsEmbedded As Boolean
            Get
                Return EmbeddedSymbolKind <> VisualBasic.Symbols.EmbeddedSymbolKind.None
            End Get
        End Property

        Friend Overridable ReadOnly Property EmbeddedSymbolKind As EmbeddedSymbolKind
            Get
                Return EmbeddedSymbolKind.None
            End Get
        End Property

        ''' <summary>
        ''' <see cref="CharSet"/> effective for this symbol (type or DllImport method).
        ''' Nothing if <see cref="DefaultCharSetAttribute"/> isn't applied on the containing module or it doesn't apply on this symbol.
        ''' </summary>
        ''' <remarks>
        ''' Determined based upon value specified via <see cref="DefaultCharSetAttribute"/> applied on the containing module.
        ''' Symbols that are embedded are not affected by <see cref="DefaultCharSetAttribute"/> (see DevDiv bug #16434).
        ''' </remarks>
        Friend ReadOnly Property EffectiveDefaultMarshallingCharSet As CharSet?
            Get
                Return If(IsEmbedded, Nothing, Me.ContainingModule.DefaultMarshallingCharSet)
            End Get
        End Property

        Friend Function IsFromCompilation(compilation As VisualBasicCompilation) As Boolean
            Debug.Assert(compilation IsNot Nothing)
            Return compilation Is Me.DeclaringCompilation
        End Function

        ''' <summary>
        ''' Always prefer IsFromCompilation.
        ''' </summary>
        ''' <remarks>
        ''' This property is actually a triple workaround:
        ''' 
        ''' 1) Unfortunately, when determining overriding/hiding/implementation relationships, we don't
        '''    have the "current" compilation available.  We could, but that would clutter up the API
        '''    without providing much benefit.  As a compromise, we consider all compilations "current".
        ''' 
        ''' 2) TypeSymbol.Interfaces doesn't roundtrip in the presence of implicit interface implementation.
        '''    In particular, the metadata symbol may declare fewer interfaces than the source symbol so
        '''    that runtime implicit interface implementation will find the right symbol.  Thus, we need to
        '''    know what kind of symbol we are dealing with to be able to interpret the Interfaces property
        '''    properly.  Since a retargeting TypeSymbol will reflect the behavior of the underlying source
        '''    TypeSymbol, we need this property to match as well.  (C# does not have this problem.)
        ''' 
        ''' 3) The Dev12 VB compiler avoided loading private fields of structs from metadata, even though
        '''    they're supposed to affect definite assignment analysis.  For compatibility
        '''    we therefore ignore these fields when doing DA analysis.  (C# has a similar issue.)
        ''' </remarks>
        Friend ReadOnly Property Dangerous_IsFromSomeCompilationIncludingRetargeting As Boolean
            Get
                If Me.DeclaringCompilation IsNot Nothing Then
                    Return True
                End If

                If Me.Kind = SymbolKind.Assembly Then
                    Dim retargetingAssembly = TryCast(Me, Retargeting.RetargetingAssemblySymbol)
                    Return retargetingAssembly IsNot Nothing AndAlso retargetingAssembly.UnderlyingAssembly.DeclaringCompilation IsNot Nothing
                End If

                Dim [module] = If(Me.Kind = SymbolKind.NetModule, Me, Me.ContainingModule)
                Dim retargetingModule = TryCast([module], Retargeting.RetargetingModuleSymbol)
                Return retargetingModule IsNot Nothing AndAlso retargetingModule.UnderlyingModule.DeclaringCompilation IsNot Nothing
            End Get
        End Property

        ''' <summary>
        ''' Equivalent to MethodKind = MethodKind.LambdaMethod, but can be called on a symbol directly.
        ''' </summary>
        Friend Overridable ReadOnly Property IsLambdaMethod As Boolean
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' Is this an auto-generated property of a group class?
        ''' </summary>
        Friend Overridable ReadOnly Property IsMyGroupCollectionProperty As Boolean
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' Is this lambda method a query lambda? 
        ''' If it is, IsLambdaMethod == True as well.
        ''' </summary>
        Friend Overridable ReadOnly Property IsQueryLambdaMethod As Boolean
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' Returns the Documentation Comment ID for the symbol, or Nothing if the symbol
        ''' doesn't support documentation comments.
        ''' </summary>
        Public Overridable Function GetDocumentationCommentId() As String Implements ISymbol.GetDocumentationCommentId
            Dim pool = PooledStringBuilder.GetInstance()
            DocumentationCommentIdVisitor.Instance.Visit(Me, pool.Builder)

            Dim result = pool.ToStringAndFree()
            Return If(result.Length = 0, Nothing, result)
        End Function

        ''' <summary>
        ''' Fetches the documentation comment for this element with a cancellation token.
        ''' </summary>
        ''' <param name="preferredCulture">Optionally, retrieve the comments formatted for a particular culture. No impact on source documentation comments.</param>
        ''' <param name="expandIncludes">Optionally, expand <![CDATA[<include>]]> elements. No impact on non-source documentation comments.</param>
        ''' <param name="cancellationToken">Optionally, allow cancellation of documentation comment retrieval.</param>
        ''' <returns>The XML that would be written to the documentation file for the symbol.</returns>
        Public Overridable Function GetDocumentationCommentXml(Optional preferredCulture As CultureInfo = Nothing, Optional expandIncludes As Boolean = False, Optional cancellationToken As CancellationToken = Nothing) As String Implements ISymbol.GetDocumentationCommentXml
            Return ""
        End Function

        ''' <summary>
        ''' Compare two symbol objects to see if they refer to the same symbol. You should always use
        ''' = and &lt;&gt; or the Equals method, to compare two symbols for equality.
        ''' </summary>
        Public Shared Operator =(left As Symbol, right As Symbol) As Boolean
            'PERF: this Function() Is often called with
            '      1) left referencing same object as the right 
            '      2) right being null
            '      The code attempts to check for these conditions before 
            '      resorting to .Equals

            If (right Is Nothing) Then
                Return left Is Nothing
            End If

            Return left Is right OrElse right.Equals(left)
        End Operator

        ''' <summary>
        ''' Compare two symbol objects to see if they refer to the same symbol. You should always use
        ''' = and &lt;&gt;, or the Equals method, to compare two symbols for equality.
        ''' </summary>
        Public Shared Operator <>(left As Symbol, right As Symbol) As Boolean
            'PERF: this Function() Is often called with
            '      1) left referencing same object as the right 
            '      2) right being null
            '      The code attempts to check for these conditions before 
            '      resorting to .Equals

            If (right Is Nothing) Then
                Return left IsNot Nothing
            End If

            Return left IsNot right AndAlso Not right.Equals(left)
        End Operator

        ' By default, we do reference equality. This can be overridden.
        Public Overrides Function [Equals](obj As Object) As Boolean
            Return Me Is obj
        End Function

        Private Overloads Function IEquatable_Equals(other As ISymbol) As Boolean Implements IEquatable(Of ISymbol).Equals
            Return Me.[Equals](TryCast(other, Symbol), SymbolEqualityComparer.Default.CompareKind)
        End Function

        Private Overloads Function ISymbol_Equals(other As ISymbol, equalityComparer As SymbolEqualityComparer) As Boolean Implements ISymbol.Equals
            Return Me.[Equals](TryCast(other, Symbol), equalityComparer.CompareKind)
        End Function

        Private Overloads Function ISymbolInternal_Equals(other As ISymbolInternal, compareKind As TypeCompareKind) As Boolean Implements ISymbolInternal.Equals
            Return Me.Equals(TryCast(other, Symbol), compareKind)
        End Function

        ' By default we don't consider the compareKind. This can be overridden.
        Public Overridable Overloads Function Equals(other As Symbol, compareKind As TypeCompareKind) As Boolean
            Return Me.Equals(other)
        End Function

        ' By default, we do reference equality. This can be overridden.
        Public Overrides Function GetHashCode() As Integer
            Return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(Me)
        End Function

        Public NotOverridable Overrides Function ToString() As String
            Return ToDisplayString(SymbolDisplayFormat.VisualBasicErrorMessageFormat)
        End Function

        Public Function ToDisplayString(Optional format As SymbolDisplayFormat = Nothing) As String
            Return Display.ToDisplayString(Me, format)
        End Function

        Public Function ToDisplayParts(Optional format As SymbolDisplayFormat = Nothing) As ImmutableArray(Of SymbolDisplayPart)
            Return Display.ToDisplayParts(Me, format)
        End Function

        Public Function ToMinimalDisplayString(semanticModel As SemanticModel, position As Integer, Optional format As SymbolDisplayFormat = Nothing) As String
            Return Display.ToMinimalDisplayString(Me, semanticModel, position, format)
        End Function

        Public Function ToMinimalDisplayParts(semanticModel As SemanticModel, position As Integer, Optional format As SymbolDisplayFormat = Nothing) As ImmutableArray(Of SymbolDisplayPart)
            Return Display.ToMinimalDisplayParts(Me, semanticModel, position, format)
        End Function

        Private Function GetDebuggerDisplay() As String
            Return String.Format("{0} {1}", Me.Kind, Me.ToDisplayString(SymbolDisplayFormat.TestFormat))
        End Function

        ' ---- End of Public Definition ---
        ' Below here can be Friend members that are useful to the compiler, but we don't
        ' want to expose publicly. However, using a class derived from SymbolVisitor can be
        ' a way to add the equivalent of a virtual method, but without having to put it directly
        ' in the Symbol class.
        ' ---- End of Public Definition ---

        Friend MustOverride Function Accept(Of TArgument, TResult)(visitor As VisualBasicSymbolVisitor(Of TArgument, TResult), arg As TArgument) As TResult

        ' Prevent anyone else from deriving from this class.
        Friend Sub New()
        End Sub

        ' Returns true if some or all of the symbol is defined in the given source tree.
        Friend Overridable Function IsDefinedInSourceTree(tree As SyntaxTree, definedWithinSpan As TextSpan?, Optional cancellationToken As CancellationToken = Nothing) As Boolean Implements ISymbolInternal.IsDefinedInSourceTree
            Dim declaringReferences = Me.DeclaringSyntaxReferences
            If Me.IsImplicitlyDeclared AndAlso declaringReferences.Length = 0 Then
                Return Me.ContainingSymbol.IsDefinedInSourceTree(tree, definedWithinSpan, cancellationToken)
            End If

            ' Default implementation: go through all locations and check for the definition.
            ' This is overridden for certain special cases (e.g., the implicit default constructor).
            For Each syntaxRef In declaringReferences
                cancellationToken.ThrowIfCancellationRequested()

                If syntaxRef.SyntaxTree Is tree AndAlso
                    (Not definedWithinSpan.HasValue OrElse syntaxRef.Span.IntersectsWith(definedWithinSpan.Value)) Then
                    Return True
                End If
            Next

            Return False
        End Function

        Friend Shared Function IsDefinedInSourceTree(syntaxNode As SyntaxNode, tree As SyntaxTree, definedWithinSpan As TextSpan?, Optional cancellationToken As CancellationToken = Nothing) As Boolean
            Return syntaxNode IsNot Nothing AndAlso
                syntaxNode.SyntaxTree Is tree AndAlso
                (Not definedWithinSpan.HasValue OrElse definedWithinSpan.Value.IntersectsWith(syntaxNode.FullSpan))
        End Function

        ''' <summary>
        ''' Force all declaration diagnostics to be generated for the symbol.
        ''' </summary>
        Friend Overridable Sub GenerateDeclarationErrors(cancellationToken As CancellationToken)
        End Sub

#Region "Use-Site Diagnostic"

        ''' <summary>
        ''' Returns dependencies and an error info for an error, if any, that should be reported at the use site of the symbol.
        ''' </summary>
        Friend Overridable Function GetUseSiteInfo() As UseSiteInfo(Of AssemblySymbol)
            Return Nothing
        End Function

        Friend ReadOnly Property PrimaryDependency As AssemblySymbol
            Get
                Dim dependency As AssemblySymbol = Me.ContainingAssembly
                If dependency IsNot Nothing AndAlso dependency.CorLibrary = dependency Then
                    Return Nothing
                End If

                Return dependency
            End Get
        End Property

        ''' <summary>
        ''' Indicates that this symbol uses metadata that cannot be supported by the language.
        ''' 
        ''' Examples include:
        '''    - Pointer types in VB
        '''    - ByRef return type
        '''    - Required custom modifiers
        '''    
        ''' This is distinguished from, for example, references to metadata symbols defined in assemblies that weren't referenced.
        ''' Symbols where this returns true can never be used successfully, and thus should never appear in any IDE feature.
        ''' 
        ''' This is set for metadata symbols, as follows:
        ''' Type - if a type is unsupported (e.g., a pointer type, etc.)
        ''' Method - parameter or return type is unsupported
        ''' Field - type is unsupported
        ''' Event - type is unsupported
        ''' Property - type is unsupported
        ''' Parameter - type is unsupported
        ''' </summary>
        Public Overridable ReadOnly Property HasUnsupportedMetadata As Boolean Implements ISymbol.HasUnsupportedMetadata
            Get
                Return False
            End Get
        End Property

        ''' <summary>
        ''' Derive dependencies and error info from a type symbol.
        ''' </summary>
        Friend Function DeriveUseSiteInfoFromType(type As TypeSymbol) As UseSiteInfo(Of AssemblySymbol)
            Dim useSiteInfo As UseSiteInfo(Of AssemblySymbol) = type.GetUseSiteInfo()

            If useSiteInfo.DiagnosticInfo IsNot Nothing Then
                Select Case useSiteInfo.DiagnosticInfo.Code
                    Case ERRID.ERR_UnsupportedType1

                        GetSymbolSpecificUnsupportedMetadataUseSiteErrorInfo(useSiteInfo)

                    Case Else
                        ' Nothing to do, simply use the same error info.
                End Select
            End If

            Return useSiteInfo
        End Function

        Private Sub GetSymbolSpecificUnsupportedMetadataUseSiteErrorInfo(ByRef useSiteInfo As UseSiteInfo(Of AssemblySymbol))
            Select Case Me.Kind
                Case SymbolKind.Field
                    useSiteInfo = New UseSiteInfo(Of AssemblySymbol)(ErrorFactory.ErrorInfo(ERRID.ERR_UnsupportedField1, CustomSymbolDisplayFormatter.ShortErrorName(Me)))

                Case SymbolKind.Method
                    useSiteInfo = New UseSiteInfo(Of AssemblySymbol)(ErrorFactory.ErrorInfo(ERRID.ERR_UnsupportedMethod1, CustomSymbolDisplayFormatter.ShortErrorName(Me)))

                Case SymbolKind.Property
                    useSiteInfo = New UseSiteInfo(Of AssemblySymbol)(ErrorFactory.ErrorInfo(ERRID.ERR_UnsupportedProperty1, CustomSymbolDisplayFormatter.ShortErrorName(Me)))
            End Select
        End Sub

        ''' <summary>
        ''' Returns true if the error code is highest priority while calculating use site error for this symbol. 
        ''' </summary>
        Protected Overridable Function IsHighestPriorityUseSiteError(code As Integer) As Boolean ' Supposed to be ERRID, but it causes inconsistent accessibility error.
            Return False
        End Function

        Friend Function MergeUseSiteInfo(ByRef result As UseSiteInfo(Of AssemblySymbol), other As UseSiteInfo(Of AssemblySymbol)) As Boolean
            If other.DiagnosticInfo IsNot Nothing AndAlso IsHighestPriorityUseSiteError(other.DiagnosticInfo.Code) Then
                result = other
                Return True
            End If

            If result.DiagnosticInfo Is Nothing Then
                If other.DiagnosticInfo IsNot Nothing Then
                    result = other
                Else
                    Dim primaryDependency = result.PrimaryDependency
                    Dim secondaryDependency = result.SecondaryDependencies

                    other.MergeDependencies(primaryDependency, secondaryDependency)
                    result = New UseSiteInfo(Of AssemblySymbol)(diagnosticInfo:=Nothing, primaryDependency, secondaryDependency)
                End If

                Return False
            Else
                Return IsHighestPriorityUseSiteError(result.DiagnosticInfo.Code)
            End If
        End Function

        Friend Function DeriveUseSiteInfoFromParameter(param As ParameterSymbol) As UseSiteInfo(Of AssemblySymbol)
            Dim useSiteInfo As UseSiteInfo(Of AssemblySymbol) = DeriveUseSiteInfoFromType(param.Type)

            If useSiteInfo.DiagnosticInfo IsNot Nothing AndAlso IsHighestPriorityUseSiteError(useSiteInfo.DiagnosticInfo.Code) Then
                Return useSiteInfo
            End If

            Dim refModifiersUseSiteInfo As UseSiteInfo(Of AssemblySymbol) = DeriveUseSiteInfoFromCustomModifiers(param.RefCustomModifiers)

            If refModifiersUseSiteInfo.DiagnosticInfo IsNot Nothing AndAlso IsHighestPriorityUseSiteError(refModifiersUseSiteInfo.DiagnosticInfo.Code) Then
                Return refModifiersUseSiteInfo
            End If

            Dim modifiersUseSiteInfo As UseSiteInfo(Of AssemblySymbol) = DeriveUseSiteInfoFromCustomModifiers(param.CustomModifiers)

            If modifiersUseSiteInfo.DiagnosticInfo IsNot Nothing AndAlso IsHighestPriorityUseSiteError(modifiersUseSiteInfo.DiagnosticInfo.Code) Then
                Return modifiersUseSiteInfo
            End If

            Dim errorInfo = If(useSiteInfo.DiagnosticInfo, If(refModifiersUseSiteInfo.DiagnosticInfo, modifiersUseSiteInfo.DiagnosticInfo))

            If errorInfo IsNot Nothing Then
                Return New UseSiteInfo(Of AssemblySymbol)(errorInfo)
            End If

            Dim primaryDependency = useSiteInfo.PrimaryDependency
            Dim secondaryDependency = useSiteInfo.SecondaryDependencies

            refModifiersUseSiteInfo.MergeDependencies(primaryDependency, secondaryDependency)
            modifiersUseSiteInfo.MergeDependencies(primaryDependency, secondaryDependency)

            Return New UseSiteInfo(Of AssemblySymbol)(diagnosticInfo:=Nothing, primaryDependency, secondaryDependency)
        End Function

        Friend Function DeriveUseSiteInfoFromParameters(parameters As ImmutableArray(Of ParameterSymbol)) As UseSiteInfo(Of AssemblySymbol)
            Dim paramsUseSiteInfo As UseSiteInfo(Of AssemblySymbol) = Nothing

            For Each param As ParameterSymbol In parameters
                If MergeUseSiteInfo(paramsUseSiteInfo, DeriveUseSiteInfoFromParameter(param)) Then
                    Exit For
                End If
            Next

            Return paramsUseSiteInfo
        End Function

        Friend Function DeriveUseSiteInfoFromCustomModifiers(
            customModifiers As ImmutableArray(Of CustomModifier),
            Optional allowIsExternalInit As Boolean = False
        ) As UseSiteInfo(Of AssemblySymbol)
            Dim modifiersUseSiteInfo As UseSiteInfo(Of AssemblySymbol) = Nothing

            For Each modifier As CustomModifier In customModifiers
                Dim useSiteInfo As UseSiteInfo(Of AssemblySymbol)

                If Not modifier.IsOptional AndAlso
                   (Not allowIsExternalInit OrElse Not DirectCast(modifier, VisualBasicCustomModifier).ModifierSymbol.IsWellKnownTypeIsExternalInit()) Then

                    useSiteInfo = New UseSiteInfo(Of AssemblySymbol)(ErrorFactory.ErrorInfo(ERRID.ERR_UnsupportedType1, String.Empty))
                    GetSymbolSpecificUnsupportedMetadataUseSiteErrorInfo(useSiteInfo)

                    If MergeUseSiteInfo(modifiersUseSiteInfo, useSiteInfo) Then
                        Exit For
                    End If
                End If

                useSiteInfo = DeriveUseSiteInfoFromType(DirectCast(modifier, VisualBasicCustomModifier).ModifierSymbol)

                If MergeUseSiteInfo(modifiersUseSiteInfo, useSiteInfo) Then
                    Exit For
                End If
            Next

            Return modifiersUseSiteInfo
        End Function

        Friend Overloads Shared Function GetUnificationUseSiteDiagnosticRecursive(Of T As TypeSymbol)(types As ImmutableArray(Of T), owner As Symbol, ByRef checkedTypes As HashSet(Of TypeSymbol)) As DiagnosticInfo
            For Each t In types
                Dim info = t.GetUnificationUseSiteDiagnosticRecursive(owner, checkedTypes)
                If info IsNot Nothing Then
                    Return info
                End If
            Next

            Return Nothing
        End Function

        Friend Overloads Shared Function GetUnificationUseSiteDiagnosticRecursive(modifiers As ImmutableArray(Of CustomModifier), owner As Symbol, ByRef checkedTypes As HashSet(Of TypeSymbol)) As DiagnosticInfo
            For Each modifier In modifiers
                Dim info = DirectCast(modifier.Modifier, TypeSymbol).GetUnificationUseSiteDiagnosticRecursive(owner, checkedTypes)
                If info IsNot Nothing Then
                    Return info
                End If
            Next

            Return Nothing
        End Function

        Friend Overloads Shared Function GetUnificationUseSiteDiagnosticRecursive(parameters As ImmutableArray(Of ParameterSymbol), owner As Symbol, ByRef checkedTypes As HashSet(Of TypeSymbol)) As DiagnosticInfo
            For Each parameter In parameters
                Dim info = If(parameter.Type.GetUnificationUseSiteDiagnosticRecursive(owner, checkedTypes),
                              If(GetUnificationUseSiteDiagnosticRecursive(parameter.RefCustomModifiers, owner, checkedTypes),
                                    GetUnificationUseSiteDiagnosticRecursive(parameter.CustomModifiers, owner, checkedTypes)))

                If info IsNot Nothing Then
                    Return info
                End If
            Next

            Return Nothing
        End Function

        Friend Overloads Shared Function GetUnificationUseSiteDiagnosticRecursive(typeParameters As ImmutableArray(Of TypeParameterSymbol), owner As Symbol, ByRef checkedTypes As HashSet(Of TypeSymbol)) As DiagnosticInfo
            For Each typeParameter In typeParameters
                Dim info = GetUnificationUseSiteDiagnosticRecursive(typeParameter.ConstraintTypesNoUseSiteDiagnostics, owner, checkedTypes)
                If info IsNot Nothing Then
                    Return info
                End If
            Next

            Return Nothing
        End Function

#End Region

#Region "ISymbol"

        Public MustOverride Sub Accept(visitor As SymbolVisitor) Implements ISymbol.Accept

        Public MustOverride Function Accept(Of TResult)(visitor As SymbolVisitor(Of TResult)) As TResult Implements ISymbol.Accept

        Public MustOverride Function Accept(Of TArgument, TResult)(visitor As SymbolVisitor(Of TArgument, TResult), argument As TArgument) As TResult Implements ISymbol.Accept

        Public MustOverride Sub Accept(visitor As VisualBasicSymbolVisitor)

        Public MustOverride Function Accept(Of TResult)(visitor As VisualBasicSymbolVisitor(Of TResult)) As TResult

        Private ReadOnly Property ISymbol_ContainingAssembly As IAssemblySymbol Implements ISymbol.ContainingAssembly
            Get
                Return Me.ContainingAssembly
            End Get
        End Property

        Private ReadOnly Property ISymbolInternal_ContainingAssembly As IAssemblySymbolInternal Implements ISymbolInternal.ContainingAssembly
            Get
                Return Me.ContainingAssembly
            End Get
        End Property

        Private ReadOnly Property ISymbol_ContainingModule As IModuleSymbol Implements ISymbol.ContainingModule
            Get
                Return Me.ContainingModule
            End Get
        End Property

        Private ReadOnly Property ISymbolInternal_ContainingModule As IModuleSymbolInternal Implements ISymbolInternal.ContainingModule
            Get
                Return Me.ContainingModule
            End Get
        End Property

        Private ReadOnly Property ISymbol_ContainingNamespace As INamespaceSymbol Implements ISymbol.ContainingNamespace
            Get
                Return Me.ContainingNamespace
            End Get
        End Property

        Private ReadOnly Property ISymbolInternal_ContainingNamespace As INamespaceSymbolInternal Implements ISymbolInternal.ContainingNamespace
            Get
                Return Me.ContainingNamespace
            End Get
        End Property

        Private ReadOnly Property ISymbol_ContainingSymbol As ISymbol Implements ISymbol.ContainingSymbol
            Get
                Return Me.ContainingSymbol
            End Get
        End Property

        Private ReadOnly Property ISymbolInternal_ContainingSymbol As ISymbolInternal Implements ISymbolInternal.ContainingSymbol
            Get
                Return Me.ContainingSymbol
            End Get
        End Property

        Private ReadOnly Property ISymbol_ContainingType As INamedTypeSymbol Implements ISymbol.ContainingType
            Get
                Return Me.ContainingType
            End Get
        End Property

        Private ReadOnly Property ISymbolInternal_ContainingType As INamedTypeSymbolInternal Implements ISymbolInternal.ContainingType
            Get
                Return Me.ContainingType
            End Get
        End Property

        Private ReadOnly Property ISymbol_DeclaredAccessibility As Accessibility Implements ISymbol.DeclaredAccessibility, ISymbolInternal.DeclaredAccessibility
            Get
                Return Me.DeclaredAccessibility
            End Get
        End Property

        Protected Overridable ReadOnly Property ISymbol_IsAbstract As Boolean Implements ISymbol.IsAbstract, ISymbolInternal.IsAbstract
            Get
                Return Me.IsMustOverride
            End Get
        End Property

        Private ReadOnly Property ISymbol_IsDefinition As Boolean Implements ISymbol.IsDefinition, ISymbolInternal.IsDefinition
            Get
                Return Me.IsDefinition
            End Get
        End Property

        Private ReadOnly Property ISymbol_IsOverride As Boolean Implements ISymbol.IsOverride, ISymbolInternal.IsOverride
            Get
                Return Me.IsOverrides
            End Get
        End Property

        Protected Overridable ReadOnly Property ISymbol_IsSealed As Boolean Implements ISymbol.IsSealed
            Get
                Return Me.IsNotOverridable
            End Get
        End Property

        Protected Overridable ReadOnly Property ISymbol_IsStatic As Boolean Implements ISymbol.IsStatic, ISymbolInternal.IsStatic
            Get
                Return Me.IsShared
            End Get
        End Property

        Private ReadOnly Property ISymbol_IsImplicitlyDeclared As Boolean Implements ISymbol.IsImplicitlyDeclared, ISymbolInternal.IsImplicitlyDeclared
            Get
                Return Me.IsImplicitlyDeclared
            End Get
        End Property

        Private ReadOnly Property ISymbol_IsVirtual As Boolean Implements ISymbol.IsVirtual, ISymbolInternal.IsVirtual
            Get
                Return Me.IsOverridable
            End Get
        End Property

        Private ReadOnly Property ISymbol_CanBeReferencedByName As Boolean Implements ISymbol.CanBeReferencedByName
            Get
                Return Me.CanBeReferencedByName
            End Get
        End Property

        Public ReadOnly Property Language As String Implements ISymbol.Language
            Get
                Return LanguageNames.VisualBasic
            End Get
        End Property

        Private ReadOnly Property ISymbol_Locations As ImmutableArray(Of Location) Implements ISymbol.Locations, ISymbolInternal.Locations
            Get
                Return Me.Locations
            End Get
        End Property

        Private ReadOnly Property ISymbol_DeclaringSyntaxReferences As ImmutableArray(Of SyntaxReference) Implements ISymbol.DeclaringSyntaxReferences
            Get
                Return Me.DeclaringSyntaxReferences
            End Get
        End Property

        Private ReadOnly Property ISymbol_Name As String Implements ISymbol.Name, ISymbolInternal.Name
            Get
                Return Me.Name
            End Get
        End Property

        Private ReadOnly Property ISymbol_OriginalDefinition As ISymbol Implements ISymbol.OriginalDefinition
            Get
                Return Me.OriginalDefinition
            End Get
        End Property

        Private ReadOnly Property ISymbol_Kind As SymbolKind Implements ISymbol.Kind, ISymbolInternal.Kind
            Get
                Return Me.Kind
            End Get
        End Property

        Private ReadOnly Property ISymbol_RequiresUnsafeContext As Boolean Implements ISymbol.RequiresUnsafeContext
            Get
                Return False
            End Get
        End Property

        Private Function ISymbol_ToDisplayString(Optional format As SymbolDisplayFormat = Nothing) As String Implements ISymbol.ToDisplayString
            Return Display.ToDisplayString(Me, format)
        End Function

        Private Function ISymbol_ToDisplayParts(Optional format As SymbolDisplayFormat = Nothing) As ImmutableArray(Of SymbolDisplayPart) Implements ISymbol.ToDisplayParts
            Return Display.ToDisplayParts(Me, format)
        End Function

        Private Function ISymbol_ToMinimalDisplayString(semanticModel As SemanticModel, position As Integer, Optional format As SymbolDisplayFormat = Nothing) As String Implements ISymbol.ToMinimalDisplayString
            Return Display.ToMinimalDisplayString(Me, semanticModel, position, format)
        End Function

        Private Function ISymbol_ToMinimalDisplayParts(semanticModel As SemanticModel, position As Integer, Optional format As SymbolDisplayFormat = Nothing) As ImmutableArray(Of SymbolDisplayPart) Implements ISymbol.ToMinimalDisplayParts
            Return Display.ToMinimalDisplayParts(Me, semanticModel, position, format)
        End Function

        Private ReadOnly Property ISymbol_IsExtern As Boolean Implements ISymbol.IsExtern, ISymbolInternal.IsExtern
            Get
                Return False
            End Get
        End Property

        Private Function ISymbol_GetAttributes() As ImmutableArray(Of AttributeData) Implements ISymbol.GetAttributes
            Return StaticCast(Of AttributeData).From(Me.GetAttributes())
        End Function

#End Region

        Protected Shared Function ConstructTypeArguments(ParamArray typeArguments() As ITypeSymbol) As ImmutableArray(Of TypeSymbol)
            Dim builder = ArrayBuilder(Of TypeSymbol).GetInstance(typeArguments.Length)
            For Each typeArg In typeArguments
                builder.Add(typeArg.EnsureVbSymbolOrNothing(Of TypeSymbol)(NameOf(typeArguments)))
            Next
            Return builder.ToImmutableAndFree()
        End Function

        Protected Shared Function ConstructTypeArguments(typeArguments As ImmutableArray(Of ITypeSymbol), typeArgumentNullableAnnotations As ImmutableArray(Of CodeAnalysis.NullableAnnotation)) As ImmutableArray(Of TypeSymbol)
            If typeArguments.IsDefault Then
                Throw New ArgumentException(NameOf(typeArguments))
            End If

            Dim n = typeArguments.Length
            If Not typeArgumentNullableAnnotations.IsDefault AndAlso typeArgumentNullableAnnotations.Length <> n Then
                Throw New ArgumentException(NameOf(typeArgumentNullableAnnotations))
            End If

            Return typeArguments.SelectAsArray(Function(typeArg) typeArg.EnsureVbSymbolOrNothing(Of TypeSymbol)(NameOf(typeArguments)))
        End Function

        Private Overloads Function IFormattable_ToString(format As String, formatProvider As IFormatProvider) As String Implements IFormattable.ToString
            Return ToString()
        End Function

        Private Function ISymbolInternal_GetISymbol() As ISymbol Implements ISymbolInternal.GetISymbol
            Return Me
        End Function

    End Class
End Namespace