Have Microsoft.CSharp pick correct default for optional MarshalAs(UnmanagedType.IDispatch) (#25508)

* Use null as default for optional parameters that marshal as IDispatch

Fixes #25507

* Don't allocate six arrays for empty parameters in MethodOrPropertySymbol

* More tests for default parameter value handling

* Remove dead path from SetParameterAttributes

Looks for default decimal value, but we've already looked for that via
DecimalConstantAttribute.

* Remove dead branch in handling of assigning Type.Missing

Called if a parameter type which is known to be typeof(object) is
typeof(Missing), which clearly can't happen. (And if it did the result
would be a harmless cast from Missing to Missing anyway).

* More tests for optional arguments

Default enums & structs and optionals without defaults.

* Assert MethodOrPropertySymbol._Params is set only once.

Author: JonHanna

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/GroupToArgsBinder.cs

@@ -586,15 +586,7 @@ private static Expr GenerateOptionalArgument(
                             FieldSymbol field = symbolLoader.LookupAggMember(name, agg, symbmask_t.MASK_FieldSymbol) as FieldSymbol;
                             FieldWithType fwt = new FieldWithType(field, agg.getThisType());
                             ExprField exprField = exprFactory.CreateField(agg.getThisType(), null, fwt, false);
-
-                            if (agg.getThisType() != type)
-                            {
-                                optionalArgument = exprFactory.CreateCast(type, exprField);
-                            }
-                            else
-                            {
-                                optionalArgument = exprField;
-                            }
+                            optionalArgument = exprFactory.CreateCast(type, exprField);
                         }
                     }
                     else

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/Semantics/Symbols/MethodOrPropertySymbol.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
@@ -59,16 +60,27 @@ public TypeArray Params
             }
             set
             {
-                // Should only be set once!
+                Debug.Assert(_Params == null, "Should only be set once");
                 _Params = value;
-                _optionalParameterIndex = new bool[_Params.Count];
-                _defaultParameterIndex = new bool[_Params.Count];
-                _defaultParameters = new ConstVal[_Params.Count];
-                _defaultParameterConstValTypes = new CType[_Params.Count];
-                _marshalAsIndex = new bool[_Params.Count];
-                _marshalAsBuffer = new UnmanagedType[_Params.Count];
+                int count = value.Count;
+                if (count == 0)
+                {
+                    _optionalParameterIndex = _defaultParameterIndex = _marshalAsIndex = Array.Empty<bool>();
+                    _defaultParameters = Array.Empty<ConstVal>();
+                    _defaultParameterConstValTypes = Array.Empty<CType>();
+                    _marshalAsBuffer = Array.Empty<UnmanagedType>();
+                }
+                else
+                {
+                    _optionalParameterIndex = new bool[count];
+                    _defaultParameterIndex = new bool[count];
+                    _defaultParameters = new ConstVal[count];
+                    _defaultParameterConstValTypes = new CType[count];
+                    _marshalAsIndex = new bool[count];
+                    _marshalAsBuffer = new UnmanagedType[count];
+                }
             }
-        }             // array of cParams parameter types.
+        }
 
         public MethodOrPropertySymbol()
         {
@@ -157,14 +169,13 @@ private UnmanagedType GetMarshalAsParameterValue(int index)
 
         public bool MarshalAsObject(int index)
         {
-            UnmanagedType marshalAsType = default(UnmanagedType);
-
             if (IsMarshalAsParameter(index))
             {
-                marshalAsType = GetMarshalAsParameterValue(index);
+                UnmanagedType marshalAsType = GetMarshalAsParameterValue(index);
+                return marshalAsType == UnmanagedType.Interface || marshalAsType == UnmanagedType.IUnknown || marshalAsType == UnmanagedType.IDispatch;
             }
 
-            return marshalAsType == UnmanagedType.Interface || marshalAsType == UnmanagedType.IUnknown;
+            return false;
         }
 
         public AggregateSymbol getClass() => parent as AggregateSymbol;

src/Microsoft.CSharp/src/Microsoft/CSharp/RuntimeBinder/SymbolTable.cs

@@ -1620,6 +1620,7 @@ private void SetParameterAttributes(MethodOrPropertySymbol methProp, ParameterIn
                     {
                         object defValue = parameter.DefaultValue;
 #endif
+                        Debug.Assert(Type.GetTypeCode(defValue.GetType()) != TypeCode.Decimal); // Handled above
                         switch (Type.GetTypeCode(defValue.GetType()))
                         {
 
@@ -1653,11 +1654,6 @@ private void SetParameterAttributes(MethodOrPropertySymbol methProp, ParameterIn
                                 cvType = _semanticChecker.SymbolLoader.GetPredefindType(PredefinedType.PT_DOUBLE);
                                 break;
 
-                            case TypeCode.Decimal:
-                                cv = ConstVal.Get((decimal)defValue);
-                                cvType = _semanticChecker.SymbolLoader.GetPredefindType(PredefinedType.PT_DECIMAL);
-                                break;
-
                             case TypeCode.Char:
                                 cv = ConstVal.Get((char)defValue);
                                 cvType = _semanticChecker.SymbolLoader.GetPredefindType(PredefinedType.PT_CHAR);