public void Emit(OpCode opcode, RuntimeTypeHandle typeHandle) {
if (typeHandle.IsNullHandle())
throw new ArgumentNullException("typeHandle");
int tempVal = m_scope.GetTokenFor(typeHandle);
EnsureCapacity(7);
InternalEmit(opcode);
m_length=PutInteger4(tempVal, m_length, m_ILStream);
}
public void Emit(OpCode opcode, RuntimeMethodHandle meth, RuntimeTypeHandle typeContext) {
if (meth.IsNullHandle())
throw new ArgumentNullException("meth");
if (typeContext.IsNullHandle())
throw new ArgumentNullException("typeContext");
// need to sort out the stack size story
//int stackchange = 0;
int tempVal = m_scope.GetTokenFor(meth, typeContext);
EnsureCapacity(7);
InternalEmit(opcode);
// need to sort out the stack size story
/*
if (opcode.m_push == StackBehaviour.Varpush
&& meth.ReturnType != typeof(void)) { stackchange++; }
if (opcode.m_pop == StackBehaviour.Varpop) {
stackchange -= meth.GetParametersNoCopy().Length; }
if (!meth.IsStatic && !(opcode.Equals(OpCodes.Newobj))) {stackchange--; }
UpdateStackSize(opcode, stackchange);
*/
// need to sort out the stack size story
UpdateStackSize(opcode, 1);
m_length=PutInteger4(tempVal, m_length, m_ILStream);
}
public void Emit(OpCode opcode, RuntimeMethodHandle meth, RuntimeTypeHandle typeContext)
{
if (meth.IsNullHandle())
{
throw new ArgumentNullException("meth");
}
if (typeContext.IsNullHandle())
{
throw new ArgumentNullException("typeContext");
}
int tokenFor = this.m_scope.GetTokenFor(meth, typeContext);
base.EnsureCapacity(7);
base.InternalEmit(opcode);
base.UpdateStackSize(opcode, 1);
base.PutInteger4(tokenFor);
}
internal static unsafe RuntimeMethodInfo AssignAssociates(
int tkMethod,
RuntimeTypeHandle declaredTypeHandle,
RuntimeTypeHandle reflectedTypeHandle)
{
if (MetadataToken.IsNullToken(tkMethod))
return null;
ASSERT.PRECONDITION(!declaredTypeHandle.IsNullHandle());
ASSERT.PRECONDITION(!reflectedTypeHandle.IsNullHandle());
bool isInherited = !declaredTypeHandle.Equals(reflectedTypeHandle);
RuntimeMethodHandle associateMethodHandle = declaredTypeHandle.GetModuleHandle().ResolveMethodHandle(tkMethod, declaredTypeHandle.GetInstantiation(), new RuntimeTypeHandle[0]);
//RuntimeMethodHandle associateMethodHandle = declaredTypeHandle.GetMethodFromToken(tkMethod);
ASSERT.CONSISTENCY_CHECK(!associateMethodHandle.IsNullHandle(), "Failed to resolve associateRecord methodDef token");
MethodAttributes methAttr = associateMethodHandle.GetAttributes();
bool isPrivate =(methAttr & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
bool isVirtual =(methAttr & MethodAttributes.Virtual) != 0;
if (isInherited)
{
// ECMA MethodSemantics: "All methods for a given Property or Event shall have the same accessibility
//(ie the MemberAccessMask subfield of their Flags row) and cannot be CompilerControlled [CLS]"
// Consequently, a property may be composed of public and private methods. If the declared type !=
// the reflected type, the private methods should not be exposed. Note that this implies that the
// identity of a property includes it's reflected type.
if (isPrivate)
return null;
// Note this is the first time the property was encountered walking from the most derived class
// towards the base class. It would seem to follow that any associated methods would not
// be overriden -- but this is not necessarily true. A more derived class may have overriden a
// virtual method associated with a property in a base class without associating the override with
// the same or any property in the derived class.
if (isVirtual)
{
bool declaringTypeIsClass =
(declaredTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class;
ASSERT.CONSISTENCY_CHECK(LOGIC.BIJECTION(declaringTypeIsClass,
(reflectedTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class));
// It makes no sense to search for a virtual override of a method declared on an interface.
if (declaringTypeIsClass)
{
int slot = associateMethodHandle.GetSlot();
// Find the override visible from the reflected type
associateMethodHandle = reflectedTypeHandle.GetMethodAt(slot);
}
}
}
MethodAttributes visibility = methAttr & MethodAttributes.MemberAccessMask;
bool isPublic = visibility == MethodAttributes.Public;
bool isNonProtectedInternal = visibility == MethodAttributes.Assembly;
bool isStatic =(methAttr & MethodAttributes.Static) != 0;
RuntimeMethodInfo associateMethod =
RuntimeType.GetMethodBase(reflectedTypeHandle, associateMethodHandle) as RuntimeMethodInfo;
// suppose a property was mapped to a method not in the derivation hierarchy of the reflectedTypeHandle
if (associateMethod == null)
associateMethod = reflectedTypeHandle.GetRuntimeType().Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo;
return associateMethod;
}
public void Emit(OpCode opcode, RuntimeTypeHandle typeHandle)
{
if (typeHandle.IsNullHandle())
{
throw new ArgumentNullException("typeHandle");
}
int tokenFor = this.m_scope.GetTokenFor(typeHandle);
base.EnsureCapacity(7);
base.InternalEmit(opcode);
base.PutInteger4(tokenFor);
}
