From a845ccbb00a82463fe24861351d6ab2c7c49f146 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Tue, 1 Dec 2020 23:00:25 +0100 Subject: [PATCH 01/18] First proposal for auto emulation feature. --- Simulation.sln | 19 ++ .../AutoEmulation/AutoEmulation.csproj | 25 ++ src/Simulation/AutoEmulation/CodeGenerator.cs | 294 ++++++++++++++++++ src/Simulation/AutoEmulation/Emulation.qs | 15 + src/Simulation/AutoEmulation/RewriteStep.cs | 118 +++++++ 5 files changed, 471 insertions(+) create mode 100644 src/Simulation/AutoEmulation/AutoEmulation.csproj create mode 100644 src/Simulation/AutoEmulation/CodeGenerator.cs create mode 100644 src/Simulation/AutoEmulation/Emulation.qs create mode 100644 src/Simulation/AutoEmulation/RewriteStep.cs diff --git a/Simulation.sln b/Simulation.sln index 8b6e60cdf10..3de4905a3f2 100644 --- a/Simulation.sln +++ b/Simulation.sln @@ -67,6 +67,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TargetedExe", "src\Simulati EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntrinsicTests", "src\Simulation\Simulators.Tests\TestProjects\IntrinsicTests\IntrinsicTests.csproj", "{D5D41201-101F-4C0D-B6A0-201D8FC3AB91}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoEmulation", "src\Simulation\AutoEmulation\AutoEmulation.csproj", "{84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -495,6 +497,22 @@ Global {D5D41201-101F-4C0D-B6A0-201D8FC3AB91}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU {D5D41201-101F-4C0D-B6A0-201D8FC3AB91}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU {D5D41201-101F-4C0D-B6A0-201D8FC3AB91}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Debug|x64.ActiveCfg = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Debug|x64.Build.0 = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Release|Any CPU.Build.0 = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Release|x64.ActiveCfg = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.Release|x64.Build.0 = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.RelWithDebInfo|Any CPU.ActiveCfg = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.RelWithDebInfo|Any CPU.Build.0 = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.RelWithDebInfo|x64.ActiveCfg = Release|Any CPU + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C}.RelWithDebInfo|x64.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -527,6 +545,7 @@ Global {C015FF41-9A51-4AF0-AEFC-2547D596B10A} = {09C842CB-930C-4C7D-AD5F-E30DE4A55820} {D292BF18-3956-4827-820E-254C3F81EF09} = {09C842CB-930C-4C7D-AD5F-E30DE4A55820} {D5D41201-101F-4C0D-B6A0-201D8FC3AB91} = {09C842CB-930C-4C7D-AD5F-E30DE4A55820} + {84CB9C12-0D35-45ED-8A04-F5EBC0DF235C} = {A567C185-A429-418B-AFDE-6F1785BA4A77} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {929C0464-86D8-4F70-8835-0A5EAF930821} diff --git a/src/Simulation/AutoEmulation/AutoEmulation.csproj b/src/Simulation/AutoEmulation/AutoEmulation.csproj new file mode 100644 index 00000000000..d39b5a45dd8 --- /dev/null +++ b/src/Simulation/AutoEmulation/AutoEmulation.csproj @@ -0,0 +1,25 @@ + + + + Library + netstandard2.1 + Enable + x64 + true + + + + Microsoft.Quantum.AutoEmulation + Microsoft + Code generation for simulator emulation. + © Microsoft Corporation. All rights reserved. + true + true + snupkg + $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb;.xml + + + + + + diff --git a/src/Simulation/AutoEmulation/CodeGenerator.cs b/src/Simulation/AutoEmulation/CodeGenerator.cs new file mode 100644 index 00000000000..2f30e2f00e5 --- /dev/null +++ b/src/Simulation/AutoEmulation/CodeGenerator.cs @@ -0,0 +1,294 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Editing; +using Microsoft.Quantum.QsCompiler.CsharpGeneration; +using Microsoft.Quantum.QsCompiler.SyntaxTree; + +namespace Microsoft.Quantum.QsCompiler.AutoEmulation +{ + public class CodeGenerator + { + public CodeGenerator(CodegenContext context) + { + ctx = context; + gen = Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetGenerator(new AdhocWorkspace(), LanguageNames.CSharp); + } + + /// + /// Generates an emulation class for a given callable with a given name + /// + /// + /// + /// In the following we illustrate the syntax that is generated using + /// as an example the `Microsoft.Quantum.Canon.ApplyAnd` operation with + /// `Microsoft.Quantum.Intrinsic.CCNOT` as an alternative when using + /// `ToffoliSimulator`. + /// + /// The generated code looks as follows: + /// + /// + /// namespace Microsoft.Quantum.Canon { + /// public partial class ApplyAnd { + /// public class Native : ApplyAnd { + /// public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m) : base(m) { + /// sim0 = m as ToffoliSimulator; + /// } + /// + /// public override void __Init__() { + /// base.Init(); + /// if (sim0 != null) alternative0 = __Factory__.Get<Microsoft.Quantum.Intrinsic.CCNOT>(typeof(Microsoft.Quantum.Intrinsic.CCNOT)); + /// } + /// + /// public override Func<(Qubit, Qubit, Qubit), QVoid> __Body__ => args => { + /// if (sim0 != null) return alternative0.__Body__(args); + /// else return base.__Body__(args); + /// } + /// + /// // methods for other specializations ... + /// + /// private ToffoliSimulator sim0 = null; + /// private Microsoft.Quantum.Intrinsic.CCNOT alternative0 = null; + /// } + /// } + /// } + /// + /// + /// + /// Namespace and name of the callable + /// Q# Callable + /// All attribute values from @EmulateWith attributes of that callable + public void AddCallable(QsQualifiedName name, QsCallable callable, IEnumerable<(string AlternativeOperation, string InSimulator)> emulationAttributes) + { + var attributes = emulationAttributes.Select((attr, idx) => new EmulationAttribute( + SyntaxFactory.ParseTypeName(attr.AlternativeOperation), + gen.IdentifierName($"alternative{idx}"), + SyntaxFactory.ParseTypeName(attr.InSimulator), + gen.IdentifierName($"sim{idx}") + )); + + var operationFields = attributes.Select(CreateOperationField); + var simulatorFields = attributes.Select(CreateSimulatorField); + + var specializationProperties = callable.Specializations.Select(specialization => + CreateSpecializationProperty( + specializationName: specialization.Kind switch + { + var kind when kind.IsQsBody => "__Body__", + var kind when kind.IsQsAdjoint => "__AdjointBody__", + var kind when kind.IsQsControlled => "__ControlledBody__", + var kind when kind.IsQsControlledAdjoint => "__ControlledAdjointBody__", + _ => throw new Exception("unexpected specialization kind") + }, + attributes: attributes, + argumentType: SimulationCode.roslynTypeName(ctx, specialization.Signature.ArgumentType), + returnType: SimulationCode.roslynTypeName(ctx, specialization.Signature.ReturnType)) + ); + + var innerClass = gen.ClassDeclaration( + "Native", + accessibility: Accessibility.Public, + baseType: gen.IdentifierName(name.Name), + members: new[] { + CreateConstructor(attributes.Select(CreateSimulatorCast)), + CreateInitMethod(attributes.Select(CreateOperationAssignment)) + }.Concat(specializationProperties).Concat(operationFields).Concat(simulatorFields)); + + var cls = gen.ClassDeclaration( + name.Name, + accessibility: callable.Modifiers.Access.IsInternal ? Accessibility.Internal : Accessibility.Public, + modifiers: DeclarationModifiers.Partial, + members: new[] { innerClass }); + + InsertClassNode(name.Namespace, cls); + } + + /// + /// Creates a syntax node for the constructor of the inner Native class + /// + private SyntaxNode CreateConstructor(IEnumerable bodyStatements) => + gen.ConstructorDeclaration( + "Native", + parameters: new[] { gen.ParameterDeclaration("m", SyntaxFactory.ParseTypeName("Microsoft.Quantum.Simulation.Core.IOperationFactory")) }, + accessibility: Accessibility.Public, + baseConstructorArguments: new[] { gen.IdentifierName("m") }, + statements: bodyStatements); + + /// + /// Creates a syntax node for the Init() method of the inner Native class + /// + private SyntaxNode CreateInitMethod(IEnumerable bodyStatements) => + gen.MethodDeclaration( + "__Init__", + accessibility: Accessibility.Public, + modifiers: DeclarationModifiers.Override, + statements: new[] { + gen.ExpressionStatement( + gen.InvocationExpression(gen.MemberAccessExpression(gen.BaseExpression(), "__Init__")) + ) + }.Concat(bodyStatements)); + + /// + /// Creates a syntax node for field declarations for the alternative operations + /// + private SyntaxNode CreateOperationField(EmulationAttribute attr) => + gen.FieldDeclaration( + attr.OperationName.ToFullString(), + type: attr.OperationType, + accessibility: Accessibility.Private, + initializer: gen.NullLiteralExpression()); + + /// + /// Creates a syntax node for operation field assignments in the Init() method + /// + private SyntaxNode CreateOperationAssignment(EmulationAttribute attr) => + gen.IfStatement( + condition: gen.ValueNotEqualsExpression(attr.SimulatorName, gen.NullLiteralExpression()), + trueStatements: new[] + { + gen.AssignmentStatement( + left: attr.OperationName, + right: CreateFactoryGetStatement(attr.OperationType)) + } + ); + + /// + /// Creates a syntax node for the __Factory__.Get statement in operation field assignments + /// + private SyntaxNode CreateFactoryGetStatement(SyntaxNode type) => + gen.InvocationExpression( + gen.MemberAccessExpression( + gen.IdentifierName("__Factory__"), + gen.GenericName("Get", type)), + gen.TypeOfExpression(type)); + + /// + /// Creates a syntax node for field declarations for the simulators + /// + /// + /// + private SyntaxNode CreateSimulatorField(EmulationAttribute attr) => + gen.FieldDeclaration( + attr.SimulatorName.ToFullString(), + type: attr.SimulatorType, + accessibility: Accessibility.Private, + initializer: gen.NullLiteralExpression()); + + /// + /// Creates a syntax node for the simulator field cast assignments in the constructor + /// + /// + /// + private SyntaxNode CreateSimulatorCast(EmulationAttribute attr) => + gen.AssignmentStatement( + left: attr.SimulatorName, + right: gen.TryCastExpression(gen.IdentifierName("m"), attr.SimulatorType) + ); + + /// + /// Creates a syntax node for one specialization property + /// + private SyntaxNode CreateSpecializationProperty(string specializationName, IEnumerable attributes, string argumentType, string returnType) => + gen.PropertyDeclaration( + specializationName, + type: SyntaxFactory.ParseTypeName($"Func<{argumentType}, {returnType}>"), + accessibility: Accessibility.Public, + modifiers: DeclarationModifiers.Override | DeclarationModifiers.ReadOnly, + getAccessorStatements: new[] { gen.ReturnStatement(CreateSpecializationLambda(specializationName, attributes)) }); + + /// + /// Creates a syntax node for the lambda expression, returned in the + /// `get` accessor of a specialization property + /// + private SyntaxNode CreateSpecializationLambda(string specializationName, IEnumerable attrs) => + gen.ValueReturningLambdaExpression( + "args", + new[] + { + CreateSpecializationBody(specializationName, attrs) + }); + + /// + /// Creates a syntax node for a nested if-statement for all possible + /// operation alternatives + /// + private SyntaxNode CreateSpecializationBody(string specializationName, IEnumerable attrs) => + attrs.Count() switch + { + 0 => gen.ReturnStatement( + gen.InvocationExpression( + gen.MemberAccessExpression(gen.BaseExpression(), specializationName), + gen.IdentifierName("args"))), + _ => gen.IfStatement( + condition: gen.ValueNotEqualsExpression(attrs.First().SimulatorName, gen.NullLiteralExpression()), + trueStatements: new[] { + gen.ReturnStatement( + gen.InvocationExpression( + gen.MemberAccessExpression(attrs.First().OperationName, specializationName), + gen.IdentifierName("args"))) }, + falseStatement: CreateSpecializationBody(specializationName, attrs.Skip(1))) + }; + + /// + /// Inserts a syntax node for a class declaration into a list for its + /// corresponding namespace + /// + /// Namespace name + /// Syntax node for class declaration + private void InsertClassNode(string @namespace, SyntaxNode classNode) + { + if (!classNodes.ContainsKey(@namespace)) + { + classNodes.Add(@namespace, new List()); + } + + classNodes[@namespace].Add(classNode); + } + + /// + /// Group class declarations of the same namespace into a namespace node + /// + private IEnumerable GetNamespaceNodes() => + classNodes.Select(pair => gen.NamespaceDeclaration(pair.Key, pair.Value)); + + /// + /// Write namespaces into a text writer + /// + /// Text writer, e.g., `Console.Out` + public void WriteTo(TextWriter writer) => + gen.CompilationUnit( + new[] { "System", "Microsoft.Quantum.Simulation.Core", "Microsoft.Quantum.Simulation.Simulators" }.Select(gen.NamespaceImportDeclaration) + .Concat(GetNamespaceNodes()) + ).NormalizeWhitespace().WriteTo(writer); + + /// + /// Helper struct to prepare syntax nodes for @EmulationWith attribute values + /// + private class EmulationAttribute + { + public EmulationAttribute(SyntaxNode operationType, SyntaxNode operationName, SyntaxNode simulatorType, SyntaxNode simulatorName) + { + OperationType = operationType; + OperationName = operationName; + SimulatorType = simulatorType; + SimulatorName = simulatorName; + } + + public SyntaxNode OperationType { get; private set; } + public SyntaxNode OperationName { get; private set; } + public SyntaxNode SimulatorType { get; private set; } + public SyntaxNode SimulatorName { get; private set; } + } + + private readonly CodegenContext ctx; + private readonly Microsoft.CodeAnalysis.Editing.SyntaxGenerator gen; + + /// + /// Contains class nodes by namespace names + /// + private readonly Dictionary> classNodes = new Dictionary>(); + } +} diff --git a/src/Simulation/AutoEmulation/Emulation.qs b/src/Simulation/AutoEmulation/Emulation.qs new file mode 100644 index 00000000000..8dea7fc4378 --- /dev/null +++ b/src/Simulation/AutoEmulation/Emulation.qs @@ -0,0 +1,15 @@ +namespace Microsoft.Quantum.Core +{ + /// # Summary + /// Enables to emulate an operation with an alternative operation for a given simulator + /// + /// # Named Items + /// ## AlternativeOperation + /// Fully qualified name of alternative operation to emulate operation with. + /// + /// ## InSimulator + /// One of `QuantumSimulator`, `ToffoliSimulator`, or `ResourcesEstimator`, or a fully qualified name + /// of a custom simulator. + @Attribute() + newtype EmulateWith = (AlternativeOperation : String, InSimulator : String); +} diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs new file mode 100644 index 00000000000..a86d6cead20 --- /dev/null +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -0,0 +1,118 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Linq; +using Microsoft.CodeAnalysis; +using Microsoft.Quantum.QsCompiler.CsharpGeneration; +using Microsoft.Quantum.QsCompiler.SyntaxTokens; +using Microsoft.Quantum.QsCompiler.SyntaxTree; + +namespace Microsoft.Quantum.QsCompiler.AutoEmulation +{ + /// + /// A Q# rewrite step for auto emulation + /// + /// + /// + /// This rewrite step creates custom emulators for operations that have the + /// `EmulateWith` attribute. This attribute holds an alternative operation, + /// with the same signature, as its first argument, and a simulator, for which + /// the alternative operation should be used, as its second argument. + /// + public class RewriteStep : IRewriteStep + { + public string Name => "AutoEmulation"; + + // This rewrite step needs to be run before C# code generation + public int Priority => -2; + + public IDictionary AssemblyConstants { get; } = new Dictionary(); + + public IEnumerable GeneratedDiagnostics => diagnostics; + + public bool ImplementsPreconditionVerification => false; + + public bool ImplementsTransformation => true; + + public bool ImplementsPostconditionVerification => false; + + public bool PostconditionVerification(QsCompilation compilation) => throw new System.NotImplementedException(); + + public bool PreconditionVerification(QsCompilation compilation) => throw new System.NotImplementedException(); + + public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out QsCompilation? transformed) + { + // we do not change the Q# syntax tree + transformed = compilation; + + // collect all callables that have an emulation attribute + var globals = compilation.Namespaces + .GlobalCallableResolutions() + .Where(p => p.Value.SourceFile.EndsWith(".qs")) + .Where(p => p.Value.Attributes.Any(HasEmulationAttribute)); + + if (!globals.Any()) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Info, + Message = "AutoEmulation: no operations have @EmulateWith attribute", + Stage = IRewriteStep.Stage.Transformation + }); + return true; + } + + // no need to generate any C# file, if there is no emulation attribute, or if we cannot retrieve the output path + if (!AssemblyConstants.TryGetValue(Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants.OutputPath, out var outputPath)) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Error, + Message = "AutoEmulation: cannot determine output path for generated C# code", + Stage = IRewriteStep.Stage.Transformation + }); + return true; + } + + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Info, + Message = $"AutoEmulation: Generating file __AutoEmulation__.g.cs in {outputPath}", + Stage = IRewriteStep.Stage.Transformation + }); + + using var writer = new StreamWriter(Path.Combine(outputPath, "__AutoEmulation__.g.cs")); + var context = CodegenContext.Create(compilation, AssemblyConstants); + + var generator = new CodeGenerator(context); + foreach (var (key, value) in globals) + { + generator.AddCallable(key, value, value.Attributes.Where(HasEmulationAttribute).Select(GetEmulationAttributeArguments)); + } + generator.WriteTo(writer); + + + return true; + } + + private static bool HasEmulationAttribute(QsDeclarationAttribute attribute) => + attribute.TypeId.IsValue && attribute.TypeId.Item.Namespace == "Microsoft.Quantum.Core" && attribute.TypeId.Item.Name == "EmulateWith"; + + private static (string AlternativeOperation, string InSimulator) GetEmulationAttributeArguments(QsDeclarationAttribute attribute) => + attribute.Argument.Expression switch + { + QsExpressionKind.ValueTuple tuple => + tuple.Item switch + { + var arr when arr.Count() == 2 => + (arr.ElementAt(0).Expression, arr.ElementAt(1).Expression) switch + { + (QsExpressionKind.StringLiteral alternativeOperation, QsExpressionKind.StringLiteral inSimulator) => (alternativeOperation.Item1, inSimulator.Item1), + _ => throw new Exception("Unexpected argument") + }, + _ => throw new Exception("Unexpected argument") + }, + _ => throw new Exception("Unexpected argument") + }; + + private List diagnostics = new List(); + } +} From 807e9d1759d1a5dc08e4a98c5b865d4b04b3d4c2 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Thu, 11 Feb 2021 16:48:52 +0100 Subject: [PATCH 02/18] Deprecation. --- src/Simulation/AutoEmulation/RewriteStep.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs index a86d6cead20..8b2c4caf77b 100644 --- a/src/Simulation/AutoEmulation/RewriteStep.cs +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -49,7 +49,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs // collect all callables that have an emulation attribute var globals = compilation.Namespaces .GlobalCallableResolutions() - .Where(p => p.Value.SourceFile.EndsWith(".qs")) + .Where(p => p.Value.Source.CodeFile.EndsWith(".qs")) .Where(p => p.Value.Attributes.Any(HasEmulationAttribute)); if (!globals.Any()) From c45a3cdb703b96fa85981b222ead40f75215ddef Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Thu, 11 Feb 2021 16:49:08 +0100 Subject: [PATCH 03/18] Update to newer version. --- src/Simulation/AutoEmulation/AutoEmulation.csproj | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Simulation/AutoEmulation/AutoEmulation.csproj b/src/Simulation/AutoEmulation/AutoEmulation.csproj index d39b5a45dd8..2bc758a2e26 100644 --- a/src/Simulation/AutoEmulation/AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation/AutoEmulation.csproj @@ -1,4 +1,4 @@ - + Library @@ -20,6 +20,7 @@ - + + From 3d78eae7a3777de91d43711112e4a7714f761063 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Thu, 11 Feb 2021 16:49:17 +0100 Subject: [PATCH 04/18] Successful tests. --- .../CodeGenerationTests.cs | 59 ++++++++++ .../AutoEmulation.Tests/TestFiles/Success.cs_ | 49 ++++++++ .../AutoEmulation.Tests/TestFiles/Success.qs | 6 + .../TestFiles/SuccessA.cs_ | 69 +++++++++++ .../AutoEmulation.Tests/TestFiles/SuccessA.qs | 6 + .../TestFiles/SuccessC.cs_ | 69 +++++++++++ .../AutoEmulation.Tests/TestFiles/SuccessC.qs | 6 + .../TestFiles/SuccessCA.cs_ | 109 ++++++++++++++++++ .../TestFiles/SuccessCA.qs | 6 + .../Tests.AutoEmulation.csproj | 54 +++++++++ 10 files changed, 433 insertions(+) create mode 100644 src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs create mode 100644 src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj diff --git a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs new file mode 100644 index 00000000000..eb81480db72 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs @@ -0,0 +1,59 @@ +using System; +using System.IO; +using Microsoft.Quantum.QsCompiler.AutoEmulation; +using Microsoft.Quantum.QsCompiler.CompilationBuilder; +using Xunit; +using System.Linq; +using System.Collections.Immutable; +using Microsoft.Quantum.QsCompiler.ReservedKeywords; + +namespace Microsoft.Quantum.AutoEmulation.Testing +{ + public class CodeGenerationTests + { + [Fact] + public void CanGenerateAutoEmulationCode() + { + TestOneSuccessfulFile("Success"); + TestOneSuccessfulFile("SuccessA"); + TestOneSuccessfulFile("SuccessC"); + TestOneSuccessfulFile("SuccessCA"); + } + + private void TestOneSuccessfulFile(string fileName) + { + var step = new RewriteStep(); + var path = CreateNewTemporaryPath(); + step.AssemblyConstants[AssemblyConstants.OutputPath] = path; + + var mgr = new CompilationUnitManager(); + var files = CreateFileManager("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + mgr.AddOrUpdateSourceFilesAsync(files).Wait(); + var compilation = mgr.Build().BuiltCompilation; + + Assert.True(step.Transformation(compilation, out var transformed)); + Assert.Single(step.GeneratedDiagnostics); + var generatedFileName = Path.Combine(path, "__AutoEmulation__.g.cs"); + Assert.True(File.Exists(generatedFileName)); + + // uncomment, when creating files with expected content + //File.Copy(generatedFileName, $"{fileName}.cs_", true); + + Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")), File.ReadAllText(generatedFileName)); + + Directory.Delete(path, true); + } + + private ImmutableHashSet CreateFileManager(params string[] fileNames) => + CompilationUnitManager.InitializeFileManagers( + fileNames.Select(fileName => { + var fileId = new Uri(Path.GetFullPath(fileName)); + return (id: fileId, content: File.ReadAllText(fileName)); + }).ToDictionary(t => t.id, t => t.content) + ); + + private readonly System.Random random = new System.Random(); + private string CreateNewTemporaryPath() => + Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), $"emulation-test-{random.Next(Int32.MaxValue)}")).FullName; + } +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ new file mode 100644 index 00000000000..58d2b363812 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ @@ -0,0 +1,49 @@ +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoEmulationTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + private AutoEmulationTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } +} \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs new file mode 100644 index 00000000000..378d7c82350 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + operation Success() : Unit {} + + operation SuccessClassical() : Unit {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ new file mode 100644 index 00000000000..be0c1dbe05d --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ @@ -0,0 +1,69 @@ +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoEmulationTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func __AdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__AdjointBody__(args); + } + else + { + return base.__AdjointBody__(args); + } + } + + ; + } + } + + private AutoEmulationTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } +} \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs new file mode 100644 index 00000000000..cc59e4a8665 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + operation Success() : Unit is Adj {} + + operation SuccessClassical() : Unit is Adj {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ new file mode 100644 index 00000000000..9d07f38600b --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ @@ -0,0 +1,69 @@ +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoEmulationTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledBody__(args); + } + else + { + return base.__ControlledBody__(args); + } + } + + ; + } + } + + private AutoEmulationTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } +} \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs new file mode 100644 index 00000000000..a4eee110312 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + operation Success() : Unit is Ctl {} + + operation SuccessClassical() : Unit is Ctl {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ new file mode 100644 index 00000000000..458e41f0c20 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ @@ -0,0 +1,109 @@ +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoEmulationTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func __AdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__AdjointBody__(args); + } + else + { + return base.__AdjointBody__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledBody__(args); + } + else + { + return base.__ControlledBody__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledAdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledAdjointBody__(args); + } + else + { + return base.__ControlledAdjointBody__(args); + } + } + + ; + } + } + + private AutoEmulationTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } +} \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs new file mode 100644 index 00000000000..0bf045306b3 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + operation Success() : Unit is Adj+Ctl {} + + operation SuccessClassical() : Unit is Adj+Ctl {} +} diff --git a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj new file mode 100644 index 00000000000..0fbef6e6b13 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj @@ -0,0 +1,54 @@ + + + + netcoreapp3.1 + Tests.Microsoft.Quantum.AutoEmulation + false + x64 + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + + + + all + runtime; build; native; contentfiles; analyzers + + + + + + + + + From d92efa9d43cd1a7701b706959f4f7874dcba1e95 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Thu, 11 Feb 2021 17:50:39 +0100 Subject: [PATCH 05/18] Compatibility checks. --- .../CodeGenerationTests.cs | 43 +++++++++--- .../TestFiles/FailAlternativeDoesNotExist.qs | 4 ++ .../TestFiles/FailDifferentSignatures.qs | 6 ++ .../FailDifferentSpecializationKinds.qs | 6 ++ .../TestFiles/FailNoNamespace.qs | 6 ++ .../Tests.AutoEmulation.csproj | 12 ++++ src/Simulation/AutoEmulation/RewriteStep.cs | 66 +++++++++++++++++-- 7 files changed, 128 insertions(+), 15 deletions(-) create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs diff --git a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs index eb81480db72..67e6fde1427 100644 --- a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs @@ -1,11 +1,12 @@ using System; +using System.Collections.Immutable; using System.IO; +using System.Linq; using Microsoft.Quantum.QsCompiler.AutoEmulation; using Microsoft.Quantum.QsCompiler.CompilationBuilder; -using Xunit; -using System.Linq; -using System.Collections.Immutable; using Microsoft.Quantum.QsCompiler.ReservedKeywords; +using Microsoft.Quantum.QsCompiler.SyntaxTree; +using Xunit; namespace Microsoft.Quantum.AutoEmulation.Testing { @@ -20,19 +21,24 @@ public void CanGenerateAutoEmulationCode() TestOneSuccessfulFile("SuccessCA"); } + [Fact] + public void CanFailForVariousReasons() + { + TestOneFailingFile("FailAlternativeDoesNotExist"); + TestOneFailingFile("FailDifferentSignatures"); + TestOneFailingFile("FailDifferentSpecializationKinds"); + TestOneFailingFile("FailNoNamespace"); + } + private void TestOneSuccessfulFile(string fileName) { var step = new RewriteStep(); var path = CreateNewTemporaryPath(); step.AssemblyConstants[AssemblyConstants.OutputPath] = path; - var mgr = new CompilationUnitManager(); - var files = CreateFileManager("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); - mgr.AddOrUpdateSourceFilesAsync(files).Wait(); - var compilation = mgr.Build().BuiltCompilation; + var compilation = CreateCompilation("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); Assert.True(step.Transformation(compilation, out var transformed)); - Assert.Single(step.GeneratedDiagnostics); var generatedFileName = Path.Combine(path, "__AutoEmulation__.g.cs"); Assert.True(File.Exists(generatedFileName)); @@ -44,6 +50,27 @@ private void TestOneSuccessfulFile(string fileName) Directory.Delete(path, true); } + private void TestOneFailingFile(string fileName) + { + var step = new RewriteStep(); + var path = CreateNewTemporaryPath(); + step.AssemblyConstants[AssemblyConstants.OutputPath] = path; + + var compilation = CreateCompilation("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + + Assert.False(step.Transformation(compilation, out var transformed)); + Assert.Equal(2, step.GeneratedDiagnostics.Count()); + Assert.Equal(CodeAnalysis.DiagnosticSeverity.Error, step.GeneratedDiagnostics.Last().Severity); + } + + private QsCompilation CreateCompilation(params string[] fileNames) + { + var mgr = new CompilationUnitManager(); + var files = CreateFileManager(fileNames); + mgr.AddOrUpdateSourceFilesAsync(files).Wait(); + return mgr.Build().BuiltCompilation; + } + private ImmutableHashSet CreateFileManager(params string[] fileNames) => CompilationUnitManager.InitializeFileManagers( fileNames.Select(fileName => { diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs new file mode 100644 index 00000000000..43a47e68adb --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs @@ -0,0 +1,4 @@ +namespace AutoEmulationTests { + @EmulateWith("Namespace.NotExisting", "ToffoliSimulator") + operation Fail() : Unit {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs new file mode 100644 index 00000000000..482e5fa446c --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("AutoEmulationTests.FailClassical", "ToffoliSimulator") + operation Fail(a : Int) : Unit {} + + operation FailClassical(a : Double) : Unit {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs new file mode 100644 index 00000000000..d8d2baa0ec4 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("FailClassical", "ToffoliSimulator") + operation Fail() : Unit is Adj {} + + operation FailClassical() : Unit {} +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs new file mode 100644 index 00000000000..71deb74caf4 --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs @@ -0,0 +1,6 @@ +namespace AutoEmulationTests { + @EmulateWith("FailClassical", "ToffoliSimulator") + operation Fail() : Unit {} + + operation FailClassical() : Unit {} +} diff --git a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj index 0fbef6e6b13..9255f61e685 100644 --- a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj @@ -35,6 +35,18 @@ PreserveNewest + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs index 8b2c4caf77b..b13e14772b0 100644 --- a/src/Simulation/AutoEmulation/RewriteStep.cs +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -46,11 +46,12 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs // we do not change the Q# syntax tree transformed = compilation; + // global callables + var globalCallables = compilation.Namespaces.GlobalCallableResolutions(); + // collect all callables that have an emulation attribute - var globals = compilation.Namespaces - .GlobalCallableResolutions() - .Where(p => p.Value.Source.CodeFile.EndsWith(".qs")) - .Where(p => p.Value.Attributes.Any(HasEmulationAttribute)); + var globals = globalCallables.Where(p => p.Value.Source.CodeFile.EndsWith(".qs")) + .Where(p => p.Value.Attributes.Any(HasEmulationAttribute)); if (!globals.Any()) { @@ -70,7 +71,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs Message = "AutoEmulation: cannot determine output path for generated C# code", Stage = IRewriteStep.Stage.Transformation }); - return true; + return false; } diagnostics.Add(new IRewriteStep.Diagnostic { @@ -83,9 +84,57 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs var context = CodegenContext.Create(compilation, AssemblyConstants); var generator = new CodeGenerator(context); - foreach (var (key, value) in globals) + foreach (var (key, callable) in globals) { - generator.AddCallable(key, value, value.Attributes.Where(HasEmulationAttribute).Select(GetEmulationAttributeArguments)); + var attributeArguments = callable.Attributes.Where(HasEmulationAttribute).Select(GetEmulationAttributeArguments); + foreach (var (alternativeOperation, _) in attributeArguments) + { + var period = alternativeOperation.LastIndexOf('.'); + if (period == -1) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Error, + Message = $"AutoEmulation: name of alternative operation in {key.Namespace}.{key.Name} must be completely specified (including namespace)", + Stage = IRewriteStep.Stage.Transformation + }); + return false; + } + + var qualifiedName = new QsQualifiedName(alternativeOperation.Substring(0, period), alternativeOperation.Substring(period + 1)); + if (!globalCallables.TryGetValue(qualifiedName, out var alternativeCallable)) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Error, + Message = $"AutoEmulation: cannot find alternative operation `{alternativeOperation}`", + Stage = IRewriteStep.Stage.Transformation + }); + return false; + } + + var callableSignature = callable.Signature; + var alternativeSignature = alternativeCallable.Signature; + + if (!callable.Signature.Equals(alternativeCallable.Signature)) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Error, + Message = $"AutoEmulation: signature of `{alternativeOperation}` does not match the one of {key.Namespace}.{key.Name}", + Stage = IRewriteStep.Stage.Transformation + }); + return false; + } + + if (!GetSpecializationKinds(callable).IsSubsetOf(GetSpecializationKinds(alternativeCallable))) + { + diagnostics.Add(new IRewriteStep.Diagnostic { + Severity = DiagnosticSeverity.Error, + Message = $"AutoEmulation: specializations of `{alternativeOperation}` must be a superset of specializations of {key.Namespace}.{key.Name}", + Stage = IRewriteStep.Stage.Transformation + }); + return false; + } + } + generator.AddCallable(key, callable, attributeArguments); } generator.WriteTo(writer); @@ -113,6 +162,9 @@ var arr when arr.Count() == 2 => _ => throw new Exception("Unexpected argument") }; + private static ISet GetSpecializationKinds(QsCallable callable) => + callable.Specializations.Select(spec => spec.Kind).OrderBy(kind => kind).ToHashSet(); + private List diagnostics = new List(); } } From 865438807273bf9c28139634be285a1050d9946e Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Thu, 11 Feb 2021 18:08:50 +0100 Subject: [PATCH 06/18] Do not change this file. --- Simulation.sln | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Simulation.sln b/Simulation.sln index 07a1fc75a57..b13975b999a 100644 --- a/Simulation.sln +++ b/Simulation.sln @@ -685,4 +685,4 @@ Global GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {929C0464-86D8-4F70-8835-0A5EAF930821} EndGlobalSection -EndGlobal +EndGlobal \ No newline at end of file From 5083938d1e673322fcac9d1c03a227a93f6e0514 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 12 Feb 2021 13:36:39 +0100 Subject: [PATCH 07/18] Signature checking too restrictive. --- src/Simulation/AutoEmulation/RewriteStep.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs index b13e14772b0..b7601770d32 100644 --- a/src/Simulation/AutoEmulation/RewriteStep.cs +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -114,7 +114,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs var callableSignature = callable.Signature; var alternativeSignature = alternativeCallable.Signature; - if (!callable.Signature.Equals(alternativeCallable.Signature)) + if (!callableSignature.ArgumentType.Equals(alternativeSignature.ArgumentType) || !callableSignature.ReturnType.Equals(alternativeSignature.ReturnType)) { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, From 7adf9fa2b3704ca22f9fa49e24a9f36c210d91b6 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 12 Feb 2021 13:36:45 +0100 Subject: [PATCH 08/18] Add integration test. --- .../Integration.qs | 29 +++++++++++++++++++ .../Tests.AutoEmulation.Integration.csproj | 14 +++++++++ 2 files changed, 43 insertions(+) create mode 100644 src/Simulation/AutoEmulation.Integration.Tests/Integration.qs create mode 100644 src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs new file mode 100644 index 00000000000..63b5bdd8494 --- /dev/null +++ b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs @@ -0,0 +1,29 @@ +namespace Microsoft.Quantum.AutoEmulation.Testing { + open Microsoft.Quantum.Diagnostics; + open Microsoft.Quantum.Intrinsic; + open Microsoft.Quantum.Measurement; + + @EmulateWith("Microsoft.Quantum.Intrinsic.SWAP", "ToffoliSimulator") + operation QuantumSwap(a : Qubit, b : Qubit) : Unit { + within { + CNOT(a, b); + H(a); + H(b); + } apply { + CNOT(a, b); + } + } + + @Test("ToffoliSimulator") + operation TestQuantumSwap() : Unit { + use a = Qubit(); + use b = Qubit(); + + X(a); + + QuantumSwap(a, b); + + EqualityFactR(MResetZ(a), Zero, "unexpected value for a after swap"); + EqualityFactR(MResetZ(b), One, "unexpected value for b after swap"); + } +} diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj b/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj new file mode 100644 index 00000000000..2eabf3a4d41 --- /dev/null +++ b/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj @@ -0,0 +1,14 @@ + + + + Library + netcoreapp3.1 + x64 + + + + + + + + From f363fa7386f0c34b5d859331b7ad37e28bb93d6e Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 15:30:06 +0200 Subject: [PATCH 09/18] Update QDK version. --- .../Tests.AutoEmulation.Integration.csproj | 4 ++-- src/Simulation/AutoEmulation/AutoEmulation.csproj | 4 ++-- src/Simulation/AutoEmulation/CodeGenerator.cs | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj b/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj index 2eabf3a4d41..6ab9ad65cb7 100644 --- a/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj +++ b/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj @@ -1,4 +1,4 @@ - + Library @@ -7,7 +7,7 @@ - + diff --git a/src/Simulation/AutoEmulation/AutoEmulation.csproj b/src/Simulation/AutoEmulation/AutoEmulation.csproj index 2bc758a2e26..0fa56d124c8 100644 --- a/src/Simulation/AutoEmulation/AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation/AutoEmulation.csproj @@ -1,4 +1,4 @@ - + Library @@ -20,7 +20,7 @@ - + diff --git a/src/Simulation/AutoEmulation/CodeGenerator.cs b/src/Simulation/AutoEmulation/CodeGenerator.cs index 2f30e2f00e5..7f920fe6ece 100644 --- a/src/Simulation/AutoEmulation/CodeGenerator.cs +++ b/src/Simulation/AutoEmulation/CodeGenerator.cs @@ -99,7 +99,7 @@ public void AddCallable(QsQualifiedName name, QsCallable callable, IEnumerable<( var cls = gen.ClassDeclaration( name.Name, - accessibility: callable.Modifiers.Access.IsInternal ? Accessibility.Internal : Accessibility.Public, + accessibility: callable.Access.IsInternal ? Accessibility.Internal : Accessibility.Public, modifiers: DeclarationModifiers.Partial, members: new[] { innerClass }); From a2d25d7ca3f23c0f32f108fe06e2de86b32289bb Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 16:01:26 +0200 Subject: [PATCH 10/18] Incorporate Microsoft/QuantumLibraries#426. --- .../AutoEmulation.Integration.Tests/Integration.qs | 3 ++- .../AutoEmulation.Tests/CodeGenerationTests.cs | 4 ++-- src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs | 2 ++ .../TestFiles/FailAlternativeDoesNotExist.qs | 4 +++- .../TestFiles/FailDifferentSignatures.qs | 4 +++- .../TestFiles/FailDifferentSpecializationKinds.qs | 4 +++- .../AutoEmulation.Tests/TestFiles/FailNoNamespace.qs | 4 +++- .../AutoEmulation.Tests/TestFiles/Success.qs | 4 +++- .../AutoEmulation.Tests/TestFiles/SuccessA.qs | 4 +++- .../AutoEmulation.Tests/TestFiles/SuccessC.qs | 4 +++- .../AutoEmulation.Tests/TestFiles/SuccessCA.qs | 4 +++- .../AutoEmulation.Tests/Tests.AutoEmulation.csproj | 3 +++ src/Simulation/AutoEmulation/CodeGenerator.cs | 2 +- src/Simulation/AutoEmulation/Emulation.qs | 10 +++++----- src/Simulation/AutoEmulation/RewriteStep.cs | 12 ++++++------ 15 files changed, 45 insertions(+), 23 deletions(-) create mode 100644 src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs index 63b5bdd8494..42f0a80a718 100644 --- a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs +++ b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs @@ -2,8 +2,9 @@ namespace Microsoft.Quantum.AutoEmulation.Testing { open Microsoft.Quantum.Diagnostics; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; + open Microsoft.Quantum.Targeting; - @EmulateWith("Microsoft.Quantum.Intrinsic.SWAP", "ToffoliSimulator") + @SubstitutableOnTarget("Microsoft.Quantum.Intrinsic.SWAP", "ToffoliSimulator") operation QuantumSwap(a : Qubit, b : Qubit) : Unit { within { CNOT(a, b); diff --git a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs index 67e6fde1427..0f09f616634 100644 --- a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs @@ -36,7 +36,7 @@ private void TestOneSuccessfulFile(string fileName) var path = CreateNewTemporaryPath(); step.AssemblyConstants[AssemblyConstants.OutputPath] = path; - var compilation = CreateCompilation("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); Assert.True(step.Transformation(compilation, out var transformed)); var generatedFileName = Path.Combine(path, "__AutoEmulation__.g.cs"); @@ -56,7 +56,7 @@ private void TestOneFailingFile(string fileName) var path = CreateNewTemporaryPath(); step.AssemblyConstants[AssemblyConstants.OutputPath] = path; - var compilation = CreateCompilation("Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); Assert.False(step.Transformation(compilation, out var transformed)); Assert.Equal(2, step.GeneratedDiagnostics.Count()); diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs new file mode 100644 index 00000000000..76745f5a1bc --- /dev/null +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs @@ -0,0 +1,2 @@ +namespace Microsoft.Quantum.Core { +} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs index 43a47e68adb..203a04a9a91 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs @@ -1,4 +1,6 @@ namespace AutoEmulationTests { - @EmulateWith("Namespace.NotExisting", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("Namespace.NotExisting", "ToffoliSimulator") operation Fail() : Unit {} } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs index 482e5fa446c..a69681d9037 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("AutoEmulationTests.FailClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("AutoEmulationTests.FailClassical", "ToffoliSimulator") operation Fail(a : Int) : Unit {} operation FailClassical(a : Double) : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs index d8d2baa0ec4..fbdf8da9e87 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("FailClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("FailClassical", "ToffoliSimulator") operation Fail() : Unit is Adj {} operation FailClassical() : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs index 71deb74caf4..dab68fbcab8 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("FailClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("FailClassical", "ToffoliSimulator") operation Fail() : Unit {} operation FailClassical() : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs index 378d7c82350..ca6183c8f94 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit {} operation SuccessClassical() : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs index cc59e4a8665..6a6f4c713af 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Adj {} operation SuccessClassical() : Unit is Adj {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs index a4eee110312..ddaed2ec8f1 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Ctl {} operation SuccessClassical() : Unit is Ctl {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs index 0bf045306b3..27888e7b36e 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs @@ -1,5 +1,7 @@ namespace AutoEmulationTests { - @EmulateWith("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + open Microsoft.Quantum.Targeting; + + @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Adj+Ctl {} operation SuccessClassical() : Unit is Adj+Ctl {} diff --git a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj index 9255f61e685..3aa33759543 100644 --- a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj @@ -11,6 +11,9 @@ PreserveNewest + + PreserveNewest + PreserveNewest diff --git a/src/Simulation/AutoEmulation/CodeGenerator.cs b/src/Simulation/AutoEmulation/CodeGenerator.cs index 7f920fe6ece..0a404e5e86f 100644 --- a/src/Simulation/AutoEmulation/CodeGenerator.cs +++ b/src/Simulation/AutoEmulation/CodeGenerator.cs @@ -60,7 +60,7 @@ public CodeGenerator(CodegenContext context) /// /// Namespace and name of the callable /// Q# Callable - /// All attribute values from @EmulateWith attributes of that callable + /// All attribute values from @HasSubstitutionAttribute attributes of that callable public void AddCallable(QsQualifiedName name, QsCallable callable, IEnumerable<(string AlternativeOperation, string InSimulator)> emulationAttributes) { var attributes = emulationAttributes.Select((attr, idx) => new EmulationAttribute( diff --git a/src/Simulation/AutoEmulation/Emulation.qs b/src/Simulation/AutoEmulation/Emulation.qs index 8dea7fc4378..3e88d9e37b5 100644 --- a/src/Simulation/AutoEmulation/Emulation.qs +++ b/src/Simulation/AutoEmulation/Emulation.qs @@ -1,15 +1,15 @@ -namespace Microsoft.Quantum.Core +namespace Microsoft.Quantum.Targeting { /// # Summary - /// Enables to emulate an operation with an alternative operation for a given simulator + /// Enables to substitute an operation with an alternative operation for a given target /// /// # Named Items /// ## AlternativeOperation /// Fully qualified name of alternative operation to emulate operation with. /// - /// ## InSimulator + /// ## TargetName /// One of `QuantumSimulator`, `ToffoliSimulator`, or `ResourcesEstimator`, or a fully qualified name - /// of a custom simulator. + /// of a custom target. @Attribute() - newtype EmulateWith = (AlternativeOperation : String, InSimulator : String); + newtype SubstitutableOnTarget = (AlternativeOperation : String, TargetName : String); } diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs index b7601770d32..4acc6cd9bf8 100644 --- a/src/Simulation/AutoEmulation/RewriteStep.cs +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -16,7 +16,7 @@ namespace Microsoft.Quantum.QsCompiler.AutoEmulation /// /// /// This rewrite step creates custom emulators for operations that have the - /// `EmulateWith` attribute. This attribute holds an alternative operation, + /// `SubstitutableOnTarget` attribute. This attribute holds an alternative operation, /// with the same signature, as its first argument, and a simulator, for which /// the alternative operation should be used, as its second argument. /// @@ -51,13 +51,13 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs // collect all callables that have an emulation attribute var globals = globalCallables.Where(p => p.Value.Source.CodeFile.EndsWith(".qs")) - .Where(p => p.Value.Attributes.Any(HasEmulationAttribute)); + .Where(p => p.Value.Attributes.Any(HasSubstitutionAttribute)); if (!globals.Any()) { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Info, - Message = "AutoEmulation: no operations have @EmulateWith attribute", + Message = "AutoEmulation: no operations have @SubstitutableOnTarget attribute", Stage = IRewriteStep.Stage.Transformation }); return true; @@ -86,7 +86,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs var generator = new CodeGenerator(context); foreach (var (key, callable) in globals) { - var attributeArguments = callable.Attributes.Where(HasEmulationAttribute).Select(GetEmulationAttributeArguments); + var attributeArguments = callable.Attributes.Where(HasSubstitutionAttribute).Select(GetEmulationAttributeArguments); foreach (var (alternativeOperation, _) in attributeArguments) { var period = alternativeOperation.LastIndexOf('.'); @@ -142,8 +142,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs return true; } - private static bool HasEmulationAttribute(QsDeclarationAttribute attribute) => - attribute.TypeId.IsValue && attribute.TypeId.Item.Namespace == "Microsoft.Quantum.Core" && attribute.TypeId.Item.Name == "EmulateWith"; + private static bool HasSubstitutionAttribute(QsDeclarationAttribute attribute) => + attribute.TypeId.IsValue && attribute.TypeId.Item.Namespace == "Microsoft.Quantum.Targeting" && attribute.TypeId.Item.Name == "SubstitutableOnTarget"; private static (string AlternativeOperation, string InSimulator) GetEmulationAttributeArguments(QsDeclarationAttribute attribute) => attribute.Argument.Expression switch From 4a92681fe6cb4449f1b45bf8a16a2d24412b2ca5 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 16:10:24 +0200 Subject: [PATCH 11/18] Rename emulation to substitution. --- .../Integration.qs | 2 +- .../CodeGenerationTests.cs | 14 ++++----- .../TestFiles/FailAlternativeDoesNotExist.qs | 2 +- .../TestFiles/FailDifferentSignatures.qs | 4 +-- .../FailDifferentSpecializationKinds.qs | 2 +- .../TestFiles/FailNoNamespace.qs | 2 +- .../AutoEmulation.Tests/TestFiles/Success.cs_ | 6 ++-- .../AutoEmulation.Tests/TestFiles/Success.qs | 4 +-- .../TestFiles/SuccessA.cs_ | 6 ++-- .../AutoEmulation.Tests/TestFiles/SuccessA.qs | 4 +-- .../TestFiles/SuccessC.cs_ | 6 ++-- .../AutoEmulation.Tests/TestFiles/SuccessC.qs | 4 +-- .../TestFiles/SuccessCA.cs_ | 6 ++-- .../TestFiles/SuccessCA.qs | 4 +-- .../Tests.AutoEmulation.csproj | 2 +- .../AutoEmulation/AutoEmulation.csproj | 4 +-- src/Simulation/AutoEmulation/CodeGenerator.cs | 30 +++++++++---------- src/Simulation/AutoEmulation/RewriteStep.cs | 30 +++++++++---------- .../{Emulation.qs => Substitution.qs} | 2 +- 19 files changed, 67 insertions(+), 67 deletions(-) rename src/Simulation/AutoEmulation/{Emulation.qs => Substitution.qs} (85%) diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs index 42f0a80a718..55c3e3a674c 100644 --- a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs +++ b/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs @@ -1,4 +1,4 @@ -namespace Microsoft.Quantum.AutoEmulation.Testing { +namespace Microsoft.Quantum.AutoSubstitution.Testing { open Microsoft.Quantum.Diagnostics; open Microsoft.Quantum.Intrinsic; open Microsoft.Quantum.Measurement; diff --git a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs index 0f09f616634..9bd9afbaa04 100644 --- a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs @@ -2,18 +2,18 @@ using System.Collections.Immutable; using System.IO; using System.Linq; -using Microsoft.Quantum.QsCompiler.AutoEmulation; +using Microsoft.Quantum.QsCompiler.AutoSubstitution; using Microsoft.Quantum.QsCompiler.CompilationBuilder; using Microsoft.Quantum.QsCompiler.ReservedKeywords; using Microsoft.Quantum.QsCompiler.SyntaxTree; using Xunit; -namespace Microsoft.Quantum.AutoEmulation.Testing +namespace Microsoft.Quantum.AutoSubstitution.Testing { public class CodeGenerationTests { [Fact] - public void CanGenerateAutoEmulationCode() + public void CanGenerateAutoSubstitutionCode() { TestOneSuccessfulFile("Success"); TestOneSuccessfulFile("SuccessA"); @@ -36,10 +36,10 @@ private void TestOneSuccessfulFile(string fileName) var path = CreateNewTemporaryPath(); step.AssemblyConstants[AssemblyConstants.OutputPath] = path; - var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Substitution.qs", Path.Combine("TestFiles", $"{fileName}.qs")); Assert.True(step.Transformation(compilation, out var transformed)); - var generatedFileName = Path.Combine(path, "__AutoEmulation__.g.cs"); + var generatedFileName = Path.Combine(path, "__AutoSubstitution__.g.cs"); Assert.True(File.Exists(generatedFileName)); // uncomment, when creating files with expected content @@ -56,7 +56,7 @@ private void TestOneFailingFile(string fileName) var path = CreateNewTemporaryPath(); step.AssemblyConstants[AssemblyConstants.OutputPath] = path; - var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Emulation.qs", Path.Combine("TestFiles", $"{fileName}.qs")); + var compilation = CreateCompilation(Path.Combine("TestFiles", "Core.qs"), "Substitution.qs", Path.Combine("TestFiles", $"{fileName}.qs")); Assert.False(step.Transformation(compilation, out var transformed)); Assert.Equal(2, step.GeneratedDiagnostics.Count()); @@ -81,6 +81,6 @@ private ImmutableHashSet CreateFileManager(params string[] f private readonly System.Random random = new System.Random(); private string CreateNewTemporaryPath() => - Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), $"emulation-test-{random.Next(Int32.MaxValue)}")).FullName; + Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), $"substitution-test-{random.Next(Int32.MaxValue)}")).FullName; } } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs index 203a04a9a91..7896578878e 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs @@ -1,4 +1,4 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; @SubstitutableOnTarget("Namespace.NotExisting", "ToffoliSimulator") diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs index a69681d9037..548496c4a26 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs @@ -1,7 +1,7 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; - @SubstitutableOnTarget("AutoEmulationTests.FailClassical", "ToffoliSimulator") + @SubstitutableOnTarget("AutoSubstitutionTests.FailClassical", "ToffoliSimulator") operation Fail(a : Int) : Unit {} operation FailClassical(a : Double) : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs index fbdf8da9e87..fcfba7c3866 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs @@ -1,4 +1,4 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; @SubstitutableOnTarget("FailClassical", "ToffoliSimulator") diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs index dab68fbcab8..81ed06e2fa4 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs @@ -1,4 +1,4 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; @SubstitutableOnTarget("FailClassical", "ToffoliSimulator") diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ index 58d2b363812..d39371f348e 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ @@ -2,7 +2,7 @@ using System; using Microsoft.Quantum.Simulation.Core; using Microsoft.Quantum.Simulation.Simulators; -namespace AutoEmulationTests +namespace AutoSubstitutionTests { public partial class Success { @@ -18,7 +18,7 @@ namespace AutoEmulationTests base.__Init__(); if ((sim0) != (null)) { - alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); } } @@ -42,7 +42,7 @@ namespace AutoEmulationTests } } - private AutoEmulationTests.SuccessClassical alternative0 = null; + private AutoSubstitutionTests.SuccessClassical alternative0 = null; private ToffoliSimulator sim0 = null; } } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs index ca6183c8f94..4e5c8390aec 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs @@ -1,7 +1,7 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; - @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + @SubstitutableOnTarget("AutoSubstitutionTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit {} operation SuccessClassical() : Unit {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ index be0c1dbe05d..38289596669 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ @@ -2,7 +2,7 @@ using System; using Microsoft.Quantum.Simulation.Core; using Microsoft.Quantum.Simulation.Simulators; -namespace AutoEmulationTests +namespace AutoSubstitutionTests { public partial class Success { @@ -18,7 +18,7 @@ namespace AutoEmulationTests base.__Init__(); if ((sim0) != (null)) { - alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); } } @@ -62,7 +62,7 @@ namespace AutoEmulationTests } } - private AutoEmulationTests.SuccessClassical alternative0 = null; + private AutoSubstitutionTests.SuccessClassical alternative0 = null; private ToffoliSimulator sim0 = null; } } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs index 6a6f4c713af..99a4407bb37 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs @@ -1,7 +1,7 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; - @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + @SubstitutableOnTarget("AutoSubstitutionTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Adj {} operation SuccessClassical() : Unit is Adj {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ index 9d07f38600b..af622967bf8 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ @@ -2,7 +2,7 @@ using System; using Microsoft.Quantum.Simulation.Core; using Microsoft.Quantum.Simulation.Simulators; -namespace AutoEmulationTests +namespace AutoSubstitutionTests { public partial class Success { @@ -18,7 +18,7 @@ namespace AutoEmulationTests base.__Init__(); if ((sim0) != (null)) { - alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); } } @@ -62,7 +62,7 @@ namespace AutoEmulationTests } } - private AutoEmulationTests.SuccessClassical alternative0 = null; + private AutoSubstitutionTests.SuccessClassical alternative0 = null; private ToffoliSimulator sim0 = null; } } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs index ddaed2ec8f1..612e1671ac7 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs @@ -1,7 +1,7 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; - @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + @SubstitutableOnTarget("AutoSubstitutionTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Ctl {} operation SuccessClassical() : Unit is Ctl {} diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ index 458e41f0c20..f87f3c80f04 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ @@ -2,7 +2,7 @@ using System; using Microsoft.Quantum.Simulation.Core; using Microsoft.Quantum.Simulation.Simulators; -namespace AutoEmulationTests +namespace AutoSubstitutionTests { public partial class Success { @@ -18,7 +18,7 @@ namespace AutoEmulationTests base.__Init__(); if ((sim0) != (null)) { - alternative0 = (__Factory__.Get(typeof(AutoEmulationTests.SuccessClassical))); + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); } } @@ -102,7 +102,7 @@ namespace AutoEmulationTests } } - private AutoEmulationTests.SuccessClassical alternative0 = null; + private AutoSubstitutionTests.SuccessClassical alternative0 = null; private ToffoliSimulator sim0 = null; } } diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs index 27888e7b36e..58b4652ef94 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs +++ b/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs @@ -1,7 +1,7 @@ -namespace AutoEmulationTests { +namespace AutoSubstitutionTests { open Microsoft.Quantum.Targeting; - @SubstitutableOnTarget("AutoEmulationTests.SuccessClassical", "ToffoliSimulator") + @SubstitutableOnTarget("AutoSubstitutionTests.SuccessClassical", "ToffoliSimulator") operation Success() : Unit is Adj+Ctl {} operation SuccessClassical() : Unit is Adj+Ctl {} diff --git a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj index 3aa33759543..1d4d7310d75 100644 --- a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj @@ -8,7 +8,7 @@ - + PreserveNewest diff --git a/src/Simulation/AutoEmulation/AutoEmulation.csproj b/src/Simulation/AutoEmulation/AutoEmulation.csproj index 0fa56d124c8..6f07c3a2a00 100644 --- a/src/Simulation/AutoEmulation/AutoEmulation.csproj +++ b/src/Simulation/AutoEmulation/AutoEmulation.csproj @@ -9,9 +9,9 @@ - Microsoft.Quantum.AutoEmulation + Microsoft.Quantum.AutoSubstitution Microsoft - Code generation for simulator emulation. + Code generation for target substitution. © Microsoft Corporation. All rights reserved. true true diff --git a/src/Simulation/AutoEmulation/CodeGenerator.cs b/src/Simulation/AutoEmulation/CodeGenerator.cs index 0a404e5e86f..3a92f5eb8aa 100644 --- a/src/Simulation/AutoEmulation/CodeGenerator.cs +++ b/src/Simulation/AutoEmulation/CodeGenerator.cs @@ -8,7 +8,7 @@ using Microsoft.Quantum.QsCompiler.CsharpGeneration; using Microsoft.Quantum.QsCompiler.SyntaxTree; -namespace Microsoft.Quantum.QsCompiler.AutoEmulation +namespace Microsoft.Quantum.QsCompiler.AutoSubstitution { public class CodeGenerator { @@ -19,7 +19,7 @@ public CodeGenerator(CodegenContext context) } /// - /// Generates an emulation class for a given callable with a given name + /// Generates an substitution class for a given callable with a given name /// /// /// @@ -60,10 +60,10 @@ public CodeGenerator(CodegenContext context) /// /// Namespace and name of the callable /// Q# Callable - /// All attribute values from @HasSubstitutionAttribute attributes of that callable - public void AddCallable(QsQualifiedName name, QsCallable callable, IEnumerable<(string AlternativeOperation, string InSimulator)> emulationAttributes) + /// All attribute values from @HasSubstitutionAttribute attributes of that callable + public void AddCallable(QsQualifiedName name, QsCallable callable, IEnumerable<(string AlternativeOperation, string InSimulator)> substitutionAttributes) { - var attributes = emulationAttributes.Select((attr, idx) => new EmulationAttribute( + var attributes = substitutionAttributes.Select((attr, idx) => new SubstitutionAttribute( SyntaxFactory.ParseTypeName(attr.AlternativeOperation), gen.IdentifierName($"alternative{idx}"), SyntaxFactory.ParseTypeName(attr.InSimulator), @@ -134,7 +134,7 @@ private SyntaxNode CreateInitMethod(IEnumerable bodyStatements) => /// /// Creates a syntax node for field declarations for the alternative operations /// - private SyntaxNode CreateOperationField(EmulationAttribute attr) => + private SyntaxNode CreateOperationField(SubstitutionAttribute attr) => gen.FieldDeclaration( attr.OperationName.ToFullString(), type: attr.OperationType, @@ -144,7 +144,7 @@ private SyntaxNode CreateOperationField(EmulationAttribute attr) => /// /// Creates a syntax node for operation field assignments in the Init() method /// - private SyntaxNode CreateOperationAssignment(EmulationAttribute attr) => + private SyntaxNode CreateOperationAssignment(SubstitutionAttribute attr) => gen.IfStatement( condition: gen.ValueNotEqualsExpression(attr.SimulatorName, gen.NullLiteralExpression()), trueStatements: new[] @@ -170,7 +170,7 @@ private SyntaxNode CreateFactoryGetStatement(SyntaxNode type) => /// /// /// - private SyntaxNode CreateSimulatorField(EmulationAttribute attr) => + private SyntaxNode CreateSimulatorField(SubstitutionAttribute attr) => gen.FieldDeclaration( attr.SimulatorName.ToFullString(), type: attr.SimulatorType, @@ -182,7 +182,7 @@ private SyntaxNode CreateSimulatorField(EmulationAttribute attr) => /// /// /// - private SyntaxNode CreateSimulatorCast(EmulationAttribute attr) => + private SyntaxNode CreateSimulatorCast(SubstitutionAttribute attr) => gen.AssignmentStatement( left: attr.SimulatorName, right: gen.TryCastExpression(gen.IdentifierName("m"), attr.SimulatorType) @@ -191,7 +191,7 @@ private SyntaxNode CreateSimulatorCast(EmulationAttribute attr) => /// /// Creates a syntax node for one specialization property /// - private SyntaxNode CreateSpecializationProperty(string specializationName, IEnumerable attributes, string argumentType, string returnType) => + private SyntaxNode CreateSpecializationProperty(string specializationName, IEnumerable attributes, string argumentType, string returnType) => gen.PropertyDeclaration( specializationName, type: SyntaxFactory.ParseTypeName($"Func<{argumentType}, {returnType}>"), @@ -203,7 +203,7 @@ private SyntaxNode CreateSpecializationProperty(string specializationName, IEnum /// Creates a syntax node for the lambda expression, returned in the /// `get` accessor of a specialization property /// - private SyntaxNode CreateSpecializationLambda(string specializationName, IEnumerable attrs) => + private SyntaxNode CreateSpecializationLambda(string specializationName, IEnumerable attrs) => gen.ValueReturningLambdaExpression( "args", new[] @@ -215,7 +215,7 @@ private SyntaxNode CreateSpecializationLambda(string specializationName, IEnumer /// Creates a syntax node for a nested if-statement for all possible /// operation alternatives /// - private SyntaxNode CreateSpecializationBody(string specializationName, IEnumerable attrs) => + private SyntaxNode CreateSpecializationBody(string specializationName, IEnumerable attrs) => attrs.Count() switch { 0 => gen.ReturnStatement( @@ -265,11 +265,11 @@ public void WriteTo(TextWriter writer) => ).NormalizeWhitespace().WriteTo(writer); /// - /// Helper struct to prepare syntax nodes for @EmulationWith attribute values + /// Helper struct to prepare syntax nodes for @SubstitutableOnTarget attribute values /// - private class EmulationAttribute + private class SubstitutionAttribute { - public EmulationAttribute(SyntaxNode operationType, SyntaxNode operationName, SyntaxNode simulatorType, SyntaxNode simulatorName) + public SubstitutionAttribute(SyntaxNode operationType, SyntaxNode operationName, SyntaxNode simulatorType, SyntaxNode simulatorName) { OperationType = operationType; OperationName = operationName; diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoEmulation/RewriteStep.cs index 4acc6cd9bf8..d0430be52a0 100644 --- a/src/Simulation/AutoEmulation/RewriteStep.cs +++ b/src/Simulation/AutoEmulation/RewriteStep.cs @@ -8,10 +8,10 @@ using Microsoft.Quantum.QsCompiler.SyntaxTokens; using Microsoft.Quantum.QsCompiler.SyntaxTree; -namespace Microsoft.Quantum.QsCompiler.AutoEmulation +namespace Microsoft.Quantum.QsCompiler.AutoSubstitution { /// - /// A Q# rewrite step for auto emulation + /// A Q# rewrite step for auto substitution /// /// /// @@ -22,7 +22,7 @@ namespace Microsoft.Quantum.QsCompiler.AutoEmulation /// public class RewriteStep : IRewriteStep { - public string Name => "AutoEmulation"; + public string Name => "AutoSubstitution"; // This rewrite step needs to be run before C# code generation public int Priority => -2; @@ -49,7 +49,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs // global callables var globalCallables = compilation.Namespaces.GlobalCallableResolutions(); - // collect all callables that have an emulation attribute + // collect all callables that have an substitution attribute var globals = globalCallables.Where(p => p.Value.Source.CodeFile.EndsWith(".qs")) .Where(p => p.Value.Attributes.Any(HasSubstitutionAttribute)); @@ -57,18 +57,18 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Info, - Message = "AutoEmulation: no operations have @SubstitutableOnTarget attribute", + Message = "AutoSubstitution: no operations have @SubstitutableOnTarget attribute", Stage = IRewriteStep.Stage.Transformation }); return true; } - // no need to generate any C# file, if there is no emulation attribute, or if we cannot retrieve the output path + // no need to generate any C# file, if there is no substitution attribute, or if we cannot retrieve the output path if (!AssemblyConstants.TryGetValue(Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants.OutputPath, out var outputPath)) { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, - Message = "AutoEmulation: cannot determine output path for generated C# code", + Message = "AutoSubstitution: cannot determine output path for generated C# code", Stage = IRewriteStep.Stage.Transformation }); return false; @@ -76,17 +76,17 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Info, - Message = $"AutoEmulation: Generating file __AutoEmulation__.g.cs in {outputPath}", + Message = $"AutoSubstitution: Generating file __AutoSubstitution__.g.cs in {outputPath}", Stage = IRewriteStep.Stage.Transformation }); - using var writer = new StreamWriter(Path.Combine(outputPath, "__AutoEmulation__.g.cs")); + using var writer = new StreamWriter(Path.Combine(outputPath, "__AutoSubstitution__.g.cs")); var context = CodegenContext.Create(compilation, AssemblyConstants); var generator = new CodeGenerator(context); foreach (var (key, callable) in globals) { - var attributeArguments = callable.Attributes.Where(HasSubstitutionAttribute).Select(GetEmulationAttributeArguments); + var attributeArguments = callable.Attributes.Where(HasSubstitutionAttribute).Select(GetSubstitutionAttributeArguments); foreach (var (alternativeOperation, _) in attributeArguments) { var period = alternativeOperation.LastIndexOf('.'); @@ -94,7 +94,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, - Message = $"AutoEmulation: name of alternative operation in {key.Namespace}.{key.Name} must be completely specified (including namespace)", + Message = $"AutoSubstitution: name of alternative operation in {key.Namespace}.{key.Name} must be completely specified (including namespace)", Stage = IRewriteStep.Stage.Transformation }); return false; @@ -105,7 +105,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, - Message = $"AutoEmulation: cannot find alternative operation `{alternativeOperation}`", + Message = $"AutoSubstitution: cannot find alternative operation `{alternativeOperation}`", Stage = IRewriteStep.Stage.Transformation }); return false; @@ -118,7 +118,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, - Message = $"AutoEmulation: signature of `{alternativeOperation}` does not match the one of {key.Namespace}.{key.Name}", + Message = $"AutoSubstitution: signature of `{alternativeOperation}` does not match the one of {key.Namespace}.{key.Name}", Stage = IRewriteStep.Stage.Transformation }); return false; @@ -128,7 +128,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs { diagnostics.Add(new IRewriteStep.Diagnostic { Severity = DiagnosticSeverity.Error, - Message = $"AutoEmulation: specializations of `{alternativeOperation}` must be a superset of specializations of {key.Namespace}.{key.Name}", + Message = $"AutoSubstitution: specializations of `{alternativeOperation}` must be a superset of specializations of {key.Namespace}.{key.Name}", Stage = IRewriteStep.Stage.Transformation }); return false; @@ -145,7 +145,7 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs private static bool HasSubstitutionAttribute(QsDeclarationAttribute attribute) => attribute.TypeId.IsValue && attribute.TypeId.Item.Namespace == "Microsoft.Quantum.Targeting" && attribute.TypeId.Item.Name == "SubstitutableOnTarget"; - private static (string AlternativeOperation, string InSimulator) GetEmulationAttributeArguments(QsDeclarationAttribute attribute) => + private static (string AlternativeOperation, string InSimulator) GetSubstitutionAttributeArguments(QsDeclarationAttribute attribute) => attribute.Argument.Expression switch { QsExpressionKind.ValueTuple tuple => diff --git a/src/Simulation/AutoEmulation/Emulation.qs b/src/Simulation/AutoEmulation/Substitution.qs similarity index 85% rename from src/Simulation/AutoEmulation/Emulation.qs rename to src/Simulation/AutoEmulation/Substitution.qs index 3e88d9e37b5..e7d84afad8d 100644 --- a/src/Simulation/AutoEmulation/Emulation.qs +++ b/src/Simulation/AutoEmulation/Substitution.qs @@ -5,7 +5,7 @@ namespace Microsoft.Quantum.Targeting /// /// # Named Items /// ## AlternativeOperation - /// Fully qualified name of alternative operation to emulate operation with. + /// Fully qualified name of alternative operation to substitute operation with. /// /// ## TargetName /// One of `QuantumSimulator`, `ToffoliSimulator`, or `ResourcesEstimator`, or a fully qualified name From 8189afb99ce275d0619bf76061cd72d2ffaf079f Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 16:12:48 +0200 Subject: [PATCH 12/18] Rename projects and directories. --- .../Integration.qs | 0 ...Tests.AutoSubstitution.Integration.csproj} | 2 +- .../CodeGenerationTests.cs | 0 .../TestFiles/Core.qs | 0 .../TestFiles/FailAlternativeDoesNotExist.qs | 0 .../TestFiles/FailDifferentSignatures.qs | 0 .../FailDifferentSpecializationKinds.qs | 0 .../TestFiles/FailNoNamespace.qs | 0 .../TestFiles/Success.cs_ | 96 ++++---- .../TestFiles/Success.qs | 0 .../TestFiles/SuccessA.cs_ | 136 +++++------ .../TestFiles/SuccessA.qs | 0 .../TestFiles/SuccessC.cs_ | 136 +++++------ .../TestFiles/SuccessC.qs | 0 .../TestFiles/SuccessCA.cs_ | 216 +++++++++--------- .../TestFiles/SuccessCA.qs | 0 .../Tests.AutoSubstitution.csproj} | 6 +- .../AutoSubstitution.csproj} | 0 .../CodeGenerator.cs | 0 .../RewriteStep.cs | 0 .../Substitution.qs | 0 21 files changed, 296 insertions(+), 296 deletions(-) rename src/Simulation/{AutoEmulation.Integration.Tests => AutoSubstitution.Integration.Tests}/Integration.qs (100%) rename src/Simulation/{AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj => AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj} (81%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/CodeGenerationTests.cs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/Core.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/FailAlternativeDoesNotExist.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/FailDifferentSignatures.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/FailDifferentSpecializationKinds.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/FailNoNamespace.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/Success.cs_ (96%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/Success.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessA.cs_ (96%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessA.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessC.cs_ (96%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessC.qs (100%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessCA.cs_ (96%) rename src/Simulation/{AutoEmulation.Tests => AutoSubstitution.Tests}/TestFiles/SuccessCA.qs (100%) rename src/Simulation/{AutoEmulation.Tests/Tests.AutoEmulation.csproj => AutoSubstitution.Tests/Tests.AutoSubstitution.csproj} (92%) rename src/Simulation/{AutoEmulation/AutoEmulation.csproj => AutoSubstitution/AutoSubstitution.csproj} (100%) rename src/Simulation/{AutoEmulation => AutoSubstitution}/CodeGenerator.cs (100%) rename src/Simulation/{AutoEmulation => AutoSubstitution}/RewriteStep.cs (100%) rename src/Simulation/{AutoEmulation => AutoSubstitution}/Substitution.qs (100%) diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Integration.qs b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs similarity index 100% rename from src/Simulation/AutoEmulation.Integration.Tests/Integration.qs rename to src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs diff --git a/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj similarity index 81% rename from src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj rename to src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj index 6ab9ad65cb7..60ed8338fa2 100644 --- a/src/Simulation/AutoEmulation.Integration.Tests/Tests.AutoEmulation.Integration.csproj +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj @@ -9,6 +9,6 @@ - + diff --git a/src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/CodeGenerationTests.cs rename to src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/Core.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/FailAlternativeDoesNotExist.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/FailAlternativeDoesNotExist.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/FailAlternativeDoesNotExist.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/FailDifferentSignatures.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSignatures.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/FailDifferentSignatures.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/FailDifferentSpecializationKinds.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/FailDifferentSpecializationKinds.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/FailDifferentSpecializationKinds.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/FailNoNamespace.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/FailNoNamespace.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/FailNoNamespace.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ b/src/Simulation/AutoSubstitution.Tests/TestFiles/Success.cs_ similarity index 96% rename from src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ rename to src/Simulation/AutoSubstitution.Tests/TestFiles/Success.cs_ index d39371f348e..1e3cdbfda1a 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.cs_ +++ b/src/Simulation/AutoSubstitution.Tests/TestFiles/Success.cs_ @@ -1,49 +1,49 @@ -using System; -using Microsoft.Quantum.Simulation.Core; -using Microsoft.Quantum.Simulation.Simulators; - -namespace AutoSubstitutionTests -{ - public partial class Success - { - public class Native : Success - { - public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) - { - sim0 = ((m) as ToffoliSimulator); - } - - public override void __Init__() - { - base.__Init__(); - if ((sim0) != (null)) - { - alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); - } - } - - public override Func __Body__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__Body__(args); - } - else - { - return base.__Body__(args); - } - } - - ; - } - } - - private AutoSubstitutionTests.SuccessClassical alternative0 = null; - private ToffoliSimulator sim0 = null; - } - } +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoSubstitutionTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + private AutoSubstitutionTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } } \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/Success.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/Success.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/Success.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessA.cs_ similarity index 96% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessA.cs_ index 38289596669..c8cd88d9fa6 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.cs_ +++ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessA.cs_ @@ -1,69 +1,69 @@ -using System; -using Microsoft.Quantum.Simulation.Core; -using Microsoft.Quantum.Simulation.Simulators; - -namespace AutoSubstitutionTests -{ - public partial class Success - { - public class Native : Success - { - public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) - { - sim0 = ((m) as ToffoliSimulator); - } - - public override void __Init__() - { - base.__Init__(); - if ((sim0) != (null)) - { - alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); - } - } - - public override Func __Body__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__Body__(args); - } - else - { - return base.__Body__(args); - } - } - - ; - } - } - - public override Func __AdjointBody__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__AdjointBody__(args); - } - else - { - return base.__AdjointBody__(args); - } - } - - ; - } - } - - private AutoSubstitutionTests.SuccessClassical alternative0 = null; - private ToffoliSimulator sim0 = null; - } - } +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoSubstitutionTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func __AdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__AdjointBody__(args); + } + else + { + return base.__AdjointBody__(args); + } + } + + ; + } + } + + private AutoSubstitutionTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } } \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessA.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessA.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessA.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessC.cs_ similarity index 96% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessC.cs_ index af622967bf8..73b7cfe76d9 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.cs_ +++ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessC.cs_ @@ -1,69 +1,69 @@ -using System; -using Microsoft.Quantum.Simulation.Core; -using Microsoft.Quantum.Simulation.Simulators; - -namespace AutoSubstitutionTests -{ - public partial class Success - { - public class Native : Success - { - public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) - { - sim0 = ((m) as ToffoliSimulator); - } - - public override void __Init__() - { - base.__Init__(); - if ((sim0) != (null)) - { - alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); - } - } - - public override Func __Body__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__Body__(args); - } - else - { - return base.__Body__(args); - } - } - - ; - } - } - - public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__ControlledBody__(args); - } - else - { - return base.__ControlledBody__(args); - } - } - - ; - } - } - - private AutoSubstitutionTests.SuccessClassical alternative0 = null; - private ToffoliSimulator sim0 = null; - } - } +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoSubstitutionTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledBody__(args); + } + else + { + return base.__ControlledBody__(args); + } + } + + ; + } + } + + private AutoSubstitutionTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } } \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessC.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessC.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessC.qs diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessCA.cs_ similarity index 96% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessCA.cs_ index f87f3c80f04..eaeac06869c 100644 --- a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.cs_ +++ b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessCA.cs_ @@ -1,109 +1,109 @@ -using System; -using Microsoft.Quantum.Simulation.Core; -using Microsoft.Quantum.Simulation.Simulators; - -namespace AutoSubstitutionTests -{ - public partial class Success - { - public class Native : Success - { - public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) - { - sim0 = ((m) as ToffoliSimulator); - } - - public override void __Init__() - { - base.__Init__(); - if ((sim0) != (null)) - { - alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); - } - } - - public override Func __Body__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__Body__(args); - } - else - { - return base.__Body__(args); - } - } - - ; - } - } - - public override Func __AdjointBody__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__AdjointBody__(args); - } - else - { - return base.__AdjointBody__(args); - } - } - - ; - } - } - - public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__ControlledBody__(args); - } - else - { - return base.__ControlledBody__(args); - } - } - - ; - } - } - - public override Func<(IQArray, QVoid), QVoid> __ControlledAdjointBody__ - { - get - { - return args => - { - if ((sim0) != (null)) - { - return alternative0.__ControlledAdjointBody__(args); - } - else - { - return base.__ControlledAdjointBody__(args); - } - } - - ; - } - } - - private AutoSubstitutionTests.SuccessClassical alternative0 = null; - private ToffoliSimulator sim0 = null; - } - } +using System; +using Microsoft.Quantum.Simulation.Core; +using Microsoft.Quantum.Simulation.Simulators; + +namespace AutoSubstitutionTests +{ + public partial class Success + { + public class Native : Success + { + public Native(Microsoft.Quantum.Simulation.Core.IOperationFactory m): base(m) + { + sim0 = ((m) as ToffoliSimulator); + } + + public override void __Init__() + { + base.__Init__(); + if ((sim0) != (null)) + { + alternative0 = (__Factory__.Get(typeof(AutoSubstitutionTests.SuccessClassical))); + } + } + + public override Func __Body__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__Body__(args); + } + else + { + return base.__Body__(args); + } + } + + ; + } + } + + public override Func __AdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__AdjointBody__(args); + } + else + { + return base.__AdjointBody__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledBody__(args); + } + else + { + return base.__ControlledBody__(args); + } + } + + ; + } + } + + public override Func<(IQArray, QVoid), QVoid> __ControlledAdjointBody__ + { + get + { + return args => + { + if ((sim0) != (null)) + { + return alternative0.__ControlledAdjointBody__(args); + } + else + { + return base.__ControlledAdjointBody__(args); + } + } + + ; + } + } + + private AutoSubstitutionTests.SuccessClassical alternative0 = null; + private ToffoliSimulator sim0 = null; + } + } } \ No newline at end of file diff --git a/src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessCA.qs similarity index 100% rename from src/Simulation/AutoEmulation.Tests/TestFiles/SuccessCA.qs rename to src/Simulation/AutoSubstitution.Tests/TestFiles/SuccessCA.qs diff --git a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj b/src/Simulation/AutoSubstitution.Tests/Tests.AutoSubstitution.csproj similarity index 92% rename from src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj rename to src/Simulation/AutoSubstitution.Tests/Tests.AutoSubstitution.csproj index 1d4d7310d75..d2ce8ad57ba 100644 --- a/src/Simulation/AutoEmulation.Tests/Tests.AutoEmulation.csproj +++ b/src/Simulation/AutoSubstitution.Tests/Tests.AutoSubstitution.csproj @@ -2,13 +2,13 @@ netcoreapp3.1 - Tests.Microsoft.Quantum.AutoEmulation + Tests.Microsoft.Quantum.AutoSubstitution false x64 - + PreserveNewest @@ -63,7 +63,7 @@ - + diff --git a/src/Simulation/AutoEmulation/AutoEmulation.csproj b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj similarity index 100% rename from src/Simulation/AutoEmulation/AutoEmulation.csproj rename to src/Simulation/AutoSubstitution/AutoSubstitution.csproj diff --git a/src/Simulation/AutoEmulation/CodeGenerator.cs b/src/Simulation/AutoSubstitution/CodeGenerator.cs similarity index 100% rename from src/Simulation/AutoEmulation/CodeGenerator.cs rename to src/Simulation/AutoSubstitution/CodeGenerator.cs diff --git a/src/Simulation/AutoEmulation/RewriteStep.cs b/src/Simulation/AutoSubstitution/RewriteStep.cs similarity index 100% rename from src/Simulation/AutoEmulation/RewriteStep.cs rename to src/Simulation/AutoSubstitution/RewriteStep.cs diff --git a/src/Simulation/AutoEmulation/Substitution.qs b/src/Simulation/AutoSubstitution/Substitution.qs similarity index 100% rename from src/Simulation/AutoEmulation/Substitution.qs rename to src/Simulation/AutoSubstitution/Substitution.qs From 681725bb2e2b454746c3974e0e1df20de24dddb2 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 17:17:57 +0200 Subject: [PATCH 13/18] Packaging. --- Simulation.sln | 60 +++++++++++++++++++ build/manifest.ps1 | 2 + build/pack.ps1 | 1 + .../AutoSubstitution/AutoSubstitution.csproj | 14 +---- .../AutoSubstitution/CodeGenerator.cs | 2 +- ...t.Quantum.AutoSubstitution.nuspec.template | 29 +++++++++ .../AutoSubstitution/RewriteStep.props | 8 +++ 7 files changed, 104 insertions(+), 12 deletions(-) create mode 100644 src/Simulation/AutoSubstitution/Microsoft.Quantum.AutoSubstitution.nuspec.template create mode 100644 src/Simulation/AutoSubstitution/RewriteStep.props diff --git a/Simulation.sln b/Simulation.sln index 9a65f34a9db..ac2435996de 100644 --- a/Simulation.sln +++ b/Simulation.sln @@ -113,6 +113,14 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "StandaloneInputReference", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "qir-standalone-input-reference", "src\Qir\Samples\StandaloneInputReference\qsharp\qir-standalone-input-reference.csproj", "{D7D34736-A719-4B45-A33F-2723F59EC29D}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Simulation", "Simulation", "{3CD26906-C7F3-47B8-AF43-FF6BCF1CB3EF}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoSubstitution", "src\Simulation\AutoSubstitution\AutoSubstitution.csproj", "{33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.AutoSubstitution", "src\Simulation\AutoSubstitution.Tests\Tests.AutoSubstitution.csproj", "{4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.AutoSubstitution.Integration", "src\Simulation\AutoSubstitution.Integration.Tests\Tests.AutoSubstitution.Integration.csproj", "{D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -749,6 +757,54 @@ Global {D7D34736-A719-4B45-A33F-2723F59EC29D}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU {D7D34736-A719-4B45-A33F-2723F59EC29D}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU {D7D34736-A719-4B45-A33F-2723F59EC29D}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Debug|x64.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Debug|x64.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Release|Any CPU.Build.0 = Release|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Release|x64.ActiveCfg = Release|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.Release|x64.Build.0 = Release|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Debug|x64.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Debug|x64.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Release|Any CPU.Build.0 = Release|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Release|x64.ActiveCfg = Release|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.Release|x64.Build.0 = Release|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Debug|x64.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Debug|x64.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.MinSizeRel|x64.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Release|Any CPU.Build.0 = Release|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Release|x64.ActiveCfg = Release|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.Release|x64.Build.0 = Release|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.RelWithDebInfo|Any CPU.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.RelWithDebInfo|Any CPU.Build.0 = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.RelWithDebInfo|x64.ActiveCfg = Debug|Any CPU + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C}.RelWithDebInfo|x64.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -802,6 +858,10 @@ Global {AAFB81D3-BC87-404D-BA64-AF40B2D2E45A} = {F6C2D4C0-12DC-40E3-9C86-FA5308D9B567} {A7DB7367-9FD6-4164-8263-A05077BE54AB} = {AAFB81D3-BC87-404D-BA64-AF40B2D2E45A} {D7D34736-A719-4B45-A33F-2723F59EC29D} = {A7DB7367-9FD6-4164-8263-A05077BE54AB} + {3CD26906-C7F3-47B8-AF43-FF6BCF1CB3EF} = {020356B7-C3FC-4100-AE37-97E5D8288D1D} + {33D66E90-049F-4A0B-A2B1-79E7E7E0ED0F} = {3CD26906-C7F3-47B8-AF43-FF6BCF1CB3EF} + {4EBC65DF-3B5E-419B-8E26-3EEF0B5CD300} = {3CD26906-C7F3-47B8-AF43-FF6BCF1CB3EF} + {D23480EE-88FC-4DF2-86BD-1C5BDD6CD98C} = {3CD26906-C7F3-47B8-AF43-FF6BCF1CB3EF} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {929C0464-86D8-4F70-8835-0A5EAF930821} diff --git a/build/manifest.ps1 b/build/manifest.ps1 index 4ce93ed25b1..a66e133c80c 100644 --- a/build/manifest.ps1 +++ b/build/manifest.ps1 @@ -20,6 +20,7 @@ param( $artifacts = @{ Packages = @( "Microsoft.Azure.Quantum.Client", + "Microsoft.Quantum.AutoSubstitution", "Microsoft.Quantum.CSharpGeneration", "Microsoft.Quantum.Development.Kit", "Microsoft.Quantum.EntryPointDriver", @@ -35,6 +36,7 @@ $artifacts = @{ Assemblies = @( ".\src\Azure\Azure.Quantum.Client\bin\$Env:BUILD_CONFIGURATION\netstandard2.1\Microsoft.Azure.Quantum.Client.dll", + ".\src\Simulation\AutoSubstitution\bin\$Env:BUILD_CONFIGURATION\netstandard2.1\Microsoft.Quantum.AutoSubstitution.dll", ".\src\Simulation\CSharpGeneration\bin\$Env:BUILD_CONFIGURATION\netstandard2.1\Microsoft.Quantum.CSharpGeneration.dll", ".\src\Simulation\CSharpGeneration.App\bin\$Env:BUILD_CONFIGURATION\netcoreapp3.1\Microsoft.Quantum.CSharpGeneration.App.dll", ".\src\Simulation\RoslynWrapper\bin\$Env:BUILD_CONFIGURATION\netstandard2.1\Microsoft.Quantum.RoslynWrapper.dll", diff --git a/build/pack.ps1 b/build/pack.ps1 index 7522f034cd9..8ac9fdc6191 100644 --- a/build/pack.ps1 +++ b/build/pack.ps1 @@ -63,6 +63,7 @@ function Pack-Dotnet() { Write-Host "##[info]Using nuget to create packages" Pack-Dotnet '../src/Azure/Azure.Quantum.Client/Microsoft.Azure.Quantum.Client.csproj' Pack-One '../src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj' '-IncludeReferencedProjects' +Pack-One '../src/Simulation/AutoSubstitution/AutoSubstitution.csproj' '-IncludeReferencedProjects' Pack-Dotnet '../src/Simulation/EntryPointDriver/Microsoft.Quantum.EntryPointDriver.csproj' Pack-Dotnet '../src/Simulation/Core/Microsoft.Quantum.Runtime.Core.csproj' Pack-Dotnet '../src/Simulation/TargetDefinitions/Interfaces/Microsoft.Quantum.Targets.Interfaces.csproj' diff --git a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj index 6f07c3a2a00..cf250657345 100644 --- a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj +++ b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj @@ -1,4 +1,6 @@ + + Library @@ -6,17 +8,7 @@ Enable x64 true - - - - Microsoft.Quantum.AutoSubstitution - Microsoft - Code generation for target substitution. - © Microsoft Corporation. All rights reserved. - true - true - snupkg - $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb;.xml + Microsoft.Quantum.AutoSubstitution diff --git a/src/Simulation/AutoSubstitution/CodeGenerator.cs b/src/Simulation/AutoSubstitution/CodeGenerator.cs index 3a92f5eb8aa..38ad86924f1 100644 --- a/src/Simulation/AutoSubstitution/CodeGenerator.cs +++ b/src/Simulation/AutoSubstitution/CodeGenerator.cs @@ -43,7 +43,7 @@ public CodeGenerator(CodegenContext context) /// if (sim0 != null) alternative0 = __Factory__.Get<Microsoft.Quantum.Intrinsic.CCNOT>(typeof(Microsoft.Quantum.Intrinsic.CCNOT)); /// } /// - /// public override Func<(Qubit, Qubit, Qubit), QVoid> __Body__ => args => { + /// public override Func<(Qubit, Qubit, Qubit), QVoid> __Body__ => args => { /// if (sim0 != null) return alternative0.__Body__(args); /// else return base.__Body__(args); /// } diff --git a/src/Simulation/AutoSubstitution/Microsoft.Quantum.AutoSubstitution.nuspec.template b/src/Simulation/AutoSubstitution/Microsoft.Quantum.AutoSubstitution.nuspec.template new file mode 100644 index 00000000000..f9d83f01d9a --- /dev/null +++ b/src/Simulation/AutoSubstitution/Microsoft.Quantum.AutoSubstitution.nuspec.template @@ -0,0 +1,29 @@ + + + + Microsoft.Quantum.AutoSubstitution + $version$ + $title$ + Microsoft + QuantumEngineering, Microsoft + + MIT + https://docs.microsoft.com/azure/quantum + images\qdk-nuget-icon.png + + false + C# code generation for automatic target substitution. + + See: https://docs.microsoft.com/azure/quantum/qdk-relnotes/ + + $copyright$ + Quantum Q# QSharp + + + + + + + + + diff --git a/src/Simulation/AutoSubstitution/RewriteStep.props b/src/Simulation/AutoSubstitution/RewriteStep.props new file mode 100644 index 00000000000..ad16b42a1b3 --- /dev/null +++ b/src/Simulation/AutoSubstitution/RewriteStep.props @@ -0,0 +1,8 @@ + + + + + $(MSBuildThisFileDirectory)/../lib/netstandard2.1/Microsoft.Quantum.AutoSubstitution.dll + + + From 6c0f3d71b098dda513af34d06542552723fd4256 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Fri, 30 Apr 2021 18:31:12 +0200 Subject: [PATCH 14/18] Fix line-feed problems. --- src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs index 9bd9afbaa04..98f267a8989 100644 --- a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs @@ -45,7 +45,7 @@ private void TestOneSuccessfulFile(string fileName) // uncomment, when creating files with expected content //File.Copy(generatedFileName, $"{fileName}.cs_", true); - Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")), File.ReadAllText(generatedFileName)); + Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")), File.ReadAllText(generatedFileName).Replace("\r\n", "\n")); Directory.Delete(path, true); } From f94c9b52aa707587923bbcfad237f0c89aec7cd8 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Sat, 1 May 2021 14:06:58 +0200 Subject: [PATCH 15/18] Fix LF. --- src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs index 98f267a8989..0460a433e98 100644 --- a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs @@ -45,7 +45,7 @@ private void TestOneSuccessfulFile(string fileName) // uncomment, when creating files with expected content //File.Copy(generatedFileName, $"{fileName}.cs_", true); - Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")), File.ReadAllText(generatedFileName).Replace("\r\n", "\n")); + Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")).Replace("\r\n", "\n"), File.ReadAllText(generatedFileName).Replace("\r\n", "\n")); Directory.Delete(path, true); } From 8a165ca12b837b7340ea9eca8c1356143929bad4 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Mon, 14 Jun 2021 11:50:08 +0200 Subject: [PATCH 16/18] Adressing reviewer feedback. --- .../Integration.qs | 3 +++ .../CodeGenerationTests.cs | 6 ++++- .../AutoSubstitution.Tests/TestFiles/Core.qs | 3 +++ .../AutoSubstitution/CodeGenerator.cs | 3 +++ .../AutoSubstitution/RewriteStep.cs | 26 +++++++++++++------ .../AutoSubstitution/Substitution.qs | 6 +++-- 6 files changed, 36 insertions(+), 11 deletions(-) diff --git a/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs index 55c3e3a674c..aad9dfc40f2 100644 --- a/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs @@ -1,3 +1,6 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + namespace Microsoft.Quantum.AutoSubstitution.Testing { open Microsoft.Quantum.Diagnostics; open Microsoft.Quantum.Intrinsic; diff --git a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs index 0460a433e98..218482a0069 100644 --- a/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs +++ b/src/Simulation/AutoSubstitution.Tests/CodeGenerationTests.cs @@ -1,3 +1,6 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + using System; using System.Collections.Immutable; using System.IO; @@ -42,7 +45,8 @@ private void TestOneSuccessfulFile(string fileName) var generatedFileName = Path.Combine(path, "__AutoSubstitution__.g.cs"); Assert.True(File.Exists(generatedFileName)); - // uncomment, when creating files with expected content + // uncomment this line, when creating new unit tests to + // create files with expected content //File.Copy(generatedFileName, $"{fileName}.cs_", true); Assert.Equal(File.ReadAllText(Path.Combine("TestFiles", $"{fileName}.cs_")).Replace("\r\n", "\n"), File.ReadAllText(generatedFileName).Replace("\r\n", "\n")); diff --git a/src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs b/src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs index 76745f5a1bc..2fdd2185eb8 100644 --- a/src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs +++ b/src/Simulation/AutoSubstitution.Tests/TestFiles/Core.qs @@ -1,2 +1,5 @@ +// This file is needed to ensure that the Microsoft.Quantum.Core namespace +// exists for the tests. + namespace Microsoft.Quantum.Core { } diff --git a/src/Simulation/AutoSubstitution/CodeGenerator.cs b/src/Simulation/AutoSubstitution/CodeGenerator.cs index 38ad86924f1..50e1ec8e0b4 100644 --- a/src/Simulation/AutoSubstitution/CodeGenerator.cs +++ b/src/Simulation/AutoSubstitution/CodeGenerator.cs @@ -1,3 +1,6 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + using System; using System.Collections.Generic; using System.IO; diff --git a/src/Simulation/AutoSubstitution/RewriteStep.cs b/src/Simulation/AutoSubstitution/RewriteStep.cs index d0430be52a0..2108bd8c93c 100644 --- a/src/Simulation/AutoSubstitution/RewriteStep.cs +++ b/src/Simulation/AutoSubstitution/RewriteStep.cs @@ -1,3 +1,6 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; @@ -16,7 +19,7 @@ namespace Microsoft.Quantum.QsCompiler.AutoSubstitution /// /// /// This rewrite step creates custom emulators for operations that have the - /// `SubstitutableOnTarget` attribute. This attribute holds an alternative operation, + /// SubstitutableOnTarget attribute. This attribute holds an alternative operation, /// with the same signature, as its first argument, and a simulator, for which /// the alternative operation should be used, as its second argument. /// @@ -55,7 +58,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs if (!globals.Any()) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Info, Message = "AutoSubstitution: no operations have @SubstitutableOnTarget attribute", Stage = IRewriteStep.Stage.Transformation @@ -66,7 +70,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs // no need to generate any C# file, if there is no substitution attribute, or if we cannot retrieve the output path if (!AssemblyConstants.TryGetValue(Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants.OutputPath, out var outputPath)) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Error, Message = "AutoSubstitution: cannot determine output path for generated C# code", Stage = IRewriteStep.Stage.Transformation @@ -74,7 +79,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs return false; } - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Info, Message = $"AutoSubstitution: Generating file __AutoSubstitution__.g.cs in {outputPath}", Stage = IRewriteStep.Stage.Transformation @@ -92,7 +98,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs var period = alternativeOperation.LastIndexOf('.'); if (period == -1) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Error, Message = $"AutoSubstitution: name of alternative operation in {key.Namespace}.{key.Name} must be completely specified (including namespace)", Stage = IRewriteStep.Stage.Transformation @@ -103,7 +110,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs var qualifiedName = new QsQualifiedName(alternativeOperation.Substring(0, period), alternativeOperation.Substring(period + 1)); if (!globalCallables.TryGetValue(qualifiedName, out var alternativeCallable)) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Error, Message = $"AutoSubstitution: cannot find alternative operation `{alternativeOperation}`", Stage = IRewriteStep.Stage.Transformation @@ -116,7 +124,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs if (!callableSignature.ArgumentType.Equals(alternativeSignature.ArgumentType) || !callableSignature.ReturnType.Equals(alternativeSignature.ReturnType)) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Error, Message = $"AutoSubstitution: signature of `{alternativeOperation}` does not match the one of {key.Namespace}.{key.Name}", Stage = IRewriteStep.Stage.Transformation @@ -126,7 +135,8 @@ public bool Transformation(QsCompilation compilation, [NotNullWhen(true)] out Qs if (!GetSpecializationKinds(callable).IsSubsetOf(GetSpecializationKinds(alternativeCallable))) { - diagnostics.Add(new IRewriteStep.Diagnostic { + diagnostics.Add(new IRewriteStep.Diagnostic + { Severity = DiagnosticSeverity.Error, Message = $"AutoSubstitution: specializations of `{alternativeOperation}` must be a superset of specializations of {key.Namespace}.{key.Name}", Stage = IRewriteStep.Stage.Transformation diff --git a/src/Simulation/AutoSubstitution/Substitution.qs b/src/Simulation/AutoSubstitution/Substitution.qs index e7d84afad8d..ccaf539b6a0 100644 --- a/src/Simulation/AutoSubstitution/Substitution.qs +++ b/src/Simulation/AutoSubstitution/Substitution.qs @@ -1,5 +1,7 @@ -namespace Microsoft.Quantum.Targeting -{ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace Microsoft.Quantum.Targeting { /// # Summary /// Enables to substitute an operation with an alternative operation for a given target /// From 6096a22b93fa43b708f698cd40153a50ac595f96 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Mon, 14 Jun 2021 13:46:09 +0200 Subject: [PATCH 17/18] Update Sdk version. --- .../Tests.AutoSubstitution.Integration.csproj | 4 ++-- src/Simulation/AutoSubstitution/AutoSubstitution.csproj | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj index 60ed8338fa2..8cacd9e6f30 100644 --- a/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj @@ -1,4 +1,4 @@ - + Library @@ -7,7 +7,7 @@ - + diff --git a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj index cf250657345..296cd0c18dd 100644 --- a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj +++ b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj @@ -1,4 +1,4 @@ - + @@ -12,7 +12,7 @@ - + From b1d65446edb42e8e19da1617689b21917d6ae3b4 Mon Sep 17 00:00:00 2001 From: Mathias Soeken Date: Tue, 15 Jun 2021 10:38:05 +0200 Subject: [PATCH 18/18] Fixes dependency error. --- .../Integration.cs | 18 ++++++++++++++++++ .../Integration.qs | 1 - .../Tests.AutoSubstitution.Integration.csproj | 14 +++++++++++--- .../AutoSubstitution/AutoSubstitution.csproj | 4 ++-- 4 files changed, 31 insertions(+), 6 deletions(-) create mode 100644 src/Simulation/AutoSubstitution.Integration.Tests/Integration.cs diff --git a/src/Simulation/AutoSubstitution.Integration.Tests/Integration.cs b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.cs new file mode 100644 index 00000000000..c8e9979c4a4 --- /dev/null +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using Microsoft.Quantum.Simulation.Simulators; +using Xunit; + +namespace Microsoft.Quantum.AutoSubstitution.Testing +{ + public class CodeGenerationTests + { + [Fact] + public void CanSimulateWithAlternativeSimulator() + { + var sim = new ToffoliSimulator(); + TestQuantumSwap.Run(sim).Wait(); + } + } +} diff --git a/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs index aad9dfc40f2..eb2adb4a726 100644 --- a/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Integration.qs @@ -18,7 +18,6 @@ namespace Microsoft.Quantum.AutoSubstitution.Testing { } } - @Test("ToffoliSimulator") operation TestQuantumSwap() : Unit { use a = Qubit(); use b = Qubit(); diff --git a/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj index 8cacd9e6f30..7260a0b8e2c 100644 --- a/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj +++ b/src/Simulation/AutoSubstitution.Integration.Tests/Tests.AutoSubstitution.Integration.csproj @@ -1,4 +1,4 @@ - + Library @@ -7,8 +7,16 @@ - - + + + + all + runtime; build; native; contentfiles; analyzers + + + + + diff --git a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj index 296cd0c18dd..4cd398f157c 100644 --- a/src/Simulation/AutoSubstitution/AutoSubstitution.csproj +++ b/src/Simulation/AutoSubstitution/AutoSubstitution.csproj @@ -1,4 +1,4 @@ - + @@ -12,7 +12,7 @@ - +