private void AddOverrider(MethodInfo method, Reference invocationHandler)
        {
            var overrider = _emitter.CreateMethod(method.Name, MethodAttributes.Public | MethodAttributes.Virtual, method);

            overrider.AddCustomAttribute(new CustomAttributeBuilder(s_attributeConstructor, new object[0]));

            Reference      targetReference       = GetTargetReference();
            Expression     overriddenMethodToken = new MethodTokenExpression(method);
            LocalReference argsLocal             = CopyArgumentsToLocalVariable(overrider);
            Expression     baseMethodInvoker     = GetBaseInvokerExpression(method);

            TypeReference handlerReference = new TypeReferenceWrapper(invocationHandler, typeof(MethodInvocationHandler));

            Expression[] handlerArgs = new Expression[] { targetReference.ToExpression(), overriddenMethodToken, argsLocal.ToExpression(), baseMethodInvoker };

            Expression handlerInvocation = new VirtualMethodInvocationExpression(handlerReference, s_handlerInvokeMethod, handlerArgs);

            if (method.ReturnType != typeof(void))
            {
                overrider.ImplementByReturning(new ConvertExpression(method.ReturnType, typeof(object), handlerInvocation));
            }
            else
            {
                overrider.AddStatement(new ExpressionStatement(handlerInvocation));
                overrider.AddStatement(new PopStatement());
                overrider.ImplementByReturningVoid();
            }
        }
        public void TypeAndOwner()
        {
            Reference ownerReference   = _mockRepository.StrictMock <Reference>();
            Reference wrappedReference = _mockRepository.StrictMock <Reference> (ownerReference);

            TypeReferenceWrapper tr = new TypeReferenceWrapper(wrappedReference, typeof(int));

            Assert.That(tr.Type, Is.EqualTo(typeof(int)));
            Assert.That(tr.OwnerReference, Is.SameAs(ownerReference));
        }
        public void LoadAddressReference()
        {
            Reference   wrappedReference = _mockRepository.StrictMock <Reference> ();
            ILGenerator gen = new DynamicMethod("Foo", typeof(void), Type.EmptyTypes, AssemblyBuilder.GetExecutingAssembly().ManifestModule).GetILGenerator();

            // expect
            wrappedReference.LoadAddressOfReference(gen);

            _mockRepository.ReplayAll();

            TypeReferenceWrapper tr = new TypeReferenceWrapper(wrappedReference, typeof(int));

            tr.LoadAddressOfReference(gen);

            _mockRepository.VerifyAll();
        }