Compile-time errors for Q# programs not supported by QPRGen1 runtime capabilities

src/QsCompiler/CompilationManager/DataStructures.cs

@@ -326,7 +326,12 @@ internal struct TreeNode
             private readonly Position rootPosition;
             public readonly CodeFragment Fragment;
             public readonly IReadOnlyList<TreeNode> Children;
+
+            /// <summary>
+            /// Returns the position of the root node that all child node positions are relative to.
+            /// </summary>
             public Position GetRootPosition() => rootPosition.Copy();
+
             public Position GetPositionRelativeToRoot() => relPosition.Copy();
 
             /// <summary>

src/QsCompiler/CompilationManager/DiagnosticTools.cs

@@ -53,6 +53,20 @@ internal static Position GetAbsolutePosition(Position offset, QsPositionInfo rel
             return absPos;
         }
 
+        /// <summary>
+        /// Creates an absolute position by adding the zero-based offset to the relative position.
+        /// </summary>
+        /// <param name="position">The position.</param>
+        /// <param name="offset">A zero-based line and column offset.</param>
+        /// <exception cref="ArgumentException">Thrown if the position line or column is negative.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if offset line or column is negative.</exception>
+        /// <returns>The absolute position.</returns>
+        internal static Position GetAbsolutePosition(Position position, Tuple<int, int> offset)
+        {
+            var (line, column) = offset;
+            return GetAbsolutePosition(position, new QsPositionInfo(line + 1, column + 1));
+        }
+
         /// <summary>
         /// Given the starting position, convertes the relative range returned by the Q# compiler w.r.t. that starting position into an absolute range as expected by VS.
         /// IMPORTANT: The position returned by the Q# Compiler is (assumed to be) one-based, whereas the given and returned absolute positions are (assumed to be) zero-based!

src/QsCompiler/CompilationManager/TypeChecking.cs

@@ -742,10 +742,12 @@ private static bool TryBuildIfStatement(IEnumerator<FragmentTree.TreeNode> nodes
 
             if (nodes.Current.Fragment.Kind is QsFragmentKind.IfClause ifCond)
             {
+                var rootPosition = nodes.Current.GetRootPosition();
+
                 // if block
                 var buildClause = BuildStatement(nodes.Current,
                     (relPos, ctx) => Statements.NewConditionalBlock(nodes.Current.Fragment.Comments, relPos, ctx, ifCond.Item),
-                    context, diagnostics);
+                    context.WithinIfCondition, diagnostics);
                 var ifBlock = buildClause(BuildScope(nodes.Current.Children, context, diagnostics));
 
                 // elif blocks
@@ -755,7 +757,7 @@ private static bool TryBuildIfStatement(IEnumerator<FragmentTree.TreeNode> nodes
                 {
                     buildClause = BuildStatement(nodes.Current,
                         (relPos, ctx) => Statements.NewConditionalBlock(nodes.Current.Fragment.Comments, relPos, ctx, elifCond.Item),
-                        context, diagnostics);
+                        context.WithinIfCondition, diagnostics);
                     elifBlocks.Add(buildClause(BuildScope(nodes.Current.Children, context, diagnostics)));
                     proceed = nodes.MoveNext();
                 }
@@ -771,7 +773,15 @@ private static bool TryBuildIfStatement(IEnumerator<FragmentTree.TreeNode> nodes
                     proceed = nodes.MoveNext();
                 }
 
-                statement = Statements.NewIfStatement(ifBlock, elifBlocks, elseBlock);
+                var (ifStatement, ifDiagnostics) =
+                    Statements.NewIfStatement(context, ifBlock.Item1, ifBlock.Item2, elifBlocks, elseBlock);
+                statement = ifStatement;
+                diagnostics.AddRange(ifDiagnostics.Select(item =>
+                {
+                    var (relativeOffset, diagnostic) = item;
+                    var offset = DiagnosticTools.GetAbsolutePosition(rootPosition, relativeOffset);
+                    return Diagnostics.Generate(context.Symbols.SourceFile.Value, diagnostic, offset);
+                }));
                 return true;
             }
             (statement, proceed) = (null, true);
@@ -816,7 +826,12 @@ QsNullable<QsLocation> RelativeLocation(FragmentTree.TreeNode node) =>
                     var innerTransformation = BuildScope(nodes.Current.Children, context, diagnostics);
                     var inner = new QsPositionedBlock(innerTransformation, RelativeLocation(nodes.Current), nodes.Current.Fragment.Comments);
                     var built = Statements.NewConjugation(outer, inner);
-                    diagnostics.AddRange(built.Item2.Select(msg => Diagnostics.Generate(context.Symbols.SourceFile.Value, msg.Item2, nodes.Current.GetRootPosition())));
+                    diagnostics.AddRange(built.Item2.Select(item =>
+                    {
+                        var (relativeOffset, diagnostic) = item;
+                        var offset = DiagnosticTools.GetAbsolutePosition(nodes.Current.GetRootPosition(), relativeOffset);
+                        return Diagnostics.Generate(context.Symbols.SourceFile.Value, diagnostic, offset);
+                    }));
 
                     statement = built.Item1;
                     proceed = nodes.MoveNext();

src/QsCompiler/Core/SyntaxGenerator.fs

@@ -76,6 +76,11 @@ module SyntaxGenerator =
     let UnitValue =
         AutoGeneratedExpression UnitValue QsTypeKind.UnitType false
 
+    /// Creates a typed expression that corresponds to a Bool literal with the given value.
+    /// Sets the range information for the built expression to Null.
+    let BoolLiteral value =
+        AutoGeneratedExpression (BoolLiteral value) QsTypeKind.Bool false
+
     /// Creates a typed expression that corresponds to an Int literal with the given value.
     /// Sets the range information for the built expression to Null.
     let IntLiteral v =

src/QsCompiler/DataStructures/Diagnostics.fs

@@ -167,6 +167,9 @@ type ErrorCode =
     | ExpectingCallableExpr = 5021
     | UnknownIdentifier = 5022
     | UnsupportedResultComparison = 5023
+    | ResultComparisonNotInOperationIf = 5024
+    | ReturnInResultConditionedBlock = 5025
+    | SetInResultConditionedBlock = 5026
 
     | CallableRedefinition = 6001
     | CallableOverlapWithTypeConstructor = 6002
@@ -544,8 +547,19 @@ type DiagnosticItem =
             | ErrorCode.ExpectingIterableExpr                     -> "The type {0} does not support iteration. Expecting an expression of array type or of type Range."
             | ErrorCode.ExpectingCallableExpr                     -> "The type of the expression must be a function or operation type. The given expression is of type {0}." 
             | ErrorCode.UnknownIdentifier                         -> "No identifier with the name \"{0}\" exists."
-            // TODO: When the names of the runtime capabilities are finalized, they can be included in the error message.
+            // TODO: When the names of the runtime capabilities are finalized, they can be included in the result
+            //       comparison error messages.
             | ErrorCode.UnsupportedResultComparison               -> "The target {0} does not support comparing measurement results."
+            | ErrorCode.ResultComparisonNotInOperationIf          ->
+                "Measurement results cannot be compared here. " +
+                "The execution target {0} only supports comparing measurement results as part of the condition of an if- or elif-statement in an operation."
+            | ErrorCode.ReturnInResultConditionedBlock            ->
+                "A return statement cannot be used here. " +
+                "The execution target {0} does not support return statements in conditional blocks that depend on a measurement result."
+            | ErrorCode.SetInResultConditionedBlock               ->
+                "The variable \"{0}\" cannot be reassigned here. " +
+                "In conditional blocks that depend on a measurement result, the execution target {1} only supports reassigning variables that were declared within the block."
+
             | ErrorCode.CallableRedefinition                      -> "Invalid callable declaration. A function or operation with the name \"{0}\" already exists."
             | ErrorCode.CallableOverlapWithTypeConstructor        -> "Invalid callable declaration. A type constructor with the name \"{0}\" already exists."
             | ErrorCode.TypeRedefinition                          -> "Invalid type declaration. A type with the name \"{0}\" already exists."

src/QsCompiler/SyntaxProcessor/ExpressionVerification.fs

@@ -63,7 +63,7 @@ let internal toString (t : ResolvedType) = SyntaxTreeToQsharp.Default.ToCode t
 /// This subtyping carries over to tuple types containing operations, and callable types containing operations as within their in- and/or output type. 
 /// However, arrays in particular are treated as invariant; 
 /// i.e. an array of operations of type t1 are *not* a subtype of arrays of operations of type t2 even if t1 is a subtype of t2. 
-let private CommonBaseType addError mismatchErr parent (lhsType : ResolvedType, lhsRange) (rhsType : ResolvedType, rhsRange) : ResolvedType = 
+let private CommonBaseType addError mismatchErr parent (lhsType : ResolvedType, lhsRange) (rhsType : ResolvedType, rhsRange) : ResolvedType =
     let raiseError errCode (lhsCond, rhsCond) = 
         if lhsCond then lhsRange |> addError errCode
         if rhsCond then rhsRange |> addError errCode
@@ -251,9 +251,16 @@ let private VerifyEqualityComparison context addError (lhsType, lhsRange) (rhsTy
     // comparison for any derived type).
     let argumentError = ErrorCode.ArgumentMismatchInBinaryOp, [toString lhsType; toString rhsType]
     let baseType = CommonBaseType addError argumentError context.Symbols.Parent (lhsType, lhsRange) (rhsType, rhsRange)
+
+    // This assumes that:
+    // - Result has no derived types that support equality comparisons.
+    // - Compound types containing Result (e.g., tuples or arrays of results) do not support equality comparison.
     match baseType.Resolution with
     | Result when context.Capabilities = RuntimeCapabilities.QPRGen0 ->
         addError (ErrorCode.UnsupportedResultComparison, [context.ProcessorArchitecture.Value]) rhsRange
+    | Result when context.Capabilities = RuntimeCapabilities.QPRGen1 &&
+                  not (context.IsInOperation && context.IsInIfCondition) ->
+        addError (ErrorCode.ResultComparisonNotInOperationIf, [context.ProcessorArchitecture.Value]) rhsRange
     | _ ->
         let unsupportedError = ErrorCode.InvalidTypeInEqualityComparison, [toString baseType]
         VerifyIsOneOf (fun t -> t.supportsEqualityComparison) unsupportedError addError (baseType, rhsRange) |> ignore

src/QsCompiler/SyntaxProcessor/ScopeTools.fs

@@ -286,6 +286,8 @@ type ScopeContext<'a> =
       Symbols : SymbolTracker<'a>
       /// True if the parent callable for the current scope is an operation.
       IsInOperation : bool
+      /// True if the current expression is contained within the condition of an if- or elif-statement.
+      IsInIfCondition : bool
       /// The return type of the parent callable for the current scope.
       ReturnType : ResolvedType
       /// The runtime capabilities for the compilation unit.
@@ -313,7 +315,12 @@ type ScopeContext<'a> =
         | Found declaration ->
             { Symbols = SymbolTracker<'a> (nsManager, spec.SourceFile, spec.Parent)
               IsInOperation = declaration.Kind = Operation
+              IsInIfCondition = false
               ReturnType = StripPositionInfo.Apply declaration.Signature.ReturnType
               Capabilities = capabilities
               ProcessorArchitecture = processorArchitecture }
         | _ -> raise <| ArgumentException "The specialization's parent callable does not exist."
+
+    /// Returns a new scope context for an expression that is contained within the condition of an if- or
+    /// elif-statement.
+    member this.WithinIfCondition = { this with IsInIfCondition = true }

src/QsCompiler/SyntaxProcessor/StatementVerification.fs

@@ -9,6 +9,7 @@ open System.Collections.Immutable
 open Microsoft.Quantum.QsCompiler
 open Microsoft.Quantum.QsCompiler.DataTypes
 open Microsoft.Quantum.QsCompiler.Diagnostics
+open Microsoft.Quantum.QsCompiler.ReservedKeywords.AssemblyConstants
 open Microsoft.Quantum.QsCompiler.SyntaxExtensions
 open Microsoft.Quantum.QsCompiler.SyntaxProcessing
 open Microsoft.Quantum.QsCompiler.SyntaxProcessing.Expressions
@@ -51,6 +52,75 @@ let private onAutoInvertGenerateError (errCode, range) (symbols : SymbolTracker<
     if not (symbols.RequiredFunctorSupport.Contains QsFunctor.Adjoint) then [||]
     else [| range |> QsCompilerDiagnostic.Error errCode |] 
 
+/// <summary>
+/// Returns true if the expression is an equality or inequality comparison between two expressions of type Result.
+/// </summary>
+/// <param name="parent">The name of the callable in which the expression occurs.</param>
+/// <param name="expression">The expression.</param>
+let private isResultComparison ({ Expression = expression } : TypedExpression) =
+    let validType = function
+        | InvalidType -> None
+        | kind -> Some kind
+    let binaryType lhs rhs = validType lhs.ResolvedType.Resolution |> Option.defaultValue rhs.ResolvedType.Resolution
+
+    // This assumes that:
+    // - Result has no derived types that support equality comparisons.
+    // - Compound types containing Result (e.g., tuples or arrays of results) do not support equality comparison.
+    match expression with
+    | EQ (lhs, rhs) -> binaryType lhs rhs = Result
+    | NEQ (lhs, rhs) -> binaryType lhs rhs = Result
+    | _ -> false
+
+/// Finds the locations where a mutable variable, which was not declared locally in the given scope, is reassigned. The
+/// symbol tracker is not modified. Returns the name of the variable and the location of the reassignment.
+let private nonLocalUpdates (symbols : SymbolTracker<_>) (scope : QsScope) =
+    // This assumes that a variable with the same name cannot be re-declared in an inner scope (i.e., shadowing is not
+    // allowed).
+    let identifierExists (name, location : QsLocation) =
+        let symbol = { Symbol = Symbol name; Range = Value location.Range }
+        match (symbols.ResolveIdentifier ignore symbol |> fst).VariableName with
+        | InvalidIdentifier -> false
+        | _ -> true
+    let accumulator = AccumulateIdentifiers()
+    accumulator.Statements.OnScope scope |> ignore
+    accumulator.SharedState.ReassignedVariables
+    |> Seq.collect (fun grouping -> Seq.map (fun location -> grouping.Key, location) grouping)
+    |> Seq.filter identifierExists
+
+/// Verifies that any conditional blocks which depend on a measurement result do not use any language constructs that
+/// are not supported by the runtime capabilities. Returns the diagnostics for the blocks.
+let private verifyResultConditionalBlocks context condBlocks elseBlock =
+    // Diagnostics for return statements.
+    let returnStatements (statement : QsStatement) = statement.ExtractAll <| fun s ->
+        match s.Statement with
+        | QsReturnStatement _ -> [s]
+        | _ -> []
+    let returnError (statement : QsStatement) =
+        let error = ErrorCode.ReturnInResultConditionedBlock, [context.ProcessorArchitecture.Value]
+        let location = statement.Location.ValueOr { Offset = 0, 0; Range = QsCompilerDiagnostic.DefaultRange }
+        location.Offset, QsCompilerDiagnostic.Error error location.Range
+    let returnErrors (block : QsPositionedBlock) =
+        block.Body.Statements |> Seq.collect returnStatements |> Seq.map returnError
+
+    // Diagnostics for variable reassignments.
+    let setError (name : NonNullable<string>, location : QsLocation) =
+        let error = ErrorCode.SetInResultConditionedBlock, [name.Value; context.ProcessorArchitecture.Value]
+        location.Offset, QsCompilerDiagnostic.Error error location.Range
+    let setErrors (block : QsPositionedBlock) = nonLocalUpdates context.Symbols block.Body |> Seq.map setError
+
+    let blocks =
+        elseBlock
+        |> QsNullable<_>.Map (fun block -> SyntaxGenerator.BoolLiteral true, block)
+        |> QsNullable<_>.Fold (fun acc x -> x :: acc) []
+        |> Seq.append condBlocks
+    let foldErrors (dependsOnResult, diagnostics) (condition : TypedExpression, block) =
+        if dependsOnResult || condition.Exists isResultComparison
+        then true, Seq.concat [returnErrors block; setErrors block; diagnostics]
+        else false, diagnostics
+    if context.Capabilities = RuntimeCapabilities.QPRGen1
+    then Seq.fold foldErrors (false, Seq.empty) blocks |> snd
+    else Seq.empty
+
 
 // utils for building QsStatements from QsFragmentKinds
 
@@ -250,15 +320,21 @@ let NewConditionalBlock comments location context (qsExpr : QsExpression) =
     let block body = condition, QsPositionedBlock.New comments (Value location) body
     new BlockStatement<_>(block), Array.concat [errs; autoGenErrs]
 
-/// Given a conditional block for the if-clause of a Q# if-statement, a sequence of conditional blocks for the elif-clauses, 
-/// as well as optionally a positioned block of Q# statements and its location for the else-clause, builds and returns the complete if-statement.  
-/// Throws an ArgumentException if the given if-block contains no location information. 
-let NewIfStatement (ifBlock : TypedExpression * QsPositionedBlock, elifBlocks, elseBlock : QsNullable<QsPositionedBlock>) = 
-    let location = (snd ifBlock).Location |> function 
-        | Null -> ArgumentException "no location is set for the given if-block" |> raise
-        | Value loc -> loc 
-    let condBlocks = seq { yield ifBlock; yield! elifBlocks; }
-    QsConditionalStatement.New (condBlocks, elseBlock) |> QsConditionalStatement |> asStatement QsComments.Empty location LocalDeclarations.Empty
+/// Given a conditional block for the if-clause of a Q# if-statement, a sequence of conditional blocks for the elif-clauses,
+/// as well as optionally a positioned block of Q# statements and its location for the else-clause, builds and returns the complete if-statement.
+/// Throws an ArgumentException if the given if-block contains no location information.
+let NewIfStatement context (ifBlock : TypedExpression * QsPositionedBlock) elifBlocks elseBlock =
+    let location =
+        match (snd ifBlock).Location with
+        | Null -> ArgumentException "No location is set for the given if-block." |> raise
+        | Value location -> location
+    let condBlocks = Seq.append (Seq.singleton ifBlock) elifBlocks
+    let statement =
+        QsConditionalStatement.New (condBlocks, elseBlock)
+        |> QsConditionalStatement
+        |> asStatement QsComments.Empty location LocalDeclarations.Empty
+    let diagnostics = verifyResultConditionalBlocks context condBlocks elseBlock
+    statement, diagnostics
 
 /// Given a positioned block of Q# statements for the repeat-block of a Q# RUS-statement, a typed expression containing the success condition, 
 /// as well as a positioned block of Q# statements for the fixup-block, builds the complete RUS-statement at the given location and returns it.

src/QsCompiler/SyntaxProcessor/VerificationTools.fs

@@ -107,5 +107,3 @@ type ResolvedType with
         | Range -> Some (Int |> ResolvedType.New)
         | ArrayType bt -> Some bt
         | _ -> None
-
-