' 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.IO
Imports Microsoft.CodeAnalysis
Imports Microsoft.CodeAnalysis.SpecialType
Imports Microsoft.CodeAnalysis.Test.Utilities
Imports Microsoft.CodeAnalysis.Text
Imports Microsoft.CodeAnalysis.VisualBasic
Imports Microsoft.CodeAnalysis.VisualBasic.OverloadResolution
Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Imports Microsoft.CodeAnalysis.VisualBasic.UnitTests.Emit

Imports Roslyn.Test.Utilities

Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics

    Public Class ArrayLiteralTests
        Inherits BasicTestBase

        Private ReadOnly _strictOff As VisualBasicCompilationOptions = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Off)
        Private ReadOnly _strictOn As VisualBasicCompilationOptions = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.On)
        Private ReadOnly _strictCustom As VisualBasicCompilationOptions = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Custom)

        <Fact()>
        Public Sub TestArrayLiteralInferredType()
            Dim source =
<compilation name="TestArrayLiteralInferredType">
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections.Generic

Module Program

    Sub Main(args As String())
        dim i1 = {1,2}                          '
        Console.WriteLine(i1.GetType)

        dim i2 = {{1},{2}}
        Console.WriteLine(i2.GetType)

        dim i3 = {1D}
        Console.WriteLine(i3.GetType)

        dim i4 ={({1,2}), ({3, 4})}
        Console.WriteLine(i4.GetType)
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
System.Int32[]
System.Int32[,]
System.Decimal[]
System.Int32[][]
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
System.Int32[]
System.Int32[,]
System.Decimal[]
System.Int32[][]
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestEmptyArrayLiteral()
            Dim source =
<compilation name="TestEmptyArrayLiteral">
    <file name="a.vb">
        <![CDATA[
Module Program

    Sub Main(args As String())
        dim i1 = {}         ' error if option strict is on
        dim i2 = {{}}       ' error if option strict is on
        dim i3(,) = {}      ' error if option strict is on
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
                Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{{}}"),
                Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}")
                )

        End Sub

        <Fact()>
        <CompilerTrait(CompilerFeature.IOperation)>
        Public Sub TestNestedEmptyArrayLiteralWithObject()
            Dim source =
<compilation name="TestNestedEmptyArrayLiteral">
    <file name="a.vb">
        <![CDATA[
Imports System.Collections.Generic
Module Program
    Class c
    End Class

    Sub S(o()() As Object)
    End Sub

    Sub Main(args As String())

        Dim i0 = {({})}                 ' should report an error with option strict
        Dim i1 As Object = {({})}       ' should report an error with option strict
        Dim i2 As Object() = {({})}     ' should report an error with option strict
        Dim i3 As Object()() = {({})}

        Dim j0 = {}                     ' should report an error with option strict
        Dim j1 As Object = {}           ' should report an error with option strict
        Dim j11() As Object = {}
        Dim j3(,) As Object = {}
        Dim j31(,) = {}                 ' should report an error with option strict
        Dim j4()() As Object = {}
        Dim j5() = {"a", New c}         ' should report an error with option strict

        S({({})})                       ' should report and error with option strict

        Dim ie1 As IEnumerable(Of Object) = {}
        Dim ie2 As IEnumerable(Of Object) = {({})} ' should report an error with option strict
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
                               ]]>)

            Dim tree = comp.SyntaxTrees.Single()
            Dim node = tree.GetRoot().DescendantNodes().OfType(Of LocalDeclarationStatementSyntax)().ElementAt(7)

            Assert.Equal("Dim j3(,) As Object = {}", node.ToString())

            comp.VerifyOperationTree(node.Declarators.Last.Initializer.Value, expectedOperationTree:=
            <![CDATA[
IArrayCreationOperation (OperationKind.ArrayCreation, Type: System.Object(,)) (Syntax: '{}')
  Dimension Sizes(2):
      ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 0, IsImplicit) (Syntax: '{}')
      ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 0, IsImplicit) (Syntax: '{}')
  Initializer: 
    IArrayInitializerOperation (1 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '{}')
      Element Values(1):
          IArrayInitializerOperation (0 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '{}')
            Element Values(0)
]]>.Value)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{""a"", New c}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}"),
    Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{}")
                )

        End Sub

        <Fact()>
        Public Sub TestEmptyArrayLiteralWithTargetType()
            Dim source =
<compilation name="TestEmptyArrayLiteralWithTargetType">
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections.Generic

Module Program

    Sub Main(args As String())
        dim i1 as Integer() = {} 
        dim i2 as Integer(,) = {}  
        dim i3 as Integer(,) = {{}}
        dim i4 as IEnumerable(of Decimal) = {}
        dim i5 as IList(of Decimal) = {}
        dim i6 as ICollection(of Decimal) = {}
    End Sub

End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWithTargetType()
            Dim source =
<compilation name="TestArrayLiteralWithTargetType">
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections
Imports System.Collections.Generic

Module Program

    Sub Main(args As String())
        dim i1 as IEnumerable = {1}
        dim i2 as IEnumerable(of Double) = {1}
        dim i3 as IList(of Decimal) = {1}
        dim i4 as ICollection(of short) = {1}
        dim i5() as double = {1}
        dim i6(,) as double = {{1}}
        dim i7 as string = {"h"c, "e"c, "l"c, "l"c, "o"c} 'should convert char() to string
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralDimensionMismatch()
            Dim source =
<compilation name="TestArrayLiteralWithTargetType">
    <file name="a.vb">
        <![CDATA[
Imports System.Collections.Generic

Module Program

    Sub Main(args As String())
        dim a1() = {{1}}
        dim a2 = {1, {2}}
        dim a3(,) = {{{1}}, 2}
        dim i2 as IEnumerable(of Double) = {{1}}
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.AssertTheseDiagnostics(
<expected>
BC36909: Cannot infer a data type for 'a1' because the array dimensions do not match.
        dim a1() = {{1}}
            ~~~~
BC30414: Value of type 'Integer(*,*)' cannot be converted to 'Object()' because the array types have different numbers of dimensions.
        dim a1() = {{1}}
                   ~~~~~
BC30566: Array initializer has too many dimensions.
        dim a2 = {1, {2}}
                     ~~~
BC30565: Array initializer has too few dimensions.
        dim a3(,) = {{{1}}, 2}
                            ~
BC30311: Value of type 'Integer(*,*)' cannot be converted to 'IEnumerable(Of Double)'.
        dim i2 as IEnumerable(of Double) = {{1}}
                                           ~~~~~
</expected>
            )
            comp = comp.WithOptions(_strictOn)
            comp.AssertTheseDiagnostics(
<expected>
BC36909: Cannot infer a data type for 'a1' because the array dimensions do not match.
        dim a1() = {{1}}
            ~~~~
BC30414: Value of type 'Integer(*,*)' cannot be converted to 'Object()' because the array types have different numbers of dimensions.
        dim a1() = {{1}}
                   ~~~~~
BC30566: Array initializer has too many dimensions.
        dim a2 = {1, {2}}
                     ~~~
BC30565: Array initializer has too few dimensions.
        dim a3(,) = {{{1}}, 2}
                            ~
BC30311: Value of type 'Integer(*,*)' cannot be converted to 'IEnumerable(Of Double)'.
        dim i2 as IEnumerable(of Double) = {{1}}
                                           ~~~~~
</expected>
            )

        End Sub

        <Fact()>
        Public Sub TestArrayLiteralImplicitWidening()
            Dim source =
<compilation name="TestArrayLiteralImplicitWidening">
    <file name="a.vb">
        <![CDATA[
Module Module1

    Class C
        Public Sub New(i() As Integer)
        End Sub

        Public Shared Widening Operator CType(i() As Integer) As C
            Return nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 as C = {1}
        Dim c2 = DirectCast({1}, C) 'Should fail, user defined conversion should not be applied.
        Dim c3 = TryCast({1}, C)    'Should fail, user defined conversion should not be applied.
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.VerifyDiagnostics(
                   Diagnostic(ERRID.ERR_TypeMismatch2, "{1}").WithArguments("Integer()", "Module1.C"),
                   Diagnostic(ERRID.ERR_TypeMismatch2, "{1}").WithArguments("Integer()", "Module1.C"))

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                   Diagnostic(ERRID.ERR_TypeMismatch2, "{1}").WithArguments("Integer()", "Module1.C"),
                   Diagnostic(ERRID.ERR_TypeMismatch2, "{1}").WithArguments("Integer()", "Module1.C"))
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralUserDefinedWideningFromShort()
            Dim source =
<compilation name="TestArrayLiteralUserDefinedWideningFromShort">
    <file name="a.vb">
        <![CDATA[
Module Module1

    Class C
        Public Sub New(i() As Integer)
        End Sub

        Public Shared Widening Operator CType(i() As Integer) As C
            Return nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 as C = {1S}
       End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralUserDefinedWideningFromIntegerInvolvesNarrowingLiteralLong()
            Dim source =
<compilation name="TestArrayLiteralUserDefinedWideningFromIntegerInvolvesNarrowingLiteralLong">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Class C
        Public Sub New(i() As Short)
        End Sub

        Public Shared Widening Operator CType(i() As Integer) As C
            Console.WriteLine("using widening operator CType(i() as integer) as C")
            Return nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 as C = {1L} 'Dev10 fails with Option Strict On but Roslyn succeeds. However, Dev10 behavior is wrong.
       End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
using widening operator CType(i() as integer) as C
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
using widening operator CType(i() as integer) as C
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestUserDefinedWideningFromIntegerNarrowingFromString()
            Dim source =
<compilation name="TestUserDefinedWideningFromIntegerNarrowingFromString">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Class C
        Public Sub New(i() As Integer)
        End Sub

        Public Shared Widening Operator CType(i() As Integer) As C
            Console.WriteLine("using widening operator CType(i() as integer) as C")
            Return nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 as C = {"1"} 'Narrowing not allowed with option strict on
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
            using widening operator CType(i() as integer) as C
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, """1""").WithArguments("String", "Integer"))

        End Sub


        <Fact()>
        Public Sub TestUserDefinedNarrowFromInteger()
            Dim source =
<compilation name="TestUserDefinedNarrowFromInteger">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Class C
        Public Sub New(i() As Integer)
        End Sub

        Public Shared Narrowing Operator CType(i() As Integer) As C
            Console.WriteLine("using narrowing operator CType(i() as integer) as C")
            Return nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 as C = {1S} 'Should fail when option strict is on
        Dim c2 as C = {1} 'Should fail when option strict is on
        Dim c3 as C = {1L} 'Should fail when option strict is on
        Dim c4 as C = {1D} 'Should fail when option strict is on
        Dim c5 as C = {1.0R} 'Should fail when option strict is on
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
using narrowing operator CType(i() as integer) as C
using narrowing operator CType(i() as integer) as C
using narrowing operator CType(i() as integer) as C
using narrowing operator CType(i() as integer) as C
using narrowing operator CType(i() as integer) as C
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "{1S}").WithArguments("Integer()", "Module1.C"),
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "{1}").WithArguments("Integer()", "Module1.C"),
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "{1L}").WithArguments("Integer()", "Module1.C"),
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "1D").WithArguments("Decimal", "Integer"),
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "1.0R").WithArguments("Double", "Integer"))

        End Sub

        <Fact>
        Public Sub TestArrayLiteralInferredElementTypeDiagnostics()
            Dim source =
<compilation name="TestArrayLiteralInferredElementTypeDiagnostics">
    <file name="a.vb">
        <![CDATA[
        Imports System

Module Program
    Class c
    End Class

    Sub Main(args As String())
        Dim a As ArgIterator = Nothing
        Dim x = {a}
        Dim y = {1, 1D, "a"}
        Dim z = {"a", New c}
    End Sub
End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_RestrictedType1, "= {a}").WithArguments("System.ArgIterator"),
                Diagnostic(ERRID.ERR_RestrictedType1, "{a}").WithArguments("System.ArgIterator"))

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_RestrictedType1, "= {a}").WithArguments("System.ArgIterator"),
                Diagnostic(ERRID.ERR_RestrictedType1, "{a}").WithArguments("System.ArgIterator"),
                Diagnostic(ERRID.ERR_ArrayInitTooManyTypesObjectDisallowed, "{1, 1D, ""a""}"),
                Diagnostic(ERRID.ERR_ArrayInitNoTypeObjectDisallowed, "{""a"", New c}"))

            comp = comp.WithOptions(_strictCustom)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_RestrictedType1, "= {a}").WithArguments("System.ArgIterator"),
                Diagnostic(ERRID.ERR_RestrictedType1, "{a}").WithArguments("System.ArgIterator"),
                Diagnostic(ERRID.WRN_ObjectAssumed1, "{1, 1D, ""a""}").WithArguments("Cannot infer an element type because more than one type is possible; 'Object' assumed."),
                Diagnostic(ERRID.WRN_ObjectAssumed1, "{""a"", New c}").WithArguments("Cannot infer an element type; 'Object' assumed."))
        End Sub

        <Fact>
        Public Sub TestArrayLiteralInferredElementArgIterator_1()
            Dim source =
<compilation name="TestArrayLiteralInferredElementTypeDiagnostics">
    <file name="a.vb">
        <![CDATA[
Imports System

Module Program
    Class c
    End Class

    Sub Main(args As String())
        Dim a As ArgIterator = Nothing
        Dim x as ArgIterator= {a} 
    End Sub
End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            Dim expected =
<expected>
	BC30311: Value of type 'ArgIterator()' cannot be converted to 'ArgIterator'.
        Dim x as ArgIterator= {a} 
                              ~~~
</expected>
            comp.AssertTheseDiagnostics(expected)

            comp = comp.WithOptions(_strictOn)
            comp.AssertTheseDiagnostics(expected)

            comp = comp.WithOptions(_strictCustom)
            comp.AssertTheseDiagnostics(expected)
        End Sub

        <Fact>
        <WorkItem(529377, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/529377")>
        Public Sub TestArrayLiteralInferredElementArgIterator_2()
            Dim source =
<compilation name="TestArrayLiteralInferredElementTypeDiagnostics">
    <file name="a.vb">
        <![CDATA[
Imports System

Module Program
    Class c
    End Class

    Sub Main(args As String())
        Dim a As ArgIterator = Nothing
        Dim x as ArgIterator() = {a} 
    End Sub
End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            Dim expected =
<expected>
BC31396: 'ArgIterator' cannot be made nullable, and cannot be used as the data type of an array element, field, anonymous type member, type argument, 'ByRef' parameter, or return statement.
        Dim x as ArgIterator() = {a} 
                 ~~~~~~~~~~~~~
</expected>
            comp.AssertTheseDiagnostics(expected)

            comp = comp.WithOptions(_strictOn)
            comp.AssertTheseDiagnostics(expected)

            comp = comp.WithOptions(_strictCustom)
            comp.AssertTheseDiagnostics(expected)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralInDirectCast()
            Dim source =
<compilation name="TestArrayLiteralWithCast">
    <file name="a.vb">
        <![CDATA[
Module Module1

    Sub Main()
        Dim x1 = DirectCast({1S}, Integer())
        Dim x2 = Directcast({1}, Integer())
        Dim x3 = Directcast({1D}, Integer())
        Dim x4 = DirectCast({1}, Decimal())
        Dim x5 = Directcast({"a"c, "b"c}, string)
     End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
     expectedOutput:=<![CDATA[
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "1D").WithArguments("Decimal", "Integer")
                       )
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWithAddressOfActionUndefined()
            Dim source =
<compilation name="TestArrayLiteralWithAddressOfActionUndefined">
    <file name="a.vb">
        <![CDATA[
Module Module1

    Sub Main()
        Dim b = {Addressof Main}
        Dim a As Action() = {AddressOf Main} 'Action is undefined
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_ArrayInitNoType, "{Addressof Main}"),
                Diagnostic(ERRID.ERR_AddressOfNotDelegate1, "Addressof Main").WithArguments("Object"),
                Diagnostic(ERRID.ERR_UndefinedType1, "Action").WithArguments("Action")
                )

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_ArrayInitNoType, "{Addressof Main}"),
                Diagnostic(ERRID.ERR_AddressOfNotDelegate1, "Addressof Main").WithArguments("Object"),
                Diagnostic(ERRID.ERR_UndefinedType1, "Action").WithArguments("Action")
                )
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWithAddressOf()
            Dim source =
<compilation name="TestArrayLiteralWithAddressOf">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Sub Main()
        Dim b = {Addressof Main}
        Dim a As Action() = {AddressOf Main} 'Action is undefined
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_ArrayInitNoType, "{Addressof Main}"),
                Diagnostic(ERRID.ERR_AddressOfNotDelegate1, "Addressof Main").WithArguments("Object")
                )

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                    Diagnostic(ERRID.ERR_ArrayInitNoType, "{Addressof Main}"),
                    Diagnostic(ERRID.ERR_AddressOfNotDelegate1, "Addressof Main").WithArguments("Object")
                       )
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralNarrowingConversion()
            Dim source =
<compilation name="TestArrayLiteralNarrowingConversion">
    <file name="a.vb">
        <![CDATA[
Imports System

Module Module1
    Class C
        Public Shared Narrowing Operator CType(ByVal x As Integer()) As C
            Console.WriteLine("Public Shared Narrowing Operator CType(ByVal x As Integer()) As C")
            Return Nothing
        End Operator

        Public Shared Narrowing Operator CType(ByVal x As C) As Integer()
            Console.WriteLine("Public Shared Narrowing Operator CType(ByVal x As C) As Integer()")
            Return Nothing
        End Operator
    End Class

    Sub Main()
        'Both Narrowing
        Dim c1 As New C
        c1 = {1, 2, 3, 4, 5} '//UD Conversion
    End Sub

End Module
]]>
    </file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)

            CompileAndVerify(comp,
          expectedOutput:=<![CDATA[
Public Shared Narrowing Operator CType(ByVal x As Integer()) As C
                             ]]>)


            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "{1, 2, 3, 4, 5}").WithArguments("Integer()", "Module1.C")
                )
        End Sub


        <Fact()>
        Public Sub TestArrayLiteralInvolvesNarrowingFromNumericConstantAllWidening()
            'All conversions in the array literal are narrowing with InvolvesNarrowingFromNumericConstant
            'Because the second argument is identity (byte) test2 should resolve to Sub Test2(x As Short(), y As Byte)
            Dim source =
<compilation name="TestArrayLiteralInvolvesNarrowingFromNumericConstantAllWidening">
    <file name="a.vb">
        <![CDATA[
Module m
    Sub Test2(x As Integer(), y As Integer)
        System.Console.WriteLine("Test2(x As Integer(), y As Integer)")
    End Sub

    Sub Test2(x As Byte(), y As Byte)
        System.Console.WriteLine("Test2(x As Byte(), y As Byte)")
    End Sub

    Sub Main()
        Dim b As Byte = 1
        Test2({&H7FFFFFFFL, &H7FFFFFFFL, &H7FFFFFFFL}, b) 
    End Sub

End Module
]]></file>
</compilation>

            Dim strictOffOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Off).WithOverflowChecks(False)

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=strictOffOverflowChecksOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Test2(x As Byte(), y As Byte)
            ]]>)

            Dim strictOnOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.On).WithOverflowChecks(False)

            comp = comp.WithOptions(strictOnOverflowChecksOff)
            CompileAndVerify(comp,
                            expectedOutput:=<![CDATA[
Test2(x As Byte(), y As Byte)
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralExactlyOneInvolvesNarrowingFromNumericConstantAndWidening()
            'The conversion in the array literal is narrowing with InvolvesNarrowingFromNumericConstant. The others are widening.
            'Because the second argument is identity (byte) test2 should resolve to Sub Test2(x As Short(), y As Byte)
            Dim source =
<compilation name="TestArrayLiteralExactlyOneInvolvesNarrowingFromNumericConstantAndWidening">
    <file name="a.vb">
        <![CDATA[
Module m
    Sub Test2(x As Integer(), y As Integer)
        System.Console.WriteLine("Test2(x As Integer(), y As Integer)")
    End Sub

    Sub Test2(x As Short(), y As Byte)
        System.Console.WriteLine("Test2(x As Short(), y As Byte)")
    End Sub

    Sub Main()
        Dim b As Byte = 1
        Test2({1S, 2S, &H7FFFFFFFL, 3S}, b) 
    End Sub

End Module
]]></file>
</compilation>

            Dim strictOffOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Off).WithOverflowChecks(False)

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=strictOffOverflowChecksOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Test2(x As Short(), y As Byte)
            ]]>)

            Dim strictOnOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.On).WithOverflowChecks(False)

            comp = comp.WithOptions(strictOnOverflowChecksOff)
            CompileAndVerify(comp,
                            expectedOutput:=<![CDATA[
Test2(x As Short(), y As Byte)
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralExactlyInvolvesNarrowingFromNumericConstantAndNarrowing()
            'All conversions in the array literal are widening, one is narrowing with InvolvesNarrowingFromNumericConstant and one is narrowing
            'Because one narrowing conversion lacks InvolvesNarrowingFromNumericConstant, this fails overload resolution.
            Dim source =
<compilation name="TestArrayLiteralExactlyInvolvesNarrowingFromNumericConstantAndNarrowing">
    <file name="a.vb">
        <![CDATA[
Module m
    Sub Test2(x As Integer(), y As Integer)
        System.Console.WriteLine("Test2(x As Integer(), y As Integer)")
    End Sub

    Sub Test2(x As Short(), y As Byte)
        System.Console.WriteLine("Test2(x As Short(), y As Byte)")
    End Sub

    Sub Main()
        Dim b As Byte = 1
        Test2({1S, 2S, &H7FFFFFFFL, 1.0}, b) 
    End Sub

End Module
]]></file>
</compilation>

            Dim strictOffOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Off).WithOverflowChecks(False)

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=strictOffOverflowChecksOff)
            comp.VerifyDiagnostics(
                   Diagnostic(ERRID.ERR_NoNonNarrowingOverloadCandidates2, "Test2").WithArguments("Test2", Environment.NewLine &
            "    'Public Sub Test2(x As Integer(), y As Integer)': Argument matching parameter 'x' narrows to 'Integer()'." & Environment.NewLine &
            "    'Public Sub Test2(x As Short(), y As Byte)': Argument matching parameter 'x' narrows to 'Short()'."))

            Dim strictOnOverflowChecksOff = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.On).WithOverflowChecks(False)

            comp = comp.WithOptions(strictOnOverflowChecksOff)
            comp.VerifyDiagnostics(
                 Diagnostic(ERRID.ERR_NoCallableOverloadCandidates2, "Test2").WithArguments("Test2", Environment.NewLine &
          "    'Public Sub Test2(x As Integer(), y As Integer)': Option Strict On disallows implicit conversions from 'Double' to 'Integer'." & Environment.NewLine &
          "    'Public Sub Test2(x As Short(), y As Byte)': Option Strict On disallows implicit conversions from 'Double' to 'Short'."))
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWithNarrowing1()
            Dim source =
<compilation name="TestArrayLiteralWithNarrowing1">
    <file name="a.vb">
        <![CDATA[
Module Program

    Sub Main(args As String())
        dim s0() as short = {1000, 1000L} 'Pass Both
        dim s1() as short = {1000, 1000L, 1000.0} 'Pass Option Strict Off/Fail Option Strict On
        dim s2() as short = {1000, 1000L, "a"c} 'Fail Both
        dim s3() as short = {1000, 1000L, "a"}  'Pass Option Strict Off/Fail Option Strict On
    End Sub
End Module
]]></file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.VerifyDiagnostics(Diagnostic(ERRID.ERR_CharToIntegralTypeMismatch1, """a""c").WithArguments("Short"))

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "1000.0").WithArguments("Double", "Short"),
                Diagnostic(ERRID.ERR_CharToIntegralTypeMismatch1, """a""c").WithArguments("Short"),
                Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, """a""").WithArguments("String", "Short"))
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWithNarrowing2()
            Dim source =
<compilation name="TestArrayLiteralWithNarrowing2">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Class C
        Public Sub New(i() As Short)
        End Sub

        Public Shared Narrowing Operator CType(i() As Short) As C
            Console.WriteLine("Public Shared Narrowing Operator CType(i() As Short) As C")
            Return Nothing
        End Operator
    End Class

    Sub Main()
        Dim c1 As C = {10S, 10, 10L} 
    End Sub

End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Public Shared Narrowing Operator CType(i() As Short) As C
            ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                     Diagnostic(ERRID.ERR_NarrowingConversionDisallowed2, "{10S, 10, 10L}").WithArguments("Short()", "Module1.C")
               )
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWideningUserDefinedWithNarrowingLiteral1()
            Dim source =
<compilation name="TestArrayLiteralWithNarrowing2">
    <file name="a.vb">
        <![CDATA[
Module m
    Class B1
        Shared Widening Operator CType(x As Short()) As B1
            Return Nothing
        End Operator
    End Class

    Class B2
        Shared Widening Operator CType(x As Byte()) As B2
            Return Nothing
        End Operator
    End Class

    Sub Test2(x As B1, y As Integer)
        System.Console.WriteLine("Test2(x As B1)")
    End Sub

    Sub Test2(x As B2, y As Byte)
        System.Console.WriteLine("Test2(x As B2)")
    End Sub

    Sub Main()
        Dim i As Integer = 1
        Dim b As Byte = 0
        Test2({1}, b)         ' differs from dev10 - dev10 reports error because it fails to apply user defined conversion for array literal.  
        Test2({1S}, b)        ' differs from dev10 - binds to B2, Dev10 binds to B1.
        Test2({CShort(i)}, b) 
    End Sub
End Module
]]>
    </file>
</compilation>
            ' See comments above.  Two of the calls differ from Dev10.  Roslyn considers user defined conversions for array literal arguments
            ' when doing overload resolution.  Dev10 does not.

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Test2(x As B2)
Test2(x As B2)
Test2(x As B1)
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Test2(x As B2)
Test2(x As B2)
Test2(x As B1)
            ]]>)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralWideningUserDefinedWithNarrowingLiteral2()
            Dim source =
<compilation name="TestArrayLiteralWithNarrowing2">
    <file name="a.vb">
        <![CDATA[
Module m
    Class B1
        Shared Widening Operator CType(x As Short()) As B1
            Return Nothing
        End Operator
    End Class

    Class B2
        Shared Widening Operator CType(x As Byte()) As B2
            Return Nothing
        End Operator
    End Class

    Sub Test2(x As B1, y As Integer)
        System.Console.WriteLine("Test2(x As B1)")
    End Sub

    Sub Test2(x As B2, y As Byte)
        System.Console.WriteLine("Test2(x As B2)")
    End Sub

    Sub Main()
        Dim i As Integer = 1
        Dim b As Byte = 0
        Test2({i}, b)
    End Sub
End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.VerifyDiagnostics(
            Diagnostic(ERRID.ERR_NoNonNarrowingOverloadCandidates2, "Test2").WithArguments("Test2", Environment.NewLine &
     "    'Public Sub Test2(x As m.B1, y As Integer)': Argument matching parameter 'x' narrows to 'm.B1'." & Environment.NewLine &
     "    'Public Sub Test2(x As m.B2, y As Byte)': Argument matching parameter 'x' narrows to 'm.B2'."))

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
            Diagnostic(ERRID.ERR_NoCallableOverloadCandidates2, "Test2").WithArguments("Test2", Environment.NewLine &
     "    'Public Sub Test2(x As m.B1, y As Integer)': Option Strict On disallows implicit conversions from 'Integer' to 'Short'." & Environment.NewLine &
     "    'Public Sub Test2(x As m.B2, y As Byte)': Option Strict On disallows implicit conversions from 'Integer' to 'Byte'."))
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralLegacy1()
            Dim source =
<compilation name="TestArrayLiteralLegacy1">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Module1

    Public Class c1
        Private Shared Sub StrReturnMethod(msg As String)
            Console.WriteLine(msg)
        End Sub

        Public Shared Sub goo(ByVal ParamArray z As String())
            StrReturnMethod("string()")
        End Sub

        Public Shared Sub goo(ByVal z As Char())
            StrReturnMethod("char()")
        End Sub

        Public Shared Sub goo(ByVal z As String)
            StrReturnMethod("string")
        End Sub
    End Class

    Sub Main()
        c1.goo({"a"c}) '//Char()
    End Sub

End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
char()
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
char()
            ]]>)

        End Sub

        <Fact()>
        Public Sub TestArrayLiteralLegacy2()
            Dim source =
<compilation name="TestArrayLiteralLegacy2">
    <file name="a.vb">
        <![CDATA[
Imports System
Module Program
    Dim strMethod As String = ""

    Class S5_C1a
        Public Shared Widening Operator CType(ByVal x As Integer()) As S5_C1a
            Console.WriteLine("Widening Operator CType(ByVal x As Integer())")
            Return Nothing
        End Operator

        Public Shared Widening Operator CType(ByVal x As Short()) As S5_C1a
            Console.WriteLine("Widening Operator CType(ByVal x As Short())")
            Return Nothing
        End Operator

    End Class

    Sub Main(args As String())
        'All Widening
        Dim Obj_S5_C1a As New S5_C1a

        Obj_S5_C1a = {1S, 2S, 3S, 4S, 5S}

    End Sub
End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Widening Operator CType(ByVal x As Short())
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Widening Operator CType(ByVal x As Short())
            ]]>)


        End Sub

        <Fact()>
        Public Sub TestArrayLiteralLegacy3()
            Dim source =
<compilation name="TestArrayLiteralLegacy3">
    <file name="a.vb">
        <![CDATA[
Imports System

Module Program
    Sub SubExpectingFuncOfT(Of t)(ByVal x As Func(Of t)())
        Console.WriteLine("SubExpectingFuncOfT - Array")
    End Sub

    Sub Main(args As String())

                'Specified
        Dim b2 As Func(Of Integer) = Function() 1 'Lambda Single

        SubExpectingFuncOfT({b2})
    End Sub
End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
SubExpectingFuncOfT - Array
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
SubExpectingFuncOfT - Array
            ]]>)

        End Sub

        <Fact()>
        Public Sub TestArrayLiteralLegacy4()
            Dim source =
<compilation name="TestArrayLiteralLegacy4">
    <file name="a.vb">
        <![CDATA[
Imports System
Module m

    Sub Main()
        Goo2Params({1, 2, 3}, {1.1, 2.2, 3.3})
        Goo2Params({1, 2, 3}, {1L, 2L, 3L})
    End Sub

    Function Goo2Params(Of t)(x As t, y As t) As String
        Console.WriteLine("Function Goo2Param(of {0})(x as {0}, y as {0})", x.getType())
        Return Nothing
    End Function
End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo2Param(of System.Double[])(x as System.Double[], y as System.Double[])
Function Goo2Param(of System.Int64[])(x as System.Int64[], y as System.Int64[])
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo2Param(of System.Double[])(x as System.Double[], y as System.Double[])
Function Goo2Param(of System.Int64[])(x as System.Int64[], y as System.Int64[])
            ]]>)

        End Sub

        <Fact()>
        Public Sub TestArrayLiteralLegacy5()
            Dim source =
<compilation name="TestArrayLiteralLegacy5">
    <file name="a.vb">
        <![CDATA[
Imports System
Module m

    Sub Main()
       Goo2ParamsArray({1, 2, 3}, 3L)
    End Sub

   Function Goo2ParamsArray(Of t)(x() As t, y As t) As String
     Console.WriteLine("Function Goo2Param(of {0})(x as {0}, y as {0})", x.getType())
     return nothing
    End Function

End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo2Param(of System.Int64[])(x as System.Int64[], y as System.Int64[])
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo2Param(of System.Int64[])(x as System.Int64[], y as System.Int64[])
            ]]>)

        End Sub


        ' Tests inferring generic parameter type via user defined conversion in C.
        <Fact()>
        Public Sub TestArrayLiteralGenericParameterAndUserDefinedConversion()
            Dim source =
<compilation name="TestArrayLiteralGenericParameterAndUserDefinedConversion">
    <file name="a.vb">
        <![CDATA[
Imports System
Module m
    Class C
        Public Shared Widening Operator CType(ByVal x As Integer()) As C
            Console.WriteLine("Widening Operator CType(ByVal x As Integer())")
            Return new C
        End Operator
    End Class

    Sub Main()
        Goo({1, 2})
        Goo2Params({1, 2, 3}, New C())
    End Sub

    Function Goo(Of t)(ByVal x As t) As String
        Console.WriteLine("Function Goo(of {0})(x as {0})", x.getType())
        Return nothing
    End Function

   Function Goo2Params(Of t)(x As t, y As t) As String
     Console.WriteLine("Function Goo2Params(of {0})(x as {0}, y as {1})", x.getType(), y.GetType())
     return nothing
    End Function

End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo(of System.Int32[])(x as System.Int32[])
Widening Operator CType(ByVal x As Integer())
Function Goo2Params(of m+C)(x as m+C, y as m+C)
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Function Goo(of System.Int32[])(x as System.Int32[])
Widening Operator CType(ByVal x As Integer())
Function Goo2Params(of m+C)(x as m+C, y as m+C)
            ]]>)

        End Sub

        ' Tests dominant type when array is converted to c via user defined function
        <Fact()>
        Public Sub TestArrayLiteralDominantTypeAndUserDefinedConversion()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Imports System
Module m
    Class C
        Public Shared Widening Operator CType(ByVal x As Integer()) As C
            Console.WriteLine("Widening Operator CType(ByVal x As Integer())")
            Return new C
        End Operator
    End Class

    Sub Main()
         Dim x = {New C(), ({1, 2, 3})}
        Console.WriteLine("{0}", x.GetType())
    End Sub

End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Widening Operator CType(ByVal x As Integer())
m+C[]
            ]]>)


            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Widening Operator CType(ByVal x As Integer())
m+C[]
            ]]>)

        End Sub

        <WorkItem(544203, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544203")>
        <Fact()>
        Public Sub ArrayLiteralInferenceBug12426()
            Dim source =
<compilation name="ArrayLiteralInferenceBug12426">
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections.Generic
Module Program
    Sub Main()
        Dim a =
            ImmutableArray(Of BoundStatement).CreateFrom(
            {
                New BoundExpressionStatement(),
                New BoundReturnStatement()
            })

        Console.WriteLine("{0}", a.GetType())
    End Sub
End Module
Class ImmutableArray(Of T)
    Public Shared Function CreateFrom(ParamArray items() As T) As ImmutableArray(Of T)
        Console.WriteLine("Public Shared Function CreateFrom(ParamArray items() As {0}) As ImmutableArray(Of {0})",
                          items.GetType().GetElementType())
        Return New ImmutableArray(Of T)()
    End Function
    Public Shared Function CreateFrom(Of U As T)(items As ICollection(Of U)) As ImmutableArray(Of T)
        Console.WriteLine("Public Shared Function CreateFrom(Of U As T)(items As ICollection(Of {0})) As ImmutableArray(Of T)",
                          items.GetType().GetElementType())
        Return New ImmutableArray(Of T)()
    End Function
End Class
Class BoundStatement
End Class
Class BoundReturnStatement
    Inherits BoundStatement
End Class
Class BoundExpressionStatement
    Inherits BoundStatement
End Class
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Public Shared Function CreateFrom(ParamArray items() As BoundStatement) As ImmutableArray(Of BoundStatement)
ImmutableArray`1[BoundStatement]
            ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Public Shared Function CreateFrom(ParamArray items() As BoundStatement) As ImmutableArray(Of BoundStatement)
ImmutableArray`1[BoundStatement]
            ]]>)

        End Sub

        <WorkItem(544381, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544381")>
        <Fact()>
        Public Sub ArrayLiteralInferenceBug12679()
            Dim source =
<compilation name="ArrayLiteralInferenceBug12679">
    <file name="a.vb">
        <![CDATA[
Imports System

Module Module1

    Enum TypedConstantKind
        Array
    End Enum

    Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As T)
        Console.WriteLine("Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As {0})", v.GetType())
    End Sub

    Sub Main(args As String())
        VerifyValue(0, TypedConstantKind.Array, {1, "two", GetType(String), 3.1415926})
        VerifyValue(0, TypedConstantKind.Array, {})
    End Sub
End Module
]]>
    </file>
</compilation>

            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As System.Object[])
Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As System.Object[])
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(
                Diagnostic(ERRID.WRN_TypeInferenceAssumed3, "{1, ""two"", GetType(String), 3.1415926}").WithArguments("T", "Friend Sub VerifyValue(Of T)(i As Integer, kind As Module1.TypedConstantKind, v As T)", "Object()"),
                Diagnostic(ERRID.WRN_TypeInferenceAssumed3, "{}").WithArguments("T", "Friend Sub VerifyValue(Of T)(i As Integer, kind As Module1.TypedConstantKind, v As T)", "Object()"))
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As System.Object[])
Friend Sub VerifyValue(Of T)(i As Integer, kind As TypedConstantKind, v As System.Object[])
                         ]]>)

        End Sub

        <Fact>
        Public Sub TestSemanticInfoTooDeeplyNestedArrayLiteral()
            Dim compilation = CreateCompilationWithMscorlib40(
<compilation>
    <file name="a.vb"><![CDATA[
Imports System
Imports System.Collections.Generic
Imports System.Linq

Module Program
    Sub Main(args As String())
        Dim x = {1, {2}}'BIND:"{2}"
    End Sub
End Module
    ]]></file>
</compilation>)
            ' No semantic information is reported. It should be Int32.
            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Equal("?", semanticSummary.Type.ToTestDisplayString())
            Assert.Equal(TypeKind.Error, semanticSummary.Type.TypeKind)
            Assert.Equal("?", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(TypeKind.Error, semanticSummary.ConvertedType.TypeKind)
            Assert.Equal(ConversionKind.Identity, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(CandidateReason.None, semanticSummary.CandidateReason)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)
        End Sub

        <WorkItem(544363, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544363")>
        <Fact()>
        Public Sub TestArrayLiteralWithAmbiguousOverloadWithParamArray()
            Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
<compilation>
    <file name="a.vb"><![CDATA[
Module Program
    Sub Main(ByVal args As String())
        gooModules({"1"}, {1})
    End Sub
    Public Sub gooModules(Of T)(ByVal ParamArray z As T())
    End Sub
    Public Sub gooModules(ByVal ParamArray z As String())
    End Sub
End Module
    ]]></file>
</compilation>)

            Dim expected =
<expected>
BC30311: Value of type 'String()' cannot be converted to 'String'.
        gooModules({"1"}, {1})
                   ~~~~~
BC30311: Value of type 'Integer()' cannot be converted to 'String'.
        gooModules({"1"}, {1})
                          ~~~
</expected>

            AssertTheseDiagnostics(compilation, expected)

            compilation = compilation.WithOptions(_strictOn)
            AssertTheseDiagnostics(compilation, expected)
        End Sub

        <WorkItem(544352, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544352")>
        <Fact()>
        Public Sub TestArrayLiteralErrorMsgArrayOfDelegate()
            Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
<compilation>
    <file name="a.vb"><![CDATA[
Imports System
Module Program
    Sub Main(ByVal args As String())
        Dim x1 As Func(Of Integer) = {AddressOf Goo}
    End Sub
 
    Sub Goo()
    End Sub
End Module
    ]]></file>
</compilation>)

            compilation.VerifyDiagnostics(Diagnostic(ERRID.ERR_ArrayInitNoType, "{AddressOf Goo}"))

            compilation = compilation.WithOptions(_strictOn)
            compilation.VerifyDiagnostics(Diagnostic(ERRID.ERR_ArrayInitNoType, "{AddressOf Goo}"))
        End Sub


        <WorkItem(544566, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544566")>
        <Fact()>
        Public Sub TestArrayLiteralInTernaryIf()
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation>
    <file name="a.vb"><![CDATA[
Option Infer On
Imports System
Module M
Sub Main()
        Dim o1 = If(True, {1, 2S, 3S}, Nothing)
        Dim o2 = If(True, {1, 2S, 3S}, CType(Nothing, Long()))
        Dim o3 As Integer() = If(True, {1, 2S, 3S}, Nothing)
        Dim o4 As Long() = If(True, {1, 2S, 3S}, CType(Nothing, Long()))
        Dim x As Long() = New Long() {}
        Dim o5 = If(True, {1, 2S, 3S}, x)

        Console.WriteLine(o1.GetType())
        Console.WriteLine(o2.GetType())
        Console.WriteLine(o5.GetType())
End Sub
End Module

    ]]></file>
</compilation>, options:=_strictOff)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
System.Int32[]
System.Int64[]
System.Int64[]
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp, expectedOutput:=<![CDATA[
System.Int32[]
System.Int64[]
System.Int64[]
                        ]]>)
        End Sub

        <WorkItem(529543, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/529543")>
        <Fact()>
        Public Sub TestArrayLiteralSemanticModelCTypeLongConversion()
            Dim compilation = CreateCompilationWithMscorlib40(
 <compilation>
     <file name="a.vb"><![CDATA[
Imports System
Imports System.Collections.Generic
Imports System.Linq

Module Program
    Sub Main(args As String())
        Dim x As Object = CType({1}, Long())'BIND:"{1}"
        Console.WriteLine(x.GetType)
    End Sub
End Module
    ]]></file>
 </compilation>)

            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Null(semanticSummary.Type)
            Assert.Equal("System.Int64()", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(TypeKind.Array, semanticSummary.ConvertedType.TypeKind)
            Assert.Equal(ConversionKind.Widening, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(CandidateReason.None, semanticSummary.CandidateReason)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)

            Dim model = GetSemanticModel(compilation, "a.vb")
            Dim node As ExpressionSyntax = CompilationUtils.FindBindingText(Of ExpressionSyntax)(compilation, "a.vb")
            Dim conversion = model.ClassifyConversion(node, semanticSummary.ConvertedType)
            Assert.False(conversion.IsArray)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralSemanticModelUserDefinedConversion()
            Dim compilation = CreateCompilationWithMscorlib40(
<compilation>
    <file name="a.vb"><![CDATA[
Imports System
Module m
    Class C
        Public Shared Widening Operator CType(ByVal x As Integer()) As C
            Console.WriteLine("Widening Operator CType(ByVal x As Integer())")
            Return New C
        End Operator
    End Class

    Sub Main()
        Goo({1, 2})
        Goo2Params({1, 2, 3}, New C())'BIND:"{1, 2, 3}"
    End Sub

    Function Goo(Of t)(ByVal x As t) As String
        Console.WriteLine("Function Goo(of {0})(x as {0})", x.GetType())
        Return Nothing
    End Function

    Function Goo2Params(Of t)(x As t, y As t) As String
        Console.WriteLine("Function Goo2Params(of {0})(x as {0}, y as {1})", x.GetType(), y.GetType())
        Return Nothing
    End Function

End Module
    ]]></file>
</compilation>)

            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Null(semanticSummary.Type)
            Assert.Equal("m.C", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(TypeKind.Class, semanticSummary.ConvertedType.TypeKind)
            Assert.Equal(ConversionKind.Widening Or ConversionKind.UserDefined, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)
        End Sub

        <Fact()>
        Public Sub TestArrayLiteralSemanticModelCharArrayConversion()
            Dim compilation = CreateCompilationWithMscorlib40(
<compilation>
    <file name="a.vb"><![CDATA[
Imports System
Imports System.Collections.Generic
Imports System.Linq

Module Program
    Sub Main(args As String())
        Dim s As String = {"a"c}'BIND:"{"a"c}"
    End Sub
End Module
    ]]></file>
</compilation>)

            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Null(semanticSummary.Type)
            Assert.Equal("System.String", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(TypeKind.Class, semanticSummary.ConvertedType.TypeKind)
            Assert.Equal(ConversionKind.WideningString, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(CandidateReason.None, semanticSummary.CandidateReason)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)
        End Sub

        <WorkItem(545375, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545375")>
        <Fact()>
        Public Sub TestArrayLiteralInferTypeInIf()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main(args As String())
        Dim i1 = If(True, {2, "hello"}, New Object() {})  ' Object()                        '
        Console.WriteLine(i1.GetType)
    End Sub

End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
            System.Object[]
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
            System.Object[]
                        ]]>)
        End Sub

        <WorkItem(545517, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545517")>
        <Fact()>
        Public Sub TestArrayLiteralInferTypeInWithinParens1()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Imports System
Imports System.Collections.Generic
Module M
    Sub Main()
       Goo({({1})})
    End Sub
    Sub Goo(Of T As Structure)(x As T?()())
        Console.WriteLine("Sub Goo(Of T As Structure)(x As T?()())")
    End Sub
    Sub Goo(Of T)(x As IList(Of T)())
        Console.WriteLine("Sub Goo(Of T)(x As IList(Of T)())")
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
Sub Goo(Of T)(x As IList(Of T)())
                        ]]>)

            comp = comp.WithOptions(_strictOn)
            CompileAndVerify(comp,
                             expectedOutput:=<![CDATA[
Sub Goo(Of T)(x As IList(Of T)())
                        ]]>)
        End Sub

        <WorkItem(545517, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545517")>
        <Fact()>
        Public Sub TestArrayLiteralInferTypeInWithinParens2()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Module M
    Sub Main()
       dim x as integer?() = {1}    ' should succeed
       dim y as integer?() = ({1})  ' should fail
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, options:=_strictOff)
            comp.VerifyDiagnostics(Diagnostic(ERRID.ERR_ConvertArrayMismatch4, "({1})").WithArguments("Integer()", "Integer?()", "Integer", "Integer?"))

            comp = comp.WithOptions(_strictOn)
            comp.VerifyDiagnostics(Diagnostic(ERRID.ERR_ConvertArrayMismatch4, "({1})").WithArguments("Integer()", "Integer?()", "Integer", "Integer?"))

        End Sub

        <WorkItem(530876, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530876")>
        <Fact()>
        Public Sub Bug17124()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Module Program
    Sub Main()
    	Dim x = New Long()()() {({({1L,2L}), ({3L, 4L})})}
    End Sub
End Module
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
            CompileAndVerify(comp)
        End Sub

        <WorkItem(796610, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/796610")>
        <Fact()>
        Public Sub Bug796610_1()
            Dim source =
<compilation>
    <file name="a.vb">
        <![CDATA[
Option Explicit On
Imports System
Imports Microsoft.VisualBasic

Module M
    Sub Main()
        Dim obj1 = If(True, {Nothing, New With {.a = 1}}, {Nothing})
        Validate(obj1)
        Validate({Nothing, New With {.a = 1}}, {Nothing})
        Console.WriteLine("--------------")

        Dim a1 = If(True, {<basic xmlns="">true</basic>}, {Nothing})
        Validate(a1)
        Validate({<basic xmlns="">true</basic>}, {Nothing})
        Dim a3 = If({"goo"}, {Nothing})
        Validate(a3)
        Validate({"goo"}, {Nothing})
        System.Console.WriteLine("--------------")

        Dim b1 = If(True, {New Animal, New Mammal}, {New Fish, New Mammal})
        Dim b2 = If(False, {New Animal, New Mammal}, {New Fish, New Mammal})
        Validate(b1)
        Validate(b2)
        Validate({New Animal, New Mammal}, {New Fish, New Mammal})
        System.Console.WriteLine("--------------")

        Dim x5 = If(True, {CType(New Bar(1), Goo)}, {Nothing})
        Validate(x5)
        Validate({CType(New Bar(1), Goo)}, {Nothing})

        System.Console.WriteLine("======================" & Environment.NewLine)
        Dim obj2 = If(True, {Nothing}, {Nothing, New With {.a = 1}})
        Validate(obj2)
        Validate({Nothing}, {Nothing, New With {.a = 1}})
        Console.WriteLine("--------------")
        Dim obj3 = If(True, {Nothing, New With {.a = 1}}, {})
        Validate(obj3)
        Validate({Nothing, New With {.a = 1}}, {})
        Console.WriteLine("--------------")
        Dim obj4 = If(True, {}, {Nothing, New With {.a = 1}})
        Validate(obj4)
        Validate({}, {Nothing, New With {.a = 1}})
        Console.WriteLine("--------------")

        Dim obj5 = If(True, {}, {{New Object()}})
        Validate(obj5)
        Validate({}, {{New Object()}})
        Console.WriteLine("--------------")
        Dim obj6 = If(True, {{New Object()}}, {})
        Validate(obj6)
        Validate({{New Object()}}, {})
        Console.WriteLine("--------------")

        Dim obj7 = If(True, Nothing, {{New Object()}})
        Validate(obj7)
        Validate(Nothing, {{New Object()}})
        Console.WriteLine("--------------")
        Dim obj8 = If(True, {{New Object()}}, Nothing)
        Validate(obj8)
        Validate({{New Object()}}, Nothing)
        Console.WriteLine("--------------")

        Dim obj9 = If(True, (Nothing), {{New Object()}})
        Validate(obj9)
        Validate((Nothing), {{New Object()}})
        Console.WriteLine("--------------")
        Dim obj10 = If(True, {{New Object()}}, (Nothing))
        Validate(obj10)
        Validate({{New Object()}}, (Nothing))
        Console.WriteLine("--------------")
    End Sub

    Sub Validate(Of T)(ByVal x As T)
        Dim ActualType As Type = GetType(T)
        Console.WriteLine("Static={0}, Runtime={1}", ActualType.ToString, If(x Is Nothing, "Nothing", x.GetType().ToString()))
    End Sub

    Sub Validate(Of T)(ByVal x As T, ByVal y As T)
        Dim ActualType As Type = GetType(T)
        Console.WriteLine("Static={0}, Runtime x={1}, Runtime y={2}", ActualType.ToString, If(x Is Nothing, "Nothing", x.GetType().ToString()), If(y Is Nothing, "Nothing", y.GetType().ToString()))
    End Sub
End Module

Class Animal : End Class
Class Mammal : Inherits Animal : End Class
Class Fish : Inherits Animal : End Class

Class Goo
    Sub New(ByVal x As Integer)
        Field = x
    End Sub
    Public Field As Integer
    Public Overloads Shared Widening Operator CType(ByVal x As Bar) As Goo
        Return New Goo(x.Field)
    End Operator
End Class
Class Bar
    Public Field As Integer
    Sub New(ByVal x As Integer)
        Field = x
    End Sub
    Public Overloads Shared Widening Operator CType(ByVal x As Goo) As Bar
        Return New Bar(x.Field)
    End Operator
End Class
]]></file>
</compilation>
            Dim comp = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, XmlReferences, TestOptions.ReleaseExe)
            CompileAndVerify(comp,
            <![CDATA[
Static=VB$AnonymousType_0`1[System.Int32][], Runtime=VB$AnonymousType_0`1[System.Int32][]
Static=VB$AnonymousType_0`1[System.Int32][], Runtime x=VB$AnonymousType_0`1[System.Int32][], Runtime y=VB$AnonymousType_0`1[System.Int32][]
--------------
Static=System.Xml.Linq.XElement[], Runtime=System.Xml.Linq.XElement[]
Static=System.Xml.Linq.XElement[], Runtime x=System.Xml.Linq.XElement[], Runtime y=System.Xml.Linq.XElement[]
Static=System.String[], Runtime=System.String[]
Static=System.String[], Runtime x=System.String[], Runtime y=System.String[]
--------------
Static=Animal[], Runtime=Animal[]
Static=Animal[], Runtime=Animal[]
Static=Animal[], Runtime x=Animal[], Runtime y=Animal[]
--------------
Static=Goo[], Runtime=Goo[]
Static=Goo[], Runtime x=Goo[], Runtime y=Goo[]
======================

Static=VB$AnonymousType_0`1[System.Int32][], Runtime=VB$AnonymousType_0`1[System.Int32][]
Static=VB$AnonymousType_0`1[System.Int32][], Runtime x=VB$AnonymousType_0`1[System.Int32][], Runtime y=VB$AnonymousType_0`1[System.Int32][]
--------------
Static=VB$AnonymousType_0`1[System.Int32][], Runtime=VB$AnonymousType_0`1[System.Int32][]
Static=VB$AnonymousType_0`1[System.Int32][], Runtime x=VB$AnonymousType_0`1[System.Int32][], Runtime y=VB$AnonymousType_0`1[System.Int32][]
--------------
Static=VB$AnonymousType_0`1[System.Int32][], Runtime=VB$AnonymousType_0`1[System.Int32][]
Static=VB$AnonymousType_0`1[System.Int32][], Runtime x=VB$AnonymousType_0`1[System.Int32][], Runtime y=VB$AnonymousType_0`1[System.Int32][]
--------------
Static=System.Object[,], Runtime=System.Object[,]
Static=System.Object[,], Runtime x=System.Object[,], Runtime y=System.Object[,]
--------------
Static=System.Object[,], Runtime=System.Object[,]
Static=System.Object[,], Runtime x=System.Object[,], Runtime y=System.Object[,]
--------------
Static=System.Object[,], Runtime=Nothing
Static=System.Object[,], Runtime x=Nothing, Runtime y=System.Object[,]
--------------
Static=System.Object[,], Runtime=System.Object[,]
Static=System.Object[,], Runtime x=System.Object[,], Runtime y=Nothing
--------------
Static=System.Object[,], Runtime=Nothing
Static=System.Object[,], Runtime x=Nothing, Runtime y=System.Object[,]
--------------
Static=System.Object[,], Runtime=System.Object[,]
Static=System.Object[,], Runtime x=System.Object[,], Runtime y=Nothing
--------------
]]>)
        End Sub

        <WorkItem(796610, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/796610")>
        <Fact()>
        Public Sub Bug796610_2()
            Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
<compilation>
    <file name="a.vb"><![CDATA[
Module Program
    Sub Main(ByVal args As String())
        gooModules({"1"}, {})
    End Sub
    Public Sub gooModules(Of T)(ByVal ParamArray z As T())
        System.Console.WriteLine(GetType(T))
    End Sub
    Public Sub gooModules(ByVal ParamArray z As String())
    End Sub
End Module
    ]]></file>
</compilation>, TestOptions.ReleaseExe)

            CompileAndVerify(compilation, <![CDATA[System.String[]]]>)

            compilation = compilation.WithOptions(_strictOn)
            CompileAndVerify(compilation, <![CDATA[System.String[]]]>)
        End Sub

        <WorkItem(116, "https://github.com/dotnet/roslyn/issues/116")>
        <Fact()>
        Public Sub TestArrayLiteralSemanticModelImplicitConversion()
            Dim compilation = CreateCompilationWithMscorlib40(
 <compilation>
     <file name="a.vb"><![CDATA[
Imports System

Module Program
    Sub Main(args As String())
        Dim x As Integer() = {1, 2, 3} 'BIND:"{1, 2, 3}"
    End Sub
End Module
    ]]></file>
 </compilation>)

            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Null(semanticSummary.Type)
            Assert.Equal("System.Int32()", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(ConversionKind.Widening, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(CandidateReason.None, semanticSummary.CandidateReason)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)
        End Sub

        <WorkItem(799045, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/799045")>
        <Fact()>
        Public Sub TestArrayLiteralSemanticModelImplicitConversionParenthesized()
            Dim compilation = CreateCompilationWithMscorlib40(
 <compilation>
     <file name="a.vb"><![CDATA[
Imports System

Module Program
    Sub Main(args As String())
        Dim x As Integer() = ({1, 2, 3}) 'BIND:"{1, 2, 3}"
    End Sub
End Module
    ]]></file>
 </compilation>)

            Dim semanticSummary = CompilationUtils.GetSemanticInfoSummary(Of CollectionInitializerSyntax)(compilation, "a.vb")

            Assert.Null(semanticSummary.Type)
            Assert.Equal("System.Int32()", semanticSummary.ConvertedType.ToTestDisplayString())
            Assert.Equal(ConversionKind.Widening, semanticSummary.ImplicitConversion.Kind)

            Assert.Null(semanticSummary.Symbol)
            Assert.Equal(CandidateReason.None, semanticSummary.CandidateReason)
            Assert.Equal(0, semanticSummary.CandidateSymbols.Length)

            Assert.Null(semanticSummary.Alias)

            Assert.Equal(0, semanticSummary.MemberGroup.Length)

            Assert.False(semanticSummary.ConstantValue.HasValue)
        End Sub

    End Class
End Namespace


