CompileTimeCalculations.vb

' 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.

Option Strict On
Option Explicit On
Option Infer On

Imports System.Runtime.CompilerServices
Imports Microsoft.CodeAnalysis.Text
Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax

Namespace Microsoft.CodeAnalysis.VisualBasic

    Friend Module CompileTimeCalculations

        Friend Function UncheckedCLng(v As ULong) As Long
            Return CType(v, Long)
        End Function

        Friend Function UncheckedCLng(v As Double) As Long
            Return CType(v, Long)
        End Function

        Friend Function UncheckedCULng(v As Long) As ULong
            Return CType(v, ULong)
        End Function

        Friend Function UncheckedCULng(v As Integer) As ULong
            Return CType(v, ULong)
        End Function

        Friend Function UncheckedCULng(v As Double) As ULong
            Return CType(v, ULong)
        End Function

        Friend Function UncheckedCInt(v As ULong) As Integer
            Return CType(v, Integer)
        End Function

        Friend Function UncheckedCInt(v As Long) As Integer
            Return CType(v, Integer)
        End Function

        Friend Function UncheckedCUInt(v As ULong) As UInteger
            Return CType(v, UInteger)
        End Function

        Friend Function UncheckedCUInt(v As Long) As UInteger
            Return CType(v, UInteger)
        End Function

        Friend Function UncheckedCUInt(v As Integer) As UInteger
            Return CType(v, UInteger)
        End Function

        Friend Function UncheckedCShort(v As ULong) As Short
            Return CType(v, Short)
        End Function

        Friend Function UncheckedCShort(v As Long) As Short
            Return CType(v, Short)
        End Function

        Friend Function UncheckedCShort(v As Integer) As Short
            Return CType(v, Short)
        End Function

        Friend Function UncheckedCShort(v As UShort) As Short
            Return CType(v, Short)
        End Function

        Friend Function UncheckedCInt(v As UInteger) As Integer
            Return CType(v, Integer)
        End Function

        Friend Function UncheckedCShort(v As UInteger) As Short
            Return CType(v, Short)
        End Function

        Friend Function UncheckedCUShort(v As Short) As UShort
            Return CType(v, UShort)
        End Function

        Friend Function UncheckedCUShort(v As Integer) As UShort
            Return CType(v, UShort)
        End Function

        Friend Function UncheckedCUShort(v As Long) As UShort
            Return CType(v, UShort)
        End Function

        Friend Function UncheckedCByte(v As SByte) As Byte
            Return CType(v, Byte)
        End Function

        Friend Function UncheckedCByte(v As Integer) As Byte
            Return CType(v, Byte)
        End Function

        Friend Function UncheckedCByte(v As Long) As Byte
            Return CType(v, Byte)
        End Function

        Friend Function UncheckedCByte(v As UShort) As Byte
            Return CType(v, Byte)
        End Function

        Friend Function UncheckedCSByte(v As Byte) As SByte
            Return CType(v, SByte)
        End Function

        Friend Function UncheckedCSByte(v As Integer) As SByte
            Return CType(v, SByte)
        End Function

        Friend Function UncheckedCSByte(v As Long) As SByte
            Return CType(v, SByte)
        End Function

        Friend Function UncheckedMul(x As Integer, y As Integer) As Integer
            Return x * y
        End Function

        Friend Function UncheckedMul(x As Long, y As Long) As Long
            Return x * y
        End Function

        Friend Function UncheckedIntegralDiv(x As Long, y As Long) As Long
            If y = -1 Then
                Return UncheckedNegate(x)
            End If

            Return x \ y
        End Function

        Private Function UncheckedAdd(x As Long, y As Long) As Long
            Return x + y
        End Function

        Private Function UncheckedNegate(x As Long) As Long
            Return -x
        End Function

        Friend Function GetConstantValueAsInt64(ByRef value As ConstantValue) As Long
            Select Case (value.Discriminator)
                Case ConstantValueTypeDiscriminator.SByte : Return value.SByteValue
                Case ConstantValueTypeDiscriminator.Byte : Return value.ByteValue
                Case ConstantValueTypeDiscriminator.Int16 : Return value.Int16Value
                Case ConstantValueTypeDiscriminator.UInt16 : Return value.UInt16Value
                Case ConstantValueTypeDiscriminator.Int32 : Return value.Int32Value
                Case ConstantValueTypeDiscriminator.UInt32 : Return value.UInt32Value
                Case ConstantValueTypeDiscriminator.Int64 : Return value.Int64Value
                Case ConstantValueTypeDiscriminator.UInt64 : Return UncheckedCLng(value.UInt64Value)
                Case ConstantValueTypeDiscriminator.Char : Return AscW(value.CharValue)
                Case ConstantValueTypeDiscriminator.Boolean : Return If(value.BooleanValue, 1, 0)
                Case ConstantValueTypeDiscriminator.DateTime : Return value.DateTimeValue.Ticks
                Case Else : Throw ExceptionUtilities.UnexpectedValue(value.Discriminator)
            End Select
        End Function

        Friend Function GetConstantValue(type As ConstantValueTypeDiscriminator, value As Long) As ConstantValue
            Dim result As ConstantValue

            Select Case (type)
                Case ConstantValueTypeDiscriminator.SByte : result = ConstantValue.Create(UncheckedCSByte(value))
                Case ConstantValueTypeDiscriminator.Byte : result = ConstantValue.Create(UncheckedCByte(value))
                Case ConstantValueTypeDiscriminator.Int16 : result = ConstantValue.Create(UncheckedCShort(value))
                Case ConstantValueTypeDiscriminator.UInt16 : result = ConstantValue.Create(UncheckedCUShort(value))
                Case ConstantValueTypeDiscriminator.Int32 : result = ConstantValue.Create(UncheckedCInt(value))
                Case ConstantValueTypeDiscriminator.UInt32 : result = ConstantValue.Create(UncheckedCUInt(value))
                Case ConstantValueTypeDiscriminator.Int64 : result = ConstantValue.Create(value)
                Case ConstantValueTypeDiscriminator.UInt64 : result = ConstantValue.Create(UncheckedCULng(value))
                Case ConstantValueTypeDiscriminator.Char : result = ConstantValue.Create(ChrW(UncheckedCInt(value)))
                Case ConstantValueTypeDiscriminator.Boolean : result = ConstantValue.Create(If(value = 0, False, True))
                Case ConstantValueTypeDiscriminator.DateTime : result = ConstantValue.Create(New DateTime(value))
                Case Else : Throw ExceptionUtilities.UnexpectedValue(type)
            End Select

            Debug.Assert(result.Discriminator = type)

            Return result
        End Function

        Friend Function NarrowIntegralResult(
            sourceValue As Long,
            sourceType As ConstantValueTypeDiscriminator,
            resultType As ConstantValueTypeDiscriminator,
            ByRef overflow As Boolean
        ) As Long
            Dim resultValue As Long = 0

            Select Case (resultType)

                Case ConstantValueTypeDiscriminator.Boolean
                    resultValue = If(sourceValue = 0, 0, 1)
                    Return resultValue

                Case ConstantValueTypeDiscriminator.SByte
                    resultValue = UncheckedCSByte(sourceValue)

                Case ConstantValueTypeDiscriminator.Byte
                    resultValue = UncheckedCByte(sourceValue)

                Case ConstantValueTypeDiscriminator.Int16
                    resultValue = UncheckedCShort(sourceValue)

                Case ConstantValueTypeDiscriminator.UInt16
                    resultValue = UncheckedCUShort(sourceValue)

                Case ConstantValueTypeDiscriminator.Int32
                    resultValue = UncheckedCInt(sourceValue)

                Case ConstantValueTypeDiscriminator.UInt32
                    resultValue = UncheckedCUInt(sourceValue)

                Case ConstantValueTypeDiscriminator.Int64
                    resultValue = sourceValue

                Case ConstantValueTypeDiscriminator.UInt64
                    resultValue = sourceValue 'UncheckedCLng(UncheckedCULng(SourceValue))

                Case ConstantValueTypeDiscriminator.Char
                    resultValue = UncheckedCUShort(sourceValue)
                    ' // ?? overflow?

                Case Else
                    Throw ExceptionUtilities.UnexpectedValue(resultType)
            End Select

            If Not ConstantValue.IsBooleanType(sourceType) AndAlso
                 (ConstantValue.IsUnsignedIntegralType(sourceType) Xor ConstantValue.IsUnsignedIntegralType(resultType)) Then
                ' // If source is a signed type and is a negative value or
                ' // target is a signed type and results in a negative
                ' // value, indicate overflow.
                If Not ConstantValue.IsUnsignedIntegralType(sourceType) Then
                    If sourceValue < 0 Then
                        overflow = True
                    End If
                Else
                    Debug.Assert(Not ConstantValue.IsUnsignedIntegralType(resultType), "Expected signed Target type!!!")

                    If resultValue < 0 Then
                        overflow = True
                    End If
                End If
            End If

            If resultValue <> sourceValue Then
                overflow = True
            End If

            Return resultValue
        End Function

        Friend Function NarrowIntegralResult(
            sourceValue As Long,
            sourceType As SpecialType,
            resultType As SpecialType,
            ByRef overflow As Boolean
        ) As Long
            Return NarrowIntegralResult(sourceValue,
                                        sourceType.ToConstantValueDiscriminator(),
                                        resultType.ToConstantValueDiscriminator(),
                                        overflow)
        End Function

        ''' <summary>
        ''' Narrow a quadword result to a specific integral type, setting Overflow true
        ''' if the result value cannot be represented in the result type.
        ''' </summary>
        Friend Function NarrowIntegralResult(
                        sourceValue As Long,
                        sourceType As TypeSymbol,
                        resultType As TypeSymbol,
                        ByRef overflow As Boolean) As Long

            Debug.Assert(sourceType.IsIntegralType() OrElse sourceType.IsBooleanType() OrElse sourceType.IsCharType(),
                        "Unexpected source type passed in to conversion function!!!")

            Return NarrowIntegralResult(sourceValue,
                                        sourceType.GetConstantValueTypeDiscriminator(),
                                        resultType.GetConstantValueTypeDiscriminator(),
                                        overflow)
        End Function

        Friend Function ConvertIntegralValue(
            sourceValue As Long,
            sourceType As ConstantValueTypeDiscriminator,
            targetType As ConstantValueTypeDiscriminator,
            ByRef integerOverflow As Boolean
        ) As ConstantValue

            Debug.Assert(ConstantValue.IsIntegralType(sourceType) OrElse ConstantValue.IsBooleanType(sourceType) OrElse ConstantValue.IsCharType(sourceType),
                "Unexpected source type passed in to conversion function!!!")

            If ConstantValue.IsIntegralType(targetType) OrElse ConstantValue.IsBooleanType(targetType) OrElse ConstantValue.IsCharType(targetType) Then
                Return GetConstantValue(targetType, NarrowIntegralResult(sourceValue, sourceType, targetType, integerOverflow))
            End If

            If ConstantValue.IsStringType(targetType) Then
                'This is correct only if the input type is Char.
                If ConstantValue.IsCharType(sourceType) Then
                    Return ConstantValue.Create(New String(ChrW(UncheckedCInt(sourceValue)), 1))
                End If
            End If

            If ConstantValue.IsFloatingType(targetType) Then
                Return ConvertFloatingValue(
                            If(ConstantValue.IsUnsignedIntegralType(sourceType), CType(UncheckedCULng(sourceValue), Double), CType(sourceValue, Double)),
                            targetType,
                            integerOverflow)
            End If

            If ConstantValue.IsDecimalType(targetType) Then

                Dim resultValue As Decimal

                Dim sign As Boolean

                If Not ConstantValue.IsUnsignedIntegralType(sourceType) AndAlso sourceValue < 0 Then
                    ' // Negative numbers need converted to positive and set the negative sign bit
                    sign = True
                    sourceValue = -sourceValue
                Else
                    sign = False
                End If

                Dim lo32 As Integer = UncheckedCInt(sourceValue And &HFFFFFFFF)
                ' // We include the sign bit here because we negated a negative above, so the
                ' // only number that still has the sign bit set is the maximum negative number
                ' // (which has no positive counterpart)
                Dim mid32 As Integer = UncheckedCInt((sourceValue And &HFFFFFFFF00000000) >> 32)
                Dim hi32 As Integer = 0
                Dim scale As Byte = 0

                resultValue = New Decimal(lo32, mid32, hi32, sign, scale)

                Return ConvertDecimalValue(resultValue, targetType, integerOverflow)
            End If

            Throw ExceptionUtilities.Unreachable()
        End Function

        Friend Function ConvertFloatingValue(
            sourceValue As Double,
                        targetType As ConstantValueTypeDiscriminator,
            ByRef integerOverflow As Boolean
        ) As ConstantValue

            Dim overflow As Boolean = False

            If (ConstantValue.IsBooleanType(targetType)) Then

                Return ConvertIntegralValue(If(sourceValue = 0.0, 0, 1),
                                            ConstantValueTypeDiscriminator.Int64,
                                            targetType,
                                            integerOverflow)
            End If

            If ConstantValue.IsIntegralType(targetType) OrElse ConstantValue.IsCharType(targetType) Then

                overflow = DetectFloatingToIntegralOverflow(sourceValue, ConstantValue.IsUnsignedIntegralType(targetType))

                If Not overflow Then
                    Dim integralValue As Long
                    Dim temporary As Double
                    Dim floor As Double
                    Dim sourceIntegralType As ConstantValueTypeDiscriminator

                    ' // VB has different rounding behavior than C by default. Ensure we
                    ' // are using the right type of rounding

                    temporary = sourceValue + 0.5

                    ' // We had a number that was equally close to 2 integers.
                    ' // We need to return the even one.
                    floor = Math.Floor(temporary)

                    '[AlekseyT]: Using Math.IEEERemainder as a replacement for fmod.
                    If floor <> temporary OrElse Math.IEEERemainder(temporary, 2.0) = 0 Then
                        integralValue = If(IsUnsignedLongType(targetType), ConvertFloatingToUI64(floor), UncheckedCLng(floor))
                    Else
                        integralValue = If(IsUnsignedLongType(targetType), ConvertFloatingToUI64(floor - 1.0), UncheckedCLng(floor - 1.0))
                    End If

                    If sourceValue < 0 Then
                        sourceIntegralType = ConstantValueTypeDiscriminator.Int64
                    Else
                        sourceIntegralType = ConstantValueTypeDiscriminator.UInt64
                    End If

                    Return ConvertIntegralValue(integralValue,
                                                sourceIntegralType,
                                                targetType,
                                                integerOverflow)
                End If
            End If

            If ConstantValue.IsFloatingType(targetType) Then
                Dim resultValue As Double = NarrowFloatingResult(sourceValue, targetType, overflow)

                ' // We have decided to ignore overflows in compile-time evaluation
                ' // of floating expressions.

                If targetType = ConstantValueTypeDiscriminator.Single Then
                    Return ConstantValue.Create(CType(resultValue, Single))
                End If

                Debug.Assert(targetType = ConstantValueTypeDiscriminator.Double)
                Return ConstantValue.Create(resultValue)
            End If

            If ConstantValue.IsDecimalType(targetType) Then
                Dim resultValue As Decimal

                Try
                    resultValue = Convert.ToDecimal(sourceValue)
                Catch ex As OverflowException
                    overflow = True
                End Try

                If Not overflow Then
                    Return ConvertDecimalValue(resultValue, targetType, integerOverflow)
                End If
            End If

            If overflow Then
                Return ConstantValue.Bad
            End If

            Throw ExceptionUtilities.Unreachable()
        End Function

        Friend Function ConvertDecimalValue(
            sourceValue As Decimal,
            targetType As ConstantValueTypeDiscriminator,
            ByRef integerOverflow As Boolean
        ) As ConstantValue

            Dim overflow As Boolean = False

            If ConstantValue.IsIntegralType(targetType) OrElse ConstantValue.IsCharType(targetType) Then
                Dim isNegative As Boolean
                Dim scale As Byte
                Dim low, mid, high As UInteger
                sourceValue.GetBits(isNegative, scale, low, mid, high)

                If scale = 0 Then
                    Dim resultValue As Long

                    ' Easy case: no scale factor.
                    overflow = high <> 0

                    If Not overflow Then
                        resultValue = (CLng(mid) << 32) Or low

                        Dim sourceIntegralType As ConstantValueTypeDiscriminator = Nothing

                        If isNegative Then
                            ' The source value is negative, so we need to negate the result value.
                            ' If the result type is unsigned, or the result value is already
                            ' large enough that it consumes the sign bit, then we have overflowed.
                            If ConstantValue.IsUnsignedIntegralType(targetType) OrElse
                               UncheckedCULng(resultValue) > &H8000000000000000UL Then
                                overflow = True
                            Else
                                resultValue = UncheckedNegate(resultValue)
                                sourceIntegralType = ConstantValueTypeDiscriminator.Int64
                            End If
                        Else
                            sourceIntegralType = ConstantValueTypeDiscriminator.UInt64
                        End If

                        If Not overflow Then
                            Return ConvertIntegralValue(resultValue,
                                                        sourceIntegralType,
                                                        targetType,
                                                        integerOverflow)
                        End If
                    End If

                Else
                    Dim resultValue As Double

                    ' // No overflow possible
                    resultValue = Decimal.ToDouble(sourceValue)

                    Return ConvertFloatingValue(resultValue,
                                                targetType,
                                                integerOverflow)
                End If
            End If

            If ConstantValue.IsFloatingType(targetType) OrElse ConstantValue.IsBooleanType(targetType) Then
                Dim resultValue As Double

                ' // No overflow possible
                resultValue = Decimal.ToDouble(sourceValue)

                Return ConvertFloatingValue(resultValue,
                                            targetType,
                                            integerOverflow)
            End If

            If ConstantValue.IsDecimalType(targetType) Then
                Return ConstantValue.Create(sourceValue)
            End If

            If overflow Then
                Return ConstantValue.Bad
            End If

            Throw ExceptionUtilities.Unreachable()
        End Function

        Friend Function NarrowFloatingResult(
            value As Double,
            resultType As ConstantValueTypeDiscriminator,
            ByRef overflow As Boolean
        ) As Double

            If Double.IsNaN(value) Then
                overflow = True
            End If

            Select Case (resultType)

                Case ConstantValueTypeDiscriminator.Double
                    Return value

                Case ConstantValueTypeDiscriminator.Single

                    If value > Single.MaxValue OrElse value < Single.MinValue Then
                        overflow = True
                    End If

                    Return CType(value, Single)

                Case Else
                    Throw ExceptionUtilities.UnexpectedValue(resultType)
            End Select

            Return value
        End Function

        Friend Function NarrowFloatingResult(
                value As Double,
                resultType As SpecialType,
                ByRef overflow As Boolean
            ) As Double

            If Double.IsNaN(value) Then
                overflow = True
            End If

            Select Case resultType
                Case SpecialType.System_Double
                    Return value

                Case SpecialType.System_Single
                    If value > Single.MaxValue OrElse value < Single.MinValue Then
                        overflow = True
                    End If

                    Return CType(value, Single)

                Case Else
                    Throw ExceptionUtilities.UnexpectedValue(resultType)
            End Select

            Return value
        End Function

        Private Function DetectFloatingToIntegralOverflow(
            sourceValue As Double,
            isUnsigned As Boolean
        ) As Boolean

            If isUnsigned Then
                ' // this code is shared by fjitdef.h
                If sourceValue < &HF000000000000000UL Then
                    If sourceValue > -1 Then
                        Return False
                    End If
                Else
                    Dim temporary As Double = (sourceValue - &HF000000000000000UL)

                    If temporary < &H7000000000000000L AndAlso UncheckedCLng(temporary) < &H1000000000000000L Then
                        Return False
                    End If
                End If
            Else
                ' // this code is shared by fjitdef.h
                If sourceValue < -&H7000000000000000L Then
                    Dim temporary As Double = sourceValue - (-&H7000000000000000L)

                    If temporary > -&H7000000000000000L AndAlso UncheckedCLng(temporary) > -&H1000000000000001L Then
                        Return False
                    End If
                Else
                    If sourceValue > &H7000000000000000L Then
                        Dim temporary As Double = (sourceValue - &H7000000000000000L)

                        If temporary < &H7000000000000000L AndAlso UncheckedCLng(temporary) > &H1000000000000000L Then
                            Return False
                        End If
                    Else
                        Return False
                    End If
                End If
            End If

            Return True
        End Function

        Private Function ConvertFloatingToUI64(sourceValue As Double) As Long
            ' // Conversion from double to uint64 is annoyingly implemented by the
            ' // VC++ compiler as (uint64)(int64)(double)val, so we have to do it by hand.

            Dim result As Long

            ' // code below stolen from jit...
            Dim two63 As Double = 2147483648.0 * 4294967296.0

            If sourceValue < two63 Then
                result = UncheckedCLng(sourceValue)
            Else
                result = UncheckedAdd(UncheckedCLng(sourceValue - two63), &H8000000000000000)
            End If

            Return result
        End Function

        Private Function IsUnsignedLongType(type As ConstantValueTypeDiscriminator) As Boolean
            Return type = ConstantValueTypeDiscriminator.UInt64
        End Function

        Friend Function TypeAllowsCompileTimeConversions(type As ConstantValueTypeDiscriminator) As Boolean
            Return TypeAllowsCompileTimeOperations(type)
        End Function

        Friend Function TypeAllowsCompileTimeOperations(type As ConstantValueTypeDiscriminator) As Boolean
            Select Case (type)
                Case ConstantValueTypeDiscriminator.Boolean,
                     ConstantValueTypeDiscriminator.SByte,
                     ConstantValueTypeDiscriminator.Byte,
                     ConstantValueTypeDiscriminator.Int16,
                     ConstantValueTypeDiscriminator.UInt16,
                     ConstantValueTypeDiscriminator.Int32,
                     ConstantValueTypeDiscriminator.UInt32,
                     ConstantValueTypeDiscriminator.Int64,
                     ConstantValueTypeDiscriminator.UInt64,
                     ConstantValueTypeDiscriminator.Char,
                     ConstantValueTypeDiscriminator.Decimal,
                     ConstantValueTypeDiscriminator.Double,
                     ConstantValueTypeDiscriminator.Single,
                     ConstantValueTypeDiscriminator.DateTime,
                     ConstantValueTypeDiscriminator.String

                    Return True

                Case Else
                    Return False
            End Select

        End Function

        Friend Function AdjustConstantValueFromMetadata(value As ConstantValue, targetType As TypeSymbol, isByRefParamValue As Boolean) As ConstantValue
            ' See MetaImport::DecodeValue in Dev10 compiler.

            If targetType Is Nothing OrElse targetType.IsErrorType() Then
                Return value
            End If

            Select Case value.Discriminator

                Case ConstantValueTypeDiscriminator.Int32

                    ' Adding the test for Object here is necessary in order to
                    ' make something like "Optional Byref X As Object = 5" work.
                    If targetType.IsIntrinsicType() OrElse
                       targetType.IsEnumType() OrElse
                       targetType.IsObjectType() OrElse
                       (targetType.IsNullableType() AndAlso targetType.GetNullableUnderlyingType().IsIntrinsicType()) Then
                        'No change
                        Exit Select
                    End If

                    If isByRefParamValue OrElse
                        (Not targetType.IsTypeParameter() AndAlso
                         Not targetType.IsArrayType() AndAlso
                         targetType.IsReferenceType()) Then

                        ' // REVIEW: are there other byref types besides Integer and enums
                        ' //         that might need to be handled here?
                        ' // ByRef Integer, and ByRef Enum (that is stored as I4)
                        ' // are pointer types, but optional values are not pointers

                        ' // COM+ encodes pointer constants as I4's
                        ' // CONSIDER LATER AnthonyL 8/21/00: Does this t_ref workaround move to I8 on a 64-bit machine?

                        ' // MattGe: Back out part of 604868 to address build lab issue #4093
                        ' // Probably just need to #ifdef this differently for 64bit, but
                        ' // will let Cameron decide.
                        ' //Value.Integral = (__int32)*(WIN64_UNALIGNED void **)pvValue;

                        If value.Int32Value = 0 Then
                            value = ConstantValue.Nothing
                        Else
                            value = ConstantValue.Bad
                        End If
                    End If

                Case ConstantValueTypeDiscriminator.Int64

                    If targetType.IsDateTimeType() Then
                        value = ConstantValue.Create(New DateTime(value.Int64Value))
                    End If
            End Select

            Return value
        End Function

        Friend Function Multiply(
            leftValue As Long,
            rightValue As Long,
            sourceType As SpecialType,
            resultType As SpecialType,
            ByRef integerOverflow As Boolean
        ) As Long
            Return Multiply(leftValue, rightValue,
                            sourceType.ToConstantValueDiscriminator(),
                            resultType.ToConstantValueDiscriminator(),
                            integerOverflow)
        End Function

        Friend Function Multiply(
            leftValue As Long,
            rightValue As Long,
            sourceType As ConstantValueTypeDiscriminator,
            resultType As ConstantValueTypeDiscriminator,
            ByRef integerOverflow As Boolean
        ) As Long

            Dim ResultValue = NarrowIntegralResult(
                                    UncheckedMul(leftValue, rightValue),
                                    sourceType,
                                    resultType,
                                    integerOverflow)

            If ConstantValue.IsUnsignedIntegralType(resultType) Then
                If rightValue <> 0 AndAlso
                     UncheckedCULng(ResultValue) / UncheckedCULng(rightValue) <> UncheckedCULng(leftValue) Then

                    integerOverflow = True
                End If
            Else
                If (leftValue > 0 AndAlso rightValue > 0 AndAlso ResultValue <= 0) OrElse
                    (leftValue < 0 AndAlso rightValue < 0 AndAlso ResultValue <= 0) OrElse
                    (leftValue > 0 AndAlso rightValue < 0 AndAlso ResultValue >= 0) OrElse
                    (leftValue < 0 AndAlso rightValue > 0 AndAlso ResultValue >= 0) OrElse
                    (rightValue <> 0 AndAlso ResultValue / rightValue <> leftValue) Then

                    integerOverflow = True
                End If
            End If

            Return ResultValue
        End Function
    End Module

End Namespace