public static VisualBasicCompilationOptions CreateCompilationOptions(string rootNamespace = null)
{
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithGlobalImports(GlobalImport.Parse(
"System",
"System.Collections",
"System.Collections.Generic",
"System.Diagnostics",
"System.Globalization",
"System.IO",
"System.Linq",
"System.Reflection",
"System.Runtime.CompilerServices",
"System.Runtime.InteropServices",
"System.Security",
"System.Text",
"System.Threading.Tasks",
"System.Xml.Linq",
"Microsoft.VisualBasic"))
.WithOptionExplicit(true)
.WithOptionCompareText(false)
.WithOptionStrict(OptionStrict.Off)
.WithOptionInfer(true)
.WithRootNamespace(rootNamespace);
return(compilationOptions);
}
public static VisualBasicCompilation CreateVisualBasicCompilation(IEnumerable <MetadataReference> references, string rootNamespace = null)
{
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithRootNamespace(rootNamespace)
.WithGlobalImports(GlobalImport.Parse(
"System",
"System.Collections.Generic",
"System.Diagnostics",
"System.Globalization",
"System.IO",
"System.Linq",
"System.Reflection",
"System.Runtime.CompilerServices",
"System.Security",
"System.Text",
"System.Threading.Tasks",
"Microsoft.VisualBasic"))
.WithOptionExplicit(true)
.WithOptionCompareText(false)
.WithOptionStrict(OptionStrict.Off)
.WithOptionInfer(true);
var compilation = VisualBasicCompilation.Create("Conversion", references: references)
.WithOptions(compilationOptions);
return(compilation);
}
public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable <MetadataReference> references)
{
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithRootNamespace("TestProject")
.WithGlobalImports(GlobalImport.Parse("System", "System.Collections.Generic", "System.Linq",
"Microsoft.VisualBasic"));
var compilation = VisualBasicCompilation.Create("Conversion", new[] { tree }, references)
.WithOptions(compilationOptions);
return(compilation);
}
/// <summary>
/// Constructs a new global binding.
/// </summary>
/// <param name="import">The global import of the binding.</param>
/// <param name="field">The field the import is bound to.</param>
public GlobalBinding(GlobalImport import, FieldInfo field)
{
if (import is null)
{
throw new ArgumentNullException(nameof(import));
}
if (field is null)
{
throw new ArgumentNullException(nameof(field));
}
Import = import;
Field = field;
Validate();
}
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);
}
private static GlobalBinding BindGlobal(GlobalImport import, IEnumerable <FieldInfo> fields)
{
var field = fields?.Where(f =>
{
var attribute = (ImportAttribute)f.GetCustomAttribute(typeof(ImportAttribute));
return(attribute.Name == import.Name &&
((string.IsNullOrEmpty(attribute.Module) &&
string.IsNullOrEmpty(import.ModuleName)) ||
attribute.Module == import.ModuleName));
}
).FirstOrDefault();
if (field is null)
{
throw new WasmtimeException($"Failed to bind global import '{import}': the host does not contain a global field with a matching 'Import' attribute.");
}
return(new GlobalBinding(import, field));
}
public Task MissingSystemImport_IsNotAdded_WhenIncludedInGlobalImports_VBAsync()
{
var test = new VerifyVB.Test
{
TestCode = VBWithBody(@"Dim s = {|#0:foo & bar.Substring(1)|}"),
FixedCode = VBWithBody(@"Dim s = String.Concat(foo, bar.AsSpan(1))"),
ReferenceAssemblies = ReferenceAssemblies.Net.Net50,
ExpectedDiagnostics = { VerifyVB.Diagnostic(Rule).WithLocation(0) }
};
test.SolutionTransforms.Add((s, id) =>
{
var project = s.Projects.Single();
var options = project.CompilationOptions as VisualBasicCompilationOptions;
var globalSystemImport = GlobalImport.Parse(nameof(System));
options = options.WithGlobalImports(globalSystemImport);
return(s.WithProjectCompilationOptions(project.Id, options));
});
return(test.RunAsync());
}
public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable <MetadataReference> references)
{
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithRootNamespace("TestProject")
.WithGlobalImports(GlobalImport.Parse(
"System",
"System.Collections.Generic",
"System.Diagnostics",
"System.Globalization",
"System.IO",
"System.Linq",
"System.Reflection",
"System.Runtime.CompilerServices",
"System.Security",
"System.Text",
"System.Threading.Tasks",
"Microsoft.VisualBasic"));
var compilation = VisualBasicCompilation.Create("Conversion", new[] { tree }, references)
.WithOptions(compilationOptions);
return(compilation);
}
private static CompilationOptions CreateCompilationOptions(TestWorkspace workspace, string language, XElement compilationOptionsElement)
{
var rootNamespace = new VisualBasicCompilationOptions(OutputKind.ConsoleApplication).RootNamespace;
var globalImports = new List <GlobalImport>();
var reportDiagnostic = ReportDiagnostic.Default;
if (compilationOptionsElement != null)
{
globalImports = compilationOptionsElement.Elements(GlobalImportElementName)
.Select(x => GlobalImport.Parse(x.Value)).ToList();
var rootNamespaceAttribute = compilationOptionsElement.Attribute(RootNamespaceAttributeName);
if (rootNamespaceAttribute != null)
{
rootNamespace = rootNamespaceAttribute.Value;
}
var reportDiagnosticAttribute = compilationOptionsElement.Attribute(ReportDiagnosticAttributeName);
if (reportDiagnosticAttribute != null)
{
reportDiagnostic = (ReportDiagnostic)Enum.Parse(typeof(ReportDiagnostic), (string)reportDiagnosticAttribute);
}
var outputTypeAttribute = compilationOptionsElement.Attribute(OutputTypeAttributeName);
if (outputTypeAttribute != null &&
outputTypeAttribute.Value == "WindowsRuntimeMetadata")
{
if (rootNamespaceAttribute == null)
{
rootNamespace = new VisualBasicCompilationOptions(OutputKind.WindowsRuntimeMetadata).RootNamespace;
}
return(language == LanguageNames.CSharp
? (CompilationOptions) new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata)
: new VisualBasicCompilationOptions(OutputKind.WindowsRuntimeMetadata).WithGlobalImports(globalImports).WithRootNamespace(rootNamespace));
}
}
else
{
// Add some common global imports by default for VB
globalImports.Add(GlobalImport.Parse("System"));
globalImports.Add(GlobalImport.Parse("System.Collections.Generic"));
globalImports.Add(GlobalImport.Parse("System.Linq"));
}
// TODO: Allow these to be specified.
var languageServices = workspace.Services.GetLanguageServices(language);
var metadataService = workspace.Services.GetService <IMetadataService>();
var compilationOptions = languageServices.GetService <ICompilationFactoryService>().GetDefaultCompilationOptions();
compilationOptions = compilationOptions.WithOutputKind(OutputKind.DynamicallyLinkedLibrary)
.WithGeneralDiagnosticOption(reportDiagnostic)
.WithSourceReferenceResolver(SourceFileResolver.Default)
.WithXmlReferenceResolver(XmlFileResolver.Default)
.WithMetadataReferenceResolver(new WorkspaceMetadataFileReferenceResolver(metadataService, new RelativePathResolver(ImmutableArray <string> .Empty, null)))
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (language == LanguageNames.VisualBasic)
{
compilationOptions = ((VisualBasicCompilationOptions)compilationOptions).WithRootNamespace(rootNamespace)
.WithGlobalImports(globalImports);
}
return(compilationOptions);
}
private static CompilationOptions CreateCompilationOptions(TestWorkspace workspace, string language, XElement compilationOptionsElement, ParseOptions parseOptions)
{
var rootNamespace = new VisualBasicCompilationOptions(OutputKind.ConsoleApplication).RootNamespace;
var globalImports = new List <GlobalImport>();
var reportDiagnostic = ReportDiagnostic.Default;
var cryptoKeyFile = (string)null;
var strongNameProvider = (StrongNameProvider)null;
var delaySign = (bool?)null;
var checkOverflow = false;
var allowUnsafe = false;
var outputKind = OutputKind.DynamicallyLinkedLibrary;
var nullable = NullableContextOptions.Disable;
if (compilationOptionsElement != null)
{
globalImports = compilationOptionsElement.Elements(GlobalImportElementName)
.Select(x => GlobalImport.Parse(x.Value)).ToList();
var rootNamespaceAttribute = compilationOptionsElement.Attribute(RootNamespaceAttributeName);
if (rootNamespaceAttribute != null)
{
rootNamespace = rootNamespaceAttribute.Value;
}
var outputKindAttribute = compilationOptionsElement.Attribute(OutputKindName);
if (outputKindAttribute != null)
{
outputKind = (OutputKind)Enum.Parse(typeof(OutputKind), (string)outputKindAttribute.Value);
}
var checkOverflowAttribute = compilationOptionsElement.Attribute(CheckOverflowAttributeName);
if (checkOverflowAttribute != null)
{
checkOverflow = (bool)checkOverflowAttribute;
}
var allowUnsafeAttribute = compilationOptionsElement.Attribute(AllowUnsafeAttributeName);
if (allowUnsafeAttribute != null)
{
allowUnsafe = (bool)allowUnsafeAttribute;
}
var reportDiagnosticAttribute = compilationOptionsElement.Attribute(ReportDiagnosticAttributeName);
if (reportDiagnosticAttribute != null)
{
reportDiagnostic = (ReportDiagnostic)Enum.Parse(typeof(ReportDiagnostic), (string)reportDiagnosticAttribute);
}
var cryptoKeyFileAttribute = compilationOptionsElement.Attribute(CryptoKeyFileAttributeName);
if (cryptoKeyFileAttribute != null)
{
cryptoKeyFile = (string)cryptoKeyFileAttribute;
}
var strongNameProviderAttribute = compilationOptionsElement.Attribute(StrongNameProviderAttributeName);
if (strongNameProviderAttribute != null)
{
var type = Type.GetType((string)strongNameProviderAttribute);
// DesktopStrongNameProvider and SigningTestHelpers.VirtualizedStrongNameProvider do
// not have a default constructor but constructors with optional parameters.
// Activator.CreateInstance does not work with this.
if (type == typeof(DesktopStrongNameProvider))
{
strongNameProvider = SigningTestHelpers.DefaultDesktopStrongNameProvider;
}
else
{
strongNameProvider = (StrongNameProvider)Activator.CreateInstance(type);
}
}
var delaySignAttribute = compilationOptionsElement.Attribute(DelaySignAttributeName);
if (delaySignAttribute != null)
{
delaySign = (bool)delaySignAttribute;
}
var nullableAttribute = compilationOptionsElement.Attribute(NullableAttributeName);
if (nullableAttribute != null)
{
nullable = (NullableContextOptions)Enum.Parse(typeof(NullableContextOptions), (string)nullableAttribute.Value);
}
var outputTypeAttribute = compilationOptionsElement.Attribute(OutputTypeAttributeName);
if (outputTypeAttribute != null &&
outputTypeAttribute.Value == "WindowsRuntimeMetadata")
{
if (rootNamespaceAttribute == null)
{
rootNamespace = new VisualBasicCompilationOptions(OutputKind.WindowsRuntimeMetadata).RootNamespace;
}
// VB needs Compilation.ParseOptions set (we do the same at the VS layer)
return(language == LanguageNames.CSharp
? (CompilationOptions) new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata, allowUnsafe: allowUnsafe)
: new VisualBasicCompilationOptions(OutputKind.WindowsRuntimeMetadata).WithGlobalImports(globalImports).WithRootNamespace(rootNamespace)
.WithParseOptions((VisualBasicParseOptions)parseOptions ?? VisualBasicParseOptions.Default));
}
}
else
{
// Add some common global imports by default for VB
globalImports.Add(GlobalImport.Parse("System"));
globalImports.Add(GlobalImport.Parse("System.Collections.Generic"));
globalImports.Add(GlobalImport.Parse("System.Linq"));
}
// TODO: Allow these to be specified.
var languageServices = workspace.Services.GetLanguageServices(language);
var metadataService = workspace.Services.GetService <IMetadataService>();
var compilationOptions = languageServices.GetService <ICompilationFactoryService>().GetDefaultCompilationOptions();
compilationOptions = compilationOptions.WithOutputKind(outputKind)
.WithGeneralDiagnosticOption(reportDiagnostic)
.WithSourceReferenceResolver(SourceFileResolver.Default)
.WithXmlReferenceResolver(XmlFileResolver.Default)
.WithMetadataReferenceResolver(new WorkspaceMetadataFileReferenceResolver(metadataService, new RelativePathResolver(ImmutableArray <string> .Empty, null)))
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default)
.WithCryptoKeyFile(cryptoKeyFile)
.WithStrongNameProvider(strongNameProvider)
.WithDelaySign(delaySign)
.WithOverflowChecks(checkOverflow);
if (language == LanguageNames.CSharp)
{
compilationOptions = ((CSharpCompilationOptions)compilationOptions).WithAllowUnsafe(allowUnsafe).WithNullableContextOptions(nullable);
}
if (language == LanguageNames.VisualBasic)
{
// VB needs Compilation.ParseOptions set (we do the same at the VS layer)
compilationOptions = ((VisualBasicCompilationOptions)compilationOptions).WithRootNamespace(rootNamespace)
.WithGlobalImports(globalImports)
.WithParseOptions((VisualBasicParseOptions)parseOptions ??
VisualBasicParseOptions.Default);
}
return(compilationOptions);
}
private static VisualBasicCompilationOptions CreateVisualBasicCompilationOptions(
string assemblyFileName,
CompilationOptionsReader optionsReader
)
{
var pdbOptions = optionsReader.GetMetadataCompilationOptions();
var langVersionString = pdbOptions.GetUniqueOption(
CompilationOptionNames.LanguageVersion
);
pdbOptions.TryGetUniqueOption(
CompilationOptionNames.Optimization,
out var optimization
);
pdbOptions.TryGetUniqueOption(CompilationOptionNames.Platform, out var platform);
pdbOptions.TryGetUniqueOption(
CompilationOptionNames.GlobalNamespaces,
out var globalNamespacesString
);
IEnumerable <GlobalImport>?globalImports = null;
if (!string.IsNullOrEmpty(globalNamespacesString))
{
globalImports = GlobalImport.Parse(globalNamespacesString.Split(';'));
}
VB.LanguageVersion langVersion = default;
VB.LanguageVersionFacts.TryParse(langVersionString, ref langVersion);
IReadOnlyDictionary <string, object>?preprocessorSymbols = null;
if (pdbOptions.OptionToString(CompilationOptionNames.Define) is string defineString)
{
preprocessorSymbols =
VisualBasicCommandLineParser.ParseConditionalCompilationSymbols(
defineString,
out var diagnostics
);
var diagnostic = diagnostics?.FirstOrDefault(x => x.IsUnsuppressedError);
if (diagnostic is object)
{
throw new Exception($"Cannot create compilation options: {diagnostic}");
}
}
var parseOptions = VisualBasicParseOptions.Default
.WithLanguageVersion(langVersion)
.WithPreprocessorSymbols(preprocessorSymbols.ToImmutableArrayOrEmpty());
var(optimizationLevel, plus) = GetOptimizationLevel(optimization);
var isChecked = pdbOptions.OptionToBool(CompilationOptionNames.Checked) ?? true;
var embedVBRuntime =
pdbOptions.OptionToBool(CompilationOptionNames.EmbedRuntime) ?? false;
var rootNamespace = pdbOptions.OptionToString(CompilationOptionNames.RootNamespace);
var compilationOptions = new VisualBasicCompilationOptions(
pdbOptions.OptionToEnum <OutputKind>(CompilationOptionNames.OutputKind)
?? OutputKind.DynamicallyLinkedLibrary,
moduleName: assemblyFileName,
mainTypeName: optionsReader.GetMainTypeName(),
scriptClassName: "Script",
globalImports: globalImports,
rootNamespace: rootNamespace,
optionStrict: pdbOptions.OptionToEnum <OptionStrict>(
CompilationOptionNames.OptionStrict
) ?? OptionStrict.Off,
optionInfer: pdbOptions.OptionToBool(CompilationOptionNames.OptionInfer) ?? false,
optionExplicit: pdbOptions.OptionToBool(CompilationOptionNames.OptionExplicit)
?? false,
optionCompareText: pdbOptions.OptionToBool(CompilationOptionNames.OptionCompareText)
?? false,
parseOptions: parseOptions,
embedVbCoreRuntime: embedVBRuntime,
optimizationLevel: optimizationLevel,
checkOverflow: isChecked,
cryptoKeyContainer: null,
cryptoKeyFile: null,
cryptoPublicKey: optionsReader.GetPublicKey()?.ToImmutableArray() ?? default,
delaySign: null,
platform: GetPlatform(platform),
generalDiagnosticOption: ReportDiagnostic.Default,
specificDiagnosticOptions: null,
concurrentBuild: true,
deterministic: true,
xmlReferenceResolver: null,
sourceReferenceResolver: null,
metadataReferenceResolver: null,
assemblyIdentityComparer: null,
strongNameProvider: null,
publicSign: false,
reportSuppressedDiagnostics: false,
metadataImportOptions: MetadataImportOptions.Public
);
compilationOptions.DebugPlusMode = plus;
return(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);
}
}
}
