private DynamicMetaObject GetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion)
{
Array array = (Array)target.Value;
if (indexes.Length == 1)
{
if (PSEnumerableBinder.IsEnumerable(indexes[0]) == null)
{
return(target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, new Expression[] { ExpressionCache.Constant(array.Rank), Expression.Dynamic(PSToStringBinder.Get(), typeof(string), indexes[0].Expression, ExpressionCache.GetExecutionContextFromTLS) }));
}
return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValueOrSlice, Expression.Convert(target.Expression, typeof(Array)), indexes[0].Expression.Cast(typeof(object))), target.CombineRestrictions(indexes)));
}
IEnumerable <Expression> source = from index in indexes
select ConvertIndex(index, typeof(int)) into i
where i != null
select i;
if (source.Count <Expression>() == indexes.Length)
{
return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValue, Expression.Convert(target.Expression, typeof(Array)), Expression.NewArrayInit(typeof(int), source), ExpressionCache.Constant(!this._allowSlicing)), target.CombineRestrictions(indexes)));
}
if (this._allowSlicing)
{
return(this.InvokeSlicingIndexer(target, indexes));
}
return(errorSuggestion ?? this.CannotIndexTarget(target, indexes));
}
internal static DynamicMetaObject EnsureAllowedInLanguageMode(PSLanguageMode languageMode, DynamicMetaObject target, object targetValue, string name, bool isStatic, DynamicMetaObject[] args, BindingRestrictions moreTests, string errorID, string resourceString)
{
if ((languageMode == PSLanguageMode.ConstrainedLanguage) && !IsAllowedInConstrainedLanguage(targetValue, name, isStatic))
{
return(target.ThrowRuntimeError(args, moreTests, errorID, resourceString, new Expression[0]));
}
return(null);
}
public override DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion)
{
if (target.HasValue && !(from mo in indexes
where !mo.HasValue
select mo).Any <DynamicMetaObject>())
{
if ((!(target.Value is PSObject) || (PSObject.Base(target.Value) == target.Value)) && !(from mo in indexes
where (mo.Value is PSObject) && (PSObject.Base(mo.Value) != mo.Value)
select mo).Any <DynamicMetaObject>())
{
if (target.Value == null)
{
return((errorSuggestion ?? target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NullArray", ParserStrings.NullArray, new Expression[0])).WriteToDebugLog(this));
}
if (((indexes.Length == 1) && (indexes[0].Value == null)) && this._allowSlicing)
{
return((errorSuggestion ?? target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NullArrayIndex", ParserStrings.NullArrayIndex, new Expression[0])).WriteToDebugLog(this));
}
if (target.LimitType.IsArray)
{
return(this.GetIndexArray(target, indexes, errorSuggestion).WriteToDebugLog(this));
}
foreach (Type type in target.LimitType.GetInterfaces())
{
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(IDictionary <,>)))
{
DynamicMetaObject obj2 = this.GetIndexDictionary(target, indexes, type);
if (obj2 != null)
{
return(obj2.WriteToDebugLog(this));
}
}
}
DefaultMemberAttribute attribute = target.LimitType.GetCustomAttributes <DefaultMemberAttribute>(true).FirstOrDefault <DefaultMemberAttribute>();
if (attribute != null)
{
return(this.InvokeIndexer(target, indexes, errorSuggestion, attribute.MemberName).WriteToDebugLog(this));
}
return(errorSuggestion ?? this.CannotIndexTarget(target, indexes).WriteToDebugLog(this));
}
return(this.DeferForPSObject(indexes.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()).WriteToDebugLog(this));
}
return(base.Defer(indexes.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()).WriteToDebugLog(this));
}
private DynamicMetaObject CannotIndexTarget(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value)
{
BindingRestrictions bindingRestriction = value.PSGetTypeRestriction();
bindingRestriction = bindingRestriction.Merge(BinderUtils.GetVersionCheck(this, this._version));
bindingRestriction = bindingRestriction.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
Expression[] expressionArray = new Expression[1];
expressionArray[0] = Expression.Constant(target.LimitType);
return(target.ThrowRuntimeError(indexes, bindingRestriction, "CannotIndex", ParserStrings.CannotIndex, expressionArray));
}
private DynamicMetaObject IncrDecr(DynamicMetaObject target, int valueToAdd, DynamicMetaObject errorSuggestion)
{
if (!target.HasValue)
{
return(base.Defer(target, new DynamicMetaObject[0]));
}
if ((target.Value is PSObject) && (PSObject.Base(target.Value) != target.Value))
{
return(this.DeferForPSObject(new DynamicMetaObject[] { target }));
}
if (target.Value == null)
{
return(new DynamicMetaObject(ExpressionCache.Constant(valueToAdd).Cast(typeof(object)), target.PSGetTypeRestriction()));
}
if (target.LimitType.IsNumeric())
{
DynamicMetaObject arg = new DynamicMetaObject(ExpressionCache.Constant(valueToAdd), BindingRestrictions.Empty, valueToAdd);
return(new DynamicMetaObject(PSBinaryOperationBinder.Get(ExpressionType.Add, true, false).FallbackBinaryOperation(target, arg, errorSuggestion).Expression, target.PSGetTypeRestriction()));
}
return(errorSuggestion ?? target.ThrowRuntimeError(new DynamicMetaObject[0], BindingRestrictions.Empty, "OperatorRequiresNumber", ParserStrings.OperatorRequiresNumber, new Expression[] { Expression.Constant(((base.Operation == ExpressionType.Increment) ? TokenKind.PlusPlus : TokenKind.MinusMinus).Text()), Expression.Constant(target.LimitType) }));
}
public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
{
PSMemberInfo info;
BindingRestrictions restrictions2;
bool flag3;
Type type4;
if (!target.HasValue || !value.HasValue)
{
return(base.Defer(target, new DynamicMetaObject[] { value }));
}
object obj2 = PSObject.Base(target.Value);
if (obj2 == null)
{
return(target.ThrowRuntimeError(new DynamicMetaObject[] { value }, BindingRestrictions.Empty, "PropertyNotFound", ParserStrings.PropertyNotFound, new Expression[] { Expression.Constant(base.Name) }).WriteToDebugLog(this));
}
if (value.Value == AutomationNull.Value)
{
value = new DynamicMetaObject(ExpressionCache.NullConstant, value.PSGetTypeRestriction(), null);
}
if (this._getMemberBinder.HasInstanceMember && PSGetMemberBinder.TryGetInstanceMember(target.Value, base.Name, out info))
{
ParameterExpression expression = Expression.Variable(typeof(PSMemberInfo));
ParameterExpression expression2 = Expression.Variable(typeof(object));
ConditionalExpression expression3 = Expression.Condition(Expression.Call(CachedReflectionInfo.PSGetMemberBinder_TryGetInstanceMember, target.Expression.Cast(typeof(object)), Expression.Constant(base.Name), expression), Expression.Assign(Expression.Property(expression, "Value"), value.Expression.Cast(typeof(object))), base.GetUpdateExpression(typeof(object)));
BindingRestrictions restrictions = BinderUtils.GetVersionCheck(this._getMemberBinder, this._getMemberBinder._version).Merge(value.PSGetTypeRestriction());
return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression, expression2 }, new Expression[] { expression3 }), restrictions).WriteToDebugLog(this));
}
if (obj2 is IDictionary)
{
Type genericTypeArg = null;
bool flag = PSGetMemberBinder.IsGenericDictionary(obj2, ref genericTypeArg);
if (!flag || (genericTypeArg != null))
{
bool flag2;
Type type = flag ? typeof(IDictionary <,>).MakeGenericType(new Type[] { typeof(string), genericTypeArg }) : typeof(IDictionary);
MethodInfo method = type.GetMethod("set_Item");
ParameterExpression left = Expression.Variable(genericTypeArg ?? typeof(object));
Type resultType = left.Type;
LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(value.Value, resultType, out flag2);
if (conversion.Rank != ConversionRank.None)
{
Expression right = PSConvertBinder.InvokeConverter(conversion, value.Expression, resultType, flag2, ExpressionCache.InvariantCulture);
return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { left }, new Expression[] { Expression.Assign(left, right), Expression.Call(PSGetMemberBinder.GetTargetExpr(target).Cast(type), method, Expression.Constant(base.Name), right), right.Cast(typeof(object)) }), target.CombineRestrictions(new DynamicMetaObject[] { value })).WriteToDebugLog(this));
}
}
}
info = this._getMemberBinder.GetPSMemberInfo(target, out restrictions2, out flag3, out type4, null, null);
restrictions2 = restrictions2.Merge(value.PSGetTypeRestriction());
if (ExecutionContext.HasEverUsedConstrainedLanguage)
{
restrictions2 = restrictions2.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
DynamicMetaObject obj3 = PSGetMemberBinder.EnsureAllowedInLanguageMode(LocalPipeline.GetExecutionContextFromTLS().LanguageMode, target, obj2, base.Name, this._static, new DynamicMetaObject[] { value }, restrictions2, "PropertySetterNotSupportedInConstrainedLanguage", ParserStrings.PropertySetConstrainedLanguage);
if (obj3 != null)
{
return(obj3.WriteToDebugLog(this));
}
}
if (flag3)
{
if (info == null)
{
return((errorSuggestion ?? new DynamicMetaObject(Compiler.ThrowRuntimeError("PropertyAssignmentException", ParserStrings.PropertyNotFound, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2)).WriteToDebugLog(this));
}
PSPropertyInfo info3 = info as PSPropertyInfo;
if (info3 != null)
{
if (!info3.IsSettable)
{
Expression innerException = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ParserStrings.PropertyIsReadOnly), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(base.Name) }) });
return(new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ParserStrings.PropertyIsReadOnly), innerException, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2).WriteToDebugLog(this));
}
PSProperty property = info3 as PSProperty;
if (property != null)
{
DotNetAdapter.PropertyCacheEntry adapterData = property.adapterData as DotNetAdapter.PropertyCacheEntry;
if (adapterData != null)
{
Expression expression10;
Type propertyType;
if (adapterData.member.DeclaringType.IsGenericTypeDefinition)
{
Expression expression9 = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }) });
return(new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), expression9, this.ReturnType, new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }), restrictions2).WriteToDebugLog(this));
}
PropertyInfo member = adapterData.member as PropertyInfo;
if (member != null)
{
propertyType = member.PropertyType;
Expression expression11 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
expression10 = Expression.Property(expression11, member);
}
else
{
FieldInfo field = (FieldInfo)adapterData.member;
propertyType = field.FieldType;
Expression expression12 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
expression10 = Expression.Field(expression12, field);
}
Type underlyingType = Nullable.GetUnderlyingType(propertyType);
Type type7 = underlyingType ?? propertyType;
ParameterExpression expression13 = Expression.Variable(type7);
Expression expression14 = (underlyingType != null) ? ((value.Value == null) ? ((Expression)Expression.Constant(null, propertyType)) : ((Expression)Expression.New(propertyType.GetConstructor(new Type[] { underlyingType }), new Expression[] { expression13 }))) : ((Expression)expression13);
Expression expression15 = (type7.Equals(typeof(object)) && value.LimitType.Equals(typeof(PSObject))) ? Expression.Call(CachedReflectionInfo.PSObject_Base, value.Expression.Cast(typeof(PSObject))) : value.CastOrConvert(type7);
Expression expr = Expression.Block(new ParameterExpression[] { expression13 }, new Expression[] { Expression.Assign(expression13, expression15), Expression.Assign(expression10, expression14), expression13.Cast(typeof(object)) });
ParameterExpression variable = Expression.Variable(typeof(Exception));
return(new DynamicMetaObject(Expression.TryCatch(expr.Cast(typeof(object)), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.ExceptionHandlingOps_ConvertToMethodInvocationException, variable, Expression.Constant(typeof(SetValueInvocationException)), Expression.Constant(base.Name), ExpressionCache.Constant(0), Expression.Constant(null, typeof(MemberInfo))), Expression.Rethrow(typeof(object)))) }), restrictions2).WriteToDebugLog(this));
}
}
PSCodeProperty property2 = info3 as PSCodeProperty;
if (property2 != null)
{
ParameterExpression expression17 = Expression.Variable(typeof(object));
return(new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression17 }, new Expression[] { Expression.Assign(expression17, value.CastOrConvert(expression17.Type)), PSInvokeMemberBinder.InvokeMethod(property2.SetterCodeReference, null, new DynamicMetaObject[] { target, value }, false), expression17 }), restrictions2).WriteToDebugLog(this));
}
PSScriptProperty property3 = info3 as PSScriptProperty;
if (property3 != null)
{
return(new DynamicMetaObject(Expression.Call(Expression.Constant(property3), CachedReflectionInfo.PSScriptProperty_InvokeSetter, PSGetMemberBinder.GetTargetExpr(target), value.Expression.Cast(typeof(object))), restrictions2).WriteToDebugLog(this));
}
}
if (errorSuggestion != null)
{
return(errorSuggestion.WriteToDebugLog(this));
}
}
return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.PSSetMemberBinder_SetAdaptedValue, PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object)), Expression.Constant(base.Name), value.Expression.Cast(typeof(object))), restrictions2).WriteToDebugLog(this));
}
public override DynamicMetaObject FallbackSetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
{
if (target.HasValue)
{
DynamicMetaObject[] dynamicMetaObjectArray = indexes;
if (!dynamicMetaObjectArray.Where <DynamicMetaObject>((DynamicMetaObject mo) => !mo.HasValue).Any <DynamicMetaObject>() && value.HasValue)
{
if (target.Value as PSObject == null || PSObject.Base(target.Value) == target.Value)
{
DynamicMetaObject[] dynamicMetaObjectArray1 = indexes;
if (!dynamicMetaObjectArray1.Where <DynamicMetaObject>((DynamicMetaObject mo) =>
{
if ((mo.Value as PSObject == null))
{
return(false);
}
else
{
return(PSObject.Base(mo.Value) != mo.Value);
}
}
).Any <DynamicMetaObject>())
{
if (target.Value != null)
{
if ((int)indexes.Length != 1 || indexes[0].Value != null)
{
if (!target.LimitType.IsArray)
{
DefaultMemberAttribute defaultMemberAttribute = target.LimitType.GetCustomAttributes <DefaultMemberAttribute>(true).FirstOrDefault <DefaultMemberAttribute>();
if (defaultMemberAttribute == null)
{
DynamicMetaObject dynamicMetaObject = errorSuggestion;
DynamicMetaObject debugLog = dynamicMetaObject;
if (dynamicMetaObject == null)
{
debugLog = this.CannotIndexTarget(target, indexes, value).WriteToDebugLog(this);
}
return(debugLog);
}
else
{
return(this.InvokeIndexer(target, indexes, value, errorSuggestion, defaultMemberAttribute.MemberName).WriteToDebugLog(this));
}
}
else
{
return(this.SetIndexArray(target, indexes, value, errorSuggestion).WriteToDebugLog(this));
}
}
else
{
DynamicMetaObject dynamicMetaObject1 = errorSuggestion;
DynamicMetaObject debugLog1 = dynamicMetaObject1;
if (dynamicMetaObject1 == null)
{
debugLog1 = target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NullArrayIndex", ParserStrings.NullArrayIndex, new Expression[0]).WriteToDebugLog(this);
}
return(debugLog1);
}
}
else
{
DynamicMetaObject dynamicMetaObject2 = errorSuggestion;
DynamicMetaObject dynamicMetaObject3 = dynamicMetaObject2;
if (dynamicMetaObject2 == null)
{
dynamicMetaObject3 = target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NullArray", ParserStrings.NullArray, new Expression[0]);
}
return(dynamicMetaObject3.WriteToDebugLog(this));
}
}
}
return(this.DeferForPSObject(indexes.Prepend <DynamicMetaObject>(target).Append <DynamicMetaObject>(value).ToArray <DynamicMetaObject>()).WriteToDebugLog(this));
}
}
return(base.Defer(indexes.Prepend <DynamicMetaObject>(target).Append <DynamicMetaObject>(value).ToArray <DynamicMetaObject>()).WriteToDebugLog(this));
}
private DynamicMetaObject SetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
{
Type elementType = target.LimitType.GetElementType();
Expression expression = PSGetIndexBinder.ConvertIndex(value, elementType);
if (expression != null)
{
if ((int)indexes.Length != 1)
{
Array arrays = (Array)target.Value;
if ((int)indexes.Length == arrays.Rank)
{
Expression[] expressionArray = new Expression[(int)indexes.Length];
int num = 0;
while (num < (int)indexes.Length)
{
expressionArray[num] = PSGetIndexBinder.ConvertIndex(indexes[num], typeof(int));
if (expressionArray[num] != null)
{
num++;
}
else
{
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
dynamicMetaObjectArray[0] = indexes[num];
return(PSConvertBinder.ThrowNoConversion(indexes[num], typeof(int), this, this._version, indexes.Except <DynamicMetaObject>(dynamicMetaObjectArray).Append <DynamicMetaObject>(target).Append <DynamicMetaObject>(value).ToArray <DynamicMetaObject>()));
}
}
return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), Expression.NewArrayInit(typeof(int), expressionArray), expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction())));
}
else
{
DynamicMetaObject dynamicMetaObject = errorSuggestion;
DynamicMetaObject dynamicMetaObject1 = dynamicMetaObject;
if (dynamicMetaObject == null)
{
DynamicMetaObject dynamicMetaObject2 = target;
DynamicMetaObject[] dynamicMetaObjectArray1 = indexes;
BindingRestrictions bindingRestriction = value.PSGetTypeRestriction();
string str = "NeedMultidimensionalIndex";
string needMultidimensionalIndex = ParserStrings.NeedMultidimensionalIndex;
Expression[] expressionArray1 = new Expression[2];
expressionArray1[0] = ExpressionCache.Constant(arrays.Rank);
Expression[] expressionArray2 = expressionArray1;
int num1 = 1;
MethodInfo arrayOpsIndexStringMessage = CachedReflectionInfo.ArrayOps_IndexStringMessage;
Type type = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray2 = indexes;
expressionArray2[num1] = Expression.Call(arrayOpsIndexStringMessage, Expression.NewArrayInit(type, dynamicMetaObjectArray2.Select <DynamicMetaObject, Expression>((DynamicMetaObject i) => i.Expression.Cast(typeof(object)))));
dynamicMetaObject1 = dynamicMetaObject2.ThrowRuntimeError(dynamicMetaObjectArray1, bindingRestriction, str, needMultidimensionalIndex, expressionArray1);
}
return(dynamicMetaObject1);
}
}
else
{
Expression expression1 = PSGetIndexBinder.ConvertIndex(indexes[0], typeof(int[]));
if (expression1 != null)
{
return(new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), expression1, expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction())));
}
else
{
DynamicMetaObject dynamicMetaObject3 = errorSuggestion;
DynamicMetaObject dynamicMetaObject4 = dynamicMetaObject3;
if (dynamicMetaObject3 == null)
{
DynamicMetaObject[] dynamicMetaObjectArray3 = new DynamicMetaObject[2];
dynamicMetaObjectArray3[0] = target;
dynamicMetaObjectArray3[1] = value;
dynamicMetaObject4 = PSConvertBinder.ThrowNoConversion(indexes[0], typeof(int[]), this, this._version, dynamicMetaObjectArray3);
}
return(dynamicMetaObject4);
}
}
}
else
{
DynamicMetaObject dynamicMetaObject5 = errorSuggestion;
DynamicMetaObject dynamicMetaObject6 = dynamicMetaObject5;
if (dynamicMetaObject5 == null)
{
dynamicMetaObject6 = PSConvertBinder.ThrowNoConversion(value, elementType, this, this._version, indexes.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>());
}
return(dynamicMetaObject6);
}
}
private DynamicMetaObject SetIndexArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
{
Array arrays = (Array)target.Value;
if (arrays.Rank <= 1)
{
if ((int)indexes.Length <= 1)
{
Expression expression = PSGetIndexBinder.ConvertIndex(indexes[0], typeof(int));
if (expression != null)
{
Type elementType = target.LimitType.GetElementType();
Expression expression1 = PSGetIndexBinder.ConvertIndex(value, elementType);
if (expression1 != null)
{
PSSetIndexBinder pSSetIndexBinder = this;
DynamicMetaObject dynamicMetaObject = new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction());
DynamicMetaObject dynamicMetaObject1 = new DynamicMetaObject(expression, indexes[0].PSGetTypeRestriction());
DynamicMetaObject dynamicMetaObject2 = new DynamicMetaObject(expression1, value.PSGetTypeRestriction());
PropertyInfo property = target.LimitType.GetProperty("Length");
return(pSSetIndexBinder.IndexWithNegativeChecks(dynamicMetaObject, dynamicMetaObject1, dynamicMetaObject2, property, (Expression t, Expression i, Expression v) =>
{
Expression[] expressionArray = new Expression[1];
expressionArray[0] = i;
return Expression.Assign(Expression.ArrayAccess(t, expressionArray), v);
}
));
}
else
{
DynamicMetaObject dynamicMetaObject3 = errorSuggestion;
DynamicMetaObject dynamicMetaObject4 = dynamicMetaObject3;
if (dynamicMetaObject3 == null)
{
dynamicMetaObject4 = PSConvertBinder.ThrowNoConversion(value, elementType, this, this._version, indexes.Prepend <DynamicMetaObject>(target).OfType <DynamicMetaObject>().ToArray <DynamicMetaObject>());
}
return(dynamicMetaObject4);
}
}
else
{
DynamicMetaObject dynamicMetaObject5 = errorSuggestion;
DynamicMetaObject dynamicMetaObject6 = dynamicMetaObject5;
if (dynamicMetaObject5 == null)
{
DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[2];
dynamicMetaObjectArray[0] = target;
dynamicMetaObjectArray[1] = value;
dynamicMetaObject6 = PSConvertBinder.ThrowNoConversion(indexes[0], typeof(int), this, this._version, dynamicMetaObjectArray);
}
return(dynamicMetaObject6);
}
}
else
{
DynamicMetaObject dynamicMetaObject7 = errorSuggestion;
DynamicMetaObject dynamicMetaObject8 = dynamicMetaObject7;
if (dynamicMetaObject7 == null)
{
DynamicMetaObject dynamicMetaObject9 = target;
DynamicMetaObject[] dynamicMetaObjectArray1 = indexes;
BindingRestrictions bindingRestriction = value.PSGetTypeRestriction();
string str = "ArraySliceAssignmentFailed";
string arraySliceAssignmentFailed = ParserStrings.ArraySliceAssignmentFailed;
Expression[] expressionArray1 = new Expression[1];
Expression[] expressionArray2 = expressionArray1;
int num = 0;
MethodInfo arrayOpsIndexStringMessage = CachedReflectionInfo.ArrayOps_IndexStringMessage;
Type type = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray2 = indexes;
expressionArray2[num] = Expression.Call(arrayOpsIndexStringMessage, Expression.NewArrayInit(type, dynamicMetaObjectArray2.Select <DynamicMetaObject, Expression>((DynamicMetaObject i) => i.Expression.Cast(typeof(object)))));
dynamicMetaObject8 = dynamicMetaObject9.ThrowRuntimeError(dynamicMetaObjectArray1, bindingRestriction, str, arraySliceAssignmentFailed, expressionArray1);
}
return(dynamicMetaObject8);
}
}
else
{
return(this.SetIndexMultiDimensionArray(target, indexes, value, errorSuggestion));
}
}
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
PSMemberInfo pSMemberInfo = null;
BindingRestrictions bindingRestriction = null;
bool flag = false;
Type type = null;
Expression expression;
Type value;
MethodInformation[] methodInformationArray;
Type type1;
if (target.HasValue)
{
DynamicMetaObject[] dynamicMetaObjectArray = args;
if (!dynamicMetaObjectArray.Where <DynamicMetaObject>((DynamicMetaObject arg) => !arg.HasValue).Any <DynamicMetaObject>())
{
object obj = PSObject.Base(target.Value);
if (obj != null)
{
if (!this._getMemberBinder.HasInstanceMember || !PSGetMemberBinder.TryGetInstanceMember(target.Value, base.Name, out pSMemberInfo))
{
PSMethodInfo pSMethodInfo = this._getMemberBinder.GetPSMemberInfo(target, out bindingRestriction, out flag, out type, null, null) as PSMethodInfo;
DynamicMetaObject[] dynamicMetaObjectArray1 = args;
BindingRestrictions bindingRestriction1 = bindingRestriction;
bindingRestriction = dynamicMetaObjectArray1.Aggregate <DynamicMetaObject, BindingRestrictions>(bindingRestriction1, (BindingRestrictions current, DynamicMetaObject arg) => current.Merge(arg.PSGetMethodArgumentRestriction()));
if (ExecutionContext.HasEverUsedConstrainedLanguage)
{
bindingRestriction = bindingRestriction.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
DynamicMetaObject dynamicMetaObject = PSGetMemberBinder.EnsureAllowedInLanguageMode(executionContextFromTLS.LanguageMode, target, obj, base.Name, this._static, args, bindingRestriction, "MethodInvocationNotSupportedInConstrainedLanguage", ParserStrings.InvokeMethodConstrainedLanguage);
if (dynamicMetaObject != null)
{
return(dynamicMetaObject.WriteToDebugLog(this));
}
}
if (flag)
{
PSObject pSObject = target.Value as PSObject;
if (pSObject != null && (obj.GetType().Equals(typeof(Hashtable)) || obj.GetType().Equals(typeof(ArrayList))))
{
if (!pSObject.isDeserialized)
{
bindingRestriction = bindingRestriction.Merge(BindingRestrictions.GetExpressionRestriction(Expression.Not(Expression.Field(target.Expression.Cast(typeof(PSObject)), CachedReflectionInfo.PSObject_isDeserialized))));
}
else
{
pSMethodInfo = null;
bindingRestriction = bindingRestriction.Merge(BindingRestrictions.GetExpressionRestriction(Expression.Field(target.Expression.Cast(typeof(PSObject)), CachedReflectionInfo.PSObject_isDeserialized)));
}
}
PSMethod pSMethod = pSMethodInfo as PSMethod;
if (pSMethod == null)
{
PSScriptMethod pSScriptMethod = pSMethodInfo as PSScriptMethod;
if (pSScriptMethod == null)
{
PSCodeMethod pSCodeMethod = pSMethodInfo as PSCodeMethod;
if (pSCodeMethod == null)
{
PSParameterizedProperty pSParameterizedProperty = pSMethodInfo as PSParameterizedProperty;
if (pSParameterizedProperty == null)
{
if (errorSuggestion == null)
{
if (this._static)
{
value = (Type)target.Value;
}
else
{
value = PSObject.Base(target.Value).GetType();
}
Type type2 = value;
if (!this._static && !this._nonEnumerating && target.Value != AutomationNull.Value)
{
DynamicMetaObject dynamicMetaObject1 = PSEnumerableBinder.IsEnumerable(target);
if (dynamicMetaObject1 != null)
{
return(this.InvokeMemberOnCollection(dynamicMetaObject1, args, type2, bindingRestriction));
}
}
Expression[] expressionArray = new Expression[2];
expressionArray[0] = Expression.Constant(type2.FullName);
expressionArray[1] = Expression.Constant(base.Name);
return(new DynamicMetaObject(Compiler.ThrowRuntimeError("MethodNotFound", ParserStrings.MethodNotFound, expressionArray), bindingRestriction).WriteToDebugLog(this));
}
else
{
return(errorSuggestion.WriteToDebugLog(this));
}
}
else
{
DotNetAdapter.ParameterizedPropertyCacheEntry parameterizedPropertyCacheEntry = (DotNetAdapter.ParameterizedPropertyCacheEntry)pSParameterizedProperty.adapterData;
PSInvokeMemberBinder pSInvokeMemberBinder = this;
DynamicMetaObject dynamicMetaObject2 = target;
DynamicMetaObject[] dynamicMetaObjectArray2 = args;
BindingRestrictions bindingRestriction2 = bindingRestriction;
if (this._propertySetter)
{
methodInformationArray = parameterizedPropertyCacheEntry.setterInformation;
}
else
{
methodInformationArray = parameterizedPropertyCacheEntry.getterInformation;
}
if (this._propertySetter)
{
type1 = typeof(SetValueInvocationException);
}
else
{
type1 = typeof(GetValueInvocationException);
}
return(pSInvokeMemberBinder.InvokeDotNetMethod(dynamicMetaObject2, dynamicMetaObjectArray2, bindingRestriction2, methodInformationArray, type1).WriteToDebugLog(this));
}
}
else
{
return(new DynamicMetaObject(PSInvokeMemberBinder.InvokeMethod(pSCodeMethod.CodeReference, null, args.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>(), false).Cast(typeof(object)), bindingRestriction).WriteToDebugLog(this));
}
}
else
{
MethodInfo pSScriptMethodInvokeScript = CachedReflectionInfo.PSScriptMethod_InvokeScript;
ConstantExpression constantExpression = Expression.Constant(base.Name);
ConstantExpression constantExpression1 = Expression.Constant(pSScriptMethod.Script);
Expression expression1 = target.Expression.Cast(typeof(object));
Type type3 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray3 = args;
return(new DynamicMetaObject(Expression.Call(pSScriptMethodInvokeScript, constantExpression, constantExpression1, expression1, Expression.NewArrayInit(type3, dynamicMetaObjectArray3.Select <DynamicMetaObject, Expression>((DynamicMetaObject e) => e.Expression.Cast(typeof(object))))), bindingRestriction).WriteToDebugLog(this));
}
}
else
{
DotNetAdapter.MethodCacheEntry methodCacheEntry = (DotNetAdapter.MethodCacheEntry)pSMethod.adapterData;
return(this.InvokeDotNetMethod(target, args, bindingRestriction, methodCacheEntry.methodInformationStructures, typeof(MethodException)).WriteToDebugLog(this));
}
}
else
{
if (!this._propertySetter)
{
MethodInfo pSInvokeMemberBinderInvokeAdaptedMember = CachedReflectionInfo.PSInvokeMemberBinder_InvokeAdaptedMember;
Expression expression2 = PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object));
ConstantExpression constantExpression2 = Expression.Constant(base.Name);
Type type4 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray4 = args;
expression = Expression.Call(pSInvokeMemberBinderInvokeAdaptedMember, expression2, constantExpression2, Expression.NewArrayInit(type4, dynamicMetaObjectArray4.Select <DynamicMetaObject, Expression>((DynamicMetaObject arg) => arg.Expression.Cast(typeof(object)))));
}
else
{
MethodInfo pSInvokeMemberBinderInvokeAdaptedSetMember = CachedReflectionInfo.PSInvokeMemberBinder_InvokeAdaptedSetMember;
Expression expression3 = PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object));
ConstantExpression constantExpression3 = Expression.Constant(base.Name);
Type type5 = typeof(object);
IEnumerable <DynamicMetaObject> dynamicMetaObjects = args.Take <DynamicMetaObject>((int)args.Length - 1);
expression = Expression.Call(pSInvokeMemberBinderInvokeAdaptedSetMember, expression3, constantExpression3, Expression.NewArrayInit(type5, dynamicMetaObjects.Select <DynamicMetaObject, Expression>((DynamicMetaObject arg) => arg.Expression.Cast(typeof(object)))), args.Last <DynamicMetaObject>().Expression.Cast(typeof(object)));
}
return(new DynamicMetaObject(expression, bindingRestriction).WriteToDebugLog(this));
}
}
else
{
ParameterExpression parameterExpression = Expression.Variable(typeof(PSMethodInfo));
MethodCallExpression methodCallExpression = Expression.Call(CachedReflectionInfo.PSInvokeMemberBinder_TryGetInstanceMethod, target.Expression.Cast(typeof(object)), Expression.Constant(base.Name), parameterExpression);
ParameterExpression parameterExpression1 = parameterExpression;
MethodInfo pSMethodInfoInvoke = CachedReflectionInfo.PSMethodInfo_Invoke;
Expression[] expressionArray1 = new Expression[1];
Expression[] expressionArray2 = expressionArray1;
int num = 0;
Type type6 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray5 = args;
expressionArray2[num] = Expression.NewArrayInit(type6, dynamicMetaObjectArray5.Select <DynamicMetaObject, Expression>((DynamicMetaObject dmo) => dmo.Expression.Cast(typeof(object))));
ConditionalExpression conditionalExpression = Expression.Condition(methodCallExpression, Expression.Call(parameterExpression1, pSMethodInfoInvoke, expressionArray1), base.GetUpdateExpression(typeof(object)));
ParameterExpression[] parameterExpressionArray = new ParameterExpression[1];
parameterExpressionArray[0] = parameterExpression;
Expression[] expressionArray3 = new Expression[1];
expressionArray3[0] = conditionalExpression;
return(new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray3), BinderUtils.GetVersionCheck(this._getMemberBinder, this._getMemberBinder._version)).WriteToDebugLog(this));
}
}
else
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "InvokeMethodOnNull", ParserStrings.InvokeMethodOnNull, new Expression[0]).WriteToDebugLog(this));
}
}
}
return(base.Defer(args.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()));
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
return(errorSuggestion ?? target.ThrowRuntimeError(args, BindingRestrictions.Empty, "CannotInvoke", ParserStrings.CannotInvoke, new Expression[0]));
}
public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
bool flag;
Type type = (Type)target.Value;
MethodInformation[] methodInformationArray = DotNetAdapter.GetMethodInformationArray(type.GetConstructors());
target = new DynamicMetaObject(target.Expression, BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value), target.Value);
string errorId = null;
string errorMsg = null;
int count = base.CallInfo.ArgumentCount - base.CallInfo.ArgumentNames.Count;
MethodInformation information = Adapter.FindBestMethod(methodInformationArray, null, (from arg in args.Take <DynamicMetaObject>(count) select arg.Value).ToArray <object>(), ref errorId, ref errorMsg, out flag);
if (information == null)
{
if (errorSuggestion == null)
{
}
return(new DynamicMetaObject(Expression.Throw(Expression.New(CachedReflectionInfo.MethodException_ctor, new Expression[] { Expression.Constant(errorId), Expression.Constant(null, typeof(Exception)), Expression.Constant(errorMsg), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(".ctor").Cast(typeof(object)), ExpressionCache.Constant(count).Cast(typeof(object)) }) }), this.ReturnType), target.CombineRestrictions(args)));
}
ConstructorInfo method = (ConstructorInfo)information.method;
ParameterInfo[] parameters = method.GetParameters();
Expression[] arguments = new Expression[parameters.Length];
int index = 0;
while (index < parameters.Length)
{
bool flag3;
Type parameterType = parameters[index].ParameterType;
if (parameters[index].GetCustomAttributes(typeof(ParamArrayAttribute), true).Any <object>() && flag)
{
Type elementType = parameters[index].ParameterType.GetElementType();
List <Expression> initializers = new List <Expression>();
int num3 = index;
int num4 = index;
while (num4 < count)
{
bool flag2;
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(args[index].Value, elementType, out flag2);
initializers.Add(PSConvertBinder.InvokeConverter(data, args[num4].Expression, elementType, flag2, ExpressionCache.InvariantCulture));
num4++;
index++;
}
arguments[num3] = Expression.NewArrayInit(elementType, initializers);
break;
}
LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(args[index].Value, parameterType, out flag3);
arguments[index] = PSConvertBinder.InvokeConverter(conversion, args[index].Expression, parameterType, flag3, ExpressionCache.InvariantCulture);
index++;
}
Expression right = Expression.New(method, arguments);
if (base.CallInfo.ArgumentNames.Any <string>())
{
ParameterExpression expr = Expression.Parameter(right.Type);
List <Expression> expressions = new List <Expression>();
foreach (string str3 in base.CallInfo.ArgumentNames)
{
Expression expression3;
Type propertyType;
bool flag4;
MemberInfo[] infoArray3 = type.GetMember(str3, MemberTypes.Property | MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if ((infoArray3.Length != 1) || (!(infoArray3[0] is PropertyInfo) && !(infoArray3[0] is FieldInfo)))
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, new Expression[] { Expression.Constant(str3), Expression.Constant(type) }));
}
MemberInfo info2 = infoArray3[0];
if (info2 is PropertyInfo)
{
PropertyInfo property = (PropertyInfo)info2;
if (property.GetSetMethod() == null)
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyIsReadOnly", ParserStrings.PropertyIsReadOnly, new Expression[] { Expression.Constant(str3) }));
}
propertyType = property.PropertyType;
expression3 = Expression.Property(expr.Cast(info2.DeclaringType), property);
}
else
{
propertyType = ((FieldInfo)info2).FieldType;
expression3 = Expression.Field(expr.Cast(info2.DeclaringType), (FieldInfo)info2);
}
LanguagePrimitives.ConversionData data3 = LanguagePrimitives.FigureConversion(args[index].Value, propertyType, out flag4);
if (data3.Rank == ConversionRank.None)
{
return(PSConvertBinder.ThrowNoConversion(args[index], propertyType, this, -1, args.Except <DynamicMetaObject>(new DynamicMetaObject[] { args[index] }).Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()));
}
expressions.Add(Expression.Assign(expression3, PSConvertBinder.InvokeConverter(data3, args[index].Expression, propertyType, flag4, ExpressionCache.InvariantCulture)));
index++;
}
ParameterExpression variable = Expression.Parameter(typeof(Exception));
BlockExpression expression5 = Expression.Block(Expression.Assign(expr, right), Expression.TryCatch(Expression.Block(typeof(void), expressions), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, variable), Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Property(variable, "Message"), variable, typeof(void), new Expression[0]))) }), expr);
right = Expression.Block(new ParameterExpression[] { expr }, new Expression[] { expression5 });
}
return(new DynamicMetaObject(right, target.CombineRestrictions(args)));
}
