Imported Upstream version 5.0.0.42

Former-commit-id: fd56571888259555122d8a0f58c68838229cea2b

mcs/class/referencesource/System.Core/System/Linq/Expressions/ExpressionVisitor.cs

@@ -80,10 +80,14 @@ namespace System.Linq.Expressions {
                 case ExpressionType.ListInit:
                     return this.VisitListInit((ListInitExpression)exp);
                 default:
-                    throw Error.UnhandledExpressionType(exp.NodeType);
+                    throw UnhandledExpressionType(exp.NodeType);
             }
         }
 
+        static Exception UnhandledExpressionType(object p0) {
+            return new ArgumentException(string.Format ("Unhandled Expression Type: {0}", p0));
+        }        
+
         internal virtual MemberBinding VisitBinding(MemberBinding binding) {
             switch (binding.BindingType) {
                 case MemberBindingType.Assignment:
@@ -93,9 +97,13 @@ namespace System.Linq.Expressions {
                 case MemberBindingType.ListBinding:
                     return this.VisitMemberListBinding((MemberListBinding)binding);
                 default:
-                    throw Error.UnhandledBindingType(binding.BindingType);
+                    throw UnhandledBindingType(binding.BindingType);
             }
         }
+
+        static Exception UnhandledBindingType(object p0) {
+            return new ArgumentException(string.Format ("Unhandled Binding Type: {0}", p0));
+        }        
         
         internal virtual ElementInit VisitElementInitializer(ElementInit initializer) {
             ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);

mcs/class/referencesource/System.Core/System/Linq/Parallel/QueryOperators/Binary/UnionQueryOperator.cs

@@ -189,7 +189,9 @@ namespace System.Linq.Parallel
 
             private QueryOperatorEnumerator<Pair<TInputOutput, NoKeyMemoizationRequired>, TLeftKey> m_leftSource; // Left data source.
             private QueryOperatorEnumerator<Pair<TInputOutput, NoKeyMemoizationRequired>, TRightKey> m_rightSource; // Right data source.
+#if !MONO
             private readonly int m_partitionIndex; // The current partition.
+#endif
             private Set<TInputOutput> m_hashLookup; // The hash lookup, used to produce the union.
             private CancellationToken m_cancellationToken;
             private Shared<int> m_outputLoopCount;
@@ -210,7 +212,9 @@ namespace System.Linq.Parallel
 
                 m_leftSource = leftSource;
                 m_rightSource = rightSource;
+#if !MONO
                 m_partitionIndex = partitionIndex;
+#endif
                 m_comparer = comparer;
                 m_cancellationToken = cancellationToken;
             }

mcs/class/referencesource/System.Core/System/Linq/Parallel/QueryOperators/Options/OrderingQueryOperator.cs

@@ -23,8 +23,10 @@ namespace System.Linq.Parallel
     /// <typeparam name="TSource"></typeparam>
     internal sealed class OrderingQueryOperator<TSource> : QueryOperator<TSource>
     {
+#if !MONO
         // Turns on order (AsOrdered) or turns off order (AsUnordered)
         private bool m_orderOn;
+#endif
         private QueryOperator<TSource> m_child;
         private OrdinalIndexState m_ordinalIndexState;
 
@@ -33,7 +35,9 @@ namespace System.Linq.Parallel
         {
             m_child = child;
             m_ordinalIndexState = m_child.OrdinalIndexState;
+#if !MONO
             m_orderOn = orderOn;
+#endif
         }
 
         internal override QueryResults<TSource> Open(QuerySettings settings, bool preferStriping)

mcs/class/referencesource/System.Core/System/Linq/Parallel/QueryOperators/Unary/ConcatQueryOperator.cs

@@ -233,7 +233,9 @@ namespace System.Linq.Parallel
 
         class ConcatQueryOperatorResults : BinaryQueryOperatorResults
         {
+#if !MONO
             ConcatQueryOperator<TSource> m_concatOp; // Operator that generated the results
+#endif
             int m_leftChildCount; // The number of elements in the left child result set
             int m_rightChildCount; // The number of elements in the right child result set
 
@@ -260,7 +262,9 @@ namespace System.Linq.Parallel
                 bool preferStriping)
                 : base(leftChildQueryResults, rightChildQueryResults, concatOp, settings, preferStriping)
             {
+#if !MONO
                 m_concatOp = concatOp;
+#endif
                 Contract.Assert(leftChildQueryResults.IsIndexible && rightChildQueryResults.IsIndexible);
 
                 m_leftChildCount = leftChildQueryResults.ElementsCount;

mcs/class/referencesource/System.Core/System/Linq/Parallel/QueryOperators/Unary/SortQueryOperator.cs

@@ -150,7 +150,9 @@ namespace System.Linq.Parallel
         protected QueryResults<TInputOutput> m_childQueryResults; // Results of the child query
         private SortQueryOperator<TInputOutput, TSortKey> m_op; // Operator that generated these results
         private QuerySettings m_settings; // Settings collected from the query
+#if !MONO
         private bool m_preferStriping; // If the results are indexible, should we use striping when partitioning them
+#endif
 
         internal SortQueryOperatorResults(
             QueryResults<TInputOutput> childQueryResults, SortQueryOperator<TInputOutput, TSortKey> op,
@@ -159,7 +161,9 @@ namespace System.Linq.Parallel
             m_childQueryResults = childQueryResults;
             m_op = op;
             m_settings = settings;
+#if !MONO
             m_preferStriping = preferStriping;
+#endif
         }
 
         internal override bool IsIndexible

mcs/class/referencesource/System.Core/System/Linq/Parallel/Scheduling/OrderPreservingPipeliningSpoolingTask.cs

@@ -25,7 +25,9 @@ namespace System.Linq.Parallel
     class OrderPreservingPipeliningSpoolingTask<TOutput, TKey> : SpoolingTaskBase
     {
         private readonly QueryTaskGroupState m_taskGroupState; // State shared among tasks.
+#if !MONO
         private readonly TaskScheduler m_taskScheduler; // The task manager to execute the query.
+#endif
         private readonly QueryOperatorEnumerator<TOutput, TKey> m_partition; // The source partition.
         private readonly bool[] m_consumerWaiting; // Whether a consumer is waiting on a particular producer
         private readonly bool[] m_producerWaiting; // Whether a particular producer is waiting on the consumer
@@ -83,7 +85,9 @@ namespace System.Linq.Parallel
             m_partitionIndex = partitionIndex;
             m_buffers = buffers;
             m_bufferLock = bufferLock;
+#if !MONO
             m_taskScheduler = taskScheduler;
+#endif
             m_autoBuffered = autoBuffered;
         }
 

mcs/class/referencesource/System.Core/System/Linq/Parallel/Utils/Sorting.cs

@@ -70,11 +70,15 @@ namespace System.Linq.Parallel
             Contract.Assert(sharedkeys != null);
             Contract.Assert(sharedValues != null);
             Contract.Assert(sharedBarriers != null);
+#if !MONO
             Contract.Assert(groupState.CancellationState.MergedCancellationToken != null);
+#endif
             Contract.Assert(sharedIndices.Length <= sharedkeys.Length);
             Contract.Assert(sharedIndices.Length == sharedValues.Length);
             Contract.Assert(sharedIndices.Length == sharedBarriers.GetLength(1));
+#if !MONO            
             Contract.Assert(groupState.CancellationState.MergedCancellationToken != null);
+#endif
 
             m_source = source;
             m_partitionCount = partitionCount;

mcs/class/referencesource/System.Core/System/Linq/SequenceQuery.cs

@@ -101,7 +101,9 @@ namespace System.Linq {
         object IQueryProvider.Execute(Expression expression){
             if (expression == null)
                 throw Error.ArgumentNull("expression");
+#if !MONO
             Type execType = typeof(EnumerableExecutor<>).MakeGenericType(expression.Type);
+#endif
             return EnumerableExecutor.Create(expression).ExecuteBoxed();
         }
 
@@ -194,7 +196,9 @@ namespace System.Linq {
 
             // check for args changed
             if (obj != m.Object || args != m.Arguments) {
+#if !MONO
                 Expression[] argArray = args.ToArray();
+#endif
                 Type[] typeArgs = (m.Method.IsGenericMethod) ? m.Method.GetGenericArguments() : null;
 
                 if ((m.Method.IsStatic || m.Method.DeclaringType.IsAssignableFrom(obj.Type))