/// <summary>
/// The compiling process is closely related to the rollback process. When the initial compilation fails, the rollback process will be executed.
/// </summary>
/// <param name="syntaxTrees">The syntaxtrees to compile</param>
/// <param name="ms">The memory stream to store the compilation result onto</param>
public CompilingProcessResult Compile(IEnumerable <SyntaxTree> syntaxTrees, MemoryStream ms)
{
var compiler = CSharpCompilation.Create(_input.ProjectInfo.ProjectUnderTestAssemblyName,
syntaxTrees: syntaxTrees,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
references: _input.AssemblyReferences);
RollbackProcessResult rollbackProcessResult = null;
// first try compiling
var emitResult = compiler.Emit(ms);
if (!emitResult.Success)
{
LogEmitResult(emitResult);
// remove broken mutations
rollbackProcessResult = _rollbackProcess.Start(compiler, emitResult.Diagnostics);
// reset the memoryStream for the second compilation
ms.SetLength(0);
// second try compiling
emitResult = rollbackProcessResult.Compilation.Emit(ms);
}
LogEmitResult(emitResult);
return(new CompilingProcessResult()
{
Success = emitResult.Success,
RollbackResult = rollbackProcessResult
});
}
private (RollbackProcessResult, EmitResult, int) TryCompilation(
MemoryStream ms,
CSharpCompilation compilation,
EmitResult previousEmitResult,
bool lastAttempt,
bool devMode,
int retryCount)
{
RollbackProcessResult rollbackProcessResult = null;
if (previousEmitResult != null)
{
// remove broken mutations
rollbackProcessResult = _rollbackProcess.Start(compilation, previousEmitResult.Diagnostics, lastAttempt, devMode);
compilation = rollbackProcessResult.Compilation;
}
// reset the memoryStream
ms.SetLength(0);
_logger.LogDebug($"Trying compilation for the {ReadableNumber(retryCount)} time.");
var emitResult = compilation.Emit(
ms,
manifestResources: _input.ProjectInfo.ProjectUnderTestAnalyzerResult.Resources,
win32Resources: compilation.CreateDefaultWin32Resources(
versionResource: true, // Important!
noManifest: false,
manifestContents: null,
iconInIcoFormat: null));
LogEmitResult(emitResult);
return(rollbackProcessResult, emitResult, ++retryCount);
}
public CompilingProcessResult Compile(IEnumerable <ParsedInput> syntaxTrees, bool devMode)
{
var analyzerResult = _input.ProjectInfo.ProjectUnderTestAnalyzerResult;
FSharpList <ParsedInput> trees = ListModule.OfSeq(syntaxTrees.Reverse());
FSharpList <string> dependencies = ListModule.OfSeq(analyzerResult.References);
//we need a checker if we want to compile
var checker = FSharpChecker.Create(projectCacheSize: null, keepAssemblyContents: null, keepAllBackgroundResolutions: null, legacyReferenceResolver: null, tryGetMetadataSnapshot: null, suggestNamesForErrors: null, keepAllBackgroundSymbolUses: null, enableBackgroundItemKeyStoreAndSemanticClassification: null);
var pathlist = new List <string>();
var pdblist = new List <string>();
foreach (var testProject in _input.ProjectInfo.TestProjectAnalyzerResults)
{
var injectionPath = _input.ProjectInfo.GetInjectionFilePath(testProject);
if (!_fileSystem.Directory.Exists(injectionPath.Substring(0, injectionPath.LastIndexOf('\\'))))
{
_fileSystem.Directory.CreateDirectory(injectionPath);
}
pathlist.Add(Path.Combine(injectionPath, _input.ProjectInfo.GetInjectionFilePath(testProject)));
pdblist.Add(Path.Combine(injectionPath,
_input.ProjectInfo.ProjectUnderTestAnalyzerResult.GetSymbolFileName()));
_logger.LogDebug("Injected the mutated assembly file into {0}", injectionPath);
}
if (!pathlist.Any())
{
throw new GeneralStrykerException("Could not find project under test.");
}
//rollback still needs to be implemented
RollbackProcessResult rollbackProcessResult = null;
(var compilationSucces, FSharpErrorInfo[] errorinfo) = TryCompilation(checker, trees, pathlist, dependencies);
if (compilationSucces)
{
//we return if compiled succesfully
//it is however not used as this is the end of the current F# implementation
return(new CompilingProcessResult()
{
Success = compilationSucces,
RollbackResult = rollbackProcessResult
});
}
// compiling failed
_logger.LogError("Failed to restore the project to a buildable state. Please report the issue. Stryker can not proceed further");
throw new CompilationException("Failed to restore build able state.");
}
/// <summary>
/// The compiling process is closely related to the rollback process. When the initial compilation fails, the rollback process will be executed.
/// </summary>
/// <param name="syntaxTrees">The syntaxtrees to compile</param>
/// <param name="ms">The memory stream to store the compilation result onto</param>
/// <param name="devMode"></param>
public CompilingProcessResult Compile(IEnumerable <SyntaxTree> syntaxTrees, MemoryStream ms, bool devMode)
{
var analyzerResult = _input.ProjectInfo.ProjectUnderTestAnalyzerResult;
var compiler = CSharpCompilation.Create(analyzerResult.Properties.GetValueOrDefault("TargetName"),
syntaxTrees: syntaxTrees,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
allowUnsafe: true,
cryptoKeyFile: analyzerResult.SignAssembly ? analyzerResult.AssemblyOriginatorKeyFile : null,
strongNameProvider: analyzerResult.SignAssembly ? new DesktopStrongNameProvider() : null),
references: _input.AssemblyReferences);
RollbackProcessResult rollbackProcessResult = null;
// first try compiling
var emitResult = compiler.Emit(ms, manifestResources: analyzerResult.Resources);
if (!emitResult.Success)
{
// second try compiling
(rollbackProcessResult, emitResult) = RetryCompilation(ms, compiler, emitResult, devMode);
}
if (!emitResult.Success)
{
// third try compiling
(rollbackProcessResult, emitResult) = RetryCompilation(ms, rollbackProcessResult.Compilation, emitResult, devMode);
}
LogEmitResult(emitResult);
if (!emitResult.Success)
{
// compiling failed
_logger.LogError("Failed to restore the project to a buildable state. Please report the issue. Stryker can not proceed further");
foreach (var emitResultDiagnostic in emitResult.Diagnostics)
{
_logger.LogWarning($"{emitResultDiagnostic}");
}
throw new ApplicationException("Failed to restore build able state.");
}
return(new CompilingProcessResult()
{
Success = emitResult.Success,
RollbackResult = rollbackProcessResult
});
}
/// <summary>
/// The compiling process is closely related to the rollback process. When the initial compilation fails, the rollback process will be executed.
/// </summary>
/// <param name="syntaxTrees">The syntaxtrees to compile</param>
/// <param name="ms">The memory stream to store the compilation result onto</param>
/// <param name="devMode"></param>
public CompilingProcessResult Compile(IEnumerable <SyntaxTree> syntaxTrees, MemoryStream ms, bool devMode)
{
var analyzerResult = _input.ProjectInfo.ProjectUnderTestAnalyzerResult;
// Set assembly and file info
AddVersionInfoSyntaxes(syntaxTrees, analyzerResult);
var compilation = CSharpCompilation.Create(analyzerResult.Properties.GetValueOrDefault("TargetName"),
syntaxTrees: syntaxTrees,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
allowUnsafe: true,
cryptoKeyFile: analyzerResult.SignAssembly ? analyzerResult.AssemblyOriginatorKeyFile : null,
strongNameProvider: analyzerResult.SignAssembly ? new DesktopStrongNameProvider() : null),
references: _input.AssemblyReferences);
RollbackProcessResult rollbackProcessResult = null;
// first try compiling
EmitResult emitResult = null;
int retryCount = 1;
(rollbackProcessResult, emitResult, retryCount) = TryCompilation(ms, compilation, null, devMode, retryCount);
for (var count = 1; !emitResult.Success && count < 50; count++)
{
// compilation did not succeed. let's compile a couple times more for good measure
(rollbackProcessResult, emitResult, retryCount) = TryCompilation(ms, rollbackProcessResult?.Compilation ?? compilation, emitResult, devMode, retryCount);
}
if (!emitResult.Success)
{
// compiling failed
_logger.LogError("Failed to restore the project to a buildable state. Please report the issue. Stryker can not proceed further");
foreach (var emitResultDiagnostic in emitResult.Diagnostics)
{
_logger.LogWarning($"{emitResultDiagnostic}");
}
throw new ApplicationException("Failed to restore build able state.");
}
return(new CompilingProcessResult()
{
Success = emitResult.Success,
RollbackResult = rollbackProcessResult
});
}
private (RollbackProcessResult, EmitResult, int) TryCompilation(
Stream ms,
Stream symbolStream,
CSharpCompilation compilation,
EmitResult previousEmitResult,
bool lastAttempt,
bool devMode,
int retryCount)
{
RollbackProcessResult rollbackProcessResult = null;
if (previousEmitResult != null)
{
// remove broken mutations
rollbackProcessResult = _rollbackProcess.Start(compilation, previousEmitResult.Diagnostics, lastAttempt, devMode);
compilation = rollbackProcessResult.Compilation;
}
// reset the memoryStream
ms.SetLength(0);
symbolStream?.SetLength(0);
_logger.LogDebug($"Trying compilation for the {ReadableNumber(retryCount)} time.");
var emitOptions = symbolStream == null ? null : new EmitOptions(false, DebugInformationFormat.PortablePdb,
_input.ProjectInfo.ProjectUnderTestAnalyzerResult.GetSymbolFileName());
var emitResult = compilation.Emit(
ms,
symbolStream,
manifestResources: _input.ProjectInfo.ProjectUnderTestAnalyzerResult.GetResources(_logger),
win32Resources: compilation.CreateDefaultWin32Resources(
true, // Important!
false,
null,
null),
options: emitOptions);
LogEmitResult(emitResult);
return(rollbackProcessResult, emitResult, ++retryCount);
}
/// <summary>
/// The compiling process is closely related to the rollback process. When the initial compilation fails, the rollback process will be executed.
/// </summary>
/// <param name="syntaxTrees">The syntaxtrees to compile</param>
/// <param name="ms">The memory stream to store the compilation result onto</param>
/// <param name="devMode"></param>
public CompilingProcessResult Compile(IEnumerable <SyntaxTree> syntaxTrees, MemoryStream ms, bool devMode)
{
var compiler = CSharpCompilation.Create(_input.ProjectInfo.ProjectUnderTestAssemblyName,
syntaxTrees: syntaxTrees,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true),
references: _input.AssemblyReferences);
RollbackProcessResult rollbackProcessResult = null;
// first try compiling
var emitResult = compiler.Emit(ms);
if (!emitResult.Success)
{
// second try compiling
(rollbackProcessResult, emitResult) = RetryCompilation(ms, compiler, emitResult, devMode);
}
if (!emitResult.Success)
{
// third try compiling
(rollbackProcessResult, emitResult) = RetryCompilation(ms, rollbackProcessResult.Compilation, emitResult, devMode);
}
LogEmitResult(emitResult);
if (!emitResult.Success)
{
// compiling failed
_logger.LogError("Failed to restore the project to a buildable state. Please report the issue. Stryker can not proceed further");
foreach (var emitResultDiagnostic in emitResult.Diagnostics)
{
_logger.LogWarning($"{emitResultDiagnostic}");
}
throw new ApplicationException("Failed to restore build able state.");
}
return(new CompilingProcessResult()
{
Success = emitResult.Success,
RollbackResult = rollbackProcessResult
});
}
/// <summary>
/// The compiling process is closely related to the rollback process. When the initial compilation fails, the rollback process will be executed.
/// </summary>
/// <param name="syntaxTrees">The syntaxtrees to compile</param>
/// <param name="ms">The memory stream to store the compilation result onto</param>
/// <param name="devMode"></param>
public CompilingProcessResult Compile(IEnumerable <SyntaxTree> syntaxTrees, MemoryStream ms, bool devMode)
{
var compiler = CSharpCompilation.Create(_input.ProjectInfo.ProjectUnderTestAssemblyName,
syntaxTrees: syntaxTrees,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
references: _input.AssemblyReferences);
RollbackProcessResult rollbackProcessResult = null;
// first try compiling
var emitResult = compiler.Emit(ms);
if (!emitResult.Success)
{
LogEmitResult(emitResult);
// remove broken mutations
rollbackProcessResult = _rollbackProcess.Start(compiler, emitResult.Diagnostics, devMode);
// reset the memoryStream for the second compilation
ms.SetLength(0);
// second try compiling
emitResult = rollbackProcessResult.Compilation.Emit(ms);
}
LogEmitResult(emitResult);
if (!emitResult.Success)
{
_logger.LogError("Failed to restore the project to a buildable state. Please report the issue. Stryker can not proceed further");
throw new ApplicationException("Failed to restore build able state.");
}
return(new CompilingProcessResult()
{
Success = emitResult.Success,
RollbackResult = rollbackProcessResult
});
}
