private Type GetCreatedExplicitDelegateType([NotNull] Type originalType)
{
var signature = GetSignatureTypesFromGenericDelegate(originalType);
var delegateName = GetDelegateTypeName(signature.ReturnType, signature.ParameterTypes);
return(TargetModule.GetType(delegateName));
}
private TypeBuilder GenerateDelegateType
(
[NotNull] IntrospectiveMethodInfo methodInfo,
[NotNull] string memberIdentifier,
CallingConvention callingConvention
)
{
// Declare a delegate type
var delegateBuilder = TargetModule.DefineType
(
$"{memberIdentifier}_dt",
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.AutoClass,
typeof(MulticastDelegate)
);
var attributeConstructor = typeof(UnmanagedFunctionPointerAttribute).GetConstructors().First
(
c =>
c.GetParameters().Any() &&
c.GetParameters().Length == 1 &&
c.GetParameters().First().ParameterType == typeof(CallingConvention)
);
var functionPointerAttributeBuilder = new CustomAttributeBuilder
(
attributeConstructor,
new object[] { callingConvention },
new[] { typeof(UnmanagedFunctionPointerAttribute).GetField(nameof(UnmanagedFunctionPointerAttribute.SetLastError)) },
new object[] { true }
);
delegateBuilder.SetCustomAttribute(functionPointerAttributeBuilder);
foreach (var attribute in methodInfo.CustomAttributes)
{
delegateBuilder.SetCustomAttribute(attribute.GetAttributeBuilder());
}
var delegateCtorBuilder = delegateBuilder.DefineConstructor
(
RTSpecialName | HideBySig | Public,
Standard,
new[] { typeof(object), typeof(IntPtr) }
);
delegateCtorBuilder.SetImplementationFlags(Runtime | Managed);
var delegateMethodBuilder = delegateBuilder.DefineMethod
(
"Invoke",
Public | HideBySig | NewSlot | Virtual,
methodInfo.ReturnType,
methodInfo.ParameterTypes.ToArray()
);
delegateMethodBuilder.ApplyCustomAttributesFrom(methodInfo);
delegateMethodBuilder.SetImplementationFlags(Runtime | Managed);
return(delegateBuilder);
}
private TypeSig Import(TypeSig typeSig)
{
if (typeSig.DefinitionAssembly != null && SourceAssemblies.Contains(typeSig.DefinitionAssembly.Name))
{
var baseTypeSig = typeSig;
if (typeSig.IsSZArray || typeSig.IsByRef || typeSig.IsArray)
{
baseTypeSig = typeSig.Next;
}
else if (typeSig.IsFunctionPointer || typeSig.IsPointer || typeSig.IsPinned || typeSig.IsModuleSig || typeSig.IsGenericParameter ||
typeSig.IsGenericTypeParameter || typeSig.IsGenericInstanceType || typeSig.IsGenericMethodParameter || typeSig.IsValueArray)
{
throw new NotImplementedException();
}
TypeSig importedTypeSig;
if (baseTypeSig.IsGenericInstanceType)
{
importedTypeSig = RemapGenericInstSig(baseTypeSig.ToGenericInstSig());
}
else
{
var name = baseTypeSig.FullName;
var targetTypeDef = TargetModule.FindThrow(name, false);
importedTypeSig = Module.Import(targetTypeDef).ToTypeSig();
if (Options.Resolve)
{
importedTypeSig.ToTypeDefOrRef().ResolveTypeDefThrow();
}
}
if (typeSig.IsSZArray)
{
return(new SZArraySig(importedTypeSig));
}
else if (typeSig.IsByRef)
{
return(new ByRefSig(importedTypeSig));
}
else if (typeSig.IsArray)
{
var arraySig = typeSig.ToArraySig();
return(new ArraySig(importedTypeSig, arraySig.Rank, arraySig.Sizes, arraySig.LowerBounds));
}
else
{
return(importedTypeSig);
}
}
return(typeSig);
}
public void Save(string targetModule)
{
var parameters = new WriterParameters();
if (TargetModule.HasSymbols && DebugSymbolFormat != DebugSymbolFormat.None)
{
parameters.SymbolWriterProvider = DebugSymbolFormat == DebugSymbolFormat.Mdb
? (ISymbolWriterProvider) new MdbWriterProvider()
: new PdbWriterProvider();
}
TargetModule.Write(targetModule, parameters);
}
private TypeBuilder GenerateDelegateType
(
[NotNull] PipelineWorkUnit <IntrospectiveMethodInfo> workUnit
)
{
var definition = workUnit.Definition;
// Declare a delegate type
var delegateBuilder = TargetModule.DefineDelegate
(
$"{workUnit.GetUniqueBaseMemberName()}_delegate",
definition,
Options.HasFlagFast(SuppressSecurity)
);
return(delegateBuilder);
}
/// <summary>
/// Executes the task to generate a list of test assemblies
/// based on file changes from a specified Pull Request.
/// The output it produces is said list.
/// </summary>
/// <returns> Returns a value indicating wheter the success status of the task. </returns>
public override bool Execute()
{
if (MapFilePath == null)
{
throw new ArgumentNullException("The MapFilePath cannot be null.");
}
if (!File.Exists(MapFilePath))
{
throw new FileNotFoundException("The MapFilePath provided could not be found. Please provide a valid MapFilePath.");
}
var mappingsDictionary = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(File.ReadAllText(MapFilePath));
if (FilesChanged != null && FilesChanged.Length > 0)
{
Console.WriteLine($"Filter according to {FilesChanged.Length} file(s) in FilesChanged");
var filesChangedSet = new HashSet <string>(FilesChanged);
Output = SetGenerator.Generate(filesChangedSet, mappingsDictionary).ToArray();
}
else if (!string.IsNullOrWhiteSpace(TargetModule))
{
Console.WriteLine($"Filter module {TargetModule}");
var modules = (TargetModule.Equals("Accounts"))? new string[] { "Accounts" } : new string[] { "Accounts", TargetModule };
Output = SetGenerator.Generate(modules, mappingsDictionary).ToArray();
}
else
{
Console.WriteLine($"Skip filter and load all from ${MapFilePath}");
var set = new HashSet <string>();
mappingsDictionary = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(File.ReadAllText(MapFilePath));
foreach (KeyValuePair <string, string[]> pair in mappingsDictionary)
{
set.UnionWith(pair.Value);
}
Output = set.ToArray();
}
return(true);
}
public void Dispose()
{
AssemblyResolver?.Dispose();
TargetModule?.Dispose();
}
result = new TypeRefUser(TargetModule, type.Namespace, type.Name, scope);
