regenerated xml.generated file

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

@@ -180,8 +180,8 @@ internal BoundExpression ConvertPatternExpression(TypeSymbol inputType, CSharpSy
                 {
                     case ConversionKind.ExplicitDynamic:
                     case ConversionKind.ImplicitDynamic:
-                        // Since the input was `dynamic`, which is equivalent to `object`, there must also
-                        // exist some unboxing, identity, or reference conversion as well, making the conversion legal.
+                    // Since the input was `dynamic`, which is equivalent to `object`, there must also
+                    // exist some unboxing, identity, or reference conversion as well, making the conversion legal.
                     case ConversionKind.Boxing:
                     case ConversionKind.ExplicitNullable:
                     case ConversionKind.ExplicitReference:
@@ -245,7 +245,7 @@ internal BoundExpression ConvertPatternExpression(TypeSymbol inputType, CSharpSy
                 case SyntaxKind.SingleVariableDesignation:
                     break;
                 case SyntaxKind.DiscardDesignation:
-                    return new BoundDeclarationPattern(node, null, boundDeclType, isVar, hasErrors);
+                    return new BoundDeclarationPattern(node, null, new BoundDiscardExpression(node, boundDeclType.Type), boundDeclType, isVar, hasErrors);
                 default:
                     throw ExceptionUtilities.UnexpectedValue(node.Designation.Kind());
             }
@@ -271,7 +271,8 @@ internal BoundExpression ConvertPatternExpression(TypeSymbol inputType, CSharpSy
                     hasErrors = CheckRestrictedTypeInAsync(this.ContainingMemberOrLambda, declType, diagnostics, typeSyntax);
                 }
 
-                return new BoundDeclarationPattern(node, localSymbol, boundDeclType, isVar, hasErrors);
+                var expression = localSymbol == null ? new BoundDiscardExpression(node, boundDeclType.Type) : (BoundExpression)new BoundLocal(node, localSymbol, null, boundDeclType.Type);
+                return new BoundDeclarationPattern(node, localSymbol, expression, boundDeclType, isVar, hasErrors);
             }
             else
             {

src/Compilers/CSharp/Portable/BoundTree/Statement.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+#if false
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Semantics;
 using System.Collections.Immutable;
@@ -262,8 +263,8 @@ public override void Accept(OperationVisitor visitor)
 
     internal partial class BoundForEachStatement : IForEachLoopStatement
     {
-        ILocalSymbol IForEachLoopStatement.IterationVariable => this.IterationVariables.Length == 1?
-                                                                        this.IterationVariables.FirstOrDefault():
+        ILocalSymbol IForEachLoopStatement.IterationVariable => this.IterationVariables.Length == 1 ?
+                                                                        this.IterationVariables.FirstOrDefault() :
                                                                         null;
 
         IOperation IForEachLoopStatement.Collection => this.Expression;
@@ -612,7 +613,7 @@ ImmutableArray<IVariableDeclaration> IVariableDeclarationStatement.Variables
             get
             {
                 return (ImmutableArray<IVariableDeclaration>)s_variablesMappings.GetValue(this,
-                    declaration => ImmutableArray.Create<IVariableDeclaration>(new VariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax)));
+                    declaration => ImmutableArray.Create<IVariableDeclaration>(OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax)));
             }
         }
 
@@ -641,7 +642,7 @@ ImmutableArray<IVariableDeclaration> IVariableDeclarationStatement.Variables
                 return (ImmutableArray<IVariableDeclaration>)s_variablesMappings.GetValue(this,
                     multipleDeclarations =>
                         multipleDeclarations.LocalDeclarations.SelectAsArray(declaration =>
-                            (IVariableDeclaration)new VariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax)));
+                            (IVariableDeclaration)OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax)));
             }
         }
 
@@ -837,3 +838,4 @@ public override void Accept(OperationVisitor visitor)
         }
     }
 }
+#endif
\ No newline at end of file

src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs

@@ -103,7 +103,7 @@ public override CSharpSemanticModel ParentModel
         internal override MemberSemanticModel GetMemberModel(SyntaxNode node)
         {
             // We do have to override this method, but should never call it because it might not do the right thing. 
-            Debug.Assert(false); 
+            Debug.Assert(false);
             return IsInTree(node) ? this : null;
         }
 
@@ -591,7 +591,7 @@ private LocalFunctionSymbol GetDeclaredLocalFunction(LocalFunctionStatementSynta
 
         private static LocalFunctionSymbol GetDeclaredLocalFunction(Binder enclosingBinder, SyntaxToken declaredIdentifier)
         {
-            for (var binder = enclosingBinder ; binder != null; binder = binder.Next)
+            for (var binder = enclosingBinder; binder != null; binder = binder.Next)
             {
                 foreach (var localFunction in binder.LocalFunctions)
                 {
@@ -929,7 +929,7 @@ public override ISymbol GetDeclaredSymbol(ArgumentSyntax declaratorSyntax, Cance
             {
                 var elements = tupleLiteralType.TupleElements;
 
-                if(!elements.IsDefault)
+                if (!elements.IsDefault)
                 {
                     var idx = tupleLiteral.Arguments.IndexOf(declaratorSyntax);
                     return elements[idx];
@@ -978,7 +978,7 @@ internal override IOperation GetOperationWorker(CSharpSyntaxNode node, GetOperat
                     break;
             }
 
-            return result as IOperation;
+            return CSharpOperationFactory.Create(result);
         }
 
         internal override SymbolInfo GetSymbolInfoWorker(CSharpSyntaxNode node, SymbolInfoOptions options, CancellationToken cancellationToken = default(CancellationToken))
@@ -1520,7 +1520,7 @@ private static Binder GetQueryEnclosingBinder(int position, CSharpSyntaxNode sta
             }
             while (node != null);
 
-done:
+            done:
             return GetEnclosingBinderInternalWithinRoot(AdjustStartingNodeAccordingToNewRoot(startingNode, queryClause.Syntax),
                                       position, queryClause.Binder, queryClause.Syntax);
         }
@@ -1805,7 +1805,7 @@ protected CSharpSyntaxNode GetBindableParentNode(CSharpSyntaxNode node)
                 {
                     return null;
                 }
-                
+
                 throw new ArgumentException($"The parent of {nameof(node)} must not be null unless this is a speculative semantic model.", nameof(node));
             }
 

src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AwaitExpressionSpiller.cs

@@ -56,18 +56,6 @@ public bool HasLocals
                 }
             }
 
-            protected override OperationKind ExpressionKind => OperationKind.None;
-
-            public override void Accept(OperationVisitor visitor)
-            {
-                throw ExceptionUtilities.Unreachable;
-            }
-
-            public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
-            {
-                throw ExceptionUtilities.Unreachable;
-            }
-
             public ImmutableArray<LocalSymbol> GetLocals()
             {
                 return (_locals == null) ? ImmutableArray<LocalSymbol>.Empty : _locals.ToImmutable();
@@ -772,8 +760,8 @@ public override BoundNode VisitCall(BoundCall node)
 
         private static RefKind ReceiverSpillRefKind(BoundExpression receiver)
         {
-            return LocalRewriter.WouldBeAssignableIfUsedAsMethodReceiver(receiver) ? 
-                RefKind.Ref : 
+            return LocalRewriter.WouldBeAssignableIfUsedAsMethodReceiver(receiver) ?
+                RefKind.Ref :
                 RefKind.None;
         }
 

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/PartiallyLoweredLocalFunctionReference.cs

@@ -29,23 +29,5 @@ internal class PartiallyLoweredLocalFunctionReference : BoundExpression
 
         public override BoundNode Accept(BoundTreeVisitor visitor) =>
             visitor.Visit(this);
-
-        protected override OperationKind ExpressionKind
-        {
-            get
-            {
-                throw new InvalidOperationException();
-            }
-        }
-
-        public override void Accept(OperationVisitor visitor)
-        {
-            throw new InvalidOperationException();
-        }
-
-        public override TResult Accept<TArgument, TResult>(OperationVisitor<TArgument, TResult> visitor, TArgument argument)
-        {
-            throw new InvalidOperationException();
-        }
     }
 }

src/Compilers/Core/Portable/CodeAnalysis.csproj

@@ -43,7 +43,6 @@
     <Compile Include="Operations\BranchKind.cs" />
     <Compile Include="Operations\CaseKind.cs" />
     <Compile Include="Operations\ConversionKind.cs" />
-    <Compile Include="Operations\Expressions.cs" />
     <Compile Include="Operations\IAddressOfExpression.cs" />
     <Compile Include="Operations\IArgument.cs" />
     <Compile Include="Operations\IArrayCreationExpression.cs" />
@@ -131,6 +130,7 @@
     <Compile Include="Operations\IWhileUntilLoopStatement.cs" />
     <Compile Include="Operations\IWithStatement.cs" />
     <Compile Include="Operations\LoopKind.cs" />
+    <Compile Include="Operations\OperationFactory.cs" />
     <Compile Include="Operations\SimpleBinaryOperationKind.cs" />
     <Compile Include="Operations\SimpleUnaryOperationKind.cs" />
     <Compile Include="Operations\SyntheticLocalKind.cs" />
@@ -403,7 +403,6 @@
     <Compile Include="Compilation\SemanticModel.cs" />
     <Compile Include="Compilation\SourceReferenceResolver.cs" />
     <Compile Include="Compilation\SpeculativeBindingOption.cs" />
-    <Compile Include="Operations\Statement.cs" />
     <Compile Include="Compilation\SubsystemVersion.cs" />
     <Compile Include="Compilation\SymbolInfo.cs" />
     <Compile Include="Compilation\TypeInfo.cs" />

src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs

@@ -1913,12 +1913,19 @@ public override void Accept(OperationVisitor visitor)
     /// </summary>
     internal sealed partial class IndexedPropertyReferenceExpression : PropertyReferenceExpressionBase, IHasArgumentsExpression, IIndexedPropertyReferenceExpression
     {
-        public IndexedPropertyReferenceExpression(IPropertySymbol property, IOperation instance, ISymbol member, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public IndexedPropertyReferenceExpression(IPropertySymbol property, IOperation instance, ISymbol member, ImmutableArray<IArgument> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(property, member, OperationKind.IndexedPropertyReferenceExpression, isInvalid, syntax, type, constantValue)
         {
+            ArgumentsInParameterOrder = argumentsInParameterOrder;
             Instance = instance ?? throw new System.ArgumentNullException("instance");
         }
         /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
+        /// <summary>
         /// Instance of the type. Null if the reference is to a static/shared member.
         /// </summary>
         public override IOperation Instance { get; }
@@ -1938,11 +1945,20 @@ public override void Accept(OperationVisitor visitor)
     internal sealed partial class LazyIndexedPropertyReferenceExpression : PropertyReferenceExpressionBase, IHasArgumentsExpression, IIndexedPropertyReferenceExpression
     {
         private readonly Lazy<IOperation> _lazyInstance;
+        private readonly Lazy<ImmutableArray<IArgument>> _lazyArgumentsInParameterOrder;
 
-        public LazyIndexedPropertyReferenceExpression(IPropertySymbol property, Lazy<IOperation> instance, ISymbol member, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(property, member, OperationKind.IndexedPropertyReferenceExpression, isInvalid, syntax, type, constantValue)
+        public LazyIndexedPropertyReferenceExpression(IPropertySymbol property, Lazy<IOperation> instance, ISymbol member, Lazy<ImmutableArray<IArgument>> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(property, member, OperationKind.IndexedPropertyReferenceExpression, isInvalid, syntax, type, constantValue)
         {
+            _lazyArgumentsInParameterOrder = argumentsInParameterOrder;
             _lazyInstance = instance ?? throw new System.ArgumentNullException("instance");
         }
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public ImmutableArray<IArgument> ArgumentsInParameterOrder => _lazyArgumentsInParameterOrder.Value;
+
         /// <summary>
         /// Instance of the type. Null if the reference is to a static/shared member.
         /// </summary>
@@ -2051,6 +2067,12 @@ internal abstract partial class InvocationExpressionBase : Operation, IHasArgume
         /// unless supplied in source.
         /// </summary>
         public abstract ImmutableArray<IArgument> ArgumentsInSourceOrder { get; }
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public abstract ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitInvocationExpression(this);
@@ -2066,11 +2088,12 @@ public override void Accept(OperationVisitor visitor)
     /// </summary>
     internal sealed partial class InvocationExpression : InvocationExpressionBase, IHasArgumentsExpression, IInvocationExpression
     {
-        public InvocationExpression(IMethodSymbol targetMethod, IOperation instance, bool isVirtual, ImmutableArray<IArgument> argumentsInSourceOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public InvocationExpression(IMethodSymbol targetMethod, IOperation instance, bool isVirtual, ImmutableArray<IArgument> argumentsInSourceOrder, ImmutableArray<IArgument> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(targetMethod, isVirtual, isInvalid, syntax, type, constantValue)
         {
             Instance = instance ?? throw new System.ArgumentNullException("instance");
             ArgumentsInSourceOrder = argumentsInSourceOrder;
+            ArgumentsInParameterOrder = argumentsInParameterOrder;
         }
         /// <summary>
         /// 'This' or 'Me' instance to be supplied to the method, or null if the method is static.
@@ -2082,6 +2105,12 @@ internal sealed partial class InvocationExpression : InvocationExpressionBase, I
         /// unless supplied in source.
         /// </summary>
         public override ImmutableArray<IArgument> ArgumentsInSourceOrder { get; }
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public override ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
     }
 
     /// <summary>
@@ -2091,11 +2120,13 @@ internal sealed partial class LazyInvocationExpression : InvocationExpressionBas
     {
         private readonly Lazy<IOperation> _lazyInstance;
         private readonly Lazy<ImmutableArray<IArgument>> _lazyArgumentsInSourceOrder;
+        private readonly Lazy<ImmutableArray<IArgument>> _lazyArgumentsInParameterOrder;
 
-        public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy<IOperation> instance, bool isVirtual, Lazy<ImmutableArray<IArgument>> argumentsInSourceOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(targetMethod, isVirtual, isInvalid, syntax, type, constantValue)
+        public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy<IOperation> instance, bool isVirtual, Lazy<ImmutableArray<IArgument>> argumentsInSourceOrder, Lazy<ImmutableArray<IArgument>> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(targetMethod, isVirtual, isInvalid, syntax, type, constantValue)
         {
             _lazyInstance = instance ?? throw new System.ArgumentNullException("instance");
             _lazyArgumentsInSourceOrder = argumentsInSourceOrder;
+            _lazyArgumentsInParameterOrder = argumentsInParameterOrder;
         }
         /// <summary>
         /// 'This' or 'Me' instance to be supplied to the method, or null if the method is static.
@@ -2108,6 +2139,13 @@ public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy<IOperation> ins
         /// unless supplied in source.
         /// </summary>
         public override ImmutableArray<IArgument> ArgumentsInSourceOrder => _lazyArgumentsInSourceOrder.Value;
+
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public override ImmutableArray<IArgument> ArgumentsInParameterOrder => _lazyArgumentsInParameterOrder.Value;
     }
 
     /// <summary>
@@ -2677,6 +2715,12 @@ internal abstract partial class ObjectCreationExpressionBase : Operation, IHasAr
         /// Explicitly-specified member initializers.
         /// </summary>
         public abstract ImmutableArray<ISymbolInitializer> MemberInitializers { get; }
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public abstract ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         public override void Accept(OperationVisitor visitor)
         {
             visitor.VisitObjectCreationExpression(this);
@@ -2692,15 +2736,22 @@ public override void Accept(OperationVisitor visitor)
     /// </summary>
     internal sealed partial class ObjectCreationExpression : ObjectCreationExpressionBase, IHasArgumentsExpression, IObjectCreationExpression
     {
-        public ObjectCreationExpression(IMethodSymbol constructor, ImmutableArray<ISymbolInitializer> memberInitializers, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
+        public ObjectCreationExpression(IMethodSymbol constructor, ImmutableArray<ISymbolInitializer> memberInitializers, ImmutableArray<IArgument> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
             base(constructor, isInvalid, syntax, type, constantValue)
         {
             MemberInitializers = memberInitializers;
+            ArgumentsInParameterOrder = argumentsInParameterOrder;
         }
         /// <summary>
         /// Explicitly-specified member initializers.
         /// </summary>
         public override ImmutableArray<ISymbolInitializer> MemberInitializers { get; }
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public override ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
     }
 
     /// <summary>
@@ -2709,15 +2760,24 @@ internal sealed partial class ObjectCreationExpression : ObjectCreationExpressio
     internal sealed partial class LazyObjectCreationExpression : ObjectCreationExpressionBase, IHasArgumentsExpression, IObjectCreationExpression
     {
         private readonly Lazy<ImmutableArray<ISymbolInitializer>> _lazyMemberInitializers;
+        private readonly Lazy<ImmutableArray<IArgument>> _lazyArgumentsInParameterOrder;
 
-        public LazyObjectCreationExpression(IMethodSymbol constructor, Lazy<ImmutableArray<ISymbolInitializer>> memberInitializers, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(constructor, isInvalid, syntax, type, constantValue)
+        public LazyObjectCreationExpression(IMethodSymbol constructor, Lazy<ImmutableArray<ISymbolInitializer>> memberInitializers, Lazy<ImmutableArray<IArgument>> argumentsInParameterOrder, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) : base(constructor, isInvalid, syntax, type, constantValue)
         {
             _lazyMemberInitializers = memberInitializers;
+            _lazyArgumentsInParameterOrder = argumentsInParameterOrder;
         }
         /// <summary>
         /// Explicitly-specified member initializers.
         /// </summary>
         public override ImmutableArray<ISymbolInitializer> MemberInitializers => _lazyMemberInitializers.Value;
+
+        /// <summary>
+        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
+        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
+        /// optional arguments missing in source.
+        /// </summary>
+        public override ImmutableArray<IArgument> ArgumentsInParameterOrder => _lazyArgumentsInParameterOrder.Value;
     }
 
     /// <summary>

src/Compilers/Core/Portable/Operations/Expressions.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Immutable;
-using System.Linq;
-
-namespace Microsoft.CodeAnalysis.Semantics
-{
-    internal sealed partial class ConditionalChoiceExpression : IConditionalChoiceExpression
-    {
-        public ConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SyntaxNode syntax) :
-            this(condition,
-                ifTrue,
-                ifFalse,
-                IsInvalidOperation(condition, ifTrue, ifFalse, resultType),
-                syntax,
-                resultType,
-                default(Optional<object>))
-        {
-        }
-
-        private static bool IsInvalidOperation(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType)
-        {
-            return (condition == null || condition.IsInvalid || ifTrue == null || ifTrue.IsInvalid || ifFalse == null || ifFalse.IsInvalid || resultType == null);
-        }
-    }
-
-    internal sealed partial class ExpressionStatement : IExpressionStatement
-    {
-        public ExpressionStatement(IOperation target, IOperation value, SyntaxNode syntax) :
-            this(new AssignmentExpression(target, value, IsInvalidOperation(target, value), syntax, target.Type, default(Optional<object>)),
-                syntax)
-        {
-        }
-
-        public ExpressionStatement(IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, IMethodSymbol operatorMethod, SyntaxNode syntax) :
-            this(new CompoundAssignmentExpression(
-                    binaryOperationKind,
-                    target,
-                    value,
-                    operatorMethod != null,
-                    operatorMethod,
-                    IsInvalidOperation(target, value),
-                    syntax,
-                    target.Type,
-                    default(Optional<object>)),
-                syntax)
-        {
-        }
-
-        private ExpressionStatement(IOperation expression, SyntaxNode syntax) :
-            this(expression, expression.IsInvalid, syntax, type: null, constantValue: default(Optional<object>))
-        {
-        }
-
-        private static bool IsInvalidOperation(IOperation target, IOperation value)
-        {
-            return target == null || target.IsInvalid || value == null || value.IsInvalid;
-        }
-    }
-
-    internal sealed partial class LiteralExpression : ILiteralExpression
-    {
-        public LiteralExpression(long value, ITypeSymbol resultType, SyntaxNode syntax) :
-            this(value.ToString(), isInvalid: false, syntax: syntax, type: resultType, constantValue: new Optional<object>(value))
-        {
-        }
-
-        public LiteralExpression(ConstantValue value, ITypeSymbol resultType, SyntaxNode syntax) :
-            this(value.GetValueToDisplay(), value.IsBad, syntax, resultType, new Optional<object>(value.Value))
-        {
-        }
-    }
-
-    internal sealed partial class BinaryOperatorExpression : IBinaryOperatorExpression
-    {
-        public BinaryOperatorExpression(BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SyntaxNode syntax) :
-            this(binaryOperationKind, left, right,
-                usesOperatorMethod: false, operatorMethod: null,
-                isInvalid: IsInvalidOperation(binaryOperationKind, left, right, resultType),
-                syntax: syntax, type: resultType, constantValue: default(Optional<object>))
-        {
-        }
-
-        private static bool IsInvalidOperation(BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol type)
-        {
-            return left == null || left.IsInvalid || right == null
-                   || right.IsInvalid || binaryOperationKind == BinaryOperationKind.Invalid || type == null;
-        }
-    }
-
-    internal sealed partial class ArrayCreationExpression : IArrayCreationExpression
-    {
-        public ArrayCreationExpression(IArrayTypeSymbol arrayType, ImmutableArray<IOperation> elementValues, SyntaxNode syntax) :
-            this(arrayType.ElementType,
-                ImmutableArray.Create<IOperation>(new LiteralExpression(elementValues.Count(), resultType: null, syntax: syntax)),
-                new ArrayInitializer(elementValues, elementValues.Any(v => v.IsInvalid), syntax, arrayType, default(Optional<object>)),
-                syntax,
-                arrayType,
-                default(Optional<object>))
-        {
-        }
-
-        private ArrayCreationExpression(ITypeSymbol elementType, ImmutableArray<IOperation> dimensionSizes, IArrayInitializer initializer, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :
-            this(elementType, dimensionSizes, initializer, initializer.IsInvalid, syntax, type, constantValue)
-        {
-        }
-    }
-
-    internal partial class InvalidExpression : IInvalidExpression
-    {
-        public InvalidExpression(SyntaxNode syntax) :
-            this(isInvalid: true, syntax: syntax, type: null, constantValue: default(Optional<object>))
-        {
-        }
-    }
-}

src/Compilers/Core/Portable/Operations/IndexedPropertyReferenceExpression_IHasArgumentsExpression.cs

@@ -6,12 +6,6 @@ namespace Microsoft.CodeAnalysis.Semantics
 {
     internal partial class IndexedPropertyReferenceExpression : IHasArgumentsExpression
     {
-        /// <summary>
-        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
-        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
-        /// optional arguments missing in source.
-        /// </summary>
-        public ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         /// <summary>
         /// Find the argument supplied for a given parameter of the target method.
         /// </summary>
@@ -19,18 +13,12 @@ internal partial class IndexedPropertyReferenceExpression : IHasArgumentsExpress
         /// <returns>Argument corresponding to the parameter.</returns>
         public IArgument GetArgumentMatchingParameter(IParameterSymbol parameter)
         {
-            throw new System.NotImplementedException();
+            return this.ArgumentsInParameterOrder[parameter.Ordinal];
         }
     }
 
     internal partial class LazyIndexedPropertyReferenceExpression : IHasArgumentsExpression
     {
-        /// <summary>
-        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
-        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
-        /// optional arguments missing in source.
-        /// </summary>
-        public ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         /// <summary>
         /// Find the argument supplied for a given parameter of the target method.
         /// </summary>
@@ -38,7 +26,7 @@ internal partial class LazyIndexedPropertyReferenceExpression : IHasArgumentsExp
         /// <returns>Argument corresponding to the parameter.</returns>
         public IArgument GetArgumentMatchingParameter(IParameterSymbol parameter)
         {
-            throw new System.NotImplementedException();
+            return this.ArgumentsInParameterOrder[parameter.Ordinal];
         }
     }
 }

src/Compilers/Core/Portable/Operations/InvocationExpression_IHasArgumentsExpression.cs

@@ -6,12 +6,6 @@ namespace Microsoft.CodeAnalysis.Semantics
 {
     internal partial class InvocationExpressionBase : IHasArgumentsExpression
     {
-        /// <summary>
-        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
-        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
-        /// optional arguments missing in source.
-        /// </summary>
-        public ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         /// <summary>
         /// Find the argument supplied for a given parameter of the target method.
         /// </summary>
@@ -19,7 +13,7 @@ internal partial class InvocationExpressionBase : IHasArgumentsExpression
         /// <returns>Argument corresponding to the parameter.</returns>
         public IArgument GetArgumentMatchingParameter(IParameterSymbol parameter)
         {
-            throw new System.NotImplementedException();
+            return this.ArgumentsInParameterOrder[parameter.Ordinal];
         }
     }
 }

src/Compilers/Core/Portable/Operations/ObjectCreationExpression_IHasArgumentsExpression.cs

@@ -6,12 +6,6 @@ namespace Microsoft.CodeAnalysis.Semantics
 {
     internal partial class ObjectCreationExpressionBase : IHasArgumentsExpression
     {
-        /// <summary>
-        /// Arguments of the invocation, excluding the instance argument. Arguments are in parameter order,
-        /// and params/ParamArray arguments have been collected into arrays. Default values are supplied for
-        /// optional arguments missing in source.
-        /// </summary>
-        public ImmutableArray<IArgument> ArgumentsInParameterOrder { get; }
         /// <summary>
         /// Find the argument supplied for a given parameter of the target method.
         /// </summary>
@@ -19,7 +13,7 @@ internal partial class ObjectCreationExpressionBase : IHasArgumentsExpression
         /// <returns>Argument corresponding to the parameter.</returns>
         public IArgument GetArgumentMatchingParameter(IParameterSymbol parameter)
         {
-            throw new System.NotImplementedException();
+            return this.ArgumentsInParameterOrder[parameter.Ordinal];
         }
     }
 }

src/Compilers/Core/Portable/Operations/OperationFactory.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace Microsoft.CodeAnalysis.Semantics
+{
+    internal static class OperationFactory
+    {
+        public static VariableDeclaration CreateVariableDeclaration(ILocalSymbol variable, IOperation initialValue, SyntaxNode syntax)
+        {
+            return new VariableDeclaration(
+                variable,
+                initialValue,
+                variable == null || (initialValue != null && initialValue.IsInvalid),
+                syntax,
+                type: null,
+                constantValue: default(Optional<object>));
+        }
+
+        public static ConditionalChoiceExpression CreateConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SyntaxNode syntax)
+        {
+            var isInvalid = (condition == null || condition.IsInvalid || ifTrue == null || ifTrue.IsInvalid || ifFalse == null || ifFalse.IsInvalid || resultType == null);
+
+            return new ConditionalChoiceExpression(
+                condition,
+                ifTrue,
+                ifFalse,
+                isInvalid,
+                syntax,
+                resultType,
+                default(Optional<object>));
+        }
+
+        public static ExpressionStatement CreateAssignmentExpressionStatement(IOperation target, IOperation value, SyntaxNode syntax)
+        {
+            var isInvalid = target == null || target.IsInvalid || value == null || value.IsInvalid;
+            var expression = new AssignmentExpression(target, value, isInvalid, syntax, target.Type, default(Optional<object>));
+            return new ExpressionStatement(expression, expression.IsInvalid, syntax, type: null, constantValue: default(Optional<object>));
+        }
+
+        public static ExpressionStatement CreateCompoundAssignmentExpressionStatement(
+            IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, IMethodSymbol operatorMethod, SyntaxNode syntax)
+        {
+            var isInvalid = target == null || target.IsInvalid || value == null || value.IsInvalid;
+            var expression = new CompoundAssignmentExpression(
+                     binaryOperationKind,
+                     target,
+                     value,
+                     operatorMethod != null,
+                     operatorMethod,
+                     isInvalid,
+                     syntax,
+                     target.Type,
+                     default(Optional<object>));
+
+            return new ExpressionStatement(expression, expression.IsInvalid, syntax, type: null, constantValue: default(Optional<object>));
+        }
+
+        public static LiteralExpression CreateLiteralExpression(long value, ITypeSymbol resultType, SyntaxNode syntax)
+        {
+            return new LiteralExpression(value.ToString(), isInvalid: false, syntax: syntax, type: resultType, constantValue: new Optional<object>(value));
+        }
+
+        public static LiteralExpression CreateLiteralExpression(ConstantValue value, ITypeSymbol resultType, SyntaxNode syntax)
+        {
+            return new LiteralExpression(value.GetValueToDisplay(), value.IsBad, syntax, resultType, new Optional<object>(value.Value));
+        }
+
+        public static BinaryOperatorExpression CreateBinaryOperatorExpression(
+            BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SyntaxNode syntax)
+        {
+            var isInvalid = left == null || left.IsInvalid || right == null || right.IsInvalid || binaryOperationKind == BinaryOperationKind.Invalid || resultType == null;
+            return new BinaryOperatorExpression(
+                binaryOperationKind, left, right,
+                usesOperatorMethod: false, operatorMethod: null,
+                isInvalid: isInvalid, syntax: syntax, type: resultType, constantValue: default(Optional<object>));
+        }
+
+        public static ArrayCreationExpression CreateArrayCreationExpression(
+            IArrayTypeSymbol arrayType, ImmutableArray<IOperation> elementValues, SyntaxNode syntax)
+        {
+            var initializer = new ArrayInitializer(elementValues, elementValues.Any(v => v.IsInvalid), syntax, arrayType, default(Optional<object>));
+            return new ArrayCreationExpression(
+                arrayType.ElementType,
+                ImmutableArray.Create<IOperation>(CreateLiteralExpression(elementValues.Count(), resultType: null, syntax: syntax)),
+                initializer,
+                initializer.IsInvalid,
+                syntax,
+                arrayType,
+                default(Optional<object>));
+        }
+
+        public static InvalidExpression CreateInvalidExpression(SyntaxNode syntax)
+        {
+            return new InvalidExpression(isInvalid: true, syntax: syntax, type: null, constantValue: default(Optional<object>));
+        }
+    }
+}
\ No newline at end of file

src/Compilers/Core/Portable/Operations/Statement.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-namespace Microsoft.CodeAnalysis.Semantics
-{
-    internal partial class VariableDeclaration : IVariableDeclaration
-    {
-        public VariableDeclaration(ILocalSymbol variable, IOperation initialValue, SyntaxNode syntax) :
-            this(variable,
-                initialValue,
-                variable == null || (initialValue != null && initialValue.IsInvalid),
-                syntax,
-                type: null,
-                constantValue: default(Optional<object>))
-        {
-        }
-    }
-}
\ No newline at end of file

src/Compilers/VisualBasic/Portable/BoundTree/Expression.vb

@@ -58,7 +58,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 End If
             End If
 
-            Return New InvalidExpression(parent.Syntax)
+            Return OperationFactory.CreateInvalidExpression(parent.Syntax)
         End Function
 
     End Class

src/Compilers/VisualBasic/Portable/BoundTree/Statement.vb

@@ -569,7 +569,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                 End If
 
                                 Dim stepOperand As IOperation = If(stepValue.IsConstant, DirectCast(stepValue, IOperation), New Temporary(SyntheticLocalKind.ForLoopStepValue, BoundFor, stepValue))
-                                statements.Add(New ExpressionStatement(controlReference, stepOperand, Semantics.Expression.DeriveAdditionKind(controlType), Nothing, stepValue.Syntax))
+                                statements.Add(OperationFactory.CreateCompoundAssignmentExpressionStatement(controlReference, stepOperand, Semantics.Expression.DeriveAdditionKind(controlType), Nothing, stepValue.Syntax))
                             End If
                         End If
 
@@ -592,17 +592,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                         ' ControlVariable = InitialValue
                         Dim controlReference As IOperation = BoundFor.ControlVariable
                         If controlReference IsNot Nothing Then
-                            statements.Add(New ExpressionStatement(controlReference, BoundFor.InitialValue, BoundFor.InitialValue.Syntax))
+                            statements.Add(OperationFactory.CreateAssignmentExpressionStatement(controlReference, BoundFor.InitialValue, BoundFor.InitialValue.Syntax))
                         End If
 
                         ' T0 = LimitValue
                         If Not Me.LimitValue.IsConstant Then
-                            statements.Add(New ExpressionStatement(New Temporary(SyntheticLocalKind.ForLoopLimitValue, BoundFor, BoundFor.LimitValue), BoundFor.LimitValue, BoundFor.LimitValue.Syntax))
+                            statements.Add(OperationFactory.CreateAssignmentExpressionStatement(New Temporary(SyntheticLocalKind.ForLoopLimitValue, BoundFor, BoundFor.LimitValue), BoundFor.LimitValue, BoundFor.LimitValue.Syntax))
                         End If
 
                         ' T1 = StepValue
                         If BoundFor.StepValue IsNot Nothing AndAlso Not BoundFor.StepValue.IsConstant Then
-                            statements.Add(New ExpressionStatement(New Temporary(SyntheticLocalKind.ForLoopStepValue, BoundFor, BoundFor.StepValue), BoundFor.StepValue, BoundFor.StepValue.Syntax))
+                            statements.Add(OperationFactory.CreateAssignmentExpressionStatement(New Temporary(SyntheticLocalKind.ForLoopStepValue, BoundFor, BoundFor.StepValue), BoundFor.StepValue, BoundFor.StepValue.Syntax))
                         End If
 
                         Return statements.ToImmutableAndFree()
@@ -640,25 +640,25 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                 ' Either ControlVariable <= LimitValue or ControlVariable >= LimitValue, depending on whether the step value is negative.
 
                                 Dim relationalCode As BinaryOperationKind = DeriveBinaryOperationKind(If(BoundFor.StepValue IsNot Nothing AndAlso BoundFor.StepValue.ConstantValueOpt.IsNegativeNumeric, BinaryOperatorKind.GreaterThanOrEqual, BinaryOperatorKind.LessThanOrEqual), controlVariable)
-                                Return New BinaryOperatorExpression(relationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
+                                Return OperationFactory.CreateBinaryOperatorExpression(relationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
                             Else
                                 ' If(StepValue >= 0, ControlVariable <= LimitValue, ControlVariable >= LimitValue)
 
                                 Dim stepValue As IOperation = New Temporary(SyntheticLocalKind.ForLoopStepValue, BoundFor, BoundFor.StepValue)
                                 Dim stepRelationalCode As BinaryOperationKind = DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, BoundFor.StepValue)
-                                Dim stepCondition As IOperation = New BinaryOperatorExpression(stepRelationalCode,
+                                Dim stepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(stepRelationalCode,
                                                                              stepValue,
-                                                                             New LiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValue.Type, 0), BoundFor.StepValue.Type, BoundFor.StepValue.Syntax),
+                                                                             OperationFactory.CreateLiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValue.Type, 0), BoundFor.StepValue.Type, BoundFor.StepValue.Syntax),
                                                                              booleanType,
                                                                              BoundFor.StepValue.Syntax)
 
                                 Dim positiveStepRelationalCode As BinaryOperationKind = DeriveBinaryOperationKind(BinaryOperatorKind.LessThanOrEqual, controlVariable)
-                                Dim positiveStepCondition As IOperation = New BinaryOperatorExpression(positiveStepRelationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
+                                Dim positiveStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(positiveStepRelationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
 
                                 Dim negativeStepRelationalCode As BinaryOperationKind = DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, controlVariable)
-                                Dim negativeStepCondition As IOperation = New BinaryOperatorExpression(negativeStepRelationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
+                                Dim negativeStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(negativeStepRelationalCode, controlVariable, limitValue, booleanType, limitValue.Syntax)
 
-                                Return New ConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, limitValue.Syntax)
+                                Return OperationFactory.CreateConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, limitValue.Syntax)
                             End If
                         End If
                     End Function)
@@ -1058,11 +1058,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                                      For Each base In dimStatement.LocalDeclarations
                                                                          If base.Kind = BoundKind.LocalDeclaration Then
                                                                              Dim declaration = DirectCast(base, BoundLocalDeclaration)
-                                                                             builder.Add(New VariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax))
+                                                                             builder.Add(OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, declaration.InitializerOpt, declaration.Syntax))
                                                                          ElseIf base.Kind = BoundKind.AsNewLocalDeclarations Then
                                                                              Dim asNewDeclarations = DirectCast(base, BoundAsNewLocalDeclarations)
                                                                              For Each asNewDeclaration In asNewDeclarations.LocalDeclarations
-                                                                                 builder.Add(New VariableDeclaration(asNewDeclaration.LocalSymbol, asNewDeclarations.Initializer, asNewDeclaration.Syntax))
+                                                                                 builder.Add(OperationFactory.CreateVariableDeclaration(asNewDeclaration.LocalSymbol, asNewDeclarations.Initializer, asNewDeclaration.Syntax))
                                                                              Next
                                                                          End If
                                                                      Next