internal static void SetMember(IDynamicMetaObjectProvider o, string name, object value)
 {
     CallSite<Action<CallSite, object, object>> site;
     if(!setSites.TryGetValue(name, out site)) {
         site = CallSite<Action<CallSite, object, object>>.Create(new DoHelpersSetMemberBinder(name));
         setSites.Add(name, site);
     }
     site.Target(site, o, value);
 }

 internal static void IDOIndexSet(IDynamicMetaObjectProvider Instance, object[] Arguments, string[] ArgumentNames)
 {
     SaveCopyBack back = new SaveCopyBack(null);
     using (back)
     {
         object[] packedArgs = null;
         CallInfo callInfo = null;
         IDOUtils.PackArguments(1, ArgumentNames, Arguments, ref packedArgs, ref callInfo);
         IDOUtils.CreateFuncCallSiteAndInvoke(new VBIndexSetBinder(callInfo), Instance, packedArgs);
     }
 }

 internal bool TryGetMember(IDynamicMetaObjectProvider dynamicProvider, string name, out object value)
 {
     ValidationUtils.ArgumentNotNull(dynamicProvider, "dynamicProvider");
     var callSite = _callSiteGetters.Get(name);
     var result = callSite.Target(callSite, dynamicProvider);
     if (!ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult))
     {
         value = result;
         return true;
     }
     value = null;
     return false;
 }

 // ExecuteFileInScope executes the file in the given module scope.  This
 // does NOT store the module scope on Globals.  This function returns
 // nothing.
 //
 public void ExecuteFileInScope(string filename,
                                IDynamicMetaObjectProvider moduleEO) {
     var f = new StreamReader(filename);
     // Simple way to convey script rundir for RuntimeHelpes.SymplImport
     // to load .sympl files.
     DynamicObjectHelpers.SetMember(moduleEO, "__file__", 
                                    Path.GetFullPath(filename));
     try {
         var moduleFun = ParseFileToLambda(filename, f);
         var d = moduleFun.Compile();
         d(this, moduleEO);
     } finally {
         f.Close();
     }
 }

 public ForwardingMetaObject(
     Expression expression,
     BindingRestrictions restrictions,
     object forwarder,
     IDynamicMetaObjectProvider forwardee,
     Func<Expression, Expression> forwardeeGetter
     )
     : base(expression, restrictions, forwarder)
 {
     // We'll use forwardee's meta-object to bind dynamic operations.
     metaForwardee = forwardee.GetMetaObject(
         forwardeeGetter(
             Expression.Convert(expression, forwarder.GetType())   // [1]
         )
     );
 }

 internal static object IDOGet(IDynamicMetaObjectProvider Instance, string MemberName, object[] Arguments, string[] ArgumentNames, bool[] CopyBack)
 {
     object obj2;
     SaveCopyBack back = new SaveCopyBack(CopyBack);
     using (back)
     {
         object[] packedArgs = null;
         CallInfo callInfo = null;
         IDOUtils.PackArguments(0, ArgumentNames, Arguments, ref packedArgs, ref callInfo);
         try
         {
             return IDOUtils.CreateRefCallSiteAndInvoke(new VBGetBinder(MemberName, callInfo), Instance, packedArgs);
         }
         finally
         {
             IDOUtils.CopyBackArguments(callInfo, packedArgs, Arguments);
         }
     }
     return obj2;
 }

 public ProtoTypalObjectWithMethods( IDynamicMetaObjectProvider prototype )
     : base(prototype)
 {
     StaticMethodWithNoReturnValueOrParametersWasCalled = false;
 }

 public TheDude( IDynamicMetaObjectProvider module )
     : base(module)
 {
 }

        private static PropertyReader[] GetDynamicProperties(IDynamicMetaObjectProvider provider)
        {
            var metaObject = provider.GetMetaObject(Expression.Constant(provider));

            var memberNames = metaObject.GetDynamicMemberNames(); // may return property names as well as method names, etc.

            var result = new List<PropertyReader>();

            foreach (var name in memberNames)
            {
                try
                {
                    var argumentInfo = new[] {CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)};

                    var binder = Binder.GetMember(CSharpBinderFlags.None, name, provider.GetType(), argumentInfo);

                    var site = CallSite<Func<CallSite, object, object>>.Create(binder);

                    var value = site.Target(site, provider); // will throw if no valid property getter

                    result.Add(new PropertyReader
                    {
                        Name = name,
                        DeclaringType = provider.GetType(),
                        Read = o => value
                    });
                }
                catch (RuntimeBinderException)
                {
                }
            }

            return result.ToArray();
        }

 /// <summary>
 /// Creates a new scope which is backed by an arbitrary object for it's storage.
 /// </summary>
 /// <param name="storage"></param>
 public Scope(IDynamicMetaObjectProvider storage)
 {
     _extensions = ScopeExtension.EmptyArray;
     _storage = storage;
 }

 public ScriptScope CreateScope(string languageId, IDynamicMetaObjectProvider storage) {
     return GetEngine(languageId).CreateScope(storage);
 }

        private static bool HasPropertyNaive(IDynamicMetaObjectProvider dynamicProvider, string name)
        {
            try
            {
                var callSite =
                                CallSite<Func<CallSite, object, object>>.Create(Binder.GetMember(CSharpBinderFlags.None, name, typeof(Program),
                                                         new[]
                                                                 {
                                                                     CSharpArgumentInfo.Create(
                                                                         CSharpArgumentInfoFlags.None, null)
                                                                 }));
                callSite.Target(callSite, dynamicProvider);
                return true;
            }
            catch (RuntimeBinderException)
            {

                return false;
            }
        }

 // Execute a single expression parsed from string in the provided module
 // scope and returns the resulting value.
 //
 public object ExecuteExpr(string expr_str,
                           IDynamicMetaObjectProvider moduleEO) {
     var moduleFun = ParseExprToLambda(new StringReader(expr_str));
     var d = moduleFun.Compile();
     return d(this, moduleEO);
 }

        private static TableItem CreateFromDynamicMetaObject( IDynamicMetaObjectProvider entity, bool throwOnReservedPropertyName )
        {
            var properties = new Dictionary<string, Tuple<object, Type>>();
             IEnumerable<string> memberNames = Dynamic.GetMemberNames( entity );
             foreach ( var memberName in memberNames )
             {
            dynamic result = Dynamic.InvokeGet( entity, memberName );
            properties[memberName] = new Tuple<object, Type>( (object) result, result.GetType() );
             }

             return new TableItem( properties, throwOnReservedPropertyName );
        }

        private void _OnStartExecute(IDynamicMetaObjectProvider executingScope, SourceUnit sourceUnit)
        {
            ContractUtils.Requires(executingScope is Scope);

            ExecutingScope = executingScope as Scope;
            ExecutingScopeStorage = ExecutingScope.Storage;

            //We should update the context under which this LuaTable is executing
            //so that it resolves metamethod overrides correctly.
            //TODO: Decide whether we should keep this if it is non-null, it may be that this is coming from a different
            //      CodeContext which has some metamethod stuff set particularly for this scope, or its contents, and we
            //      shouldn't change this.
            if (ExecutingScopeStorage is LuaTable)
                (ExecutingScopeStorage as LuaTable).Context = this;

            _LoadedPackages.Clear();
            _FunctionStacks.Clear();
            _EnvironmentMappings.Clear();   //We clear this here as opposed to in OnFinishExecute in case the last execution failed
        }

 public static PrototypalObject AsPrototypalObject( IDynamicMetaObjectProvider prototype )
 {
     if ( prototype == null )
     {
         return new PrototypalObject();
     }
     return prototype as PrototypalObject ?? new PrototypalObject( prototype );
 }

 private static void Iterate(
     ObjectEnumeratorBindingContext context,
     IDynamicMetaObjectProvider target,
     Action<TextWriter, object> template,
     Action<TextWriter, object> ifEmpty)
 {
     if (HandlebarsUtils.IsTruthy(target))
     {
         context.Index = 0;
         var meta = target.GetMetaObject(Expression.Constant(target));
         foreach (var name in meta.GetDynamicMemberNames())
         {
             context.Key = name;
             var value = GetProperty(target, name);
             context.First = (context.Index == 0);
             template(context.TextWriter, value);
             context.Index++;
         }
         if (context.Index == 0)
         {
             ifEmpty(context.TextWriter, context.Value);
         }
     }
     else
     {
         ifEmpty(context.TextWriter, context.Value);
     }
 }

	/// <summary>
	/// Serializes the dynamic.
	/// </summary>
	/// <param name="writer">The writer.</param>
	/// <param name="value">The value.</param>
	/// <param name="contract">The contract.</param>
	private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract)
	{
		contract.InvokeOnSerializing(value, Serializer.Context);
		SerializeStack.Add(value);

		writer.WriteStartObject();

		foreach (string memberName in value.GetDynamicMemberNames())
		{
		object memberValue;
		if (DynamicUtils.TryGetMember(value, memberName, out memberValue))
		{
			string resolvedPropertyName = (contract.PropertyNameResolver != null)
			? contract.PropertyNameResolver(memberName)
			: memberName;
			
			writer.WritePropertyName(resolvedPropertyName);
			SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null);
		}
		}

		writer.WriteEndObject();

		SerializeStack.RemoveAt(SerializeStack.Count - 1);
		contract.InvokeOnSerialized(value, Serializer.Context);
	}

 public DynamicWrapper(IDynamicMetaObjectProvider target)
 {
     this.target = target;
 }

        /// <summary>
        /// Gets the value of an IDynamicMetaObjectProvider
        /// implementation's named property.
        /// </summary>
        /// <param name="item">
        /// The IDynamicMetaObjectProvider implementation, from
        /// which to extract a named property's value.
        /// </param>
        /// <param name="propertyName">
        /// The name of the property.
        /// </param>
        /// <param name="usesCaseSensitivePropertyNameMatch">
        /// A value indicating whether the property name match should be
        /// case-sensitive.
        /// </param>
        /// <param name="exceptionThrownIfNoMatch">
        /// A value indicating whether an exception should be thrown if
        /// no matching property can be found.
        /// </param>
        /// <returns>
        /// The value of the property named by propertyName on item,
        /// or a null reference if exceptionThrownIfNoMatch is false and
        /// propertyName does not name a property on item.
        /// </returns>
        private static object GetNamedPropertyValue(
            IDynamicMetaObjectProvider item,
            string propertyName,
            bool usesCaseSensitivePropertyNameMatch,
            bool exceptionThrownIfNoMatch)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            if (string.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentException("propertyName is a null reference or empty string.", "propertyName");
            }

            if (!usesCaseSensitivePropertyNameMatch || exceptionThrownIfNoMatch)
            {
                StringComparison comparisonType = StringComparison.CurrentCultureIgnoreCase;
                if (usesCaseSensitivePropertyNameMatch)
                {
                    comparisonType = StringComparison.CurrentCulture;
                }

                propertyName = D.Dynamic.GetMemberNames(item, true).FirstOrDefault(
                        t => string.Equals(t, propertyName, comparisonType));

                if (string.IsNullOrEmpty(propertyName))
                {
                    if (exceptionThrownIfNoMatch)
                    {
                        throw new ArgumentException("propertyName does not name a property on item", "propertyName");
                    }

                    return null;
                }
            }

            try
            {
                return D.Dynamic.InvokeGet(item, propertyName);
            }
            catch (RuntimeBinderException)
            {
                return null;
            }
        }