PageRenderTime 17ms CodeModel.GetById 5ms app.highlight 39ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Compilers/CSharp/Test/Semantic/Semantics/QueryTests.cs

https://github.com/EkardNT/Roslyn
C# | 2050 lines | 1855 code | 152 blank | 43 comment | 16 complexity | 482eaf29310b38b84269bda730a13cbc MD5 | raw file

Large files files are truncated, but you can click here to view the full 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;
   4using System.IO;
   5using System.Linq;
   6using Microsoft.CodeAnalysis.CSharp.Symbols;
   7using Microsoft.CodeAnalysis.CSharp.Syntax;
   8using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
   9using Roslyn.Test.Utilities;
  10using Xunit;
  11
  12namespace Microsoft.CodeAnalysis.CSharp.UnitTests
  13{
  14    public partial class QueryTests : CompilingTestBase
  15    {
  16        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
  17        [Fact]
  18        public void DegenerateQueryExpression()
  19        {
  20            var csSource = LINQ + @"
  21class Query
  22{
  23    public static void Main(string[] args)
  24    {
  25        List1<int> c = new List1<int>(1, 2, 3, 4, 5, 6, 7);
  26        List1<int> r = from i in c select i;
  27        if (ReferenceEquals(c, r)) throw new Exception();
  28        // List1<int> r = c.Select(i => i);
  29        Console.WriteLine(r);
  30    }
  31}";
  32            CompileAndVerify(csSource, expectedOutput: "[1, 2, 3, 4, 5, 6, 7]");
  33        }
  34
  35        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
  36        [Fact]
  37        public void QueryContinuation()
  38        {
  39            var csSource = LINQ + @"
  40class Query
  41{
  42    public static void Main(string[] args)
  43    {
  44        List1<int> c = new List1<int>(1, 2, 3, 4, 5, 6, 7);
  45        List1<int> r = from i in c select i into q select q;
  46        if (ReferenceEquals(c, r)) throw new Exception();
  47        // List1<int> r = c.Select(i => i);
  48        Console.WriteLine(r);
  49    }
  50}";
  51            CompileAndVerify(csSource, expectedOutput: "[1, 2, 3, 4, 5, 6, 7]");
  52        }
  53
  54        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
  55        [Fact]
  56        public void Select()
  57        {
  58            var csSource = LINQ + @"
  59class Query
  60{
  61    public static void Main(string[] args)
  62    {
  63        List1<int> c = new List1<int>(1, 2, 3, 4, 5, 6, 7);
  64        List1<int> r = from i in c select i+1;
  65        Console.WriteLine(r);
  66    }
  67}";
  68            CompileAndVerify(csSource, expectedOutput: "[2, 3, 4, 5, 6, 7, 8]");
  69        }
  70
  71        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
  72        [Fact]
  73        public void GroupBy01()
  74        {
  75            var csSource = LINQ + @"
  76class Query
  77{
  78    public static void Main(string[] args)
  79    {
  80        List1<int> c = new List1<int>(1, 2, 3, 4, 5, 6, 7);
  81        var r = from i in c group i by i % 2;
  82        Console.WriteLine(r);
  83    }
  84}";
  85            CompileAndVerify(csSource, expectedOutput: "[1:[1, 3, 5, 7], 0:[2, 4, 6]]");
  86        }
  87
  88        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
  89        [Fact]
  90        public void GroupBy02()
  91        {
  92            var csSource = LINQ + @"
  93class Query
  94{
  95    public static void Main(string[] args)
  96    {
  97        List1<int> c = new List1<int>(1, 2, 3, 4, 5, 6, 7);
  98        var r = from i in c group 10+i by i % 2;
  99        Console.WriteLine(r);
 100    }
 101}";
 102            CompileAndVerify(csSource, expectedOutput: "[1:[11, 13, 15, 17], 0:[12, 14, 16]]");
 103        }
 104
 105        [Fact]
 106        public void Cast()
 107        {
 108            var csSource = LINQ + @"
 109class Query
 110{
 111    public static void Main(string[] args)
 112    {
 113        List1<object> c = new List1<object>(1, 2, 3, 4, 5, 6, 7);
 114        List1<int> r = from int i in c select i;
 115        Console.WriteLine(r);
 116    }
 117}";
 118            CompileAndVerify(csSource, expectedOutput: "[1, 2, 3, 4, 5, 6, 7]");
 119        }
 120
 121        [Fact]
 122        public void Where()
 123        {
 124            var csSource = LINQ + @"
 125class Query
 126{
 127    public static void Main(string[] args)
 128    {
 129        List1<object> c = new List1<object>(1, 2, 3, 4, 5, 6, 7);
 130        List1<int> r = from int i in c where i < 5 select i;
 131        Console.WriteLine(r);
 132    }
 133}";
 134            CompileAndVerify(csSource, expectedOutput: "[1, 2, 3, 4]");
 135        }
 136
 137        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 138        [Fact]
 139        public void FromJoinSelect()
 140        {
 141            var csSource = LINQ + @"
 142class Query
 143{
 144    public static void Main(string[] args)
 145    {
 146        List1<int> c1 = new List1<int>(1, 2, 3, 4, 5, 7);
 147        List1<int> c2 = new List1<int>(10, 30, 40, 50, 60, 70);
 148        List1<int> r = from x1 in c1
 149                      join x2 in c2 on x1 equals x2/10
 150                      select x1+x2;
 151        Console.WriteLine(r);
 152    }
 153}";
 154            CompileAndVerify(csSource, expectedOutput: "[11, 33, 44, 55, 77]");
 155        }
 156
 157        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 158        [Fact]
 159        public void OrderBy()
 160        {
 161            var csSource = LINQ + @"
 162class Query
 163{
 164    public static void Main(string[] args)
 165    {
 166        List1<int> c = new List1<int>(28, 51, 27, 84, 27, 27, 72, 64, 55, 46, 39);
 167        var r =
 168            from i in c
 169            orderby i/10 descending, i%10
 170            select i;
 171        Console.WriteLine(r);
 172    }
 173}";
 174            CompileAndVerify(csSource, expectedOutput: "[84, 72, 64, 51, 55, 46, 39, 27, 27, 27, 28]");
 175        }
 176
 177        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 178        [Fact]
 179        public void GroupJoin()
 180        {
 181            var csSource = LINQ + @"
 182class Query
 183{
 184    public static void Main(string[] args)
 185    {
 186        List1<int> c1 = new List1<int>(1, 2, 3, 4, 5, 7);
 187        List1<int> c2 = new List1<int>(12, 34, 42, 51, 52, 66, 75);
 188        List1<string> r =
 189            from x1 in c1
 190            join x2 in c2 on x1 equals x2 / 10 into g
 191            select x1 + "":"" + g.ToString();
 192        Console.WriteLine(r);
 193    }
 194}";
 195            CompileAndVerify(csSource, expectedOutput: "[1:[12], 2:[], 3:[34], 4:[42], 5:[51, 52], 7:[75]]");
 196        }
 197
 198        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 199        [Fact]
 200        public void SelectMany01()
 201        {
 202            var csSource = LINQ + @"
 203class Query
 204{
 205    public static void Main(string[] args)
 206    {
 207        List1<int> c1 = new List1<int>(1, 2, 3);
 208        List1<int> c2 = new List1<int>(10, 20, 30);
 209        List1<int> r = from x in c1 from y in c2 select x + y;
 210        Console.WriteLine(r);
 211    }
 212}";
 213            CompileAndVerify(csSource, expectedOutput: "[11, 21, 31, 12, 22, 32, 13, 23, 33]");
 214        }
 215
 216        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 217        [Fact]
 218        public void SelectMany02()
 219        {
 220            var csSource = LINQ + @"
 221class Query
 222{
 223    public static void Main(string[] args)
 224    {
 225        List1<int> c1 = new List1<int>(1, 2, 3);
 226        List1<int> c2 = new List1<int>(10, 20, 30);
 227        List1<int> r = from x in c1 from int y in c2 select x + y;
 228        Console.WriteLine(r);
 229    }
 230}";
 231            CompileAndVerify(csSource, expectedOutput: "[11, 21, 31, 12, 22, 32, 13, 23, 33]");
 232        }
 233
 234        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 235        [Fact]
 236        public void Let01()
 237        {
 238            var csSource = LINQ + @"
 239class Query
 240{
 241    public static void Main(string[] args)
 242    {
 243        List1<int> c1 = new List1<int>(1, 2, 3);
 244        List1<int> r1 =
 245            from int x in c1
 246            let g = x * 10
 247            let z = g + x*100
 248            select x + z;
 249        System.Console.WriteLine(r1);
 250    }
 251}";
 252            CompileAndVerify(csSource, expectedOutput: "[111, 222, 333]");
 253        }
 254
 255        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 256        [Fact]
 257        public void TransparentIdentifiers_FromLet()
 258        {
 259            var csSource = @"
 260using C = List1<int>;" + LINQ + @"
 261class Query
 262{
 263    public static void Main(string[] args)
 264    {
 265        C c1 = new C(1, 2, 3);
 266        C c2 = new C(10, 20, 30);
 267        C c3 = new C(100, 200, 300);
 268        C r1 =
 269            from int x in c1
 270            from int y in c2
 271            from int z in c3
 272            let g = x + y + z
 273            where (x + y / 10 + z / 100) < 6
 274            select g;
 275       Console.WriteLine(r1);
 276    }
 277}";
 278            CompileAndVerify(csSource, expectedOutput: "[111, 211, 311, 121, 221, 131, 112, 212, 122, 113]");
 279        }
 280
 281        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 282        [Fact]
 283        public void TransparentIdentifiers_Join01()
 284        {
 285            var csSource = @"
 286using C = List1<int>;" + LINQ + @"
 287class Query
 288{
 289    public static void Main(string[] args)
 290    {
 291        C c1 = new C(1, 2, 3);
 292        C c2 = new C(10, 20, 30);
 293        C r1 =
 294            from int x in c1
 295            join y in c2 on x equals y/10
 296            let z = x+y
 297            select z;
 298        Console.WriteLine(r1);
 299    }
 300}";
 301            CompileAndVerify(csSource, expectedOutput: "[11, 22, 33]");
 302        }
 303
 304        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 305        [Fact]
 306        public void TransparentIdentifiers_Join02()
 307        {
 308            var csSource = LINQ + @"
 309class Query
 310{
 311    public static void Main(string[] args)
 312    {
 313        List1<int> c1 = new List1<int>(1, 2, 3, 4, 5, 7);
 314        List1<int> c2 = new List1<int>(12, 34, 42, 51, 52, 66, 75);
 315        List1<string> r1 = from x1 in c1
 316                      join x2 in c2 on x1 equals x2 / 10 into g
 317                      where x1 < 7
 318                      select x1 + "":"" + g.ToString();
 319        Console.WriteLine(r1);
 320    }
 321}";
 322            CompileAndVerify(csSource, expectedOutput: "[1:[12], 2:[], 3:[34], 4:[42], 5:[51, 52]]");
 323        }
 324
 325        [Fact]
 326        public void CodegenBug()
 327        {
 328            var csSource = LINQ + @"
 329class Query
 330{
 331    public static void Main(string[] args)
 332    {
 333        List1<int> c1 = new List1<int>(1, 2, 3, 4, 5, 7);
 334        List1<int> c2 = new List1<int>(12, 34, 42, 51, 52, 66, 75);
 335
 336        List1<Tuple<int, List1<int>>> r1 =
 337            c1
 338            .GroupJoin(c2, x1 => x1, x2 => x2 / 10, (x1, g) => new Tuple<int, List1<int>>(x1, g))
 339            ;
 340
 341        Func1<Tuple<int, List1<int>>, bool> condition = (Tuple<int, List1<int>> TR1) => TR1.Item1 < 7;
 342        List1<Tuple<int, List1<int>>> r2 =
 343            r1
 344            .Where(condition)
 345            ;
 346        Func1<Tuple<int, List1<int>>, string> map = (Tuple<int, List1<int>> TR1) => TR1.Item1.ToString() + "":"" + TR1.Item2.ToString();
 347
 348        List1<string> r3 =
 349            r2
 350            .Select(map)
 351            ;
 352        string r4 = r3.ToString();
 353        Console.WriteLine(r4);
 354        return;
 355    }
 356}";
 357            CompileAndVerify(csSource, expectedOutput: "[1:[12], 2:[], 3:[34], 4:[42], 5:[51, 52]]");
 358        }
 359
 360        [Fact]
 361        public void RangeVariables01()
 362        {
 363            var csSource = @"
 364using C = List1<int>;" + LINQ + @"
 365class Query
 366{
 367    public static void Main(string[] args)
 368    {
 369        C c1 = new C(1, 2, 3);
 370        C c2 = new C(10, 20, 30);
 371        C c3 = new C(100, 200, 300);
 372        C r1 =
 373            from int x in c1
 374            from int y in c2
 375            from int z in c3
 376            select x + y + z;
 377       Console.WriteLine(r1);
 378    }
 379}";
 380            var compilation = CreateCompilationWithMscorlib(csSource);
 381            compilation.VerifyDiagnostics();
 382            var tree = compilation.SyntaxTrees[0];
 383            var model = compilation.GetSemanticModel(tree);
 384            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "Query").Single();
 385            dynamic methodM = (MethodDeclarationSyntax)classC.Members[0];
 386            QueryExpressionSyntax q = methodM.Body.Statements[3].Declaration.Variables[0].Initializer.Value;
 387
 388            var info0 = model.GetQueryClauseInfo(q.FromClause);
 389            var x = model.GetDeclaredSymbol(q.FromClause);
 390            Assert.Equal(SymbolKind.RangeVariable, x.Kind);
 391            Assert.Equal("x", x.Name);
 392            Assert.Equal("Cast", info0.CastInfo.Symbol.Name);
 393            Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info0.CastInfo.Symbol).MethodKind);
 394            Assert.Null(info0.OperationInfo.Symbol);
 395
 396            var info1 = model.GetQueryClauseInfo(q.Body.Clauses[0]);
 397            var y = model.GetDeclaredSymbol(q.Body.Clauses[0]);
 398            Assert.Equal(SymbolKind.RangeVariable, y.Kind);
 399            Assert.Equal("y", y.Name);
 400            Assert.Equal("Cast", info1.CastInfo.Symbol.Name);
 401            Assert.Equal("SelectMany", info1.OperationInfo.Symbol.Name);
 402            Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info1.OperationInfo.Symbol).MethodKind);
 403
 404            var info2 = model.GetQueryClauseInfo(q.Body.Clauses[1]);
 405            var z = model.GetDeclaredSymbol(q.Body.Clauses[1]);
 406            Assert.Equal(SymbolKind.RangeVariable, z.Kind);
 407            Assert.Equal("z", z.Name);
 408            Assert.Equal("Cast", info2.CastInfo.Symbol.Name);
 409            Assert.Equal("SelectMany", info2.OperationInfo.Symbol.Name);
 410
 411            var info3 = model.GetSemanticInfoSummary(q.Body.SelectOrGroup);
 412            Assert.NotNull(info3);
 413            // what about info3's contents ???
 414
 415            var xPyPz = (q.Body.SelectOrGroup as SelectClauseSyntax).Expression as BinaryExpressionSyntax;
 416            var xPy = xPyPz.Left as BinaryExpressionSyntax;
 417            Assert.Equal(x, model.GetSemanticInfoSummary(xPy.Left).Symbol);
 418            Assert.Equal(y, model.GetSemanticInfoSummary(xPy.Right).Symbol);
 419            Assert.Equal(z, model.GetSemanticInfoSummary(xPyPz.Right).Symbol);
 420        }
 421
 422        [Fact]
 423        public void RangeVariables02()
 424        {
 425            var csSource = @"
 426using System;
 427using System.Linq;
 428class Query
 429{
 430    public static void Main(string[] args)
 431    {
 432        var c1 = new int[] {1, 2, 3};
 433        var c2 = new int[] {10, 20, 30};
 434        var c3 = new int[] {100, 200, 300};
 435        var r1 =
 436            from int x in c1
 437            from int y in c2
 438            from int z in c3
 439            select x + y + z;
 440       Console.WriteLine(r1);
 441    }
 442}";
 443            var compilation = CreateCompilationWithMscorlib(csSource, new[] { LinqAssemblyRef });
 444            foreach (var dd in compilation.GetDiagnostics()) Console.WriteLine(dd);
 445            compilation.VerifyDiagnostics();
 446            var tree = compilation.SyntaxTrees[0];
 447            var model = compilation.GetSemanticModel(tree);
 448            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "Query").Single();
 449            dynamic methodM = (MethodDeclarationSyntax)classC.Members[0];
 450            QueryExpressionSyntax q = methodM.Body.Statements[3].Declaration.Variables[0].Initializer.Value;
 451
 452            var info0 = model.GetQueryClauseInfo(q.FromClause);
 453            var x = model.GetDeclaredSymbol(q.FromClause);
 454            Assert.Equal(SymbolKind.RangeVariable, x.Kind);
 455            Assert.Equal("x", x.Name);
 456            Assert.Equal("Cast", info0.CastInfo.Symbol.Name);
 457            Assert.Equal(MethodKind.ReducedExtension, ((IMethodSymbol)info0.CastInfo.Symbol).MethodKind);
 458            Assert.Null(info0.OperationInfo.Symbol);
 459
 460            var info1 = model.GetQueryClauseInfo(q.Body.Clauses[0]);
 461            var y = model.GetDeclaredSymbol(q.Body.Clauses[0]);
 462            Assert.Equal(SymbolKind.RangeVariable, y.Kind);
 463            Assert.Equal("y", y.Name);
 464            Assert.Equal("Cast", info1.CastInfo.Symbol.Name);
 465            Assert.Equal("SelectMany", info1.OperationInfo.Symbol.Name);
 466            Assert.Equal(MethodKind.ReducedExtension, ((IMethodSymbol)info1.OperationInfo.Symbol).MethodKind);
 467
 468            var info2 = model.GetQueryClauseInfo(q.Body.Clauses[1]);
 469            var z = model.GetDeclaredSymbol(q.Body.Clauses[1]);
 470            Assert.Equal(SymbolKind.RangeVariable, z.Kind);
 471            Assert.Equal("z", z.Name);
 472            Assert.Equal("Cast", info2.CastInfo.Symbol.Name);
 473            Assert.Equal("SelectMany", info2.OperationInfo.Symbol.Name);
 474
 475            var info3 = model.GetSemanticInfoSummary(q.Body.SelectOrGroup);
 476            Assert.NotNull(info3);
 477            // what about info3's contents ???
 478
 479            var xPyPz = (q.Body.SelectOrGroup as SelectClauseSyntax).Expression as BinaryExpressionSyntax;
 480            var xPy = xPyPz.Left as BinaryExpressionSyntax;
 481            Assert.Equal(x, model.GetSemanticInfoSummary(xPy.Left).Symbol);
 482            Assert.Equal(y, model.GetSemanticInfoSummary(xPy.Right).Symbol);
 483            Assert.Equal(z, model.GetSemanticInfoSummary(xPyPz.Right).Symbol);
 484        }
 485
 486        [Fact]
 487        public void TestGetSemanticInfo01()
 488        {
 489            var csSource = @"
 490using C = List1<int>;" + LINQ + @"
 491class Query
 492{
 493    public static void Main(string[] args)
 494    {
 495        C c1 = new C(1, 2, 3);
 496        C c2 = new C(10, 20, 30);
 497        C r1 =
 498            from int x in c1
 499            from int y in c2
 500            select x + y;
 501       Console.WriteLine(r1);
 502    }
 503}";
 504            var compilation = CreateCompilationWithMscorlib(csSource);
 505            compilation.VerifyDiagnostics();
 506            var tree = compilation.SyntaxTrees[0];
 507            var model = compilation.GetSemanticModel(tree);
 508            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "Query").Single();
 509            dynamic methodM = (MethodDeclarationSyntax)classC.Members[0];
 510            QueryExpressionSyntax q = methodM.Body.Statements[2].Declaration.Variables[0].Initializer.Value;
 511
 512            var info0 = model.GetQueryClauseInfo(q.FromClause);
 513            Assert.Equal("Cast", info0.CastInfo.Symbol.Name);
 514            Assert.Null(info0.OperationInfo.Symbol);
 515            Assert.Equal("x", model.GetDeclaredSymbol(q.FromClause).Name);
 516
 517            var info1 = model.GetQueryClauseInfo(q.Body.Clauses[0]);
 518            Assert.Equal("Cast", info1.CastInfo.Symbol.Name);
 519            Assert.Equal("SelectMany", info1.OperationInfo.Symbol.Name);
 520            Assert.Equal("y", model.GetDeclaredSymbol(q.Body.Clauses[0]).Name);
 521
 522            var info2 = model.GetSemanticInfoSummary(q.Body.SelectOrGroup);
 523            // what about info2's contents?
 524        }
 525
 526        [Fact]
 527        public void TestGetSemanticInfo02()
 528        {
 529            var csSource = LINQ + @"
 530class Query
 531{
 532    public static void Main(string[] args)
 533    {
 534        List1<int> c = new List1<int>(28, 51, 27, 84, 27, 27, 72, 64, 55, 46, 39);
 535        var r =
 536            from i in c
 537            orderby i/10 descending, i%10
 538            select i;
 539        Console.WriteLine(r);
 540    }
 541}";
 542            var compilation = CreateCompilationWithMscorlib(csSource);
 543            compilation.VerifyDiagnostics();
 544            var tree = compilation.SyntaxTrees[0];
 545            var model = compilation.GetSemanticModel(tree);
 546            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "Query").Single();
 547            dynamic methodM = (MethodDeclarationSyntax)classC.Members[0];
 548            QueryExpressionSyntax q = methodM.Body.Statements[1].Declaration.Variables[0].Initializer.Value;
 549
 550            var info0 = model.GetQueryClauseInfo(q.FromClause);
 551            Assert.Null(info0.CastInfo.Symbol);
 552            Assert.Null(info0.OperationInfo.Symbol);
 553            Assert.Equal("i", model.GetDeclaredSymbol(q.FromClause).Name);
 554            var i = model.GetDeclaredSymbol(q.FromClause);
 555
 556            var info1 = model.GetQueryClauseInfo(q.Body.Clauses[0]);
 557            Assert.Null(info1.CastInfo.Symbol);
 558            Assert.Null(info1.OperationInfo.Symbol);
 559            Assert.Null(model.GetDeclaredSymbol(q.Body.Clauses[0]));
 560
 561            var order = q.Body.Clauses[0] as OrderByClauseSyntax;
 562            var oinfo0 = model.GetSemanticInfoSummary(order.Orderings[0]);
 563            Assert.Equal("OrderByDescending", oinfo0.Symbol.Name);
 564
 565            var oinfo1 = model.GetSemanticInfoSummary(order.Orderings[1]);
 566            Assert.Equal("ThenBy", oinfo1.Symbol.Name);
 567        }
 568
 569        [WorkItem(541774, "DevDiv")]
 570        [Fact]
 571        public void MultipleFromClauseIdentifierInExprNotInContext()
 572        {
 573            var csSource = @"
 574class Program
 575{
 576    static void Main(string[] args)
 577    {
 578        var q2 = from n1 in nums 
 579                 from n2 in nums
 580                 select n1;
 581    }
 582}";
 583            CreateCompilationWithMscorlibAndSystemCore(csSource, parseOptions: TestOptions.Regular).VerifyDiagnostics(
 584            // (6,29): error CS0103: The name 'nums' does not exist in the current context
 585                Diagnostic(ErrorCode.ERR_NameNotInContext, "nums").WithArguments("nums")
 586                );
 587        }
 588
 589        [WorkItem(541906, "DevDiv")]
 590        [Fact]
 591        public void NullLiteralFollowingJoinInQuery()
 592        {
 593            var csSource = @"
 594using System.Linq;
 595
 596class Program
 597{
 598    static void Main(string[] args)
 599    {
 600        var query = from int i in new int[]{ 1 } join null on true equals true select i; //CS1031
 601    }
 602}";
 603            CreateCompilationWithMscorlibAndSystemCore(csSource, parseOptions: TestOptions.Regular).VerifyDiagnostics(
 604                // (8,55): error CS1031: Type expected
 605                //         var query = from int i in new int[]{ 1 } join null on true equals true select i; //CS1031
 606                Diagnostic(ErrorCode.ERR_TypeExpected, "null"),
 607                // (8,55): error CS1001: Identifier expected
 608                //         var query = from int i in new int[]{ 1 } join null on true equals true select i; //CS1031
 609                Diagnostic(ErrorCode.ERR_IdentifierExpected, "null"),
 610                // (8,55): error CS1003: Syntax error, 'in' expected
 611                //         var query = from int i in new int[]{ 1 } join null on true equals true select i; //CS1031
 612                Diagnostic(ErrorCode.ERR_SyntaxError, "null").WithArguments("in", "null")
 613                );
 614        }
 615
 616        [WorkItem(541779, "DevDiv")]
 617        [Fact]
 618        public void MultipleFromClauseQueryExpr()
 619        {
 620            var csSource = @"
 621using System;
 622using System.Linq;
 623
 624class Program
 625{
 626    static void Main(string[] args)
 627    {
 628        var nums = new int[] { 3, 4 };
 629
 630        var q2 = from int n1 in nums 
 631                 from int n2 in nums
 632                 select n1;
 633
 634        string serializer = String.Empty;
 635        foreach (var q in q2)
 636        {
 637            serializer = serializer + q + "" "";
 638        }
 639        System.Console.Write(serializer.Trim());
 640    }
 641}";
 642
 643            CompileAndVerify(csSource, additionalRefs: new[] { LinqAssemblyRef }, expectedOutput: "3 3 4 4");
 644        }
 645
 646        [WorkItem(541782, "DevDiv")]
 647        [Fact]
 648        public void FromSelectQueryExprOnArraysWithTypeImplicit()
 649        {
 650            var csSource = @"
 651using System;
 652using System.Linq;
 653
 654class Program
 655{
 656    static void Main(string[] args)
 657    {
 658        var nums = new int[] { 3, 4 };
 659
 660        var q2 = from n1 in nums select n1;
 661
 662        string serializer = String.Empty;
 663        foreach (var q in q2)
 664        {
 665            serializer = serializer + q + "" "";
 666        }
 667        System.Console.Write(serializer.Trim());
 668    }
 669}";
 670            CompileAndVerify(csSource, additionalRefs: new[] { LinqAssemblyRef }, expectedOutput: "3 4");
 671        }
 672
 673
 674        [WorkItem(541788, "DevDiv")]
 675        [Fact]
 676        public void JoinClauseTest()
 677        {
 678            var csSource = @"
 679using System;
 680using System.Linq;
 681
 682class Program
 683{
 684    static void Main()
 685    {
 686        var q2 =
 687           from a in Enumerable.Range(1, 13)
 688           join b in Enumerable.Range(1, 13) on 4 * a equals b
 689           select a;
 690
 691        string serializer = String.Empty;
 692        foreach (var q in q2)
 693        {
 694            serializer = serializer + q + "" "";
 695        }
 696        System.Console.Write(serializer.Trim());
 697    }
 698}";
 699
 700            CompileAndVerify(csSource, additionalRefs: new[] { LinqAssemblyRef }, expectedOutput: "1 2 3");
 701        }
 702
 703        [WorkItem(541789, "DevDiv")]
 704        [WorkItem(9229, "DevDiv_Projects/Roslyn")]
 705        [Fact]
 706        public void WhereClauseTest()
 707        {
 708            var csSource = @"
 709using System;
 710using System.Linq;
 711
 712class Program
 713{
 714    static void Main()
 715    {
 716        var nums = new int[] { 1, 2, 3, 4 };
 717
 718        var q2 = from x in nums
 719                where (x > 2)
 720                select x;
 721
 722        string serializer = String.Empty;
 723        foreach (var q in q2)
 724        {
 725            serializer = serializer + q + "" "";
 726        }
 727        System.Console.Write(serializer.Trim());
 728    }
 729}";
 730
 731            CompileAndVerify(csSource, additionalRefs: new[] { LinqAssemblyRef }, expectedOutput: "3 4");
 732        }
 733
 734        [WorkItem(541942, "DevDiv")]
 735        [Fact]
 736        public void WhereDefinedInType()
 737        {
 738            var csSource = @"
 739using System;
 740
 741class Y
 742{
 743    public int Where(Func<int, bool> predicate)
 744    {
 745        return 45;
 746    }
 747}
 748
 749class P
 750{
 751    static void Main()
 752    {
 753        var src = new Y();
 754        var query = from x in src
 755                where x > 0
 756                select x;
 757
 758        Console.Write(query);
 759    }
 760}";
 761
 762            CompileAndVerify(csSource, additionalRefs: new[] { LinqAssemblyRef }, expectedOutput: "45");
 763        }
 764
 765        [Fact]
 766        public void GetInfoForSelectExpression01()
 767        {
 768            string sourceCode = @"
 769using System;
 770using System.Linq;
 771public class Test2
 772{
 773    public static void Main()
 774    {
 775        var nums = new int[] { 1, 2, 3, 4 };
 776
 777        var q2 = from x in nums
 778                 select x;
 779    }
 780}";
 781            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 782            var tree = compilation.SyntaxTrees[0];
 783            var semanticModel = compilation.GetSemanticModel(tree);
 784
 785            SelectClauseSyntax selectClause = (SelectClauseSyntax)tree.GetCompilationUnitRoot().FindToken(sourceCode.IndexOf("select")).Parent;
 786            var info = semanticModel.GetSemanticInfoSummary(selectClause.Expression);
 787            Assert.Equal(SpecialType.System_Int32, info.Type.SpecialType);
 788            Assert.Equal(SymbolKind.RangeVariable, info.Symbol.Kind);
 789            var info2 = semanticModel.GetSemanticInfoSummary(selectClause);
 790            var m = (MethodSymbol)info2.Symbol;
 791            Assert.Equal("Select", m.ReducedFrom.Name);
 792        }
 793
 794        [Fact]
 795        public void GetInfoForSelectExpression02()
 796        {
 797            string sourceCode = @"
 798using System;
 799using System.Linq;
 800public class Test2
 801{
 802    public static void Main()
 803    {
 804        var nums = new int[] { 1, 2, 3, 4 };
 805
 806        var q2 = from x in nums
 807                 select x into w
 808                 select w;
 809    }
 810}";
 811            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 812            var tree = compilation.SyntaxTrees[0];
 813            var semanticModel = compilation.GetSemanticModel(tree);
 814
 815            SelectClauseSyntax selectClause = (SelectClauseSyntax)tree.GetCompilationUnitRoot().FindToken(sourceCode.IndexOf("select w")).Parent;
 816            var info = semanticModel.GetSemanticInfoSummary(selectClause.Expression);
 817            Assert.Equal(SpecialType.System_Int32, info.Type.SpecialType);
 818            Assert.Equal(SymbolKind.RangeVariable, info.Symbol.Kind);
 819        }
 820
 821        [Fact]
 822        public void GetInfoForSelectExpression03()
 823        {
 824            string sourceCode = @"
 825using System.Linq;
 826public class Test2
 827{
 828    public static void Main()
 829    {
 830        var nums = new int[] { 1, 2, 3, 4 };
 831
 832        var q2 = from x in nums
 833                 select x+1 into w
 834                 select w+1;
 835    }
 836}";
 837            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 838            var tree = compilation.SyntaxTrees[0];
 839            compilation.VerifyDiagnostics();
 840            var semanticModel = compilation.GetSemanticModel(tree);
 841
 842            var e = (IdentifierNameSyntax)tree.GetCompilationUnitRoot().FindToken(sourceCode.IndexOf("x+1")).Parent;
 843            var info = semanticModel.GetSemanticInfoSummary(e);
 844            Assert.Equal(SpecialType.System_Int32, info.Type.SpecialType);
 845            Assert.Equal(SymbolKind.RangeVariable, info.Symbol.Kind);
 846            Assert.Equal("x", info.Symbol.Name);
 847
 848            e = (IdentifierNameSyntax)tree.GetCompilationUnitRoot().FindToken(sourceCode.IndexOf("w+1")).Parent;
 849            info = semanticModel.GetSemanticInfoSummary(e);
 850            Assert.Equal(SpecialType.System_Int32, info.Type.SpecialType);
 851            Assert.Equal(SymbolKind.RangeVariable, info.Symbol.Kind);
 852            Assert.Equal("w", info.Symbol.Name);
 853
 854            var e2 = e.Parent as ExpressionSyntax; // w+1
 855            var info2 = semanticModel.GetSemanticInfoSummary(e2);
 856            Assert.Equal(SpecialType.System_Int32, info2.Type.SpecialType);
 857            Assert.Equal("System.Int32 System.Int32.op_Addition(System.Int32 left, System.Int32 right)", info2.Symbol.ToTestDisplayString());
 858        }
 859
 860        [WorkItem(541806, "DevDiv")]
 861        [Fact]
 862        public void GetDeclaredSymbolForQueryContinuation()
 863        {
 864            string sourceCode = @"
 865public class Test2
 866{
 867    public static void Main()
 868    {
 869        var nums = new int[] { 1, 2, 3, 4 };
 870
 871        var q2 = from x in nums
 872                 select x into w
 873                 select w;
 874    }
 875}";
 876            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 877            var tree = compilation.SyntaxTrees[0];
 878            var semanticModel = compilation.GetSemanticModel(tree);
 879
 880            var queryContinuation = tree.GetRoot().FindToken(sourceCode.IndexOf("into w")).Parent;
 881            var symbol = semanticModel.GetDeclaredSymbol(queryContinuation);
 882            
 883            Assert.NotNull(symbol);
 884            Assert.Equal("w", symbol.Name);
 885            Assert.Equal(SymbolKind.RangeVariable, symbol.Kind);
 886        }
 887
 888        [WorkItem(541899, "DevDiv")]
 889        [Fact]
 890        public void ComputeQueryVariableType()
 891        {
 892            string sourceCode = @"
 893using System.Linq;
 894public class Test2
 895{
 896    public static void Main()
 897    {
 898        var nums = new int[] { 1, 2, 3, 4 };
 899
 900        var q2 = from x in nums
 901                 select 5;
 902    }
 903}";
 904            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 905            var tree = compilation.SyntaxTrees[0];
 906            var semanticModel = compilation.GetSemanticModel(tree);
 907            var selectExpression = tree.GetCompilationUnitRoot().FindToken(sourceCode.IndexOf("5"));
 908            var info = semanticModel.GetSpeculativeTypeInfo(selectExpression.SpanStart, SyntaxFactory.ParseExpression("x"), SpeculativeBindingOption.BindAsExpression);
 909            Assert.Equal(SpecialType.System_Int32, info.Type.SpecialType);
 910        }
 911
 912        [WorkItem(541893, "DevDiv")]
 913        [Fact]
 914        public void GetDeclaredSymbolForJoinIntoClause()
 915        {
 916            string sourceCode = @"
 917using System;
 918using System.Linq;
 919
 920static class Test
 921{
 922    static void Main()
 923    {
 924        var qie = from x3 in new int[] { 0 }
 925                      join x7 in (new int[] { 0 }) on 5 equals 5 into x8
 926                      select x8;
 927    }
 928}";
 929            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 930            var tree = compilation.SyntaxTrees[0];
 931            var semanticModel = compilation.GetSemanticModel(tree);
 932
 933            var joinInto = tree.GetRoot().FindToken(sourceCode.IndexOf("into x8")).Parent;
 934            var symbol = semanticModel.GetDeclaredSymbol(joinInto);
 935
 936            Assert.NotNull(symbol);
 937            Assert.Equal("x8", symbol.Name);
 938            Assert.Equal(SymbolKind.RangeVariable, symbol.Kind);
 939            Assert.Equal("? x8", symbol.ToTestDisplayString());
 940        }
 941
 942        [WorkItem(541982, "DevDiv")]
 943        [WorkItem(543494, "DevDiv")]
 944        [Fact()]
 945        public void GetDeclaredSymbolAddAccessorDeclIncompleteQuery()
 946        {
 947            string sourceCode = @"
 948using System;
 949using System.Linq;
 950
 951public class QueryExpressionTest
 952{
 953    public static void Main()
 954    {
 955        var expr1 = new[] { 1, 2, 3, 4, 5 };
 956
 957        var query1 = from  event in expr1 select event;
 958        var query2 = from int
 959    }
 960}";
 961            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 962            var tree = compilation.SyntaxTrees[0];
 963            var semanticModel = compilation.GetSemanticModel(tree);
 964
 965            var unknownAccessorDecls = tree.GetCompilationUnitRoot().DescendantNodes().OfType<AccessorDeclarationSyntax>();
 966            var symbols = unknownAccessorDecls.Select(decl => semanticModel.GetDeclaredSymbol(decl));
 967
 968            Assert.True(symbols.All(s => ReferenceEquals(s, null)));
 969        }
 970
 971        [WorkItem(542235, "DevDiv")]
 972        [Fact]
 973        public void TwoFromClauseFollowedBySelectClause()
 974        {
 975            string sourceCode = @"
 976using System.Linq;
 977
 978class Test
 979{
 980    public static void Main()
 981    {
 982
 983        var q2 = from num1 in new int[] { 4, 5 }
 984                 from num2 in new int[] { 4, 5 }
 985                 select num1;
 986    }
 987}";
 988            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
 989            var tree = compilation.SyntaxTrees[0];
 990            var semanticModel = compilation.GetSemanticModel(tree);
 991
 992            var selectClause = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => n.IsKind(SyntaxKind.SelectClause)).Single() as SelectClauseSyntax;
 993            var fromClause1 = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => (n.IsKind(SyntaxKind.FromClause)) && (n.ToString().Contains("num1"))).Single() as FromClauseSyntax;
 994            var fromClause2 = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => (n.IsKind(SyntaxKind.FromClause)) && (n.ToString().Contains("num2"))).Single() as FromClauseSyntax;
 995
 996            var symbolInfoForSelect = semanticModel.GetSemanticInfoSummary(selectClause);
 997            var queryInfoForFrom1 = semanticModel.GetQueryClauseInfo(fromClause1);
 998            var queryInfoForFrom2 = semanticModel.GetQueryClauseInfo(fromClause2);
 999
1000            Assert.Null(queryInfoForFrom1.CastInfo.Symbol);
1001            Assert.Null(queryInfoForFrom1.OperationInfo.Symbol);
1002
1003            Assert.Null(queryInfoForFrom2.CastInfo.Symbol);
1004            Assert.Equal("SelectMany", queryInfoForFrom2.OperationInfo.Symbol.Name);
1005
1006            Assert.Null(symbolInfoForSelect.Symbol);
1007            Assert.Empty(symbolInfoForSelect.CandidateSymbols);
1008            Assert.Equal(CandidateReason.None, symbolInfoForSelect.CandidateReason);
1009        }
1010
1011        [WorkItem(528747, "DevDiv")]
1012        [Fact]
1013        public void SemanticInfoForOrderingClauses()
1014        {
1015            string sourceCode = @"
1016using System;
1017using System.Linq;
1018
1019public class QueryExpressionTest
1020{
1021    public static void Main()
1022    {
1023        var q1 =
1024            from x in new int[] { 4, 5 }
1025            orderby
1026                x descending,
1027                x.ToString() ascending,
1028                x descending
1029            select x;
1030    }
1031}";
1032            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1033            var tree = compilation.SyntaxTrees[0];
1034            var model = compilation.GetSemanticModel(tree);
1035            int count = 0;
1036            string[] names = { "OrderByDescending", "ThenBy", "ThenByDescending" };
1037            foreach (var ordering in tree.GetCompilationUnitRoot().DescendantNodes().OfType<OrderingSyntax>())
1038            {
1039                var symbolInfo = model.GetSemanticInfoSummary(ordering);
1040                Assert.Equal(names[count++], symbolInfo.Symbol.Name);
1041            }
1042            Assert.Equal(3, count);
1043        }
1044
1045        [WorkItem(542266, "DevDiv")]
1046        [Fact]
1047        public void FromOrderBySelectQueryTranslation()
1048        {
1049            string sourceCode = @"
1050using System;
1051using System.Collections;
1052using System.Collections.Generic;
1053
1054public interface IOrderedEnumerable<TElement> : IEnumerable<TElement>,
1055    IEnumerable
1056{
1057}
1058
1059public static class Extensions
1060{
1061    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
1062    this IEnumerable<TSource> source,
1063    Func<TSource, TKey> keySelector)
1064
1065    {
1066        return null;
1067    }
1068
1069    public static IEnumerable<TResult> Select<TSource, TResult>(
1070    this IEnumerable<TSource> source,
1071    Func<TSource, TResult> selector)
1072
1073    {
1074        return null;
1075    }
1076}
1077
1078class Program
1079{
1080    static void Main(string[] args)
1081    {        
1082
1083        var q1 = from num in new int[] { 4, 5 }
1084                 orderby num
1085                 select num;
1086    }
1087}";
1088            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1089            var tree = compilation.SyntaxTrees[0];
1090            var semanticModel = compilation.GetSemanticModel(tree);
1091
1092            var selectClause = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => n.IsKind(SyntaxKind.SelectClause)).Single() as SelectClauseSyntax;
1093            var symbolInfoForSelect = semanticModel.GetSemanticInfoSummary(selectClause);
1094
1095            Assert.Null(symbolInfoForSelect.Symbol);
1096        }
1097
1098        [WorkItem(528756, "DevDiv")]
1099        [Fact]
1100        public void FromWhereSelectTranslation()
1101        {
1102            string sourceCode = @"
1103using System;
1104using System.Collections.Generic;
1105
1106public static class Extensions
1107{
1108
1109    public static IEnumerable<TSource> Where<TSource>(
1110    this IEnumerable<TSource> source,
1111    Func<TSource, bool> predicate)
1112    {
1113        return null;
1114    }
1115}
1116
1117class Program
1118{
1119    static void Main(string[] args)
1120    {
1121
1122        var q1 = from num in System.Linq.Enumerable.Range(4, 5).Where(n => n > 10)
1123                 select num;
1124    }
1125}";
1126            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1127            var tree = compilation.SyntaxTrees[0];
1128            var semanticModel = compilation.GetSemanticModel(tree);
1129
1130            semanticModel.GetDiagnostics().Verify(
1131                // (21,30): error CS1935: Could not find an implementation of the query pattern for source type 'System.Collections.Generic.IEnumerable<int>'.  'Select' not found.  Are you missing a reference to 'System.Core.dll' or a using directive for 'System.Linq'?
1132                //         var q1 = from num in System.Linq.Enumerable.Range(4, 5).Where(n => n > 10)
1133                Diagnostic(ErrorCode.ERR_QueryNoProviderStandard, "System.Linq.Enumerable.Range(4, 5).Where(n => n > 10)").WithArguments("System.Collections.Generic.IEnumerable<int>", "Select"));
1134        }
1135
1136        [WorkItem(528760, "DevDiv")]
1137        [Fact]
1138        public void FromJoinSelectTranslation()
1139        {
1140            string sourceCode = @"
1141using System.Linq;
1142
1143class Program
1144{
1145    static void Main(string[] args)
1146    {
1147        var q1 = from num in new int[] { 4, 5 }
1148                 join x1 in new int[] { 4, 5 } on num equals x1
1149                 select x1 + 5;
1150    }
1151}";
1152            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1153            var tree = compilation.SyntaxTrees[0];
1154            var semanticModel = compilation.GetSemanticModel(tree);
1155
1156            var selectClause = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => n.IsKind(SyntaxKind.SelectClause)).Single() as SelectClauseSyntax;
1157            var symbolInfoForSelect = semanticModel.GetSemanticInfoSummary(selectClause);
1158
1159            Assert.Null(symbolInfoForSelect.Symbol);
1160        }
1161
1162        [WorkItem(528761, "DevDiv")]
1163        [WorkItem(544585, "DevDiv")]
1164        [Fact]
1165        public void OrderingSyntaxWithOverloadResolutionFailure()
1166        {
1167            string sourceCode = @"
1168using System.Linq;
1169
1170class Program
1171{
1172    static void Main(string[] args)
1173    {
1174        int[] numbers = new int[] { 4, 5 };
1175
1176        var q1 = from num in numbers.Single()
1177                 orderby (x1) => x1.ToString()
1178                 select num;
1179    }
1180}";
1181
1182            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1183            compilation.VerifyDiagnostics(
1184                // (10,30): error CS1936: Could not find an implementation of the query pattern for source type 'int'.  'OrderBy' not found.
1185                //         var q1 = from num in numbers.Single()
1186                Diagnostic(ErrorCode.ERR_QueryNoProvider, "numbers.Single()").WithArguments("int", "OrderBy")
1187                );
1188            var tree = compilation.SyntaxTrees[0];
1189            var semanticModel = compilation.GetSemanticModel(tree);
1190
1191            var orderingClause = tree.GetCompilationUnitRoot().DescendantNodes().Where(n => n.IsKind(SyntaxKind.AscendingOrdering)).Single() as OrderingSyntax;
1192            var symbolInfoForOrdering = semanticModel.GetSemanticInfoSummary(orderingClause);
1193
1194            Assert.Null(symbolInfoForOrdering.Symbol);
1195        }
1196
1197        [WorkItem(542292, "DevDiv")]
1198        [Fact]
1199        public void EmitIncompleteQueryWithSyntaxErrors()
1200        {
1201            string sourceCode = @"
1202using System.Linq;
1203
1204class Program
1205{
1206    static int Main()
1207    {
1208        int [] foo = new int [] {1};
1209        var q = from x in foo
1210                select x + 1 into z
1211                    select z.T
1212";
1213            using (var output = new MemoryStream())
1214            {
1215                Assert.False(CreateCompilationWithMscorlibAndSystemCore(sourceCode).Emit(output).Success);
1216            }
1217        }
1218
1219        [WorkItem(542294, "DevDiv")]
1220        [Fact]
1221        public void EmitQueryWithBindErrors()
1222        {
1223            string sourceCode = @"
1224using System.Linq;
1225class Program
1226{
1227    static void Main()
1228    {
1229        int[] nums = { 0, 1, 2, 3, 4, 5 };
1230        var query = from num in nums
1231                    let num = 3 // CS1930
1232                    select num; 
1233    }
1234}";
1235            using (var output = new MemoryStream())
1236            {
1237                Assert.False(CreateCompilationWithMscorlibAndSystemCore(sourceCode).Emit(output).Success);
1238            }
1239        }
1240
1241        [WorkItem(542372, "DevDiv")]
1242        [Fact]
1243        public void BindToIncompleteSelectManyDecl()
1244        {
1245            string sourceCode = @"
1246class P
1247{
1248    static C<X> M2<X>(X x)
1249    {
1250        return new C<X>(x);
1251    }
1252
1253    static void Main()
1254    {
1255        C<int> e1 = new C<int>(1);
1256
1257        var q = from x1 in M2<int>(x1)
1258                from x2 in e1
1259                select x1;
1260    }
1261}
1262
1263class C<T>
1264{
1265    public C<V> SelectMany";
1266
1267            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1268            var tree = compilation.SyntaxTrees[0];
1269            var semanticModel = compilation.GetSemanticModel(tree);
1270
1271            var diags = semanticModel.GetDiagnostics();
1272
1273            Assert.NotEmpty(diags);
1274        }
1275
1276        [WorkItem(542419, "DevDiv")]
1277        [Fact]
1278        public void BindIdentifierInWhereErrorTolerance()
1279        {
1280            string sourceCode = @"
1281using System;
1282using System.Collections.Generic;
1283using System.Linq;
1284
1285class Program
1286{
1287    static void Main(string[] args)
1288    {
1289        var r = args.Where(b => b < > );
1290        var q = from a in args
1291                where a <> 
1292    }
1293}";
1294
1295            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1296            var tree = compilation.SyntaxTrees[0];
1297            var semanticModel = compilation.GetSemanticModel(tree);
1298            var diags = semanticModel.GetDiagnostics();
1299            Assert.NotEmpty(diags);
1300        }
1301
1302        [WorkItem(542460, "DevDiv")]
1303        [Fact]
1304        public void QueryWithMultipleParseErrorsAndInteractiveParseOption()
1305        {
1306            string sourceCode = @"
1307using System;
1308using System.Linq;
1309
1310public class QueryExpressionTest
1311{
1312    public static void Main()
1313    {
1314        var expr1 = new int[] { 1, 2, 3, 4, 5 };
1315
1316        var query2 = from int namespace in expr1 select namespace;
1317        var query25 = from i in expr1 let namespace = expr1 select i;
1318    }
1319}";
1320
1321            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode, parseOptions: TestOptions.Interactive);
1322            var tree = compilation.SyntaxTrees[0];
1323            var semanticModel = compilation.GetSemanticModel(tree);
1324            var queryExpr = tree.GetCompilationUnitRoot().DescendantNodes().OfType<QueryExpressionSyntax>().Where(x => x.ToFullString() == "from i in expr1 let ").Single();
1325            var symbolInfo = semanticModel.GetSemanticInfoSummary(queryExpr);
1326
1327            Assert.Null(symbolInfo.Symbol);
1328        }
1329
1330        [WorkItem(542496, "DevDiv")]
1331        [Fact]
1332        public void QueryExpressionInFieldInitReferencingAnotherFieldWithInteractiveParseOption()
1333        {
1334            string sourceCode = @"
1335using System.Linq;
1336using System.Collections;
1337
1338class P
1339{
1340    double one = 1;
1341
1342    public IEnumerable e = 
1343               from x in new int[] { 1, 2, 3 }
1344               select x + one;
1345}";
1346
1347            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode, parseOptions: TestOptions.Interactive);
1348            var tree = compilation.SyntaxTrees[0];
1349            var semanticModel = compilation.GetSemanticModel(tree);
1350            var queryExpr = tree.GetCompilationUnitRoot().DescendantNodes().OfType<QueryExpressionSyntax>().Single();
1351            var symbolInfo = semanticModel.GetSemanticInfoSummary(queryExpr);
1352
1353            Assert.Null(symbolInfo.Symbol);
1354        }
1355
1356        [WorkItem(542559, "DevDiv")]
1357        [Fact]
1358        public void StaticTypeInFromClause()
1359        {
1360            string sourceCode = @"
1361using System;
1362using System.Linq;
1363
1364class C
1365{
1366    static void Main()
1367    {
1368        var q2 = string.Empty.Cast<GC>().Select(x => x);
1369        var q1 = from GC x in string.Empty select x;
1370    }
1371}";
1372            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1373            compilation.VerifyDiagnostics(
1374                // (9,36): error CS0718: 'System.GC': static types cannot be used as type arguments
1375                //         var q2 = string.Empty.Cast<GC>().Select(x => x);
1376                Diagnostic(ErrorCode.ERR_GenericArgIsStaticClass, "GC").WithArguments("System.GC").WithLocation(9,36),
1377                // (10,23): error CS0718: 'System.GC': static types cannot be used as type arguments
1378                //         var q1 = from GC x in string.Empty select x;
1379                Diagnostic(ErrorCode.ERR_GenericArgIsStaticClass, "GC").WithArguments("System.GC").WithLocation(10,23)
1380                );
1381        }
1382
1383        [WorkItem(542560, "DevDiv")]
1384        [Fact]
1385        public void MethodGroupInFromClause()
1386        {
1387            string sourceCode = @"
1388class Program
1389{
1390    static void Main()
1391    {
1392        var q1 = from y in Main select y;
1393        var q2 = Main.Select(y => y);
1394    }
1395}";
1396            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1397            compilation.VerifyDiagnostics(
1398                // (6,28): error CS0119: 'Program.Main()' is a method, which is not valid in the given context
1399                //         var q1 = from y in Main select y;
1400                Diagnostic(ErrorCode.ERR_BadSKunknown, "Main").WithArguments("Program.Main()", "method").WithLocation(6,28),
1401                // (7,18): error CS0119: 'Program.Main()' is a method, which is not valid in the given context
1402                //         var q2 = Main.Select(y => y);
1403                Diagnostic(ErrorCode.ERR_BadSKunknown, "Main").WithArguments("Program.Main()", "method").WithLocation(7,18)
1404                );
1405        }
1406
1407        [WorkItem(542558, "DevDiv")]
1408        [Fact]
1409        public void SelectFromType01()
1410        {
1411            string sourceCode = @"using System;
1412using System.Collections.Generic;
1413 
1414class C
1415{
1416    static void Main()
1417    {
1418        var q = from x in C select x;
1419    }
1420
1421    static IEnumerable<T> Select<T>(Func<int, T> f) { return null; }
1422}";
1423            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1424            compilation.VerifyDiagnostics();
1425            var tree = compilation.SyntaxTrees[0];
1426            var model = compilation.GetSemanticModel(tree);
1427            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "C").Single();
1428            dynamic main = (MethodDeclarationSyntax)classC.Members[0];
1429            QueryExpressionSyntax q = main.Body.Statements[0].Declaration.Variables[0].Initializer.Value;
1430            var info0 = model.GetQueryClauseInfo(q.FromClause);
1431            var x = model.GetDeclaredSymbol(q.FromClause);
1432            Assert.Equal(SymbolKind.RangeVariable, x.Kind);
1433            Assert.Equal("x", x.Name);
1434            Assert.Equal(null, info0.CastInfo.Symbol);
1435            Assert.Null(info0.OperationInfo.Symbol);
1436            var infoSelect = model.GetSemanticInfoSummary(q.Body.SelectOrGroup);
1437            Assert.Equal("Select", infoSelect.Symbol.Name);
1438        }
1439
1440        [WorkItem(542558, "DevDiv")]
1441        [Fact]
1442        public void SelectFromType02()
1443        {
1444            string sourceCode = @"using System;
1445using System.Collections.Generic;
1446 
1447class C
1448{
1449    static void Main()
1450    {
1451        var q = from x in C select x;
1452    }
1453
1454    static Func<Func<int, object>, IEnumerable<object>> Select = null;
1455}";
1456            var compilation = CreateCompilationWithMscorlibAndSystemCore(sourceCode);
1457            compilation.VerifyDiagnostics();
1458            var tree = compilation.SyntaxTrees[0];
1459            var model = compilation.GetSemanticModel(tree);
1460            var classC = tree.GetCompilationUnitRoot().ChildNodes().OfType<TypeDeclarationSyntax>().Where(t => t.Identifier.ValueText == "C").Single();
1461            dynamic main = (MethodDeclarationSyntax)classC.Members[0];
1462            QueryExpressionSyntax q = main.Body.Statements[0].Declaration.Variables[0].Initializer.Value;
1463            var info0 = model.GetQueryClauseInfo(q.FromClause);
1464            var x = model.GetDeclaredSymbol(q.FromClause);
1465            Assert.Equal(SymbolKind.RangeVariable, x.Kind);
1466            Assert.Equal("x", x.Name);
1467            Assert.Equal(null, info0.CastInfo.Symbol);
1468            Assert.Null(info0.OperationInfo.Symbol);
1469            var infoSelect = model.GetSemanticInfoSummary(q.Body.SelectOrGroup);
1470            Assert.Equal("Invoke", infoSelect.Symbol.Name);
1471        }
1472
1473        [WorkItem(542624, "DevDiv")]
1474        [Fact]
1475        public void QueryColorColor()
1476        {
1477            string sourceCode = @"
1478using System;
1479using System.Collections.Generic;
1480
1481class Color
1482{
1483    public static IEnumerable<T> Sele

Large files files are truncated, but you can click here to view the full file