private static Compilation CreateCompilation(
string source,
string language,
string rootNamespace
)
{
string fileName = language == LanguageNames.CSharp ? "Test.cs" : "Test.vb";
string projectName = "TestProject";
var references = s_references.Value;
var syntaxTree =
language == LanguageNames.CSharp
? CSharpSyntaxTree.ParseText(source, path: fileName)
: VisualBasicSyntaxTree.ParseText(source, path: fileName);
if (language == LanguageNames.CSharp)
{
return(CSharpCompilation.Create(
projectName,
syntaxTrees: new[] { syntaxTree, },
references: references
));
}
else
{
return(VisualBasicCompilation.Create(
projectName,
syntaxTrees: new[] { syntaxTree },
references: references,
options: new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
rootNamespace: rootNamespace
)
));
}
}
public void Execute_ShouldWarnOnNonCSharCompilation()
{
Compilation compilation = VisualBasicCompilation.Create
(
"cica",
new[]
{
VisualBasicSyntaxTree.ParseText
(
@"
Imports System.Collections
Imports Solti.Utils.Proxy
Imports Solti.Utils.Proxy.Attributes
Imports Solti.Utils.Proxy.Generators
<Assembly:EmbedGeneratedType(GetType(DuckGenerator(Of IEnumerable, IEnumerable)))>
"
)
},
Runtime
.Assemblies
.Select(asm => asm.Location)
.Append(typeof(EmbedGeneratedTypeAttribute).Assembly.Location)
.Distinct()
.Select(location => MetadataReference.CreateFromFile(location)),
new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
);
GeneratorDriver driver = CSharpGeneratorDriver.Create(new ProxyEmbedder());
driver.RunGeneratorsAndUpdateCompilation(compilation, out compilation, out ImmutableArray <Diagnostic> diags);
Assert.That(diags.Any(diag => diag.Id == "PGE00" && diag.Severity == DiagnosticSeverity.Warning && diag.GetMessage() == SGResources.LNG_NOT_SUPPORTED));
Assert.That(diags.Length, Is.EqualTo(1));
}
public void CanBeReferencedByName()
{
var vbText = @"
Public Interface I
Property P(x As Integer)
End Interface
";
var vbcomp = VisualBasicCompilation.Create(
"Test",
new[] { VisualBasicSyntaxTree.ParseText(vbText) },
new[] { MscorlibRef_v4_0_30316_17626 },
new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var ref1 = vbcomp.EmitToImageReference(embedInteropTypes: true);
var text = @"class C : I {}";
var tree = Parse(text);
var comp = CreateEmptyCompilation(new[] { tree }, new[] { ref1 });
var t = comp.GetTypeByMetadataName("I");
Assert.Empty(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Method && !x.CanBeReferencedByName));
Assert.False(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Property).First().CanBeReferencedByName); //there's only one.
}
public static async Task <SyntaxNode> ConvertCompilationTree(Document document,
VisualBasicCompilation vbViewOfCsSymbols, Project vbReferenceProject)
{
document = await document.WithExpandedRootAsync();
var compilation = await document.Project.GetCompilationAsync();
var tree = await document.GetSyntaxTreeAsync();
var semanticModel = compilation.GetSemanticModel(tree, true);
var root = await document.GetSyntaxRootAsync() as CSS.CompilationUnitSyntax ??
throw new InvalidOperationException(NullRootError(document));
var vbSyntaxGenerator = SyntaxGenerator.GetGenerator(vbReferenceProject);
var numberOfLines = tree.GetLineSpan(root.FullSpan).EndLinePosition.Line;
var visualBasicSyntaxVisitor = new NodesVisitor(document, (CS.CSharpCompilation)compilation, semanticModel, vbViewOfCsSymbols, vbSyntaxGenerator, numberOfLines);
var converted = root.Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor);
var formattedConverted = (VBSyntax.CompilationUnitSyntax)Formatter.Format(converted, document.Project.Solution.Workspace);
return(LineTriviaMapper.MapSourceTriviaToTarget(root, formattedConverted));
}
public override CompilerResults CompileAssemblyFromSource(CompilerParameters cp, string code)
{
CodeAnalysis.SyntaxTree codeTree = Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(code);
VisualBasicCompilationOptions options = new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
true,
optimizationLevel: OptimizationLevel.Release,
generalDiagnosticOption: ReportDiagnostic.Error);
List <MetadataReference> references = new List <MetadataReference>();
foreach (string reference in cp.ReferencedAssemblies)
{
references.Add(GetReference(reference));
}
if (!cp.ReferencedAssemblies.Contains("netstandard"))
{
references.Add(GetReference("netstandard"));
}
if (!cp.ReferencedAssemblies.Contains("System.Runtime"))
{
references.Add(GetReference("System.Runtime"));
}
if (!cp.ReferencedAssemblies.Contains("System.ComponentModel.Primitives"))
{
references.Add(GetReference("System.ComponentModel.Primitives"));
}
Compilation compilation = VisualBasicCompilation.Create(
"_" + Guid.NewGuid().ToString("D"), new SyntaxTree[] { codeTree },
references: references, options: options
);
using (MemoryStream ms = new MemoryStream())
{
CodeAnalysis.Emit.EmitResult results = compilation.Emit(ms);
if (results.Success)
{
return(new CompilerResults()
{
CompiledAssembly = Assembly.Load(ms.ToArray())
});
}
else
{
CompilerResults result = new CompilerResults();
foreach (Diagnostic d in results.Diagnostics)
{
if (d.Severity == DiagnosticSeverity.Error)
{
result.Errors.Add(new CompilerError()
{
ErrorText = d.GetMessage(),
ErrorNumber = d.Id,
Line = d.Location.GetLineSpan().StartLinePosition.Line,
Column = d.Location.GetLineSpan().StartLinePosition.Character
});
}
}
return(result);
}
}
}
public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable <MetadataReference> references)
{
VisualBasicCompilation withReferences = CreateVisualBasicCompilation(references, _rootNamespace);
return(withReferences.AddSyntaxTrees(tree));
}
public static VisualBasicCompilation VerifyVisualBasicAnalyzerDiagnostics(this VisualBasicCompilation c, DiagnosticAnalyzer[] analyzers, AnalyzerOptions options = null, Func <Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException = null, params DiagnosticDescription[] expected)
{
return(VerifyAnalyzerDiagnostics(c, n => n.VisualBasicKind(), analyzers, options, expected, continueOnAnalyzerException));
}
private void TextArea_TextEntered(object sender, System.Windows.Input.TextCompositionEventArgs e)
{
var completionDataList = new List <QueryCompletionData>();
if (e.Text == ".")
{
//字符串不需要代码提示
var txt = textEditor.Text.Trim();
if ((txt.StartsWith("\"") || txt.StartsWith("“") || txt.StartsWith("”")) &&
(txt.EndsWith("\"") || txt.EndsWith("“") || txt.EndsWith("”")))
{
return;
}
try
{
var importsNamespace = "";//导入命名空间以实现省略命名空间的功能
foreach (var ns in ImportedNamespaces)
{
importsNamespace += string.Format("Imports {0}", ns);
importsNamespace += Environment.NewLine;
}
var startString = importsNamespace + @"
Module Module1
Sub Main()
Dim _tmp_ =";
var endString = @"
End Sub
End Module
";
string codeString = startString + textEditor.Text.Substring(0, textEditor.CaretOffset) + endString;
var tree = VisualBasicSyntaxTree.ParseText(codeString);
var root = tree.GetRoot();
//TODO WJF 动态加载组件后，此处运行是否还正常？
Assembly target = Assembly.GetExecutingAssembly();
List <Assembly> references = (from assemblyName in target.GetReferencedAssemblies()
select Assembly.Load(assemblyName)).ToList();
var CustomIntellisense = VisualBasicCompilation.Create("CustomIntellisense");
foreach (var assembly in references)
{
CustomIntellisense = CustomIntellisense.AddReferences(MetadataReference.CreateFromFile(assembly.Location));
}
CustomIntellisense = CustomIntellisense.AddSyntaxTrees(tree);
var model = CustomIntellisense.GetSemanticModel(tree);
var exprSyntaxNode = root.FindToken(codeString.LastIndexOf('.') - 1).Parent;
var exprFullNameString = exprSyntaxNode.Parent.ToString().Trim();
if (exprFullNameString.EndsWith("."))
{
exprFullNameString = exprFullNameString.Substring(0, exprFullNameString.Length - 1);
}
List <ExpressionNode> rootNodes =
ExpressionNode.SubsetAutoCompletionList(m_namespaceNodeRoot, exprFullNameString);
foreach (var item in rootNodes)
{
foreach (var child_item in item.Nodes)
{
if (child_item.ItemType == "namespace")
{
completionDataList.Add(new QueryCompletionData(child_item.Name, child_item.Description, SymbolKind.Namespace));
}
else if (child_item.ItemType == "class")
{
completionDataList.Add(new QueryCompletionData(child_item.Name, child_item.Description, SymbolKind.NamedType));
}
else
{
//TODO WJF后期根据需要添加
}
}
}
var literalInfo = model.GetTypeInfo(exprSyntaxNode);
var stringTypeSymbol = (INamedTypeSymbol)literalInfo.Type;
IList <ISymbol> symbols = new List <ISymbol>()
{
};
foreach (var s in (from method in stringTypeSymbol.GetMembers() where method.DeclaredAccessibility == Microsoft.CodeAnalysis.Accessibility.Public select method).Distinct())
{
symbols.Add(s);
}
if (symbols != null && symbols.Count > 0)
{
var distinctSymbols = from s in symbols group s by s.Name into g select new { Name = g.Key, Symbols = g };
foreach (var g in distinctSymbols.OrderBy(s => s.Name.ToLower()))
{
completionDataList.Add(new QueryCompletionData(g.Name, g.Symbols.ToArray()));
}
}
}
catch { }
}
else
{
if (completionWindow == null)
{
//列出本地变量列表
bool bShow = false;
if (textEditor.SelectionStart == textEditor.Text.Length)
{
if (textEditor.Text.Length == 1)
{
bShow = true;
}
if (textEditor.Text.Length >= 2)
{
var prevChar = textEditor.Text[textEditor.Text.Length - 2];
bShow = !char.IsLetterOrDigit(prevChar);
}
}
if (bShow)
{
var queryVarList = from s in variableDeclarations
where !string.IsNullOrEmpty(s) && s.StartsWith(e.Text, System.StringComparison.CurrentCultureIgnoreCase)
select s;
foreach (var name in queryVarList.OrderBy(s => s.ToLower()))
{
completionDataList.Add(new QueryCompletionData(name, string.Format("本地变量 {0}", name), SymbolKind.Local));
}
}
}
}
if (completionDataList.Count > 0)
{
completionWindow = new CompletionWindow(textEditor.TextArea);
IList <ICompletionData> data = completionWindow.CompletionList.CompletionData;
data.Clear();
foreach (var item in completionDataList)
{
data.Add(item);
}
if (e.Text != ".")
{
//此处需要特殊处理下
completionWindow.StartOffset -= e.Text.Length;
completionWindow.CompletionList.SelectItem(e.Text);
}
completionWindow.Show();
completionWindow.Closed += CompletionWindowClosed;
}
}
public async Task CorrectOutputInOtherProjectAsync()
{
var profile = this.GetDefaultTestProfile();
profile.ViewGeneration.AllInSameProject = false;
profile.ViewGeneration.XamlProjectSuffix = string.Empty;
profile.ViewGeneration.ViewModelProjectSuffix = ".ViewModels";
profile.ViewGeneration.ViewModelDirectoryName = "";
profile.ViewGeneration.ViewModelFileSuffix = "ViewModel";
profile.ViewGeneration.XamlFileDirectoryName = "Views";
profile.ViewGeneration.XamlFileSuffix = "Page";
var fs = new TestFileSystem
{
FileExistsResponse = false,
FileText = @"Public Class TestViewModel
Public Property OnlyProperty As String
End Class",
};
var synTree = VisualBasicSyntaxTree.ParseText(fs.FileText);
var semModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(synTree).GetSemanticModel(synTree, ignoreAccessibility: true);
var vsa = new TestVisualStudioAbstraction
{
SyntaxTree = synTree,
SemanticModel = semModel,
ActiveProject = new ProjectWrapper {
Name = "App.ViewModels", FileName = @"C:\Test\App.ViewModels\App.ViewModels.vbproj"
},
NamedProject = new ProjectWrapper {
Name = "App", FileName = @"C:\Test\App\App.vbproj"
},
};
var sut = new CreateViewCommandLogic(DefaultTestLogger.Create(), vsa, fs, profile);
await sut.ExecuteAsync(@"C:\Test\App.ViewModels\TestViewModel.vb");
var expectedXaml = "<Page"
+ Environment.NewLine + " x:Class=\"App.Views.TestPage\">"
+ Environment.NewLine + " <Grid>"
+ Environment.NewLine + " <StackPanel>"
+ Environment.NewLine + " <TextBlock FB=\"True\" Text=\"OnlyProperty\" />"
+ Environment.NewLine + " </StackPanel>"
+ Environment.NewLine + " </Grid>"
+ Environment.NewLine + "</Page>"
+ Environment.NewLine + "";
var expectedCodeBehind = "Imports System"
+ Environment.NewLine + "Imports Windows.UI.Xaml.Controls"
+ Environment.NewLine + "Imports App.ViewModels"
+ Environment.NewLine + ""
+ Environment.NewLine + "Namespace Views"
+ Environment.NewLine + ""
+ Environment.NewLine + " Public NotInheritable Partial Class TestPage"
+ Environment.NewLine + " Inherits Page"
+ Environment.NewLine + ""
+ Environment.NewLine + " Public Property ViewModel As TestViewModel"
+ Environment.NewLine + ""
+ Environment.NewLine + " Public Sub New()"
+ Environment.NewLine + " Me.InitializeComponent()"
+ Environment.NewLine + " Me.ViewModel = New TestViewModel()"
+ Environment.NewLine + " End Sub"
+ Environment.NewLine + " End Class"
+ Environment.NewLine + "End Namespace"
+ Environment.NewLine + "";
Assert.IsTrue(sut.CreateView);
Assert.AreEqual(@"C:\Test\App\Views\TestPage.xaml", sut.XamlFileName);
Assert.AreEqual(@"C:\Test\App\Views\TestPage.xaml.vb", sut.CodeFileName);
StringAssert.AreEqual(expectedXaml, sut.XamlFileContents);
StringAssert.AreEqual(expectedCodeBehind, sut.CodeFileContents);
}
static void VBSample()
{
SyntaxTree hostTree = VisualBasicSyntaxTree.ParseText(@"
Namespace VBUserCode
Class VBUserCodeContext
Inherits DRTInterfaces.VBUserCodeContextBase
Public Sub New(record As DRTInterfaces.IRecord)
MyBase.New(record)
End Sub
Sub _Execute()
End Sub
End Class
End Namespace");
string usercode = @"
For Each i In currentRecord.Rows
Dim val = ValueReference(i, ""myValue"")
val.Value = 4
'val = 4
System.Console.WriteLine(""Did a thing"")
Next
System.Console.WriteLine(""out of loop"")
Dim foo As Integer = 4
";
SyntaxTree userCodeTree = VisualBasicSyntaxTree.ParseText(
usercode, new VisualBasicParseOptions(kind: SourceCodeKind.Script)
);
var injectedSyntaxNode = new VBUserCodeInjector(userCodeTree).Visit(hostTree.GetRoot());
MetadataReference[] references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Microsoft.VisualBasic.CompilerServices.NewLateBinding).Assembly.Location),
MetadataReference.CreateFromFile(typeof(VBUserCodeContextBase).Assembly.Location)
};
string assemblyName = Path.GetRandomFileName();
VisualBasicCompilation compilation = VisualBasicCompilation.Create(
assemblyName,
syntaxTrees: new[] { injectedSyntaxNode.SyntaxTree },
references: references,
options: new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
// new VBVisitor().Visit(injectedSyntaxNode);
Assembly assembly = null;
using (var ms = new MemoryStream())
{
EmitResult result = compilation.Emit(ms);
if (!result.Success)
{
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (Diagnostic diagnostic in result.Diagnostics)
{
Console.Error.WriteLine("{0} - {1}: {2}", diagnostic.Id, diagnostic.Location, diagnostic.GetMessage());
}
}
else
{
ms.Seek(0, SeekOrigin.Begin);
assembly = Assembly.Load(ms.ToArray());
}
}
if (assembly != null)
{
var rec = new RecordStub();
Type type = assembly.GetType("VBUserCode.VBUserCodeContext");
var obj = Activator.CreateInstance(type, new object[] { rec }) as VBUserCodeContextBase;
type.InvokeMember("_Execute",
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
obj,
null);
}
}
public async Task CorrectOutputInSameFolderAsync()
{
var profile = this.GetDefaultTestProfile();
profile.ViewGeneration.AllInSameProject = true;
profile.ViewGeneration.ViewModelDirectoryName = "Files";
profile.ViewGeneration.ViewModelFileSuffix = "ViewModel";
profile.ViewGeneration.XamlFileDirectoryName = "Files";
profile.ViewGeneration.XamlFileSuffix = "Page";
var fs = new TestFileSystem
{
FileExistsResponse = false,
FileText = @"Public Class TestViewModel
Public Property OnlyProperty As String
End Class",
};
var synTree = VisualBasicSyntaxTree.ParseText(fs.FileText);
var semModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(synTree).GetSemanticModel(synTree, ignoreAccessibility: true);
var vsa = new TestVisualStudioAbstraction
{
SyntaxTree = synTree,
SemanticModel = semModel,
ActiveProject = new ProjectWrapper()
{
Name = "App", FileName = @"C:\Test\App\App.vbproj"
},
};
var sut = new CreateViewCommandLogic(profile, DefaultTestLogger.Create(), vsa, fs);
await sut.ExecuteAsync(@"C:\Test\App\Files\TestViewModel.vb");
var expectedXaml = @"<Page
x:Class=""App.Files.TestPage"">
<Grid>
<StackPanel>
<TextBlock FB=""True"" Text=""OnlyProperty"" />
</StackPanel>
</Grid>
</Page>
";
var expectedCodeBehind = @"Imports System
Imports Windows.UI.Xaml.Controls
Imports App.Files
Namespace Files
Public NotInheritable Partial Class TestPage
Inherits Page
Public Property ViewModel As TestViewModel
Public Sub New()
Me.InitializeComponent()
Me.ViewModel = New TestViewModel()
End Sub
End Class
End Namespace
";
Assert.IsTrue(sut.CreateView);
Assert.AreEqual(@"C:\Test\App\Files\TestPage.xaml", sut.XamlFileName);
Assert.AreEqual(@"C:\Test\App\Files\TestPage.xaml.vb", sut.CodeFileName);
Assert.AreEqual(expectedXaml, sut.XamlFileContents);
Assert.AreEqual(expectedCodeBehind, sut.CodeFileContents);
}
public void TestGivesAccessTo_CrossLanguageAndCompilation()
{
var csharpTree = CSharpSyntaxTree.ParseText(
@"
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""VB"")]
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""CS2"")]
internal class CS
{
}
"
);
var csharpTree2 = CSharpSyntaxTree.ParseText(
@"
internal class CS2
{
}
"
);
var vbTree = VisualBasicSyntaxTree.ParseText(
@"
<assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""CS"")>
<assembly: System.Runtime.CompilerServices.InternalsVisibleTo(""VB2"")>
Friend Class VB
End Class
"
);
var vbTree2 = VisualBasicSyntaxTree.ParseText(
@"
Friend Class VB2
End Class
"
);
var csc = (Compilation)CSharpCompilation.Create(
"CS",
new[] { csharpTree },
new MetadataReference[] { TestBase.MscorlibRef }
);
var CS = csc.GlobalNamespace.GetMembers("CS").First() as INamedTypeSymbol;
var csc2 = (Compilation)CSharpCompilation.Create(
"CS2",
new[] { csharpTree2 },
new MetadataReference[] { TestBase.MscorlibRef }
);
var CS2 = csc2.GlobalNamespace.GetMembers("CS2").First() as INamedTypeSymbol;
var vbc = VisualBasicCompilation.Create(
"VB",
new[] { vbTree },
new MetadataReference[] { TestBase.MscorlibRef }
);
var VB = vbc.GlobalNamespace.GetMembers("VB")[0] as INamedTypeSymbol;
var vbc2 = VisualBasicCompilation.Create(
"VB2",
new[] { vbTree2 },
new MetadataReference[] { TestBase.MscorlibRef }
);
var VB2 = vbc2.GlobalNamespace.GetMembers("VB2")[0] as INamedTypeSymbol;
Assert.True(CS.ContainingAssembly.GivesAccessTo(CS2.ContainingAssembly));
Assert.True(CS.ContainingAssembly.GivesAccessTo(VB.ContainingAssembly));
Assert.False(CS.ContainingAssembly.GivesAccessTo(VB2.ContainingAssembly));
Assert.True(VB.ContainingAssembly.GivesAccessTo(VB2.ContainingAssembly));
Assert.True(VB.ContainingAssembly.GivesAccessTo(CS.ContainingAssembly));
Assert.False(VB.ContainingAssembly.GivesAccessTo(CS2.ContainingAssembly));
}
protected override Compilation CreateNewEmptyCompilation()
{
return((Compilation)(object)VisualBasicCompilation.Create("TemporaryT4Assembly", (IEnumerable <SyntaxTree>)null, (IEnumerable <MetadataReference>)null, (VisualBasicCompilationOptions)null));
}
DbgDotNetText GetExpressionText(EvaluationContext evaluationContext, VisualBasicCompilation compilation, string expression, CancellationToken cancellationToken)
{
var(exprSource, exprOffset) = CreateExpressionSource(evaluationContext, expression);
return(GetExpressionText(LanguageNames.VisualBasic, visualBasicCompilationOptions, visualBasicParseOptions, expression, exprSource, exprOffset, compilation.References, cancellationToken));
}
public void Initialize(Compilation convertedCompilation)
{
_convertedCompilation = (VisualBasicCompilation)convertedCompilation;
}
protected override Compilation CreateScriptCompilation(string assemblyName, SyntaxTree syntaxTree,
IEnumerable <MetadataReference> references, CompilationOptions options,
Compilation previousScriptCompilation, Type returnType, Type globalsType) =>
VisualBasicCompilation.CreateScriptCompilation(assemblyName, syntaxTree, references, (VisualBasicCompilationOptions)options, (VisualBasicCompilation)previousScriptCompilation, returnType, globalsType);
// 進捗画面側で実行してもらう処理
private async Task DoWorkAsync()
{
// ソースコードをRoslynに渡す、ソースコードをDBに入れる
await Task.Run(async() =>
{
var slnParser = new SolutionParser();
var prjParser = new ProjectParser();
// ソリューションファイル
var slnInfo = slnParser.Parse(SolutionFile);
if (AppEnv.SolutionInfos.Any(x => x.SolutionFile == SolutionFile))
{
return;
}
AppEnv.SolutionInfos.Add(slnInfo);
foreach (var prjRefInfo in slnInfo.ProjectFiles)
{
// プロジェクトファイル
var prjInfo = prjParser.Parse(SolutionFile, prjRefInfo.ProjectFile);
if (AppEnv.ProjectInfos.Any(x => x.SolutionFile == prjInfo.SolutionFile && x.ProjectFile == prjInfo.ProjectFile))
{
continue;
}
AppEnv.ProjectInfos.Add(prjInfo);
// Roslyn 解析に必要なデータ系
//Microsoft.CodeAnalysis.ProjectInfo と DotBarg.Libraries.Parsers.ProjectInfo が同じクラス名のため、こちらはフルパスで書く
var dllItems = new List <Microsoft.CodeAnalysis.MetadataReference>();
var mscorlib = Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location);
dllItems.Add(mscorlib);
var csSrcItems = new List <Microsoft.CodeAnalysis.SyntaxTree>();
var vbSrcItems = new List <Microsoft.CodeAnalysis.SyntaxTree>();
// ソースファイル
var srcInfos = prjInfo.SourceFiles;
foreach (var srcInfo in srcInfos)
{
var contents = await Util.ReadToEndAsync(srcInfo.SourceFile);
switch (prjInfo.Languages)
{
case Languages.CSharp:
var csTree = CSharpSyntaxTree.ParseText(text: contents, path: srcInfo.SourceFile);
var csWalker = new CSharpSourceSyntaxWalker();
csWalker.Parse(srcInfo.SourceFile, contents, prjInfo.RootNamespace);
if (csWalker.UserDefinitions.Any())
{
AppEnv.UserDefinitions.AddRange(csWalker.UserDefinitions.ToList());
}
csSrcItems.Add(csTree);
if (srcInfo.HasDesignerFile)
{
contents = await Util.ReadToEndAsync(srcInfo.DesignerFile);
csTree = CSharpSyntaxTree.ParseText(text: contents, path: srcInfo.DesignerFile);
csWalker = new CSharpSourceSyntaxWalker();
csWalker.Parse(srcInfo.DesignerFile, contents, prjInfo.RootNamespace);
if (csWalker.UserDefinitions.Any())
{
AppEnv.UserDefinitions.AddRange(csWalker.UserDefinitions.ToList());
}
csSrcItems.Add(csTree);
}
break;
case Languages.VBNet:
var vbTree = VisualBasicSyntaxTree.ParseText(text: contents, path: srcInfo.SourceFile);
var vbWalker = new VBNetSourceSyntaxWalker();
vbWalker.Parse(srcInfo.SourceFile, contents, prjInfo.RootNamespace);
if (vbWalker.UserDefinitions.Any())
{
AppEnv.UserDefinitions.AddRange(vbWalker.UserDefinitions.ToList());
}
vbSrcItems.Add(vbTree);
if (srcInfo.HasDesignerFile)
{
contents = await Util.ReadToEndAsync(srcInfo.DesignerFile);
vbTree = VisualBasicSyntaxTree.ParseText(text: contents, path: srcInfo.DesignerFile);
vbWalker = new VBNetSourceSyntaxWalker();
vbWalker.Parse(srcInfo.DesignerFile, contents, prjInfo.RootNamespace);
if (vbWalker.UserDefinitions.Any())
{
AppEnv.UserDefinitions.AddRange(vbWalker.UserDefinitions.ToList());
}
vbSrcItems.Add(vbTree);
}
break;
}
}
if (csSrcItems.Any())
{
var comp = CSharpCompilation.Create(prjInfo.AssemblyName, csSrcItems, dllItems);
AppEnv.CSharpCompilations.Add(comp);
AppEnv.CSharpSyntaxTrees.AddRange(csSrcItems);
}
if (vbSrcItems.Any())
{
var kinds = Path.GetExtension(prjInfo.AssemblyFile).ToLower() == ".exe" ? Microsoft.CodeAnalysis.OutputKind.ConsoleApplication : Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary;
var options = new VisualBasicCompilationOptions(outputKind: kinds, rootNamespace: prjInfo.RootNamespace);
var comp = VisualBasicCompilation.Create(prjInfo.AssemblyName, vbSrcItems, dllItems, options);
AppEnv.VisualBasicCompilations.Add(comp);
AppEnv.VisualBasicSyntaxTrees.AddRange(vbSrcItems);
}
}
});
// 上記で登録したDB内容をもとに、継承元クラス、インターフェースの定義元を名前解決する
// ツリーノードのモデルを作成する
await Task.Run(() =>
{
var containers = AppEnv.UserDefinitions.Where(x => x.BaseTypeInfos.Any());
if (containers.Any())
{
FindDefinitionInfo(containers);
}
var model = CreateTreeData(SolutionFile);
Items.Add(model);
});
}
private void TextArea_TextEntered(object sender, System.Windows.Input.TextCompositionEventArgs e)
{
if (e.Text == ".")
{
try
{
string startString = @"
Imports System
Imports System.Collections.Generic
Imports System.Text
Namespace SomeNamespace
Public Class NotAProgram
Private Sub SomeMethod()
"
+ "var blah = ";
string endString = @"
End Sub
End Class
End Namespace
";
string codeString = startString + this.Text.Substring(0, this.CaretOffset) + endString;
var tree = VisualBasicSyntaxTree.ParseText(codeString);
var root = (Microsoft.CodeAnalysis.VisualBasic.Syntax.CompilationUnitSyntax)tree.GetRoot();
var compilation = VisualBasicCompilation.Create("CustomIntellisense")
.AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddSyntaxTrees(tree);
var model = compilation.GetSemanticModel(tree);
var exprString = root.FindToken(codeString.LastIndexOf('.') - 1).Parent;
var literalInfo = model.GetTypeInfo(exprString);
var stringTypeSymbol = (INamedTypeSymbol)literalInfo.Type;
IList <ISymbol> symbols = new List <ISymbol>()
{
};
foreach (var s in (from method in stringTypeSymbol.GetMembers() where method.DeclaredAccessibility == Accessibility.Public select method).Distinct())
{
symbols.Add(s);
}
if (symbols != null && symbols.Count > 0)
{
completionWindow = new CompletionWindow(this.TextArea);
IList <ICompletionData> data = completionWindow.CompletionList.CompletionData;
data.Clear();
var distinctSymbols = from s in symbols group s by s.Name into g select new { Name = g.Key, Symbols = g };
foreach (var g in distinctSymbols.OrderBy(s => s.Name))
{
data.Add(new QueryCompletionData(g.Name, g.Symbols.ToArray()));
}
completionWindow.Show();
completionWindow.Closed += delegate
{
completionWindow = null;
};
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
protected override Compilation CreateCompilation(IEnumerable <SyntaxTree> code, string dllName, IEnumerable <MetadataReference> refs, CompilationOptions opts) => VisualBasicCompilation.Create(dllName, code, refs, (VisualBasicCompilationOptions)opts);
private static Compilation CompileAssembly(SyntaxTree syntaxTree, string assemblyName)
{
return(VisualBasicCompilation.Create(assemblyName, new SyntaxTree[] { syntaxTree }, ReferenceResolver.GetDefaultReferences(), DefaultCompilationOptions));
}
private static ITypeSymbol GetTypeSymbol(SemanticModel semModel, SyntaxNode prop, PropertyDetails propDetails)
{
ITypeSymbol typeSymbol = null;
if (propDetails.PropertyType.IsGenericTypeName())
{
Logger?.RecordInfo(StringRes.Info_GettingGenericType);
TypeSyntax typeSyntax = null;
if (prop is PropertyStatementSyntax pss)
{
if (pss.AsClause is SimpleAsClauseSyntax sacs)
{
if (sacs.Type is GenericNameSyntax gns)
{
typeSyntax = gns.TypeArgumentList.Arguments.First();
}
else if (sacs.Type is QualifiedNameSyntax qns)
{
typeSyntax = ((GenericNameSyntax)qns.Right).TypeArgumentList.Arguments.First();
}
}
if (typeSyntax == null)
{
Logger?.RecordInfo(StringRes.Info_PropertyTypeNotRecognizedAsGeneric.WithParams(propDetails.PropertyType));
}
}
if (prop is PropertyBlockSyntax pbs)
{
typeSyntax = ((GenericNameSyntax)((SimpleAsClauseSyntax)pbs.PropertyStatement.AsClause).Type).TypeArgumentList.Arguments.First();
}
try
{
typeSymbol = semModel.GetTypeInfo(typeSyntax).Type;
}
catch (Exception)
{
// The semanticmodel passed into this method is the one for the active document.
// If the type is in another file, generate a new model to use to look up the typeinfo. Don't do this by default as it's expensive.
var localSemModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(prop.SyntaxTree).GetSemanticModel(prop.SyntaxTree, ignoreAccessibility: true);
typeSymbol = localSemModel.GetTypeInfo(typeSyntax).Type;
}
}
else
{
if (prop is PropertyStatementSyntax pss)
{
if (pss.AsClause != null)
{
try
{
typeSymbol = semModel.GetTypeInfo(((SimpleAsClauseSyntax)pss.AsClause).Type).Type;
}
catch (Exception)
{
// The semanticmodel passed into this method is the one for the active document.
// If the type is in another file, generate a new model to use to look up the typeinfo. Don't do this by default as it's expensive.
var localSemModel = VisualBasicCompilation.Create(string.Empty)
.AddSyntaxTrees(prop.SyntaxTree)
.GetSemanticModel(prop.SyntaxTree, ignoreAccessibility: true);
typeSymbol = localSemModel.GetTypeInfo(((SimpleAsClauseSyntax)pss.AsClause).Type).Type;
}
}
else
{
try
{
if (pss.Identifier.TrailingTrivia.ToString().StartsWith("?"))
{
var propSyn = VisualBasicSyntaxTree.ParseText(prop.ToFullString().Replace("?", string.Empty).Trim() + "?");
var propType = ((SimpleAsClauseSyntax)((CompilationUnitSyntax)propSyn.GetRoot()).Members.OfType<PropertyStatementSyntax>().FirstOrDefault()?.AsClause)?.Type;
var propSemModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(propSyn).GetSemanticModel(propSyn, true);
typeSymbol = propSemModel.GetTypeInfo(propType).Type;
}
}
catch (Exception)
{
Logger?.RecordInfo(StringRes.Info_FailedToGetNullableType.WithParams(propDetails.Name));
}
}
}
else if (prop is PropertyBlockSyntax pbs)
{
try
{
typeSymbol = semModel.GetTypeInfo(((SimpleAsClauseSyntax)pbs.PropertyStatement.AsClause).Type).Type;
}
catch (Exception)
{
// The semanticmodel passed into this method is the one for the active document.
// If the type is in another file, generate a new model to use to look up the typeinfo. Don't do this by default as it's expensive.
var localSemModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(prop.SyntaxTree).GetSemanticModel(prop.SyntaxTree, ignoreAccessibility: true);
typeSymbol = localSemModel.GetTypeInfo(((SimpleAsClauseSyntax)pbs.PropertyStatement.AsClause).Type).Type;
}
}
}
return typeSymbol;
}
private bool TryAnalyzeCsConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ITypeSymbol csType,
ITypeSymbol csConvertedType, Conversion vbConversion, ITypeSymbol vbConvertedType, ITypeSymbol vbType,
VisualBasicCompilation vbCompilation, bool isConst, out TypeConversionKind typeConversionKind)
{
var csConversion = _csCompilation.ClassifyConversion(csType, csConvertedType);
bool isConvertToString =
(vbConversion.IsString || vbConversion.IsReference && vbConversion.IsNarrowing) && vbConvertedType.SpecialType == SpecialType.System_String;
bool isArithmetic = vbNode.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.AddExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.SubtractExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.MultiplyExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.DivideExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.IntegerDivideExpression);
if (!csConversion.Exists || csConversion.IsUnboxing)
{
if (ConvertStringToCharLiteral(vbNode, vbConvertedType, out _))
{
typeConversionKind =
TypeConversionKind.Identity; // Already handled elsewhere by other usage of method
return(true);
}
if (vbType.SpecialType == SpecialType.System_String && vbConvertedType.IsArrayOf(SpecialType.System_Char))
{
typeConversionKind = TypeConversionKind.StringToCharArray;
return(true);
}
if (isConvertToString || vbConversion.IsNarrowing)
{
typeConversionKind = isConst ? TypeConversionKind.ConstConversion : TypeConversionKind.Conversion;
return(true);
}
}
else if (vbConversion.IsWidening && vbConversion.IsNumeric && csConversion.IsImplicit &&
csConversion.IsNumeric)
{
// Safe overapproximation: A cast is really only needed to help resolve the overload for the operator/method used.
// e.g. When VB "&" changes to C# "+", there are lots more overloads available that implicit casts could match.
// e.g. sbyte * ulong uses the decimal * operator in VB. In C# it's ambiguous - see ExpressionTests.vb "TestMul".
typeConversionKind = TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (csConversion.IsExplicit && csConversion.IsEnumeration)
{
typeConversionKind = TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (isArithmetic)
{
var arithmeticConversion =
vbCompilation.ClassifyConversion(vbConvertedType,
vbCompilation.GetTypeByMetadataName("System.Int32"));
if (arithmeticConversion.IsWidening && !arithmeticConversion.IsIdentity)
{
typeConversionKind = isConst ? TypeConversionKind.ConstConversion : TypeConversionKind.Conversion;
return(true);
}
}
else if (csConversion.IsExplicit && csConversion.IsNumeric && vbConversion.IsNarrowing && isConst)
{
typeConversionKind = IsImplicitConstantConversion(vbNode) ? TypeConversionKind.Identity : TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (csConversion.IsExplicit && vbConversion.IsNumeric && vbType.TypeKind != TypeKind.Enum)
{
typeConversionKind = IsImplicitConstantConversion(vbNode) ? TypeConversionKind.Identity :
isConst ? TypeConversionKind.ConstConversion : TypeConversionKind.Conversion;
return(true);
}
else if (csConversion.IsExplicit && vbConversion.IsIdentity && csConversion.IsNumeric && vbType.TypeKind != TypeKind.Enum)
{
typeConversionKind = isConst ? TypeConversionKind.ConstConversion : TypeConversionKind.Conversion;
return(true);
}
else if (isConvertToString && vbType.SpecialType == SpecialType.System_Object)
{
typeConversionKind = isConst ? TypeConversionKind.ConstConversion : TypeConversionKind.Conversion;
return(true);
}
else if (csConversion.IsNullable && csConvertedType.SpecialType == SpecialType.System_Boolean)
{
typeConversionKind = TypeConversionKind.NullableBool;
return(true);
}
else if (csConversion.IsExplicit)
{
typeConversionKind = TypeConversionKind.DestructiveCast;
return(true);
}
typeConversionKind = csConversion.IsIdentity ? TypeConversionKind.Identity : TypeConversionKind.Unknown;
return(false);
}
public override Compilation CreatCompilation(string compilationName, SyntaxTree syntaxTree, IEnumerable <MetadataReference> references, OutputKind outputKind)
=> VisualBasicCompilation.Create(compilationName, new SyntaxTree[] { syntaxTree }, references, new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
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);
}
}
private static object CalculateSum(double a, double b)
{
const string code = @"Option strict off
Imports System
Imports Microsoft.VisualBasic
Imports LibraryProject
Namespace DummyNamespace
Public Class Helper
Inherits CustomType
Function Sum(d1 As Double, d2 As Double) As Double
Return d1+d2
End Function
End Class
End Namespace";
var tree = VisualBasicSyntaxTree.ParseText(code, VisualBasicParseOptions.Default);
var binDirectory = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName;
var vbAssembly = typeof(Conversions).Assembly;
var vb = MetadataReference.CreateFromFile(vbAssembly.Location);
var fileName = "myLib";
var compilation = VisualBasicCompilation.Create(fileName)
.WithOptions(new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(MetadataReference.CreateFromFile(typeof(CustomType).Assembly.Location))
.AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddReferences(vb)
.AddReferences(GetReferencedAssembliesRecursively(vbAssembly).Select(a => MetadataReference.CreateFromFile(a)))
.AddSyntaxTrees(tree);
var newpath = Path.Combine(Path.GetTempPath(), $"MyLibrary_{DateTime.Now:yyMMdd}");
Directory.CreateDirectory(newpath);
var path = Path.Combine(newpath, "MyLibrary.dll");
var compilationResult = compilation.Emit(path);
if (compilationResult.Success)
{
// below code works since our reference to LibraryProject.dll is already loaded in thi ALC
/* var nunitCustomAssemblyLoadContext = AssemblyLoadContext.All.Single(c => c.ToString().Contains("NUnit.Engine.Internal.CustomAssemblyLoadContext"));
* var asm = nunitCustomAssemblyLoadContext.LoadFromAssemblyPath(path);*/
//This code works as well using NUnit.Console 3.13.0: https://github.com/nunit/nunit-console/pull/942
var asm = (AssemblyLoadContext.CurrentContextualReflectionContext ?? AssemblyLoadContext.Default).LoadFromAssemblyPath(path);
// this doesn't work
//var asm = Assembly.LoadFrom(path);
var classFullName = "DummyNamespace.Helper";
var type = asm.GetType(classFullName);
if (type == null)
{
throw new Exception($"Type '{classFullName}' could not be found");
}
var instance = asm.CreateInstance(classFullName);
if (instance == null)
{
throw new Exception($"'{classFullName}' deosn't have a valid default constructor");
}
var methodInfo = type.GetMethod("Sum");
if (methodInfo == null)
{
throw new Exception($"Method 'Sum' could not be found in type {type.FullName}");
}
return(methodInfo.Invoke(instance, new object[] { a, b }));
}
foreach (var codeIssue in compilationResult.Diagnostics)
{
Console.WriteLine($"ID: {codeIssue.Id}, Message: {codeIssue.GetMessage()}, Location: {codeIssue.Location.GetLineSpan()}, Severity: {codeIssue.Severity}");
}
return(null);
}
