Exemplo n.º 1
0
 public override DynamicMetaObject FallbackConvert(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
 {
     bool flag;
     if (!target.HasValue)
     {
         return base.Defer(target, new DynamicMetaObject[0]).WriteToDebugLog(this);
     }
     if (target.Value == AutomationNull.Value)
     {
         return new DynamicMetaObject(Expression.Default(base.Type), target.PSGetTypeRestriction()).WriteToDebugLog(this);
     }
     Type resultType = base.Type;
     LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(target.Value, resultType, out flag);
     if ((errorSuggestion != null) && (target.Value is DynamicObject))
     {
         return errorSuggestion.WriteToDebugLog(this);
     }
     BindingRestrictions restrictions = target.PSGetTypeRestriction().Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(this, resultType, this._version));
     return new DynamicMetaObject(InvokeConverter(conversion, target.Expression, resultType, flag, ExpressionCache.InvariantCulture), restrictions).WriteToDebugLog(this);
 }
Exemplo n.º 2
0
 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);
 }