mcs/class/referencesource/System.Data.Entity/System/Data/Objects/ELinq/ReflectionUtil.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="ReflectionUtil.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner  [....]
   7 //---------------------------------------------------------------------
   8
   9 using System.Reflection;
  10 using System.Collections.Generic;
  11 using System.Linq;
  12 using System.Linq.Expressions;
  13 using System.Text;
  14 using System.Globalization;
  15 namespace System.Data.Objects.ELinq
  16 {
  17     /// <summary>
  18     /// Static utility class for identifying methods in Queryable, Sequence, and IEnumerable
  19     /// and
  20     /// </summary>
  21     internal static class ReflectionUtil
  22     {
  23         #region Static information on sequence methods
  24         private static readonly Dictionary<MethodInfo, SequenceMethod> s_methodMap;
  25         private static readonly Dictionary<SequenceMethod, MethodInfo> s_inverseMap;
  26
  27         // Initialize method map
  28         static ReflectionUtil()
  29         {
  30             // register known canonical method names
  31             Dictionary<String, SequenceMethod> map = new Dictionary<string, SequenceMethod>();
  32
  33             //
  34             // DO NOT MODIFY CODE BELOW THIS LINE: CODE GEN TOOL DEPENDS ON THE REGION TAG
  35             //
  36             #region Code generated by ReflectionUtilCodeGen tool
  37             map.Add(@"AsQueryable(IEnumerable`1<T0>)->IQueryable`1<T0>", SequenceMethod.AsQueryableGeneric);
  38             map.Add(@"AsQueryable(IEnumerable)->IQueryable", SequenceMethod.AsQueryable);
  39             map.Add(@"Where(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->IQueryable`1<T0>", SequenceMethod.Where);
  40             map.Add(@"Where(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, Boolean>>)->IQueryable`1<T0>", SequenceMethod.WhereOrdinal);
  41             map.Add(@"OfType(IQueryable)->IQueryable`1<T0>", SequenceMethod.OfType);
  42             map.Add(@"Cast(IQueryable)->IQueryable`1<T0>", SequenceMethod.Cast);
  43             map.Add(@"Select(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IQueryable`1<T1>", SequenceMethod.Select);
  44             map.Add(@"Select(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, T1>>)->IQueryable`1<T1>", SequenceMethod.SelectOrdinal);
  45             map.Add(@"SelectMany(IQueryable`1<T0>, Expression`1<Func`2<T0, IEnumerable`1<T1>>>)->IQueryable`1<T1>", SequenceMethod.SelectMany);
  46             map.Add(@"SelectMany(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, IEnumerable`1<T1>>>)->IQueryable`1<T1>", SequenceMethod.SelectManyOrdinal);
  47             map.Add(@"SelectMany(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, IEnumerable`1<T1>>>, Expression`1<Func`3<T0, T1, T2>>)->IQueryable`1<T2>", SequenceMethod.SelectManyOrdinalResultSelector);
  48             map.Add(@"SelectMany(IQueryable`1<T0>, Expression`1<Func`2<T0, IEnumerable`1<T1>>>, Expression`1<Func`3<T0, T1, T2>>)->IQueryable`1<T2>", SequenceMethod.SelectManyResultSelector);
  49             map.Add(@"Join(IQueryable`1<T0>, IEnumerable`1<T1>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`2<T1, T2>>, Expression`1<Func`3<T0, T1, T3>>)->IQueryable`1<T3>", SequenceMethod.Join);
  50             map.Add(@"Join(IQueryable`1<T0>, IEnumerable`1<T1>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`2<T1, T2>>, Expression`1<Func`3<T0, T1, T3>>, IEqualityComparer`1<T2>)->IQueryable`1<T3>", SequenceMethod.JoinComparer);
  51             map.Add(@"GroupJoin(IQueryable`1<T0>, IEnumerable`1<T1>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`2<T1, T2>>, Expression`1<Func`3<T0, IEnumerable`1<T1>, T3>>)->IQueryable`1<T3>", SequenceMethod.GroupJoin);
  52             map.Add(@"GroupJoin(IQueryable`1<T0>, IEnumerable`1<T1>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`2<T1, T2>>, Expression`1<Func`3<T0, IEnumerable`1<T1>, T3>>, IEqualityComparer`1<T2>)->IQueryable`1<T3>", SequenceMethod.GroupJoinComparer);
  53             map.Add(@"OrderBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IOrderedQueryable`1<T0>", SequenceMethod.OrderBy);
  54             map.Add(@"OrderBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, IComparer`1<T1>)->IOrderedQueryable`1<T0>", SequenceMethod.OrderByComparer);
  55             map.Add(@"OrderByDescending(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IOrderedQueryable`1<T0>", SequenceMethod.OrderByDescending);
  56             map.Add(@"OrderByDescending(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, IComparer`1<T1>)->IOrderedQueryable`1<T0>", SequenceMethod.OrderByDescendingComparer);
  57             map.Add(@"ThenBy(IOrderedQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IOrderedQueryable`1<T0>", SequenceMethod.ThenBy);
  58             map.Add(@"ThenBy(IOrderedQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, IComparer`1<T1>)->IOrderedQueryable`1<T0>", SequenceMethod.ThenByComparer);
  59             map.Add(@"ThenByDescending(IOrderedQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IOrderedQueryable`1<T0>", SequenceMethod.ThenByDescending);
  60             map.Add(@"ThenByDescending(IOrderedQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, IComparer`1<T1>)->IOrderedQueryable`1<T0>", SequenceMethod.ThenByDescendingComparer);
  61             map.Add(@"Take(IQueryable`1<T0>, Int32)->IQueryable`1<T0>", SequenceMethod.Take);
  62             map.Add(@"TakeWhile(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->IQueryable`1<T0>", SequenceMethod.TakeWhile);
  63             map.Add(@"TakeWhile(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, Boolean>>)->IQueryable`1<T0>", SequenceMethod.TakeWhileOrdinal);
  64             map.Add(@"Skip(IQueryable`1<T0>, Int32)->IQueryable`1<T0>", SequenceMethod.Skip);
  65             map.Add(@"SkipWhile(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->IQueryable`1<T0>", SequenceMethod.SkipWhile);
  66             map.Add(@"SkipWhile(IQueryable`1<T0>, Expression`1<Func`3<T0, Int32, Boolean>>)->IQueryable`1<T0>", SequenceMethod.SkipWhileOrdinal);
  67             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->IQueryable`1<IGrouping`2<T1, T0>>", SequenceMethod.GroupBy);
  68             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`2<T0, T2>>)->IQueryable`1<IGrouping`2<T1, T2>>", SequenceMethod.GroupByElementSelector);
  69             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, IEqualityComparer`1<T1>)->IQueryable`1<IGrouping`2<T1, T0>>", SequenceMethod.GroupByComparer);
  70             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`2<T0, T2>>, IEqualityComparer`1<T1>)->IQueryable`1<IGrouping`2<T1, T2>>", SequenceMethod.GroupByElementSelectorComparer);
  71             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`3<T1, IEnumerable`1<T2>, T3>>)->IQueryable`1<T3>", SequenceMethod.GroupByElementSelectorResultSelector);
  72             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`3<T1, IEnumerable`1<T0>, T2>>)->IQueryable`1<T2>", SequenceMethod.GroupByResultSelector);
  73             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`3<T1, IEnumerable`1<T0>, T2>>, IEqualityComparer`1<T1>)->IQueryable`1<T2>", SequenceMethod.GroupByResultSelectorComparer);
  74             map.Add(@"GroupBy(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>, Expression`1<Func`2<T0, T2>>, Expression`1<Func`3<T1, IEnumerable`1<T2>, T3>>, IEqualityComparer`1<T1>)->IQueryable`1<T3>", SequenceMethod.GroupByElementSelectorResultSelectorComparer);
  75             map.Add(@"Distinct(IQueryable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Distinct);
  76             map.Add(@"Distinct(IQueryable`1<T0>, IEqualityComparer`1<T0>)->IQueryable`1<T0>", SequenceMethod.DistinctComparer);
  77             map.Add(@"Concat(IQueryable`1<T0>, IEnumerable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Concat);
  78             map.Add(@"Zip(IQueryable`1<T0>, IEnumerable`1<T1>, Expression`1<Func`3<T0, T1, T2>>)->IQueryable`1<T2>", SequenceMethod.Zip);
  79             map.Add(@"Union(IQueryable`1<T0>, IEnumerable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Union);
  80             map.Add(@"Union(IQueryable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IQueryable`1<T0>", SequenceMethod.UnionComparer);
  81             map.Add(@"Intersect(IQueryable`1<T0>, IEnumerable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Intersect);
  82             map.Add(@"Intersect(IQueryable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IQueryable`1<T0>", SequenceMethod.IntersectComparer);
  83             map.Add(@"Except(IQueryable`1<T0>, IEnumerable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Except);
  84             map.Add(@"Except(IQueryable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IQueryable`1<T0>", SequenceMethod.ExceptComparer);
  85             map.Add(@"First(IQueryable`1<T0>)->T0", SequenceMethod.First);
  86             map.Add(@"First(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.FirstPredicate);
  87             map.Add(@"FirstOrDefault(IQueryable`1<T0>)->T0", SequenceMethod.FirstOrDefault);
  88             map.Add(@"FirstOrDefault(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.FirstOrDefaultPredicate);
  89             map.Add(@"Last(IQueryable`1<T0>)->T0", SequenceMethod.Last);
  90             map.Add(@"Last(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.LastPredicate);
  91             map.Add(@"LastOrDefault(IQueryable`1<T0>)->T0", SequenceMethod.LastOrDefault);
  92             map.Add(@"LastOrDefault(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.LastOrDefaultPredicate);
  93             map.Add(@"Single(IQueryable`1<T0>)->T0", SequenceMethod.Single);
  94             map.Add(@"Single(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.SinglePredicate);
  95             map.Add(@"SingleOrDefault(IQueryable`1<T0>)->T0", SequenceMethod.SingleOrDefault);
  96             map.Add(@"SingleOrDefault(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->T0", SequenceMethod.SingleOrDefaultPredicate);
  97             map.Add(@"ElementAt(IQueryable`1<T0>, Int32)->T0", SequenceMethod.ElementAt);
  98             map.Add(@"ElementAtOrDefault(IQueryable`1<T0>, Int32)->T0", SequenceMethod.ElementAtOrDefault);
  99             map.Add(@"DefaultIfEmpty(IQueryable`1<T0>)->IQueryable`1<T0>", SequenceMethod.DefaultIfEmpty);
 100             map.Add(@"DefaultIfEmpty(IQueryable`1<T0>, T0)->IQueryable`1<T0>", SequenceMethod.DefaultIfEmptyValue);
 101             map.Add(@"Contains(IQueryable`1<T0>, T0)->Boolean", SequenceMethod.Contains);
 102             map.Add(@"Contains(IQueryable`1<T0>, T0, IEqualityComparer`1<T0>)->Boolean", SequenceMethod.ContainsComparer);
 103             map.Add(@"Reverse(IQueryable`1<T0>)->IQueryable`1<T0>", SequenceMethod.Reverse);
 104             map.Add(@"SequenceEqual(IQueryable`1<T0>, IEnumerable`1<T0>)->Boolean", SequenceMethod.SequenceEqual);
 105             map.Add(@"SequenceEqual(IQueryable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->Boolean", SequenceMethod.SequenceEqualComparer);
 106             map.Add(@"Any(IQueryable`1<T0>)->Boolean", SequenceMethod.Any);
 107             map.Add(@"Any(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->Boolean", SequenceMethod.AnyPredicate);
 108             map.Add(@"All(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->Boolean", SequenceMethod.All);
 109             map.Add(@"Count(IQueryable`1<T0>)->Int32", SequenceMethod.Count);
 110             map.Add(@"Count(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->Int32", SequenceMethod.CountPredicate);
 111             map.Add(@"LongCount(IQueryable`1<T0>)->Int64", SequenceMethod.LongCount);
 112             map.Add(@"LongCount(IQueryable`1<T0>, Expression`1<Func`2<T0, Boolean>>)->Int64", SequenceMethod.LongCountPredicate);
 113             map.Add(@"Min(IQueryable`1<T0>)->T0", SequenceMethod.Min);
 114             map.Add(@"Min(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->T1", SequenceMethod.MinSelector);
 115             map.Add(@"Max(IQueryable`1<T0>)->T0", SequenceMethod.Max);
 116             map.Add(@"Max(IQueryable`1<T0>, Expression`1<Func`2<T0, T1>>)->T1", SequenceMethod.MaxSelector);
 117             map.Add(@"Sum(IQueryable`1<Int32>)->Int32", SequenceMethod.SumInt);
 118             map.Add(@"Sum(IQueryable`1<Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.SumNullableInt);
 119             map.Add(@"Sum(IQueryable`1<Int64>)->Int64", SequenceMethod.SumLong);
 120             map.Add(@"Sum(IQueryable`1<Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.SumNullableLong);
 121             map.Add(@"Sum(IQueryable`1<Single>)->Single", SequenceMethod.SumSingle);
 122             map.Add(@"Sum(IQueryable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.SumNullableSingle);
 123             map.Add(@"Sum(IQueryable`1<Double>)->Double", SequenceMethod.SumDouble);
 124             map.Add(@"Sum(IQueryable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.SumNullableDouble);
 125             map.Add(@"Sum(IQueryable`1<Decimal>)->Decimal", SequenceMethod.SumDecimal);
 126             map.Add(@"Sum(IQueryable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.SumNullableDecimal);
 127             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Int32>>)->Int32", SequenceMethod.SumIntSelector);
 128             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Int32>>>)->Nullable`1<Int32>", SequenceMethod.SumNullableIntSelector);
 129             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Int64>>)->Int64", SequenceMethod.SumLongSelector);
 130             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Int64>>>)->Nullable`1<Int64>", SequenceMethod.SumNullableLongSelector);
 131             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Single>>)->Single", SequenceMethod.SumSingleSelector);
 132             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Single>>>)->Nullable`1<Single>", SequenceMethod.SumNullableSingleSelector);
 133             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Double>>)->Double", SequenceMethod.SumDoubleSelector);
 134             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Double>>>)->Nullable`1<Double>", SequenceMethod.SumNullableDoubleSelector);
 135             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Decimal>>)->Decimal", SequenceMethod.SumDecimalSelector);
 136             map.Add(@"Sum(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Decimal>>>)->Nullable`1<Decimal>", SequenceMethod.SumNullableDecimalSelector);
 137             map.Add(@"Average(IQueryable`1<Int32>)->Double", SequenceMethod.AverageInt);
 138             map.Add(@"Average(IQueryable`1<Nullable`1<Int32>>)->Nullable`1<Double>", SequenceMethod.AverageNullableInt);
 139             map.Add(@"Average(IQueryable`1<Int64>)->Double", SequenceMethod.AverageLong);
 140             map.Add(@"Average(IQueryable`1<Nullable`1<Int64>>)->Nullable`1<Double>", SequenceMethod.AverageNullableLong);
 141             map.Add(@"Average(IQueryable`1<Single>)->Single", SequenceMethod.AverageSingle);
 142             map.Add(@"Average(IQueryable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.AverageNullableSingle);
 143             map.Add(@"Average(IQueryable`1<Double>)->Double", SequenceMethod.AverageDouble);
 144             map.Add(@"Average(IQueryable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.AverageNullableDouble);
 145             map.Add(@"Average(IQueryable`1<Decimal>)->Decimal", SequenceMethod.AverageDecimal);
 146             map.Add(@"Average(IQueryable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.AverageNullableDecimal);
 147             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Int32>>)->Double", SequenceMethod.AverageIntSelector);
 148             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Int32>>>)->Nullable`1<Double>", SequenceMethod.AverageNullableIntSelector);
 149             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Single>>)->Single", SequenceMethod.AverageSingleSelector);
 150             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Single>>>)->Nullable`1<Single>", SequenceMethod.AverageNullableSingleSelector);
 151             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Int64>>)->Double", SequenceMethod.AverageLongSelector);
 152             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Int64>>>)->Nullable`1<Double>", SequenceMethod.AverageNullableLongSelector);
 153             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Double>>)->Double", SequenceMethod.AverageDoubleSelector);
 154             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Double>>>)->Nullable`1<Double>", SequenceMethod.AverageNullableDoubleSelector);
 155             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Decimal>>)->Decimal", SequenceMethod.AverageDecimalSelector);
 156             map.Add(@"Average(IQueryable`1<T0>, Expression`1<Func`2<T0, Nullable`1<Decimal>>>)->Nullable`1<Decimal>", SequenceMethod.AverageNullableDecimalSelector);
 157             map.Add(@"Aggregate(IQueryable`1<T0>, Expression`1<Func`3<T0, T0, T0>>)->T0", SequenceMethod.Aggregate);
 158             map.Add(@"Aggregate(IQueryable`1<T0>, T1, Expression`1<Func`3<T1, T0, T1>>)->T1", SequenceMethod.AggregateSeed);
 159             map.Add(@"Aggregate(IQueryable`1<T0>, T1, Expression`1<Func`3<T1, T0, T1>>, Expression`1<Func`2<T1, T2>>)->T2", SequenceMethod.AggregateSeedSelector);
 160             map.Add(@"Where(IEnumerable`1<T0>, Func`2<T0, Boolean>)->IEnumerable`1<T0>", SequenceMethod.Where);
 161             map.Add(@"Where(IEnumerable`1<T0>, Func`3<T0, Int32, Boolean>)->IEnumerable`1<T0>", SequenceMethod.WhereOrdinal);
 162             map.Add(@"Select(IEnumerable`1<T0>, Func`2<T0, T1>)->IEnumerable`1<T1>", SequenceMethod.Select);
 163             map.Add(@"Select(IEnumerable`1<T0>, Func`3<T0, Int32, T1>)->IEnumerable`1<T1>", SequenceMethod.SelectOrdinal);
 164             map.Add(@"SelectMany(IEnumerable`1<T0>, Func`2<T0, IEnumerable`1<T1>>)->IEnumerable`1<T1>", SequenceMethod.SelectMany);
 165             map.Add(@"SelectMany(IEnumerable`1<T0>, Func`3<T0, Int32, IEnumerable`1<T1>>)->IEnumerable`1<T1>", SequenceMethod.SelectManyOrdinal);
 166             map.Add(@"SelectMany(IEnumerable`1<T0>, Func`3<T0, Int32, IEnumerable`1<T1>>, Func`3<T0, T1, T2>)->IEnumerable`1<T2>", SequenceMethod.SelectManyOrdinalResultSelector);
 167             map.Add(@"SelectMany(IEnumerable`1<T0>, Func`2<T0, IEnumerable`1<T1>>, Func`3<T0, T1, T2>)->IEnumerable`1<T2>", SequenceMethod.SelectManyResultSelector);
 168             map.Add(@"Take(IEnumerable`1<T0>, Int32)->IEnumerable`1<T0>", SequenceMethod.Take);
 169             map.Add(@"TakeWhile(IEnumerable`1<T0>, Func`2<T0, Boolean>)->IEnumerable`1<T0>", SequenceMethod.TakeWhile);
 170             map.Add(@"TakeWhile(IEnumerable`1<T0>, Func`3<T0, Int32, Boolean>)->IEnumerable`1<T0>", SequenceMethod.TakeWhileOrdinal);
 171             map.Add(@"Skip(IEnumerable`1<T0>, Int32)->IEnumerable`1<T0>", SequenceMethod.Skip);
 172             map.Add(@"SkipWhile(IEnumerable`1<T0>, Func`2<T0, Boolean>)->IEnumerable`1<T0>", SequenceMethod.SkipWhile);
 173             map.Add(@"SkipWhile(IEnumerable`1<T0>, Func`3<T0, Int32, Boolean>)->IEnumerable`1<T0>", SequenceMethod.SkipWhileOrdinal);
 174             map.Add(@"Join(IEnumerable`1<T0>, IEnumerable`1<T1>, Func`2<T0, T2>, Func`2<T1, T2>, Func`3<T0, T1, T3>)->IEnumerable`1<T3>", SequenceMethod.Join);
 175             map.Add(@"Join(IEnumerable`1<T0>, IEnumerable`1<T1>, Func`2<T0, T2>, Func`2<T1, T2>, Func`3<T0, T1, T3>, IEqualityComparer`1<T2>)->IEnumerable`1<T3>", SequenceMethod.JoinComparer);
 176             map.Add(@"GroupJoin(IEnumerable`1<T0>, IEnumerable`1<T1>, Func`2<T0, T2>, Func`2<T1, T2>, Func`3<T0, IEnumerable`1<T1>, T3>)->IEnumerable`1<T3>", SequenceMethod.GroupJoin);
 177             map.Add(@"GroupJoin(IEnumerable`1<T0>, IEnumerable`1<T1>, Func`2<T0, T2>, Func`2<T1, T2>, Func`3<T0, IEnumerable`1<T1>, T3>, IEqualityComparer`1<T2>)->IEnumerable`1<T3>", SequenceMethod.GroupJoinComparer);
 178             map.Add(@"OrderBy(IEnumerable`1<T0>, Func`2<T0, T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.OrderBy);
 179             map.Add(@"OrderBy(IEnumerable`1<T0>, Func`2<T0, T1>, IComparer`1<T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.OrderByComparer);
 180             map.Add(@"OrderByDescending(IEnumerable`1<T0>, Func`2<T0, T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.OrderByDescending);
 181             map.Add(@"OrderByDescending(IEnumerable`1<T0>, Func`2<T0, T1>, IComparer`1<T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.OrderByDescendingComparer);
 182             map.Add(@"ThenBy(IOrderedEnumerable`1<T0>, Func`2<T0, T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.ThenBy);
 183             map.Add(@"ThenBy(IOrderedEnumerable`1<T0>, Func`2<T0, T1>, IComparer`1<T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.ThenByComparer);
 184             map.Add(@"ThenByDescending(IOrderedEnumerable`1<T0>, Func`2<T0, T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.ThenByDescending);
 185             map.Add(@"ThenByDescending(IOrderedEnumerable`1<T0>, Func`2<T0, T1>, IComparer`1<T1>)->IOrderedEnumerable`1<T0>", SequenceMethod.ThenByDescendingComparer);
 186             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>)->IEnumerable`1<IGrouping`2<T1, T0>>", SequenceMethod.GroupBy);
 187             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, IEqualityComparer`1<T1>)->IEnumerable`1<IGrouping`2<T1, T0>>", SequenceMethod.GroupByComparer);
 188             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>)->IEnumerable`1<IGrouping`2<T1, T2>>", SequenceMethod.GroupByElementSelector);
 189             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>, IEqualityComparer`1<T1>)->IEnumerable`1<IGrouping`2<T1, T2>>", SequenceMethod.GroupByElementSelectorComparer);
 190             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`3<T1, IEnumerable`1<T0>, T2>)->IEnumerable`1<T2>", SequenceMethod.GroupByResultSelector);
 191             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>, Func`3<T1, IEnumerable`1<T2>, T3>)->IEnumerable`1<T3>", SequenceMethod.GroupByElementSelectorResultSelector);
 192             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`3<T1, IEnumerable`1<T0>, T2>, IEqualityComparer`1<T1>)->IEnumerable`1<T2>", SequenceMethod.GroupByResultSelectorComparer);
 193             map.Add(@"GroupBy(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>, Func`3<T1, IEnumerable`1<T2>, T3>, IEqualityComparer`1<T1>)->IEnumerable`1<T3>", SequenceMethod.GroupByElementSelectorResultSelectorComparer);
 194             map.Add(@"Concat(IEnumerable`1<T0>, IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Concat);
 195             map.Add(@"Zip(IEnumerable`1<T0>, IEnumerable`1<T1>, Func`3<T0, T1, T2>)->IEnumerable`1<T2>", SequenceMethod.Zip);
 196             map.Add(@"Distinct(IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Distinct);
 197             map.Add(@"Distinct(IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IEnumerable`1<T0>", SequenceMethod.DistinctComparer);
 198             map.Add(@"Union(IEnumerable`1<T0>, IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Union);
 199             map.Add(@"Union(IEnumerable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IEnumerable`1<T0>", SequenceMethod.UnionComparer);
 200             map.Add(@"Intersect(IEnumerable`1<T0>, IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Intersect);
 201             map.Add(@"Intersect(IEnumerable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IEnumerable`1<T0>", SequenceMethod.IntersectComparer);
 202             map.Add(@"Except(IEnumerable`1<T0>, IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Except);
 203             map.Add(@"Except(IEnumerable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->IEnumerable`1<T0>", SequenceMethod.ExceptComparer);
 204             map.Add(@"Reverse(IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.Reverse);
 205             map.Add(@"SequenceEqual(IEnumerable`1<T0>, IEnumerable`1<T0>)->Boolean", SequenceMethod.SequenceEqual);
 206             map.Add(@"SequenceEqual(IEnumerable`1<T0>, IEnumerable`1<T0>, IEqualityComparer`1<T0>)->Boolean", SequenceMethod.SequenceEqualComparer);
 207             map.Add(@"AsEnumerable(IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.AsEnumerable);
 208             map.Add(@"ToArray(IEnumerable`1<T0>)->TSource[]", SequenceMethod.NotSupported);
 209             map.Add(@"ToList(IEnumerable`1<T0>)->List`1<T0>", SequenceMethod.NotSupported);
 210             map.Add(@"ToDictionary(IEnumerable`1<T0>, Func`2<T0, T1>)->Dictionary`2<T1, T0>", SequenceMethod.NotSupported);
 211             map.Add(@"ToDictionary(IEnumerable`1<T0>, Func`2<T0, T1>, IEqualityComparer`1<T1>)->Dictionary`2<T1, T0>", SequenceMethod.NotSupported);
 212             map.Add(@"ToDictionary(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>)->Dictionary`2<T1, T2>", SequenceMethod.NotSupported);
 213             map.Add(@"ToDictionary(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>, IEqualityComparer`1<T1>)->Dictionary`2<T1, T2>", SequenceMethod.NotSupported);
 214             map.Add(@"ToLookup(IEnumerable`1<T0>, Func`2<T0, T1>)->ILookup`2<T1, T0>", SequenceMethod.NotSupported);
 215             map.Add(@"ToLookup(IEnumerable`1<T0>, Func`2<T0, T1>, IEqualityComparer`1<T1>)->ILookup`2<T1, T0>", SequenceMethod.NotSupported);
 216             map.Add(@"ToLookup(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>)->ILookup`2<T1, T2>", SequenceMethod.NotSupported);
 217             map.Add(@"ToLookup(IEnumerable`1<T0>, Func`2<T0, T1>, Func`2<T0, T2>, IEqualityComparer`1<T1>)->ILookup`2<T1, T2>", SequenceMethod.NotSupported);
 218             map.Add(@"DefaultIfEmpty(IEnumerable`1<T0>)->IEnumerable`1<T0>", SequenceMethod.DefaultIfEmpty);
 219             map.Add(@"DefaultIfEmpty(IEnumerable`1<T0>, T0)->IEnumerable`1<T0>", SequenceMethod.DefaultIfEmptyValue);
 220             map.Add(@"OfType(IEnumerable)->IEnumerable`1<T0>", SequenceMethod.OfType);
 221             map.Add(@"Cast(IEnumerable)->IEnumerable`1<T0>", SequenceMethod.Cast);
 222             map.Add(@"First(IEnumerable`1<T0>)->T0", SequenceMethod.First);
 223             map.Add(@"First(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.FirstPredicate);
 224             map.Add(@"FirstOrDefault(IEnumerable`1<T0>)->T0", SequenceMethod.FirstOrDefault);
 225             map.Add(@"FirstOrDefault(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.FirstOrDefaultPredicate);
 226             map.Add(@"Last(IEnumerable`1<T0>)->T0", SequenceMethod.Last);
 227             map.Add(@"Last(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.LastPredicate);
 228             map.Add(@"LastOrDefault(IEnumerable`1<T0>)->T0", SequenceMethod.LastOrDefault);
 229             map.Add(@"LastOrDefault(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.LastOrDefaultPredicate);
 230             map.Add(@"Single(IEnumerable`1<T0>)->T0", SequenceMethod.Single);
 231             map.Add(@"Single(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.SinglePredicate);
 232             map.Add(@"SingleOrDefault(IEnumerable`1<T0>)->T0", SequenceMethod.SingleOrDefault);
 233             map.Add(@"SingleOrDefault(IEnumerable`1<T0>, Func`2<T0, Boolean>)->T0", SequenceMethod.SingleOrDefaultPredicate);
 234             map.Add(@"ElementAt(IEnumerable`1<T0>, Int32)->T0", SequenceMethod.ElementAt);
 235             map.Add(@"ElementAtOrDefault(IEnumerable`1<T0>, Int32)->T0", SequenceMethod.ElementAtOrDefault);
 236             map.Add(@"Range(Int32, Int32)->IEnumerable`1<Int32>", SequenceMethod.NotSupported);
 237             map.Add(@"Repeat(T0, Int32)->IEnumerable`1<T0>", SequenceMethod.NotSupported);
 238             map.Add(@"Empty()->IEnumerable`1<T0>", SequenceMethod.Empty);
 239             map.Add(@"Any(IEnumerable`1<T0>)->Boolean", SequenceMethod.Any);
 240             map.Add(@"Any(IEnumerable`1<T0>, Func`2<T0, Boolean>)->Boolean", SequenceMethod.AnyPredicate);
 241             map.Add(@"All(IEnumerable`1<T0>, Func`2<T0, Boolean>)->Boolean", SequenceMethod.All);
 242             map.Add(@"Count(IEnumerable`1<T0>)->Int32", SequenceMethod.Count);
 243             map.Add(@"Count(IEnumerable`1<T0>, Func`2<T0, Boolean>)->Int32", SequenceMethod.CountPredicate);
 244             map.Add(@"LongCount(IEnumerable`1<T0>)->Int64", SequenceMethod.LongCount);
 245             map.Add(@"LongCount(IEnumerable`1<T0>, Func`2<T0, Boolean>)->Int64", SequenceMethod.LongCountPredicate);
 246             map.Add(@"Contains(IEnumerable`1<T0>, T0)->Boolean", SequenceMethod.Contains);
 247             map.Add(@"Contains(IEnumerable`1<T0>, T0, IEqualityComparer`1<T0>)->Boolean", SequenceMethod.ContainsComparer);
 248             map.Add(@"Aggregate(IEnumerable`1<T0>, Func`3<T0, T0, T0>)->T0", SequenceMethod.Aggregate);
 249             map.Add(@"Aggregate(IEnumerable`1<T0>, T1, Func`3<T1, T0, T1>)->T1", SequenceMethod.AggregateSeed);
 250             map.Add(@"Aggregate(IEnumerable`1<T0>, T1, Func`3<T1, T0, T1>, Func`2<T1, T2>)->T2", SequenceMethod.AggregateSeedSelector);
 251             map.Add(@"Sum(IEnumerable`1<Int32>)->Int32", SequenceMethod.SumInt);
 252             map.Add(@"Sum(IEnumerable`1<Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.SumNullableInt);
 253             map.Add(@"Sum(IEnumerable`1<Int64>)->Int64", SequenceMethod.SumLong);
 254             map.Add(@"Sum(IEnumerable`1<Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.SumNullableLong);
 255             map.Add(@"Sum(IEnumerable`1<Single>)->Single", SequenceMethod.SumSingle);
 256             map.Add(@"Sum(IEnumerable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.SumNullableSingle);
 257             map.Add(@"Sum(IEnumerable`1<Double>)->Double", SequenceMethod.SumDouble);
 258             map.Add(@"Sum(IEnumerable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.SumNullableDouble);
 259             map.Add(@"Sum(IEnumerable`1<Decimal>)->Decimal", SequenceMethod.SumDecimal);
 260             map.Add(@"Sum(IEnumerable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.SumNullableDecimal);
 261             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Int32>)->Int32", SequenceMethod.SumIntSelector);
 262             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.SumNullableIntSelector);
 263             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Int64>)->Int64", SequenceMethod.SumLongSelector);
 264             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.SumNullableLongSelector);
 265             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Single>)->Single", SequenceMethod.SumSingleSelector);
 266             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.SumNullableSingleSelector);
 267             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Double>)->Double", SequenceMethod.SumDoubleSelector);
 268             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.SumNullableDoubleSelector);
 269             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Decimal>)->Decimal", SequenceMethod.SumDecimalSelector);
 270             map.Add(@"Sum(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.SumNullableDecimalSelector);
 271             map.Add(@"Min(IEnumerable`1<Int32>)->Int32", SequenceMethod.MinInt);
 272             map.Add(@"Min(IEnumerable`1<Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.MinNullableInt);
 273             map.Add(@"Min(IEnumerable`1<Int64>)->Int64", SequenceMethod.MinLong);
 274             map.Add(@"Min(IEnumerable`1<Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.MinNullableLong);
 275             map.Add(@"Min(IEnumerable`1<Single>)->Single", SequenceMethod.MinSingle);
 276             map.Add(@"Min(IEnumerable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.MinNullableSingle);
 277             map.Add(@"Min(IEnumerable`1<Double>)->Double", SequenceMethod.MinDouble);
 278             map.Add(@"Min(IEnumerable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.MinNullableDouble);
 279             map.Add(@"Min(IEnumerable`1<Decimal>)->Decimal", SequenceMethod.MinDecimal);
 280             map.Add(@"Min(IEnumerable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.MinNullableDecimal);
 281             map.Add(@"Min(IEnumerable`1<T0>)->T0", SequenceMethod.Min);
 282             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Int32>)->Int32", SequenceMethod.MinIntSelector);
 283             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.MinNullableIntSelector);
 284             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Int64>)->Int64", SequenceMethod.MinLongSelector);
 285             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.MinNullableLongSelector);
 286             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Single>)->Single", SequenceMethod.MinSingleSelector);
 287             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.MinNullableSingleSelector);
 288             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Double>)->Double", SequenceMethod.MinDoubleSelector);
 289             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.MinNullableDoubleSelector);
 290             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Decimal>)->Decimal", SequenceMethod.MinDecimalSelector);
 291             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.MinNullableDecimalSelector);
 292             map.Add(@"Min(IEnumerable`1<T0>, Func`2<T0, T1>)->T1", SequenceMethod.MinSelector);
 293             map.Add(@"Max(IEnumerable`1<Int32>)->Int32", SequenceMethod.MaxInt);
 294             map.Add(@"Max(IEnumerable`1<Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.MaxNullableInt);
 295             map.Add(@"Max(IEnumerable`1<Int64>)->Int64", SequenceMethod.MaxLong);
 296             map.Add(@"Max(IEnumerable`1<Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.MaxNullableLong);
 297             map.Add(@"Max(IEnumerable`1<Double>)->Double", SequenceMethod.MaxDouble);
 298             map.Add(@"Max(IEnumerable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.MaxNullableDouble);
 299             map.Add(@"Max(IEnumerable`1<Single>)->Single", SequenceMethod.MaxSingle);
 300             map.Add(@"Max(IEnumerable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.MaxNullableSingle);
 301             map.Add(@"Max(IEnumerable`1<Decimal>)->Decimal", SequenceMethod.MaxDecimal);
 302             map.Add(@"Max(IEnumerable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.MaxNullableDecimal);
 303             map.Add(@"Max(IEnumerable`1<T0>)->T0", SequenceMethod.Max);
 304             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Int32>)->Int32", SequenceMethod.MaxIntSelector);
 305             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int32>>)->Nullable`1<Int32>", SequenceMethod.MaxNullableIntSelector);
 306             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Int64>)->Int64", SequenceMethod.MaxLongSelector);
 307             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int64>>)->Nullable`1<Int64>", SequenceMethod.MaxNullableLongSelector);
 308             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Single>)->Single", SequenceMethod.MaxSingleSelector);
 309             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.MaxNullableSingleSelector);
 310             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Double>)->Double", SequenceMethod.MaxDoubleSelector);
 311             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.MaxNullableDoubleSelector);
 312             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Decimal>)->Decimal", SequenceMethod.MaxDecimalSelector);
 313             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.MaxNullableDecimalSelector);
 314             map.Add(@"Max(IEnumerable`1<T0>, Func`2<T0, T1>)->T1", SequenceMethod.MaxSelector);
 315             map.Add(@"Average(IEnumerable`1<Int32>)->Double", SequenceMethod.AverageInt);
 316             map.Add(@"Average(IEnumerable`1<Nullable`1<Int32>>)->Nullable`1<Double>", SequenceMethod.AverageNullableInt);
 317             map.Add(@"Average(IEnumerable`1<Int64>)->Double", SequenceMethod.AverageLong);
 318             map.Add(@"Average(IEnumerable`1<Nullable`1<Int64>>)->Nullable`1<Double>", SequenceMethod.AverageNullableLong);
 319             map.Add(@"Average(IEnumerable`1<Single>)->Single", SequenceMethod.AverageSingle);
 320             map.Add(@"Average(IEnumerable`1<Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.AverageNullableSingle);
 321             map.Add(@"Average(IEnumerable`1<Double>)->Double", SequenceMethod.AverageDouble);
 322             map.Add(@"Average(IEnumerable`1<Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.AverageNullableDouble);
 323             map.Add(@"Average(IEnumerable`1<Decimal>)->Decimal", SequenceMethod.AverageDecimal);
 324             map.Add(@"Average(IEnumerable`1<Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.AverageNullableDecimal);
 325             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Int32>)->Double", SequenceMethod.AverageIntSelector);
 326             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int32>>)->Nullable`1<Double>", SequenceMethod.AverageNullableIntSelector);
 327             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Int64>)->Double", SequenceMethod.AverageLongSelector);
 328             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Int64>>)->Nullable`1<Double>", SequenceMethod.AverageNullableLongSelector);
 329             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Single>)->Single", SequenceMethod.AverageSingleSelector);
 330             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Single>>)->Nullable`1<Single>", SequenceMethod.AverageNullableSingleSelector);
 331             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Double>)->Double", SequenceMethod.AverageDoubleSelector);
 332             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Double>>)->Nullable`1<Double>", SequenceMethod.AverageNullableDoubleSelector);
 333             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Decimal>)->Decimal", SequenceMethod.AverageDecimalSelector);
 334             map.Add(@"Average(IEnumerable`1<T0>, Func`2<T0, Nullable`1<Decimal>>)->Nullable`1<Decimal>", SequenceMethod.AverageNullableDecimalSelector);
 335             #endregion // ReflectionUtilCodeGen
 336             //
 337             // DO NOT MODIFY CODE ABOVE THIS LINE: CODE GEN TOOL RELIES ON ENDREGION TAG
 338             //
 339
 340             // by redirection through canonical method names, determine sequence enum value
 341             // for all know LINQ operators
 342             s_methodMap = new Dictionary<MethodInfo, SequenceMethod>();
 343             s_inverseMap = new Dictionary<SequenceMethod, MethodInfo>();
 344             foreach (MethodInfo method in GetAllLinqOperators())
 345             {
 346                 SequenceMethod sequenceMethod;
 347                 string canonicalMethod = GetCanonicalMethodDescription(method);
 348                 if (map.TryGetValue(canonicalMethod, out sequenceMethod))
 349                 {
 350                     s_methodMap.Add(method, sequenceMethod);
 351                     s_inverseMap[sequenceMethod] = method;
 352                 }
 353             }
 354         }
 355         #endregion
 356
 357         /// <summary>
 358         /// Identifies methods as instances of known sequence operators.
 359         /// </summary>
 360         /// <param name="method">Method info to identify</param>
 361         /// <param name="sequenceMethod">Identified sequence operator</param>
 362         /// <returns><c>true</c> if method is known; <c>false</c> otherwise</returns>
 363         internal static bool TryIdentifySequenceMethod(MethodInfo method, out SequenceMethod sequenceMethod)
 364         {
 365             method = method.IsGenericMethod ? method.GetGenericMethodDefinition() :
 366                 method;
 367             return s_methodMap.TryGetValue(method, out sequenceMethod);
 368         }
 369
 370         /// <summary>
 371         /// Identifies method call expressions as calls to known sequence operators.
 372         /// </summary>
 373         /// <param name="expression">
 374         ///     Expression that may represent a call to a known sequence method
 375         /// </param>
 376         /// <param name="unwrapLambda">
 377         ///     If <c>true</c>, and the <paramref name="expression"/> argument is a LambdaExpression,
 378         ///     the Body of the LambdaExpression argument will be retrieved, and that expression will
 379         ///     then be examined for a sequence method call instead of the Lambda itself.
 380         /// </param>
 381         /// <param name="sequenceMethod">
 382         ///     Identified sequence operator
 383         /// </param>
 384         /// <returns>
 385         ///     <c>true</c> if <paramref name="expression"/> is a <see cref="MethodCallExpression"/>
 386         ///     and its target method is known; <c>false</c> otherwise
 387         /// </returns>
 388         internal static bool TryIdentifySequenceMethod(Expression expression, bool unwrapLambda, out SequenceMethod sequenceMethod)
 389         {
 390             if (expression.NodeType == ExpressionType.Lambda && unwrapLambda)
 391             {
 392                 expression = ((LambdaExpression)expression).Body;
 393             }
 394
 395             if (expression.NodeType == ExpressionType.Call)
 396             {
 397                 MethodCallExpression methodCall = (MethodCallExpression)expression;
 398                 return ReflectionUtil.TryIdentifySequenceMethod(methodCall.Method, out sequenceMethod);
 399             }
 400
 401             sequenceMethod = default(SequenceMethod);
 402             return false;
 403         }
 404
 405         /// <summary>
 406         /// Looks up some implementation of a sequence method.
 407         /// </summary>
 408         /// <param name="sequenceMethod">Sequence method to find</param>
 409         /// <param name="method">Known method</param>
 410         /// <returns>true if some method is found; false otherwise</returns>
 411         internal static bool TryLookupMethod(SequenceMethod sequenceMethod, out MethodInfo method)
 412         {
 413             return s_inverseMap.TryGetValue(sequenceMethod, out method);
 414         }
 415
 416         /// <remarks>
 417         /// Requires:
 418         /// - no collisions on type names
 419         /// - no output or reference method parameters
 420         /// </remarks>
 421         /// <summary>
 422         /// Produces a string description of a method consisting of the name and all parameters,
 423         /// where all generic type parameters have been substituted with number identifiers.
 424         /// </summary>
 425         /// <param name="method">Method to identify.</param>
 426         /// <returns>Canonical description of method (suitable for lookup)</returns>
 427         internal static string GetCanonicalMethodDescription(MethodInfo method)
 428         {
 429             EntityUtil.CheckArgumentNull(method, "method");
 430
 431             // retrieve all generic type arguments and assign them numbers based on order
 432             Dictionary<Type, int> genericArgumentOrdinals = null;
 433             if (method.IsGenericMethodDefinition)
 434             {
 435                 genericArgumentOrdinals = method.GetGenericArguments()
 436                     .Where(t => t.IsGenericParameter)
 437                     .Select((t, i) => new KeyValuePair<Type, int>(t, i))
 438                     .ToDictionary(r => r.Key, r => r.Value);
 439             }
 440
 441             StringBuilder description = new StringBuilder();
 442             description.Append(method.Name).Append("(");
 443
 444             // append types for all method parameters
 445             bool first = true;
 446             foreach (ParameterInfo parameter in method.GetParameters())
 447             {
 448                 if (first) { first = false; }
 449                 else { description.Append(", "); }
 450                 AppendCanonicalTypeDescription(parameter.ParameterType, genericArgumentOrdinals, description);
 451             }
 452
 453             description.Append(")");
 454
 455             // include return type
 456             if (null != method.ReturnType)
 457             {
 458                 description.Append("->");
 459                 AppendCanonicalTypeDescription(method.ReturnType, genericArgumentOrdinals, description);
 460             }
 461
 462             return description.ToString();
 463         }
 464
 465         private static void AppendCanonicalTypeDescription(Type type, Dictionary<Type, int> genericArgumentOrdinals, StringBuilder description)
 466         {
 467             int ordinal;
 468
 469             // if this a type argument for the method, substitute
 470             if (null != genericArgumentOrdinals && genericArgumentOrdinals.TryGetValue(type, out ordinal))
 471             {
 472                 description.Append("T").Append(ordinal.ToString(CultureInfo.InvariantCulture));
 473                 return;
 474             }
 475
 476             // always include the name (note: we omit the namespace/assembly; assuming type names do not collide)
 477             description.Append(type.Name);
 478
 479             if (type.IsGenericType)
 480             {
 481                 description.Append("<");
 482                 bool first = true;
 483                 foreach (Type genericArgument in type.GetGenericArguments())
 484                 {
 485                     if (first) { first = false; }
 486                     else { description.Append(", "); }
 487                     AppendCanonicalTypeDescription(genericArgument, genericArgumentOrdinals, description);
 488                 }
 489                 description.Append(">");
 490             }
 491         }
 492
 493         /// <summary>
 494         /// Returns all static methods in the Queryable and Enumerable classes.
 495         /// </summary>
 496         internal static IEnumerable<MethodInfo> GetAllLinqOperators()
 497         {
 498             return typeof(Queryable).GetMethods(BindingFlags.Static | BindingFlags.Public).Concat(
 499                 typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public));
 500         }
 501     }
 502
 503     /// <summary>
 504     /// Enumeration of known extension methods
 505     /// </summary>
 506     internal enum SequenceMethod
 507     {
 508         Where,
 509         WhereOrdinal,
 510         OfType,
 511         Cast,
 512         Select,
 513         SelectOrdinal,
 514         SelectMany,
 515         SelectManyOrdinal,
 516         SelectManyResultSelector,
 517         SelectManyOrdinalResultSelector,
 518         Join,
 519         JoinComparer,
 520         GroupJoin,
 521         GroupJoinComparer,
 522         OrderBy,
 523         OrderByComparer,
 524         OrderByDescending,
 525         OrderByDescendingComparer,
 526         ThenBy,
 527         ThenByComparer,
 528         ThenByDescending,
 529         ThenByDescendingComparer,
 530         Take,
 531         TakeWhile,
 532         TakeWhileOrdinal,
 533         Skip,
 534         SkipWhile,
 535         SkipWhileOrdinal,
 536         GroupBy,
 537         GroupByComparer,
 538         GroupByElementSelector,
 539         GroupByElementSelectorComparer,
 540         GroupByResultSelector,
 541         GroupByResultSelectorComparer,
 542         GroupByElementSelectorResultSelector,
 543         GroupByElementSelectorResultSelectorComparer,
 544         Distinct,
 545         DistinctComparer,
 546         Concat,
 547         Union,
 548         UnionComparer,
 549         Intersect,
 550         IntersectComparer,
 551         Except,
 552         ExceptComparer,
 553         First,
 554         FirstPredicate,
 555         FirstOrDefault,
 556         FirstOrDefaultPredicate,
 557         Last,
 558         LastPredicate,
 559         LastOrDefault,
 560         LastOrDefaultPredicate,
 561         Single,
 562         SinglePredicate,
 563         SingleOrDefault,
 564         SingleOrDefaultPredicate,
 565         ElementAt,
 566         ElementAtOrDefault,
 567         DefaultIfEmpty,
 568         DefaultIfEmptyValue,
 569         Contains,
 570         ContainsComparer,
 571         Reverse,
 572         Empty,
 573         SequenceEqual,
 574         SequenceEqualComparer,
 575
 576         Any,
 577         AnyPredicate,
 578         All,
 579
 580         Count,
 581         CountPredicate,
 582         LongCount,
 583         LongCountPredicate,
 584
 585         Min,
 586         MinSelector,
 587         Max,
 588         MaxSelector,
 589
 590         MinInt,
 591         MinNullableInt,
 592         MinLong,
 593         MinNullableLong,
 594         MinDouble,
 595         MinNullableDouble,
 596         MinDecimal,
 597         MinNullableDecimal,
 598         MinSingle,
 599         MinNullableSingle,
 600         MinIntSelector,
 601         MinNullableIntSelector,
 602         MinLongSelector,
 603         MinNullableLongSelector,
 604         MinDoubleSelector,
 605         MinNullableDoubleSelector,
 606         MinDecimalSelector,
 607         MinNullableDecimalSelector,
 608         MinSingleSelector,
 609         MinNullableSingleSelector,
 610
 611         MaxInt,
 612         MaxNullableInt,
 613         MaxLong,
 614         MaxNullableLong,
 615         MaxDouble,
 616         MaxNullableDouble,
 617         MaxDecimal,
 618         MaxNullableDecimal,
 619         MaxSingle,
 620         MaxNullableSingle,
 621         MaxIntSelector,
 622         MaxNullableIntSelector,
 623         MaxLongSelector,
 624         MaxNullableLongSelector,
 625         MaxDoubleSelector,
 626         MaxNullableDoubleSelector,
 627         MaxDecimalSelector,
 628         MaxNullableDecimalSelector,
 629         MaxSingleSelector,
 630         MaxNullableSingleSelector,
 631
 632         SumInt,
 633         SumNullableInt,
 634         SumLong,
 635         SumNullableLong,
 636         SumDouble,
 637         SumNullableDouble,
 638         SumDecimal,
 639         SumNullableDecimal,
 640         SumSingle,
 641         SumNullableSingle,
 642         SumIntSelector,
 643         SumNullableIntSelector,
 644         SumLongSelector,
 645         SumNullableLongSelector,
 646         SumDoubleSelector,
 647         SumNullableDoubleSelector,
 648         SumDecimalSelector,
 649         SumNullableDecimalSelector,
 650         SumSingleSelector,
 651         SumNullableSingleSelector,
 652
 653         AverageInt,
 654         AverageNullableInt,
 655         AverageLong,
 656         AverageNullableLong,
 657         AverageDouble,
 658         AverageNullableDouble,
 659         AverageDecimal,
 660         AverageNullableDecimal,
 661         AverageSingle,
 662         AverageNullableSingle,
 663         AverageIntSelector,
 664         AverageNullableIntSelector,
 665         AverageLongSelector,
 666         AverageNullableLongSelector,
 667         AverageDoubleSelector,
 668         AverageNullableDoubleSelector,
 669         AverageDecimalSelector,
 670         AverageNullableDecimalSelector,
 671         AverageSingleSelector,
 672         AverageNullableSingleSelector,
 673
 674         Aggregate,
 675         AggregateSeed,
 676         AggregateSeedSelector,
 677
 678         AsQueryable,
 679         AsQueryableGeneric,
 680         AsEnumerable,
 681
 682         Zip,
 683
 684         NotSupported,
 685     }
 686 }