protected override DynamicMetaObject SetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject instance, DynamicMetaObject errorSuggestion) {
     return new DynamicMetaObject(
         Expression.Condition(
             Ast.Call(
                 typeof(PythonOps).GetMethod("SlotTrySetValue"),
                 ((PythonOverloadResolverFactory)factory)._codeContext,
                 AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)),
                 AstUtils.Convert(
                     instance.Expression,
                     typeof(object)
                 ),
                 AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)),
                 value.Expression
             ),
             AstUtils.Convert(value.Expression, typeof(object)),
             errorSuggestion != null ?
                 errorSuggestion.Expression :
                 Expression.Throw(
                     Expression.Call(
                         typeof(PythonOps).GetMethod("AttributeErrorForMissingAttribute", new Type[] { typeof(object), typeof(string) }),
                         instance.Expression,
                         Expression.Constant(Name)
                     ),
                     typeof(object)
                 )
         ),
         BindingRestrictions.Empty
     );
 }

        public ParameterWrapper(ActionBinder binder, ParameterInfo info)
            : this(binder, info.ParameterType)
        {
            _name = SymbolTable.StringToId(info.Name ?? "<unknown>");

            _isParams = info.IsDefined(typeof(ParamArrayAttribute), false);
        }

        public ToyEngine(LanguageProvider provider, EngineOptions engineOptions) : base(provider, engineOptions) {
            IronPython.Runtime.Operations.Ops.Bool2Object(true); //awful initialization hack

            IronPython.Runtime.Operations.Ops.RegisterAssembly(typeof(ToyEngine).Assembly);

            _defaultContext = new ToyContext(this);
            _defaultBinder = new DefaultActionBinder(new CodeContext(null, _defaultContext));
        }

        /// <summary>
        /// Internal helper to produce the actual expression used for the error when emitting
        /// the error into a rule.
        /// </summary>
        public Statement MakeErrorForRule(StandardRule rule, ActionBinder binder) {
            if (_value != null) {
                rule.IsError = true;
                return rule.MakeReturn(binder, _value);
            }

            return rule.MakeError(_exception);
        } 

        public DefaultOverloadResolver(ActionBinder binder, IList<DynamicMetaObject> args, CallSignature signature, CallTypes callType)
            : base(binder) {
            ContractUtils.RequiresNotNullItems(args, "args");

            Debug.Assert((callType == CallTypes.ImplicitInstance ? 1 : 0) + signature.ArgumentCount == args.Count);
            _args = args;
            _signature = signature;
            _callType = callType;
        }

 public Expression GetBoundPythonValue(RuleBuilder builder, ActionBinder binder, PythonType accessing) {
     return Ast.Call(
         typeof(PythonOps).GetMethod("SlotGetValue"),
         builder.Context,
         Ast.Constant(GetSlot(), typeof(PythonTypeSlot)),
         Ast.Constant(null),
         Ast.Constant(accessing)
     );
 }

        public RubyParameterBinder(ActionBinder/*!*/ binder, Expression/*!*/ scopeOrContextExpression, bool isScope)
            : base(binder) {
            Assert.NotNull(binder, scopeOrContextExpression);

            if (isScope) {
                _scopeExpression = AstUtils.Convert(scopeOrContextExpression, typeof(RubyScope));
            } else {
                _contextExpression = AstUtils.Convert(scopeOrContextExpression, typeof(RubyContext));
            }
        }

 protected override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) {
     return Ast.Call(
         typeof(PythonOps).GetMethod("SlotGetValue"),
         context,
         Ast.Constant(GetSlot(), typeof(PythonTypeSlot)),
         AstUtils.Convert(
             instance,
             typeof(object)
         ),
         Ast.Constant(DynamicHelpers.GetPythonTypeFromType(type))
     );
 }

 public ParameterWrapper(ActionBinder binder, ParameterInfo info, Type type, SymbolId name, bool prohibitNull, bool isParams, bool isParamsDict) {
     ContractUtils.RequiresNotNull(binder, "binder");
     ContractUtils.RequiresNotNull(type, "type");
     
     _type = type;
     _prohibitNull = prohibitNull;
     _binder = binder;
     _info = info;
     _name = name;
     _isParams = isParams;
     _isParamsDict = isParamsDict;
 }

        public override ErrorInfo GetError(ActionBinder binder) {
            MethodInfo getter = ResolveGetter(binder.PrivateBinding);

            if (getter == null) {
                return binder.MakeMissingMemberErrorInfo(DeclaringType, Name);
            }

            if (getter.ContainsGenericParameters) {
                return binder.MakeGenericAccessError(this);
            }

            throw new InvalidOperationException();
        }

        public MethodBinderContext(ActionBinder actionBinder
#if FULL
, StandardRule rule 
#endif
)
        {
            _actionBinder = actionBinder;

#if FULL
 _rule = rule; 
#endif

        }

 protected override DynamicMetaObject GetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type type, DynamicMetaObject instance) {
     return new DynamicMetaObject(
         Ast.Call(
             typeof(PythonOps).GetMethod("SlotGetValue"),
             ((PythonOverloadResolverFactory)factory)._codeContext,
             AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)),
             AstUtils.Convert(
                 instance.Expression,
                 typeof(object)
             ),
             AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type))
         ),
         BindingRestrictions.Empty
     );
 }

        public ParameterWrapper(ActionBinder binder, ParameterInfo info)
            : this(binder, info.ParameterType) {
            _name = SymbolTable.StringToId(info.Name ?? "<unknown>");

#if FULL
            _prohibitNull = info.IsDefined(typeof(NotNullAttribute), false); 
#endif

            _isParams = info.IsDefined(typeof(ParamArrayAttribute), false);

#if FULL
            _isParamsDict = info.IsDefined(typeof(ParamDictionaryAttribute), false); 
#endif

            }

        internal static void Initialize(IronSchemeLanguageProvider ironSchemeLanguageProvider)
        {
            lp = ironSchemeLanguageProvider;
              se = lp.GetEngine() as IronSchemeScriptEngine;

              scriptmodule = ScriptDomainManager.CurrentManager.Host.DefaultModule as ScriptModule;

              ModuleContext mc = new ModuleContext(scriptmodule);

              mc.CompilerContext = new CompilerContext(SourceUnit.CreateSnippet(se, ""));

              cc = new CodeContext(scriptmodule.Scope, se.GetLanguageContext(), mc);

              binder = new IronScheme.Actions.IronSchemeActionBinder(cc);

              Generator.initme = true;
        }

 public static MSA.DynamicExpression/*!*/ MakeCallAction(string/*!*/ name, ActionBinder/*!*/ binder, RubyCallSignature signature, 
     params MSA.Expression[]/*!*/ args) {
     RubyCallAction call = RubyCallAction.Make(name, signature);
     switch (args.Length) {
         case 0: return Ast.Dynamic(call, typeof(object), AstFactory.EmptyExpressions);
         case 1: return Ast.Dynamic(call, typeof(object), args[0]);
         case 2: return Ast.Dynamic(call, typeof(object), args[0], args[1]);
         case 3: return Ast.Dynamic(call, typeof(object), args[0], args[1], args[2]);
         case 4: return Ast.Dynamic(call, typeof(object), args[0], args[1], args[2], args[3]);
         default:
             return Ast.Dynamic(
                 call,
                 typeof(object),
                 new ReadOnlyCollection<MSA.Expression>(args)
             );
     }
 }

        public override ErrorInfo GetBoundError(ActionBinder binder, DynamicMetaObject instance, Type instanceType)
        {
            MethodInfo getter = ResolveGetter(instanceType, binder.PrivateBinding);

            if (getter == null) {
                return binder.MakeMissingMemberErrorInfo(DeclaringType, Name);
            }

            if (getter.ContainsGenericParameters) {
                return binder.MakeGenericAccessError(this);
            }

            if (IsStatic) {
                return binder.MakeStaticPropertyInstanceAccessError(this, false, instance);
            }

            throw new InvalidOperationException();
        }

        public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type) {
            if (!IsStatic || GetIndexParameters().Length > 0) {
                // need to bind to a value or parameters to get the value.
                return binder.ReturnMemberTracker(type, this);
            }

            MethodInfo getter = ResolveGetter(binder.PrivateBinding);
            if (getter == null || getter.ContainsGenericParameters) {
                // no usable getter
                return null;
            }

            if (getter.IsPublic && getter.DeclaringType.IsPublic) {
                return binder.MakeCallExpression(resolverFactory, getter);
            }

            // private binding is just a call to the getter method...
            return MemberTracker.FromMemberInfo(getter).Call(resolverFactory, binder);
        }

        private MethodBinder(ActionBinder binder, string name, IList<MethodBase> methods, BinderType binderType, SymbolId[] kwArgs)
        {
            _binder = binder;
            _name = name;
            _binderType = binderType;
            _kwArgs = kwArgs;
            foreach (MethodBase method in methods) {
                if (IsUnsupported(method)) continue;

                AddBasicMethodTargets(method);
            }

            if (_paramsCandidates != null) {
                foreach (MethodCandidate maker in _paramsCandidates) {
                    foreach (int count in _targetSets.Keys) {
                        MethodCandidate target = maker.MakeParamsExtended(binder, count, _kwArgs);
                        if (target != null) AddTarget(target);
                    }
                }
            }
        }

 protected internal override Expression GetBoundValue(Expression context, ActionBinder binder, Type type, Expression instance) {
     return binder.ReturnMemberTracker(type, BindToInstance(instance));
 }

 public override DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value) {
     return SetBoundValue(resolverFactory, binder, type, value, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty));
 }