PageRenderTime 6ms CodeModel.GetById 8ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenImplicitlyTypeArraysTests.cs

https://github.com/EkardNT/Roslyn
C# | 1042 lines | 889 code | 82 blank | 71 comment | 0 complexity | cad50d6e10fdab93d06216a7d8d7c3d4 MD5 | raw file
   1// Copyright (c) Microsoft Open Technologies, Inc.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
   2
   3using System.IO;
   4using Microsoft.CodeAnalysis.CSharp.Symbols;
   5using Microsoft.CodeAnalysis.CSharp.Syntax;
   6using ProprietaryTestResources = Microsoft.CodeAnalysis.Test.Resources.Proprietary;
   7using Microsoft.CodeAnalysis.Test.Utilities;
   8using Microsoft.CodeAnalysis.Text;
   9using Roslyn.Test.Utilities;
  10using Xunit;
  11
  12namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
  13{
  14    public class CodeGenImplicitlyTypeArraysTests : CompilingTestBase
  15    {
  16        #region "Functionality tests"
  17
  18        [Fact]
  19        public void Test_001_Simple()
  20        {
  21            var source = @"
  22using System.Linq;
  23
  24namespace Test
  25{
  26    public class Program
  27    {
  28        public static void Main()
  29        {
  30            var a = new [] {1, 2, 3};
  31            
  32            System.Console.Write(a.SequenceEqual(new int[]{1, 2, 3}));
  33        }
  34    }
  35}
  36";
  37
  38            CompileAndVerify(
  39                source,
  40                emitOptions: EmitOptions.CCI,
  41                additionalRefs: new[] { LinqAssemblyRef },
  42                expectedOutput: "True");
  43        }
  44
  45        [Fact]
  46        public void Test_002_IntTypeBest()
  47        {
  48            // Best type: int
  49
  50            var source = @"
  51using System.Linq;
  52
  53namespace Test
  54{
  55    public class Program
  56    {
  57        public static void Main()
  58        {            
  59            var a = new [] {1, (byte)2, (short)3};
  60        
  61             System.Console.Write(a.SequenceEqual(new int[]{1, (byte)2, (short)3}));
  62        }
  63    }
  64}
  65";
  66
  67            CompileAndVerify(
  68              source,
  69              emitOptions: EmitOptions.CCI,
  70              additionalRefs: new[] { LinqAssemblyRef },
  71              expectedOutput: "True");
  72        }
  73
  74        [Fact]
  75        public void Test_003_DoubleTypeBest()
  76        {
  77            // Best type: double
  78
  79            var source = @"
  80using System.Linq;
  81
  82namespace Test
  83{
  84    public class Program
  85    {
  86        public static void Main()
  87        {            
  88            var a = new [] {(sbyte)1, (byte)2, (short)3, (ushort)4, 5, 6u, 7l, 8ul, (char)9, 10.0f, 11.0d};
  89        
  90           System.Console.Write(a.SequenceEqual(new double[]{(sbyte)1, (byte)2, (short)3, (ushort)4, 5, 6u, 7l, 8ul, (char)9, 10.0f, 11.0d}));
  91        }
  92    }
  93}
  94";
  95
  96            CompileAndVerify(
  97                source,
  98                emitOptions: EmitOptions.CCI,
  99                additionalRefs: new[] { LinqAssemblyRef },
 100                expectedOutput: "True");
 101        }
 102
 103        [Fact, WorkItem(895655, "DevDiv")]
 104        public void Test_004_Enum()
 105        {
 106            // Enums conversions
 107
 108            var source = @"
 109using System.Linq;
 110
 111namespace Test
 112{
 113    public class Program
 114    {
 115        enum E
 116        {
 117            START
 118        };
 119        
 120        public static void Main()
 121        {            
 122            var a = new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu};
 123        
 124             System.Console.Write(a.SequenceEqual(new E[]{E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}));
 125        }
 126    }
 127}
 128";
 129
 130            var comp = CreateCompilationWithMscorlib(source, references: new[] { LinqAssemblyRef });
 131            comp.VerifyDiagnostics(
 132    // (15,54): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 133    //             var a = new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu};
 134    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(15, 54),
 135    // (15,88): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 136    //             var a = new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu};
 137    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(15, 88),
 138    // (15,93): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 139    //             var a = new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu};
 140    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(15, 93),
 141    // (17,84): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 142    //              System.Console.Write(a.SequenceEqual(new E[]{E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}));
 143    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(17, 84),
 144    // (17,118): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 145    //              System.Console.Write(a.SequenceEqual(new E[]{E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}));
 146    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(17, 118),
 147    // (17,123): warning CS0078: The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
 148    //              System.Console.Write(a.SequenceEqual(new E[]{E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}));
 149    Diagnostic(ErrorCode.WRN_LowercaseEllSuffix, "l").WithLocation(17, 123),
 150    // (15,21): error CS0826: No best type found for implicitly-typed array
 151    //             var a = new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu};
 152    Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new [] {E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}").WithLocation(15, 21),
 153    // (17,35): error CS1929: '?[]' does not contain a definition for 'SequenceEqual' and the best extension method overload 'System.Linq.Queryable.SequenceEqual<Test.Program.E>(System.Linq.IQueryable<Test.Program.E>, System.Collections.Generic.IEnumerable<Test.Program.E>)' requires a receiver of type 'System.Linq.IQueryable<Test.Program.E>'
 154    //              System.Console.Write(a.SequenceEqual(new E[]{E.START, 0, 0U, 0u, 0L, 0l, 0UL, 0Ul, 0uL, 0ul, 0LU, 0Lu, 0lU, 0lu}));
 155    Diagnostic(ErrorCode.ERR_BadInstanceArgType, "a").WithArguments("?[]", "SequenceEqual", "System.Linq.Queryable.SequenceEqual<Test.Program.E>(System.Linq.IQueryable<Test.Program.E>, System.Collections.Generic.IEnumerable<Test.Program.E>)", "System.Linq.IQueryable<Test.Program.E>").WithLocation(17, 35)
 156                );
 157        }
 158
 159        [Fact]
 160        public void Test_005_ObjectTypeBest()
 161        {
 162            // Implicit reference conversions -- From any reference-type to object.
 163
 164            var source = @"
 165
 166using System.Linq;
 167
 168namespace Test
 169{
 170    public class C { };
 171    public interface I { };    
 172    public class C2 : I { };
 173    
 174    public class Program
 175    {
 176        delegate void D();
 177        
 178        public static void M() { }
 179        
 180        public static void Main()
 181        {
 182            object o = new object();
 183            C c = new C();
 184            I i = new C2();
 185            D d = new D(M);
 186            int[] aa = new int[] {1};
 187            
 188           var a = new [] {o, """", c, i, d, aa};
 189            
 190           System.Console.Write(a.SequenceEqual(new object[]{o, """", c, i, d, aa}));
 191        }
 192    }
 193}
 194";
 195
 196            CompileAndVerify(
 197                source,
 198                emitOptions: EmitOptions.CCI,
 199                additionalRefs: new[] { LinqAssemblyRef },
 200                expectedOutput: "True");
 201        }
 202
 203        [Fact]
 204        public void Test_006_ArrayTypeBest()
 205        {
 206            // Implicit reference conversions -- From an array-type S with an element type SE to an array-type T with an element type TE,
 207
 208            var source = @"
 209
 210using System.Linq;
 211
 212namespace Test
 213{
 214    public class Program
 215    {
 216        public static void Main()
 217        {
 218            object[] oa = new object[] {null};
 219            string[] sa = new string[] {null};
 220                        
 221            var a = new [] {oa, sa};
 222            
 223            System.Console.Write(a.SequenceEqual(new object[][]{oa, sa}));
 224        }
 225    }
 226}
 227";
 228
 229            CompileAndVerify(
 230                source,
 231                emitOptions: EmitOptions.CCI,
 232                additionalRefs: new[] { LinqAssemblyRef },
 233                expectedOutput: "True");
 234        }
 235
 236        [Fact]
 237        public void Test_007A()
 238        {
 239            // Implicit reference conversions -- From a one-dimensional array-type S[] to System.Collections.Generic.IList<S>.
 240
 241            var testSrc = @"
 242using System.Linq;
 243using System.Collections.Generic;
 244
 245namespace Test
 246{
 247    public class Program
 248    {
 249        public static void Main()
 250        {
 251            int[] ia = new int[] {1, 2, 3};
 252            IList<int> la = new List<int> {1, 2, 3};
 253                        
 254            var a = new [] {ia, la};
 255            
 256            System.Console.Write(a.SequenceEqual(new IList<int>[]{ia, la}));
 257        }
 258    }
 259}
 260";
 261            var compilation = CompileAndVerify(
 262                testSrc,
 263                emitOptions: EmitOptions.CCI,
 264                additionalRefs: new[] { LinqAssemblyRef },
 265                expectedOutput: "True");
 266        }
 267
 268        [Fact]
 269        public void Test_007B()
 270        {
 271            // Implicit reference conversions -- From a one-dimensional array-type S[] to System.Collections.Generic.IReadOnlyList<S>.
 272
 273            var testSrc = @"
 274using System.Collections.Generic;
 275
 276namespace Test
 277{
 278    public class Program
 279    {
 280        public static void Main()
 281        {
 282            int[] array = new int[] {1, 2, 3};
 283            object obj = array;
 284            IEnumerable<int> ro1 = array;
 285            IReadOnlyList<int> ro2 = (IReadOnlyList<int>)obj;
 286            IReadOnlyList<int> ro3 = (IReadOnlyList<int>)array;
 287            IReadOnlyList<int> ro4 = obj as IReadOnlyList<int>;
 288            System.Console.WriteLine(ro4 != null ? 1 : 2);
 289        }
 290    }
 291}
 292";
 293            // The version of mscorlib checked in to the test resources in v4_0_30316 does not have
 294            // the IReadOnlyList<T> and IReadOnlyCollection<T> interfaces. Use the one in v4_0_30316_17626.
 295
 296            var mscorlib17626 = new MetadataImageReference(ProprietaryTestResources.NetFX.v4_0_30316_17626.mscorlib.AsImmutableOrNull(), display: "mscorlib");
 297            CompileAndVerify(testSrc, new MetadataReference[] { mscorlib17626 }, expectedOutput: "1");
 298        }
 299
 300        [Fact]
 301        public void Test_008_DelegateType()
 302        {
 303            // Implicit reference conversions -- From any delegate-type to System.Delegate.
 304
 305            var source = @"
 306using System;
 307using System.Linq;
 308
 309namespace Test
 310{
 311    public class Program
 312    {
 313        delegate void D1();
 314        public static void M1() {}
 315        
 316        delegate int D2();
 317        public static int M2() { return 0;}
 318        
 319        delegate void D3(int i);
 320        public static void M3(int i) {}
 321        
 322        delegate void D4(params object[] o);
 323        public static void M4(params object[] o) { }
 324               
 325        public static void Main()
 326        {            
 327            D1 d1 = new D1(M1);
 328            D2 d2 = new D2(M2);
 329            D3 d3 = new D3(M3);
 330            D4 d4 = new D4(M4);
 331            Delegate d = d1;
 332        
 333            var a = new [] {d, d1, d2, d3, d4};
 334            
 335            System.Console.Write(a.SequenceEqual(new Delegate[]{d, d1, d2, d3, d4}));
 336        }
 337    }
 338}
 339";
 340
 341            CompileAndVerify(
 342                source,
 343                emitOptions: EmitOptions.CCI,
 344                additionalRefs: new[] { LinqAssemblyRef },
 345                expectedOutput: "True");
 346        }
 347
 348        [Fact]
 349        public void Test_009_Null()
 350        {
 351            // Implicit reference conversions -- From the null type to any reference-type.
 352
 353            var source = @"
 354using System.Linq;
 355
 356namespace Test
 357{
 358    public class Program
 359    {
 360        public static void Main()
 361        {
 362            var a = new [] {""aa"", ""bb"", null};
 363            
 364             System.Console.Write(a.SequenceEqual(new string[]{""aa"", ""bb"", null}));
 365        }
 366    }
 367}
 368";
 369
 370            CompileAndVerify(
 371                source,
 372                emitOptions: EmitOptions.CCI,
 373                additionalRefs: new[] { LinqAssemblyRef },
 374                expectedOutput: "True");
 375        }
 376
 377        [Fact]
 378        public void Test_010_TypeParameter()
 379        {
 380            // Implicit reference conversions -- 
 381            // For a type-parameter T that is known to be a reference type , the following 
 382            // implicit reference conversions exist:
 383            // From T to its effective base class C, from T to any base class of C, 
 384            // and from T to any interface implemented by C.
 385
 386            var source = @"
 387using System.Linq;
 388
 389namespace Test
 390{
 391    public interface I {}
 392    public class B {}
 393    public class C : B, I {}
 394    public class D : C {}
 395    
 396    public class Program
 397    {
 398        public static void M<T>() where T : C, new()
 399        {
 400            T t = new T();
 401            I i = t;
 402            
 403            var a = new [] {i, t};
 404            System.Console.Write(a.SequenceEqual(new I[]{i, t}));
 405        }
 406    
 407        public static void Main()
 408        {
 409            M<D>();
 410        }
 411    }
 412}
 413";
 414
 415            CompileAndVerify(
 416                source,
 417                emitOptions: EmitOptions.CCI,
 418                additionalRefs: new[] { LinqAssemblyRef },
 419                expectedOutput: "True");
 420        }
 421
 422        [Fact]
 423        public void Test_011_BoxingConversion()
 424        {
 425            // Implicit reference conversions -- Boxing conversions
 426
 427            var testSrc = @"
 428using System;
 429using System.Linq;
 430
 431namespace Test
 432{
 433    public struct S
 434    {
 435    }
 436    
 437    public class Program
 438    {
 439        enum E { START };
 440        
 441        public static void Main()
 442        {
 443            IComparable v = 1;
 444            int? i = 1;
 445            
 446            var a = new [] {v, i, E.START, true, (byte)2, (sbyte)3, (short)4, (ushort)5, 6, 7U, 8L, 9UL, 10.0F, 11.0D, 12M, (char)13};
 447            
 448            System.Console.Write(a.SequenceEqual(new IComparable[]{v, i, E.START, true, (byte)2, (sbyte)3, (short)4, (ushort)5, 6, 7U, 8L, 9UL, 10.0F, 11.0D, 12M, (char)13}));
 449        }
 450    }
 451}
 452";
 453            var compilation = CompileAndVerify(
 454                testSrc,
 455                emitOptions: EmitOptions.CCI,
 456                additionalRefs: new[] { LinqAssemblyRef },
 457                expectedOutput: "True");
 458        }
 459
 460        [Fact]
 461        public void Test_012_UserDefinedImplicitConversion()
 462        {
 463            // User-defined implicit conversions.
 464
 465            var testSrc = @"
 466using System.Linq;
 467
 468namespace Test
 469{
 470    public class B {}
 471    
 472    public class C
 473    {
 474        public static B b = new B();
 475        
 476        public static implicit operator B(C c)
 477        {
 478            return b;
 479        }
 480    }
 481    
 482    public class Program
 483    {
 484        public static void Main()
 485        {
 486            B b = new B();
 487            C c = new C();
 488            
 489            var a = new [] {b, c};
 490        
 491            System.Console.Write(a.SequenceEqual(new B[]{b, c}));
 492        }
 493    }
 494}
 495";
 496            // NYI: When user-defined conversion lowering is implemented, replace the
 497            // NYI: error checking below with:
 498            // var compilation = CompileAndVerify(testSrc, emitOptions: EmitOptions.CCI, 
 499            //    additionalRefs: GetReferences(), expectedOutput: "");
 500            var compilation = CreateCompilationWithMscorlibAndSystemCore(testSrc);
 501            compilation.VerifyDiagnostics();
 502        }
 503
 504        [Fact]
 505        public void Test_013_A_UserDefinedNullableConversions()
 506        {
 507            // Lifted user-defined conversions
 508
 509            var testSrc = @"
 510using System.Linq;
 511namespace Test
 512{
 513    public struct B { }
 514    public struct C
 515    {
 516        public static B b = new B();
 517        public static implicit operator B(C c)
 518        {
 519            return b;
 520        }
 521    }
 522    public class Program
 523    {
 524        public static void Main()
 525        {
 526            C? c = new C();
 527            B? b = new B();            
 528            if (!(new [] {b, c}.SequenceEqual(new B?[] {b, c})))
 529            {
 530                System.Console.WriteLine(""Test fail at struct C? implicitly convert to struct B?"");
 531            }
 532        }
 533    }
 534}
 535";
 536            // NYI: When lifted user-defined conversion lowering is implemented, replace the
 537            // NYI: error checking below with:
 538
 539            // var compilation = CompileAndVerify(testSrc, emitOptions: EmitOptions.CCI, 
 540            //     additionalRefs: GetReferences(), expectedOutput: "");
 541
 542            var compilation = CreateCompilationWithMscorlibAndSystemCore(testSrc);
 543            compilation.VerifyDiagnostics();
 544        }
 545
 546        // Bug 10700: We should be able to infer the array type from elements of types int? and short?
 547        [Fact]
 548        public void Test_013_B_NullableConversions()
 549        {
 550            // Lifted implicit numeric conversions
 551
 552            var testSrc = @"
 553using System.Linq;
 554namespace Test
 555{
 556    public class Program
 557    {
 558        public static void Main()
 559        {
 560            int? i = 1;
 561            short? s = 2;
 562            if (!new [] {i, s}.SequenceEqual(new int?[] {i, s}))
 563            {
 564                System.Console.WriteLine(""Test fail at short? implicitly convert to int?"");
 565            }
 566        }
 567    }
 568}
 569";
 570            // NYI: When lifted conversions are implemented, remove the diagnostics check
 571            // NYI: and replace it with:
 572            // var compilation = CompileAndVerify(testSrc, emitOptions: EmitOptions.CCI,
 573            //     additionalRefs: GetReferences(), expectedOutput: "");
 574
 575            var compilation = CreateCompilationWithMscorlibAndSystemCore(testSrc);
 576            compilation.VerifyDiagnostics();
 577        }
 578
 579        [Fact]
 580        public void Test_014_LambdaExpression()
 581        {
 582            // Implicitly conversion from lambda expression to compatible delegate type
 583
 584            var source = @"
 585using System;
 586
 587namespace Test
 588{
 589    public class Program
 590    {
 591        delegate int D(int i);
 592        
 593        public static int M(int i) {return i;}
 594        
 595        public static void Main()
 596        {            
 597           var a = new [] {new D(M), (int i)=>{return i;}, x => x+1, (int i)=>{short s = 2; return s;}};
 598        
 599           Console.Write(((a is D[]) && (a.Length==4)));
 600        }
 601    }
 602}
 603";
 604
 605            CompileAndVerify(
 606                source,
 607                emitOptions: EmitOptions.CCI,
 608                additionalRefs: new[] { LinqAssemblyRef },
 609                expectedOutput: "True");
 610        }
 611
 612        [Fact]
 613        public void Test_015_ImplicitlyTypedLocalExpr()
 614        {
 615            // local variable declared as "var" type is used inside an implicitly typed array.
 616
 617            var source = @"
 618using System.Linq;
 619
 620namespace Test
 621{
 622    public class B { };
 623    public class C : B { };
 624    
 625    public class Program
 626    {        
 627        public static void Main()
 628        {
 629            var b = new B();
 630            var c = new C();
 631            
 632            var a = new [] {b, c};
 633            
 634            System.Console.Write(a.SequenceEqual(new B[]{b, c}));
 635        }
 636    }
 637}
 638";
 639
 640            CompileAndVerify(
 641                source,
 642                emitOptions: EmitOptions.CCI,
 643                additionalRefs: new[] { LinqAssemblyRef },
 644                expectedOutput: "True");
 645        }
 646
 647        [Fact]
 648        public void Test_016_ArrayCreationExpression()
 649        {
 650            // Array creation expression as element in implicitly typed arrays
 651
 652            var source = @"
 653using System;
 654
 655namespace Test
 656{   
 657    public class Program
 658    {        
 659        public static void Main()
 660        {            
 661            var a = new [] {new int[1] , new int[3] {11, 12, 13}, new int[] {21, 22, 23}};
 662            
 663            Console.Write(((a is int[][]) && (a.Length==3)));
 664        }
 665    }
 666}
 667";
 668
 669            CompileAndVerify(
 670                source,
 671                emitOptions: EmitOptions.CCI,
 672                additionalRefs: new[] { LinqAssemblyRef },
 673                expectedOutput: "True");
 674        }
 675
 676        [Fact]
 677        public void Test_017_AnonymousObjectCreationExpression()
 678        {
 679            // Anonymous object creation expression as element in implicitly typed arrays
 680
 681            var source = @"
 682using System;
 683
 684namespace Test
 685{   
 686    public class Program
 687    {        
 688        public static void Main()
 689        {
 690            var a = new [] {new {i = 2, s = ""bb""}, new {i = 3, s = ""cc""}};
 691            
 692            Console.Write(((a is Array) && (a.Length==2)));
 693        }
 694    }
 695}
 696";
 697
 698            CompileAndVerify(
 699                source,
 700                emitOptions: EmitOptions.CCI,
 701                additionalRefs: new[] { LinqAssemblyRef },
 702                expectedOutput: "True");
 703        }
 704
 705        [Fact]
 706        public void Test_018_MemberAccessExpression()
 707        {
 708            // Member access expression as element in implicitly typed arrays
 709
 710            var source = @"
 711using System.Linq;
 712
 713using NT = Test;
 714
 715namespace Test
 716{
 717    public class Program
 718    {
 719        public delegate int D(string s);
 720        
 721        public static D d1 = new D(M2);
 722        
 723        public static int M<T>(string s) {return 1;}
 724                
 725        public static int M2(string s) {return 2;}        
 726            
 727        public D d2 = new D(M2);
 728        public static Program p = new Program();
 729        
 730        public static Program GetP() {return p;}
 731    
 732        public static void Main()
 733        {            
 734            System.Console.Write(new [] {Program.d1, Program.M<int>, GetP().d2, int.Parse, NT::Program.M2}.SequenceEqual( 
 735                                 new D[] {Program.d1, Program.M<int>, GetP().d2, int.Parse, NT::Program.M2}));
 736        }
 737    }
 738}
 739";
 740
 741            CompileAndVerify(
 742                source,
 743                emitOptions: EmitOptions.CCI,
 744                additionalRefs: new[] { LinqAssemblyRef },
 745                expectedOutput: "True");
 746        }
 747
 748        [Fact]
 749        public void Test_019_JaggedArray()
 750        {
 751            // JaggedArray in implicitly typed arrays
 752
 753            var source = @"
 754using System;
 755
 756namespace Test
 757{    
 758    public class Program
 759    {
 760        public static void Main()
 761        {        
 762            var a3 = new [] { new [] {new [] {1}}, 
 763                                         new [] {new int[] {2}}, 
 764                                         new int[][] {new int[] {3}}, 
 765                                         new int[][] {new [] {4}} };
 766            if ( !((a3 is int[][][]) && (a3.Length == 4)) )
 767            {
 768                Console.Write(""Test fail"");          
 769            }
 770            else
 771            {
 772                Console.Write(""True"");
 773            }            
 774        }
 775    }
 776}
 777";
 778
 779            CompileAndVerify(
 780                source,
 781                emitOptions: EmitOptions.CCI,
 782                additionalRefs: new[] { LinqAssemblyRef },
 783                expectedOutput: "True");
 784        }
 785
 786        [Fact]
 787        public void Test_020_MultiDimensionalArray()
 788        {
 789            // MultiDimensionalArray in implicitly typed arrays
 790
 791            var testSrc = @"
 792using System;
 793
 794namespace Test
 795{    
 796    public class Program
 797    {
 798        public static void Main()
 799        {            
 800            var a3 = new [] { new int[,,] {{{3, 4}}}, 
 801                              new int[,,] {{{3, 4}}} };
 802            if ( !((a3 is int[][,,]) && (a3.Rank == 1) && (a3.Length == 2)) )
 803            {
 804                Console.WriteLine(0);
 805            }
 806            else
 807            {
 808                Console.WriteLine(1);
 809            }
 810        }
 811    }
 812}";
 813
 814            CompileAndVerify(testSrc, expectedOutput: "1");
 815        }
 816
 817        [Fact]
 818        public void Test_021_MultiDimensionalArray_02()
 819        {
 820            // Implicitly typed arrays should can be used in creating MultiDimensionalArray
 821
 822            var testSrc = @"
 823using System;
 824
 825namespace Test
 826{    
 827    public class Program
 828    {
 829        public static void Main()
 830        {           
 831            var a3 = new [,,] { {{2, 3, 4}}, {{2, 3, 4}} };
 832            if ( !((a3 is int[,,]) && (a3.Rank == 3) && (a3.Length == 6)) )
 833            {
 834                Console.WriteLine(0);
 835            }
 836            else
 837            {
 838                Console.WriteLine(1);
 839            }
 840        }
 841    }
 842}
 843";
 844            CompileAndVerify(testSrc, expectedOutput: "1");
 845        }
 846
 847        [Fact]
 848        public void Test_022_GenericMethod()
 849        {
 850            //  Implicitly typed arrays used in generic method
 851
 852            var source = @"
 853using System.Linq;
 854
 855namespace Test
 856{   
 857    public class Program
 858    {
 859        public static void Main()
 860        {
 861            System.Console.Write(GM(new [] {1, 2, 3}).SequenceEqual(new int[]{1, 2, 3}));
 862        }
 863    
 864        public static T GM<T>(T t)
 865        {
 866           return t;
 867        }
 868    }
 869}
 870";
 871
 872            CompileAndVerify(
 873                source,
 874                emitOptions: EmitOptions.CCI,
 875                additionalRefs: new[] { LinqAssemblyRef },
 876                expectedOutput: "True");
 877        }
 878
 879        [Fact]
 880        public void Test_023_Query()
 881        {
 882            //  Query expression as element in implicitly typed arrays 
 883
 884            var source = @"
 885using System;
 886using System.Collections;
 887using System.Collections.Generic;
 888using System.Linq;
 889
 890public class Program
 891{        
 892     public static void Main()
 893     {            
 894        int[] ta = new int[] {1, 2, 3, 4, 5};
 895        IEnumerable i = ta;
 896                        
 897        IEnumerable[] a = new [] {i, from c in ta select c, from c in ta group c by c, 
 898                                  from c in ta select c into g select g, from c in ta where c==3 select c, 
 899                                  from c in ta orderby c select c, from c in ta orderby c ascending select c, 
 900                                  from c in ta orderby c descending select c, from c in ta where c==3 orderby c select c};        
 901 
 902        Console.Write((a is IEnumerable[]) && (a.Length==9));
 903        }
 904}
 905";
 906
 907            CompileAndVerify(
 908                source,
 909                emitOptions: EmitOptions.CCI,
 910                additionalRefs: new[] { LinqAssemblyRef },
 911                expectedOutput: "True");
 912        }
 913
 914        [Fact]
 915        public void Test_023_Literal()
 916        {
 917            //  Query expression as element in implicitly typed arrays 
 918
 919            var source = @"
 920using System;
 921using System.Linq;
 922
 923public class Program
 924{
 925    public static void Main()
 926    {          
 927            Console.Write(new [] {true, false}.SequenceEqual(new bool[] {true, false}));
 928            Console.Write(new [] {0123456789U, 1234567890U, 2345678901u, 3456789012UL, 4567890123Ul, 5678901234UL, 6789012345Ul, 7890123456uL, 8901234567ul, 9012345678LU, 9123456780Lu, 1234567809LU, 2345678091LU}.SequenceEqual(
 929                          new ulong[] {0123456789U, 1234567890U, 2345678901u, 3456789012UL, 4567890123Ul, 5678901234UL, 6789012345Ul, 7890123456uL, 8901234567ul, 9012345678LU, 9123456780Lu, 1234567809LU, 2345678091LU}));
 930            Console.Write(new [] {0123456789, 1234567890, 2345678901, 3456789012L, 4567890123L, 5678901234L, 6789012345L, 7890123456L, 8901234567L, 9012345678L, 9123456780L, 1234567809L, 2345678091L}.SequenceEqual( 
 931                          new long[] {0123456789, 1234567890, 2345678901, 3456789012L, 4567890123L, 5678901234L, 6789012345L, 7890123456L, 8901234567L, 9012345678L, 9123456780L, 1234567809L, 2345678091L}));
 932            Console.Write(new [] {0x012345U, 0x6789ABU, 0xCDEFabU, 0xcdef01U, 0X123456U, 0x12579BU, 0x13579Bu, 0x14579BLU, 0x15579BLU, 0x16579BUL, 0x17579BUl, 0x18579BuL, 0x19579Bul, 0x1A579BLU, 0x1B579BLu, 0x1C579BLU, 0x1C579BLu}.SequenceEqual( 
 933                          new ulong[] {0x012345U, 0x6789ABU, 0xCDEFabU, 0xcdef01U, 0X123456U, 0x12579BU, 0x13579Bu, 0x14579BLU, 0x15579BLU, 0x16579BUL, 0x17579BUl, 0x18579BuL, 0x19579Bul, 0x1A579BLU, 0x1B579BLu, 0x1C579BLU, 0x1C579BLu}));
 934            Console.Write(new [] {0x012345, 0x6789AB, 0xCDEFab, 0xcdef01, 0X123456, 0x12579B, 0x13579B, 0x14579BL, 0x15579BL, 0x16579BL, 0x17579BL, 0x18579BL, 0x19579BL, 0x1A579BL, 0x1B579BL, 0x1C579BL, 0x1C579BL}.SequenceEqual(
 935                          new long[] {0x012345, 0x6789AB, 0xCDEFab, 0xcdef01, 0X123456, 0x12579B, 0x13579B, 0x14579BL, 0x15579BL, 0x16579BL, 0x17579BL, 0x18579BL, 0x19579BL, 0x1A579BL, 0x1B579BL, 0x1C579BL, 0x1C579BL}));
 936            Console.Write(new [] {0123456789F, 1234567890f, 2345678901D, 3456789012d, 3.2, 3.3F, 3.4e5, 3.5E5, 3.6E+5, 3.7E-5, 3.8e+5, 3.9e-5, 3.22E5D, .234, .23456D, .245e3, .2334e7D, 3E5, 3E-5, 3E+6, 4E4D}.SequenceEqual(
 937                          new double[] {0123456789F, 1234567890f, 2345678901D, 3456789012d, 3.2, 3.3F, 3.4e5, 3.5E5, 3.6E+5, 3.7E-5, 3.8e+5, 3.9e-5, 3.22E5D, .234, .23456D, .245e3, .2334e7D, 3E5, 3E-5, 3E+6, 4E4D})) ;    
 938            Console.Write(new [] {0123456789M, 1234567890m, 3.3M, 3.22E5M, 3.2E+4M, 3.3E-4M, .234M, .245e3M, .2334e+7M, .24e-3M, 3E5M, 3E-5M, 3E+6M}.SequenceEqual(
 939                          new decimal[] {0123456789M, 1234567890m, 3.3M, 3.22E5M, 3.2E+4M, 3.3E-4M, .234M, .245e3M, .2334e+7M, .24e-3M, 3E5M, 3E-5M, 3E+6M}));
 940            Console.Write(new [] {0123456789, 5678901234UL, 2345678901D, 3.2, 3.4E5, 3.6E+5, 3.7E-5, 3.22E5D, .234, .23456D, .245E3, 3E5, 4E4D}.SequenceEqual(
 941                          new double[] {0123456789, 5678901234UL, 2345678901D, 3.2, 3.4E5, 3.6E+5, 3.7E-5, 3.22E5D, .234, .23456D, .245E3, 3E5, 4E4D}));
 942            Console.Write(new [] {0123456789, 5678901234UL, 2345678901M, 3.2M, 3.4E5M, 3.6E+5M, 3.7E-5M, .234M, .245E3M, 3E5M}.SequenceEqual(
 943                          new decimal[] {0123456789, 5678901234UL, 2345678901M, 3.2M, 3.4E5M, 3.6E+5M, 3.7E-5M, .234M, .245E3M, 3E5M}));
 944   }
 945}
 946";
 947
 948            CompileAndVerify(
 949                source,
 950                emitOptions: EmitOptions.CCI,
 951                additionalRefs: new[] { LinqAssemblyRef },
 952                expectedOutput: "TrueTrueTrueTrueTrueTrueTrueTrueTrue");
 953        }
 954
 955        #endregion
 956
 957        #region "Error tests"
 958
 959        [Fact]
 960        public void Error_NonArrayInitExpr()
 961        {
 962            var testSrc = @"
 963namespace Test
 964{
 965    public class Program
 966    {
 967        public void Foo()
 968        {
 969            var a3 = new[,,] { { { 3, 4 } }, 3, 4 };
 970        }
 971    }
 972}
 973";
 974            var comp = CreateCompilationWithMscorlib(testSrc);
 975            comp.VerifyDiagnostics(
 976                // (8,46): error CS0846: A nested array initializer is expected
 977                //             var a3 = new[,,] { { { 3, 4 } }, 3, 4 };
 978                Diagnostic(ErrorCode.ERR_ArrayInitializerExpected, "3").WithLocation(8, 46),
 979                // (8,49): error CS0846: A nested array initializer is expected
 980                //             var a3 = new[,,] { { { 3, 4 } }, 3, 4 };
 981                Diagnostic(ErrorCode.ERR_ArrayInitializerExpected, "4").WithLocation(8, 49));
 982        }
 983
 984        [Fact]
 985        public void Error_NonArrayInitExpr_02()
 986        {
 987            var testSrc = @"
 988namespace Test
 989{
 990    public class Program
 991    {
 992        public void Foo()
 993        {
 994            var a3 = new[,,] { { { 3, 4 } }, x, 4 };
 995        }
 996    }
 997}
 998";
 999            var comp = CreateCompilationWithMscorlib(testSrc);
1000            comp.VerifyDiagnostics(
1001                // (8,46): error CS0103: The name 'x' does not exist in the current context
1002                //             var a3 = new[,,] { { { 3, 4 } }, x, 4 };
1003                Diagnostic(ErrorCode.ERR_NameNotInContext, "x").WithArguments("x").WithLocation(8, 46),
1004                // (8,49): error CS0846: A nested array initializer is expected
1005                //             var a3 = new[,,] { { { 3, 4 } }, x, 4 };
1006                Diagnostic(ErrorCode.ERR_ArrayInitializerExpected, "4").WithLocation(8, 49));
1007        }
1008
1009        [WorkItem(543571, "DevDiv")]
1010        [Fact]
1011        public void CS0826ERR_ImplicitlyTypedArrayNoBestType()
1012        {
1013            var text = @"
1014using System;
1015
1016namespace Test
1017{
1018    public class Program
1019    {
1020        enum E
1021        {
1022            Zero,
1023            FortyTwo = 42
1024        };
1025
1026        public static void Main()
1027        {
1028            E[] a = new[] { E.FortyTwo, 0 }; // Dev10 error CS0826
1029            Console.WriteLine(String.Format(""Type={0}, a[0]={1}, a[1]={2}"", a.GetType(), a[0], a[1]));
1030        }
1031    }
1032}
1033";
1034            CreateCompilationWithMscorlib(text).VerifyDiagnostics(
1035                // (16,21): error CS0826: No best type found for implicitly-typed array
1036                //             E[] a = new[] { E.FortyTwo, 0 }; // Dev10 error CS0826
1037                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { E.FortyTwo, 0 }").WithLocation(16, 21));
1038        }
1039
1040        #endregion
1041    }
1042}