static VisualBasicControlVM()
{
const LanguageVersion latestVersion = LanguageVersion.VisualBasic14;
Debug.Assert(!Enum.IsDefined(typeof(LanguageVersion), (LanguageVersion)((int)latestVersion + 1)));
parseOptions = new VisualBasicParseOptions(languageVersion: latestVersion, kind: SourceCodeKind.Script);
}
public static VisualBasicParseOptions GetVisualBasicParseOptionsForSourceCodeKind(SourceCodeKind sourceCodeKind)
{
VisualBasicParseOptions options = new VisualBasicParseOptions();
options.GetType().GetProperty("Kind").SetValue(options, sourceCodeKind);
return(options);
}
public SyntaxTree ParseText(string code, SourceCodeKind kind)
{
var options = new VisualBasicParseOptions(
kind: kind,
languageVersion: MaxLanguageVersion
).WithFeatures(_features);
return(VisualBasicSyntaxTree.ParseText(code, options));
}
public VisualBasicCodeVerificationOptions WithParseOptions(VisualBasicParseOptions parseOptions)
{
return(new VisualBasicCodeVerificationOptions(
parseOptions: parseOptions,
compilationOptions: CompilationOptions,
assemblyNames: AssemblyNames,
allowedCompilerDiagnosticSeverity: AllowedCompilerDiagnosticSeverity,
allowedCompilerDiagnosticIds: AllowedCompilerDiagnosticIds));
}
public async Task Initialize(Project project)
{
_sourceCsProject = project;
var cSharpCompilationOptions = VisualBasicCompiler.CreateCompilationOptions(RootNamespace);
_visualBasicParseOptions = VisualBasicParseOptions.Default;
_convertedVbProject = project.ToProjectFromAnyOptions(cSharpCompilationOptions, _visualBasicParseOptions);
_vbViewOfCsSymbols = (VisualBasicCompilation)await project.CreateReferenceOnlyCompilationFromAnyOptionsAsync(cSharpCompilationOptions);
}
public VisualBasicCodeVerificationOptions WithParseOptions(VisualBasicParseOptions parseOptions)
{
return(new VisualBasicCodeVerificationOptions(
parseOptions: parseOptions,
compilationOptions: CompilationOptions,
allowNewCompilerDiagnostics: AllowNewCompilerDiagnostics,
enableDiagnosticsDisabledByDefault: EnableDiagnosticsDisabledByDefault,
maxAllowedCompilerDiagnosticSeverity: MaxAllowedCompilerDiagnosticSeverity,
allowedCompilerDiagnosticIds: AllowedCompilerDiagnosticIds));
}
public VisualBasicTestOptions(
VisualBasicCompilationOptions compilationOptions = null,
VisualBasicParseOptions parseOptions = null,
IEnumerable <MetadataReference> metadataReferences = null,
IEnumerable <string> allowedCompilerDiagnosticIds = null,
DiagnosticSeverity allowedCompilerDiagnosticSeverity = DiagnosticSeverity.Info)
: base(metadataReferences, allowedCompilerDiagnosticIds, allowedCompilerDiagnosticSeverity)
{
CompilationOptions = compilationOptions ?? new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
ParseOptions = parseOptions ?? VisualBasicParseOptions.Default;
}
public VisualBasicCodeVerificationOptions(
VisualBasicParseOptions parseOptions,
VisualBasicCompilationOptions compilationOptions,
IEnumerable <string> assemblyNames,
DiagnosticSeverity allowedCompilerDiagnosticSeverity = DiagnosticSeverity.Info,
IEnumerable <string> allowedCompilerDiagnosticIds = null)
: base(assemblyNames, allowedCompilerDiagnosticSeverity, allowedCompilerDiagnosticIds)
{
ParseOptions = parseOptions ?? throw new ArgumentNullException(nameof(parseOptions));
CompilationOptions = compilationOptions ?? throw new ArgumentNullException(nameof(compilationOptions));
}
public VisualBasicCodeVerificationOptions(
VisualBasicParseOptions parseOptions = null,
VisualBasicCompilationOptions compilationOptions = null,
bool allowNewCompilerDiagnostics = false,
bool enableDiagnosticsDisabledByDefault = true,
DiagnosticSeverity maxAllowedCompilerDiagnosticSeverity = DiagnosticSeverity.Info,
IEnumerable <string> allowedCompilerDiagnosticIds = null)
: base(parseOptions, compilationOptions, allowNewCompilerDiagnostics, enableDiagnosticsDisabledByDefault, maxAllowedCompilerDiagnosticSeverity, allowedCompilerDiagnosticIds)
{
ParseOptions = parseOptions;
CompilationOptions = compilationOptions;
}
internal static IEnumerable <ColorizedWord> ColorizeInternal(string code)
{
if (re.IsMatch(code))
{
code = "__dummyfrom__=" + code; // because From is contextual
}
code = code.Replace("...", "___threedots___"); // because ... is unusually hard to parse
var ref_mscorlib = MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location);
var ref_system = MetadataReference.CreateFromFile(typeof(Uri).GetTypeInfo().Assembly.Location);
var ref_systemcore = MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location);
var ref_systemcollectionsimmutable = MetadataReference.CreateFromFile(typeof(ImmutableArray <>).GetTypeInfo().Assembly.Location);
var parse_options = new VisualBasicParseOptions(kind: SourceCodeKind.Script);
var compile_options = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary, globalImports: new[] { GlobalImport.Parse("System"), GlobalImport.Parse("System.Collections"), GlobalImport.Parse("System.Collections.Generic") });
var compilationUnit = SyntaxFactory.ParseCompilationUnit(code, options: parse_options);
var syntaxTree = compilationUnit.SyntaxTree;
var compilation = VisualBasicCompilation.Create("dummyAssemblyName", new[] { syntaxTree }, new[] { ref_mscorlib, ref_system, ref_systemcore, ref_systemcollectionsimmutable }, compile_options);
var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
var w = new VBColorizingWalker()
{
sm = semanticModel
};
w.Visit(syntaxTree.GetRoot());
//
var suppressNextEquals = false;
foreach (var word in w.Words)
{
if (word == null)
{
yield return(word);
}
else if (word.Text == "___threedots___")
{
yield return new ColorizedWord {
Text = "..."
}
}
;
else if (word.Text == "__dummyfrom__")
{
suppressNextEquals = true; continue;
}
else if (word.Text == "=" && suppressNextEquals)
{
}
else
{
word.Text = word.Text.Replace("___threedots___", "...").Replace("__dummyfrom__", "");
yield return(word);
}
}
}
protected bool IsCompleteSubmission(string code)
{
//invalid REPL command
if (code.StartsWith(":"))
{
return true;
}
var options = new VisualBasicParseOptions(LanguageVersion.VisualBasic14, DocumentationMode.Parse, SourceCodeKind.Interactive, null);
var syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options);
var diagnostics = syntaxTree.GetDiagnostics();
return !diagnostics.Any();
}
private static VisualBasicTestOptions CreateDefault()
{
VisualBasicParseOptions parseOptions = VisualBasicParseOptions.Default;
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
return(new VisualBasicTestOptions(
compilationOptions: compilationOptions,
parseOptions: parseOptions,
metadataReferences: RuntimeMetadataReference.DefaultMetadataReferences.Select(f => f.Value).ToImmutableArray(),
allowedCompilerDiagnosticIds: null,
allowedCompilerDiagnosticSeverity: DiagnosticSeverity.Info));
}
protected bool IsCompleteSubmission(string code)
{
//invalid REPL command
if (code.StartsWith(":"))
{
return(true);
}
var options = new VisualBasicParseOptions(LanguageVersion.VisualBasic14, DocumentationMode.Parse, SourceCodeKind.Interactive, null);
var syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options);
var diagnostics = syntaxTree.GetDiagnostics();
return(!diagnostics.Any());
}
public CSToVBProjectContentsConverter(ConversionOptions conversionOptions)
{
var vbCompilationOptions =
(VisualBasicCompilationOptions)conversionOptions.TargetCompilationOptionsOverride ??
VisualBasicCompiler.CreateCompilationOptions(conversionOptions.RootNamespaceOverride);
if (conversionOptions.RootNamespaceOverride != null)
{
vbCompilationOptions = vbCompilationOptions.WithRootNamespace(conversionOptions.RootNamespaceOverride);
}
_vbCompilationOptions = vbCompilationOptions;
_vbParseOptions = VisualBasicParseOptions.Default;
RootNamespace = conversionOptions.RootNamespaceOverride;
}
public CSToVBProjectContentsConverter(ConversionOptions conversionOptions, IProgress <ConversionProgress> progress, CancellationToken cancellationToken)
{
_progress = progress;
_cancellationToken = cancellationToken;
var vbCompilationOptions =
(VisualBasicCompilationOptions)conversionOptions.TargetCompilationOptionsOverride ??
VisualBasicCompiler.CreateCompilationOptions(conversionOptions.RootNamespaceOverride);
if (conversionOptions.RootNamespaceOverride != null)
{
vbCompilationOptions = vbCompilationOptions.WithRootNamespace(conversionOptions.RootNamespaceOverride);
}
_vbCompilationOptions = vbCompilationOptions;
_vbParseOptions = VisualBasicCompiler.ParseOptions;
RootNamespace = conversionOptions.RootNamespaceOverride;
}
void VBWorkspaceSetup(out CSharpDiagnosticTestBase.TestWorkspace workspace, out Document doc, VisualBasicParseOptions parseOptions = null)
{
workspace = new CSharpDiagnosticTestBase.TestWorkspace();
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
if (parseOptions == null)
{
parseOptions = new VisualBasicParseOptions(
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14,
DocumentationMode.Diagnose | DocumentationMode.Parse,
SourceCodeKind.Regular
);
}
workspace.Options.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInControlBlocks, false);
workspace.Open(ProjectInfo.Create(
projectId,
VersionStamp.Create(),
"TestProject",
"TestProject",
LanguageNames.VisualBasic,
null,
null,
new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
"",
"",
"Script",
GlobalImport.Parse("System", "Microsoft.VisualBasic")
),
parseOptions,
new[] {
DocumentInfo.Create(
documentId,
"a.vb",
null,
SourceCodeKind.Regular
)
},
null,
DiagnosticTestBase.DefaultMetadataReferences
)
);
doc = workspace.CurrentSolution.GetProject(projectId).GetDocument(documentId);
}
public override Project AddProject(Solution solution)
{
Project project = base.AddProject(solution);
var compilationOptions = (VisualBasicCompilationOptions)project.CompilationOptions;
VisualBasicCompilationOptions newCompilationOptions = compilationOptions
.WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
var parseOptions = (VisualBasicParseOptions)project.ParseOptions;
VisualBasicParseOptions newParseOptions = parseOptions
.WithLanguageVersion(LanguageVersion.Latest);
return(project
.WithCompilationOptions(newCompilationOptions)
.WithParseOptions(newParseOptions));
}
public CSToVBProjectContentsConverter(ConversionOptions conversionOptions, IProgress <ConversionProgress> progress, CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
OptionalOperations = new OptionalOperations(conversionOptions.AbandonOptionalTasksAfter, progress, cancellationToken);
var vbCompilationOptions =
(VisualBasicCompilationOptions)conversionOptions.TargetCompilationOptionsOverride ??
VisualBasicCompiler.CreateCompilationOptions(conversionOptions.RootNamespaceOverride)
.WithParseOptions(VisualBasicCompiler.ParseOptions);
if (conversionOptions.RootNamespaceOverride != null)
{
vbCompilationOptions = vbCompilationOptions.WithRootNamespace(conversionOptions.RootNamespaceOverride);
}
_vbCompilationOptions = vbCompilationOptions;
_vbParseOptions = vbCompilationOptions.ParseOptions;
RootNamespace = conversionOptions.RootNamespaceOverride;
}
void VBWorkspaceSetup(out CSharpDiagnosticTestBase.TestWorkspace workspace, out Document doc, VisualBasicParseOptions parseOptions = null)
{
workspace = new CSharpDiagnosticTestBase.TestWorkspace();
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
if (parseOptions == null)
{
parseOptions = new VisualBasicParseOptions(
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14,
DocumentationMode.Diagnose | DocumentationMode.Parse,
SourceCodeKind.Regular
);
}
workspace.Options.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInControlBlocks, false);
workspace.Open(ProjectInfo.Create(
projectId,
VersionStamp.Create(),
"TestProject",
"TestProject",
LanguageNames.VisualBasic,
null,
null,
new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
"",
"",
"Script",
GlobalImport.Parse("System", "Microsoft.VisualBasic")
),
parseOptions,
new[] {
DocumentInfo.Create(
documentId,
"a.vb",
null,
SourceCodeKind.Regular
)
},
null,
DiagnosticTestBase.DefaultMetadataReferences
)
);
doc = workspace.CurrentSolution.GetProject(projectId).GetDocument(documentId);
}
public void Test_OldVB()
{
var parseOptions = new VisualBasicParseOptions(
LanguageVersion.VisualBasic12,
DocumentationMode.Diagnose | DocumentationMode.Parse,
SourceCodeKind.Regular
);
Test <CheckIfParameterIsNothingCodeRefactoringProvider>(@"
Class Foo
Sub Test($test As String)
End Sub
End Class", @"
Class Foo
Sub Test(test As String)
If test Is Nothing Then
Throw New System.ArgumentNullException(""test"")
End If
End Sub
End Class", parseOptions: parseOptions);
}
private static VisualBasicCodeVerificationOptions CreateDefault()
{
VisualBasicParseOptions parseOptions = null;
VisualBasicCompilationOptions compilationOptions = null;
using (var workspace = new AdhocWorkspace())
{
Project project = workspace
.CurrentSolution
.AddProject("Temp", "Temp", LanguageNames.VisualBasic);
compilationOptions = ((VisualBasicCompilationOptions)project.CompilationOptions)
.WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
parseOptions = ((VisualBasicParseOptions)project.ParseOptions)
.WithLanguageVersion(LanguageVersion.Latest);
}
return(new VisualBasicCodeVerificationOptions(
parseOptions: parseOptions,
compilationOptions: compilationOptions));
}
public override Project AddProject(Solution solution, CodeVerificationOptions options = null)
{
Project project = base.AddProject(solution, options);
var compilationOptions = (VisualBasicCompilationOptions)project.CompilationOptions;
VisualBasicCompilationOptions newCompilationOptions = compilationOptions
.WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
var parseOptions = (VisualBasicParseOptions)project.ParseOptions;
VisualBasicCodeVerificationOptions visualBasicOptions = (options != null)
? ((VisualBasicCodeVerificationOptions)options)
: VisualBasicCodeVerificationOptions.Default;
VisualBasicParseOptions newParseOptions = parseOptions
.WithLanguageVersion(visualBasicOptions.LanguageVersion);
return(project
.WithCompilationOptions(newCompilationOptions)
.WithParseOptions(newParseOptions));
}
public static CompilerResults CompileVB(string sourceFileName, CompilerOptions flags = CompilerOptions.UseDebug, string outputFileName = null)
{
List <string> sourceFileNames = new List <string> {
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).Select(symbol => new KeyValuePair <string, object>(symbol, 1)).ToList();
if (flags.HasFlag(CompilerOptions.UseRoslyn))
{
var parseOptions = new VisualBasicParseOptions(preprocessorSymbols: preprocessorSymbols, languageVersion: LanguageVersion.Latest);
var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f));
var references = defaultReferences.Value;
if (flags.HasFlag(CompilerOptions.ReferenceVisualBasic))
{
references = references.Concat(visualBasic.Value);
}
var compilation = VisualBasicCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName),
syntaxTrees, references,
new VisualBasicCompilationOptions(
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,
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 if (flags.HasFlag(CompilerOptions.UseMcs))
{
throw new NotSupportedException("Cannot use mcs for VB");
}
else
{
var provider = new VBCodeProvider(new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
});
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = !flags.HasFlag(CompilerOptions.Library);
options.CompilerOptions = "/optimize" + (flags.HasFlag(CompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
options.CompilerOptions += " /optioninfer+ /optionexplicit+";
if (preprocessorSymbols.Count > 0)
{
options.CompilerOptions += " /d:" + string.Join(",", preprocessorSymbols.Select(p => $"{p.Key}={p.Value}"));
}
if (outputFileName != null)
{
options.OutputAssembly = outputFileName;
}
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("System.Xml.dll");
if (flags.HasFlag(CompilerOptions.ReferenceVisualBasic))
{
options.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
}
CompilerResults results = provider.CompileAssemblyFromFile(options, sourceFileNames.ToArray());
if (results.Errors.Cast <CompilerError>().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);
}
}
// http://stackoverflow.com/questions/13601412/compilation-errors-when-dealing-with-c-sharp-script-using-roslyn
protected SyntaxTree ParseSyntaxTree(string code, VisualBasicParseOptions parseOptions, string path = "")
{
var tree = VisualBasicSyntaxTree.ParseText(code, parseOptions, path);
return(tree);
}
public VBNetLanguageService(VisualBasicParseOptions options, LanguageServiceOptions serviceOptions)
: base(serviceOptions)
{
_options = options ?? DefaultOptions;
}
public void TestConversionCSharpToVisualBasic(string csharpCode, string expectedVisualBasicCode, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
DiagnosticTestBase.TestWorkspace csharpWorkspace, vbWorkspace;
Document inputDocument, outputDocument;
CSharpWorkspaceSetup(csharpCode, out csharpWorkspace, out inputDocument, csharpOptions);
VBWorkspaceSetup(out vbWorkspace, out outputDocument, vbOptions);
var outputNode = Convert((CSharpSyntaxNode)inputDocument.GetSyntaxRootAsync().Result, inputDocument.GetSemanticModelAsync().Result, outputDocument);
var txt = outputDocument.WithSyntaxRoot(Formatter.Format(outputNode, vbWorkspace)).GetTextAsync().Result.ToString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedVisualBasicCode = Utils.HomogenizeEol(expectedVisualBasicCode).TrimEnd();
if (expectedVisualBasicCode != txt)
{
Console.WriteLine("expected:");
Console.WriteLine(expectedVisualBasicCode);
Console.WriteLine("got:");
Console.WriteLine(txt);
Console.WriteLine("diff:");
int l = Math.Max(expectedVisualBasicCode.Length, txt.Length);
StringBuilder diff = new StringBuilder(l);
for (int i = 0; i < l; i++)
{
if (i >= expectedVisualBasicCode.Length || i >= txt.Length || expectedVisualBasicCode[i] != txt[i])
{
diff.Append('x');
}
else
{
diff.Append(expectedVisualBasicCode[i]);
}
}
Console.WriteLine(diff.ToString());
Assert.Fail();
}
}
public void TestConversionVisualBasicToCSharp(string visualBasicCode, string expectedCsharpCode, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
TestWorkspace csharpWorkspace, vbWorkspace;
Document inputDocument, outputDocument;
VBWorkspaceSetup(visualBasicCode, out vbWorkspace, out inputDocument, vbOptions);
CSharpWorkspaceSetup(out csharpWorkspace, out outputDocument, csharpOptions);
var outputNode = Convert((VisualBasicSyntaxNode)inputDocument.GetSyntaxRootAsync().Result, inputDocument.GetSemanticModelAsync().Result, outputDocument);
var txt = outputDocument.WithSyntaxRoot(Formatter.Format(outputNode, vbWorkspace)).GetTextAsync().Result.ToString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedCsharpCode = Utils.HomogenizeEol(expectedCsharpCode).TrimEnd();
if (expectedCsharpCode != txt)
{
int l = Math.Max(expectedCsharpCode.Length, txt.Length);
StringBuilder sb = new StringBuilder(l * 4);
sb.AppendLine("expected:");
sb.AppendLine(expectedCsharpCode);
sb.AppendLine("got:");
sb.AppendLine(txt);
sb.AppendLine("diff:");
for (int i = 0; i < l; i++)
{
if (i >= expectedCsharpCode.Length || i >= txt.Length || expectedCsharpCode[i] != txt[i])
{
sb.Append('x');
}
else
{
sb.Append(expectedCsharpCode[i]);
}
}
Assert.True(false, sb.ToString());
}
}
public void TestConversionCSharpToVisualBasic(string csharpCode, string expectedVisualBasicCode, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
DiagnosticTestBase.TestWorkspace csharpWorkspace, vbWorkspace;
Document inputDocument, outputDocument;
CSharpWorkspaceSetup(csharpCode, out csharpWorkspace, out inputDocument, csharpOptions);
VBWorkspaceSetup(out vbWorkspace, out outputDocument, vbOptions);
var outputNode = Convert((CSharpSyntaxNode)inputDocument.GetSyntaxRootAsync().Result, inputDocument.GetSemanticModelAsync().Result, outputDocument);
var txt = outputDocument.WithSyntaxRoot(Formatter.Format(outputNode, vbWorkspace)).GetTextAsync().Result.ToString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedVisualBasicCode = Utils.HomogenizeEol(expectedVisualBasicCode).TrimEnd();
if (expectedVisualBasicCode != txt)
{
Console.WriteLine("expected:");
Console.WriteLine(expectedVisualBasicCode);
Console.WriteLine("got:");
Console.WriteLine(txt);
Console.WriteLine("diff:");
int l = Math.Max(expectedVisualBasicCode.Length, txt.Length);
StringBuilder diff = new StringBuilder(l);
for (int i = 0; i < l; i++)
{
if (i >= expectedVisualBasicCode.Length || i >= txt.Length || expectedVisualBasicCode[i] != txt[i])
diff.Append('x');
else
diff.Append(expectedVisualBasicCode[i]);
}
Console.WriteLine(diff.ToString());
Assert.Fail();
}
}
public void Test_OldVB()
{
var parseOptions = new VisualBasicParseOptions(
LanguageVersion.VisualBasic12,
DocumentationMode.Diagnose | DocumentationMode.Parse,
SourceCodeKind.Regular
);
Test<CheckIfParameterIsNothingCodeRefactoringProvider>(@"
Class Foo
Sub Test($test As String)
End Sub
End Class", @"
Class Foo
Sub Test(test As String)
If test Is Nothing Then
Throw New System.ArgumentNullException(""test"")
End If
End Sub
End Class", parseOptions: parseOptions);
}
public VisualBasicTestOptions WithParseOptions(VisualBasicParseOptions parseOptions)
{
return(new VisualBasicTestOptions(this)
{
ParseOptions = parseOptions ?? throw new ArgumentNullException(nameof(parseOptions))
});
public VBNetLanguageService(VisualBasicParseOptions options)
: this(options, null)
{
}
public void TestConversionVisualBasicToCSharpWithoutComments(string visualBasicCode, string expectedCsharpCode, bool addUsings = true, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
AssertConvertedCodeResultEquals <VBToCSConversion>(visualBasicCode, expectedCsharpCode);
}
public void TestConversionCSharpToVisualBasic(string csharpCode, string expectedVisualBasicCode, bool expectSurroundingMethodBlock = false, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
expectedVisualBasicCode = AddSurroundingMethodBlock(expectedVisualBasicCode, expectSurroundingMethodBlock);
TestConversionCSharpToVisualBasicWithoutComments(csharpCode, expectedVisualBasicCode);
if (_testCstoVBCommentsByDefault)
{
TestConversionCSharpToVisualBasicWithoutComments(AddLineNumberComments(csharpCode, "// ", false), AddLineNumberComments(expectedVisualBasicCode, "' ", true));
}
}
public void TestConversionCSharpToVisualBasic(string csharpCode, string expectedVisualBasicCode, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
DiagnosticTestBase.TestWorkspace csharpWorkspace, vbWorkspace;
Document inputDocument, outputDocument;
CSharpWorkspaceSetup(csharpCode, out csharpWorkspace, out inputDocument, csharpOptions);
VBWorkspaceSetup(out vbWorkspace, out outputDocument, vbOptions);
var outputNode = Convert((CSharpSyntaxNode)inputDocument.GetSyntaxRootAsync().Result, inputDocument.GetSemanticModelAsync().Result);
var txt = outputDocument.WithSyntaxRoot(Formatter.Format(outputNode, vbWorkspace)).GetTextAsync().Result.ToString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedVisualBasicCode = Utils.HomogenizeEol(expectedVisualBasicCode).TrimEnd();
if (expectedVisualBasicCode != txt)
{
Console.WriteLine("expected:");
Console.WriteLine(expectedVisualBasicCode);
Console.WriteLine("got:");
Console.WriteLine(txt);
Assert.Fail();
}
}
public void TestConversionCSharpToVisualBasic(string csharpCode, string expectedVisualBasicCode, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
DiagnosticTestBase.TestWorkspace csharpWorkspace, vbWorkspace;
Document inputDocument, outputDocument;
CSharpWorkspaceSetup(csharpCode, out csharpWorkspace, out inputDocument, csharpOptions);
VBWorkspaceSetup(out vbWorkspace, out outputDocument, vbOptions);
var outputNode = Convert((CSharpSyntaxNode)inputDocument.GetSyntaxRootAsync().Result, inputDocument.GetSemanticModelAsync().Result);
var txt = outputDocument.WithSyntaxRoot(Formatter.Format(outputNode, vbWorkspace)).GetTextAsync().Result.ToString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedVisualBasicCode = Utils.HomogenizeEol(expectedVisualBasicCode).TrimEnd();
if (expectedVisualBasicCode != txt)
{
Console.WriteLine("expected:");
Console.WriteLine(expectedVisualBasicCode);
Console.WriteLine("got:");
Console.WriteLine(txt);
Assert.Fail();
}
}
