|
' 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 Microsoft.CodeAnalysis.VisualBasic.Syntax
Imports Microsoft.CodeAnalysis.Test.Utilities
Imports Roslyn.Test.Utilities
Imports Basic.Reference.Assemblies
Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
Public Class MethodCalls
Inherits BasicTestBase
<Fact>
Public Sub NamedArguments()
Dim compilationDef =
<compilation name="VBNamedArguments1">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
TestOrder2(b:=TestOrder1(1), a:=TestOrder1(2))
TestOrder2(a:=TestOrder1(3), b:=TestOrder1(4))
TestOrder2(b:=TestOrder3("5"), a:=TestOrder1(6))
TestOrder2(b:=TestOrder1(7), a:=TestOrder3("8"))
TestOrder2(b:=TestOrder3("9"), a:=TestOrder3("10"))
TestOrder2(a:=TestOrder3("11"), b:=TestOrder3("12"))
End Sub
Sub TestOrder2(a As Integer, b As Integer)
System.Console.WriteLine("TestOrder2: {0}, {1}", a, b)
End Sub
Function TestOrder1(a As Integer) As Integer
System.Console.WriteLine("TestOrder1: {0}", a)
Return a
End Function
Function TestOrder3(a As String) As String
System.Console.WriteLine("TestOrder3: {0}", a)
Return a
End Function
End Module
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
TestOrder1: 2
TestOrder1: 1
TestOrder2: 2, 1
TestOrder1: 3
TestOrder1: 4
TestOrder2: 3, 4
TestOrder1: 6
TestOrder3: 5
TestOrder2: 6, 5
TestOrder3: 8
TestOrder1: 7
TestOrder2: 8, 7
TestOrder3: 10
TestOrder3: 9
TestOrder2: 10, 9
TestOrder3: 11
TestOrder3: 12
TestOrder2: 11, 12
]]>)
End Sub
<Fact>
Public Sub TrueByRefArguments1()
Dim compilationDef =
<compilation name="VBTrueByRefArguments1">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
Dim x As Integer = 1
Dim z As Integer() = New Integer() {0, 3}
System.Console.WriteLine("---")
TestByRef(x)
System.Console.WriteLine("Test1: {0}", x)
System.Console.WriteLine("---")
TestByRef(z(Return1()))
System.Console.WriteLine("Test3: {0}", z(1))
System.Console.WriteLine("---")
TestByRef(ReturnArray(z)(Return1()))
System.Console.WriteLine("Test4: {0}", z(1))
End Sub
Sub TestByRef(ByRef a As Integer)
a = a + 1
End Sub
Function ReturnArray(z As Integer()) As Integer()
System.Console.WriteLine("ReturnArray")
Return z
End Function
Function Return1() As Integer
System.Console.WriteLine("Return1")
Return 1
End Function
End Module
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
---
Test1: 2
---
Return1
Test3: 4
---
ReturnArray
Return1
Test4: 5
]]>)
End Sub
<Fact>
Public Sub ParamArray1()
Dim compilationDef =
<compilation name="VBParamArray1">
<file name="a.vb">
Imports System
Module Module1
Sub Main()
ParamArray1()
ParamArray1("a"c)
ParamArray1("a"c, "b"c)
ParamArray2(1)
ParamArray2(2, "a"c)
ParamArray2(3, "a"c, "b"c)
ParamArray2(a:=4)
End Sub
Sub ParamArray1(ParamArray a As Char())
System.Console.WriteLine("ParamArray1: [{0}]", CStr(a))
End Sub
Sub ParamArray2(a As Integer, ParamArray b As Char())
System.Console.WriteLine("ParamArray1: {0}, [{1}]", a, CStr(b))
End Sub
End Module
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
ParamArray1: []
ParamArray1: [a]
ParamArray1: [ab]
ParamArray1: 1, []
ParamArray1: 2, [a]
ParamArray1: 3, [ab]
ParamArray1: 4, []
]]>)
End Sub
<Fact>
Public Sub ByRefArguments2()
Dim compilationDef =
<compilation name="VBByRefArguments2">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Dim staticFld As Byte
ReadOnly staticReadonlyFld As Integer
Sub Main()
Dim z As Byte() = New Byte() {0, 81}
System.Console.WriteLine("---")
Test1()
System.Console.WriteLine("---")
System.Console.WriteLine(Test2())
System.Console.WriteLine("---")
Test2_1()
System.Console.WriteLine("---")
System.Console.WriteLine(Test3())
System.Console.WriteLine("---")
System.Console.WriteLine(Test3_1())
System.Console.WriteLine("---")
System.Console.WriteLine(Test3_2())
System.Console.WriteLine("---")
System.Console.WriteLine(Test4(51))
Dim By As Byte = 53
System.Console.WriteLine("---")
Test4_1(By)
System.Console.WriteLine(By)
System.Console.WriteLine("---")
staticFld = 61
Test5()
System.Console.WriteLine(staticFld)
Dim tc As TestClass = New TestClass()
System.Console.WriteLine("---")
tc.instanceFld = 63
Test5_1(tc)
System.Console.WriteLine(tc.instanceFld)
System.Console.WriteLine("---")
Test5_2()
System.Console.WriteLine("---")
Test5_3(tc)
Dim ts As TestStruct = New TestStruct()
ts.instanceFld = 65
System.Console.WriteLine("---")
Test5_4(ts)
System.Console.WriteLine(ts.instanceFld)
System.Console.WriteLine("---")
System.Console.WriteLine(Test5_5(ts))
System.Console.WriteLine("---")
Test5_6(ts)
System.Console.WriteLine("---")
Test5_7()
System.Console.WriteLine("---")
Test5_8()
System.Console.WriteLine("---")
Test5_9(tc)
System.Console.WriteLine(tc.instanceFld)
System.Console.WriteLine("---")
Test5_10()
System.Console.WriteLine("---")
Test6(z)
System.Console.WriteLine(z(1))
System.Console.WriteLine("---")
Test6_1(z)
System.Console.WriteLine(z(1))
ts.instanceFld = 91
Dim z1 As TestStruct() = New TestStruct() {Nothing, ts}
System.Console.WriteLine("---")
Test6_2(z1)
System.Console.WriteLine(z1(1).instanceFld)
System.Console.WriteLine("---")
Test6_3(z1)
System.Console.WriteLine(z1(1).instanceFld)
End Sub
Sub Test6(z As Byte())
TestByRef(z(1))
End Sub
Sub Test6_1(z As Byte())
TestByRef(ReturnArray(z)(1))
End Sub
Sub Test6_2(z As TestStruct())
TestByRef(z(Return1()).instanceFld)
End Sub
Sub Test6_3(z As TestStruct())
TestByRef(z(1).instanceFld)
End Sub
Sub Test1()
TestByRef(20)
End Sub
Function Test2() As Long
Dim x As Byte = 30
Return TestByRef2(CInt(x))
End Function
Sub Test2_1()
Dim x As Byte = 32
TestByRef2(CInt(x))
End Sub
Function Test3() As Byte
Dim x As Byte = 40
TestByRef(x)
Return x
End Function
Function Test3_1() As Long
Dim x As Byte = 42
Return TestByRef2(x) + x
End Function
Function Test3_2() As Byte
Dim x As Byte = 44
TestByRef2(x)
Return x
End Function
Function Test4(x As Byte) As Byte
TestByRef(x)
Return x
End Function
Sub Test4_1(ByRef x As Byte)
TestByRef(x)
End Sub
Sub Test5()
TestByRef(staticFld)
End Sub
Sub Test5_1(x As TestClass)
TestByRef(x.instanceFld)
End Sub
Sub Test5_2()
TestByRef(staticReadonlyFld)
End Sub
Sub Test5_3(x As TestClass)
TestByRef(x.instanceReadonlyFld)
End Sub
Sub Test5_4(ByRef x As TestStruct)
TestByRef(x.instanceFld)
End Sub
Function Test5_5(x As TestStruct) As Byte
TestByRef(x.instanceFld)
Return x.instanceFld
End Function
Sub Test5_6(x As TestStruct)
TestByRef(x.instanceReadonlyFld)
End Sub
Sub Test5_7()
TestByRef(ReturnInteger())
End Sub
Sub Test5_8()
TestByRef(ReturnTestStruct().instanceFld2)
End Sub
Sub Test5_9(x As TestClass)
TestByRef(ReturnTestClass(x).instanceFld)
End Sub
Sub Test5_10()
TestByRef(1)
End Sub
Function ReturnInteger() As Integer
Return 71
End Function
Function ReturnTestStruct() As TestStruct
Dim x As TestStruct = New TestStruct()
x.instanceFld2 = 73
Return x
End Function
Function ReturnTestClass(x As TestClass) As TestClass
Return x
End Function
Sub TestByRef(ByRef a As Integer)
System.Console.WriteLine("TestByRef: {0}", a)
a = a + 1
End Sub
Function TestByRef2(ByRef a As Integer) As Long
System.Console.WriteLine("TestByRef2: {0}", a)
a = a + 1
Return a
End Function
Function ReturnArray(z As Byte()) As Byte()
System.Console.WriteLine("ReturnArray")
Return z
End Function
Function Return1() As Integer
System.Console.WriteLine("Return1")
Return 1
End Function
End Module
Class TestClass
Public instanceFld As Byte
Public ReadOnly instanceReadonlyFld As Integer
End Class
Structure TestStruct
Public instanceFld As Byte
Public ReadOnly instanceReadonlyFld As Integer
Public instanceFld2 As Integer
Sub Test1()
TestByRef(Me.instanceFld)
End Sub
Sub Test2()
TestByRef(instanceFld)
End Sub
Sub Test3()
TestByRef(Me.instanceReadonlyFld)
End Sub
End Structure
</file>
</compilation>
Dim verifier = CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
---
TestByRef: 20
---
TestByRef2: 30
31
---
TestByRef2: 32
---
TestByRef: 40
41
---
TestByRef2: 42
86
---
TestByRef2: 44
45
---
TestByRef: 51
52
---
TestByRef: 53
54
---
TestByRef: 61
62
---
TestByRef: 63
64
---
TestByRef: 0
---
TestByRef: 0
---
TestByRef: 65
66
---
TestByRef: 66
67
---
TestByRef: 0
---
TestByRef: 71
---
TestByRef: 73
---
TestByRef: 64
65
---
TestByRef: 1
---
TestByRef: 81
82
---
ReturnArray
TestByRef: 82
83
---
Return1
TestByRef: 91
92
---
TestByRef: 92
93
]]>)
verifier.VerifyIL("Module1.Test1",
<![CDATA[
{
// Code size 11 (0xb)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.s 20
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000a: ret
}
]]>)
verifier.VerifyIL("Module1.Test2",
<![CDATA[
{
// Code size 11 (0xb)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.s 30
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Function Module1.TestByRef2(ByRef Integer) As Long"
IL_000a: ret
}
]]>)
verifier.VerifyIL("Module1.Test2_1",
<![CDATA[
{
// Code size 12 (0xc)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.s 32
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Function Module1.TestByRef2(ByRef Integer) As Long"
IL_000a: pop
IL_000b: ret
}
]]>)
verifier.VerifyIL("Module1.Test3",
<![CDATA[
{
// Code size 13 (0xd)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.s 40
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000a: ldloc.0
IL_000b: conv.ovf.u1
IL_000c: ret
}
]]>)
verifier.VerifyIL("Module1.Test3_1",
<![CDATA[
{
// Code size 19 (0x13)
.maxstack 2
.locals init (Byte V_0, //x
Integer V_1)
IL_0000: ldc.i4.s 42
IL_0002: stloc.0
IL_0003: ldloc.0
IL_0004: stloc.1
IL_0005: ldloca.s V_1
IL_0007: call "Function Module1.TestByRef2(ByRef Integer) As Long"
IL_000c: ldloc.1
IL_000d: conv.ovf.u1
IL_000e: stloc.0
IL_000f: ldloc.0
IL_0010: conv.u8
IL_0011: add.ovf
IL_0012: ret
}
]]>)
verifier.VerifyIL("Module1.Test3_2",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.s 44
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Function Module1.TestByRef2(ByRef Integer) As Long"
IL_000a: pop
IL_000b: ldloc.0
IL_000c: conv.ovf.u1
IL_000d: ret
}
]]>)
verifier.VerifyIL("Module1.Test4",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0009: ldloc.0
IL_000a: conv.ovf.u1
IL_000b: starg.s V_0
IL_000d: ldarg.0
IL_000e: ret
}
]]>)
verifier.VerifyIL("Module1.Test4_1",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldind.u1
IL_0002: stloc.0
IL_0003: ldloca.s V_0
IL_0005: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000a: ldarg.0
IL_000b: ldloc.0
IL_000c: conv.ovf.u1
IL_000d: stind.i1
IL_000e: ret
}
]]>)
verifier.VerifyIL("Module1.Test5",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldsfld "Module1.staticFld As Byte"
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ldloc.0
IL_000e: conv.ovf.u1
IL_000f: stsfld "Module1.staticFld As Byte"
IL_0014: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test5_1",
<![CDATA[
{
// Code size 25 (0x19)
.maxstack 2
.locals init (TestClass V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: stloc.0
IL_0003: ldfld "TestClass.instanceFld As Byte"
IL_0008: stloc.1
IL_0009: ldloca.s V_1
IL_000b: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0010: ldloc.0
IL_0011: ldloc.1
IL_0012: conv.ovf.u1
IL_0013: stfld "TestClass.instanceFld As Byte"
IL_0018: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test5_1",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestClass.instanceFld As Byte"
IL_0006: dup
IL_0007: ldind.u1
IL_0008: stloc.0
IL_0009: ldloca.s V_0
IL_000b: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0010: ldloc.0
IL_0011: conv.ovf.u1
IL_0012: stind.i1
IL_0013: ret
}
]]>)
#End If
verifier.VerifyIL("Module1.Test5_2",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldsfld "Module1.staticReadonlyFld As Integer"
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ret
}
]]>)
verifier.VerifyIL("Module1.Test5_3",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestClass.instanceReadonlyFld As Integer"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test5_4",
<![CDATA[
{
// Code size 23 (0x17)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestStruct.instanceFld As Byte"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ldarg.0
IL_000f: ldloc.0
IL_0010: conv.ovf.u1
IL_0011: stfld "TestStruct.instanceFld As Byte"
IL_0016: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test5_4",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct.instanceFld As Byte"
IL_0006: dup
IL_0007: ldind.u1
IL_0008: stloc.0
IL_0009: ldloca.s V_0
IL_000b: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0010: ldloc.0
IL_0011: conv.ovf.u1
IL_0012: stind.i1
IL_0013: ret
}
]]>)
#End If
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test5_5",
<![CDATA[
{
// Code size 34 (0x22)
.maxstack 2
.locals init (Byte V_0, //Test5_5
Integer V_1)
IL_0000: ldarga.s V_0
IL_0002: ldfld "TestStruct.instanceFld As Byte"
IL_0007: stloc.1
IL_0008: ldloca.s V_1
IL_000a: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000f: ldarga.s V_0
IL_0011: ldloc.1
IL_0012: conv.ovf.u1
IL_0013: stfld "TestStruct.instanceFld As Byte"
IL_0018: ldarga.s V_0
IL_001a: ldfld "TestStruct.instanceFld As Byte"
IL_001f: stloc.0
IL_0020: ldloc.0
IL_0021: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test5_5",
<![CDATA[
{
// Code size 27 (0x1b)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarga.s V_0
IL_0002: ldflda "TestStruct.instanceFld As Byte"
IL_0007: dup
IL_0008: ldind.u1
IL_0009: stloc.0
IL_000a: ldloca.s V_0
IL_000c: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0011: ldloc.0
IL_0012: conv.ovf.u1
IL_0013: stind.i1
IL_0014: ldarg.0
IL_0015: ldfld "TestStruct.instanceFld As Byte"
IL_001a: ret
}
]]>)
#End If
verifier.VerifyIL("Module1.Test5_6",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestStruct.instanceReadonlyFld As Integer"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ret
}
]]>)
verifier.VerifyIL("Module1.Test5_7",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 1
.locals init (Integer V_0)
IL_0000: call "Function Module1.ReturnInteger() As Integer"
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ret
}
]]>)
verifier.VerifyIL("Module1.Test5_8",
<![CDATA[
{
// Code size 19 (0x13)
.maxstack 1
.locals init (Integer V_0)
IL_0000: call "Function Module1.ReturnTestStruct() As TestStruct"
IL_0005: ldfld "TestStruct.instanceFld2 As Integer"
IL_000a: stloc.0
IL_000b: ldloca.s V_0
IL_000d: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0012: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test5_9",
<![CDATA[
{
// Code size 30 (0x1e)
.maxstack 2
.locals init (TestClass V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: call "Function Module1.ReturnTestClass(TestClass) As TestClass"
IL_0006: dup
IL_0007: stloc.0
IL_0008: ldfld "TestClass.instanceFld As Byte"
IL_000d: stloc.1
IL_000e: ldloca.s V_1
IL_0010: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0015: ldloc.0
IL_0016: ldloc.1
IL_0017: conv.ovf.u1
IL_0018: stfld "TestClass.instanceFld As Byte"
IL_001d: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test5_9",
<![CDATA[
{
// Code size 25 (0x19)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Function Module1.ReturnTestClass(TestClass) As TestClass"
IL_0006: ldflda "TestClass.instanceFld As Byte"
IL_000b: dup
IL_000c: ldind.u1
IL_000d: stloc.0
IL_000e: ldloca.s V_0
IL_0010: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0015: ldloc.0
IL_0016: conv.ovf.u1
IL_0017: stind.i1
IL_0018: ret
}
]]>)
#End If
verifier.VerifyIL("Module1.Test5_10",
<![CDATA[
{
// Code size 10 (0xa)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4.1
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0009: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("TestStruct.Test1",
<![CDATA[
{
// Code size 23 (0x17)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestStruct.instanceFld As Byte"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ldarg.0
IL_000f: ldloc.0
IL_0010: conv.ovf.u1
IL_0011: stfld "TestStruct.instanceFld As Byte"
IL_0016: ret
}
]]>)
#Else
verifier.VerifyIL("TestStruct.Test1",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct.instanceFld As Byte"
IL_0006: dup
IL_0007: ldind.u1
IL_0008: stloc.0
IL_0009: ldloca.s V_0
IL_000b: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0010: ldloc.0
IL_0011: conv.ovf.u1
IL_0012: stind.i1
IL_0013: ret
}
]]>)
#End If
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("TestStruct.Test2",
<![CDATA[
{
// Code size 23 (0x17)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestStruct.instanceFld As Byte"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ldarg.0
IL_000f: ldloc.0
IL_0010: conv.ovf.u1
IL_0011: stfld "TestStruct.instanceFld As Byte"
IL_0016: ret
}
]]>)
#Else
verifier.VerifyIL("TestStruct.Test2",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct.instanceFld As Byte"
IL_0006: dup
IL_0007: ldind.u1
IL_0008: stloc.0
IL_0009: ldloca.s V_0
IL_000b: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0010: ldloc.0
IL_0011: conv.ovf.u1
IL_0012: stind.i1
IL_0013: ret
}
]]>)
#End If
verifier.VerifyIL("TestStruct.Test3",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldfld "TestStruct.instanceReadonlyFld As Integer"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000e: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test6",
<![CDATA[
{
// Code size 19 (0x13)
.maxstack 3
.locals init (Byte() V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: stloc.0
IL_0003: ldc.i4.1
IL_0004: ldelem.u1
IL_0005: stloc.1
IL_0006: ldloca.s V_1
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ldloc.0
IL_000e: ldc.i4.1
IL_000f: ldloc.1
IL_0010: conv.ovf.u1
IL_0011: stelem.i1
IL_0012: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test6",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.1
IL_0002: ldelema "Byte"
IL_0007: dup
IL_0008: ldind.u1
IL_0009: stloc.0
IL_000a: ldloca.s V_0
IL_000c: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0011: ldloc.0
IL_0012: conv.ovf.u1
IL_0013: stind.i1
IL_0014: ret
}
]]>)
#End If
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test6_1",
<![CDATA[
{
// Code size 24 (0x18)
.maxstack 3
.locals init (Byte() V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: call "Function Module1.ReturnArray(Byte()) As Byte()"
IL_0006: dup
IL_0007: stloc.0
IL_0008: ldc.i4.1
IL_0009: ldelem.u1
IL_000a: stloc.1
IL_000b: ldloca.s V_1
IL_000d: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0012: ldloc.0
IL_0013: ldc.i4.1
IL_0014: ldloc.1
IL_0015: conv.ovf.u1
IL_0016: stelem.i1
IL_0017: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test6_1",
<![CDATA[
{
// Code size 26 (0x1a)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Function Module1.ReturnArray(Byte()) As Byte()"
IL_0006: ldc.i4.1
IL_0007: ldelema "Byte"
IL_000c: dup
IL_000d: ldind.u1
IL_000e: stloc.0
IL_000f: ldloca.s V_0
IL_0011: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0016: ldloc.0
IL_0017: conv.ovf.u1
IL_0018: stind.i1
IL_0019: ret
}
]]>)
#End If
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test6_2",
<![CDATA[
{
// Code size 43 (0x2b)
.maxstack 3
.locals init (TestStruct() V_0,
Integer V_1,
Integer V_2)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: stloc.0
IL_0003: call "Function Module1.Return1() As Integer"
IL_0008: dup
IL_0009: stloc.1
IL_000a: ldelema "TestStruct"
IL_000f: ldfld "TestStruct.instanceFld As Byte"
IL_0014: stloc.2
IL_0015: ldloca.s V_2
IL_0017: call "Sub Module1.TestByRef(ByRef Integer)"
IL_001c: ldloc.0
IL_001d: ldloc.1
IL_001e: ldelema "TestStruct"
IL_0023: ldloc.2
IL_0024: conv.ovf.u1
IL_0025: stfld "TestStruct.instanceFld As Byte"
IL_002a: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test6_2",
<![CDATA[
{
// Code size 30 (0x1e)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Function Module1.Return1() As Integer"
IL_0006: ldelema "TestStruct"
IL_000b: ldflda "TestStruct.instanceFld As Byte"
IL_0010: dup
IL_0011: ldind.u1
IL_0012: stloc.0
IL_0013: ldloca.s V_0
IL_0015: call "Sub Module1.TestByRef(ByRef Integer)"
IL_001a: ldloc.0
IL_001b: conv.ovf.u1
IL_001c: stind.i1
IL_001d: ret
}
]]>)
#End If
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test6_3",
<![CDATA[
{
// Code size 37 (0x25)
.maxstack 2
.locals init (TestStruct() V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: stloc.0
IL_0003: ldc.i4.1
IL_0004: ldelema "TestStruct"
IL_0009: ldfld "TestStruct.instanceFld As Byte"
IL_000e: stloc.1
IL_000f: ldloca.s V_1
IL_0011: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0016: ldloc.0
IL_0017: ldc.i4.1
IL_0018: ldelema "TestStruct"
IL_001d: ldloc.1
IL_001e: conv.ovf.u1
IL_001f: stfld "TestStruct.instanceFld As Byte"
IL_0024: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test6_3",
<![CDATA[
{
// Code size 26 (0x1a)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.1
IL_0002: ldelema "TestStruct"
IL_0007: ldflda "TestStruct.instanceFld As Byte"
IL_000c: dup
IL_000d: ldind.u1
IL_000e: stloc.0
IL_000f: ldloca.s V_0
IL_0011: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0016: ldloc.0
IL_0017: conv.ovf.u1
IL_0018: stind.i1
IL_0019: ret
}
]]>)
#End If
End Sub
' Same as ByRefArguments2 but with properties not fields.
<Fact>
Public Sub ByRefArguments2A()
Dim compilationDef =
<compilation name="VBByRefArguments2A">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Property staticFld As Byte
ReadOnly _staticReadonlyFld As Integer
ReadOnly Property staticReadonlyFld As Integer
Get
Return _staticReadonlyFld
End Get
End Property
Sub Main()
Dim z As Byte() = New Byte() {0, 81}
System.Console.WriteLine("---")
Test1()
System.Console.WriteLine("---")
System.Console.WriteLine(Test2())
System.Console.WriteLine("---")
Test2_1()
System.Console.WriteLine("---")
System.Console.WriteLine(Test3())
System.Console.WriteLine("---")
System.Console.WriteLine(Test3_1())
System.Console.WriteLine("---")
System.Console.WriteLine(Test3_2())
System.Console.WriteLine("---")
System.Console.WriteLine(Test4(51))
System.Console.WriteLine("---")
staticFld = 61
Test5()
System.Console.WriteLine(staticFld)
Dim tc As TestClass = New TestClass()
System.Console.WriteLine("---")
tc.instanceFld = 63
Test5_1(tc)
System.Console.WriteLine(tc.instanceFld)
System.Console.WriteLine("---")
Test5_2()
System.Console.WriteLine("---")
Test5_3(tc)
Dim ts As TestStruct = New TestStruct()
ts.instanceFld = 65
System.Console.WriteLine("---")
Test5_4(ts)
System.Console.WriteLine(ts.instanceFld)
System.Console.WriteLine("---")
System.Console.WriteLine(Test5_5(ts))
System.Console.WriteLine("---")
Test5_6(ts)
System.Console.WriteLine("---")
Test5_7()
System.Console.WriteLine("---")
Test5_8()
System.Console.WriteLine("---")
Test5_9(tc)
System.Console.WriteLine(tc.instanceFld)
System.Console.WriteLine("---")
Test5_10()
System.Console.WriteLine("---")
Test6(z)
System.Console.WriteLine(z(1))
System.Console.WriteLine("---")
Test6_1(z)
System.Console.WriteLine(z(1))
ts.instanceFld = 91
Dim z1 As TestStruct() = New TestStruct() {Nothing, ts}
System.Console.WriteLine("---")
Test6_2(z1)
System.Console.WriteLine(z1(1).instanceFld)
System.Console.WriteLine("---")
Test6_3(z1)
System.Console.WriteLine(z1(1).instanceFld)
End Sub
Sub Test6(z As Byte())
TestByRef(z(1))
End Sub
Sub Test6_1(z As Byte())
TestByRef(ReturnArray(z)(1))
End Sub
Sub Test6_2(z As TestStruct())
TestByRef(z(Return1()).instanceFld)
End Sub
Sub Test6_3(z As TestStruct())
TestByRef(z(1).instanceFld)
End Sub
Sub Test1()
TestByRef(20)
End Sub
Function Test2() As Long
Dim x As Byte = 30
Return TestByRef2(CInt(x))
End Function
Sub Test2_1()
Dim x As Byte = 32
TestByRef2(CInt(x))
End Sub
Function Test3() As Byte
Dim x As Byte = 40
TestByRef(x)
Return x
End Function
Function Test3_1() As Long
Dim x As Byte = 42
Return TestByRef2(x) + x
End Function
Function Test3_2() As Byte
Dim x As Byte = 44
TestByRef2(x)
Return x
End Function
Function Test4(x As Byte) As Byte
TestByRef(x)
Return x
End Function
Sub Test5()
TestByRef(staticFld)
End Sub
Sub Test5_1(x As TestClass)
TestByRef(x.instanceFld)
End Sub
Sub Test5_2()
TestByRef(staticReadonlyFld)
End Sub
Sub Test5_3(x As TestClass)
TestByRef(x.instanceReadonlyFld)
End Sub
Sub Test5_4(ByRef x As TestStruct)
TestByRef(x.instanceFld)
End Sub
Function Test5_5(x As TestStruct) As Byte
TestByRef(x.instanceFld)
Return x.instanceFld
End Function
Sub Test5_6(x As TestStruct)
TestByRef(x.instanceReadonlyFld)
End Sub
Sub Test5_7()
TestByRef(ReturnInteger())
End Sub
Sub Test5_8()
TestByRef(ReturnTestStruct().instanceFld2)
End Sub
Sub Test5_9(x As TestClass)
TestByRef(ReturnTestClass(x).instanceFld)
End Sub
Sub Test5_10()
TestByRef(1)
End Sub
Function ReturnInteger() As Integer
Return 71
End Function
Function ReturnTestStruct() As TestStruct
Dim x As TestStruct = New TestStruct()
x.instanceFld2 = 73
Return x
End Function
Function ReturnTestClass(x As TestClass) As TestClass
Return x
End Function
Sub TestByRef(ByRef a As Integer)
System.Console.WriteLine("TestByRef: {0}", a)
a = a + 1
End Sub
Function TestByRef2(ByRef a As Integer) As Long
System.Console.WriteLine("TestByRef2: {0}", a)
a = a + 1
Return a
End Function
Function ReturnArray(z As Byte()) As Byte()
System.Console.WriteLine("ReturnArray")
Return z
End Function
Function Return1() As Integer
System.Console.WriteLine("Return1")
Return 1
End Function
End Module
Class TestClass
Public Property instanceFld As Byte
Private ReadOnly _instanceReadonlyFld As Integer
Public ReadOnly Property instanceReadonlyFld As Integer
Get
Return _instanceReadonlyFld
End Get
End Property
End Class
Structure TestStruct
Public Property instanceFld As Byte
Private ReadOnly _instanceReadonlyFld As Integer
Public ReadOnly Property instanceReadonlyFld As Integer
Get
Return _instanceReadonlyFld
End Get
End Property
Public Property instanceFld2 As Integer
Sub Test1()
TestByRef(Me.instanceFld)
End Sub
Sub Test2()
TestByRef(instanceFld)
End Sub
Sub Test3()
TestByRef(Me.instanceReadonlyFld)
End Sub
End Structure
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
---
TestByRef: 20
---
TestByRef2: 30
31
---
TestByRef2: 32
---
TestByRef: 40
41
---
TestByRef2: 42
86
---
TestByRef2: 44
45
---
TestByRef: 51
52
---
TestByRef: 61
62
---
TestByRef: 63
64
---
TestByRef: 0
---
TestByRef: 0
---
TestByRef: 65
66
---
TestByRef: 66
67
---
TestByRef: 0
---
TestByRef: 71
---
TestByRef: 73
---
TestByRef: 64
65
---
TestByRef: 1
---
TestByRef: 81
82
---
ReturnArray
TestByRef: 82
83
---
Return1
TestByRef: 91
92
---
TestByRef: 92
93
]]>)
End Sub
<Fact>
Public Sub ByRefArguments3()
Dim compilationDef =
<compilation name="VBByRefArguments3">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
Dim By As Byte = 53
Dim Ob As Object
Ob = New TestClass(By)
System.Console.WriteLine(By)
Ob = New TestStructure(By)
System.Console.WriteLine(By)
End Sub
End Module
Class TestClass
Public Sub New(ByRef x As Integer)
x = x + 1
End Sub
End Class
Structure TestStructure
Public Sub New(ByRef x As Integer)
x = x + 1
End Sub
End Structure
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
54
55
]]>)
End Sub
<Fact>
Public Sub ByRefArguments4()
Dim compilationDef =
<compilation name="VBByRefArguments4">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
System.Console.WriteLine("---")
Test1()
System.Console.WriteLine("---")
System.Console.WriteLine(TestClass.baseStaticReadonlyFld)
System.Console.WriteLine(TestClass.staticReadonlyFld)
System.Console.WriteLine(TestClass.output)
System.Console.WriteLine("---")
Dim tc1 As TestClass = New TestClass()
System.Console.WriteLine(tc1.instanceReadonlyFld)
System.Console.WriteLine("---")
Dim tc2 As TestClass = New TestClass(tc1)
System.Console.WriteLine(tc1.instanceReadonlyFld)
System.Console.WriteLine(tc2.instanceReadonlyFld)
System.Console.WriteLine("---")
Dim tc3 As TestClass = New TestClass(tc1, tc2)
System.Console.WriteLine(TestClass.staticReadonlyFld)
System.Console.WriteLine("---")
Dim tc4 As TestClass = New TestClass(tc1, tc2, tc3)
System.Console.WriteLine(tc4.baseInstanceReadonlyFld)
System.Console.WriteLine("---")
Test2(tc1)
System.Console.WriteLine(TestClass.staticField)
System.Console.WriteLine("---")
Dim z As Byte() = New Byte() {0, 3}
'Dim z As Byte() = New Byte() {0, 1, 2, 3, 4}
Test3(z)
System.Console.WriteLine(z((1 + 1 * 2)/3))
End Sub
Sub Test1()
TestByRef(System.Int32.MinValue)
End Sub
Sub Test2(tc As TestClass)
TestByRef(tc.staticField)
End Sub
Sub Test3(z As Byte())
TestByRef(z((1 + 1 * 2)/3))
End Sub
Sub TestByRef(ByRef a As Integer)
System.Console.WriteLine("TestByRef: {0}", a)
a = a + 1
End Sub
End Module
Class Base
Public ReadOnly baseInstanceReadonlyFld As Integer
Public Shared ReadOnly baseStaticReadonlyFld As Integer
End Class
Class TestClass
Inherits Base
Public ReadOnly instanceReadonlyFld As Integer
Public Shared ReadOnly staticReadonlyFld As Integer
Public Shared output As Integer
Public Shared staticField As Byte
Sub New()
TestByRef(instanceReadonlyFld)
End Sub
Sub New(tc As TestClass)
TestByRef(tc.instanceReadonlyFld)
End Sub
Sub New(tc1 As TestClass, tc2 As TestClass)
TestByRef(Me.staticReadonlyFld)
End Sub
Sub New(tc1 As TestClass, tc2 As TestClass, tc3 As TestClass)
TestByRef(Me.baseInstanceReadonlyFld)
End Sub
Shared Sub New()
TestByRef(staticReadonlyFld)
TestByRef(baseStaticReadonlyFld)
Dim tc As TestClass = New TestClass()
TestByRef(tc.instanceReadonlyFld)
output = tc.instanceReadonlyFld
End Sub
End Class
</file>
</compilation>
Dim verifier = CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
---
TestByRef: -2147483648
---
0
TestByRef: 0
TestByRef: 0
TestByRef: 0
TestByRef: 1
1
1
---
TestByRef: 0
1
---
TestByRef: 1
1
0
---
TestByRef: 1
1
---
TestByRef: 0
0
---
TestByRef: 0
1
---
TestByRef: 3
4
]]>)
verifier.VerifyIL("Module1.Test1",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldc.i4 0x80000000
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ret
}
]]>)
verifier.VerifyIL("TestClass..ctor",
<![CDATA[
{
// Code size 18 (0x12)
.maxstack 1
IL_0000: ldarg.0
IL_0001: call "Sub Base..ctor()"
IL_0006: ldarg.0
IL_0007: ldflda "TestClass.instanceReadonlyFld As Integer"
IL_000c: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0011: ret
}
]]>)
verifier.VerifyIL("TestClass..ctor(TestClass)",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Sub Base..ctor()"
IL_0006: ldarg.1
IL_0007: ldfld "TestClass.instanceReadonlyFld As Integer"
IL_000c: stloc.0
IL_000d: ldloca.s V_0
IL_000f: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0014: ret
}
]]>)
verifier.VerifyIL("TestClass..ctor(TestClass, TestClass)",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Sub Base..ctor()"
IL_0006: ldsfld "TestClass.staticReadonlyFld As Integer"
IL_000b: stloc.0
IL_000c: ldloca.s V_0
IL_000e: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0013: ret
}
]]>)
verifier.VerifyIL("TestClass..ctor(TestClass, TestClass, TestClass)",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: call "Sub Base..ctor()"
IL_0006: ldarg.0
IL_0007: ldfld "Base.baseInstanceReadonlyFld As Integer"
IL_000c: stloc.0
IL_000d: ldloca.s V_0
IL_000f: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0014: ret
}
]]>)
verifier.VerifyIL("TestClass..cctor",
<![CDATA[
{
// Code size 53 (0x35)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldsflda "TestClass.staticReadonlyFld As Integer"
IL_0005: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000a: ldsfld "Base.baseStaticReadonlyFld As Integer"
IL_000f: stloc.0
IL_0010: ldloca.s V_0
IL_0012: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0017: newobj "Sub TestClass..ctor()"
IL_001c: dup
IL_001d: ldfld "TestClass.instanceReadonlyFld As Integer"
IL_0022: stloc.0
IL_0023: ldloca.s V_0
IL_0025: call "Sub Module1.TestByRef(ByRef Integer)"
IL_002a: ldfld "TestClass.instanceReadonlyFld As Integer"
IL_002f: stsfld "TestClass.output As Integer"
IL_0034: ret
}
]]>)
verifier.VerifyIL("Module1.Test2",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldsfld "TestClass.staticField As Byte"
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ldloc.0
IL_000e: conv.ovf.u1
IL_000f: stsfld "TestClass.staticField As Byte"
IL_0014: ret
}
]]>)
#If DONT_USE_BYREF_LOCALS_FOR_USE_TWICE Then
verifier.VerifyIL("Module1.Test3",
<![CDATA[
{
// Code size 19 (0x13)
.maxstack 3
.locals init (Byte() V_0,
Integer V_1)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: stloc.0
IL_0003: ldc.i4.1
IL_0004: ldelem.u1
IL_0005: stloc.1
IL_0006: ldloca.s V_1
IL_0008: call "Sub Module1.TestByRef(ByRef Integer)"
IL_000d: ldloc.0
IL_000e: ldc.i4.1
IL_000f: ldloc.1
IL_0010: conv.ovf.u1
IL_0011: stelem.i1
IL_0012: ret
}
]]>)
#Else
verifier.VerifyIL("Module1.Test3",
<![CDATA[
{
// Code size 21 (0x15)
.maxstack 2
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldc.i4.1
IL_0002: ldelema "Byte"
IL_0007: dup
IL_0008: ldind.u1
IL_0009: stloc.0
IL_000a: ldloca.s V_0
IL_000c: call "Sub Module1.TestByRef(ByRef Integer)"
IL_0011: ldloc.0
IL_0012: conv.ovf.u1
IL_0013: stind.i1
IL_0014: ret
}
]]>)
#End If
End Sub
<Fact>
Public Sub ByRefArguments5()
Dim compilationDef =
<compilation name="VBByRefArguments5">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
Dim s2 As TestStruct2 = New TestStruct2()
s2.fld2.fld1 = 1
System.Console.WriteLine((s2.fld2).Increment())
System.Console.WriteLine(s2.fld2.fld1)
System.Console.WriteLine((s2.fld2).Increment())
System.Console.WriteLine(s2.fld2.fld1)
System.Console.WriteLine((s2.fld2).Increment())
System.Console.WriteLine(s2.fld2.fld1)
System.Console.WriteLine("----")
System.Console.WriteLine(s2.fld2.fld1)
Test1(s2)
System.Console.WriteLine(s2.fld2.fld1)
Test2(s2)
System.Console.WriteLine(s2.fld2.fld1)
Test3(s2)
System.Console.WriteLine(s2.fld2.fld1)
Test4(s2)
System.Console.WriteLine(s2.fld2.fld1)
End Sub
Sub Test1(ByRef s2 As TestStruct2)
Increment(s2.fld2.fld1)
End Sub
Sub Test2(ByRef s2 As TestStruct2)
Increment((s2).fld2.fld1)
End Sub
Sub Test3(ByRef s2 As TestStruct2)
Increment((s2.fld2).fld1)
End Sub
Sub Test4(ByRef s2 As TestStruct2)
Increment((s2.fld2.fld1))
End Sub
Sub Increment(ByRef x As Integer)
x = x + 1
End Sub
End Module
Structure TestStruct1
Public fld1 As Integer
Function Increment() As Integer
fld1 = fld1 + 1
Return fld1
End Function
End Structure
Structure TestStruct2
Public fld2 As TestStruct1
End Structure
</file>
</compilation>
Dim verifier = CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
2
2
3
3
4
4
----
4
5
5
5
5
]]>)
verifier.VerifyIL("Module1.Test1",
<![CDATA[
{
// Code size 17 (0x11)
.maxstack 1
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct2.fld2 As TestStruct1"
IL_0006: ldflda "TestStruct1.fld1 As Integer"
IL_000b: call "Sub Module1.Increment(ByRef Integer)"
IL_0010: ret
}
]]>)
verifier.VerifyIL("Module1.Test2",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct2.fld2 As TestStruct1"
IL_0006: ldfld "TestStruct1.fld1 As Integer"
IL_000b: stloc.0
IL_000c: ldloca.s V_0
IL_000e: call "Sub Module1.Increment(ByRef Integer)"
IL_0013: ret
}
]]>)
verifier.VerifyIL("Module1.Test3",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct2.fld2 As TestStruct1"
IL_0006: ldfld "TestStruct1.fld1 As Integer"
IL_000b: stloc.0
IL_000c: ldloca.s V_0
IL_000e: call "Sub Module1.Increment(ByRef Integer)"
IL_0013: ret
}
]]>)
verifier.VerifyIL("Module1.Test4",
<![CDATA[
{
// Code size 20 (0x14)
.maxstack 1
.locals init (Integer V_0)
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct2.fld2 As TestStruct1"
IL_0006: ldfld "TestStruct1.fld1 As Integer"
IL_000b: stloc.0
IL_000c: ldloca.s V_0
IL_000e: call "Sub Module1.Increment(ByRef Integer)"
IL_0013: ret
}
]]>)
End Sub
<Fact()>
Public Sub ByRefArguments6()
Dim compilationDef =
<compilation name="LambdaTests1">
<file name="a.vb"><![CDATA[
Module Program
Sub Test1(ByRef x As Object)
x = -2
End Sub
Function Test2(Of T)(a As T(), i As Integer) As System.Action
Return Sub()
Test1(a(i))
End Sub
End Function
Sub Main()
Dim a = New Integer() {1, 2, 3}
Dim x As System.Action = Test2(a, 1)
x()
System.Console.WriteLine(a(1))
End Sub
End Module
]]></file>
</compilation>
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef, TestOptions.ReleaseExe)
Dim verifier = CompileAndVerify(compilation, expectedOutput:=
<![CDATA[
-2
]]>)
End Sub
<Fact>
Public Sub PassByRef()
Dim source =
<compilation>
<file name="c.vb">
Imports System
Class A
Public Sub New(i As Short)
FI = i
_PI = i
FB = New B(3)
_PB = New B(3)
FC = New C(4)
_PC = New C(4)
FT = New T(5)
_PT = New T(5)
End Sub
Public FI As Short
Private _PI As Short
Property PI As Short
Get
Console.WriteLine("A.get_PI")
Return _PI
End Get
Set(value As Short)
Console.WriteLine("A.set_PI")
_PI = value
End Set
End Property
Public FC As C
Private _PC As C
Property PC As C
Get
Console.WriteLine("A.get_PC")
Return _PC
End Get
Set(value As C)
Console.WriteLine("A.set_PC")
_PC = value
End Set
End Property
Public FT As T
Private _PT As T
Property PT As T
Get
Console.WriteLine("A.get_PT")
Return _PT
End Get
Set(value As T)
Console.WriteLine("A.set_PT")
_PT = value
End Set
End Property
Public FB As B
Private _PB As B
Property PB As B
Get
Console.WriteLine("A.get_PB")
Return _PB
End Get
Set(value As B)
Console.WriteLine("A.set_PB")
_PB = value
End Set
End Property
End Class
Class B
Public Sub New(i As Short)
FI = i
_PI = i
FC = New C(5)
_PC = New C(5)
End Sub
Public FI As Short
Private _PI As Short
Property PI As Short
Get
Console.WriteLine("B.get_PI")
Return _PI
End Get
Set(value As Short)
Console.WriteLine("B.set_PI")
_PI = value
End Set
End Property
Public FC As C
Private _PC As C
Property PC As C
Get
Console.WriteLine("B.get_PC")
Return _PC
End Get
Set(value As C)
Console.WriteLine("B.set_PC")
_PC = value
End Set
End Property
End Class
Structure S
Public Sub New(i As Short)
FI = i
_PI = i
FA = New A(2)
_PA = New A(2)
FC = New C(3)
_PC = New C(3)
FT = New T(4)
_PT = New T(4)
End Sub
Public FI As Short
Private _PI As Short
Property PI As Short
Get
Console.WriteLine("S.get_PI")
Return _PI
End Get
Set(value As Short)
Console.WriteLine("S.set_PI")
_PI = value
End Set
End Property
Public FC As C
Private _PC As C
Property PC As C
Get
Console.WriteLine("S.get_PC")
Return _PC
End Get
Set(value As C)
Console.WriteLine("S.set_PC")
_PC = value
End Set
End Property
Public FT As T
Private _PT As T
Property PT As T
Get
Console.WriteLine("S.get_PT")
Return _PT
End Get
Set(value As T)
Console.WriteLine("S.set_PT")
_PT = value
End Set
End Property
Public FA As A
Private _PA As A
Property PA As A
Get
Console.WriteLine("S.get_PA")
Return _PA
End Get
Set(value As A)
Console.WriteLine("S.set_PA")
_PA = value
End Set
End Property
End Structure
Structure T
Public Sub New(i As Short)
FI = i
_PI = i
FC = New C(6)
_PC = New C(6)
End Sub
Public FI As Short
Private _PI As Short
Property PI As Short
Get
Console.WriteLine("T.get_PI")
Return _PI
End Get
Set(value As Short)
Console.WriteLine("T.set_PI")
_PI = value
End Set
End Property
Public FC As C
Private _PC As C
Property PC As C
Get
Console.WriteLine("T.get_PC")
Return _PC
End Get
Set(value As C)
Console.WriteLine("T.set_PC")
_PC = value
End Set
End Property
End Structure
Class C
Public N As Short
Public Sub New(i As Short)
N = i
End Sub
Public Overrides Function ToString() As String
Return N.ToString()
End Function
End Class
Class Prog
Shared Sub Report(i As Integer)
Console.WriteLine("=> {0}", i)
End Sub
Shared Sub Report(i As C)
Console.WriteLine("=> {0}", i)
End Sub
Shared Sub M(ByRef i As Integer)
Console.WriteLine("M")
i = i + 1
End Sub
Shared Sub M(ByRef i As C)
Console.WriteLine("M")
i = New C(i.N + 1)
End Sub
Shared Sub Main()
Dim x As A = New A(7)
' Value type members on class.
M(x.FI)
Report(x.FI)
M(x.PI)
Report(x.PI)
' Reference type members on class.
M(x.FC)
Report(x.FC)
M(x.PC)
Report(x.PC)
' Value type members on nested class.
M(x.FB.FI)
Report(x.FB.FI)
M(x.FB.PI)
Report(x.FB.PI)
M(x.PB.FI)
Report(x.PB.FI)
M(x.PB.PI)
Report(x.PB.PI)
' Reference type members on nested class.
M(x.FB.FC)
Report(x.FB.FC)
M(x.FB.PC)
Report(x.FB.PC)
M(x.PB.FC)
Report(x.PB.FC)
M(x.PB.PC)
Report(x.PB.PC)
' Value type members on nested struct.
M(x.FT.FI)
Report(x.FT.FI)
M(x.FT.PI)
Report(x.FT.PI)
M(x.PT.FI)
Report(x.PT.FI)
M(x.PT.PI)
Report(x.PT.PI)
' Reference type members on nested struct.
M(x.FT.FC)
Report(x.FT.FC)
M(x.FT.PC)
Report(x.FT.PC)
M(x.PT.FC)
Report(x.PT.FC)
M(x.PT.PC)
Report(x.PT.PC)
Dim y As S = New S(9)
' Value type members on class.
M(y.FI)
Report(y.FI)
M(y.PI)
Report(y.PI)
' Reference type members on class.
M(y.FC)
Report(y.FC)
M(y.PC)
Report(y.PC)
' Value type members on nested class.
M(y.FA.FI)
Report(y.FA.FI)
M(y.FA.PI)
Report(y.FA.PI)
M(y.PA.FI)
Report(y.PA.FI)
M(y.PA.PI)
Report(y.PA.PI)
' Reference type members on nested class.
M(y.FA.FC)
Report(y.FA.FC)
M(y.FA.PC)
Report(y.FA.PC)
M(y.PA.FC)
Report(y.PA.FC)
M(y.PA.PC)
Report(y.PA.PC)
' Value type members on nested struct.
M(y.FT.FI)
Report(y.FT.FI)
M(y.FT.PI)
Report(y.FT.PI)
M(y.PT.FI)
Report(y.PT.FI)
M(y.PT.PI)
Report(y.PT.PI)
' Reference type members on nested struct.
M(y.FT.FC)
Report(y.FT.FC)
M(y.FT.PC)
Report(y.FT.PC)
M(y.PT.FC)
Report(y.PT.FC)
M(y.PT.PC)
Report(y.PT.PC)
End Sub
End Class
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source, expectedOutput:=
<![CDATA[M
=> 8
A.get_PI
M
A.set_PI
A.get_PI
=> 8
M
=> 5
A.get_PC
M
A.set_PC
A.get_PC
=> 5
M
=> 4
B.get_PI
M
B.set_PI
B.get_PI
=> 4
A.get_PB
M
A.get_PB
=> 4
A.get_PB
B.get_PI
M
B.set_PI
A.get_PB
B.get_PI
=> 4
M
=> 6
B.get_PC
M
B.set_PC
B.get_PC
=> 6
A.get_PB
M
A.get_PB
=> 6
A.get_PB
B.get_PC
M
B.set_PC
A.get_PB
B.get_PC
=> 6
M
=> 6
T.get_PI
M
T.set_PI
T.get_PI
=> 6
A.get_PT
M
A.get_PT
=> 5
A.get_PT
T.get_PI
M
T.set_PI
A.get_PT
T.get_PI
=> 5
M
=> 7
T.get_PC
M
T.set_PC
T.get_PC
=> 7
A.get_PT
M
A.get_PT
=> 6
A.get_PT
T.get_PC
M
T.set_PC
A.get_PT
T.get_PC
=> 6
M
=> 10
S.get_PI
M
S.set_PI
S.get_PI
=> 10
M
=> 4
S.get_PC
M
S.set_PC
S.get_PC
=> 4
M
=> 3
A.get_PI
M
A.set_PI
A.get_PI
=> 3
S.get_PA
M
S.get_PA
=> 3
S.get_PA
A.get_PI
M
A.set_PI
S.get_PA
A.get_PI
=> 3
M
=> 5
A.get_PC
M
A.set_PC
A.get_PC
=> 5
S.get_PA
M
S.get_PA
=> 5
S.get_PA
A.get_PC
M
A.set_PC
S.get_PA
A.get_PC
=> 5
M
=> 5
T.get_PI
M
T.set_PI
T.get_PI
=> 5
S.get_PT
M
S.get_PT
=> 4
S.get_PT
T.get_PI
M
T.set_PI
S.get_PT
T.get_PI
=> 4
M
=> 7
T.get_PC
M
T.set_PC
T.get_PC
=> 7
S.get_PT
M
S.get_PT
=> 6
S.get_PT
T.get_PC
M
T.set_PC
S.get_PT
T.get_PC
=> 6
]]>)
End Sub
' Instance expressions used to reference
' statics should be skipped.
<Fact>
Public Sub PassByRefStaticFromInstance()
Dim source =
<compilation>
<file name="c.vb">
Imports System
Class A
Public N As Short
Public Sub New(i As Short)
N = i
End Sub
Public Overrides Function ToString() As String
Return N.ToString()
End Function
End Class
Class B
Public Shared FI As Short = 1
Public Shared _PI As Short = 4
Shared Property PI As Short
Get
Console.WriteLine("get_PI")
Return _PI
End Get
Set(value As Short)
Console.WriteLine("set_PI")
_PI = value
End Set
End Property
Public Shared FC As A = New A(7)
Public Shared _PC As A = New A(10)
Shared Property PC As A
Get
Console.WriteLine("get_PC")
Return _PC
End Get
Set(value As A)
Console.WriteLine("set_PC")
_PC = value
End Set
End Property
Public Function G() As B
Console.WriteLine("G")
Return Me
End Function
End Class
Class Prog
Shared Function F() As B
Console.WriteLine("F")
Return Nothing
End Function
Shared Sub Report(i As Integer)
Console.WriteLine("=> {0}", i)
End Sub
Shared Sub Report(i As A)
Console.WriteLine("=> {0}", i)
End Sub
Shared Sub M(ByRef i As Integer)
Console.WriteLine("M")
i = i + 1
End Sub
Shared Sub M(ByRef i As A)
Console.WriteLine("M")
i = New A(i.N + 1)
End Sub
Shared Sub Main()
Dim x As B = New B()
M(x.G().FI)
Report(B.FI)
M(x.G().PI)
Report(B._PI)
M(F().FC)
Report(B.FC)
M(F().PC)
Report(B._PC)
End Sub
End Class
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source, expectedOutput:=
<![CDATA[M
=> 2
get_PI
M
set_PI
=> 5
M
=> 8
get_PC
M
set_PC
=> 11
]]>)
End Sub
<Fact>
Public Sub PassByRefArgs()
Dim source =
<compilation>
<file name="c.vb">
Imports System
Class Value
Private Shared _n As Integer = 0
Shared Function [Next]()
_n = _n + 1
Return _n
End Function
End Class
Class C
Private Shared _P
Shared Property P(x As Object)
Get
Console.WriteLine("P({0}) (= {1})", x, _P)
Return _P
End Get
Set(value)
Console.WriteLine("P({0}) = {1}", x, value)
_P = value
End Set
End Property
Shared Sub Main()
_P = Value.Next()
F(C.P(F(C.P(Value.Next()))))
End Sub
Shared Function F(ByRef o)
Console.WriteLine("F({0})", o)
o = Value.Next()
Return o
End Function
End Class
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source, expectedOutput:=
<![CDATA[P(2) (= 1)
F(1)
P(2) = 3
P(3) (= 3)
F(3)
P(3) = 4
]]>)
compilationVerifier.VerifyIL("C.Main",
<![CDATA[
{
// Code size 104 (0x68)
.maxstack 3
.locals init (Object V_0,
Object V_1,
Object V_2)
IL_0000: call "Function Value.Next() As Object"
IL_0005: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_000a: stsfld "C._P As Object"
IL_000f: call "Function Value.Next() As Object"
IL_0014: dup
IL_0015: stloc.1
IL_0016: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_001b: call "Function C.get_P(Object) As Object"
IL_0020: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_0025: stloc.2
IL_0026: ldloca.s V_2
IL_0028: call "Function C.F(ByRef Object) As Object"
IL_002d: ldloc.1
IL_002e: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_0033: ldloc.2
IL_0034: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_0039: call "Sub C.set_P(Object, Object)"
IL_003e: dup
IL_003f: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_0044: call "Function C.get_P(Object) As Object"
IL_0049: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_004e: stloc.0
IL_004f: ldloca.s V_0
IL_0051: call "Function C.F(ByRef Object) As Object"
IL_0056: pop
IL_0057: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_005c: ldloc.0
IL_005d: call "Function System.Runtime.CompilerServices.RuntimeHelpers.GetObjectValue(Object) As Object"
IL_0062: call "Sub C.set_P(Object, Object)"
IL_0067: ret
}
]]>)
End Sub
<Fact>
Public Sub CopyBackDiagnostic1()
Dim compilationDef =
<compilation name="VBCopyBackDiagnostic1">
<file name="a.vb">
Module Module1
Sub Main()
Dim By As Byte = 53
TestByRef(By)
End Sub
Sub TestByRef(ByRef a As Integer)
End Sub
End Module
</file>
</compilation>
CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
compilationDef,
New VisualBasicCompilationOptions(OutputKind.ConsoleApplication).WithOptionStrict(OptionStrict.Custom)).
VerifyDiagnostics(Diagnostic(ERRID.WRN_ImplicitConversionCopyBack, "By").WithArguments("a", "Integer", "Byte"))
End Sub
<Fact>
Public Sub Bug4275()
Dim compilationDef =
<compilation name="Bug4275">
<file name="a.vb">
Module M
Sub Goo()
End Sub
Sub Bar(Of T)()
End Sub
Function Goo1() As Integer
Return 0
End Function
Sub Main()
Goo$()
Goo$
M.Goo$()
M.Goo$
Bar%(Of Integer)()
Bar$(Of Integer)
Dim x As Object
x=Goo1$
End Sub
End Module
</file>
</compilation>
CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(compilationDef).
VerifyDiagnostics(
Diagnostic(ERRID.ERR_TypecharNoMatch2, "Goo$()").WithArguments("$", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "Goo$").WithArguments("$", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "M.Goo$()").WithArguments("$", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "M.Goo$").WithArguments("$", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "Bar%(Of Integer)()").WithArguments("%", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "Bar$(Of Integer)").WithArguments("$", "Void"),
Diagnostic(ERRID.ERR_TypecharNoMatch2, "Goo1$").WithArguments("$", "Integer"))
End Sub
<Fact>
Public Sub CallGenericMethod()
Dim compilationDef =
<compilation name="CallGenericMethod">
<file name="a.vb">
Module M
Sub Bar(Of T)(x as T)
System.Console.WriteLine(x)
End Sub
Sub Main()
Bar(Of Integer)("1234")
End Sub
End Module
</file>
</compilation>
CompileAndVerify(compilationDef, expectedOutput:="1234")
End Sub
<Fact>
Public Sub ConstructorCallDiagnostic()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="ConstructorCallDiagnostic">
<file name="a.vb">
Module Module1
Sub Main()
Dim z1 = New TC1()
Dim z2 = New TC1(1, 2, 3)
End Sub
End Module
Class TC1
Sub New(x As Integer)
End Sub
Sub New(x As Integer, y As Double)
End Sub
End Class
</file>
</compilation>)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30516: Overload resolution failed because no accessible 'New' accepts this number of arguments.
Dim z1 = New TC1()
~~~
BC30516: Overload resolution failed because no accessible 'New' accepts this number of arguments.
Dim z2 = New TC1(1, 2, 3)
~~~
</expected>)
End Sub
<WorkItem(539691, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/539691")>
<Fact>
Public Sub DiagnosticsOnInvalidConstructorCall()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="DiagnosticsOnInvalidConstructorCall">
<file name="a.vb">
class C
sub Goo()
dim x = new C(4,5,6)
end sub
end class
</file>
</compilation>)
Dim tree As SyntaxTree = (From t In compilation.SyntaxTrees Where t.FilePath = "a.vb").Single()
Dim semanticModel = compilation.GetSemanticModel(tree)
Dim objectCreationNode = tree.FindNodeOrTokenByKind(SyntaxKind.ObjectCreationExpression)
Dim semanticInfo = semanticModel.GetSemanticInfoSummary(CType(objectCreationNode, ExpressionSyntax))
Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticInfo.CandidateReason)
End Sub
<Fact>
Public Sub ByRefParamArraysFromMetadata()
Dim source =
<compilation name="ByRefParamArraysFromMetadata">
<file name="a.vb">
Imports System
Module M
Sub Main()
Test(Nothing)
End Sub
Sub Test(d0 As DelegateByRefParamArray_Base())
Dim d1 As DelegateByRefParamArray_Base() = Nothing
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1(d0)
Console.WriteLine(d0 Is Nothing)
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1(d1)
Console.WriteLine(d1 Is Nothing)
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1(_d2)
Console.WriteLine(_d2 Is Nothing)
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1(d2)
Console.WriteLine(d2 Is Nothing)
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1((d2))
Console.WriteLine(d2 Is Nothing)
Dim d3()() As DelegateByRefParamArray_Base = New DelegateByRefParamArray_Base()() {Nothing}
DelegateByRefParamArray.SubWithByRefParamArrayOfReferenceTypes_Identify_1(d3(0))
Console.WriteLine(d3(0) Is Nothing)
End Sub
Dim _d2 As DelegateByRefParamArray_Base() = Nothing
Property d2 As DelegateByRefParamArray_Base()
Get
Return _d2
End Get
Set(value As DelegateByRefParamArray_Base())
System.Console.WriteLine("d2.Set")
_d2 = value
End Set
End Property
End Module
</file>
</compilation>
Dim assemblyPath = TestReferences.SymbolsTests.DelegateImplementation.DelegateByRefParamArray
CompileAndVerify(source,
references:={assemblyPath},
expectedOutput:=<![CDATA[
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
Called SubWithByRefParamArrayOfReferenceTypes_Identify_1.
True
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties1()
Dim source =
<compilation name="ByRefParametersOnProperties1">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
DoTest(129)
End Sub
Sub DoTest(y6 As Integer)
Dim x As New PropertiesWithByRef()
Dim y1 As Integer = 123
Dim y2 As Byte = 124
Dim z As Integer
z = x.P1(y1)
System.Console.WriteLine(y1)
x.P1(y1) = z + 1
System.Console.WriteLine(y1)
z = x.P1(y2)
System.Console.WriteLine(y2)
x.P1(y2) = z + 1
System.Console.WriteLine(y2)
y3 = 125
z = x.P1(y3)
System.Console.WriteLine(y3)
x.P1(y3) = z + 1
System.Console.WriteLine(y3)
y4 = 126
z = x.P1(y4)
System.Console.WriteLine(y4)
x.P1(y4) = z + 1
System.Console.WriteLine(y4)
Dim t As New Test1()
t.y5 = 127
z = x.P1(t.y5)
System.Console.WriteLine(t.y5)
x.P1(t.y5) = z + 1
System.Console.WriteLine(t.y5)
Dim ar As Integer() = New Integer() {128}
z = x.P1(ar(0))
System.Console.WriteLine(ar(0))
x.P1(ar(0)) = z + 1
System.Console.WriteLine(ar(0))
z = x.P1(y6)
System.Console.WriteLine(y6)
x.P1(y6) = z + 1
System.Console.WriteLine(y6)
End Sub
Private _y3 As Integer
Property y3 As Integer
Get
System.Console.WriteLine("Executing get_y3")
Return _y3
End Get
Set(value As Integer)
System.Console.WriteLine("Executing set_y3")
_y3 = value
End Set
End Property
Private y4 As Integer
End Module
Class Test1
Public y5 As Integer
End Class
</file>
</compilation>
CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(123)
123
set_P1(123)
123
get_P1(124)
124
set_P1(124)
124
Executing set_y3
Executing get_y3
get_P1(125)
Executing get_y3
125
Executing get_y3
set_P1(125)
Executing get_y3
125
get_P1(126)
126
set_P1(126)
126
get_P1(127)
127
set_P1(127)
127
get_P1(128)
128
set_P1(128)
128
get_P1(129)
129
set_P1(129)
129
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties2()
Dim source =
<compilation name="ByRefParametersOnProperties2">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
Dim ar As Integer() = New Integer() {1}
DoTest(x, ar)
System.Console.WriteLine(ar(0))
End Sub
Sub DoTest(x As PropertiesWithByRef, ar As Integer())
PassByRef(x.P1(ar(0)), ar)
End Sub
Sub PassByRef(ByRef x As Integer, ar As Integer())
System.Console.WriteLine("PassByRef: {0}, {1}.", x, ar(0))
End Sub
End Module
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(1)
PassByRef: 2, 1.
set_P1(1)
1
]]>)
compilationVerifier.VerifyIL("Module1.DoTest",
<![CDATA[
{
// Code size 35 (0x23)
.maxstack 4
.locals init (Integer V_0,
Integer V_1,
Integer V_2)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: ldarg.1
IL_0003: ldc.i4.0
IL_0004: ldelem.i4
IL_0005: dup
IL_0006: stloc.0
IL_0007: stloc.2
IL_0008: ldloca.s V_2
IL_000a: callvirt "Function PropertiesWithByRef.get_P1(ByRef Integer) As Integer"
IL_000f: stloc.1
IL_0010: ldloca.s V_1
IL_0012: ldarg.1
IL_0013: call "Sub Module1.PassByRef(ByRef Integer, Integer())"
IL_0018: ldloc.0
IL_0019: stloc.2
IL_001a: ldloca.s V_2
IL_001c: ldloc.1
IL_001d: callvirt "Sub PropertiesWithByRef.set_P1(ByRef Integer, Integer)"
IL_0022: ret
}
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties3()
Dim source =
<compilation name="ByRefParametersOnProperties3">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
Dim y As Integer = 1
System.Console.WriteLine(DoTest(x, y))
End Sub
Function DoTest(x As PropertiesWithByRef, y As Integer) As Integer
PassByRef(x.P1(y), y)
Return y
End Function
Sub PassByRef(ByRef x As Integer, y As Integer)
System.Console.WriteLine("PassByRef: {0}, {1}.", x, y)
End Sub
End Module
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(1)
PassByRef: 2, 1.
set_P1(1)
1
]]>)
compilationVerifier.VerifyIL("Module1.DoTest",
<![CDATA[
{
// Code size 34 (0x22)
.maxstack 4
.locals init (Integer V_0,
Integer V_1,
Integer V_2)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: ldarg.1
IL_0003: dup
IL_0004: stloc.0
IL_0005: stloc.2
IL_0006: ldloca.s V_2
IL_0008: callvirt "Function PropertiesWithByRef.get_P1(ByRef Integer) As Integer"
IL_000d: stloc.1
IL_000e: ldloca.s V_1
IL_0010: ldarg.1
IL_0011: call "Sub Module1.PassByRef(ByRef Integer, Integer)"
IL_0016: ldloc.0
IL_0017: stloc.2
IL_0018: ldloca.s V_2
IL_001a: ldloc.1
IL_001b: callvirt "Sub PropertiesWithByRef.set_P1(ByRef Integer, Integer)"
IL_0020: ldarg.1
IL_0021: ret
}
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties4()
Dim source =
<compilation name="ByRefParametersOnProperties4">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
System.Console.WriteLine(DoTest(x))
End Sub
Function DoTest(x As PropertiesWithByRef) As Integer
Dim y As Integer = 1
PassByRef(x.P1(y), y)
Return y
End Function
Sub PassByRef(ByRef x As Integer, y As Integer)
System.Console.WriteLine("PassByRef: {0}, {1}.", x, y)
End Sub
End Module
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(1)
PassByRef: 2, 1.
set_P1(1)
1
]]>)
compilationVerifier.VerifyIL("Module1.DoTest",
<![CDATA[
{
// Code size 36 (0x24)
.maxstack 4
.locals init (Integer V_0, //y
Integer V_1,
Integer V_2,
Integer V_3)
IL_0000: ldc.i4.1
IL_0001: stloc.0
IL_0002: ldarg.0
IL_0003: dup
IL_0004: ldloc.0
IL_0005: dup
IL_0006: stloc.1
IL_0007: stloc.3
IL_0008: ldloca.s V_3
IL_000a: callvirt "Function PropertiesWithByRef.get_P1(ByRef Integer) As Integer"
IL_000f: stloc.2
IL_0010: ldloca.s V_2
IL_0012: ldloc.0
IL_0013: call "Sub Module1.PassByRef(ByRef Integer, Integer)"
IL_0018: ldloc.1
IL_0019: stloc.3
IL_001a: ldloca.s V_3
IL_001c: ldloc.2
IL_001d: callvirt "Sub PropertiesWithByRef.set_P1(ByRef Integer, Integer)"
IL_0022: ldloc.0
IL_0023: ret
}
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties5()
Dim source =
<compilation name="ByRefParametersOnProperties5">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
DoTest(x)
System.Console.WriteLine(y)
End Sub
Dim y As Integer = 1
Sub DoTest(x As PropertiesWithByRef)
PassByRef(x.P1(y), y)
End Sub
Sub PassByRef(ByRef x As Integer, y As Integer)
System.Console.WriteLine("PassByRef: {0}, {1}.", x, y)
End Sub
End Module
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(1)
PassByRef: 2, 1.
set_P1(1)
1
]]>)
compilationVerifier.VerifyIL("Module1.DoTest",
<![CDATA[
{
// Code size 41 (0x29)
.maxstack 4
.locals init (Integer V_0,
Integer V_1,
Integer V_2)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: ldsfld "Module1.y As Integer"
IL_0007: dup
IL_0008: stloc.0
IL_0009: stloc.2
IL_000a: ldloca.s V_2
IL_000c: callvirt "Function PropertiesWithByRef.get_P1(ByRef Integer) As Integer"
IL_0011: stloc.1
IL_0012: ldloca.s V_1
IL_0014: ldsfld "Module1.y As Integer"
IL_0019: call "Sub Module1.PassByRef(ByRef Integer, Integer)"
IL_001e: ldloc.0
IL_001f: stloc.2
IL_0020: ldloca.s V_2
IL_0022: ldloc.1
IL_0023: callvirt "Sub PropertiesWithByRef.set_P1(ByRef Integer, Integer)"
IL_0028: ret
}
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties6()
Dim source =
<compilation name="ByRefParametersOnProperties6">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
s.y = 1
DoTest(x)
System.Console.WriteLine(s.y)
End Sub
Dim s As S1
Sub DoTest(x As PropertiesWithByRef)
PassByRef(x.P1(s.y), s.y)
End Sub
Sub PassByRef(ByRef x As Integer, y As Integer)
System.Console.WriteLine("PassByRef: {0}, {1}.", x, y)
End Sub
Structure S1
Public y As Integer
End Structure
End Module
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(1)
PassByRef: 2, 1.
set_P1(1)
1
]]>)
compilationVerifier.VerifyIL("Module1.DoTest",
<![CDATA[
{
// Code size 51 (0x33)
.maxstack 4
.locals init (Integer V_0,
Integer V_1,
Integer V_2)
IL_0000: ldarg.0
IL_0001: dup
IL_0002: ldsflda "Module1.s As Module1.S1"
IL_0007: ldfld "Module1.S1.y As Integer"
IL_000c: dup
IL_000d: stloc.0
IL_000e: stloc.2
IL_000f: ldloca.s V_2
IL_0011: callvirt "Function PropertiesWithByRef.get_P1(ByRef Integer) As Integer"
IL_0016: stloc.1
IL_0017: ldloca.s V_1
IL_0019: ldsflda "Module1.s As Module1.S1"
IL_001e: ldfld "Module1.S1.y As Integer"
IL_0023: call "Sub Module1.PassByRef(ByRef Integer, Integer)"
IL_0028: ldloc.0
IL_0029: stloc.2
IL_002a: ldloca.s V_2
IL_002c: ldloc.1
IL_002d: callvirt "Sub PropertiesWithByRef.set_P1(ByRef Integer, Integer)"
IL_0032: ret
}
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnProperties7()
Dim source =
<compilation name="ByRefParametersOnProperties7">
<file name="a.vb">
Option Strict Off
Module Module1
Sub Main()
DoTest(129)
End Sub
Sub DoTest(y6 As Integer)
Dim x As New PropertiesWithByRef()
Dim y1 As Integer = 123
Dim y2 As Byte = 124
PassByRef(x.P1(y1), y1)
System.Console.WriteLine(y1)
PassByRef(x.P1(y2), y2)
System.Console.WriteLine(y2)
y3 = 125
PassByRef(x.P1(y3), y3)
System.Console.WriteLine(y3)
y4 = 126
PassByRef(x.P1(y4), y4)
System.Console.WriteLine(y4)
Dim t As New Test1()
t.y5 = 127
PassByRef(x.P1(t.y5), t.y5)
System.Console.WriteLine(t.y5)
Dim ar As Integer() = New Integer() {128}
PassByRef(x.P1(ar(0)), ar(0))
System.Console.WriteLine(ar(0))
PassByRef(x.P1(y6), y6)
System.Console.WriteLine(y6)
End Sub
Sub PassByRef(ByRef x As Integer, ByRef y As Integer)
System.Console.WriteLine("PassByRef: {0}, {1}.", x, y)
x = x + 25
y = y + 50
End Sub
Private _y3 As Integer
Property y3 As Integer
Get
System.Console.WriteLine("Executing get_y3")
Return _y3
End Get
Set(value As Integer)
System.Console.WriteLine("Executing set_y3")
_y3 = value
End Set
End Property
Private y4 As Integer
End Module
Class Test1
Public y5 As Integer
End Class
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(123)
PassByRef: 124, 123.
set_P1(123)
173
get_P1(124)
PassByRef: 125, 124.
set_P1(124)
174
Executing set_y3
Executing get_y3
get_P1(125)
Executing get_y3
PassByRef: 126, 125.
Executing set_y3
set_P1(125)
Executing get_y3
175
get_P1(126)
PassByRef: 127, 126.
set_P1(126)
176
get_P1(127)
PassByRef: 128, 127.
set_P1(127)
177
get_P1(128)
PassByRef: 129, 128.
set_P1(128)
178
get_P1(129)
PassByRef: 130, 129.
set_P1(129)
179
]]>)
End Sub
<Fact>
Public Sub MeInByRefContext1()
Dim source =
<compilation name="MeInByRefContext1">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
Dim x As New TestStruct1(100)
x.Test1()
x.Test2()
System.Console.WriteLine("-----")
Dim y As New TestClass1(50)
y.Test1()
y.Test2()
y.Test3()
End Sub
Function PassByRef0(ByRef x As Integer) As Integer
x = x + 1
Return x
End Function
End Module
Structure TestStruct1
Public fld1 As Integer
Sub New(x As Integer)
fld1 = x
System.Console.WriteLine(PassByRef0(Me.fld1))
System.Console.WriteLine(Me.fld1)
System.Console.WriteLine(PassByRef1(Me))
System.Console.WriteLine(Me.fld1)
End Sub
Sub Test1()
System.Console.WriteLine(PassByRef0(Me.fld1))
System.Console.WriteLine(Me.fld1)
End Sub
Sub Test2()
System.Console.WriteLine(PassByRef1(Me))
System.Console.WriteLine(Me.fld1)
End Sub
Shared Function PassByRef1(ByRef x As TestStruct1) As Integer
x.fld1 = x.fld1 + 1
Return x.fld1
End Function
End Structure
Class TestClass1
Public fld1 As Integer
Sub New(x As Integer)
fld1 = x
System.Console.WriteLine(PassByRef0(Me.fld1))
System.Console.WriteLine(Me.fld1)
If x = 50 Then
System.Console.WriteLine(PassByRef2(Me))
System.Console.WriteLine(Me.fld1)
End If
End Sub
Sub Test1()
System.Console.WriteLine(PassByRef0(Me.fld1))
System.Console.WriteLine(Me.fld1)
End Sub
Sub Test2()
System.Console.WriteLine(PassByRef1(Me))
System.Console.WriteLine(Me.fld1)
End Sub
Sub Test3()
System.Console.WriteLine(PassByRef2(Me))
System.Console.WriteLine(Me.fld1)
End Sub
Shared Function PassByRef1(ByRef x As TestClass1) As Integer
x.fld1 = x.fld1 + 1
Return x.fld1
End Function
Shared Function PassByRef2(ByRef x As TestClass1) As Integer
Dim old As TestClass1 = x
x = New TestClass1(x.fld1 + 15)
Return old.fld1
End Function
End Class
Structure S1
Sub Test1()
PassByRef1(Me)
End Sub
Sub Test2()
PassByRef1((Me))
End Sub
Sub Test3()
Me.Test1()
End Sub
Shared Sub PassByRef1(ByRef x As S1)
End Sub
End Structure
Class C2
Sub Test1()
PassByRef1(Me)
End Sub
Sub Test2()
PassByRef1((Me))
End Sub
Sub Test3()
Me.Test1()
End Sub
Shared Sub PassByRef1(ByRef x As C2)
End Sub
End Class
</file>
</compilation>
Dim compilationVerifier = CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
101
101
102
101
102
102
103
102
-----
51
51
67
67
51
51
52
52
53
53
69
69
53
53
]]>)
compilationVerifier.VerifyIL("TestStruct1..ctor(Integer)",
<![CDATA[
{
// Code size 72 (0x48)
.maxstack 2
.locals init (TestStruct1 V_0)
IL_0000: ldarg.0
IL_0001: initobj "TestStruct1"
IL_0007: ldarg.0
IL_0008: ldarg.1
IL_0009: stfld "TestStruct1.fld1 As Integer"
IL_000e: ldarg.0
IL_000f: ldflda "TestStruct1.fld1 As Integer"
IL_0014: call "Function Module1.PassByRef0(ByRef Integer) As Integer"
IL_0019: call "Sub System.Console.WriteLine(Integer)"
IL_001e: ldarg.0
IL_001f: ldfld "TestStruct1.fld1 As Integer"
IL_0024: call "Sub System.Console.WriteLine(Integer)"
IL_0029: ldarg.0
IL_002a: ldobj "TestStruct1"
IL_002f: stloc.0
IL_0030: ldloca.s V_0
IL_0032: call "Function TestStruct1.PassByRef1(ByRef TestStruct1) As Integer"
IL_0037: call "Sub System.Console.WriteLine(Integer)"
IL_003c: ldarg.0
IL_003d: ldfld "TestStruct1.fld1 As Integer"
IL_0042: call "Sub System.Console.WriteLine(Integer)"
IL_0047: ret
}
]]>)
compilationVerifier.VerifyIL("TestStruct1.Test1",
<![CDATA[
{
// Code size 28 (0x1c)
.maxstack 1
IL_0000: ldarg.0
IL_0001: ldflda "TestStruct1.fld1 As Integer"
IL_0006: call "Function Module1.PassByRef0(ByRef Integer) As Integer"
IL_000b: call "Sub System.Console.WriteLine(Integer)"
IL_0010: ldarg.0
IL_0011: ldfld "TestStruct1.fld1 As Integer"
IL_0016: call "Sub System.Console.WriteLine(Integer)"
IL_001b: ret
}
]]>)
compilationVerifier.VerifyIL("TestStruct1.Test2",
<![CDATA[
{
// Code size 31 (0x1f)
.maxstack 1
.locals init (TestStruct1 V_0)
IL_0000: ldarg.0
IL_0001: ldobj "TestStruct1"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Function TestStruct1.PassByRef1(ByRef TestStruct1) As Integer"
IL_000e: call "Sub System.Console.WriteLine(Integer)"
IL_0013: ldarg.0
IL_0014: ldfld "TestStruct1.fld1 As Integer"
IL_0019: call "Sub System.Console.WriteLine(Integer)"
IL_001e: ret
}
]]>)
compilationVerifier.VerifyIL("TestClass1..ctor",
<![CDATA[
{
// Code size 71 (0x47)
.maxstack 2
.locals init (TestClass1 V_0)
IL_0000: ldarg.0
IL_0001: call "Sub Object..ctor()"
IL_0006: ldarg.0
IL_0007: ldarg.1
IL_0008: stfld "TestClass1.fld1 As Integer"
IL_000d: ldarg.0
IL_000e: ldflda "TestClass1.fld1 As Integer"
IL_0013: call "Function Module1.PassByRef0(ByRef Integer) As Integer"
IL_0018: call "Sub System.Console.WriteLine(Integer)"
IL_001d: ldarg.0
IL_001e: ldfld "TestClass1.fld1 As Integer"
IL_0023: call "Sub System.Console.WriteLine(Integer)"
IL_0028: ldarg.1
IL_0029: ldc.i4.s 50
IL_002b: bne.un.s IL_0046
IL_002d: ldarg.0
IL_002e: stloc.0
IL_002f: ldloca.s V_0
IL_0031: call "Function TestClass1.PassByRef2(ByRef TestClass1) As Integer"
IL_0036: call "Sub System.Console.WriteLine(Integer)"
IL_003b: ldarg.0
IL_003c: ldfld "TestClass1.fld1 As Integer"
IL_0041: call "Sub System.Console.WriteLine(Integer)"
IL_0046: ret
}
]]>)
compilationVerifier.VerifyIL("TestClass1.Test1",
<![CDATA[
{
// Code size 28 (0x1c)
.maxstack 1
IL_0000: ldarg.0
IL_0001: ldflda "TestClass1.fld1 As Integer"
IL_0006: call "Function Module1.PassByRef0(ByRef Integer) As Integer"
IL_000b: call "Sub System.Console.WriteLine(Integer)"
IL_0010: ldarg.0
IL_0011: ldfld "TestClass1.fld1 As Integer"
IL_0016: call "Sub System.Console.WriteLine(Integer)"
IL_001b: ret
}
]]>)
compilationVerifier.VerifyIL("TestClass1.Test2",
<![CDATA[
{
// Code size 26 (0x1a)
.maxstack 1
.locals init (TestClass1 V_0)
IL_0000: ldarg.0
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Function TestClass1.PassByRef1(ByRef TestClass1) As Integer"
IL_0009: call "Sub System.Console.WriteLine(Integer)"
IL_000e: ldarg.0
IL_000f: ldfld "TestClass1.fld1 As Integer"
IL_0014: call "Sub System.Console.WriteLine(Integer)"
IL_0019: ret
}
]]>)
compilationVerifier.VerifyIL("TestClass1.Test3",
<![CDATA[
{
// Code size 26 (0x1a)
.maxstack 1
.locals init (TestClass1 V_0)
IL_0000: ldarg.0
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Function TestClass1.PassByRef2(ByRef TestClass1) As Integer"
IL_0009: call "Sub System.Console.WriteLine(Integer)"
IL_000e: ldarg.0
IL_000f: ldfld "TestClass1.fld1 As Integer"
IL_0014: call "Sub System.Console.WriteLine(Integer)"
IL_0019: ret
}
]]>)
compilationVerifier.VerifyIL("S1.Test1",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (S1 V_0)
IL_0000: ldarg.0
IL_0001: ldobj "S1"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub S1.PassByRef1(ByRef S1)"
IL_000e: ret
}
]]>)
compilationVerifier.VerifyIL("S1.Test2",
<![CDATA[
{
// Code size 15 (0xf)
.maxstack 1
.locals init (S1 V_0)
IL_0000: ldarg.0
IL_0001: ldobj "S1"
IL_0006: stloc.0
IL_0007: ldloca.s V_0
IL_0009: call "Sub S1.PassByRef1(ByRef S1)"
IL_000e: ret
}
]]>)
compilationVerifier.VerifyIL("S1.Test3",
<![CDATA[
{
// Code size 7 (0x7)
.maxstack 1
IL_0000: ldarg.0
IL_0001: call "Sub S1.Test1()"
IL_0006: ret
}
]]>)
compilationVerifier.VerifyIL("C2.Test1",
<![CDATA[
{
// Code size 10 (0xa)
.maxstack 1
.locals init (C2 V_0)
IL_0000: ldarg.0
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Sub C2.PassByRef1(ByRef C2)"
IL_0009: ret
}
]]>)
compilationVerifier.VerifyIL("C2.Test2",
<![CDATA[
{
// Code size 10 (0xa)
.maxstack 1
.locals init (C2 V_0)
IL_0000: ldarg.0
IL_0001: stloc.0
IL_0002: ldloca.s V_0
IL_0004: call "Sub C2.PassByRef1(ByRef C2)"
IL_0009: ret
}
]]>)
compilationVerifier.VerifyIL("C2.Test3",
<![CDATA[
{
// Code size 7 (0x7)
.maxstack 1
IL_0000: ldarg.0
IL_0001: call "Sub C2.Test1()"
IL_0006: ret
}
]]>)
End Sub
<Fact>
Public Sub Bug7195()
Dim compilationDef =
<compilation name="Bug7195">
<file name="a.vb">
Option Strict Off
Imports System
Module Module1
Sub Main()
Dim s2 As TestStruct2 = New TestStruct2()
s2.fld2.fld1 = 1
System.Console.WriteLine((s2).fld2.Increment())
System.Console.WriteLine(s2.fld2.fld1)
System.Console.WriteLine((s2.fld2).Increment())
System.Console.WriteLine(s2.fld2.fld1)
System.Console.WriteLine(((s2).fld2).Increment())
System.Console.WriteLine(s2.fld2.fld1)
End Sub
End Module
Structure TestStruct1
Public fld1 As Integer
Function Increment() As Integer
fld1 = fld1 + 1
Return fld1
End Function
End Structure
Structure TestStruct2
Public fld2 As TestStruct1
End Structure
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
2
2
3
3
4
4
]]>)
End Sub
<Fact>
Public Sub ByRefParametersOnPropertiesInLambda1()
Dim source =
<compilation name="ByRefParametersOnPropertiesInLambda1">
<file name="a.vb">
Option Strict On
Module Module1
Sub Main()
Dim x As New PropertiesWithByRef()
Dim y1 As Integer = 123
Dim z As Integer
Dim d1 As System.Action = Sub()
z = x.P1(y1)
End Sub
d1()
System.Console.WriteLine(y1)
Dim d2 As System.Action = Sub()
x.P1(y1) = z + 1
End Sub
d2()
System.Console.WriteLine(y1)
End Sub
End Module
</file>
</compilation>
CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
get_P1(123)
123
set_P1(123)
123
]]>)
End Sub
<Fact>
Public Sub ByRefInInitializer1()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="ByRefInInitializer1">
<file name="a.vb">
Class T1
Public ReadOnly x1 As Integer
Public ReadOnly x2 As Integer
Public Shared ReadOnly x3 As Integer
Public Shared ReadOnly x4 As Integer
Public ReadOnly x5 As Integer
Public ReadOnly x6 As Integer
Public Shared ReadOnly x7 As Integer
Public Shared ReadOnly x8 As Integer
Public ReadOnly x9 As Integer
Public Shared ReadOnly x10 As Integer
Public y1 As Integer = TestByRef(x1)
Public Shared y2 As Integer = TestByRef(x2)
Public z1 As Integer = TestByRef(x3)
Public Shared z2 As Integer = TestByRef(x4)
Public Property y3 As Integer = TestByRef(x5)
Public Shared Property y4 As Integer = TestByRef(x6)
Public Property z3 As Integer = TestByRef(x7)
Public Shared Property z4 As Integer = TestByRef(x8)
Public Const y5 As Integer = TestByRef(x9).MaxValue
Public Const y6 As Integer = TestByRef(x10).MaxValue
End Class
Module Module1
Sub Main()
End Sub
Function TestByRef(ByRef x As Integer) As Integer
x = x + 100
Return x
End Function
End Module
</file>
</compilation>)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Shared y2 As Integer = TestByRef(x2)
~~
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Shared Property y4 As Integer = TestByRef(x6)
~~
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Const y5 As Integer = TestByRef(x9).MaxValue
~~
BC42025: Access of shared member, constant member, enum member or nested type through an instance; qualifying expression will not be evaluated.
Public Const y6 As Integer = TestByRef(x10).MaxValue
~~~~~~~~~~~~~~~~~~~~~~~
</expected>)
End Sub
<Fact>
Public Sub ByRefInInitializer2()
Dim source =
<compilation name="ByRefInInitializer2">
<file name="a.vb">
Imports System
Class T1
Public ReadOnly x1 As Integer
Public ReadOnly x2 As Integer
Public Shared ReadOnly x3 As Integer
Public Shared ReadOnly x4 As Integer
Public ReadOnly x5 As Integer
Public ReadOnly x6 As Integer
Public Shared ReadOnly x7 As Integer
Public Shared ReadOnly x8 As Integer
Public ReadOnly x9 As Integer
Public Shared ReadOnly x10 As Integer
Public y1 As Integer = TestByRef(x1)
'Public Shared y2 As Integer = TestByRef(x2)
Public z1 As Integer = TestByRef(x3)
Public Shared z2 As Integer = TestByRef(x4)
Public Property y3 As Integer = TestByRef(x5)
'Public Shared Property y4 As Integer = TestByRef(x6)
Public Property z3 As Integer = TestByRef(x7)
Public Shared Property z4 As Integer = TestByRef(x8)
'Public Const y5 As Integer = TestByRef(x9).MaxValue
Public Const y6 As Integer = TestByRef(x10).MaxValue
End Class
Module Module1
Sub Main()
Dim t As New T1()
Console.WriteLine(t.x1)
Console.WriteLine(t.x2)
Console.WriteLine(T1.x3)
Console.WriteLine(T1.x4)
Console.WriteLine(t.x5)
Console.WriteLine(t.x6)
Console.WriteLine(T1.x7)
Console.WriteLine(T1.x8)
Console.WriteLine(t.x9)
Console.WriteLine(T1.x10)
End Sub
Function TestByRef(ByRef x As Integer) As Integer
x = x + 100
Return x
End Function
End Module
</file>
</compilation>
CompileAndVerify(source,
references:={TestReferences.SymbolsTests.PropertiesWithByRef},
expectedOutput:=<![CDATA[
100
0
0
100
100
0
0
100
0
0
]]>)
End Sub
<Fact>
Public Sub ByRefInInitializer3()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="ByRefInInitializer3">
<file name="a.vb">
Imports System
Class T1
Public ReadOnly x1 As Integer
Public ReadOnly x2 As Integer
Public Shared ReadOnly x3 As Integer
Public Shared ReadOnly x4 As Integer
Public ReadOnly x5 As Integer
Public ReadOnly x6 As Integer
Public Shared ReadOnly x7 As Integer
Public Shared ReadOnly x8 As Integer
Public ReadOnly x9 As Integer
Public Shared ReadOnly x10 As Integer
Public y1 As Action = Sub() TestByRef(x1)
Public Shared y2 As Action = Sub() TestByRef(x2)
Public z1 As Action = Sub() TestByRef(x3)
Public Shared z2 As Action = Sub() TestByRef(x4)
Public Property y3 As Action = Sub() TestByRef(x5)
Public Shared Property y4 As Action = Sub() TestByRef(x6)
Public Property z3 As Action = Sub() TestByRef(x7)
Public Shared Property z4 As Action = Sub() TestByRef(x8)
Public Const y5 As Object = CType(Function() TestByRef(x9), Func(Of Integer)).Invoke().MaxValue
Public Const y6 As Object = CType(Function() TestByRef(x10), Func(Of Integer)).Invoke().MaxValue
End Class
Module Module1
Sub Main()
End Sub
Function TestByRef(ByRef x As Integer) As Integer
x = x + 100
Return x
End Function
End Module
</file>
</compilation>)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC36602: 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor.
Public y1 As Action = Sub() TestByRef(x1)
~~
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Shared y2 As Action = Sub() TestByRef(x2)
~~
BC36602: 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor.
Public Shared z2 As Action = Sub() TestByRef(x4)
~~
BC36602: 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor.
Public Property y3 As Action = Sub() TestByRef(x5)
~~
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Shared Property y4 As Action = Sub() TestByRef(x6)
~~
BC36602: 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor.
Public Shared Property z4 As Action = Sub() TestByRef(x8)
~~
BC30369: Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class.
Public Const y5 As Object = CType(Function() TestByRef(x9), Func(Of Integer)).Invoke().MaxValue
~~
BC36602: 'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor.
Public Const y6 As Object = CType(Function() TestByRef(x10), Func(Of Integer)).Invoke().MaxValue
~~~
</expected>)
End Sub
<Fact>
Public Sub NamedArgumentsAndOverriding()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="NamedArgumentsAndOverriding">
<file name="a.vb">
Class Test1
Overridable Sub Goo(x As Integer)
End Sub
End Class
Class Test2
Inherits Test1
Overrides Sub Goo(y As Integer)
End Sub
End Class
Class Test3
Inherits Test2
Overrides Sub Goo(z As Integer)
End Sub
End Class
Module Module1
Sub Main()
Dim t3 As New Test3()
t3.Goo(z:=1)
t3.Goo(y:=1)
t3.Goo(x:=1)
End Sub
End Module
Namespace GenMethod4140
Friend Module GenMethod4140mod
Class Base
Overridable Function fun1(Of T)(ByRef t1 As T) As Object
Return Nothing
End Function
End Class
Class Derived
Inherits Base
Overrides Function fun1(Of T)(ByRef t2 As T) As Object
Return Nothing
End Function
End Class
Sub GenMethod4140()
Dim c3 As New Derived
c3.fun1(t1:=3US)
End Sub
End Module
End Namespace
</file>
</compilation>)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30455: Argument not specified for parameter 'z' of 'Public Overrides Sub Goo(z As Integer)'.
t3.Goo(y:=1)
~~~
BC30272: 'y' is not a parameter of 'Public Overrides Sub Goo(z As Integer)'.
t3.Goo(y:=1)
~
BC30455: Argument not specified for parameter 'z' of 'Public Overrides Sub Goo(z As Integer)'.
t3.Goo(x:=1)
~~~
BC30272: 'x' is not a parameter of 'Public Overrides Sub Goo(z As Integer)'.
t3.Goo(x:=1)
~
BC30455: Argument not specified for parameter 't2' of 'Public Overrides Function fun1(Of T)(ByRef t2 As T) As Object'.
c3.fun1(t1:=3US)
~~~~
BC30272: 't1' is not a parameter of 'Public Overrides Function fun1(Of T)(ByRef t2 As T) As Object'.
c3.fun1(t1:=3US)
~~
</expected>)
End Sub
<Fact()>
Public Sub SharedThroughInstance1()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="NamedArgumentsAndOverriding">
<file name="a.vb">
Module Module1
Sub Main()
Dim x As New TestC()
x.Test(1, 2)
End Sub
End Module
Class TestC
Public Shared Sub Test(x As Integer)
End Sub
Public Shared Sub Test(x As Integer, y As Integer)
System.Console.WriteLine("Success")
End Sub
End Class
</file>
</compilation>, TestOptions.ReleaseExe)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC42025: Access of shared member, constant member, enum member or nested type through an instance; qualifying expression will not be evaluated.
x.Test(1, 2)
~~~~~~
</expected>)
CompileAndVerify(compilation, expectedOutput:=
<![CDATA[
Success
]]>)
End Sub
<Fact()>
Public Sub InaccessibleOverloads1()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="NamedArgumentsAndOverriding">
<file name="a.vb">
Module Module1
Sub Main()
Dim x As New TestC()
x.Test(1)
x.Test(2, 1)
x.Test()
Dim d1 As System.Action(Of Integer) = AddressOf x.Test
Dim d2 As System.Action(Of Integer, Integer) = AddressOf x.Test
Dim d3 As System.Action = AddressOf x.Test
End Sub
End Module
Class TestC
Protected Sub Test(x As Integer)
End Sub
Protected Sub Test(x As Integer, y As Integer)
End Sub
End Class
</file>
</compilation>, TestOptions.ReleaseExe)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30390: 'TestC.Protected Sub Test(x As Integer)' is not accessible in this context because it is 'Protected'.
x.Test(1)
~~~~~~
BC30390: 'TestC.Protected Sub Test(x As Integer, y As Integer)' is not accessible in this context because it is 'Protected'.
x.Test(2, 1)
~~~~~~
BC30517: Overload resolution failed because no 'Test' is accessible.
x.Test()
~~~~~~
BC30390: 'TestC.Protected Sub Test(x As Integer)' is not accessible in this context because it is 'Protected'.
Dim d1 As System.Action(Of Integer) = AddressOf x.Test
~~~~~~
BC30390: 'TestC.Protected Sub Test(x As Integer, y As Integer)' is not accessible in this context because it is 'Protected'.
Dim d2 As System.Action(Of Integer, Integer) = AddressOf x.Test
~~~~~~
BC30517: Overload resolution failed because no 'Test' is accessible.
Dim d3 As System.Action = AddressOf x.Test
~~~~~~
</expected>)
End Sub
<Fact()>
Public Sub InaccessibleOverloads2()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="NamedArgumentsAndOverriding">
<file name="a.vb">
Module Module1
Sub Main()
Dim x As New TestC()
x.Test(1)
x.Test(2, 1)
x.Test()
Dim d1 As System.Action(Of Integer) = AddressOf x.Test
Dim d2 As System.Action(Of Integer, Integer) = AddressOf x.Test
Dim d3 As System.Action = AddressOf x.Test
End Sub
End Module
Class TestC
Protected Shared Sub Test(x As Integer)
End Sub
Protected Shared Sub Test(x As Integer, y As Integer)
End Sub
End Class
</file>
</compilation>, TestOptions.ReleaseExe)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30390: 'TestC.Protected Shared Sub Test(x As Integer)' is not accessible in this context because it is 'Protected'.
x.Test(1)
~~~~~~
BC30390: 'TestC.Protected Shared Sub Test(x As Integer, y As Integer)' is not accessible in this context because it is 'Protected'.
x.Test(2, 1)
~~~~~~
BC30517: Overload resolution failed because no 'Test' is accessible.
x.Test()
~~~~~~
BC30390: 'TestC.Protected Shared Sub Test(x As Integer)' is not accessible in this context because it is 'Protected'.
Dim d1 As System.Action(Of Integer) = AddressOf x.Test
~~~~~~
BC30390: 'TestC.Protected Shared Sub Test(x As Integer, y As Integer)' is not accessible in this context because it is 'Protected'.
Dim d2 As System.Action(Of Integer, Integer) = AddressOf x.Test
~~~~~~
BC30517: Overload resolution failed because no 'Test' is accessible.
Dim d3 As System.Action = AddressOf x.Test
~~~~~~
</expected>)
End Sub
<Fact()>
Public Sub InaccessibleOverloads3()
Dim compilation = CompilationUtils.CreateCompilationWithMscorlib40AndVBRuntime(
<compilation name="NamedArgumentsAndOverriding">
<file name="a.vb">
Module Module1
Sub Main()
Dim x As New TestC()
x.Test1(1)
x.Test2(1)
x.Test1(Of Integer)(1)
x.Test2(Of Integer)(1)
x.Test1(1,2)
x.Test3(1)
x.Test4(1)
x.Test1(DoesntExist)
x.Test2(DoesntExist)
Dim y as Long = 0
x.Test5(y)
Dim d1 As System.Action(Of Integer) = AddressOf x.Test1
Dim d2 As System.Action(Of Integer) = AddressOf x.Test2
Dim d3 As System.Action(Of Integer) = AddressOf x.Test1(Of Integer)
Dim d4 As System.Action(Of Integer) = AddressOf x.Test2(Of Integer)
Dim d5 As System.Action(Of Integer, Integer) = AddressOf x.Test1
Dim d6 As System.Action(Of Integer) = AddressOf x.Test3
Dim d7 As System.Action(Of Integer) = AddressOf x.Test4
Dim d8 As System.Action(Of Long) = AddressOf x.Test5
System.Console.WriteLine(1 + AddressOf x.Test1)
System.Console.WriteLine(1 + AddressOf x.Test2)
End Sub
End Module
Class TestC
Protected Sub Test1(x As System.Guid)
End Sub
Protected Sub Test2(x As System.Guid)
End Sub
Protected Sub Test2(x As System.Type)
End Sub
Protected Sub Test3(Of T)(x As Integer)
End Sub
Protected Sub Test4(Of T)(x As Integer)
End Sub
Protected Sub Test4(Of T)(x As String)
End Sub
Protected Sub Test5(x As Integer)
End Sub
Protected Sub Test5(x As String)
End Sub
End Class
</file>
</compilation>, TestOptions.ReleaseExe)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
x.Test1(1)
~~~~~~~
BC30311: Value of type 'Integer' cannot be converted to 'Guid'.
x.Test1(1)
~
BC30517: Overload resolution failed because no 'Test2' is accessible.
x.Test2(1)
~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
x.Test1(Of Integer)(1)
~~~~~~~~~~~~~~~~~~~
BC32045: 'Protected Sub Test1(x As Guid)' has no type parameters and so cannot have type arguments.
x.Test1(Of Integer)(1)
~~~~~~~~~~~~
BC30517: Overload resolution failed because no 'Test2' is accessible.
x.Test2(Of Integer)(1)
~~~~~~~~~~~~~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
x.Test1(1,2)
~~~~~~~
BC30311: Value of type 'Integer' cannot be converted to 'Guid'.
x.Test1(1,2)
~
BC30057: Too many arguments to 'Protected Sub Test1(x As Guid)'.
x.Test1(1,2)
~
BC30390: 'TestC.Protected Sub Test3(Of T)(x As Integer)' is not accessible in this context because it is 'Protected'.
x.Test3(1)
~~~~~~~
BC32050: Type parameter 'T' for 'Protected Sub Test3(Of T)(x As Integer)' cannot be inferred.
x.Test3(1)
~~~~~
BC30517: Overload resolution failed because no 'Test4' is accessible.
x.Test4(1)
~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
x.Test1(DoesntExist)
~~~~~~~
BC30451: 'DoesntExist' is not declared. It may be inaccessible due to its protection level.
x.Test1(DoesntExist)
~~~~~~~~~~~
BC30517: Overload resolution failed because no 'Test2' is accessible.
x.Test2(DoesntExist)
~~~~~~~
BC30451: 'DoesntExist' is not declared. It may be inaccessible due to its protection level.
x.Test2(DoesntExist)
~~~~~~~~~~~
BC30517: Overload resolution failed because no 'Test5' is accessible.
x.Test5(y)
~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
Dim d1 As System.Action(Of Integer) = AddressOf x.Test1
~~~~~~~
BC31143: Method 'Protected Sub Test1(x As Guid)' does not have a signature compatible with delegate 'Delegate Sub Action(Of Integer)(obj As Integer)'.
Dim d1 As System.Action(Of Integer) = AddressOf x.Test1
~~~~~~~
BC30517: Overload resolution failed because no 'Test2' is accessible.
Dim d2 As System.Action(Of Integer) = AddressOf x.Test2
~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
Dim d3 As System.Action(Of Integer) = AddressOf x.Test1(Of Integer)
~~~~~~~~~~~~~~~~~~~
BC32045: 'Protected Sub Test1(x As Guid)' has no type parameters and so cannot have type arguments.
Dim d3 As System.Action(Of Integer) = AddressOf x.Test1(Of Integer)
~~~~~~~~~~~~
BC30517: Overload resolution failed because no 'Test2' is accessible.
Dim d4 As System.Action(Of Integer) = AddressOf x.Test2(Of Integer)
~~~~~~~~~~~~~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
Dim d5 As System.Action(Of Integer, Integer) = AddressOf x.Test1
~~~~~~~
BC31143: Method 'Protected Sub Test1(x As Guid)' does not have a signature compatible with delegate 'Delegate Sub Action(Of Integer, Integer)(arg1 As Integer, arg2 As Integer)'.
Dim d5 As System.Action(Of Integer, Integer) = AddressOf x.Test1
~~~~~~~
BC30390: 'TestC.Protected Sub Test3(Of T)(x As Integer)' is not accessible in this context because it is 'Protected'.
Dim d6 As System.Action(Of Integer) = AddressOf x.Test3
~~~~~~~
BC36564: Type arguments could not be inferred from the delegate.
Dim d6 As System.Action(Of Integer) = AddressOf x.Test3
~~~~~~~
BC30517: Overload resolution failed because no 'Test4' is accessible.
Dim d7 As System.Action(Of Integer) = AddressOf x.Test4
~~~~~~~
BC30517: Overload resolution failed because no 'Test5' is accessible.
Dim d8 As System.Action(Of Long) = AddressOf x.Test5
~~~~~~~
BC30491: Expression does not produce a value.
System.Console.WriteLine(1 + AddressOf x.Test1)
~~~~~~~~~~~~~~~~~
BC30390: 'TestC.Protected Sub Test1(x As Guid)' is not accessible in this context because it is 'Protected'.
System.Console.WriteLine(1 + AddressOf x.Test1)
~~~~~~~
BC30491: Expression does not produce a value.
System.Console.WriteLine(1 + AddressOf x.Test2)
~~~~~~~~~~~~~~~~~
BC30517: Overload resolution failed because no 'Test2' is accessible.
System.Console.WriteLine(1 + AddressOf x.Test2)
~~~~~~~
</expected>)
End Sub
<WorkItem(543719, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543719")>
<Fact()>
Public Sub CallByRefWithTwoArgs()
Dim compilationDef =
<compilation name="Test.vb">
<file name="a.vb">
Imports System
Module Program
Sub SUB8(ByRef X1 As Integer, ByRef X2 As Integer)
Console.WriteLine(X1)
Console.WriteLine(X2)
End Sub
Sub Main(args As String())
SUB8(10, 40)
End Sub
End Module
</file>
</compilation>
CompileAndVerify(compilationDef,
expectedOutput:=
<![CDATA[
10
40
]]>)
End Sub
<Fact, WorkItem(544511, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544511")>
Public Sub Bug12877_1()
Dim source =
<compilation name="AscW">
<file name="a.vb">
Imports Microsoft.VisualBasic.Strings
Module Module1
Sub Main()
System.Console.WriteLine(Test1("a"c))
System.Console.WriteLine(Test2("b"))
End Sub
Function Test1(x As Char) As Integer
Return AscW(x)
End Function
Function Test2(x As String) As Integer
Return AscW(x)
End Function
End Module
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
97
98
]]>)
compilationVerifier.VerifyIL("Module1.Test1",
<![CDATA[
{
// Code size 2 (0x2)
.maxstack 1
IL_0000: ldarg.0
IL_0001: ret
}
]]>)
compilationVerifier.VerifyIL("Module1.Test2",
<![CDATA[
{
// Code size 7 (0x7)
.maxstack 1
IL_0000: ldarg.0
IL_0001: call "Function Microsoft.VisualBasic.Strings.AscW(String) As Integer"
IL_0006: ret
}
]]>)
compilation = CreateCompilationWithMscorlib40AndReferences(source, {SystemRef}, TestOptions.ReleaseExe.WithEmbedVbCoreRuntime(True))
compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
97
98
]]>)
compilationVerifier.VerifyIL("Module1.Test1",
<![CDATA[
{
// Code size 2 (0x2)
.maxstack 1
IL_0000: ldarg.0
IL_0001: ret
}
]]>)
compilationVerifier.VerifyIL("Module1.Test2",
<![CDATA[
{
// Code size 7 (0x7)
.maxstack 1
IL_0000: ldarg.0
IL_0001: call "Function Microsoft.VisualBasic.Strings.AscW(String) As Integer"
IL_0006: ret
}
]]>)
End Sub
<Fact, WorkItem(545521, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545521")>
Public Sub Bug14020()
Dim source =
<compilation name="AscW">
<file name="a.vb">
Option Strict On
Class A
Shared Sub Goo(Of T)(x As T)
System.Console.WriteLine("Goo(Of T)(x As T)")
End Sub
End Class
Class B
Inherits A
Overloads Shared Sub Goo(Of T)(y As Integer)
End Sub
Shared Sub Main()
Goo(x:=1)
End Sub
End Class
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
Goo(Of T)(x As T)
]]>)
End Sub
<Fact, WorkItem(545522, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545522")>
Public Sub Bug14021()
Dim source =
<compilation name="AscW">
<file name="a.vb">
<![CDATA[
Option Strict On
Imports System.Runtime.CompilerServices
Module M
Sub Main()
Dim s As String = Nothing
s.Goo(y:=1)
End Sub
<Extension>
Sub Goo(x As Object, y As Integer)
System.Console.WriteLine("Goo(x As Object, y As Integer)")
End Sub
<Extension>
Sub Goo(Of T)(x As T, z As Integer)
System.Console.WriteLine("Goo(Of T)(x As T, z As Integer)")
End Sub
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, {Net40.References.SystemCore}, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
Goo(x As Object, y As Integer)
]]>)
End Sub
<Fact, WorkItem(545522, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545522")>
Public Sub Bug14021_2()
Dim source =
<compilation name="AscW">
<file name="a.vb">
<![CDATA[
Option Strict On
Imports System.Runtime.CompilerServices
Module M
Sub Main()
Dim s As String = Nothing
s.Goo(y:=1)
End Sub
<Extension>
Sub Goo(x As String, z As Integer)
System.Console.WriteLine("Goo(x As String, z As Integer)")
End Sub
<Extension>
Sub Goo(x As Object, y As Integer)
System.Console.WriteLine("Goo(x As Object, y As Integer)")
End Sub
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, {Net40.References.SystemCore}, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
Goo(x As Object, y As Integer)
]]>)
End Sub
<Fact, WorkItem(545524, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545524")>
Public Sub Bug14024()
Dim source =
<compilation name="AscW">
<file name="a.vb">
<![CDATA[
Option Strict On
Class B
Overloads Function Goo(Of T)() As Integer
System.Console.WriteLine("Function Goo(Of T)() As Integer")
Return 4321
End Function
End Class
Class C
Inherits B
Overloads Shared Function Goo() As Integer()
System.Console.WriteLine("Function Goo() As Integer()")
Return {1234}
End Function
Shared Sub Main()
Goo(0).ToString()
End Sub
End Class
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
Function Goo() As Integer()
]]>)
End Sub
<Fact, WorkItem(545524, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545524")>
Public Sub Bug14024_2()
Dim source =
<compilation name="AscW">
<file name="a.vb">
<![CDATA[
Option Strict On
Class B
Overloads Function Goo(Of T)() As Integer
System.Console.WriteLine("Function Goo(Of T)() As Integer")
Return 4321
End Function
End Class
Class C
Inherits B
Shared Sub Main()
Goo(0).ToString()
End Sub
End Class
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
CompilationUtils.AssertTheseDiagnostics(compilation,
<expected>
BC30057: Too many arguments to 'Public Overloads Function Goo(Of T)() As Integer'.
Goo(0).ToString()
~
</expected>)
End Sub
<Fact, WorkItem(546006, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546006")>
Public Sub Bug14936()
Dim source =
<compilation name="Bug14936">
<file name="a.vb">
<![CDATA[
Module Program
Sub Main()
Dim o As New cls1
Dim x1 As Object = 1
o.goo(x1)
End Sub
End Module
Class cls1
Sub goo(ByVal x As cls1)
System.Console.WriteLine("goo(ByVal x As cls1)")
End Sub
Sub goo(ByVal x As Integer)
System.Console.WriteLine("goo(ByVal x As Integer)")
End Sub
End Class
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe.WithOptionStrict(OptionStrict.Custom))
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
goo(ByVal x As Integer)
]]>)
AssertTheseDiagnostics(compilation,
<expected>
BC42017: Late bound resolution; runtime errors could occur.
o.goo(x1)
~~~
</expected>)
End Sub
<Fact, WorkItem(547132, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547132")>
Public Sub Bug18047()
Dim source =
<compilation>
<file name="a.vb">
<![CDATA[
Imports System
Module Program
Property S1 As String
Get
Return ""
End Get
Set(value As String)
Console.WriteLine("S1")
End Set
End Property
Property S2 As String
Get
Return ""
End Get
Set(value As String)
Console.WriteLine("S2")
End Set
End Property
Property S3 As String
Get
Return ""
End Get
Set(value As String)
Console.WriteLine("S3")
End Set
End Property
Sub Verify1(ByRef x As String, ByRef y As String, ByRef z As String)
x = "a"
y = "b"
z = "c"
End Sub
Sub Main(args As String())
Verify1(S1, S2, S3)
End Sub
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
S3
S2
S1
]]>)
End Sub
<WorkItem(531448, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531448")>
<ConditionalFact(GetType(WindowsDesktopOnly), Reason:="https://github.com/dotnet/roslyn/issues/28044")>
Public Sub Bug18133_1()
Dim source =
<compilation>
<file name="a.vb">
<![CDATA[
Option Compare Text
Imports System
Imports Microsoft.VisualBasic
Module module1
Sub Main(args As String())
Console.WriteLine(InStr(1, "SSHORTDATE", "Date"))
End Sub
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
7
]]>)
End Sub
<WorkItem(531448, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531448")>
<ConditionalFact(GetType(WindowsDesktopOnly), Reason:="https://github.com/dotnet/roslyn/issues/28044")>
Public Sub Bug18133_2()
Dim source =
<compilation>
<file name="a.vb">
<![CDATA[
Option Compare Text
Imports System
Imports Microsoft.VisualBasic
Module module1
Sub Main(args As String())
Console.WriteLine(MyInStr(1, "SSHORTDATE", "Date"))
End Sub
Function MyInStr(Start As Integer, String1 As String, String2 As String, <CompilerServices.OptionCompareAttribute()> Optional Compare As CompareMethod = CompareMethod.Binary) As Integer
Return InStr(Start, String1, String2, Compare)
End Function
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
0
]]>)
End Sub
<Fact, WorkItem(531413, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531413")>
Public Sub Bug18089()
Dim source =
<compilation>
<file name="a.vb">
<![CDATA[
Friend Class Class1
Sub New(ByVal x As Short, Optional ByVal y As Integer = 0)
System.Console.WriteLine("1")
End Sub
Sub New(ByVal x As Integer, Optional ByVal y As Short = 0)
System.Console.WriteLine("2")
End Sub
Shared Sub Goo(ByVal x As Short, Optional ByVal y As Integer = 0)
System.Console.WriteLine("3")
End Sub
Shared Sub Goo(ByVal x As Integer, Optional ByVal y As Short = 0)
System.Console.WriteLine("4")
End Sub
End Class
Module Module1
Sub Main(args As String())
Dim x As New Class1(CShort(0), )
Dim y As New Class1(CShort(0))
Class1.Goo(CShort(0), )
Class1.Goo(CShort(0))
End Sub
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
1
1
3
3
]]>)
End Sub
<Fact, WorkItem(570936, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/570936")>
Public Sub Bug570936()
Dim source =
<compilation>
<file name="a.vb">
<![CDATA[
Imports System
Imports System.Runtime.CompilerServices
Module Module1
Sub Main
Dim x As New C3
Dim sResult As String = x.Goo3(1)
Console.writeline("C3 Pass")
Console.writeline( sResult)
End Sub
Class C3
Function Goo3(<[ParamArray]()> ByVal x As Integer) As String
Return "C3 Fail"
End Function
End Class
End Module
Module NonArrayMarkedAsParamArray1
<Extension()> Function Goo3(ByVal x As C3, ByVal y As Integer) As String
Return "C3 Pass"
End Function
End Module
]]>
</file>
</compilation>
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source, {Net40.References.SystemCore}, TestOptions.ReleaseExe)
Dim compilationVerifier = CompileAndVerify(compilation,
expectedOutput:=
<![CDATA[
C3 Pass
C3 Pass
]]>)
End Sub
<Fact()>
Public Sub ParameterSyntax_ModifiersAndAttributes()
CompileAndVerify(
<compilation>
<file name="a.vb">
<![CDATA[Imports System
Imports Microsoft.VisualBasic
Imports System.Collections
Imports System.Collections.Generic
Module Module1
Sub main()
Goo("test", "test2")
Bar("Test")
Bar("Test", 2)
GooAttributes({"Test", "Test2"})
GooAttributes2({"Test2", "Test"})
GooAttributes3({"Test", "Test2"}, 1)
End Sub
Sub Goo(ByVal ParamArray x() As String)
Console.WriteLine("Goo")
End Sub
Sub Bar(ByRef x As String, Optional ByVal y As Integer = 1)
Console.WriteLine("Bar")
End Sub
Sub GooAttributes(<Test> <Test2> x() As String)
Console.WriteLine("GooAttributes")
End Sub
Sub GooAttributes2(<Test, Test2> x() As String)
Console.WriteLine("GooAttributes2")
End Sub
Sub GooAttributes3(<Test, Test2> x() As String, <Test> z As Integer)
Console.WriteLine("GooAttributes3")
End Sub
End Module
<AttributeUsageAttribute(AttributeTargets.Parameter, Inherited:=True)>
Public NotInheritable Class TestAttribute
Inherits Attribute
End Class
<AttributeUsageAttribute(AttributeTargets.Parameter, Inherited:=True)>
Public NotInheritable Class Test2Attribute
Inherits Attribute
End Class
]]>
</file>
</compilation>,
expectedOutput:=<![CDATA[Goo
Bar
Bar
GooAttributes
GooAttributes2
GooAttributes3
]]>)
End Sub
<Fact()>
Public Sub AutoImplementedPropertiesWithGenericTypeParameters()
Dim TEMP = CompileAndVerify(
<compilation>
<file name="a.vb">
Imports System
Imports Microsoft.VisualBasic
Imports System.Collections
Imports System.Collections.Generic
Module Module1
Sub main()
Dim x As New Goo
x.Items = New List(Of String) From {"A", "B", "C"}
Console.WriteLine(x.Items.Count)
Dim y As New GooWithInterface
Dim i As IPropTest = y
i.Items = New List(Of String) From {"A", "B", "C"}
End Sub
End Module
Class Goo
Public Property Items As New List(Of String)
End Class
Class GooWithInterface
Implements IPropTest
Public Property Items As New List(Of String) Implements IPropTest.Items
End Class
Interface IPropTest
Property Items As List(Of String)
End Interface
</file>
</compilation>, expectedOutput:=<![CDATA[3
]]>)
End Sub
<Fact(), WorkItem(758861, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/758861")>
Public Sub Bug758861()
Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
<compilation>
<file name="a.vb">
Module Program
Const c1 As String = "DefaultValue1"
Const c2 As String = "DefaultValue2"
Declare Ansi Sub subAnsiByValStr1 Lib "DeclDll" Alias "subAnsiByValStr1" (Optional ByVal str As String = c1) 'BIND1:"c1"
Declare Ansi Function subAnsiByValStr2 Lib "DeclDll" Alias "subAnsiByValStr2" (Optional ByVal str As String = c2) 'BIND2:"c2"
Sub Main(args As String())
subAnsiByValStr1()
subAnsiByValStr2()
End Sub
End Module
</file>
</compilation>, TestOptions.ReleaseDll)
Dim verifier = CompileAndVerify(compilation)
verifier.VerifyIL("Program.Main",
<![CDATA[
{
// Code size 28 (0x1c)
.maxstack 1
.locals init (String V_0)
IL_0000: ldstr "DefaultValue1"
IL_0005: stloc.0
IL_0006: ldloca.s V_0
IL_0008: call "Declare Ansi Sub Program.subAnsiByValStr1 Lib "DeclDll" Alias "subAnsiByValStr1" (String)"
IL_000d: ldstr "DefaultValue2"
IL_0012: stloc.0
IL_0013: ldloca.s V_0
IL_0015: call "Declare Ansi Function Program.subAnsiByValStr2 Lib "DeclDll" Alias "subAnsiByValStr2" (String) As Object"
IL_001a: pop
IL_001b: ret
}
]]>)
Dim model = GetSemanticModel(compilation, "a.vb")
Dim node1 As ExpressionSyntax = CompilationUtils.FindBindingText(Of ExpressionSyntax)(compilation, "a.vb", 1)
Dim node2 As ExpressionSyntax = CompilationUtils.FindBindingText(Of ExpressionSyntax)(compilation, "a.vb", 2)
Dim cnt = model.GetConstantValue(node1)
Assert.Equal("DefaultValue1", CStr(cnt.Value))
cnt = model.GetConstantValue(node2)
Assert.Equal("DefaultValue2", CStr(cnt.Value))
End Sub
<Fact(), WorkItem(762717, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/762717")>
Public Sub Bug762717()
Dim library = CreateCompilationWithMscorlib40(
<compilation>
<file name="a.vb"><![CDATA[
Public Class Test1
Public Shared Sub Test1(a As Integer, <System.Runtime.InteropServices.OptionalAttribute> x As Integer, <System.ParamArrayAttribute> y As Integer())
End Sub
End Class
Public Class Test2
Public Shared Sub Test2(a As Integer, <System.Runtime.InteropServices.OptionalAttribute> x As Integer, <System.ParamArrayAttribute> y As Integer())
End Sub
Public Shared Sub Test2(a As String, <System.Runtime.InteropServices.OptionalAttribute> x As Integer, <System.ParamArrayAttribute> y As Integer())
End Sub
End Class
]]></file>
</compilation>, options:=TestOptions.ReleaseDll)
CompileAndVerify(library)
Dim compilation = CreateCompilationWithMscorlib40AndReferences(
<compilation>
<file name="a.vb"><![CDATA[
Class Module1
Sub Main1()
Test1.Test1(1)
End Sub
Sub Main2()
Test2.Test2(2)
End Sub
End Class
]]></file>
</compilation>, {library.EmitToImageReference()}, TestOptions.ReleaseDll)
Dim verifier = CompileAndVerify(compilation)
verifier.VerifyIL("Module1.Main1",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 3
IL_0000: ldc.i4.1
IL_0001: ldc.i4.0
IL_0002: ldc.i4.0
IL_0003: newarr "Integer"
IL_0008: call "Sub Test1.Test1(Integer, Integer, ParamArray Integer())"
IL_000d: ret
}
]]>)
verifier.VerifyIL("Module1.Main2",
<![CDATA[
{
// Code size 14 (0xe)
.maxstack 3
IL_0000: ldc.i4.2
IL_0001: ldc.i4.0
IL_0002: ldc.i4.0
IL_0003: newarr "Integer"
IL_0008: call "Sub Test2.Test2(Integer, Integer, ParamArray Integer())"
IL_000d: ret
}
]]>)
End Sub
<Fact(), WorkItem(1040093, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1040093"), WorkItem(1026678, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1026678")>
Public Sub ParenthesizedVariableAsAReceiver_01()
Dim compilationDef =
<compilation>
<file name="a.vb">
Imports System
Imports System.Threading.Tasks
Module Module1
Sub Main()
System.Console.WriteLine("Non-Async")
System.Console.WriteLine()
TestLocal()
TestParameter()
TestSharedField()
TestInstanceField()
TestArrayElement()
System.Console.WriteLine()
System.Console.WriteLine("Async")
System.Console.WriteLine()
Task.WaitAll(TestLocalAsync())
Task.WaitAll(TestParameterAsync())
Task.WaitAll(TestSharedFieldAsync())
Task.WaitAll(TestInstanceFieldAsync())
Task.WaitAll(TestArrayElementAsync())
End Sub
Sub TestLocal()
Dim l = TestStruct1.Create()
Call (l).Change()
System.Console.WriteLine("Local : {0}", l.State())
End Sub
Sub TestParameter(Optional p As TestStruct1 = Nothing)
p = TestStruct1.Create()
Call (p).Change()
System.Console.WriteLine("Parameter : {0}", p.State())
End Sub
Private f As TestStruct1
Sub TestSharedField()
f = TestStruct1.Create()
Call (f).Change()
System.Console.WriteLine("Shared Field : {0}", f.State())
End Sub
Sub TestInstanceField()
Dim i = New TestClass()
Call (i.fld2).Change()
System.Console.WriteLine("Instance Field: {0}", i.fld2.State())
End Sub
Sub TestArrayElement()
Dim a = {TestStruct1.Create()}
Call (a(0)).Change()
System.Console.WriteLine("Array element : {0}", a(0).State())
End Sub
Async Function DummyAsync() As Task(Of Object)
Return Nothing
End Function
Async Function TestLocalAsync() As Task
Dim l = TestStruct1.Create()
Call (l).Change(Await DummyAsync())
System.Console.WriteLine("Local : {0}", l.State())
End Function
Async Function TestParameterAsync(Optional p As TestStruct1 = Nothing) As Task
p = TestStruct1.Create()
Call (p).Change(Await DummyAsync())
System.Console.WriteLine("Parameter : {0}", p.State())
End Function
Async Function TestSharedFieldAsync() As Task
f = TestStruct1.Create()
Call (f).Change(Await DummyAsync())
System.Console.WriteLine("Shared Field : {0}", f.State())
End Function
Async Function TestInstanceFieldAsync() As Task
Dim i = New TestClass()
Call (i.fld2).Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld2.State())
End Function
Async Function TestArrayElementAsync() As Task
Dim a = {TestStruct1.Create()}
Call (a(0)).Change(Await DummyAsync())
System.Console.WriteLine("Array element : {0}", a(0).State())
End Function
End Module
Structure TestStruct1
Private fld1 As String
Shared Function Create() As TestStruct1
Return New TestStruct1() With {.fld1 = "Unchanged"}
End Function
Sub Change(Optional x As Object = Nothing)
fld1 = "Changed"
End Sub
Function State() As String
Return fld1
End Function
End Structure
Class TestClass
Public fld2 As TestStruct1 = TestStruct1.Create()
End Class
</file>
</compilation>
Dim compilation = CompilationUtils.CreateEmptyCompilationWithReferences(compilationDef, {MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929}, TestOptions.ReleaseExe, parseOptions:=TestOptions.ReleaseExe.ParseOptions)
Dim verifier = CompileAndVerify(compilation, expectedOutput:=
<![CDATA[
Non-Async
Local : Changed
Parameter : Changed
Shared Field : Changed
Instance Field: Changed
Array element : Changed
Async
Local : Changed
Parameter : Changed
Shared Field : Changed
Instance Field: Changed
Array element : Changed
]]>)
End Sub
<Fact(), WorkItem(1040093, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1040093"), WorkItem(1026678, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1026678")>
Public Sub ParenthesizedVariableAsAReceiver_02()
Dim compilationDef =
<compilation>
<file name="a.vb">
Imports System
Imports System.Threading.Tasks
Module Module1
Sub Main()
System.Console.WriteLine("Non-Async")
System.Console.WriteLine()
TestLocal()
TestParameter()
TestSharedField()
TestInstanceField()
TestArrayElement()
System.Console.WriteLine()
System.Console.WriteLine("Async")
System.Console.WriteLine()
Task.WaitAll(TestLocalAsync())
Task.WaitAll(TestParameterAsync())
Task.WaitAll(TestSharedFieldAsync())
Task.WaitAll(TestInstanceFieldAsync())
Task.WaitAll(TestArrayElementAsync())
End Sub
Sub TestLocal()
Dim l As TestStruct2
l = TestStruct2.Create()
Call (l).fld2.Change()
System.Console.WriteLine("Local : {0}", l.fld2.State())
l = TestStruct2.Create()
Call ((l).fld2).Change()
System.Console.WriteLine("Local : {0}", l.fld2.State())
l = TestStruct2.Create()
Call (l.fld2).Change()
System.Console.WriteLine("Local : {0}", l.fld2.State())
End Sub
Sub TestParameter(Optional p As TestStruct2 = Nothing)
p = TestStruct2.Create()
Call (p).fld2.Change()
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
p = TestStruct2.Create()
Call ((p).fld2).Change()
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
p = TestStruct2.Create()
Call (p.fld2).Change()
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
End Sub
Private f As TestStruct2
Sub TestSharedField()
f = TestStruct2.Create()
Call (f).fld2.Change()
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
f = TestStruct2.Create()
Call ((f).fld2).Change()
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
f = TestStruct2.Create()
Call (f.fld2).Change()
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
End Sub
Sub TestInstanceField()
Dim i As TestClass
i = New TestClass()
Call (i).fld3.fld2.Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call ((i).fld3).fld2.Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (((i).fld3).fld2).Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (i.fld3).fld2.Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call ((i.fld3).fld2).Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (i.fld3.fld2).Change()
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
End Sub
Sub TestArrayElement()
Dim a = {TestStruct2.Create()}
Call (a(0)).fld2.Change()
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
a = {TestStruct2.Create()}
Call ((a(0)).fld2).Change()
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
a = {TestStruct2.Create()}
Call (a(0).fld2).Change()
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
End Sub
Async Function DummyAsync() As Task(Of Object)
Return Nothing
End Function
Async Function TestLocalAsync() As Task
Dim l As TestStruct2
l = TestStruct2.Create()
Call (l).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Local : {0}", l.fld2.State())
l = TestStruct2.Create()
Call ((l).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Local : {0}", l.fld2.State())
l = TestStruct2.Create()
Call (l.fld2).Change(Await DummyAsync())
System.Console.WriteLine("Local : {0}", l.fld2.State())
End Function
Async Function TestParameterAsync(Optional p As TestStruct2 = Nothing) As Task
p = TestStruct2.Create()
Call (p).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
p = TestStruct2.Create()
Call ((p).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
p = TestStruct2.Create()
Call (p.fld2).Change(Await DummyAsync())
System.Console.WriteLine("Parameter : {0}", p.fld2.State())
End Function
Async Function TestSharedFieldAsync() As Task
f = TestStruct2.Create()
Call (f).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
f = TestStruct2.Create()
Call ((f).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
f = TestStruct2.Create()
Call (f.fld2).Change(Await DummyAsync())
System.Console.WriteLine("Shared Field : {0}", f.fld2.State())
End Function
Async Function TestInstanceFieldAsync() As Task
Dim i As TestClass
i = New TestClass()
Call (i).fld3.fld2.Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call ((i).fld3).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (((i).fld3).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (i.fld3).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call ((i.fld3).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
i = New TestClass()
Call (i.fld3.fld2).Change(Await DummyAsync())
System.Console.WriteLine("Instance Field: {0}", i.fld3.fld2.State())
End Function
Async Function TestArrayElementAsync() As Task
Dim a = {TestStruct2.Create()}
Call (a(0)).fld2.Change(Await DummyAsync())
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
a = {TestStruct2.Create()}
Call ((a(0)).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
a = {TestStruct2.Create()}
Call (a(0).fld2).Change(Await DummyAsync())
System.Console.WriteLine("Array element : {0}", a(0).fld2.State())
End Function
End Module
Structure TestStruct1
Private fld1 As String
Shared Function Create() As TestStruct1
Return New TestStruct1() With {.fld1 = "Unchanged"}
End Function
Sub Change(Optional x As Object = Nothing)
fld1 = "Changed"
End Sub
Function State() As String
Return fld1
End Function
End Structure
Structure TestStruct2
Public fld2 As TestStruct1
Shared Function Create() As TestStruct2
Return New TestStruct2() With {.fld2 = TestStruct1.Create()}
End Function
End Structure
Class TestClass
Public fld3 As TestStruct2 = TestStruct2.Create()
End Class
</file>
</compilation>
Dim compilation = CompilationUtils.CreateEmptyCompilationWithReferences(compilationDef, {MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929}, TestOptions.ReleaseExe, parseOptions:=TestOptions.ReleaseExe.ParseOptions)
Dim verifier = CompileAndVerify(compilation, expectedOutput:=
<![CDATA[
Non-Async
Local : Changed
Local : Changed
Local : Changed
Parameter : Changed
Parameter : Changed
Parameter : Changed
Shared Field : Changed
Shared Field : Changed
Shared Field : Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Array element : Changed
Array element : Changed
Array element : Changed
Async
Local : Changed
Local : Changed
Local : Changed
Parameter : Changed
Parameter : Changed
Parameter : Changed
Shared Field : Changed
Shared Field : Changed
Shared Field : Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Instance Field: Changed
Array element : Changed
Array element : Changed
Array element : Changed
]]>)
End Sub
<Fact(), WorkItem(2903, "https://github.com/dotnet/roslyn/issues/2903")>
Public Sub DelegateWithParamArray()
Dim source1 =
<compilation>
<file name="a.vb"><![CDATA[
Imports System
Public Delegate Function MessageFormatter(ByVal format As String, <[ParamArray]> args As Object()) As String
]]></file>
</compilation>
Dim compilation1 = CreateCompilationWithMscorlib40(source1, options:=TestOptions.DebugDll)
Dim source2 =
<compilation>
<file name="a.vb"><![CDATA[
Imports System
Module Program
Sub Main()
Log(Function(f) f("Test {0}", 1))
Log(Function(f) f("Test"))
Log(Function(f) "test")
End Sub
Sub Log(messageFunc As Func(Of MessageFormatter, String))
Console.WriteLine(messageFunc(New MessageFormatter(Function(format, args) String.Format(format, args))))
End Sub
End Module
]]></file>
</compilation>
Dim expectedOutput = <![CDATA[
Test 1
Test
test
]]>
Dim compilation2 = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source2, {compilation1.EmitToImageReference()}, options:=TestOptions.DebugExe)
CompileAndVerify(compilation2, expectedOutput:=expectedOutput)
Dim compilation3 = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(source2, {New VisualBasicCompilationReference(compilation1)}, options:=TestOptions.DebugExe)
CompileAndVerify(compilation3, expectedOutput:=expectedOutput)
Dim source4 =
<compilation>
<file name="a.vb"><![CDATA[
Imports System
Public Delegate Function MessageFormatter(ByVal format As String, <[ParamArray]> args As Object()) As String
Module Program
Sub Main()
Log(Function(f) f("Test {0}", 1))
Log(Function(f) f("Test"))
Log(Function(f) "test")
End Sub
Sub Log(messageFunc As Func(Of MessageFormatter, String))
Console.WriteLine(messageFunc(New MessageFormatter(Function(format, args) String.Format(format, args))))
End Sub
End Module
]]></file>
</compilation>
Dim compilation4 = CreateCompilationWithMscorlib40AndVBRuntime(source4, options:=TestOptions.DebugExe)
CompileAndVerify(compilation4, expectedOutput:=expectedOutput)
End Sub
End Class
End Namespace
|