From 7f210b585a26ee2d3d5d3b2e4d552f235bef98dc Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Sat, 3 Mar 2018 17:07:34 +0100 Subject: [PATCH] Rename CompilerOptions to CSharpCompilerOptions and add Tester.CompileVB --- .../CorrectnessTestRunner.cs | 114 ++++++++-------- .../Helpers/Tester.VB.cs | 123 ++++++++++++++++++ .../Helpers/Tester.cs | 60 ++++----- .../ICSharpCode.Decompiler.Tests.csproj | 2 + .../PrettyTestRunner.cs | 100 +++++++------- .../UglyTestRunner.cs | 30 ++--- 6 files changed, 277 insertions(+), 152 deletions(-) create mode 100644 ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs diff --git a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs b/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs index 9a536cc67..21a35ce8e 100644 --- a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs @@ -46,146 +46,146 @@ namespace ICSharpCode.Decompiler.Tests } } - static readonly CompilerOptions[] noMonoOptions = + static readonly CSharpCompilerOptions[] noMonoOptions = { - CompilerOptions.None, - CompilerOptions.Optimize, - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn, + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize, + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn, }; - static readonly CompilerOptions[] defaultOptions = + static readonly CSharpCompilerOptions[] defaultOptions = { - CompilerOptions.None, - CompilerOptions.Optimize, - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn, - CompilerOptions.UseMcs, - CompilerOptions.Optimize | CompilerOptions.UseMcs + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize, + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.UseMcs, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs }; - static readonly CompilerOptions[] roslynOnlyOptions = + static readonly CSharpCompilerOptions[] roslynOnlyOptions = { - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn }; [Test] - public void Comparisons([ValueSource("defaultOptions")] CompilerOptions options) + public void Comparisons([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Conversions([ValueSource("defaultOptions")] CompilerOptions options) + public void Conversions([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void FloatingPointArithmetic([ValueSource("defaultOptions")] CompilerOptions options) + public void FloatingPointArithmetic([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void HelloWorld([ValueSource("defaultOptions")] CompilerOptions options) + public void HelloWorld([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void ControlFlow([ValueSource("defaultOptions")] CompilerOptions options) + public void ControlFlow([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void CompoundAssignment([ValueSource("defaultOptions")] CompilerOptions options) + public void CompoundAssignment([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions options) + public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Switch([ValueSource("defaultOptions")] CompilerOptions options) + public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Using([ValueSource("defaultOptions")] CompilerOptions options) + public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Loops([ValueSource("defaultOptions")] CompilerOptions options) + public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void NullableTests([ValueSource("defaultOptions")] CompilerOptions options) + public void NullableTests([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Generics([ValueSource("defaultOptions")] CompilerOptions options) + public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void ValueTypeCall([ValueSource("defaultOptions")] CompilerOptions options) + public void ValueTypeCall([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions options) + public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void DecimalFields([ValueSource("defaultOptions")] CompilerOptions options) + public void DecimalFields([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void UndocumentedExpressions([ValueSource("noMonoOptions")] CompilerOptions options) + public void UndocumentedExpressions([ValueSource("noMonoOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void MemberLookup([ValueSource("defaultOptions")] CompilerOptions options) + public void MemberLookup([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void OverloadResolution([ValueSource("defaultOptions")] CompilerOptions options) + public void OverloadResolution([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions options) + public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions options) + public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions options) { RunCS(options: options); } @@ -193,10 +193,10 @@ namespace ICSharpCode.Decompiler.Tests [Test] public void BitNot([Values(false, true)] bool force32Bit) { - CompilerOptions compiler = CompilerOptions.UseDebug; + CSharpCompilerOptions compiler = CSharpCompilerOptions.UseDebug; AssemblerOptions asm = AssemblerOptions.None; if (force32Bit) { - compiler |= CompilerOptions.Force32Bit; + compiler |= CSharpCompilerOptions.Force32Bit; asm |= AssemblerOptions.Force32Bit; } RunIL("BitNot.il", compiler, asm); @@ -211,79 +211,79 @@ namespace ICSharpCode.Decompiler.Tests [Test] public void StackTypes([Values(false, true)] bool force32Bit) { - CompilerOptions compiler = CompilerOptions.UseRoslyn | CompilerOptions.UseDebug; + CSharpCompilerOptions compiler = CSharpCompilerOptions.UseRoslyn | CSharpCompilerOptions.UseDebug; AssemblerOptions asm = AssemblerOptions.None; if (force32Bit) { - compiler |= CompilerOptions.Force32Bit; + compiler |= CSharpCompilerOptions.Force32Bit; asm |= AssemblerOptions.Force32Bit; } RunIL("StackTypes.il", compiler, asm); } [Test] - public void UnsafeCode([ValueSource("defaultOptions")] CompilerOptions options) + public void UnsafeCode([ValueSource("defaultOptions")] CSharpCompilerOptions options) { - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { Assert.Ignore("Decompiler bug with mono!"); } RunCS(options: options); } [Test] - public void ConditionalAttr([ValueSource("defaultOptions")] CompilerOptions options) + public void ConditionalAttr([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void TrickyTypes([ValueSource("defaultOptions")] CompilerOptions options) + public void TrickyTypes([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void Capturing([ValueSource("defaultOptions")] CompilerOptions options) + public void Capturing([ValueSource("defaultOptions")] CSharpCompilerOptions options) { RunCS(options: options); } [Test] - public void YieldReturn([ValueSource("defaultOptions")] CompilerOptions options) + public void YieldReturn([ValueSource("defaultOptions")] CSharpCompilerOptions options) { - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { Assert.Ignore("Decompiler bug with mono!"); } RunCS(options: options); } [Test] - public void Async([ValueSource("defaultOptions")] CompilerOptions options) + public void Async([ValueSource("defaultOptions")] CSharpCompilerOptions options) { - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { Assert.Ignore("Decompiler bug with mono!"); } RunCS(options: options); } [Test] - public void LINQRaytracer([ValueSource("defaultOptions")] CompilerOptions options) + public void LINQRaytracer([ValueSource("defaultOptions")] CSharpCompilerOptions options) { - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { Assert.Ignore("Decompiler bug with mono!"); } RunCS(options: options); } [Test] - public void MiniJSON([ValueSource("defaultOptions")] CompilerOptions options) + public void MiniJSON([ValueSource("defaultOptions")] CSharpCompilerOptions options) { - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { Assert.Ignore("Decompiler bug with mono!"); } RunCS(options: options); } - void RunCS([CallerMemberName] string testName = null, CompilerOptions options = CompilerOptions.UseDebug) + void RunCS([CallerMemberName] string testName = null, CSharpCompilerOptions options = CSharpCompilerOptions.UseDebug) { string testFileName = testName + ".cs"; string testOutputFileName = testName + Tester.GetSuffix(options) + ".exe"; @@ -293,12 +293,12 @@ namespace ICSharpCode.Decompiler.Tests outputFile = Tester.CompileCSharp(Path.Combine(TestCasePath, testFileName), options, outputFileName: Path.Combine(TestCasePath, testOutputFileName)); string decompiledCodeFile = Tester.DecompileCSharp(outputFile.PathToAssembly, Tester.GetSettings(options)); - if (options.HasFlag(CompilerOptions.UseMcs)) { + if (options.HasFlag(CSharpCompilerOptions.UseMcs)) { // For second pass, use roslyn instead of mcs. // mcs has some compiler bugs that cause it to not accept ILSpy-generated code, // for example when there's unreachable code due to other compiler bugs in the first mcs run. - options &= ~CompilerOptions.UseMcs; - options |= CompilerOptions.UseRoslyn; + options &= ~CSharpCompilerOptions.UseMcs; + options |= CSharpCompilerOptions.UseRoslyn; // Also, add an .exe.config so that we consistently use the .NET 4.x runtime. File.WriteAllText(outputFile.PathToAssembly + ".config", @" @@ -321,7 +321,7 @@ namespace ICSharpCode.Decompiler.Tests } } - void RunIL(string testFileName, CompilerOptions options = CompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None) + void RunIL(string testFileName, CSharpCompilerOptions options = CSharpCompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None) { string outputFile = null; CompilerResults decompiledOutputFile = null; diff --git a/ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs b/ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs new file mode 100644 index 000000000..8b766f17b --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs @@ -0,0 +1,123 @@ +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.VisualBasic; +using Microsoft.VisualBasic; + +namespace ICSharpCode.Decompiler.Tests.Helpers +{ + [Flags] + public enum VBCompilerOptions + { + None, + Optimize = 0x1, + UseDebug = 0x2, + Force32Bit = 0x4, + Library = 0x8, + UseRoslyn = 0x10, + } + + partial class Tester + { + internal static string GetSuffix(VBCompilerOptions vbcOptions) + { + string suffix = ""; + if ((vbcOptions & VBCompilerOptions.Optimize) != 0) + suffix += ".opt"; + if ((vbcOptions & VBCompilerOptions.Force32Bit) != 0) + suffix += ".32"; + if ((vbcOptions & VBCompilerOptions.UseDebug) != 0) + suffix += ".dbg"; + if ((vbcOptions & VBCompilerOptions.UseRoslyn) != 0) + suffix += ".roslyn"; + return suffix; + } + + public static List> GetPreprocessorSymbols(VBCompilerOptions flags) + { + var preprocessorSymbols = new List>(); + if (flags.HasFlag(VBCompilerOptions.UseDebug)) { + preprocessorSymbols.Add(new KeyValuePair("DEBUG", 1)); + } + if (flags.HasFlag(VBCompilerOptions.Optimize)) { + preprocessorSymbols.Add(new KeyValuePair("OPT", 1)); + } + if (flags.HasFlag(VBCompilerOptions.UseRoslyn)) { + preprocessorSymbols.Add(new KeyValuePair("ROSLYN", 1)); + preprocessorSymbols.Add(new KeyValuePair("VB11", 1)); + preprocessorSymbols.Add(new KeyValuePair("VB14", 1)); + preprocessorSymbols.Add(new KeyValuePair("VB15", 1)); + } else { + preprocessorSymbols.Add(new KeyValuePair("LEGACY_VBC", 1)); + } + return preprocessorSymbols; + } + + public static CompilerResults CompileVB(string sourceFileName, VBCompilerOptions flags = VBCompilerOptions.UseDebug, string outputFileName = null) + { + List sourceFileNames = new List { sourceFileName }; + foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) { + sourceFileNames.Add(Path.GetFullPath(Path.Combine(Path.GetDirectoryName(sourceFileName), match.Groups[1].Value))); + } + + var preprocessorSymbols = GetPreprocessorSymbols(flags); + + if (flags.HasFlag(VBCompilerOptions.UseRoslyn)) { + var parseOptions = new VisualBasicParseOptions(preprocessorSymbols: preprocessorSymbols, languageVersion: LanguageVersion.Latest); + var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f)); + var compilation = VisualBasicCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName), + syntaxTrees, defaultReferences.Value, + new VisualBasicCompilationOptions( + flags.HasFlag(VBCompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication, + platform: flags.HasFlag(VBCompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu, + optimizationLevel: flags.HasFlag(VBCompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug, + deterministic: true + )); + CompilerResults results = new CompilerResults(new TempFileCollection()); + results.PathToAssembly = outputFileName ?? Path.GetTempFileName(); + var emitResult = compilation.Emit(results.PathToAssembly); + if (!emitResult.Success) { + StringBuilder b = new StringBuilder("Compiler error:"); + foreach (var diag in emitResult.Diagnostics) { + b.AppendLine(diag.ToString()); + } + throw new Exception(b.ToString()); + } + return results; + } else { + var provider = new VBCodeProvider(new Dictionary { { "CompilerVersion", "v10.0" } }); + CompilerParameters options = new CompilerParameters(); + options.GenerateExecutable = !flags.HasFlag(VBCompilerOptions.Library); + options.CompilerOptions = "/o" + (flags.HasFlag(VBCompilerOptions.Optimize) ? "+" : "-"); + options.CompilerOptions += (flags.HasFlag(VBCompilerOptions.UseDebug) ? " /debug" : ""); + options.CompilerOptions += (flags.HasFlag(VBCompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : ""); + if (preprocessorSymbols.Count > 0) { + options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols); + } + if (outputFileName != null) { + options.OutputAssembly = outputFileName; + } + + options.ReferencedAssemblies.Add("System.dll"); + options.ReferencedAssemblies.Add("System.Core.dll"); + options.ReferencedAssemblies.Add("System.Xml.dll"); + CompilerResults results = provider.CompileAssemblyFromFile(options, sourceFileNames.ToArray()); + if (results.Errors.Cast().Any(e => !e.IsWarning)) { + StringBuilder b = new StringBuilder("Compiler error:"); + foreach (var error in results.Errors) { + b.AppendLine(error.ToString()); + } + throw new Exception(b.ToString()); + } + return results; + } + } + + } +} diff --git a/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs b/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs index 3bb260dc2..67023233a 100644 --- a/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs +++ b/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs @@ -40,7 +40,7 @@ using NUnit.Framework; namespace ICSharpCode.Decompiler.Tests.Helpers { [Flags] - public enum CompilerOptions + public enum CSharpCompilerOptions { None, Optimize = 0x1, @@ -50,7 +50,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers UseRoslyn = 0x10, UseMcs = 0x20, } - + [Flags] public enum AssemblerOptions { @@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers UseOwnDisassembler = 0x8, } - public static class Tester + public static partial class Tester { public static string AssembleIL(string sourceFileName, AssemblerOptions options = AssemblerOptions.UseDebug) { @@ -161,22 +161,22 @@ namespace ICSharpCode.Decompiler.Tests.Helpers }); - public static List GetPreprocessorSymbols(CompilerOptions flags) + public static List GetPreprocessorSymbols(CSharpCompilerOptions flags) { var preprocessorSymbols = new List(); - if (flags.HasFlag(CompilerOptions.UseDebug)) { + if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) { preprocessorSymbols.Add("DEBUG"); } - if (flags.HasFlag(CompilerOptions.Optimize)) { + if (flags.HasFlag(CSharpCompilerOptions.Optimize)) { preprocessorSymbols.Add("OPT"); } - if (flags.HasFlag(CompilerOptions.UseRoslyn)) { + if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) { preprocessorSymbols.Add("ROSLYN"); preprocessorSymbols.Add("CS60"); preprocessorSymbols.Add("CS70"); preprocessorSymbols.Add("CS71"); preprocessorSymbols.Add("CS72"); - } else if (flags.HasFlag(CompilerOptions.UseMcs)) { + } else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) { preprocessorSymbols.Add("MCS"); } else { preprocessorSymbols.Add("LEGACY_CSC"); @@ -184,7 +184,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers return preprocessorSymbols; } - public static CompilerResults CompileCSharp(string sourceFileName, CompilerOptions flags = CompilerOptions.UseDebug, string outputFileName = null) + public static CompilerResults CompileCSharp(string sourceFileName, CSharpCompilerOptions flags = CSharpCompilerOptions.UseDebug, string outputFileName = null) { List sourceFileNames = new List { sourceFileName }; foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) { @@ -193,15 +193,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers var preprocessorSymbols = GetPreprocessorSymbols(flags); - if (flags.HasFlag(CompilerOptions.UseRoslyn)) { + if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) { var parseOptions = new CSharpParseOptions(preprocessorSymbols: preprocessorSymbols.ToArray(), languageVersion: LanguageVersion.Latest); var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f)); var compilation = CSharpCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName), syntaxTrees, defaultReferences.Value, new CSharpCompilationOptions( - flags.HasFlag(CompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication, - platform: flags.HasFlag(CompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu, - optimizationLevel: flags.HasFlag(CompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug, + flags.HasFlag(CSharpCompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication, + platform: flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu, + optimizationLevel: flags.HasFlag(CSharpCompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug, allowUnsafe: true, deterministic: true )); @@ -216,7 +216,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers throw new Exception(b.ToString()); } return results; - } else if (flags.HasFlag(CompilerOptions.UseMcs)) { + } else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) { CompilerResults results = new CompilerResults(new TempFileCollection()); results.PathToAssembly = outputFileName ?? Path.GetTempFileName(); string testBasePath = RoundtripAssembly.TestDir; @@ -225,19 +225,19 @@ namespace ICSharpCode.Decompiler.Tests.Helpers $"git clone https://github.com/icsharpcode/ILSpy-tests \"{testBasePath}\""); } string mcsPath = Path.Combine(testBasePath, @"mcs\2.6.4\bin\gmcs.bat"); - string otherOptions = " -unsafe -o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+ " : "- "); + string otherOptions = " -unsafe -o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+ " : "- "); - if (flags.HasFlag(CompilerOptions.Library)) { + if (flags.HasFlag(CSharpCompilerOptions.Library)) { otherOptions += "-t:library "; } else { otherOptions += "-t:exe "; } - if (flags.HasFlag(CompilerOptions.UseDebug)) { + if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) { otherOptions += "-g "; } - if (flags.HasFlag(CompilerOptions.Force32Bit)) { + if (flags.HasFlag(CSharpCompilerOptions.Force32Bit)) { otherOptions += "-platform:x86 "; } else { otherOptions += "-platform:anycpu "; @@ -269,10 +269,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers } else { var provider = new CSharpCodeProvider(new Dictionary { { "CompilerVersion", "v4.0" } }); CompilerParameters options = new CompilerParameters(); - options.GenerateExecutable = !flags.HasFlag(CompilerOptions.Library); - options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+" : "-"); - options.CompilerOptions += (flags.HasFlag(CompilerOptions.UseDebug) ? " /debug" : ""); - options.CompilerOptions += (flags.HasFlag(CompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : ""); + options.GenerateExecutable = !flags.HasFlag(CSharpCompilerOptions.Library); + options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+" : "-"); + options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.UseDebug) ? " /debug" : ""); + options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : ""); if (preprocessorSymbols.Count > 0) { options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols); } @@ -295,10 +295,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers } } - internal static DecompilerSettings GetSettings(CompilerOptions cscOptions) + internal static DecompilerSettings GetSettings(CSharpCompilerOptions cscOptions) { var settings = new DecompilerSettings(); - if ((cscOptions & CompilerOptions.UseRoslyn) == 0) { + if ((cscOptions & CSharpCompilerOptions.UseRoslyn) == 0) { // disable C# features not available in legacy compiler settings.NullPropagation = false; settings.StringInterpolation = false; @@ -324,18 +324,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers return decompiler; } - internal static string GetSuffix(CompilerOptions cscOptions) + internal static string GetSuffix(CSharpCompilerOptions cscOptions) { string suffix = ""; - if ((cscOptions & CompilerOptions.Optimize) != 0) + if ((cscOptions & CSharpCompilerOptions.Optimize) != 0) suffix += ".opt"; - if ((cscOptions & CompilerOptions.Force32Bit) != 0) + if ((cscOptions & CSharpCompilerOptions.Force32Bit) != 0) suffix += ".32"; - if ((cscOptions & CompilerOptions.UseDebug) != 0) + if ((cscOptions & CSharpCompilerOptions.UseDebug) != 0) suffix += ".dbg"; - if ((cscOptions & CompilerOptions.UseRoslyn) != 0) + if ((cscOptions & CSharpCompilerOptions.UseRoslyn) != 0) suffix += ".roslyn"; - if ((cscOptions & CompilerOptions.UseMcs) != 0) + if ((cscOptions & CSharpCompilerOptions.UseMcs) != 0) suffix += ".mcs"; return suffix; } diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj index ae23b4b72..bc4fc10f9 100644 --- a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj +++ b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj @@ -38,6 +38,7 @@ + @@ -93,6 +94,7 @@ + diff --git a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs index c24d3f689..d31781e64 100644 --- a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs @@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests } } - static readonly CompilerOptions[] noRoslynOptions = + static readonly CSharpCompilerOptions[] noRoslynOptions = { - CompilerOptions.None, - CompilerOptions.Optimize + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize }; - static readonly CompilerOptions[] roslynOnlyOptions = + static readonly CSharpCompilerOptions[] roslynOnlyOptions = { - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn }; - static readonly CompilerOptions[] defaultOptions = + static readonly CSharpCompilerOptions[] defaultOptions = { - CompilerOptions.None, - CompilerOptions.Optimize, - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize, + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn }; - static readonly CompilerOptions[] defaultOptionsWithMcs = + static readonly CSharpCompilerOptions[] defaultOptionsWithMcs = { - CompilerOptions.None, - CompilerOptions.Optimize, - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn, - CompilerOptions.UseMcs, - CompilerOptions.Optimize | CompilerOptions.UseMcs + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize, + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.UseMcs, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs }; [Test] @@ -85,25 +85,25 @@ namespace ICSharpCode.Decompiler.Tests } [Test] - public void InlineAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void InlineAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void CompoundAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void CompoundAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void ShortCircuit([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void ShortCircuit([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void ExceptionHandling([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void ExceptionHandling([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { NullPropagation = false @@ -111,162 +111,162 @@ namespace ICSharpCode.Decompiler.Tests } [Test] - public void Switch([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void DelegateConstruction([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void DelegateConstruction([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void AnonymousTypes([Values(CompilerOptions.None, CompilerOptions.Optimize)] CompilerOptions cscOptions) + public void AnonymousTypes([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize)] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void Async([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void Async([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void Lock([ValueSource("defaultOptionsWithMcs")] CompilerOptions cscOptions) + public void Lock([ValueSource("defaultOptionsWithMcs")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void Using([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void LiftedOperators([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void LiftedOperators([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void Generics([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void Loops([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void AutoProperties([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void AutoProperties([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void QueryExpressions([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void QueryExpressions([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void TypeAnalysisTests([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void TypeAnalysisTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void CheckedUnchecked([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void CheckedUnchecked([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void UnsafeCode([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void UnsafeCode([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void PInvoke([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void PInvoke([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { // This tests needs our own disassembler; ildasm has a bug with marshalinfo. RunForLibrary(cscOptions: cscOptions, asmOptions: AssemblerOptions.UseOwnDisassembler); } [Test] - public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void FixProxyCalls([Values(CompilerOptions.None, CompilerOptions.Optimize, CompilerOptions.UseRoslyn)] CompilerOptions cscOptions) + public void FixProxyCalls([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize, CSharpCompilerOptions.UseRoslyn)] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void VariableNaming([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void VariableNaming([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CompilerOptions cscOptions) + public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { UseDebugSymbols = false }); } [Test] - public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } [Test] - public void AsyncMain([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void AsyncMain([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { Run(cscOptions: cscOptions); } [Test] - public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions); } - void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) + void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null) { - Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, decompilerSettings); + Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CSharpCompilerOptions.Library, decompilerSettings); } [Test] - public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { Run(cscOptions: cscOptions); } - void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) + void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null) { var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il"; var csFile = Path.Combine(TestCasePath, testName + ".cs"); diff --git a/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs b/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs index 923763775..c449321dd 100644 --- a/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs @@ -47,40 +47,40 @@ namespace ICSharpCode.Decompiler.Tests } } - static readonly CompilerOptions[] noRoslynOptions = + static readonly CSharpCompilerOptions[] noRoslynOptions = { - CompilerOptions.None, - CompilerOptions.Optimize + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize }; - static readonly CompilerOptions[] roslynOnlyOptions = + static readonly CSharpCompilerOptions[] roslynOnlyOptions = { - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn }; - static readonly CompilerOptions[] defaultOptions = + static readonly CSharpCompilerOptions[] defaultOptions = { - CompilerOptions.None, - CompilerOptions.Optimize, - CompilerOptions.UseRoslyn, - CompilerOptions.Optimize | CompilerOptions.UseRoslyn + CSharpCompilerOptions.None, + CSharpCompilerOptions.Optimize, + CSharpCompilerOptions.UseRoslyn, + CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn }; [Test] - public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) + public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) { RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { ArrayInitializers = false }); } - void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) + void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null) { - Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, decompilerSettings); + Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CSharpCompilerOptions.Library, decompilerSettings); } - void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) + void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null) { var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il"; var csFile = Path.Combine(TestCasePath, testName + ".cs");