private Cecil.IMetadataScope ResolveScope(AnalysisNet.Types.IBasicType basicType)
{
if (basicType.ContainingAssembly.Name.Equals("mscorlib"))
{
return(Context.CurrentModule.TypeSystem.CoreLibrary);
}
if (basicType.ContainingAssembly.Name.Equals("System.Core"))
{
//var enumerable = Context.CurrentModule.ImportReference(typeof(Enumerable));
//var r = enumerable.Module.AssemblyReferences.Where(assembly => assembly.Name.Equals("System.Core")).First();
//return r;
Cecil.AssemblyNameReference a = new Cecil.AssemblyNameReference(basicType.ContainingAssembly.Name, new Version(4, 0, 0, 0))
{
PublicKeyToken = new byte[8] {
183, 122, 92, 86, 25, 52, 224, 137
}
};
return(a);
}
if (basicType.ContainingAssembly.Name.Equals("System"))
{
Cecil.AssemblyNameReference a = new Cecil.AssemblyNameReference(basicType.ContainingAssembly.Name, new Version(4, 0, 0, 0))
{
PublicKeyToken = new byte[8] {
183, 122, 92, 86, 25, 52, 224, 137
}
};
return(a);
}
return(null);
}
private Cecil.ModuleDefinition ResolveModule(AnalysisNet.Types.IBasicType basicType)
{
if (basicType.ResolvedType != null)
{
return(ResolveModule(basicType.ResolvedType));
}
return(null);
}
private void ExtractInterfaces(IList <AnalysisNet.Types.IBasicType> dest, IEnumerable <Cecil.InterfaceImplementation> source)
{
foreach (Cecil.InterfaceImplementation interfaceref in source)
{
AnalysisNet.Types.IBasicType type = ExtractType(interfaceref.InterfaceType) as AnalysisNet.Types.IBasicType;
dest.Add(type);
}
}
private Cecil.TypeReference TypeReferenceToPlatformType(AnalysisNet.Types.IBasicType basicType)
{
if (basicType is AnalysisNet.Types.PlatformType platformType)
{
var specificImplementation = platformType.ToImplementation(Context.CurrentModule.TypeSystem.CoreLibrary.Name);
specificImplementation.Resolve(Context.Host);
return(TypeReference(specificImplementation));
}
return(null);
}
public static string MetadataName(this Model.Types.IBasicType basicType)
{
int genericParameters = basicType.GenericParameterCount;
// nested types
if (basicType.ContainingType != null)
{
genericParameters -= basicType.ContainingType.GenericParameterCount;
}
if (genericParameters < 0)
{
throw new Exception("calculated generic parameter count cannot be negative.");
}
if (genericParameters == 0)
{
return(basicType.Name);
}
return(string.Format("{0}`{1}", basicType.Name, genericParameters));
}
private Cecil.TypeReference TypeReference(AnalysisNet.Types.IBasicType basicType)
{
if (typesCache.TryGetValue(basicType, out Cecil.TypeReference cecilTypeReference))
{
return(cecilTypeReference);
}
Cecil.TypeReference platformType = TypeReferenceToPlatformType(basicType);
if (platformType != null)
{
typesCache[basicType] = platformType;
return(platformType);
}
string nmspace = basicType.ContainingNamespace;
string name = basicType.MetadataName();
Cecil.ModuleDefinition module = ResolveModule(basicType);
Cecil.IMetadataScope scope = module ?? ResolveScope(basicType);
if (module == null && scope == null)
{
throw new NotImplementedException();
}
cecilTypeReference = new Cecil.TypeReference(nmspace, name, module, scope);
if (basicType.TypeKind == AnalysisNet.Types.TypeKind.ValueType)
{
cecilTypeReference.IsValueType = true;
}
if (basicType.ContainingType != null)
{
cecilTypeReference.DeclaringType = TypeReference(basicType.ContainingType);
cecilTypeReference.Namespace = string.Empty;
}
if (basicType.GenericParameterCount > 0)
{
Cecil.GenericInstanceType instantiated = null;
// should we add constraints?
cecilTypeReference.CreateGenericParameters(basicType.GenericParameterCount);
MapGenericParameters(cecilTypeReference, basicType);
// call it before instantiating it
cecilTypeReference = ImportTypeReference(cecilTypeReference);
if (basicType.GenericArguments.Count == 0)
{
instantiated = cecilTypeReference.MakeGenericInstanceType(cecilTypeReference.GenericParameters.ToArray());
}
else
{
Cecil.TypeReference[] arguments = basicType.GenericArguments.Select(ga => TypeReference(ga)).ToArray();
instantiated = cecilTypeReference.MakeGenericInstanceType(arguments);
}
cecilTypeReference = instantiated;
}
else
{
cecilTypeReference = ImportTypeReference(cecilTypeReference);
}
typesCache[basicType] = cecilTypeReference;
return(cecilTypeReference);
}
