/// <summary>
/// Load all useful references
/// </summary>
public void ScriptEngineLoadAssemblies(ScriptEngine engine, string localAssembly)
{
//GAC Assemblies
var systemCoreReference = MetadataReference.CreateAssemblyReference("System.Core");
var systemReference = MetadataReference.CreateAssemblyReference("System");
var systemComponentModel = MetadataReference.CreateAssemblyReference("System.ComponentModel");
var systemComponentModelComposition =
MetadataReference.CreateAssemblyReference("System.ComponentModel.Composition");
var systemIO = MetadataReference.CreateAssemblyReference("System.IO");
var systemLinq = MetadataReference.CreateAssemblyReference("System.Linq");
var systemReflection = MetadataReference.CreateAssemblyReference("System.Runtime.Serialization");
var systemServiceModel = MetadataReference.CreateAssemblyReference("System.ServiceModel");
var systemWindows = MetadataReference.CreateAssemblyReference("System.Windows");
//Custom Assemblies
Assembly wpfAssembly = Assembly.GetAssembly(typeof(AdminConsoleViewModel));
Assembly caliburnMicro = Assembly.GetAssembly(typeof(Conductor <IScreen> .Collection.OneActive));
engine.AddReference(systemCoreReference);
engine.AddReference(systemReference);
engine.AddReference(systemComponentModel);
engine.AddReference(systemComponentModelComposition);
engine.AddReference(systemIO);
engine.AddReference(systemLinq);
engine.AddReference(systemReflection);
engine.AddReference(systemServiceModel);
engine.AddReference(systemWindows);
engine.AddReference(wpfAssembly.Location);
engine.AddReference(caliburnMicro.Location);
engine.AddReference(localAssembly);
}
public static Compilation BuildCompilation(List <SyntaxTree> treelist)
{
List <MetadataReference> reflist = new List <MetadataReference>();
// Collect the system API references from using directives
var totalUsings = treelist.AsParallel().Select(
tree => tree.GetRoot().DescendantNodes().OfType <UsingDirectiveSyntax>());
// transfer to a list
var totalUsingList = totalUsings.SelectMany(x => x).ToList();
// create metareference
List <String> allLibNames = new List <string>();
foreach (var usingLib in totalUsingList)
{
String libName = usingLib.Name.ToString();
MetadataReference reference = null;
while (libName != "" && reference == null)
{
if (allLibNames.Contains(libName))
{
break;
}
allLibNames.Add(libName);
try
{
// Add system API libs by MetadataReference.CreateAssemblyReference
reference = MetadataReference.CreateAssemblyReference(libName);
}
catch (Exception)
{
// handle cases that "libName.dll" does not exist
int idx = libName.LastIndexOf('.');
if (idx == -1)
{
libName = "";
break;
}
libName = libName.Substring(0, idx);
}
}
if (reference != null)
{
Logger.Log("Adding reference: " + libName + ".dll");
reflist.Add(reference);
}
}
reflist.AddRange(appReflist);
var compilationOptions = new CompilationOptions(outputKind: OutputKind.WindowsApplication);
var compilation = Compilation.Create(
outputName: "AllCompilation",
options: compilationOptions,
syntaxTrees: treelist,
references: reflist);
return(compilation);
}
private static Type CreateType()
{
SyntaxTree tree = SyntaxTree.ParseText(
@"using System;
namespace Foo
{
public class Bar
{
public static void Test()
{
Console.WriteLine(""Hello World!"");
}
}
}");
var compilation = Compilation.Create("Hello")
.WithOptions(new CompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(MetadataReference.CreateAssemblyReference("mscorlib"))
.AddSyntaxTrees(tree);
ModuleBuilder helloModuleBuilder = AppDomain.CurrentDomain
.DefineDynamicAssembly(new AssemblyName("FooAssembly"), AssemblyBuilderAccess.RunAndCollect)
.DefineDynamicModule("FooModule");
var result = compilation.Emit(helloModuleBuilder);
return(helloModuleBuilder.GetType("Foo.Bar"));
}
private void CompileScripts()
{
lock (_scripts)
{
_scripts.Clear();
var newAssembly = _codeCompiler.Compile(
new[] { SyntaxTree.ParseText(_helixView.TextEditor.Text) },
new[]
{
MetadataReference.CreateAssemblyReference("mscorlib"),
MetadataReference.CreateAssemblyReference("System"),
MetadataReference.CreateAssemblyReference("System.ObjectModel"),
MetadataReference.CreateAssemblyReference("System.Runtime"),
MetadataReference.CreateAssemblyReference("PresentationCore"),
new MetadataFileReference(typeof(IResult).Assembly.Location),
new MetadataFileReference(typeof(AppBootstrapper).Assembly.Location),
new MetadataFileReference(GetType().Assembly.Location)
},
"GeminiDemoScript");
_scripts.AddRange(newAssembly.GetTypes()
.Where(x => typeof(IDemoScript).IsAssignableFrom(x))
.Select(x => (IDemoScript)Activator.CreateInstance(x)));
}
}
public static void EnsureInitialized()
{
if (!Initialized)
{
lock (ThisLock)
{
References = new MetadataReference[] {
MetadataReference.CreateAssemblyReference(typeof(object).Assembly.GetName().Name),
new MetadataFileReference(typeof(SequenceDiagram).Assembly.Location),
new MetadataFileReference(typeof(System.Reactive.Playback).Assembly.Location),
new MetadataFileReference(typeof(Tx.Windows.SystemEvent).Assembly.Location)
};
SyntaxTree tree = SyntaxTree.ParseText(JitPrimeTemplate);
var compilation = Roslyn.Compilers.CSharp.Compilation.Create(
"MyCompilation",
syntaxTrees: new[] { tree },
references: References);
var model = compilation.GetSemanticModel(tree);
var namespaces = model.Compilation.GlobalNamespace.GetMembers()
.Where((e) => e is NamespaceSymbol);
List <NamespaceSymbol> items = new List <NamespaceSymbol>();
foreach (var item in namespaces)
{
items.Add(item as NamespaceSymbol);
}
CsharpSyntaxWalker.NamespaceCollection = items.ToArray();
Initialized = true;
Trace.Assert(NamespaceContainsType("SequenceDiagram") == true);
}
}
}
private Document CreateDocument(string code)
{
var docName = "Test." + this.language == LanguageNames.CSharp ? "cs" : "vb";
var solutionId = SolutionId.CreateNewId("TestSolution");
var projectId = ProjectId.CreateNewId(debugName: "TestProject");
var documentId = DocumentId.CreateNewId(projectId, debugName: docName);
var solution = Solution
.Create(solutionId)
.AddProject(projectId, "TestProject", "TestProject", this.language)
.AddMetadataReference(projectId, MetadataReference.CreateAssemblyReference("mscorlib"))
.AddMetadataReference(projectId, MetadataReference.CreateAssemblyReference("System.Core"));
if (this.language == LanguageNames.VisualBasic)
{
solution = solution.AddMetadataReference(projectId, MetadataReference.CreateAssemblyReference("Microsoft.VisualBasic"));
}
var document = solution
.AddDocument(documentId, docName, SourceText.From(code))
.GetDocument(documentId);
var diags = document.GetSemanticModelAsync().Result.GetDiagnostics().ToArray();
foreach (var diag in diags)
{
Console.WriteLine(diag.ToString());
}
return(document);
}
public static SemanticModel GetSemanticInfo(SyntaxTree tree)
{
// Collect the system API references from using directives
List <MetadataReference> reflist = new List <MetadataReference>();
var root = tree.GetRoot();
var usingList = root.DescendantNodes().OfType <UsingDirectiveSyntax>();
List <String> allLibNames = new List <string>();
foreach (var usingLib in usingList)
{
String libName = usingLib.Name.ToString();
MetadataReference reference = null;
while (libName != "" && reference == null)
{
if (allLibNames.Contains(libName))
{
break;
}
allLibNames.Add(libName);
try
{
// Add system API libs by MetadataReference.CreateAssemblyReference
reference = MetadataReference.CreateAssemblyReference(libName);
}
catch (Exception)
{
// handle cases that "libName.dll" does not exist
int idx = libName.LastIndexOf('.');
if (idx == -1)
{
libName = "";
break;
}
libName = libName.Substring(0, idx);
}
}
if (reference != null)
{
Logger.Log("Adding reference: " + libName + ".dll");
reflist.Add(reference);
}
}
reflist.AddRange(appReflist);
var compilationOptions = new CompilationOptions(outputKind: OutputKind.WindowsApplication);
var compilation = Compilation.Create(
outputName: "ACompilation",
options: compilationOptions,
syntaxTrees: new[] { tree },
references: reflist);
var model = compilation.GetSemanticModel(tree);
return(model);
}
private static Compilation GetCompilation(SyntaxTree tree)
{
var mscorlib = MetadataReference.CreateAssemblyReference("mscorlib");
var compilation = Compilation.Create(
outputName: "HelloWorld",
syntaxTrees: new[] { tree },
references: new[] { mscorlib });
return(compilation);
}
private static IDocument GetDocument(IText text)
{
ProjectId projectId;
DocumentId documentId;
return(Solution.Create(SolutionId.CreateNewId())
.AddCSharpProject("NotifyPropertyChanged", "NotifyPropertyChanged", out projectId)
.AddMetadataReference(projectId, MetadataReference.CreateAssemblyReference("mscorlib"))
.AddMetadataReference(projectId, MetadataReference.CreateAssemblyReference("System"))
.AddDocument(projectId, "ThisFile", text, out documentId)
.GetDocument(documentId));
}
private Compilation CreateCompilation(string name, params SyntaxTree[] syntaxTrees)
{
var mscorlib = MetadataReference.CreateAssemblyReference("mscorlib");
var app = new MetadataFileReference(typeof(LexLogFormat).Assembly.Location);
var compilation = Compilation.Create(
name,
syntaxTrees: syntaxTrees,
references: new[] { mscorlib, app },
options: new CompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimize: true));
return(compilation);
}
private EmitResult CompileToInternal(IEnumerable <JSchema> schemas, Stream stream, string rootNamespace = null)
{
var syntaxTree = GetSyntaxTree(schemas, rootNamespace);
var compilation = Compilation.Create("test", new CompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(MetadataReference.CreateAssemblyReference("mscorlib"))
.AddReferences(MetadataReference.CreateAssemblyReference("System"))
.AddReferences(MetadataReference.CreateAssemblyReference("System.Core"))
.AddSyntaxTrees(syntaxTree);
var result = compilation.Emit(stream);
return(result);
}
public CodeWalker()
{
var mscorlib = MetadataReference.CreateAssemblyReference("mscorlib");
appReflist.Add(mscorlib);
// Find all the application API dll references files
IEnumerable <String> appLibFiles = Directory.EnumerateFiles(IOFile.FolderPath,
"*.dll", SearchOption.AllDirectories);
foreach (var libFile in appLibFiles)
{
// Add application API libs by new MetadataFileReference(libFile)
var reference = new MetadataFileReference(libFile);
appReflist.Add(reference);
}
}
private static Type BuildAndLoadModelTypesIntoAppDomain(string modelSourceCode)
{
var parseOptions = new ParseOptions(
compatibility: CompatibilityMode.None,
languageVersion: LanguageVersion.CSharp5,
preprocessorSymbols: new string[] {});
var syntaxTree = SyntaxTree.ParseText(modelSourceCode, options: parseOptions);
if (syntaxTree.GetDiagnostics().Any())
{
ThrowError("Parsing failed", syntaxTree.GetDiagnostics());
}
var references = new[]
{
MetadataReference.CreateAssemblyReference(typeof(object).Assembly.FullName)
};
var modelDllName = string.Format("Model.{0}.dll", Guid.NewGuid());
var compilation = Compilation.Create(
outputName: modelDllName,
options: new CompilationOptions(OutputKind.DynamicallyLinkedLibrary),
syntaxTrees: new[] { syntaxTree },
references: references);
if (compilation.GetDiagnostics().Any())
{
ThrowError("Compilation failed", compilation.GetDiagnostics());
}
using (var stream = new FileStream(modelDllName, FileMode.OpenOrCreate))
{
var compileResult = compilation.Emit(stream);
if (!compileResult.Success)
{
ThrowError("Compilation emit failed", compileResult.Diagnostics);
}
}
var compiledAssembly = Assembly.LoadFrom(Path.GetFullPath(modelDllName));
return(compiledAssembly.GetTypes().Single(type => type.Name == "ProcessingModel"));
}
private static ExecuteShaderDelegate JitCompileShader(ExecutableInstruction[] instructions)
{
var assemblyReferences = new[]
{
MetadataReference.CreateAssemblyReference("mscorlib"),
new MetadataFileReference(typeof(Number4).Assembly.Location),
new MetadataFileReference(typeof(VirtualMachine).Assembly.Location)
};
const string outputName = "SlimShader.VirtualMachine.Jitter.Generated";
var code = ShaderCodeGenerator.Generate(instructions);
var compilation = Compilation.Create(outputName)
.WithOptions(new CompilationOptions(OutputKind.DynamicallyLinkedLibrary, debugInformationKind: Roslyn.Compilers.Common.DebugInformationKind.Full))
.AddReferences(assemblyReferences)
.AddSyntaxTrees(SyntaxTree.ParseText(code));
var moduleBuilder = AppDomain.CurrentDomain
.DefineDynamicAssembly(new AssemblyName(outputName),
AssemblyBuilderAccess.RunAndCollect)
.DefineDynamicModule(outputName);
System.Diagnostics.Debug.Write(code);
var compilationResult = compilation.Emit(moduleBuilder);
if (!compilationResult.Success)
{
var errorMessage = string.Empty;
foreach (var diagnostic in compilationResult.Diagnostics)
{
errorMessage += diagnostic + Environment.NewLine;
}
throw new Exception(errorMessage);
}
var dynamicClass = moduleBuilder.GetType("DynamicShaderExecutor", false, true);
var dynamicMethod = dynamicClass.GetMethod("Execute");
return((ExecuteShaderDelegate)dynamicMethod.CreateDelegate(typeof(ExecuteShaderDelegate)));
}
public static List <string> CreateLibrary(string path, out Compilation compilation,
out List <StaticClassSource> staticClasses, out Dictionary <CodeLocation, StaticMethodSource> methodsMap,
out List <ClassSource> classes, out Dictionary <CodeLocation, ClassSource> classesMap)
{
var sourceFiles = Directory.GetFiles(path, "*.cs", SearchOption.AllDirectories);
var sources = new List <SyntaxTree>();
compilation = Compilation.Create("DynamicLibraryAssembly", new CompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(MetadataReference.CreateAssemblyReference("mscorlib"))
.AddReferences(MetadataReference.CreateAssemblyReference("System"))
.AddReferences(MetadataReference.CreateAssemblyReference("System.Numerics"));
foreach (var sourceFile in sourceFiles)
{
var src = SyntaxTree.ParseFile(sourceFile);
compilation = compilation.AddSyntaxTrees(src);
sources.Add(src);
}
var errors = compilation.GetDiagnostics().Where(d => d.Info.Severity == DiagnosticSeverity.Error)
.Select(d => d.Info.GetMessage()).ToList();
staticClasses = new List <StaticClassSource>();
methodsMap = new Dictionary <CodeLocation, StaticMethodSource>();
classes = new List <ClassSource>();
classesMap = new Dictionary <CodeLocation, ClassSource>();
if (errors.Any())
{
return(errors);
}
foreach (var syntaxTree in sources)
{
ParseSourceFile(compilation, syntaxTree.GetRoot(), staticClasses, methodsMap, classes, classesMap);
}
return(null);
}
static void test1()
{
SyntaxTree tree = SyntaxTree.ParseFile(@"..\..\..\code\test.cs");
var compilation = Compilation.Create("HelloWorld")
.AddReferences(MetadataReference.CreateAssemblyReference("mscorlib"))
.AddSyntaxTrees(tree);
var model = compilation.GetSemanticModel(tree);
var nameInfo = model.GetSymbolInfo(tree.GetRoot().Usings[0].Name);
var systemSymbol = (NamespaceSymbol)nameInfo.Symbol;
foreach (var ns in systemSymbol.GetNamespaceMembers())
{
Console.WriteLine(ns.Name);
}
//
var helloWorldString = tree.GetRoot().DescendantNodes()
.OfType <LiteralExpressionSyntax>()
.First();
var literalInfo = model.GetTypeInfo(helloWorldString);
var stringTypeSymbol = (NamedTypeSymbol)literalInfo.Type;
Console.Clear();
foreach (var name in (from method in stringTypeSymbol.GetMembers().OfType <MethodSymbol>()
where method.ReturnType == stringTypeSymbol &&
method.DeclaredAccessibility == Accessibility.Public
select method.Name).Distinct())
{
Console.WriteLine(name);
}
}
public void EnumerateSymbolsInCompilation()
{
string file1 = "public class Animal { public virtual void MakeSound() { } }";
string file2 = "class Cat : Animal { public override void MakeSound() { } }";
Compilation compilation = Compilation.Create("test")
.AddSyntaxTrees(SyntaxTree.ParseText(file1), SyntaxTree.ParseText(file2))
.AddReferences(MetadataReference.CreateAssemblyReference("mscorlib"));
NamespaceSymbol globalNamespace = compilation.SourceModule.GlobalNamespace;
StringBuilder sb = new StringBuilder();
EnumSymbols(globalNamespace, symbol => sb.AppendLine(symbol.ToString()));
Assert.AreEqual(@"<global namespace>
Animal
Animal.Animal()
Animal.MakeSound()
Cat
Cat.Cat()
Cat.MakeSound()
", sb.ToString());
}
private static Compilation CreateTestCompilation()
{
SyntaxTree programTree = SyntaxTree.ParseFile(@"..\..\Program.cs");
SyntaxTree rewriterTree = SyntaxTree.ParseFile(@"..\..\TypeInferenceRewriter.cs");
List <SyntaxTree> sourceTrees = new List <SyntaxTree>();
sourceTrees.Add(programTree);
sourceTrees.Add(rewriterTree);
MetadataReference mscorlib = MetadataReference.CreateAssemblyReference("mscorlib");
MetadataReference roslynCompilers = MetadataReference.CreateAssemblyReference("Roslyn.Compilers");
MetadataReference csCompiler = MetadataReference.CreateAssemblyReference("Roslyn.Compilers.CSharp");
List <MetadataReference> references = new List <MetadataReference>();
references.Add(mscorlib);
references.Add(roslynCompilers);
references.Add(csCompiler);
CompilationOptions compilationOptions = new CompilationOptions(OutputKind.ConsoleApplication);
return(Compilation.Create("TransformationCS", compilationOptions, sourceTrees, references));
}
public void Process()
{
var tree = SyntaxTree.ParseText(execTemplate);
CompilationUnitSyntax root = tree.GetRoot();
var body =
(from methodDeclaration in root.DescendantNodes().OfType <MethodDeclarationSyntax>()
where methodDeclaration.Identifier.ValueText == "Main"
select methodDeclaration).Single();
/*
*
* var block = body.Body.WithStatements(
* Syntax.LocalDeclarationStatement(
* Syntax.VariableDeclaration(
* Syntax.IdentifierName(Syntax.Token(SyntaxKind.IntKeyword)))
* .AddVariables(Syntax.VariableDeclarator("x"))));
*/
// var block = body.Body.WithStatements(Syntax.ParseStatement("Dsa.Utility.Guard.ArgumentNull(null, null);").WithLeadingTrivia(Syntax.Tab));
// root = root.ReplaceNode(body.Body, block);
var newTree = SyntaxTree.Create(root);
Console.WriteLine(newTree.GetText());
var comp = Compilation.Create("MyCompilation",
new CompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddSyntaxTrees(newTree)
.AddReferences(new MetadataFileReference(typeof(object).Assembly.Location))
.AddReferences(new MetadataFileReference(@"D:\PLIKI\Dropbox\++Inzynierka\VisualMutator\Projekty do testów\dsa-96133\Dsa\Dsa\bin\Debug\Dsa.dll"))
.AddReferences(new MetadataFileReference(@"C:\Users\SysOp\Documents\Visual Studio 2012\Projects\VisualMutator\VisualMutator\bin\x86\Debug\VisualMutator.dll"))
.AddReferences(MetadataReference.CreateAssemblyReference("System.Linq"));
var outputFileName = Path.Combine(Path.GetTempPath(), "MyCompilation.dll");
// var ilStream = new FileStream(outputFileName, FileMode.OpenOrCreate);
var memStream = new MemoryStream();
var result = comp.Emit(memStream);
// memStream.Close();
if (!result.Success)
{
var aggregate = result.Diagnostics.Select(a => a.Info.GetMessage() + " at line" + a.Location.GetLineSpan(false)).Aggregate((a, b) => a + "\n" + b);
throw new InvalidProgramException(aggregate);
}
AppDomain.CurrentDomain.AssemblyResolve += MyResolver;
AppDomain newDomain = AppDomain.CreateDomain("New Domain");
AppDomainCreator foo = (AppDomainCreator)newDomain.CreateInstanceFromAndUnwrap(
@"C:\Users\SysOp\Documents\Visual Studio 2012\Projects\VisualMutator\VisualMutator\obj\x86\Debug\VisualMutator.dll",
typeof(AppDomainCreator).FullName);
try
{
foo.Execute(memStream.ToArray());
}
catch (Exception e)
{
Console.WriteLine(e);
}
// Console.WriteLine(foo.TestRun(4));
AppDomain.Unload(newDomain);
// Console.ReadLine();
/*
* AppDomainSetup domainSetup = new AppDomainSetup();
* AppDomain domain = AppDomain.CreateDomain("PluginDomain", null, domainSetup);
* var obj = domain.CreateInstanceAndUnwrap().CreateInstanceFromAndUnwrap(@"C:\Users\SysOp\Documents\Visual Studio 2012\Projects\ConsoleApplication1\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe", "ConsoleApplication1.Klasa1");
*
* var m = obj.GetType().GetMethod("Method1");
*
*/
}
/// <summary>
/// Create an assembly from strings
/// </summary>
/// <param name="assemblyName">assembly name</param>
/// <param name="files">files text</param>
/// <param name="references">full name of referred assemblies</param>
/// <param name="errors">compilation errors</param>
/// <returns>Compiled assembly</returns>
public Assembly CreateAssembly(string assemblyName, List <string> files, List <string> references, out List <string> errors)
{
var trees = files.Select(file => SyntaxTree.ParseText(file)).ToList();
var refs = references.Select(r => r.Contains(":") ? MetadataFileProvider.Default.GetReference(r) : MetadataReference.CreateAssemblyReference(r)).ToList();
var compilation = Compilation.Create(
assemblyName,
syntaxTrees: trees,
references: refs,
options: new CompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var stream = new MemoryStream();
var result = compilation.Emit(stream);
if (result.Success)
{
errors = null;
return(Assembly.Load(stream.ToArray()));
}
errors = result.Diagnostics.Select(alert => alert.Info.ToString()).ToList();
return(null);
}
static void Main(string[] args)
{
MetadataReference xunitReference = MetadataReference.CreateAssemblyReference("xunit.dll");
}
/// <summary>
/// Note that it leaves any calls to contract methods in their original locations,
/// i.e., it does *not* extract contracts. That is up to the caller of this method.
/// </summary>
public static bool FileToUnitAndSourceLocationProvider(IMetadataHost host, string filename,
List <string> libPaths,
List <string> referencedAssemblies,
out IModule module,
out ISourceLocationProvider /*?*/ sourceLocationProvider)
{
var text = File.ReadAllText(filename);
SyntaxTree tree = SyntaxTree.ParseText(text, filename);
// This ctor isn't implemented yet.
//var mscorlib = new Roslyn.Compilers.AssemblyObjectReference(typeof(object).Assembly);
var mscorlib = MetadataReference.CreateAssemblyReference("mscorlib"); // Roslyn takes care of resolving where it lives.
var refs = new List <MetadataReference>();
refs.Add(mscorlib);
foreach (var r in referencedAssemblies)
{
refs.Add(MetadataReference.CreateAssemblyReference(Path.GetFileNameWithoutExtension((r))));
}
var baseFileName = Path.GetFileNameWithoutExtension(filename);
var defaultResolver = FileResolver.Default;
var ar = new FileResolver(ReadOnlyArrayExtensions.AsReadOnly(libPaths.Select(lp => Path.GetFullPath(lp))), defaultResolver.KeyFileSearchPaths, defaultResolver.BaseDirectory, defaultResolver.ArchitectureFilter, defaultResolver.PreferredCulture);
var c = Compilation.Create(
baseFileName
, syntaxTrees: new SyntaxTree[] { tree }
, references: refs
, fileResolver: ar
, options: new CompilationOptions(OutputKind.DynamicallyLinkedLibrary)
);
var diags = c.GetDiagnostics();
if (diags.Count() > 0)
{
foreach (var diag in diags)
{
Console.WriteLine(diag.ToString());
}
if (diags.Any(d => d.Info.Severity == DiagnosticSeverity.Error || d.Info.IsWarningAsError))
{
module = Dummy.Module;
sourceLocationProvider = null;
return(false);
}
}
//c = c.AddSyntaxTrees(tree); // Use this form to add another syntax tree to the same compilation (getting a new compilation since they're immutable)
var binding = c.GetSemanticModel(tree);
diags = binding.GetDiagnostics();
if (diags.Count() > 0)
{
foreach (var d in diags)
{
Console.WriteLine(d.ToString());
}
if (diags.Any(d => d.Info.Severity == DiagnosticSeverity.Error || d.Info.IsWarningAsError))
{
module = Dummy.Module;
sourceLocationProvider = null;
return(false);
}
}
ConvertRoslynToCCI(host, tree, binding, out module, out sourceLocationProvider);
return(true);
}
