/// <summary>
/// Builds the corresponding .net core assembly from the code in the given Q# Snippets.
/// Each snippet code is wrapped inside the 'SNIPPETS_NAMESPACE' namespace and processed as a file
/// with the same name as the snippet id.
/// </summary>
public AssemblyInfo BuildSnippets(Snippet[] snippets, CompilerMetadata metadatas, QSharpLogger logger, string dllName)
{
string WrapInNamespace(Snippet s) =>
$"namespace {Snippets.SNIPPETS_NAMESPACE} {{ open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Canon; {s.code} }}";
var sources = snippets.ToImmutableDictionary(s => s.Uri, WrapInNamespace);
return(BuildAssembly(sources, metadatas, logger, dllName));
}
/// <inheritdoc/>
public AssemblyInfo BuildEntryPoint(OperationInfo operation, CompilerMetadata metadatas, QSharpLogger logger, string dllName, string executionTarget = null)
{
var signature = operation.Header.PrintSignature();
var argumentTuple = SyntaxTreeToQsharp.ArgumentTuple(operation.Header.ArgumentTuple, type => type.ToString(), symbolsOnly: true);
var entryPointUri = new Uri(Path.GetFullPath(Path.Combine("/", $"entrypoint.qs")));
var entryPointSnippet = @$ "namespace ENTRYPOINT
{{
open {operation.Header.QualifiedName.Namespace.Value};
/// <summary>
/// Builds the corresponding .net core assembly from the code in the given files.
/// </summary>
public AssemblyInfo BuildFiles(string[] files, CompilerMetadata metadatas, QSharpLogger logger, string dllName)
{
var syntaxTree = BuildQsSyntaxTree(files, metadatas.QsMetadatas, logger);
Uri FileUri(string f) => CompilationUnitManager.TryGetUri(NonNullable <string> .New(f), out var uri) ? uri : null;
var assembly = BuildAssembly(files.Select(FileUri).ToArray(), syntaxTree, metadatas.RoslynMetadatas, logger, dllName);
return(assembly);
}
/// <summary>
/// Builds the corresponding .net core assembly from the code in the given Q# Snippets.
/// Each snippet code is wrapped inside the 'SNIPPETS_NAMESPACE' namespace and processed as a file
/// with the same name as the snippet id.
/// </summary>
public AssemblyInfo BuildSnippets(Snippet[] snippets, CompilerMetadata metadatas, QSharpLogger logger, string dllName)
{
string WrapInNamespace(Snippet s) => $"namespace {Snippets.SNIPPETS_NAMESPACE} {{ open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Canon; {s.code} }}";
var sources = snippets.ToDictionary(s => s.Uri, WrapInNamespace);
var syntaxTree = BuildQsSyntaxTree(sources.ToImmutableDictionary(), metadatas.QsMetadatas, logger);
var assembly = BuildAssembly(sources.Keys.ToArray(), syntaxTree, metadatas.RoslynMetadatas, logger, dllName);
return(assembly);
}
/// <summary>
/// Builds the corresponding .net core assembly from the Q# syntax tree.
/// </summary>
private AssemblyInfo BuildAssembly(ImmutableDictionary <Uri, string> sources, CompilerMetadata metadata, QSharpLogger logger, string dllName)
{
logger.LogDebug($"Compiling the following Q# files: {string.Join(",", sources.Keys.Select(f => f.LocalPath))}");
var qsCompilation = this.UpdateCompilation(sources, metadata.QsMetadatas, logger);
if (logger.HasErrors)
{
return(null);
}
try
{
// Generate C# simulation code from Q# syntax tree and convert it into C# syntax trees:
var trees = new List <SyntaxTree>();
NonNullable <string> GetFileId(Uri uri) => CompilationUnitManager.TryGetFileId(uri, out var id) ? id : NonNullable <string> .New(uri.AbsolutePath);
foreach (var file in sources.Keys)
{
var sourceFile = GetFileId(file);
var code = SimulationCode.generate(sourceFile, CodegenContext.Create(qsCompilation.Namespaces));
var tree = CSharpSyntaxTree.ParseText(code, encoding: UTF8Encoding.UTF8);
trees.Add(tree);
logger.LogDebug($"Generated the following C# code for {sourceFile.Value}:\n=============\n{code}\n=============\n");
}
// Compile the C# syntax trees:
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Debug);
var compilation = CSharpCompilation.Create(
Path.GetFileNameWithoutExtension(dllName),
trees,
metadata.RoslynMetadatas,
options);
// Generate the assembly from the C# compilation:
using (var ms = new MemoryStream())
using (var bsonStream = new MemoryStream())
{
using var writer = new BsonDataWriter(bsonStream)
{
CloseOutput = false
};
var fromSources = qsCompilation.Namespaces.Select(ns => FilterBySourceFile.Apply(ns, s => s.Value.EndsWith(".qs")));
Json.Serializer.Serialize(writer, new QsCompilation(fromSources.ToImmutableArray(), qsCompilation.EntryPoints));
var resourceDescription = new ResourceDescription
(
resourceName: QsCompiler.ReservedKeywords.DotnetCoreDll.ResourceName,
dataProvider: () => new MemoryStream(bsonStream.ToArray()),
isPublic: true
);
var result = compilation.Emit(ms, manifestResources: new[] { resourceDescription });
if (!result.Success)
{
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
logger.LogError("IQS000", "Could not compile Roslyn dll from working folder.");
foreach (Diagnostic diagnostic in failures)
{
logger.LogError(diagnostic.Id, diagnostic.GetMessage());
}
return(null);
}
else
{
logger.LogDebug($"Assembly successfully generated. Caching at {dllName}.");
var data = ms.ToArray();
try
{
File.WriteAllBytes(dllName, data);
}
catch (Exception e)
{
logger.LogError("IQS001", $"Unable to save assembly cache: {e.Message}.");
}
return(new AssemblyInfo(Assembly.Load(data), dllName, fromSources.ToArray()));
}
}
}
catch (Exception e)
{
logger.LogError("IQS002", $"Unexpected error compiling assembly: {e.Message}.");
return(null);
}
}
/// <summary>
/// Builds the corresponding .net core assembly from the code in the given files.
/// </summary>
public AssemblyInfo BuildFiles(string[] files, CompilerMetadata metadatas, QSharpLogger logger, string dllName)
{
var sources = ProjectManager.LoadSourceFiles(files, d => logger?.Log(d), ex => logger?.Log(ex));
return(BuildAssembly(sources, metadatas, logger, dllName));
}