IInvocationExpression and IArgument refinement and testing

build/Rulesets/Roslyn_BuildRules.ruleset

@@ -89,7 +89,7 @@
     <Rule Id="CA1308" Action="None" />
     <Rule Id="CA1810" Action="None" />
     <Rule Id="CA1816" Action="None" />
-    <Rule Id="CA1825" Action="Warning" />
+    <Rule Id="CA1825" Action="None" />
     <Rule Id="CA2002" Action="None" />
     <Rule Id="CA2207" Action="None" />
     <Rule Id="CA2208" Action="None" />

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs

@@ -24,25 +24,28 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private bool _sawAwait;
         private bool _sawAwaitInExceptionHandler;
         private readonly DiagnosticBag _diagnostics;
+        private readonly bool _inIOperationContext;
 
-        private LocalRewriter(
+        internal LocalRewriter(
             CSharpCompilation compilation,
             MethodSymbol containingMethod,
             int containingMethodOrdinal,
             NamedTypeSymbol containingType,
             SyntheticBoundNodeFactory factory,
             SynthesizedSubmissionFields previousSubmissionFields,
             bool allowOmissionOfConditionalCalls,
-            DiagnosticBag diagnostics)
+            DiagnosticBag diagnostics,
+            bool inIOperationContext = false)
         {
             _compilation = compilation;
             _factory = factory;
             _factory.CurrentMethod = containingMethod;
-            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod.ContainingType));
+            Debug.Assert(factory.CurrentType == (containingType ?? containingMethod?.ContainingType));
             _dynamicFactory = new LoweredDynamicOperationFactory(factory, containingMethodOrdinal);
             _previousSubmissionFields = previousSubmissionFields;
             _allowOmissionOfConditionalCalls = allowOmissionOfConditionalCalls;
             _diagnostics = diagnostics;
+            _inIOperationContext = inIOperationContext;
         }
 
         /// <summary>

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs

@@ -344,7 +344,7 @@ private static bool IsSafeForReordering(BoundExpression expression, RefKind kind
         /// itself. <paramref name="optionalParametersMethod"/> is needed for indexers since getter and setter
         /// may have distinct optional parameter values.
         /// </summary>
-        private ImmutableArray<BoundExpression> MakeArguments(
+        internal ImmutableArray<BoundExpression> MakeArguments(
             CSharpSyntaxNode syntax,
             ImmutableArray<BoundExpression> rewrittenArguments,
             Symbol methodOrIndexer,
@@ -621,7 +621,7 @@ private BoundExpression BuildParamsArray(
             // if it's available.  However, we also disable the optimization if we're in an expression lambda, the 
             // point of which is just to represent the semantics of an operation, and we don't know that all consumers
             // of expression lambdas will appropriately understand Array.Empty<T>().
-            if (arrayArgs.Length == 0 && !_inExpressionLambda)
+            if (arrayArgs.Length == 0 && !_inExpressionLambda && !_inIOperationContext)
             {
                 ArrayTypeSymbol ats = paramArrayType as ArrayTypeSymbol;
                 if (ats != null) // could be null if there's a semantic error, e.g. the params parameter type isn't an array
@@ -797,8 +797,8 @@ private void InsertMissingOptionalArguments(CSharpSyntaxNode syntax,
                 if (arguments[p] == null)
                 {
                     ParameterSymbol parameter = parameters[p];
-                    Debug.Assert(parameter.IsOptional);
-                    arguments[p] = GetDefaultParameterValue(syntax, parameter, enableCallerInfo);
+                    Debug.Assert(parameter.IsOptional || _inIOperationContext);
+                    arguments[p] = parameter.IsOptional ? GetDefaultParameterValue(syntax, parameter, enableCallerInfo) : new BoundBadExpression(syntax, LookupResultKind.Empty, ImmutableArray<Symbol>.Empty, ImmutableArray<BoundNode>.Empty, parameter.Type);
                     Debug.Assert(arguments[p].Type == parameter.Type);
                 }
             }

src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs

@@ -165,6 +165,17 @@ public SyntheticBoundNodeFactory(MethodSymbol topLevelMethodOpt, NamedTypeSymbol
             this.Diagnostics = diagnostics;
         }
 
+        /// <summary>
+        /// Constructor used in circumstances where type/method context is not available, producing a factory of limited capability.
+        /// </summary>
+        /// <param name="node">The syntax node to which generated code should be attributed</param>
+        /// <param name="diagnostics">A bag where any diagnostics should be output</param>
+        internal SyntheticBoundNodeFactory(CSharpSyntaxNode node, DiagnosticBag diagnostics)
+        {
+            this.Syntax = node;
+            this.Diagnostics = diagnostics;
+        }
+
         [Conditional("DEBUG")]
         private void CheckCurrentType()
         {

src/Compilers/CSharp/Test/Semantic/CSharpCompilerSemanticTest.csproj

@@ -68,6 +68,7 @@
     <Compile Include="Diagnostics\DiagnosticAnalyzerTests.AllInOne.cs" />
     <Compile Include="Diagnostics\DiagnosticAnalyzerTests.cs" />
     <Compile Include="Diagnostics\GetDiagnosticsTests.cs" />
+    <Compile Include="Diagnostics\IInvocationExpressionTests.cs" />
     <Compile Include="Diagnostics\OperationAnalyzerTests.cs" />
     <Compile Include="FlowAnalysis\FlowDiagnosticTests.cs" />
     <Compile Include="FlowAnalysis\FlowTestBase.cs" />