Classically Controlled to Master

src/QsCompiler/CommandLineTool/Commands/Build.cs

@@ -131,7 +131,8 @@ public static int Run(BuildOptions options, ConsoleLogger logger)
                 ProjectName = options.ProjectName,
                 GenerateFunctorSupport = true,
                 SkipSyntaxTreeTrimming = options.TrimLevel == 0,
-                AttemptFullPreEvaluation = options.TrimLevel > 1,
+                ConvertClassicalControl = options.TrimLevel >= 2,
+                AttemptFullPreEvaluation = options.TrimLevel > 2,
                 DocumentationOutputFolder = options.DocFolder,
                 BuildOutputFolder = options.OutputFolder ?? (usesPlugins ? "." : null),
                 DllOutputPath = options.EmitDll ? " " : null, // set to e.g. an empty space to generate the dll in the same location as the .bson file

src/QsCompiler/CommandLineTool/Commands/Diagnose.cs

@@ -221,7 +221,8 @@ public static int Run(DiagnoseOptions options, ConsoleLogger logger)
             {
                 GenerateFunctorSupport = true,
                 SkipSyntaxTreeTrimming = options.TrimLevel == 0,
-                AttemptFullPreEvaluation = options.TrimLevel > 1,
+                ConvertClassicalControl = options.TrimLevel >= 2,
+                AttemptFullPreEvaluation = options.TrimLevel > 2,
                 RewriteSteps = options.Plugins?.Select(step => (step, (string)null)) ?? ImmutableArray<(string, string)>.Empty,
                 EnableAdditionalChecks = true
             }; 

src/QsCompiler/Compiler/FunctorGeneration.cs

@@ -28,7 +28,7 @@ private static QsTuple<LocalVariableDeclaration<QsLocalSymbol>> ControlledArg(Qs
             : null;
 
         /// <summary>
-        /// Given a sequence of specialziations, returns the implementation of the given kind, or null if no such specialization exists.
+        /// Given a sequence of specializations, returns the implementation of the given kind, or null if no such specialization exists.
         /// Throws an ArgumentException if more than one specialization of that kind exist. 
         /// Throws an ArgumentNullException if the sequence of specializations is null, or contains any entries that are null.
         /// </summary>
@@ -67,7 +67,7 @@ private static (QsTuple<LocalVariableDeclaration<QsLocalSymbol>>, QsScope)? Body
         }
 
         /// <summary>
-        /// Given a Q# callable, evaluates any functor generator directive given for its adjoint specializiation.
+        /// Given a Q# callable, evaluates any functor generator directive given for its adjoint specialization.
         /// If the body specialization is either intrinsic or external, return the given callable unchanged. 
         /// Otherwise returns a new QsCallable with the adjoint specialization set to the generated implementation if it was generated,
         /// or set to the original specialization if the specialization was not requested to be auto-generated. 
@@ -96,7 +96,7 @@ private static QsCallable BuildAdjoint(this QsCallable callable)
         }
 
         /// <summary>
-        /// Given a Q# callable, evaluates any functor generator directive given for its controlled specializiation.
+        /// Given a Q# callable, evaluates any functor generator directive given for its controlled specialization.
         /// If the body specialization is either intrinsic or external, return the given callable unchanged. 
         /// Otherwise returns a new QsCallable with the controlled specialization set to the generated implementation if it was generated,
         /// or set to the original specialization if the specialization was not requested to be auto-generated. 
@@ -122,7 +122,7 @@ private static QsCallable BuildControlled(this QsCallable callable)
         }
 
         /// <summary>
-        /// Given a Q# callable, evaluates any functor generator directive given for its controlled adjoint specializiation.
+        /// Given a Q# callable, evaluates any functor generator directive given for its controlled adjoint specialization.
         /// If the body specialization is either intrinsic or external, return the given callable unchanged. 
         /// Otherwise returns a new QsCallable with the controlled adjoint specialization set to the generated implementation if it was generated,
         /// or set to the original specialization if the specialization was not requested to be auto-generated. 
@@ -153,10 +153,10 @@ private static QsCallable BuildControlledAdjoint(this QsCallable callable)
                 {
                     var ctl = callable.Specializations.GetSpecialization(QsSpecializationKind.QsControlled);
                     var (ctlArg, ctlImpl) = GetContent(ctl?.Implementation) ?? throw new ArgumentException("no implementation provided for controlled specialization");
-                    void SetImplementation(QsScope impl) => ctlAdj = ctlAdj.WithImplementation(SpecializationImplementation.NewProvided(ctlArg, impl));
-
-                    //if (gen.Item.IsSelfInverse) SetImplementation(ctlImpl); -> nothing to do here, we want to keep this information
-                    if (gen.Item.IsInvert) SetImplementation(ctlImpl.GenerateAdjoint());
+                    if (gen.Item.IsInvert)
+                    {
+                        ctlAdj = ctlAdj.WithImplementation(SpecializationImplementation.NewProvided(ctlArg, ctlImpl.GenerateAdjoint()));
+                    }
                 }
             }
             return callable.WithSpecializations(specs => specs.Select(s => s.Kind == QsSpecializationKind.QsControlledAdjoint ? ctlAdj : s).ToImmutableArray());

src/QsCompiler/Compiler/PluginInterface.cs

@@ -93,7 +93,7 @@ public struct Diagnostic
         /// <summary>
         /// Verifies whether a given compilation satisfies the precondition for executing this rewrite step. 
         /// <see cref="ImplementsPreconditionVerification"/> indicates whether or not this method is implemented. 
-        /// If the precondition verfication succeeds, then the invocation of an implemented transformation (if any) 
+        /// If the precondition verification succeeds, then the invocation of an implemented transformation (if any) 
         /// with the given compilation should complete without throwing an exception. 
         /// The precondition verification should never throw an exception, 
         /// but instead indicate if the precondition is satisfied via the returned value. 

src/QsCompiler/Compiler/RewriteSteps/ClassicallyControlled.cs

@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Quantum.QsCompiler.DataTypes;
+using Microsoft.Quantum.QsCompiler.SyntaxTree;
+using Microsoft.Quantum.QsCompiler.Transformations.ClassicallyControlledTransformation;
+
+
+namespace Microsoft.Quantum.QsCompiler.BuiltInRewriteSteps
+{
+    internal class ClassicallyControlled : IRewriteStep
+    {
+        public string Name => "ClassicallyControlled";
+        public int Priority => 10; // Not used for built-in transformations like this
+        public IDictionary<string, string> AssemblyConstants { get; }
+        public IEnumerable<IRewriteStep.Diagnostic> GeneratedDiagnostics => null;
+
+        public bool ImplementsTransformation => true;
+        public bool ImplementsPreconditionVerification => true;
+        public bool ImplementsPostconditionVerification => false;
+
+        public ClassicallyControlled()
+        {
+            AssemblyConstants = new Dictionary<string, string>();
+        }
+
+        public bool Transformation(QsCompilation compilation, out QsCompilation transformed)
+        {
+            transformed = ClassicallyControlledTransformation.Apply(compilation);
+            return true;
+        }
+
+        public bool PreconditionVerification(QsCompilation compilation)
+        {
+            var controlNs = compilation.Namespaces
+                .FirstOrDefault(ns => ns.Name.Equals(BuiltIn.ClassicallyControlledNamespace));
+
+            if (controlNs == null)
+            {
+                return false;
+            }
+
+            var providedOperations = new QsNamespace[] { controlNs }.Callables().Select(c => c.FullName.Name);
+            var requiredBuiltIns = new List<NonNullable<string>>()
+            {
+                BuiltIn.ApplyIfZero.Name,
+                BuiltIn.ApplyIfZeroA.Name,
+                BuiltIn.ApplyIfZeroC.Name,
+                BuiltIn.ApplyIfZeroCA.Name,
+
+                BuiltIn.ApplyIfOne.Name,
+                BuiltIn.ApplyIfOneA.Name,
+                BuiltIn.ApplyIfOneC.Name,
+                BuiltIn.ApplyIfOneCA.Name,
+
+                BuiltIn.ApplyIfElseR.Name,
+                BuiltIn.ApplyIfElseRA.Name,
+                BuiltIn.ApplyIfElseRC.Name,
+                BuiltIn.ApplyIfElseRCA.Name
+            };
+
+            return requiredBuiltIns.All(builtIn => providedOperations.Any(provided => provided.Equals(builtIn)));
+        }
+
+        public bool PostconditionVerification(QsCompilation compilation)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

src/QsCompiler/Core/Dependencies.fs

@@ -6,6 +6,7 @@ namespace Microsoft.Quantum.QsCompiler
 open System.Collections.Immutable
 open Microsoft.Quantum.QsCompiler.DataTypes
 open Microsoft.Quantum.QsCompiler.SyntaxTree
+open Microsoft.Quantum.QsCompiler.SyntaxTokens
 
 
 type BuiltIn = {
@@ -21,6 +22,7 @@ type BuiltIn = {
     static member IntrinsicNamespace = NonNullable<string>.New "Microsoft.Quantum.Intrinsic"
     static member StandardArrayNamespace = NonNullable<string>.New "Microsoft.Quantum.Arrays"
     static member DiagnosticsNamespace = NonNullable<string>.New "Microsoft.Quantum.Diagnostics"
+    static member ClassicallyControlledNamespace = NonNullable<string>.New "Microsoft.Quantum.Simulation.QuantumProcessor.Extensions"
 
     /// Returns the set of namespaces that is automatically opened for each compilation.
     static member NamespacesToAutoOpen = ImmutableHashSet.Create (BuiltIn.CoreNamespace)
@@ -85,6 +87,91 @@ type BuiltIn = {
         TypeParameters = ImmutableArray.Empty
     }
 
+    // hard dependencies in Microsoft.Quantum.Simulation.QuantumProcessor.Extensions
+
+    // This is expected to have type <'T>((Result, (('T => Unit), 'T)) => Unit)
+    static member ApplyIfZero = {
+        Name = "ApplyIfZero" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Adj), 'T)) => Unit is Adj)
+    static member ApplyIfZeroA = {
+        Name = "ApplyIfZeroA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Ctl), 'T)) => Unit is Ctl)
+    static member ApplyIfZeroC = {
+        Name = "ApplyIfZeroC" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Adj + Ctl), 'T)) => Unit is Adj + Ctl)
+    static member ApplyIfZeroCA = {
+        Name = "ApplyIfZeroCA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit), 'T)) => Unit)
+    static member ApplyIfOne = {
+        Name = "ApplyIfOne" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Adj), 'T)) => Unit is Adj)
+    static member ApplyIfOneA = {
+        Name = "ApplyIfOneA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Ctl), 'T)) => Unit is Ctl)
+    static member ApplyIfOneC = {
+        Name = "ApplyIfOneC" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T>((Result, (('T => Unit is Adj + Ctl), 'T)) => Unit is Adj + Ctl)
+    static member ApplyIfOneCA = {
+        Name = "ApplyIfOneCA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T, 'U>((Result, (('T => Unit), 'T), (('U => Unit), 'U)) => Unit)
+    static member ApplyIfElseR = {
+        Name = "ApplyIfElseR" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New, "U" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T, 'U>((Result, (('T => Unit is Adj), 'T), (('U => Unit is Adj), 'U)) => Unit is Adj)
+    static member ApplyIfElseRA = {
+        Name = "ApplyIfElseRA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New, "U" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T, 'U>((Result, (('T => Unit is Ctl), 'T), (('U => Unit is Ctl), 'U)) => Unit is Ctl)
+    static member ApplyIfElseRC = {
+        Name = "ApplyIfElseRC" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New, "U" |> NonNullable<string>.New)
+    }
+
+    // This is expected to have type <'T, 'U>((Result, (('T => Unit is Adj + Ctl), 'T), (('U => Unit is Adj + Ctl), 'U)) => Unit is Adj + Ctl)
+    static member ApplyIfElseRCA = {
+        Name = "ApplyIfElseRCA" |> NonNullable<string>.New
+        Namespace = BuiltIn.ClassicallyControlledNamespace
+        TypeParameters = ImmutableArray.Create("T" |> NonNullable<string>.New, "U" |> NonNullable<string>.New)
+    }
 
     // "weak dependencies" in other namespaces (e.g. things used for code actions)
 

src/QsCompiler/DataStructures/SyntaxExtensions.fs

@@ -171,21 +171,6 @@ type TypedExpression with
 
     // utils for walking the data structure
 
-    /// Returns true if the expression contains missing expressions.
-    /// Returns false otherwise.
-    static member public ContainsMissing (ex : TypedExpression) =
-        match ex.TupleItems with 
-        | Some items when items.Length > 1 -> items |> List.exists TypedExpression.ContainsMissing
-        | Some [] -> true
-        | _ -> false
-
-    /// Returns true if the expression is a call-like expression, and the arguments contain a missing expression.
-    /// Returns false otherwise.
-    static member public IsPartialApplication kind =
-        match kind with
-        | CallLikeExpression (_, args) -> args |> TypedExpression.ContainsMissing
-        | _ -> false
-
     /// Returns true if the expression kind does not contain any inner expressions. 
     static member private IsAtomic (kind : QsExpressionKind<'E, _, _>) = 
         match kind with

src/QsCompiler/DataStructures/SyntaxTree.fs

@@ -364,6 +364,17 @@ type TypedExpression = {
     member this.TypeParameterResolutions = 
         this.TypeArguments.ToImmutableDictionary((fun (origin, name, _) -> origin, name), (fun (_,_,t) -> t))
 
+    /// Returns true if the expression is a call-like expression, and the arguments contain a missing expression.
+    /// Returns false otherwise.
+    static member public IsPartialApplication kind =
+        let rec containsMissing ex = 
+            match ex.Expression with
+            | MissingExpr -> true
+            | ValueTuple items -> items |> Seq.exists containsMissing
+            | _ -> false
+        match kind with
+        | CallLikeExpression (_, args) -> args |> containsMissing
+        | _ -> false
 
 
 /// Fully resolved Q# initializer expression.

src/QsCompiler/Optimizations/OptimizingTransformations/ConstantPropagation.fs

@@ -22,7 +22,7 @@ type ConstantPropagation(callables) =
 
     /// Returns whether the given expression should be propagated as a constant.
     /// For a statement of the form "let x = [expr];", if shouldPropagate(expr) is true,
-    /// then we should substitute [expr] for x wherever x occurs in future code.
+    /// then we should substitute x with [expr] wherever x occurs in future code.
     let rec shouldPropagate callables (expr : TypedExpression) =
         let folder ex sub = 
             isLiteral callables ex ||

src/QsCompiler/Optimizations/Utils/Evaluation.fs

@@ -219,7 +219,7 @@ and [<AbstractClass>] private ExpressionKindEvaluator(callables: ImmutableDictio
                 let fe = FunctionEvaluator (callables)
                 return! fe.evaluateFunction qualName arg types stmtsLeft |> Option.map (fun x -> x.Expression)
             | CallLikeExpression (baseMethod, partialArg) ->
-                do! check (TypedExpression.ContainsMissing partialArg)
+                do! check (TypedExpression.IsPartialApplication method.Expression)
                 return this.Transform (CallLikeExpression (baseMethod, fillPartialArg (partialArg, arg)))
             | _ -> return! None
         } |? CallLikeExpression (method, arg)
@@ -229,7 +229,7 @@ and [<AbstractClass>] private ExpressionKindEvaluator(callables: ImmutableDictio
         maybe {
             match method.Expression with
             | CallLikeExpression (baseMethod, partialArg) ->
-                do! check (TypedExpression.ContainsMissing partialArg)
+                do! check (TypedExpression.IsPartialApplication method.Expression)
                 return this.Transform (CallLikeExpression (baseMethod, fillPartialArg (partialArg, arg)))
             | _ -> return! None
         } |? CallLikeExpression (method, arg)
@@ -239,7 +239,7 @@ and [<AbstractClass>] private ExpressionKindEvaluator(callables: ImmutableDictio
         maybe {
             match method.Expression with
             | CallLikeExpression (baseMethod, partialArg) ->
-                do! check (TypedExpression.ContainsMissing partialArg)
+                do! check (TypedExpression.IsPartialApplication method.Expression)
                 return this.Transform (CallLikeExpression (baseMethod, fillPartialArg (partialArg, arg)))
             | _ -> return! None
         } |? CallLikeExpression (method, arg)

src/QsCompiler/Optimizations/Utils/HelperFunctions.fs

@@ -190,18 +190,26 @@ and internal defaultValue (bt: TypeKind): ExprKind option =
     | _ -> None
 
 
+/// Returns true if the expression contains missing expressions.
+/// Returns false otherwise.
+let rec private containsMissing (ex : TypedExpression) =
+    match ex.Expression with 
+    | MissingExpr -> true
+    | ValueTuple items -> items |> Seq.exists containsMissing
+    | _ -> false
+
 /// Fills a partial argument by replacing MissingExprs with the corresponding values of a tuple
 let rec internal fillPartialArg (partialArg: TypedExpression, arg: TypedExpression): TypedExpression =
     match partialArg with
     | Missing -> arg
     | Tuple items ->
         let argsList =
-            match List.filter TypedExpression.ContainsMissing items, arg with
+            match List.filter containsMissing items, arg with
             | [_], _ -> [arg]
             | _, Tuple args -> args
             | _ -> failwithf "args must be a tuple"
         items |> List.mapFold (fun args t1 ->
-            if TypedExpression.ContainsMissing t1 then
+            if containsMissing t1 then
                 match args with
                 | [] -> failwithf "ran out of args"
                 | head :: tail -> fillPartialArg (t1, head), tail