private static async Task <Result> buildAndWeave(string outputFile, string[] sourceFiles)
{
var weaverLog = new WeaverLogger();
var assembler = new Assembler(outputFile, sourceFiles);
var assembly = await assembler.BuildAsync(weaverLog);
return(new Result(weaverLog, assembly, assembler));
}
public void should_log_warnings_and_errors()
{
var log = new WeaverLogger(_log, new WeaverConfigOptions());
var sequencePoint = new SequencePoint(Instruction.Create(OpCodes.Nop), new Document(""));
log.Warning("Foo", null);
log.Warning("Bar", sequencePoint);
log.Error("Baz", null);
log.Error("Hello", sequencePoint);
_log.LoggedDebug.ShouldBeEmpty();
_log.LoggedInfos.ShouldBeEmpty();
_log.LoggedWarnings.ShouldEqual(new[]
public void should_log_debug_and_info()
{
var log = new WeaverLogger(_log, new WeaverConfigOptions());
log.Debug("Foo");
log.Debug("Bar");
log.Info("Baz");
_log.LoggedDebug.ShouldEqual(new[] { "Foo", "Bar" });
_log.LoggedInfos.ShouldEqual(new[] { "Baz" });
_log.LoggedWarnings.ShouldBeEmpty();
_log.LoggedErrors.ShouldBeEmpty();
}
public override void Execute()
{
var configOptions = new WeaverConfigOptions(Config);
var config = new WeaverConfig(configOptions, ModuleDefinition);
var context = new ModuleWeavingContext(ModuleDefinition, config);
var weaverLog = new WeaverLogger(_log, configOptions);
foreach (var type in ModuleDefinition.GetTypes())
{
foreach (var method in type.Methods)
{
try
{
if (!MethodWeaver.NeedsProcessing(context, method))
{
continue;
}
_log.Debug($"Processing: {method.FullName}");
new MethodWeaver(context, method, weaverLog).Process();
}
catch (WeavingException ex)
{
AddError(ex.Message, ex.SequencePoint);
InvalidateMethod(method, ex.Message);
}
}
if (type.IsInlineILTypeUsageDeep(context))
{
AddError($"Reference to InlineIL found in type {type.FullName}. InlineIL should not be referenced in attributes/constraints, as its assembly reference will be removed.", null);
}
}
RemoveLibReference(context);
}
public override void Execute()
{
InternalLogDebug = (s, l) => LogDebug(s);
Logger = new WeaverLogger(this);
try
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
Logger.Debug($"Starting AutoDI Weaver v{GetType().Assembly.GetCustomAttribute<AssemblyVersionAttribute>()?.Version}", DebugLogLevel.Default);
var typeResolver = new TypeResolver(ModuleDefinition, ModuleDefinition.AssemblyResolver, Logger);
Settings settings = LoadSettings(typeResolver);
if (settings == null)
{
return;
}
ICollection <TypeDefinition> allTypes = typeResolver.GetAllTypes(settings, out AssemblyDefinition autoDIAssembly);
Logger.Debug($"Found types:\r\n{string.Join("\r\n", allTypes.Select(x => x.FullName))}", DebugLogLevel.Verbose);
if (autoDIAssembly == null)
{
autoDIAssembly = ResolveAssembly("AutoDI");
if (autoDIAssembly == null)
{
Logger.Warning("Could not find AutoDI assembly");
return;
}
else
{
Logger.Warning($"Failed to find AutoDI assembly. Manually injecting '{autoDIAssembly.MainModule.FileName}'");
}
}
LoadRequiredData();
ICodeGenerator gen = GetCodeGenerator(settings);
if (settings.GenerateRegistrations)
{
Mapping mapping = Mapping.GetMapping(settings, allTypes, Logger);
Logger.Debug($"Found potential map:\r\n{mapping}", DebugLogLevel.Verbose);
ModuleDefinition.Types.Add(GenerateAutoDIClass(mapping, settings, gen, out MethodDefinition initMethod));
if (settings.AutoInit)
{
InjectInitCall(initMethod);
}
}
else
{
Logger.Debug("Skipping registration", DebugLogLevel.Verbose);
}
//We only update types in our module
foreach (TypeDefinition type in allTypes.Where(type => type.Module == ModuleDefinition))
{
ProcessType(type, gen);
}
gen?.Save();
}
catch (Exception ex)
{
var sb = new StringBuilder();
for (Exception e = ex; e != null; e = e.InnerException)
{
sb.AppendLine(e.ToString());
}
Logger.Error(sb.ToString());
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomainOnAssemblyResolve;
}
}