typeresolution.vb

来自「大名鼎鼎的mono是.NET平台的跨平台（支持linux」· VB 代码 · 共 1,025 行 · 第 1/4 页

            Case BuiltInDataTypes.[SByte]
                Return 9
            Case BuiltInDataTypes.Short
                Return 10
            Case BuiltInDataTypes.Single
                Return 11
            Case BuiltInDataTypes.String
                Return 12
            Case BuiltInDataTypes.[UInteger]
                Return 13
            Case BuiltInDataTypes.[ULong]
                Return 14
            Case BuiltInDataTypes.[UShort]
                Return 15
            Case Else
                Throw New InternalException("")
        End Select
    End Function

    Shared Function KeywordToTypeCode(ByVal Keyword As KS) As TypeCode
        Select Case Keyword
            Case KS.Boolean
                Return TypeCode.Boolean
            Case KS.Byte
                Return TypeCode.Byte
            Case KS.Char
                Return TypeCode.Char
            Case KS.Date
                Return TypeCode.DateTime
            Case KS.Decimal
                Return TypeCode.Decimal
            Case KS.Double
                Return TypeCode.Double
            Case KS.Integer
                Return TypeCode.Int32
            Case KS.Long
                Return TypeCode.Int64
            Case KS.Object
                Return TypeCode.Object
            Case KS.Single
                Return TypeCode.Single
            Case KS.Short
                Return TypeCode.Int16
            Case KS.String
                Return TypeCode.String
            Case KS.SByte
                Return TypeCode.SByte
            Case KS.UShort
                Return TypeCode.UInt16
            Case KS.UInteger
                Return TypeCode.UInt32
            Case KS.ULong
                Return TypeCode.UInt64
            Case Else
                Throw New InternalException("")
        End Select
    End Function

    ''' <summary>
    ''' Returns the type of the specified keyword. Throws an internalexception if the keyword isn't a type.
    ''' </summary>
    ''' <param name="Keyword"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    ''' 
    Function KeywordToType(ByVal Keyword As KS) As Type
        Select Case Keyword
            Case KS.Boolean
                Return Compiler.TypeCache.System_Boolean
            Case KS.Byte
                Return Compiler.TypeCache.System_Byte
            Case KS.Char
                Return Compiler.TypeCache.System_Char
            Case KS.Date
                Return Compiler.TypeCache.System_DateTime
            Case KS.Decimal
                Return Compiler.TypeCache.System_Decimal
            Case KS.Double
                Return Compiler.TypeCache.System_Double
            Case KS.Integer
                Return Compiler.TypeCache.System_Int32
            Case KS.Long
                Return Compiler.TypeCache.System_Int64
            Case KS.Object
                Return Compiler.TypeCache.System_Object
            Case KS.Single
                Return Compiler.TypeCache.System_Single
            Case KS.Short
                Return Compiler.TypeCache.System_Int16
            Case KS.String
                Return Compiler.TypeCache.System_String
            Case KS.[SByte]
                Return Compiler.TypeCache.System_SByte
            Case KS.[UShort]
                Return Compiler.TypeCache.System_UInt16
            Case KS.[UInteger]
                Return Compiler.TypeCache.System_UInt32
            Case KS.[ULong]
                Return Compiler.TypeCache.System_UInt64
            Case Else
                'Throw New InternalException("Don't know if this can actually happen, though. KS = " & Keyword.ToString)
                Return Nothing
        End Select
    End Function

    Function TypeToKeyword(ByVal Type As Type) As KS
        If Helper.CompareType(Type, Compiler.TypeCache.System_Boolean) Then
            Return KS.Boolean
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Byte) Then
            Return KS.Byte
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Char) Then
            Return KS.Char
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_DateTime) Then
            Return KS.Date
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Decimal) Then
            Return KS.Decimal
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Double) Then
            Return KS.Double
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Int32) Then
            Return KS.Integer
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Int64) Then
            Return KS.Long
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Object) Then
            Return KS.Object
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Int16) Then
            Return KS.Short
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_Single) Then
            Return KS.Single
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_String) Then
            Return KS.String
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_SByte) Then
            Return KS.[SByte]
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_UInt16) Then
            Return KS.[UShort]
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_UInt32) Then
            Return KS.[UInteger]
        ElseIf Helper.CompareType(Type, Compiler.TypeCache.System_UInt64) Then
            Return KS.[ULong]
        Else
            Return KS.None
        End If
    End Function

    Function IsImplicitlyConvertible(ByVal Compiler As Compiler, ByVal FromType As TypeDescriptor, ByVal ToType As TypeDescriptor) As Boolean
        Return IsImplicitlyConvertible(Compiler, FromType.TypeInReflection, ToType.TypeInReflection)
    End Function

    Function IsImplicitlyConvertible(ByVal Compiler As Compiler, ByVal FromType As Type, ByVal ToType As Type) As Boolean
        Dim tpFrom, tpTo As TypeCode
        If Helper.CompareType(Compiler.TypeCache.Nothing, FromType) Then Return True
        If FromType.IsByRef Then FromType = FromType.GetElementType
        If ToType.IsByRef Then ToType = ToType.GetElementType
        tpFrom = Helper.GetTypeCode(Compiler, FromType)
        tpTo = Helper.GetTypeCode(Compiler, ToType)
        If tpTo = TypeCode.Object Then
            Return Helper.IsAssignable(Compiler, FromType, ToType) ' ToType.IsAssignableFrom(FromType)
        ElseIf Helper.IsEnum(Compiler, ToType) AndAlso Helper.IsEnum(Compiler, FromType) = False Then
            Return False
        ElseIf Helper.IsEnum(Compiler, ToType) AndAlso Helper.IsEnum(Compiler, FromType) Then
            Return Helper.CompareType(ToType, FromType)
        Else
            Dim result As Boolean
            result = Conversion(tpFrom, tpTo).Conversion = ConversionType.Implicit
            'Helper.Assert(result = ToType.IsAssignableFrom(FromType) )
            Return result
        End If
    End Function

    Function IsNumericType(ByVal Type As Type) As Boolean
        For Each t As Type In NumericTypes
            If Helper.CompareType(t, Type) Then Return True
        Next
    End Function

    Function IsIntegralType(ByVal Type As Type) As Boolean
        For Each t As Type In IntegralTypes
            If Helper.CompareType(t, Type) Then Return True
        Next
        Return False
    End Function

    Function IsIntegralType(ByVal Type As TypeCode) As Boolean
        For Each t As Type In IntegralTypes
            If Helper.GetTypeCode(Compiler, t) = Type Then Return True
        Next
        Return False
    End Function

    Function IsIntegralType(ByVal Type As BuiltInDataTypes) As Boolean
        Return IsIntegralType(BuiltInTypeToTypeCode(Type))
    End Function

    Function IsSignedIntegralType(ByVal Type As Type) As Boolean
        Return Helper.CompareType(Type, Compiler.TypeCache.System_SByte) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_Int16) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_Int32) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_Int64)
    End Function

    Function IsUnsignedIntegralType(ByVal Type As Type) As Boolean
        Return Helper.CompareType(Type, Compiler.TypeCache.System_Byte) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_UInt16) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_UInt32) OrElse _
         Helper.CompareType(Type, Compiler.TypeCache.System_UInt64)
    End Function

    ''' <summary>
    ''' If the type is an enum type returns the base (integral type),
    ''' otherwise returns the same type.
    ''' </summary>
    ''' <param name="tp"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Function GetIntegralType(ByVal tp As Type) As Type
        Helper.Assert(tp IsNot Nothing, "tp Is Nothing")
        If tp.IsEnum Then
            Dim field As FieldInfo
            field = tp.GetField(EnumDeclaration.EnumTypeMemberName)
            Helper.Assert(field IsNot Nothing, "field '" & EnumDeclaration.EnumTypeMemberName & "' Is Nothing of Type '" & tp.FullName & "'")
            Return field.FieldType
        Else
            Helper.Assert(IsIntegralType(tp))
            Return tp
        End If
    End Function

    ''' <summary>
    ''' Finds the smallest type that can hold both specified types.
    ''' If tp1 = Integer and tp2 = Long would return Long
    ''' </summary>
    ''' <param name="tp1"></param>
    ''' <param name="tp2"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Function GetSmallestIntegralType(ByVal tp1 As Type, ByVal tp2 As Type) As Type
        Dim cont1(), cont2() As Type

        Helper.Assert(tp1 IsNot Nothing, "tp1 Is Nothing")
        Helper.Assert(tp2 IsNot Nothing, "tp2 Is Nothing")

        Dim itp1, itp2 As Type
        itp1 = GetIntegralType(tp1)
        itp2 = GetIntegralType(tp2)
        cont1 = valCanBeContainBy(getTypeIndex(CType(TypeToKeyword(itp1), BuiltInDataTypes)))
        cont2 = valCanBeContainBy(getTypeIndex(CType(TypeToKeyword(itp2), BuiltInDataTypes)))

        If cont1 Is Nothing Or cont2 Is Nothing Then Return Nothing

        Dim found As New ArrayList
        For Each t1 As Type In cont1
            For Each t2 As Type In cont2
                If Helper.CompareType(t1, t2) Then
                    found.Add(t1)
                End If
            Next
        Next