public ReferenceContainer(ModuleDefinition moduleDefinition, IAssemblyResolver assemblyResolver)
{
var systemDefinition = assemblyResolver.Resolve("mscorlib");
var yalfDefinition = assemblyResolver.Resolve("Yalf");
var yalfTypes = yalfDefinition.MainModule.Types;
var logType = yalfTypes.Single(x => x.Name == "Log");
var iContextType = yalfTypes.Single(x => x.Name == "IContext");
var iDisposableType = systemDefinition.MainModule.Types.Single(x => x.Name == "IDisposable");
var exceptionType = systemDefinition.MainModule.Types.Single(x => x.Name == "Exception");
MethodContextMethod = moduleDefinition.Import(logType.Methods.Single(m => m.Name == "MethodContext"));
TraceExceptionMethod = moduleDefinition.Import(logType.Methods.Single(m => m.Name == "TraceException"));
CreateRecordReturnMethod = retType => {
var recordReturn = moduleDefinition.Import(iContextType.Methods.Single(m => m.Name == "RecordReturn"));
if (retType.IsGenericInstance)
{
return recordReturn.MakeGeneric(retType);
}
else
{
return recordReturn.MakeGeneric(retType);
}
};
DisposeMethod = moduleDefinition.Import(iDisposableType.Methods.Single(m => m.Name == "Dispose"));
LogType = moduleDefinition.Import(logType);
IContextType = moduleDefinition.Import(iContextType);
ExceptionType = moduleDefinition.Import(exceptionType);
PreserveStackTraceMethod = moduleDefinition.Import(iContextType.Methods.Single(m => m.Name == "PreserveStackTrace"));
}
public static void FindReferences(IAssemblyResolver assemblyResolver, ModuleDefinition moduleDefinition)
{
var baseLib = assemblyResolver.Resolve("mscorlib");
var baseLibTypes = baseLib.MainModule.Types;
var systemLib = assemblyResolver.Resolve("System");
var systemLibTypes = systemLib.MainModule.Types;
var winrt = !baseLibTypes.Any(type => type.Name == "Object");
if (winrt)
{
baseLib = assemblyResolver.Resolve("System.Runtime");
baseLibTypes = baseLib.MainModule.Types;
}
DateTime.TypeReference = moduleDefinition.Import( baseLibTypes.First( t => t.Name == "DateTime" ) );
DateTime.TypeReference.Resolve();
Boolean.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "Boolean"));
Int32.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "Int32"));
String.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "String"));
Type.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "Type"));
Type.GetTypeFromHandle = moduleDefinition.Import(Type.TypeReference.Resolve().FindMethod("GetTypeFromHandle", "RuntimeTypeHandle"));
Object.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "Object"));
Object.GetHashcode = moduleDefinition.Import(Object.TypeReference.Resolve().FindMethod("GetHashCode"));
Object.GetType = moduleDefinition.Import(Object.TypeReference.Resolve().FindMethod("GetType"));
Object.StaticEquals = moduleDefinition.Import(Object.TypeReference.Resolve().FindMethod("Equals", "Object", "Object"));
Object.ReferenceEquals = moduleDefinition.Import(Object.TypeReference.Resolve().FindMethod("ReferenceEquals", "Object", "Object"));
IEnumerable.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "IEnumerable"));
IEnumerable.GetEnumerator = moduleDefinition.Import(IEnumerable.TypeReference.Resolve().FindMethod("GetEnumerator"));
IEnumerator.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "IEnumerator"));
IEnumerator.MoveNext = moduleDefinition.Import(IEnumerator.TypeReference.Resolve().FindMethod("MoveNext"));
IEnumerator.GetCurrent = moduleDefinition.Import(IEnumerator.TypeReference.Resolve().FindMethod("get_Current"));
IEquatable.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "IEquatable`1"));
GeneratedCodeAttribute.TypeReference = moduleDefinition.Import(systemLibTypes.First(t => t.Name == "GeneratedCodeAttribute"));
GeneratedCodeAttribute.ConstructorStringString = moduleDefinition.Import(GeneratedCodeAttribute.TypeReference.Resolve().FindMethod(".ctor", "String", "String"));
DebuggerNonUserCodeAttribute.TypeReference = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "DebuggerNonUserCodeAttribute"));
DebuggerNonUserCodeAttribute.Constructor = moduleDefinition.Import(DebuggerNonUserCodeAttribute.TypeReference.Resolve().FindMethod(".ctor"));
}
public static TypeDefinition ResolveType(string type, ICustomAttributeProvider provider, IAssemblyResolver resolver)
{
if (provider == null)
throw new ArgumentException ("Type resolution support requires an AssemblyDefinition or TypeDefinition.", "provider");
if (resolver == null)
throw new ArgumentException ("Type resolution support requires a IAssemblyResolver.", "resolver");
// `type` is either a "bare" type "Foo.Bar", or an
// assembly-qualified type "Foo.Bar, AssemblyName [Version=...]?".
//
// Bare types are looked up via `provider`; assembly-qualified types are
// looked up via `resolver`
int c = type.IndexOf (',');
string typeName = c < 0 ? type : type.Substring (0, c);
string assmName = c < 0 ? null : type.Substring (c+1);
AssemblyDefinition assembly = assmName == null ? null : resolver.Resolve (assmName);
if (assembly == null) {
assembly = provider as AssemblyDefinition;
if (assembly == null) {
TypeDefinition decl = (TypeDefinition) provider;
assembly = decl.Module.Assembly;
}
}
var ret = assembly.Modules.Cast<ModuleDefinition> ()
.Select (md => md.Types.FirstOrDefault (t => t.FullName == typeName))
.FirstOrDefault (td => td != null);
if (ret == null)
throw new ArgumentException ("Type not found: " + type, "type");
return ret;
}
public static TypeDefinition Resolve (IAssemblyResolver resolver, TypeReference type)
{
type = type.GetElementType ();
var scope = type.Scope;
switch (scope.MetadataScopeType) {
case MetadataScopeType.AssemblyNameReference:
var assembly = resolver.Resolve ((AssemblyNameReference) scope);
if (assembly == null)
return null;
return GetType (assembly.MainModule, type);
case MetadataScopeType.ModuleDefinition:
return GetType ((ModuleDefinition) scope, type);
case MetadataScopeType.ModuleReference:
var modules = type.Module.Assembly.Modules;
var module_ref = (ModuleReference) scope;
for (int i = 0; i < modules.Count; i++) {
var netmodule = modules [i];
if (netmodule.Name == module_ref.Name)
return GetType (netmodule, type);
}
break;
}
throw new NotSupportedException ();
}
public static void FindReferences(IAssemblyResolver assemblyResolver, ModuleDefinition moduleDefinition)
{
var baseLib = assemblyResolver.Resolve("mscorlib");
var baseLibTypes = baseLib.MainModule.Types;
var winrt = baseLibTypes.All(type => type.Name != "Object");
if (winrt)
{
baseLib = assemblyResolver.Resolve("System.Runtime");
baseLibTypes = baseLib.MainModule.Types;
}
var argumentException = baseLibTypes.First(x => x.Name == "ArgumentException");
ArgumentExceptionConstructor = moduleDefinition.ImportReference(argumentException.Methods.First(x =>
x.IsConstructor &&
x.Parameters.Count == 2 &&
x.Parameters[0].ParameterType.Name == "String" &&
x.Parameters[1].ParameterType.Name == "String"));
var argumentNullException = baseLibTypes.First(x => x.Name == "ArgumentNullException");
ArgumentNullExceptionConstructor = moduleDefinition.ImportReference(argumentNullException.Methods.First(x =>
x.IsConstructor &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "String"));
ArgumentNullExceptionWithMessageConstructor = moduleDefinition.ImportReference(argumentNullException.Methods.First(x =>
x.IsConstructor &&
x.Parameters.Count == 2 &&
x.Parameters[0].ParameterType.Name == "String" &&
x.Parameters[1].ParameterType.Name == "String"));
var invalidOperationException = baseLibTypes.First(x => x.Name == "InvalidOperationException");
InvalidOperationExceptionConstructor = moduleDefinition.ImportReference(invalidOperationException.Methods.First(x =>
x.IsConstructor &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "String"));
var debugLib = !winrt ? assemblyResolver.Resolve("System") : assemblyResolver.Resolve("System.Diagnostics.Debug");
var debugLibTypes = debugLib.MainModule.Types;
var debug = debugLibTypes.First(x => x.Name == "Debug");
DebugAssertMethod = moduleDefinition.ImportReference(debug.Methods.First(x =>
x.IsStatic &&
x.Parameters.Count == 2 &&
x.Parameters[0].ParameterType.Name == "Boolean" &&
x.Parameters[1].ParameterType.Name == "String"));
}
/// <inheritdoc/>
public TypeDef Resolve(TypeRef typeRef)
{
if (typeRef == null)
{
return(null);
}
var nonNestedTypeRef = TypeRef.GetNonNestedTypeRef(typeRef);
if (nonNestedTypeRef == null)
{
return(null);
}
var nonNestedResolutionScope = nonNestedTypeRef.ResolutionScope;
var nonNestedModule = nonNestedTypeRef.Module;
var asmRef = nonNestedResolutionScope as AssemblyRef;
if (asmRef != null)
{
var asm = assemblyResolver.Resolve(asmRef, nonNestedModule);
return(asm == null ? null : asm.Find(typeRef) ?? ResolveExportedType(asm.Modules, typeRef));
}
var moduleDef = nonNestedResolutionScope as ModuleDef;
if (moduleDef != null)
{
return(moduleDef.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { moduleDef }, typeRef));
}
var moduleRef = nonNestedResolutionScope as ModuleRef;
if (moduleRef != null)
{
if (nonNestedModule == null)
{
return(null);
}
if (new SigComparer().Equals(moduleRef, nonNestedModule))
{
return(nonNestedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { nonNestedModule }, typeRef));
}
var nonNestedAssembly = nonNestedModule.Assembly;
if (nonNestedAssembly == null)
{
return(null);
}
var resolvedModule = nonNestedAssembly.FindModule(moduleRef.Name);
return(resolvedModule == null ? null : resolvedModule.Find(typeRef) ??
ResolveExportedType(new ModuleDef[] { resolvedModule }, typeRef));
}
return(null);
}
public static AssemblyDefinition Resolve(this IAssemblyResolver self, string fullName)
{
if (fullName == null)
{
throw new ArgumentNullException(nameof(fullName));
}
return(self.Resolve(AssemblyNameReference.Parse(fullName), defaults));
}
TypeDefinition GetTypeDefinition(string assemblyName)
{
var msCoreLibDefinition = assemblyResolver.Resolve(assemblyName);
return(msCoreLibDefinition
.MainModule
.Types
.FirstOrDefault(x => x.Name == "IsVolatile"));
}
TypeDefinition GetExceptionType(string assemblyName)
{
var msCoreLibDefinition = assemblyResolver.Resolve(assemblyName);
return(msCoreLibDefinition
.MainModule
.Types
.FirstOrDefault(x => x.Name == "InvalidOperationException"));
}
public void Execute()
{
var msCoreLibDefinition = assemblyResolver.Resolve("mscorlib");
var msCoreTypes = msCoreLibDefinition.MainModule.Types;
var objectDefinition = msCoreTypes.FirstOrDefault(x => x.Name == "Object");
if (objectDefinition == null)
{
ExecuteWinRT();
return;
}
var module = moduleReader.Module;
var voidDefinition = msCoreTypes.First(x => x.Name == "Void");
VoidTypeReference = module.Import(voidDefinition);
}
void AppendTypes(string name, List <TypeDefinition> coreTypes)
{
var definition = AssemblyResolver.Resolve(name);
if (definition != null)
{
coreTypes.AddRange(definition.MainModule.Types);
}
}
private static AssemblyDefinition Resolve(AssemblyNameReference reference)
{
if (!References.ContainsKey(reference.Name))
{
var asm = _resolver.Resolve(reference);
References.Add(reference.Name, asm);
}
return(References[reference.Name]);;
}
/// <summary>
/// Tries the load the referenced assembly.
/// </summary>
/// <param name="assemblyResolver">The assembly resolver.</param>
/// <param name="assemblyNameReference">The assembly name reference.</param>
/// <returns></returns>
private static AssemblyDefinition TryLoad(IAssemblyResolver assemblyResolver, AssemblyNameReference assemblyNameReference)
{
try
{
Logger.WriteDebug("TryLoad '{0}'", assemblyNameReference.FullName);
return(assemblyResolver.Resolve(assemblyNameReference));
}
catch (FileNotFoundException)
{ }
return(null);
}
public void Execute()
{
var msCoreLibDefinition = _assemblyResolver.Resolve(new AssemblyNameReference("mscorlib", null));
var msCoreTypes = msCoreLibDefinition.MainModule.Types;
var objectDefinition = msCoreTypes.FirstOrDefault(x => string.Equals(x.Name, "Object"));
if (objectDefinition is null)
{
return;
}
var type = GetCoreTypeReference("System.Type").Resolve();
GetTypeFromHandle = _moduleWeaver.ModuleDefinition.ImportReference(type.Methods.First(m => m.Name == "GetTypeFromHandle"));
GeneratedCodeAttribute = GetCoreTypeReference(GeneratedCodeAttributeTypeName);
CompilerGeneratedAttribute = GetCoreTypeReference(CompilerGeneratedAttributeTypeName);
DebuggerNonUserCodeAttribute = GetCoreTypeReference(DebuggerNonUserCodeAttributeTypeName);
}
public CompilerMetadataReference?Resolve(IAssembly asmRef)
{
ModuleDef sourceModule = null;
var asm = assemblyResolver.Resolve(asmRef, sourceModule ?? defaultSourceModule);
if (asm == null)
{
return(null);
}
return(CompilerMetadataReferenceCreator.Create(rawModuleBytesProvider, tempAssembly, asm.ManifestModule, nonNestedEditedTypeOrNull, makeEverythingPublic));
}
public CompilerMetadataReference?Resolve(IAssembly asmRef)
{
ModuleDef sourceModule = null;
var asm = assemblyResolver.Resolve(asmRef, sourceModule ?? defaultSourceModule);
if (asm == null)
{
return(null);
}
return(CompilerMetadataReferenceCreator.Create(asm.ManifestModule, makeEverythingPublic));
}
private static AssemblyDefinition SafeResolveBridge(IAssemblyResolver resolver)
{
try
{
return(resolver.Resolve("SyntaxTree.VisualStudio.Unity.Bridge", new ReaderParameters {
AssemblyResolver = resolver
}));
}
catch (AssemblyResolutionException)
{
return(null);
}
}
public AssemblyDefinition Resolve(AssemblyNameReference name)
{
var assemblyPath = Folder
.SelectMany(x => Directory.GetFiles(x, name.Name + ".dll"))
.SingleOrDefault();
if (assemblyPath != null)
{
return(AssemblyDefinition.ReadAssembly(assemblyPath));
}
return(_defaultAssemblyResolver.Resolve(name));
}
public IAssembly Resolve(IAssemblyReference assemblyName, string localPath)
{
if (_assemblyTable.Contains(assemblyName))
{
return((IAssembly)_assemblyTable[assemblyName]);
}
IAssembly assembly = _assemblyResolver.Resolve(assemblyName, localPath);
_assemblyTable.Add(assemblyName, assembly);
return(assembly);
}
public ICollection <TypeDefinition> GetAllTypes(Settings settings, out AssemblyDefinition autoDIAssembly)
{
autoDIAssembly = null;
var allTypes = new HashSet <TypeDefinition>(TypeComparer.FullName);
IEnumerable <TypeDefinition> FilterTypes(IEnumerable <TypeDefinition> types) =>
types.Where(t => !t.IsCompilerGenerated() && !allTypes.Remove(t));
const string autoDIFullName = "AutoDI";
foreach (ModuleDefinition module in GetAllModules())
{
if (module.Assembly.Name.Name == autoDIFullName)
{
autoDIAssembly = _assemblyResolver.Resolve(module.Assembly.Name);
continue;
}
bool isMainModule = ReferenceEquals(module, _module);
bool useAutoDiAssebmlies = settings.Behavior.HasFlag(Behaviors.IncludeDependentAutoDIAssemblies);
bool matchesAssembly = settings.Assemblies.Any(a => a.Matches(module.Assembly));
if (isMainModule || useAutoDiAssebmlies || matchesAssembly)
{
//Check if it references AutoDI. If it doesn't we will skip
//We also always process the main module since the weaver was directly added to it
if (!isMainModule && !matchesAssembly &&
module.AssemblyReferences.All(a => a.Name != autoDIFullName))
{
continue;
}
_logger.Debug($"Including types from '{module.Assembly.FullName}'", DebugLogLevel.Default);
//Either references AutoDI, or was a config assembly match, include the types.
foreach (TypeDefinition type in FilterTypes(module.GetAllTypes()))
{
allTypes.Add(type);
}
}
}
return(allTypes);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyReference" /> class.
/// </summary>
/// <param name="assemblyResolver">The assembly resolver.</param>
/// <param name="name">The name.</param>
/// <param name="isPrivate">if set to <c>true</c> [is private].</param>
/// <param name="projectItem">The project item.</param>
public AssemblyReference(IAssemblyResolver assemblyResolver, AssemblyName name, bool isPrivate, ProjectItem projectItem)
{
_assemblyResolver = assemblyResolver;
Name = name;
var assembly = assemblyResolver.Resolve(name, null);
if (assembly != null)
{
Path = assembly.ManifestModule.Location;
}
IsPrivate = isPrivate;
ProjectItem = projectItem;
}
public static void FindReferences(IAssemblyResolver assemblyResolver, ModuleDefinition moduleDefinition)
{
var baseLib = assemblyResolver.Resolve("mscorlib");
var baseLibTypes = baseLib.MainModule.Types;
var winrt = !baseLibTypes.Any(type => type.Name == "Object");
if (winrt)
{
baseLib = assemblyResolver.Resolve("System.Runtime");
baseLibTypes = baseLib.MainModule.Types;
}
var debugLib = !winrt ? baseLib : assemblyResolver.Resolve("System.Diagnostics.Debug");
var debugLibTypes = debugLib.MainModule.Types;
var collectionsLib = !winrt ? baseLib : assemblyResolver.Resolve("System.Collections");
var collectionsLibTypes = collectionsLib.MainModule.Types;
SystemType = moduleDefinition.Import(baseLibTypes.First(t => t.Name == "Type"));
DebuggerBrowsableStateType = moduleDefinition.Import(debugLibTypes.First(t => t.Name == "DebuggerBrowsableState"));
var listType = collectionsLibTypes.First(t => t.Name == "List`1");
ListCtor = moduleDefinition.Import(listType.Methods.First(m => m.IsConstructor && m.Parameters.Count == 1 && m.Parameters[0].ParameterType.Name.StartsWith("IEnumerable")));
ListToArray = moduleDefinition.Import(listType.Methods.First(m => m.Name == "ToArray"));
var debuggerBrowsableAttribute = debugLibTypes.First(t => t.Name == "DebuggerBrowsableAttribute");
DebuggerBrowsableAttributeCtor = moduleDefinition.Import(debuggerBrowsableAttribute.Methods.First(x => x.IsConstructor));
var debuggerDisplayAttribute = debugLibTypes.First(t => t.Name == "DebuggerDisplayAttribute");
DebuggerDisplayAttributeCtor = moduleDefinition.Import(debuggerDisplayAttribute.Methods.First(x => x.IsConstructor));
var debuggerTypeProxyAttribute = debugLibTypes.First(t => t.Name == "DebuggerTypeProxyAttribute");
DebuggerTypeProxyAttributeCtor = moduleDefinition.Import(debuggerTypeProxyAttribute.Methods.First(x => x.IsConstructor &&
x.Parameters[0].ParameterType.FullName == "System.Type"));
var compilerGeneratedAttribute = baseLibTypes.First(t => t.Name == "CompilerGeneratedAttribute");
CompilerGeneratedAttributeCtor = moduleDefinition.Import(compilerGeneratedAttribute.Methods.First(x => x.IsConstructor));
}
/// <summary>
/// Finds and returns an <see cref="AssemblyDef"/>
/// </summary>
/// <param name="self">this</param>
/// <param name="asmFullName">The assembly to find</param>
/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
public static AssemblyDef ResolveThrow(this IAssemblyResolver self, string asmFullName, ModuleDef sourceModule)
{
if (asmFullName is null)
{
return(null);
}
var asm = self.Resolve(new AssemblyNameInfo(asmFullName), sourceModule);
if (!(asm is null))
{
return(asm);
}
throw new AssemblyResolveException($"Could not resolve assembly: {asmFullName}");
}
/// <summary>
/// Finds and returns an <see cref="AssemblyDef"/>
/// </summary>
/// <param name="self">this</param>
/// <param name="assembly">The assembly to find</param>
/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
public static AssemblyDef ResolveThrow(this IAssemblyResolver self, IAssembly assembly, ModuleDef sourceModule)
{
if (assembly is null)
{
return(null);
}
var asm = self.Resolve(assembly, sourceModule);
if (!(asm is null))
{
return(asm);
}
throw new AssemblyResolveException($"Could not resolve assembly: {assembly}");
}
/// <summary>
/// Finds and returns an <see cref="AssemblyDef"/>
/// </summary>
/// <param name="self">this</param>
/// <param name="asmFullName">The assembly to find</param>
/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
public static AssemblyDef ResolveThrow(this IAssemblyResolver self, string asmFullName, ModuleDef sourceModule)
{
if (asmFullName == null)
{
return(null);
}
var asm = self.Resolve(new AssemblyNameInfo(asmFullName), sourceModule);
if (asm != null)
{
return(asm);
}
throw new AssemblyResolveException(string.Format("Could not resolve assembly: {0}", asmFullName));
}
/// <summary>
/// Finds and returns an <see cref="AssemblyDef"/>
/// </summary>
/// <param name="self">this</param>
/// <param name="assembly">The assembly to find</param>
/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
public static AssemblyDef ResolveThrow(this IAssemblyResolver self, AssemblyName assembly, ModuleDef sourceModule)
{
if (assembly == null)
{
return(null);
}
var asm = self.Resolve(new AssemblyNameInfo(assembly), sourceModule);
if (asm != null)
{
return(asm);
}
throw new AssemblyResolveException($"Could not resolve assembly: {assembly}");
}
public static AssemblyDefinition ResolveAssemblyReference(IAssemblyResolver resolver, AssemblyNameReference assemblyName)
{
try
{
return(resolver.Resolve(assemblyName, new ReaderParameters {
AssemblyResolver = resolver, ApplyWindowsRuntimeProjections = true
}));
}
catch (AssemblyResolutionException)
{
// DefaultAssemblyResolver doesn't handle windows runtime references correctly. But that is okay, as they cannot derive from managed types anyway
// Besides, if any assembly is missing, UnityLinker will stub it and we should not care about it
return(null);
}
}
private void MarkAsProcessed(AssemblyDefinition assembly, IAssemblyResolver resolver)
{
TypeDefinition generatedCodeAttribute = resolver.Resolve("System").MainModule.GetType(typeof(GeneratedCodeAttribute).FullName);
MethodDefinition constructor = generatedCodeAttribute.Methods.Single(a => a.IsConstructor && a.Parameters.Count == 2);
TypeReference stringType = assembly.MainModule.TypeSystem.String;
assembly.CustomAttributes.Add(new CustomAttribute(assembly.MainModule.ImportReference(constructor))
{
ConstructorArguments =
{
new CustomAttributeArgument(stringType, "SignumTask"),
new CustomAttributeArgument(stringType, this.GetType().Assembly.GetName().Version.ToString()),
}
});
}
public void Execute()
{
var msCoreLibDefinition = assemblyResolver.Resolve("mscorlib");
var msCoreTypes = msCoreLibDefinition.MainModule.Types;
var objectDefinition = msCoreTypes.FirstOrDefault(x => x.Name == "Object");
if (objectDefinition == null)
{
ExecuteWinRT();
return;
}
var module = moduleWeaver.ModuleDefinition;
var methodBaseDefinition = msCoreTypes.First(x => x.Name == "MethodBase");
GetMethodFromHandle = module.ImportReference(methodBaseDefinition.Methods.First(x => x.Name == "GetMethodFromHandle"));
var methodInfo = msCoreTypes.FirstOrDefault(x => x.Name == "MethodInfo");
MethodInfoTypeReference = module.ImportReference(methodInfo);
var compilerGeneratedDefinition = msCoreTypes.First(x => x.Name == "CompilerGeneratedAttribute");
CompilerGeneratedReference = module.ImportReference(compilerGeneratedDefinition.Methods.First(x => x.IsConstructor));
var systemCoreDefinition = GetSystemCoreDefinition();
var expressionTypeDefinition = systemCoreDefinition.MainModule.Types.First(x => x.Name == "Expression");
var propertyMethodDefinition =
expressionTypeDefinition.Methods.First(
x => x.Name == "Property" && x.Parameters.Last().ParameterType.Name == "MethodInfo");
PropertyReference = module.ImportReference(propertyMethodDefinition);
}
public GeneralStatePathRetriever(IAssemblyResolver resolver, Stream stream)
{
Module = ModuleDefinition.ReadModule(stream, new ReaderParameters()
{
AssemblyResolver = resolver
});
var sdkName = Module.AssemblyReferences.Single(a => a.Name.Split(",")[0] == "AElf.Sdk.CSharp");
Sdk = resolver.Resolve(sdkName).MainModule;
var aelfCommonName = Module.AssemblyReferences.Single(a => a.Name.Split(",")[0] == "AElf.Common");
AelfCommon = resolver.Resolve(aelfCommonName).MainModule;
AddressType = AelfCommon.GetType("AElf.Common.Address");
IContext = Sdk.GetType("AElf.Sdk.CSharp.IContext");
StateBase = Sdk.GetType("AElf.Sdk.CSharp.State.StateBase");
ContractStateBase = Sdk.GetType("AElf.Sdk.CSharp.State.ContractState");
ContractBase = Sdk.GetType("AElf.Sdk.CSharp.CSharpSmartContract");
SingletonStateBase = Sdk.GetType("AElf.Sdk.CSharp.State.SingletonState");
StructuredStateBase = Sdk.GetType("AElf.Sdk.CSharp.State.StructuredState");
MappedStateBase = Sdk.GetType("AElf.Sdk.CSharp.State.MappedStateBase");
ContractReferenceStateBase = Sdk.GetType("AElf.Sdk.CSharp.State.ContractReferenceState");
PropertyMethodIndex = new PropertyMethodIndex(Module.Types.Where(x => x.IsSubclassOf(StateBase))
.SelectMany(s => s.Properties));
}
public virtual TypeDefinition Resolve(TypeReference type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
type = type.GetElementType();
var scope = type.Scope;
if (scope == null)
{
return(null);
}
switch (scope.MetadataScopeType)
{
case MetadataScopeType.AssemblyNameReference:
var asNameRef = (AssemblyNameReference)scope;
var assembly = assembly_resolver.Resolve((AssemblyNameReference)scope);
if (assembly == null)
{
return(null);
}
var r = GetType(assembly.MainModule, type);
return(r);
case MetadataScopeType.ModuleDefinition:
return(GetType((ModuleDefinition)scope, type));
case MetadataScopeType.ModuleReference:
var modules = type.Module.Assembly.Modules;
var module_ref = (ModuleReference)scope;
for (int i = 0; i < modules.Count; i++)
{
var netmodule = modules [i];
if (netmodule.Name == module_ref.Name)
{
return(GetType(netmodule, type));
}
}
break;
}
throw new NotSupportedException();
}
static void MarkAsProcessed(AssemblyDefinition assembly, IAssemblyResolver resolver)
{
TypeDefinition generatedCodeAttribute = resolver.Resolve(AssemblyNameReference.Parse(typeof(GeneratedCodeAttribute).Assembly.GetName().Name)).MainModule.GetType(typeof(GeneratedCodeAttribute).FullName);
MethodDefinition constructor = generatedCodeAttribute.Methods.Single(a => a.IsConstructor && a.Parameters.Count == 2);
TypeReference stringType = assembly.MainModule.TypeSystem.String;
assembly.CustomAttributes.Add(new CustomAttribute(assembly.MainModule.ImportReference(constructor))
{
ConstructorArguments =
{
new CustomAttributeArgument(stringType, "SignumTask"),
new CustomAttributeArgument(stringType, typeof(Program).Assembly.GetName().Version.ToString()),
}
});
}
/// <summary>
/// Finds and returns an <see cref="AssemblyDef"/>
/// </summary>
/// <param name="self">this</param>
/// <param name="assembly">The assembly to find</param>
/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
public static AssemblyDef ResolveThrow(this IAssemblyResolver self, IAssembly assembly, ModuleDef sourceModule)
{
if (assembly == null)
{
return(null);
}
var asm = self.Resolve(assembly, sourceModule);
if (asm != null)
{
return(asm);
}
// throw new AssemblyResolveException(string.Format("Could not resolve assembly: {0}", assembly));
return(null);
}
/// <summary>
/// Tries the load the referenced assembly.
/// </summary>
/// <param name="assemblyResolver">The assembly resolver.</param>
/// <param name="assemblyNameReference">The assembly name reference.</param>
/// <param name="source">The source.</param>
/// <param name="logging">The logging.</param>
/// <param name="directReference">if set to <c>true</c> [direct reference].</param>
/// <returns></returns>
private static AssemblyDef TryLoad(IAssemblyResolver assemblyResolver, AssemblyRef assemblyNameReference, ModuleDef source, ILogging logging, bool directReference)
{
try
{
logging.WriteDebug("TryLoad '{0}' from '{1}'", assemblyNameReference.FullName, source.FullName);
var assemblyDef = assemblyResolver.Resolve(assemblyNameReference, source);
if (assemblyDef == null && directReference)
{
logging.WriteWarning("Can't load '{0}'", assemblyNameReference.FullName);
}
return(assemblyDef);
}
catch (FileNotFoundException)
{ }
logging.WriteError("Failed loading '{0}'", assemblyNameReference.FullName);
return(null);
}
public void Execute()
{
FreezableType = moduleDefinition.Types.FirstOrDefault(x => x.Name == "IFreezable");
if (FreezableType != null)
{
return;
}
foreach (var reference in moduleDefinition.AssemblyReferences)
{
var mainModule = assemblyResolver.Resolve(reference).MainModule;
FreezableType = mainModule.Types.FirstOrDefault(x => x.Name == "IFreezable");
if (FreezableType != null)
{
return;
}
}
}
public static TypeDefinition ResolveType(string type, ICustomAttributeProvider provider, IAssemblyResolver resolver)
{
if (provider == null)
{
throw new ArgumentException("Type resolution support requires an AssemblyDefinition or TypeDefinition.", "provider");
}
if (resolver == null)
{
throw new ArgumentException("Type resolution support requires a IAssemblyResolver.", "resolver");
}
// `type` is either a "bare" type "Foo.Bar", or an
// assembly-qualified type "Foo.Bar, AssemblyName [Version=...]?".
//
// Bare types are looked up via `provider`; assembly-qualified types are
// looked up via `resolver`
int c = type.IndexOf(',');
string typeName = c < 0 ? type : type.Substring(0, c);
string assmName = c < 0 ? null : type.Substring(c + 1);
var assmNameRef = AssemblyNameReference.Parse(assmName);
var assembly = assmName == null ? null : resolver.Resolve(assmNameRef);
if (assembly == null)
{
assembly = provider as AssemblyDefinition;
if (assembly == null)
{
TypeDefinition decl = (TypeDefinition)provider;
assembly = decl.Module.Assembly;
}
}
var ret = assembly.Modules.Cast <ModuleDefinition> ()
.Select(md => md.Types.FirstOrDefault(t => t.FullName == typeName))
.FirstOrDefault(td => td != null);
if (ret == null)
{
throw new ArgumentException("Type not found: " + type, "type");
}
return(ret);
}
private static IEnumerable <ModuleDef> ResolveAllAssembly(IEnumerable <ModuleDef> dllList, IAssemblyResolver resolver)
{
List <ModuleDef> defs = new List <ModuleDef>();
var moduleDefs = dllList.ToList();
while (moduleDefs.Any())
{
var moduleDef = moduleDefs[0];
moduleDefs.RemoveAt(0);
if (defs.Any(e => e.Name == moduleDef.Name && e.Assembly.Version == moduleDef.Assembly.Version))
{
continue;
}
defs.Add(moduleDef);
moduleDefs.AddRange(moduleDef.GetAssemblyRefs().Select(e => resolver.Resolve(e, moduleDef)?.ManifestModule).Where(e => e != null));
}
return(defs);
}
private static void RegisterDefaultSerializationProfile(IAssemblyResolver assemblyResolver, AssemblyDefinition assembly, ComplexSerializerCodeGenerator generator)
{
var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly);
if (mscorlibAssembly == null)
{
Console.WriteLine("Missing mscorlib.dll from assembly {0}", assembly.FullName);
throw new InvalidOperationException("Missing mscorlib.dll from assembly");
}
var coreSerializationAssembly = assemblyResolver.Resolve("SiliconStudio.Core");
// Register serializer factories (determine which type requires which serializer)
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(IList<>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.ListInterfaceSerializer`1")));
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(List<>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.ListSerializer`1")));
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(KeyValuePair<,>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.KeyValuePairSerializer`2")));
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(IDictionary<,>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.DictionaryInterfaceSerializer`2")));
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(Dictionary<,>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.DictionarySerializer`2")));
generator.SerializerFactories.Add(new CecilGenericSerializerFactory(typeof(Nullable<>), coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.NullableSerializer`1")));
generator.SerializerFactories.Add(new CecilEnumSerializerFactory(coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.EnumSerializer`1")));
generator.SerializerFactories.Add(new CecilArraySerializerFactory(coreSerializationAssembly.MainModule.GetTypeResolved("SiliconStudio.Core.Serialization.Serializers.ArraySerializer`1")));
// Iterate over tuple size
for (int i = 1; i <= 4; ++i)
{
generator.SerializerDependencies.Add(new CecilSerializerDependency(
string.Format("System.Tuple`{0}", i),
coreSerializationAssembly.MainModule.GetTypeResolved(string.Format("SiliconStudio.Core.Serialization.Serializers.TupleSerializer`{0}", i))));
generator.SerializerDependencies.Add(new CecilSerializerDependency(string.Format("SiliconStudio.Core.Serialization.Serializers.TupleSerializer`{0}", i)));
}
// Register serializer dependencies (determine which serializer serializes which sub-type)
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.ArraySerializer`1"));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.KeyValuePairSerializer`2"));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.ListSerializer`1"));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.ListInterfaceSerializer`1"));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.NullableSerializer`1"));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.DictionarySerializer`2",
mscorlibAssembly.MainModule.GetTypeResolved(typeof(KeyValuePair<,>).FullName)));
generator.SerializerDependencies.Add(new CecilSerializerDependency("SiliconStudio.Core.Serialization.Serializers.DictionaryInterfaceSerializer`2",
mscorlibAssembly.MainModule.GetTypeResolved(typeof(KeyValuePair<,>).FullName)));
}
public TypeFinder(IAssemblyResolver assemblyResolver, ModuleDefinition moduleDefinition)
{
this.moduleDefinition = moduleDefinition;
var msCoreLibDefinition = assemblyResolver.Resolve("mscorlib");
msCoreTypes = msCoreLibDefinition.MainModule.Types;
}
public static TypeDefinition ResolveTypeReference(TypeReference typeReference, IAssemblyResolver assemblyResolver, bool throwIfNotResolved)
{
TypeDefinition definition = typeReference as TypeDefinition;
if (definition != null)
{
return definition;
}
ArrayType arrayType = typeReference as ArrayType;
if (arrayType != null)
{
return ResolveTypeReference(arrayType, assemblyResolver, throwIfNotResolved);
}
// TODO: Use a weak reference cache here
IMetadataScope metadataScope = typeReference.Scope;
// check referenced assemblies
AssemblyNameReference assemblyNameReference = metadataScope as AssemblyNameReference;
if (assemblyNameReference != null)
{
AssemblyDefinition assemblyDefinition;
// module could be null, so check scope
if (typeReference.Module == null)
{
assemblyDefinition = assemblyResolver.Resolve(assemblyNameReference);
}
else
{
assemblyDefinition = typeReference.Module.Assembly.Resolver.Resolve(assemblyNameReference);
}
foreach (ModuleDefinition moduleDefinition in assemblyDefinition.Modules)
{
TypeDefinition ret = findTypeDefinition(typeReference, moduleDefinition.Types);
if (ret != null)
{
return ret;
}
}
}
ModuleDefinition moduleDefinition2 = metadataScope as ModuleDefinition;
if (moduleDefinition2 != null)
{
TypeDefinition ret = findTypeDefinition(typeReference, moduleDefinition2.Types);
if (ret != null)
{
return ret;
}
}
if (metadataScope == null)
{
// corlib?
moduleDefinition2 = CoreTypes.Corlib.MainModule;
TypeDefinition ret = findTypeDefinition(typeReference, moduleDefinition2.Types);
if (ret != null)
{
return ret;
}
}
if (throwIfNotResolved)
{
throw new CompilerException("Unable to resolve type reference: " + typeReference);
}
else
{
return null;
}
}
private static AssemblyDefinition SafeResolveBridge(IAssemblyResolver resolver)
{
try
{
return resolver.Resolve("SyntaxTree.VisualStudio.Unity.Bridge", new ReaderParameters { AssemblyResolver = resolver });
}
catch (AssemblyResolutionException)
{
return null;
}
}
/// <summary>
/// Resolves the common Stiletto assembly, loads it into memory, and
/// extracts types and methods so they can be imported into woven
/// modules.
/// </summary>
/// <param name="assemblyResolver">
/// The <see cref="IAssemblyResolver"/> instance provided by Fody.
/// </param>
/// <returns>
/// Returns a selection of relevant types and methods from Stiletto.
/// </returns>
public static StilettoReferences Create(IAssemblyResolver assemblyResolver)
{
var stiletto = assemblyResolver.Resolve("Stiletto").MainModule;
var types = stiletto
.GetAllTypes()
.Where(t => t.IsPublic)
.ToDictionary(t => t.FullName, t => t, StringComparer.Ordinal);
var tBinding = types["Stiletto.Internal.Binding"];
var tBinding_ctor = tBinding.GetMethod(".ctor");
var tBinding_GetDependencies = tBinding.GetMethod("GetDependencies");
var tBinding_Resolve = tBinding.GetMethod("Resolve");
var tBinding_Get = tBinding.GetMethod("Get");
var tBinding_InjectProperties = tBinding.GetMethod("InjectProperties");
var tBinding_RequiredBy_Getter = tBinding.GetProperty("RequiredBy").GetMethod;
var tBinding_IsLibrary_Setter = tBinding.GetProperty("IsLibrary").SetMethod;
var tProviderMethodBindingBase = types["Stiletto.Internal.ProviderMethodBindingBase"];
var tProviderMethodBingingBase_ctor = tProviderMethodBindingBase.GetMethod(".ctor");
var tRuntimeModule = types["Stiletto.Internal.RuntimeModule"];
var tRuntimeModule_ctor = tRuntimeModule.GetMethod(".ctor");
var tRuntimeModule_module_getter = tRuntimeModule.GetProperty("Module").GetMethod;
var tContainer = types["Stiletto.Container"];
var tContainer_Create = tContainer.GetMethod("Create");
var tContainer_CreateWithPlugins = tContainer.GetMethod("CreateWithPlugins");
var tPlugin = types["Stiletto.Internal.IPlugin"];
var tPlugin_GetInjectBinding = tPlugin.GetMethod("GetInjectBinding");
var tPlugin_GetLazyInjectBinding = tPlugin.GetMethod("GetLazyInjectBinding");
var tPlugin_GetProviderInjectBinding = tPlugin.GetMethod("GetIProviderInjectBinding");
var tPlugin_GetRuntimeModule = tPlugin.GetMethod("GetRuntimeModule");
var tResolver = types["Stiletto.Internal.Resolver"];
var tResolver_RequestBinding = tResolver.GetMethod("RequestBinding");
var tProviderOfT = types["Stiletto.IProvider`1"];
var tProviderOfT_Get = tProviderOfT.GetMethod("Get");
var tInjectAttribute = types["Stiletto.InjectAttribute"];
var tModuleAttribute = types["Stiletto.ModuleAttribute"];
var tProvidesAttribute = types["Stiletto.ProvidesAttribute"];
var tNamedAttribute = types["Stiletto.NamedAttribute"];
var tSingletonAttribute = types["Stiletto.SingletonAttribute"];
var tProcessedAssemblyAttribute = types["Stiletto.Internal.Plugins.Codegen.ProcessedAssemblyAttribute"];
var tProcessedAssemblyAttribute_Ctor = tProcessedAssemblyAttribute.GetDefaultConstructor();
return new StilettoReferences
{
Binding = tBinding,
Binding_Ctor = tBinding_ctor,
Binding_GetDependencies = tBinding_GetDependencies,
Binding_Resolve = tBinding_Resolve,
Binding_Get = tBinding_Get,
Binding_InjectProperties = tBinding_InjectProperties,
Binding_RequiredBy_Getter = tBinding_RequiredBy_Getter,
Binding_IsLibrary_Setter = tBinding_IsLibrary_Setter,
ProviderMethodBindingBase = tProviderMethodBindingBase,
ProviderMethodBindingBase_Ctor = tProviderMethodBingingBase_ctor,
RuntimeModule = tRuntimeModule,
RuntimeModule_Ctor = tRuntimeModule_ctor,
RuntimeModule_Module_Getter = tRuntimeModule_module_getter,
Container = tContainer,
Container_Create = tContainer_Create,
Container_CreateWithPlugins = tContainer_CreateWithPlugins,
IPlugin = tPlugin,
IPlugin_GetInjectBinding = tPlugin_GetInjectBinding,
IPlugin_GetLazyInjectBinding = tPlugin_GetLazyInjectBinding,
IPlugin_GetIProviderInjectBinding = tPlugin_GetProviderInjectBinding,
IPlugin_GetRuntimeModue = tPlugin_GetRuntimeModule,
Resolver = tResolver,
Resolver_RequestBinding = tResolver_RequestBinding,
IProviderOfT = tProviderOfT,
IProviderOfT_Get = tProviderOfT_Get,
InjectAttribute = tInjectAttribute,
ModuleAttribute = tModuleAttribute,
ProvidesAttribute = tProvidesAttribute,
NamedAttribute = tNamedAttribute,
SingletonAttribute = tSingletonAttribute,
ProcessedAssemblyAttribute = tProcessedAssemblyAttribute,
ProcessedAssemblyAttribute_Ctor = tProcessedAssemblyAttribute_Ctor
};
}
