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); }
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 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)); }
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 FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) { return (errorSuggestion ?? target.ThrowRuntimeError(args, BindingRestrictions.Empty, "CannotInvoke", ParserStrings.CannotInvoke, new Expression[0])); }
private DynamicMetaObject BinaryAdd(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion) { Expression expression; if (target.Value != null) { if (target.LimitType.IsNumericOrPrimitive() && !target.LimitType.Equals(typeof(char))) { DynamicMetaObject argAsNumericOrPrimitive = PSBinaryOperationBinder.GetArgAsNumericOrPrimitive(arg, target.LimitType); if (argAsNumericOrPrimitive == null) { if (arg.LimitType.Equals(typeof(string))) { return this.BinaryNumericStringOp(target, arg); } } else { return this.BinaryNumericOp("Add", target, argAsNumericOrPrimitive); } } Expression expression1 = null; if (target.LimitType != typeof(string)) { if (target.LimitType == typeof(char)) { Expression[] expressionArray = new Expression[2]; expressionArray[0] = target.Expression.Cast(typeof(char)); expressionArray[1] = ExpressionCache.Constant(1); expression1 = Expression.New(CachedReflectionInfo.String_ctor_char_int, expressionArray); } } else { expression1 = target.Expression.Cast(typeof(string)); } if (expression1 == null) { DynamicMetaObject dynamicMetaObject = PSEnumerableBinder.IsEnumerable(target); if (dynamicMetaObject == null) { if (target.Value as IDictionary == null) { return PSBinaryOperationBinder.CallImplicitOp("op_Addition", target, arg, "+", errorSuggestion); } else { if (arg.Value as IDictionary == null) { DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1]; dynamicMetaObjectArray[0] = arg; return target.ThrowRuntimeError(dynamicMetaObjectArray, BindingRestrictions.Empty, "AddHashTableToNonHashTable", ParserStrings.AddHashTableToNonHashTable, new Expression[0]); } else { DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1]; dynamicMetaObjectArray1[0] = arg; return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.HashtableOps_Add, target.Expression.Cast(typeof(IDictionary)), arg.Expression.Cast(typeof(IDictionary))), target.CombineRestrictions(dynamicMetaObjectArray1)); } } } else { DynamicMetaObject dynamicMetaObject1 = PSEnumerableBinder.IsEnumerable(arg); if (dynamicMetaObject1 == null) { expression = Expression.Call(CachedReflectionInfo.EnumerableOps_AddObject, ExpressionCache.GetExecutionContextFromTLS, dynamicMetaObject.Expression.Cast(typeof(IEnumerator)), arg.Expression.Cast(typeof(object))); } else { expression = Expression.Call(CachedReflectionInfo.EnumerableOps_AddEnumerable, ExpressionCache.GetExecutionContextFromTLS, dynamicMetaObject.Expression.Cast(typeof(IEnumerator)), dynamicMetaObject1.Expression.Cast(typeof(IEnumerator))); } DynamicMetaObject[] dynamicMetaObjectArray2 = new DynamicMetaObject[1]; dynamicMetaObjectArray2[0] = arg; return new DynamicMetaObject(expression, target.CombineRestrictions(dynamicMetaObjectArray2)); } } else { DynamicMetaObject[] dynamicMetaObjectArray3 = new DynamicMetaObject[1]; dynamicMetaObjectArray3[0] = arg; return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.String_Concat_String, expression1, PSToStringBinder.InvokeToString(ExpressionCache.GetExecutionContextFromTLS, arg.Expression)), target.CombineRestrictions(dynamicMetaObjectArray3)); } } else { DynamicMetaObject[] dynamicMetaObjectArray4 = new DynamicMetaObject[1]; dynamicMetaObjectArray4[0] = arg; return new DynamicMetaObject(arg.Expression.Cast(typeof(object)), target.CombineRestrictions(dynamicMetaObjectArray4)); } }
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)); }
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 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); }