/// <summary>
/// Emit generic method instantiation to the output string builder.
/// </summary>
/// <param name="methodInstHandle">Method instantiation handle</param>
private void EmitMethodInstantiationName(MethodInstantiationHandle methodInstHandle)
{
MethodInstantiation methodInst = _metadataReader.GetMethodInstantiation(methodInstHandle);
MethodSignature methodSignature;
if (methodInst.Method.HandleType == HandleType.MemberReference)
{
MemberReferenceHandle methodRefHandle = methodInst.Method.ToMemberReferenceHandle(_metadataReader);
MemberReference methodRef = methodRefHandle.GetMemberReference(_metadataReader);
EmitContainingTypeAndMethodName(methodRef, out methodSignature);
}
else
{
QualifiedMethodHandle qualifiedMethodHandle = methodInst.Method.ToQualifiedMethodHandle(_metadataReader);
QualifiedMethod qualifiedMethod = _metadataReader.GetQualifiedMethod(qualifiedMethodHandle);
EmitContainingTypeAndMethodName(qualifiedMethod, out methodSignature);
}
EmitGenericArguments(methodInst.GenericTypeArguments);
EmitMethodParameters(methodSignature);
}
public MemberReferenceMethod(GenericContext gc, MemberReferenceHandle handle) : base(gc)
{
this.gc = gc;
mr = cx.mdReader.GetMemberReference(handle);
signature = mr.DecodeMethodSignature(new SignatureDecoder(), gc);
parent = (GenericContext)cx.CreateGeneric(gc, mr.Parent);
var parentMethod = parent as Method;
var nameLabel = cx.GetId(mr.Name);
declType = parentMethod == null ? parent as Type : parentMethod.DeclaringType;
ShortId = MakeMethodId(declType, nameLabel);
var typeSourceDeclaration = declType.SourceDeclaration;
sourceDeclaration = typeSourceDeclaration == declType ? (Method)this : typeSourceDeclaration.LookupMethod(mr.Name, mr.Signature);
}
private uint CalculateMemberRefTreatmentAndRowId(MemberReferenceHandle handle)
{
MemberRefTreatment treatment;
// We need to rename the MemberRef for IClosable.Close as well
// so that the MethodImpl for the Dispose method can be correctly shown
// as IDisposable.Dispose instead of IDisposable.Close
bool isIDisposable;
if (ImplementsRedirectedInterface(handle, out isIDisposable) && isIDisposable)
{
treatment = MemberRefTreatment.Dispose;
}
else
{
treatment = MemberRefTreatment.None;
}
return(TreatmentAndRowId((byte)treatment, handle.RowId));
}
/// <summary>
/// We want to know if a given method implements a redirected interface.
/// For example, if we are given the method RemoveAt on a class "A"
/// which implements the IVector interface (which is redirected
/// to IList in .NET) then this method would return true. The most
/// likely reason why we would want to know this is that we wish to hide
/// (mark private) all methods which implement methods on a redirected
/// interface.
/// </summary>
/// <param name="memberRef">The declaration token for the method</param>
/// <param name="isIDisposable">
/// Returns true if the redirected interface is <see cref="IDisposable"/>.
/// </param>
/// <returns>True if the method implements a method on a redirected interface.
/// False otherwise.</returns>
private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable)
{
isIDisposable = false;
EntityHandle parent = MemberRefTable.GetClass(memberRef);
TypeReferenceHandle typeRef;
if (parent.Kind == HandleKind.TypeReference)
{
typeRef = (TypeReferenceHandle)parent;
}
else if (parent.Kind == HandleKind.TypeSpecification)
{
BlobHandle blob = TypeSpecTable.GetSignature((TypeSpecificationHandle)parent);
BlobReader sig = new BlobReader(BlobStream.GetMemoryBlock(blob));
if (sig.Length < 2 ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS)
{
return(false);
}
EntityHandle token = sig.ReadTypeHandle();
if (token.Kind != HandleKind.TypeReference)
{
return(false);
}
typeRef = (TypeReferenceHandle)token;
}
else
{
return(false);
}
return(GetProjectionIndexForTypeReference(typeRef, out isIDisposable) >= 0);
}
internal Symbol FindMember(MemberReferenceHandle memberRef, bool methodsOnly)
{
try
{
string memberName = Module.GetMemberRefNameOrThrow(memberRef);
BlobHandle signatureHandle = Module.GetSignatureOrThrow(memberRef);
SignatureHeader signatureHeader;
BlobReader signaturePointer = this.DecodeSignatureHeaderOrThrow(signatureHandle, out signatureHeader);
switch (signatureHeader.RawValue & SignatureHeader.CallingConventionOrKindMask)
{
case (byte)SignatureCallingConvention.Default:
case (byte)SignatureCallingConvention.VarArgs:
int typeParamCount;
ParamInfo <TypeSymbol>[] targetParamInfo = this.DecodeSignatureParametersOrThrow(ref signaturePointer, signatureHeader, out typeParamCount);
return(FindMethodBySignature(_containingType, memberName, signatureHeader, typeParamCount, targetParamInfo));
case (byte)SignatureKind.Field:
if (methodsOnly)
{
// skip:
return(null);
}
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers;
TypeSymbol type = this.DecodeFieldSignature(ref signaturePointer, out customModifiers);
return(FindFieldBySignature(_containingType, memberName, customModifiers, type));
default:
// error: unexpected calling convention
return(null);
}
}
catch (BadImageFormatException)
{
return(null);
}
}
internal MemberReferenceHandle CreateConstructorForReferencedType(Type type)
{
var ctors = type.GetConstructors();
var typeHandle = GetOrCreateType(type);
if (ctors.Length == 0)
{
return(default(MemberReferenceHandle));
}
var handles = new MemberReferenceHandle[ctors.Length];
for (var i = 0; i < ctors.Length; i++)
{
var ctor = ctors[i];
if (_ctorRefHandles.TryGetValue(ctor, out var ctorDef))
{
handles[i] = ctorDef;
continue;
}
var signature = GetConstructorSignature(ctor);
ctorDef = _metadataBuilder.AddMemberReference(
typeHandle, GetString(ctor.Name), signature);
// HACK: [vermorel] recursive insertions can happen
//if(!_ctorRefHandles.ContainsKey(ctor))
_ctorRefHandles.Add(ctor, ctorDef);
handles[i] = ctorDef;
CreateCustomAttributes(ctorDef, ctor.GetCustomAttributesData());
}
return(handles.First());
}
internal override Symbol GetSymbolForMemberRef(MemberReferenceHandle memberRef, TypeSymbol scope = null, bool methodsOnly = false)
{
TypeSymbol targetTypeSymbol = GetMemberRefTypeSymbol(memberRef);
if (targetTypeSymbol is null)
{
return(null);
}
Debug.Assert(!targetTypeSymbol.IsTupleType);
if ((object)scope != null)
{
Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType);
// We only want to consider members that are at or above "scope" in the type hierarchy.
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (!TypeSymbol.Equals(scope, targetTypeSymbol, TypeCompareKind.ConsiderEverything2) &&
!(targetTypeSymbol.IsInterfaceType()
? scope.AllInterfacesNoUseSiteDiagnostics.IndexOf((NamedTypeSymbol)targetTypeSymbol, 0, TypeSymbol.EqualsCLRSignatureComparer) != -1
: scope.IsDerivedFrom(targetTypeSymbol, TypeCompareKind.CLRSignatureCompareOptions, useSiteDiagnostics: ref useSiteDiagnostics)))
{
return(null);
}
}
if (!targetTypeSymbol.IsTupleCompatible())
{
targetTypeSymbol = TupleTypeDecoder.DecodeTupleTypesIfApplicable(targetTypeSymbol, elementNames: default);
}
// We're going to use a special decoder that can generate usable symbols for type parameters without full context.
// (We're not just using a different type - we're also changing the type context.)
var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol);
return(memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly));
}
IField ResolveFieldReference(MemberReferenceHandle memberReferenceHandle, GenericContext context)
{
var memberRef = metadata.GetMemberReference(memberReferenceHandle);
var declaringType = ResolveDeclaringType(memberRef.Parent, context);
var declaringTypeDefinition = declaringType.GetDefinition();
string name = metadata.GetString(memberRef.Name);
// field signature is for the definition, not the generic instance
var signature = memberRef.DecodeFieldSignature(TypeProvider,
new GenericContext(declaringTypeDefinition?.TypeParameters));
// 'f' in the predicate is also the definition, even if declaringType is a ParameterizedType
var field = declaringType.GetFields(f => f.Name == name && CompareTypes(f.ReturnType, signature),
GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
if (field == null)
{
field = new FakeField(Compilation)
{
ReturnType = signature,
Name = name,
DeclaringType = declaringType,
};
}
return(field);
}
internal override Symbol GetSymbolForMemberRef(MemberReferenceHandle memberRef, TypeSymbol scope = null, bool methodsOnly = false)
{
TypeSymbol targetTypeSymbol = GetMemberRefTypeSymbol(memberRef);
// TODO: ASD: MY ADDON
if (targetTypeSymbol == null)
{
Handle container = Module.GetContainingTypeOrThrow(memberRef);
HandleType containerType = container.HandleType;
if (containerType == HandleType.Method)
{
return(GetSymbolForILToken(container));
}
}
if ((object)scope != null)
{
Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType);
// We only want to consider members that are at or above "scope" in the type hierarchy.
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (scope != targetTypeSymbol &&
!(targetTypeSymbol.IsInterfaceType()
? scope.AllInterfacesNoUseSiteDiagnostics.Contains((NamedTypeSymbol)targetTypeSymbol)
: scope.IsDerivedFrom(targetTypeSymbol, ignoreDynamic: false, useSiteDiagnostics: ref useSiteDiagnostics)))
{
return(null);
}
}
// We're going to use a special decoder that can generate useable symbols for type parameters without full context.
// (We're not just using a different type - we're also changing the type context.)
var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol);
return(memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly));
}
/// <summary>
/// We want to know if a given method implements a redirected interface.
/// For example, if we are given the method RemoveAt on a class "A"
/// which implements the IVector interface (which is redirected
/// to IList in .NET) then this method would return true. The most
/// likely reason why we would want to know this is that we wish to hide
/// (mark private) all methods which implement methods on a redirected
/// interface.
/// </summary>
/// <param name="memberRef">The declaration token for the method</param>
/// <param name="isIDisposable">
/// Returns true if the redirected interface is <see cref="IDisposable"/>.
/// </param>
/// <returns>True if the method implements a method on a redirected interface.
/// False otherwise.</returns>
private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable)
{
isIDisposable = false;
EntityHandle parent = MemberRefTable.GetClass(memberRef);
TypeReferenceHandle typeRef;
if (parent.Kind == HandleKind.TypeReference)
{
typeRef = (TypeReferenceHandle)parent;
}
else if (parent.Kind == HandleKind.TypeSpecification)
{
BlobHandle blob = TypeSpecTable.GetSignature((TypeSpecificationHandle)parent);
BlobReader sig = BlobStream.GetBlobReader(blob);
if (sig.Length < 2 ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS)
{
return false;
}
EntityHandle token = sig.ReadTypeHandle();
if (token.Kind != HandleKind.TypeReference)
{
return false;
}
typeRef = (TypeReferenceHandle)token;
}
else
{
return false;
}
return GetProjectionIndexForTypeReference(typeRef, out isIDisposable) >= 0;
}
internal EntityHandle GetClass(MemberReferenceHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return MemberRefParentTag.ConvertToHandle(this.Block.PeekTaggedReference(rowOffset + _ClassOffset, _IsMemberRefParentRefSizeSmall));
}
internal BlobHandle GetSignature(MemberReferenceHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return BlobHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _SignatureOffset, _IsBlobHeapRefSizeSmall));
}
public Mapping<MemberReferenceHandle> MapMemberReference(MemberReferenceHandle handle)
{
return _memberReferences.GetOrAdd(handle, MapMemberReferenceImpl);
}
private Mapping <MemberReferenceHandle> MapMemberReferenceImpl(MemberReferenceHandle handle)
{
throw new NotImplementedException();
}
MethodDesc IR2RSignatureTypeProvider <TypeDesc, MethodDesc, R2RSigProviderContext> .GetMethodFromMemberRef(MetadataReader reader, MemberReferenceHandle handle, TypeDesc owningTypeOverride)
{
var ecmaModule = (EcmaModule)_tsc.GetModuleForSimpleName(reader.GetString(reader.GetAssemblyDefinition().Name));
var method = (MethodDesc)ecmaModule.GetObject(handle, NotFoundBehavior.ReturnNull);
if (method == null)
{
return(null);
}
if (owningTypeOverride != null)
{
return(_tsc.GetMethodForInstantiatedType(method.GetTypicalMethodDefinition(), (InstantiatedType)owningTypeOverride));
}
return(method);
}
public void MethodImplEntry()
{
var text =
@"
public class A
{
~A() { }
}
";
CompileAndVerify(
text,
assemblyValidator: (assembly) =>
{
var peFileReader = assembly.GetMetadataReader();
// Find the handle and row for A.
var pairA = peFileReader.TypeDefinitions
.AsEnumerable()
.Select(
handle =>
new
{
handle = handle,
row = peFileReader.GetTypeDefinition(handle)
}
)
.Single(
pair =>
peFileReader.GetString(pair.row.Name) == "A" &&
string.IsNullOrEmpty(peFileReader.GetString(pair.row.Namespace))
);
TypeDefinitionHandle handleA = pairA.handle;
TypeDefinition typeA = pairA.row;
// Find the handle for A's destructor.
MethodDefinitionHandle handleDestructorA = typeA
.GetMethods()
.AsEnumerable()
.Single(
handle =>
peFileReader.GetString(
peFileReader.GetMethodDefinition(handle).Name
) == WellKnownMemberNames.DestructorName
);
// Find the handle for System.Object.
TypeReferenceHandle handleObject =
peFileReader.TypeReferences
.AsEnumerable()
.Select(
handle =>
new
{
handle = handle,
row = peFileReader.GetTypeReference(handle)
}
)
.Single(
pair =>
peFileReader.GetString(pair.row.Name) == "Object" &&
peFileReader.GetString(pair.row.Namespace) == "System"
).handle;
// Find the handle for System.Object's destructor.
MemberReferenceHandle handleDestructorObject =
peFileReader.MemberReferences
.AsEnumerable()
.Select(
handle =>
new
{
handle = handle,
row = peFileReader.GetMemberReference(handle)
}
)
.Single(
pair =>
pair.row.Parent == (EntityHandle)handleObject &&
peFileReader.GetString(pair.row.Name)
== WellKnownMemberNames.DestructorName
).handle;
// Find the MethodImpl row for A.
MethodImplementation methodImpl = typeA
.GetMethodImplementations()
.AsEnumerable()
.Select(handle => peFileReader.GetMethodImplementation(handle))
.Single();
// The Class column should point to A.
Assert.Equal(handleA, methodImpl.Type);
// The MethodDeclaration column should point to System.Object.Finalize.
Assert.Equal(
(EntityHandle)handleDestructorObject,
methodImpl.MethodDeclaration
);
// The MethodDeclarationColumn should point to A's destructor.
Assert.Equal((EntityHandle)handleDestructorA, methodImpl.MethodBody);
}
);
}
/// <summary>
/// We want to know if a given method implements a redirected interface.
/// For example, if we are given the method RemoveAt on a class "A"
/// which implements the IVector interface (which is redirected
/// to IList in .NET) then this method would return true. The most
/// likely reason why we would want to know this is that we wish to hide
/// (mark private) all methods which implement methods on a redirected
/// interface.
/// </summary>
/// <param name="memberRef">The declaration token for the method</param>
/// <param name="isIDisposable">
/// Returns true if the redirected interface is <see cref="IDisposable"/>.
/// </param>
/// <returns>True if the method implements a method on a redirected interface.
/// False otherwise.</returns>
private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable)
{
isIDisposable = false;
MetadataToken parent = peFileReader.GetMemberReference((MemberReferenceHandle)memberRef).Parent;
TypeReferenceHandle typeRef;
if (parent.HandleType == HandleType.TypeReference)
{
typeRef = (TypeReferenceHandle)parent;
}
else if (parent.HandleType == HandleType.TypeSpecification)
{
BlobHandle blob = peFileReader.GetTypeSpecification((TypeSpecificationHandle)parent);
MemoryBlock sigBlock = peFileReader.BlobStream.GetMemoryBlockAt(blob);
if (sigBlock.Length < 2)
return false;
MemoryReader sig = new MemoryReader(sigBlock);
if (sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS)
{
return false;
}
MetadataToken token = SignatureHelpers.DecodeToken(ref sig);
if (token.HandleType != HandleType.TypeReference)
return false;
typeRef = (TypeReferenceHandle)token;
}
else
{
return false;
}
TypeReference reference = peFileReader.GetTypeReference(typeRef);
if (reference.Namespace.IsNil)
{
return false;
}
string name = peFileReader.StringStream[reference.Name];
string @namespace = peFileReader.StringStream[reference.Namespace];
return WinRTProjectedTypes.IsWinRTTypeReference(name, @namespace, out isIDisposable);
}
public override string GetMemberRefName(MemberReferenceHandle memberRef)
{
string name;
// We need to rename the MemberRef for IClosable.Close as well
// so that the MethodImpl for the Dispose method can be correctly shown
// as IDisposable.Dispose instead of IDisposable.Close
bool isIDisposable;
if (ImplementsRedirectedInterface(memberRef, out isIDisposable) && isIDisposable)
{
name = "Dispose";
}
else
{
name = base.GetMemberRefName(memberRef);
}
return name;
}
internal Handle GetClass(MemberReferenceHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return MemberRefParentTag.ConvertToToken(this.Block.PeekTaggedReference(rowOffset + this.ClassOffset, this.IsMemberRefParentRefSizeSmall));
}
private Mapping<MemberReferenceHandle> MapMemberReferenceImpl(MemberReferenceHandle handle)
{
throw new NotImplementedException();
}
private MemberReferenceHandle Import(MemberReferenceHandle srcHandle) =>
ImportEntity(srcHandle, _memberReferenceCache, _reader.GetMemberReference,
src => _builder.AddMemberReference(Import(src.Parent), ImportValue(src.Name),
ImportSignatureWithHeader(src.Signature)),
_reader.ToString, IsNil);
public Mapping <MemberReferenceHandle> MapMemberReference(MemberReferenceHandle handle)
{
return(_memberReferences.GetOrAdd(handle, MapMemberReferenceImpl));
}
public static string ToString(this MetadataReader reader, MemberReferenceHandle x) => reader.ToString(reader.GetMemberReference(x));
private NetType GetTypeFromMemberReferenceHandle(MemberReferenceHandle handle)
{
var memberReference = Reader.GetMemberReference(handle);
return(GetTypeFromEntityHandle((TypeReferenceHandle)memberReference.Parent));
}
/// <summary>
/// Encodes <code>call</code> instruction and its operand.
/// </summary>
public void Call(MemberReferenceHandle methodHandle)
{
OpCode(ILOpCode.Call);
Token(methodHandle);
}
private static MethodDefinitionHandle EmitMethod(string assemblyName,
MetadataBuilder metadata,
BlobBuilder ilBuilder,
string name,
Func <MetadataBuilder, BlobBuilder> signatureCallback,
string[] paramNames)
{
BlobBuilder methodSignature = signatureCallback(metadata);
// Create module and assembly
metadata.AddModule(
0,
metadata.GetOrAddString(assemblyName + ".dll"),
metadata.GetOrAddGuid(s_guid),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString(assemblyName),
version: new Version(1, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: 0,
hashAlgorithm: AssemblyHashAlgorithm.None);
// Create references to System.Object and System.Console types.
AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("System.Runtime"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: default(BlobHandle),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Object"));
// Get reference to Object's constructor.
var parameterlessCtorSignature = new BlobBuilder();
new BlobEncoder(parameterlessCtorSignature).
MethodSignature(isInstanceMethod: true).
Parameters(0, returnType => returnType.Void(), parameters => { });
BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);
MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference(
systemObjectTypeRef,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex);
var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder);
var codeBuilder = new BlobBuilder();
InstructionEncoder il;
// Emit IL for Program::.ctor
il = new InstructionEncoder(codeBuilder);
// ldarg.0
il.LoadArgument(0);
// call instance void [mscorlib]System.Object::.ctor()
il.Call(objectCtorMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int ctorBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Emit IL for a method
il = new InstructionEncoder(codeBuilder);
il.OpCode(ILOpCode.Ldnull);
il.OpCode(ILOpCode.Throw);
int methodBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Create parameters for a method definition
int nextParameterIndex = 1;
ParameterHandle pFirst = default(ParameterHandle);
for (int i = 0; i < paramNames.Length; i++)
{
ParameterHandle p = metadata.AddParameter(
ParameterAttributes.None,
metadata.GetOrAddString(paramNames[i]),
i + 1);
nextParameterIndex++;
if (i == 0)
{
pFirst = p;
}
}
// Create method definition
MethodDefinitionHandle methodDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
MethodImplAttributes.IL,
metadata.GetOrAddString(name),
metadata.GetOrAddBlob(methodSignature),
methodBodyOffset,
parameterList: pFirst);
// Create method definition for Program::.ctor
MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
MethodImplAttributes.IL,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex,
ctorBodyOffset,
parameterList: MetadataTokens.ParameterHandle(nextParameterIndex));
// Create type definition for the special <Module> type that holds global functions
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: MetadataTokens.MethodDefinitionHandle(1));
// Create type definition for ConsoleApplication.Program
metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString(assemblyName),
metadata.GetOrAddString("Program"),
baseType: systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: methodDef);
return(methodDef);
}
private void WriteResolvedToken(MemberReferenceHandle memberRefHandle)
{
var memberRef = metadataReader.GetMemberReference(memberRefHandle);
// type name
string fullName = GetFullTypeName(metadataReader, memberRef.Parent);
if (fullName != null)
{
writer.WriteAttributeString("declaringType", fullName);
}
// method name
writer.WriteAttributeString("methodName", metadataReader.GetString(memberRef.Name));
}
/// <summary>
/// Encodes <code>call</code> instruction and its operand.
/// </summary>
public void Call(MemberReferenceHandle methodHandle)
{
OpCode(ILOpCode.Call);
Token(methodHandle);
}
public static MemberReference GetMemberReference(this MemberReferenceHandle handle, MetadataReader reader) => reader.GetMemberReference(handle);
internal StringHandle GetName(MemberReferenceHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return StringHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _NameOffset, _IsStringHeapRefSizeSmall));
}
/// <summary>
/// Search through the members of a given type symbol to find the method that matches a particular
/// signature.
/// </summary>
/// <param name="targetTypeSymbol">Type containing the desired method symbol.</param>
/// <param name="memberRef">A MemberRef handle that can be used to obtain the name and signature of the method</param>
/// <param name="methodsOnly">True to only return a method.</param>
/// <returns>The matching method symbol, or null if the inputs do not correspond to a valid method.</returns>
internal Symbol FindMember(TypeSymbol targetTypeSymbol, MemberReferenceHandle memberRef, bool methodsOnly)
{
if ((object)targetTypeSymbol == null)
{
return null;
}
try
{
string memberName = Module.GetMemberRefNameOrThrow(memberRef);
BlobHandle signatureHandle = Module.GetSignatureOrThrow(memberRef);
SignatureHeader signatureHeader;
BlobReader signaturePointer = this.DecodeSignatureHeaderOrThrow(signatureHandle, out signatureHeader);
switch (signatureHeader.RawValue & SignatureHeader.CallingConventionOrKindMask)
{
case (byte)SignatureCallingConvention.Default:
case (byte)SignatureCallingConvention.VarArgs:
int typeParamCount;
ParamInfo<TypeSymbol>[] targetParamInfo = this.DecodeSignatureParametersOrThrow(ref signaturePointer, signatureHeader, out typeParamCount);
return FindMethodBySignature(targetTypeSymbol, memberName, signatureHeader, typeParamCount, targetParamInfo);
case (byte)SignatureKind.Field:
if (methodsOnly)
{
// skip:
return null;
}
ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers;
bool isVolatile;
TypeSymbol type = this.DecodeFieldSignature(ref signaturePointer, out isVolatile, out customModifiers);
return FindFieldBySignature(targetTypeSymbol, memberName, customModifiers, type);
default:
// error: unexpected calling convention
return null;
}
}
catch (BadImageFormatException)
{
return null;
}
}
private Object ResolveMemberReference(MemberReferenceHandle handle)
{
MemberReference memberReference = _metadataReader.GetMemberReference(handle);
Object parent = GetObject(memberReference.Parent, NotFoundBehavior.ReturnResolutionFailure);
if (parent is ResolutionFailure)
{
return(parent);
}
TypeDesc parentTypeDesc = parent as TypeDesc;
if (parentTypeDesc != null)
{
BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure);
string name = _metadataReader.GetString(memberReference.Name);
if (parser.IsFieldSignature)
{
FieldDesc field = parentTypeDesc.GetField(name);
if (field != null)
{
return(field);
}
return(ResolutionFailure.GetMissingFieldFailure(parentTypeDesc, name));
}
else
{
MethodSignature sig = parser.ParseMethodSignature();
if (sig == null)
{
return(parser.ResolutionFailure);
}
TypeDesc typeDescToInspect = parentTypeDesc;
Instantiation substitution = default(Instantiation);
// Try to resolve the name and signature in the current type, or any of the base types.
do
{
MethodDesc method = typeDescToInspect.GetMethod(name, sig, substitution);
if (method != null)
{
// If this resolved to one of the base types, make sure it's not a constructor.
// Instance constructors are not inherited.
if (typeDescToInspect != parentTypeDesc && method.IsConstructor)
{
break;
}
return(method);
}
var baseType = typeDescToInspect.BaseType;
if (baseType != null)
{
if (!baseType.HasInstantiation)
{
substitution = default(Instantiation);
}
else
{
// If the base type is generic, any signature match for methods on the base type with the generic details from
// the deriving type
Instantiation newSubstitution = typeDescToInspect.GetTypeDefinition().BaseType.Instantiation;
if (!substitution.IsNull)
{
TypeDesc[] newSubstitutionTypes = new TypeDesc[newSubstitution.Length];
for (int i = 0; i < newSubstitution.Length; i++)
{
newSubstitutionTypes[i] = newSubstitution[i].InstantiateSignature(substitution, default(Instantiation));
}
newSubstitution = new Instantiation(newSubstitutionTypes);
}
substitution = newSubstitution;
}
}
typeDescToInspect = baseType;
} while (typeDescToInspect != null);
return(ResolutionFailure.GetMissingMethodFailure(parentTypeDesc, name, sig));
}
}
else if (parent is MethodDesc)
{
ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramVararg, (MethodDesc)parent);
}
else if (parent is ModuleDesc)
{
throw new NotImplementedException("MemberRef to a global function or variable.");
}
ThrowHelper.ThrowBadImageFormatException();
return(null);
}
public MemberReference GetMemberReference(MemberReferenceHandle handle)
{
// PERF: This code pattern is JIT friendly and results in very efficient code.
return new MemberReference(this, GetMemberRefTreatmentAndRowId(handle));
}
private Object ResolveMemberReference(MemberReferenceHandle handle)
{
MemberReference memberReference = _metadataReader.GetMemberReference(handle);
Object parent = GetObject(memberReference.Parent);
TypeDesc parentTypeDesc = parent as TypeDesc;
if (parentTypeDesc != null)
{
BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader);
string name = _metadataReader.GetString(memberReference.Name);
if (parser.IsFieldSignature)
{
FieldDesc field = parentTypeDesc.GetField(name);
if (field != null)
{
return(field);
}
throw new TypeSystemException.MissingFieldException(parentTypeDesc, name);
}
else
{
MethodSignature sig = parser.ParseMethodSignature();
TypeDesc typeDescToInspect = parentTypeDesc;
// Try to resolve the name and signature in the current type, or any of the base types.
do
{
// TODO: handle substitutions
MethodDesc method = typeDescToInspect.GetMethod(name, sig);
if (method != null)
{
// If this resolved to one of the base types, make sure it's not a constructor.
// Instance constructors are not inherited.
if (typeDescToInspect != parentTypeDesc && method.IsConstructor)
{
break;
}
return(method);
}
typeDescToInspect = typeDescToInspect.BaseType;
} while (typeDescToInspect != null);
throw new TypeSystemException.MissingMethodException(parentTypeDesc, name, sig);
}
}
else if (parent is MethodDesc)
{
throw new TypeSystemException.InvalidProgramException(ExceptionStringID.InvalidProgramVararg, (MethodDesc)parent);
}
else if (parent is ModuleDesc)
{
throw new NotImplementedException("MemberRef to a global function or variable.");
}
throw new BadImageFormatException();
}
public void IsNil()
{
Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil);
Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil);
Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil);
Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil);
Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ExportedTypeHandle.FromRowId(1).IsNil);
Assert.False(TypeReferenceHandle.FromRowId(1).IsNil);
Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil);
Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil);
Assert.False(CustomAttributeHandle.FromRowId(1).IsNil);
Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(ConstantHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(AssemblyFileHandle.FromRowId(1).IsNil);
Assert.False(MethodImplementationHandle.FromRowId(1).IsNil);
Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil);
Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil);
Assert.False(StringHandle.FromOffset(1).IsNil);
Assert.False(BlobHandle.FromOffset(1).IsNil);
Assert.False(UserStringHandle.FromOffset(1).IsNil);
Assert.False(GuidHandle.FromIndex(1).IsNil);
Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil);
Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil);
Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil);
Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil);
Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil);
Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ExportedTypeHandle.FromRowId(0).IsNil);
Assert.True(TypeReferenceHandle.FromRowId(0).IsNil);
Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil);
Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil);
Assert.True(CustomAttributeHandle.FromRowId(0).IsNil);
Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(ConstantHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(AssemblyFileHandle.FromRowId(0).IsNil);
Assert.True(MethodImplementationHandle.FromRowId(0).IsNil);
Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil);
Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil);
// heaps:
Assert.True(StringHandle.FromOffset(0).IsNil);
Assert.True(BlobHandle.FromOffset(0).IsNil);
Assert.True(UserStringHandle.FromOffset(0).IsNil);
Assert.True(GuidHandle.FromIndex(0).IsNil);
Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil);
// virtual:
Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil);
Assert.False(StringHandle.FromVirtualIndex(0).IsNil);
Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil);
Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil);
}
private uint CalculateMemberRefTreatmentAndRowId(MemberReferenceHandle handle)
{
MemberRefTreatment treatment;
// We need to rename the MemberRef for IClosable.Close as well
// so that the MethodImpl for the Dispose method can be correctly shown
// as IDisposable.Dispose instead of IDisposable.Close
bool isIDisposable;
if (ImplementsRedirectedInterface(handle, out isIDisposable) && isIDisposable)
{
treatment = MemberRefTreatment.Dispose;
}
else
{
treatment = MemberRefTreatment.None;
}
return TreatmentAndRowId((byte)treatment, handle.RowId);
}
internal StringHandle GetName(MemberReferenceHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return StringHandle.FromIndex(this.Block.PeekReference(rowOffset + this.NameOffset, this.IsStringHeapRefSizeSmall));
}
private static MethodDefinitionHandle EmitHelloWorld(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
// Create module and assembly for a console application.
metadata.AddModule(
0,
metadata.GetOrAddString("ConsoleApplication.exe"),
metadata.GetOrAddGuid(s_guid),
default(GuidHandle),
default(GuidHandle));
metadata.AddAssembly(
metadata.GetOrAddString("ConsoleApplication"),
version: new Version(1, 0, 0, 0),
culture: default(StringHandle),
publicKey: default(BlobHandle),
flags: 0,
hashAlgorithm: AssemblyHashAlgorithm.None);
// Create references to System.Object and System.Console types.
AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference(
name: metadata.GetOrAddString("mscorlib"),
version: new Version(4, 0, 0, 0),
culture: default(StringHandle),
publicKeyOrToken: metadata.GetOrAddBlob(
new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }
),
flags: default(AssemblyFlags),
hashValue: default(BlobHandle));
TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Object"));
TypeReferenceHandle systemConsoleTypeRefHandle = metadata.AddTypeReference(
mscorlibAssemblyRef,
metadata.GetOrAddString("System"),
metadata.GetOrAddString("Console"));
// Get reference to Console.WriteLine(string) method.
var consoleWriteLineSignature = new BlobBuilder();
new BlobEncoder(consoleWriteLineSignature).
MethodSignature().
Parameters(1,
returnType => returnType.Void(),
parameters => parameters.AddParameter().Type().String());
MemberReferenceHandle consoleWriteLineMemberRef = metadata.AddMemberReference(
systemConsoleTypeRefHandle,
metadata.GetOrAddString("WriteLine"),
metadata.GetOrAddBlob(consoleWriteLineSignature));
// Get reference to Object's constructor.
var parameterlessCtorSignature = new BlobBuilder();
new BlobEncoder(parameterlessCtorSignature).
MethodSignature(isInstanceMethod: true).
Parameters(0, returnType => returnType.Void(), parameters => { });
BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);
MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference(
systemObjectTypeRef,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex);
// Create signature for "void Main()" method.
var mainSignature = new BlobBuilder();
new BlobEncoder(mainSignature).
MethodSignature().
Parameters(0, returnType => returnType.Void(), parameters => { });
var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder);
var codeBuilder = new BlobBuilder();
InstructionEncoder il;
// Emit IL for Program::.ctor
il = new InstructionEncoder(codeBuilder);
// ldarg.0
il.LoadArgument(0);
// call instance void [mscorlib]System.Object::.ctor()
il.Call(objectCtorMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int ctorBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Emit IL for Program::Main
var flowBuilder = new ControlFlowBuilder();
il = new InstructionEncoder(codeBuilder, flowBuilder);
// ldstr "hello"
il.LoadString(metadata.GetOrAddUserString("Hello, world"));
// call void [mscorlib]System.Console::WriteLine(string)
il.Call(consoleWriteLineMemberRef);
// ret
il.OpCode(ILOpCode.Ret);
int mainBodyOffset = methodBodyStream.AddMethodBody(il);
codeBuilder.Clear();
// Create method definition for Program::Main
MethodDefinitionHandle mainMethodDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
MethodImplAttributes.IL,
metadata.GetOrAddString("Main"),
metadata.GetOrAddBlob(mainSignature),
mainBodyOffset,
parameterList: default(ParameterHandle));
// Create method definition for Program::.ctor
MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
MethodImplAttributes.IL,
metadata.GetOrAddString(".ctor"),
parameterlessCtorBlobIndex,
ctorBodyOffset,
parameterList: default(ParameterHandle));
// Create type definition for the special <Module> type that holds global functions
metadata.AddTypeDefinition(
default(TypeAttributes),
default(StringHandle),
metadata.GetOrAddString("<Module>"),
baseType: default(EntityHandle),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
// Create type definition for ConsoleApplication.Program
metadata.AddTypeDefinition(
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
metadata.GetOrAddString("ConsoleApplication"),
metadata.GetOrAddString("Program"),
baseType: systemObjectTypeRef,
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: mainMethodDef);
return(mainMethodDef);
}
MethodDesc IR2RSignatureTypeProvider <TypeDesc, MethodDesc, R2RSigProviderContext> .GetMethodFromMemberRef(MetadataReader reader, MemberReferenceHandle handle, TypeDesc owningTypeOverride)
{
// Global signature cannot have MemberRef entries in them as such things aren't uniquely identifiable
throw new NotSupportedException();
}
private uint GetMemberRefTreatmentAndRowId(MemberReferenceHandle handle)
{
// PERF: This code pattern is JIT friendly and results in very efficient code.
if (this.metadataKind == MetadataKind.Ecma335)
{
return handle.RowId;
}
return CalculateMemberRefTreatmentAndRowId(handle);
}
private static bool IsNil(MemberReferenceHandle x) => x.IsNil;
/// <summary>
/// Resolves a method reference.
/// </summary>
/// <remarks>
/// Class type arguments are provided by the declaring type stored in the memberRef.
/// Method type arguments are provided by the caller.
/// </remarks>
IMethod ResolveMethodReference(MemberReferenceHandle memberRefHandle, GenericContext context, IReadOnlyList <IType> methodTypeArguments = null, bool expandVarArgs = true)
{
var memberRef = metadata.GetMemberReference(memberRefHandle);
Debug.Assert(memberRef.GetKind() == MemberReferenceKind.Method);
MethodSignature <IType> signature;
IReadOnlyList <IType> classTypeArguments = null;
IMethod method;
if (memberRef.Parent.Kind == HandleKind.MethodDefinition)
{
method = ResolveMethodDefinition((MethodDefinitionHandle)memberRef.Parent, expandVarArgs: false);
signature = memberRef.DecodeMethodSignature(TypeProvider, context);
}
else
{
var declaringType = ResolveDeclaringType(memberRef.Parent, context);
var declaringTypeDefinition = declaringType.GetDefinition();
if (declaringType.TypeArguments.Count > 0)
{
classTypeArguments = declaringType.TypeArguments;
}
// Note: declaringType might be parameterized, but the signature is for the original method definition.
// We'll have to search the member directly on declaringTypeDefinition.
string name = metadata.GetString(memberRef.Name);
signature = memberRef.DecodeMethodSignature(TypeProvider,
new GenericContext(declaringTypeDefinition?.TypeParameters));
if (declaringTypeDefinition != null)
{
// Find the set of overloads to search:
IEnumerable <IMethod> methods;
if (name == ".ctor")
{
methods = declaringTypeDefinition.GetConstructors();
}
else if (name == ".cctor")
{
methods = declaringTypeDefinition.Methods.Where(m => m.IsConstructor && m.IsStatic);
}
else
{
methods = declaringTypeDefinition.GetMethods(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers)
.Concat(declaringTypeDefinition.GetAccessors(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers));
}
// Determine the expected parameters from the signature:
ImmutableArray <IType> parameterTypes;
if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs)
{
parameterTypes = signature.ParameterTypes
.Take(signature.RequiredParameterCount)
.Concat(new[] { SpecialType.ArgList })
.ToImmutableArray();
}
else
{
parameterTypes = signature.ParameterTypes;
}
// Search for the matching method:
method = null;
foreach (var m in methods)
{
if (m.TypeParameters.Count != signature.GenericParameterCount)
{
continue;
}
if (CompareSignatures(m.Parameters, parameterTypes) && CompareTypes(m.ReturnType, signature.ReturnType))
{
method = m;
break;
}
}
}
else
{
method = null;
}
if (method == null)
{
method = CreateFakeMethod(declaringType, name, signature);
}
}
if (classTypeArguments != null || methodTypeArguments != null)
{
method = method.Specialize(new TypeParameterSubstitution(classTypeArguments, methodTypeArguments));
}
if (expandVarArgs && signature.Header.CallingConvention == SignatureCallingConvention.VarArgs)
{
method = new VarArgInstanceMethod(method, signature.ParameterTypes.Skip(signature.RequiredParameterCount));
}
return(method);
}
internal BlobHandle GetSignature(MemberReferenceHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return BlobHandle.FromIndex(this.Block.PeekReference(rowOffset + this.SignatureOffset, this.IsBlobHeapRefSizeSmall));
}
