QEP 2: Enhanced Array Literals (#643)

* Add C# gen for sized array

* Implement QArray.Repeat

* Add more array tests

* Add doc comments

* More efficient array creation

* Remove TODO, leave exception type untested

* Formatting

* Update packages

* Add tests for ref counts in array-of-arrays

* Capture value expression

* Undo QscVerbosity

* Clean up QArrayInner.Extend

* Increment ref count N times

* Add comment about exception type

* Update packages

* Fix partial application code gen test

* Update SDK package

* Update Microsoft.Quantum.CSharpGeneration.fsproj

* Update Microsoft.Quantum.CSharpGeneration.fsproj

* Update C# generation tests for microsoft/qsharp-compiler#952

* Update global.json

Author: bamarsha

global.json

@@ -1,5 +1,5 @@
 {
     "msbuild-sdks": {
-        "Microsoft.Quantum.Sdk": "0.15.210425594-alpha"
+        "Microsoft.Quantum.Sdk": "0.15.210425813-alpha"
     }
 }

src/Simulation/CSharpGeneration.Tests/SimulationCodeTests.fs

@@ -22,7 +22,7 @@
 
   <ItemGroup>
     <PackageReference Update="FSharp.Core" Version="4.7.0" />
-    <PackageReference Include="Microsoft.Quantum.Compiler" Version="0.15.210324735-alpha" />
+    <PackageReference Include="Microsoft.Quantum.Compiler" Version="0.15.210425459-pull" />
   </ItemGroup>
 
   <ItemGroup>

src/Simulation/CSharpGeneration/Microsoft.Quantum.CSharpGeneration.fsproj

@@ -409,6 +409,7 @@ module SimulationCode =
             | NamedItem (ex, acc)           -> buildNamedItem ex acc
             | ArrayItem (a, i)              -> buildArrayItem a i
             | ValueArray elems              -> buildValueArray ex.ResolvedType elems
+            | SizedArray (value, size)      -> buildSizedArray value size
             | NewArray (t, expr)            -> buildNewArray t expr
             | AdjointApplication op         -> (buildExpression op)   <|.|> (``ident`` "Adjoint")
             | ControlledApplication op      -> (buildExpression op)   <|.|> (``ident`` "Controlled")
@@ -591,6 +592,10 @@ module SimulationCode =
 // TODO: diagnostics.
             | _ -> failwith ""
 
+        and buildSizedArray value size =
+            let supplier = ``() =>`` [] (captureExpression value) :> ExpressionSyntax
+            ident "QArray" <.> (ident "Filled", [ supplier; buildExpression size ])
+
         and buildNewArray b count =
             let arrayType = (ArrayType b |> QArrayType).Value
             arrayType <.> (``ident`` "Create", [count |> buildExpression])

src/Simulation/CSharpGeneration/SimulationCode.fs

@@ -135,16 +135,22 @@ public void UnsafeSetElement(long index, T value)
 
             public void Extend(long newLength)
             {
-                var newLengthInt = Convert.ToInt32(newLength);
-                if (storage is null)
-                {
-                    storage = new List<T>(newLengthInt);
-                }
-                else if (storage.Capacity < newLengthInt)
-                {
-                    storage.Capacity = newLengthInt;
-                }
-                storage.AddRange(Enumerable.Repeat(Default.OfType<T>(), newLengthInt - storage.Count));
+                var value = Default.OfType<T>();
+                Extend(() => value, Convert.ToInt32(newLength - Length));
+            }
+
+            /// <summary>
+            /// Extends the length of the array by calling <paramref name="supplier"/> <paramref name="count"/> times to
+            /// supply a value for each new index.
+            /// </summary>
+            internal void Extend(Func<T> supplier, long count)
+            {
+                var total = Convert.ToInt32(Length + count);
+                storage ??= new List<T>(total);
+                storage.Capacity = Math.Max(storage.Capacity, total);
+                storage.AddRange(Enumerable
+                    .Repeat<object>(null, Convert.ToInt32(count))
+                    .Select(_ => supplier()));
             }
         }
 
@@ -232,15 +238,26 @@ public QArray(params T[] collection)
         }
 
         /// <summary>
-        /// Creates an array of size given by capacity and default-initializes 
-        /// array elements. Uses C# keyword <code>default</code> to initialize array elements. 
+        /// Creates an array of size given by capacity and initializes each array element to the default value it has in
+        /// Q#.
         /// </summary>
         public static QArray<T> Create(long capacity) => new QArray<T>
         {
             storage = new QArrayInner(capacity),
             Length = capacity
         };
 
+        /// <summary>
+        /// Creates an array filled by calling <paramref name="supplier"/> <paramref name="count"/> times to supply a
+        /// value for each index.
+        /// </summary>
+        internal static QArray<T> Filled(Func<T> supplier, long count)
+        {
+            var array = new QArray<T> { Length = count };
+            array.storage.Extend(supplier, count);
+            return array;
+        }
+
         /// <summary>
         /// Creates a copy of this array.
         /// </summary>
@@ -517,6 +534,17 @@ public static implicit operator QArray<object>(QArray<T> arg) =>
             arg;
     }
 
+    /// <summary>
+    /// Contains static methods for creating <see cref="QArray"/>s.
+    /// </summary>
+    public static class QArray
+    {
+        /// <summary>
+        /// Creates an array filled by calling <paramref name="supplier"/> <paramref name="count"/> times to supply a
+        /// value for each index.
+        /// </summary>
+        public static QArray<T> Filled<T>(Func<T> supplier, long count) => QArray<T>.Filled(supplier, count);
+    }
 
     /// <summary>
     /// This JsonConverter converts instances of IQArray['T] as QArray['T]
@@ -557,4 +585,3 @@ public override bool CanConvert(Type objectType) =>
                 objectType.GetGenericTypeDefinition() == typeof(QArray<>);
     }
 }
-

src/Simulation/Core/QArray.cs

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk">
+<Project Sdk="Microsoft.Quantum.Sdk">
 
   <Import Project="..\Common\AssemblyCommon.props" />
   <Import Project="..\Common\Simulators.Dev.props" />

src/Simulation/QCTraceSimulator.Tests/Tests.Microsoft.Quantum.Simulation.QCTraceSimulatorRuntime.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk">
+<Project Sdk="Microsoft.Quantum.Sdk">
   <Import Project="..\TargetDefinitions\TargetPackages\QSharpCore.Package.props" />
 
   <PropertyGroup>

src/Simulation/QSharpCore/Microsoft.Quantum.QSharp.Core.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk">
+<Project Sdk="Microsoft.Quantum.Sdk">
 
   <Import Project="..\Common\AssemblyCommon.props" />
   <Import Project="..\Common\DebugSymbols.props" />

src/Simulation/QSharpFoundation/Microsoft.Quantum.QSharp.Foundation.csproj

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Microsoft.Quantum.Simulation.Simulators.Tests.Circuits {
+    open Microsoft.Quantum.Diagnostics;
+    open Microsoft.Quantum.Intrinsic;
+
+    operation MapF<'T, 'U>(mapper : ('T -> 'U), source : 'T[]) : 'U[] {
+        mutable result = new 'U[Length(source)];
+        for (i in 0 .. Length(source) - 1) {
+            let m = mapper(source[i]);
+            set result = result w/ i <- m;
+        }
+        
+        return result;
+    }
+
+    operation LengthTest() : Unit {
+        let a1 = [One, Zero];
+        let a2 = [Zero, Zero, Zero];
+
+        AssertEqual(2, Length(a1));
+        AssertEqual(3, Length(a2));
+
+        let values = MapF(Length<Result>, [a1, a2]);
+        AssertEqual(2, values[0]);
+        AssertEqual(3, values[1]);
+    }
+
+    @Test("QuantumSimulator")
+    function CreateArrayWithPositiveSize() : Unit {
+        let xs = [true, size = 3];
+        AssertEqual([true, true, true], xs);
+    }
+
+    @Test("QuantumSimulator")
+    function CreateArrayWithZeroSize() : Unit {
+        let xs = [true, size = 0];
+        AssertEqual(0, Length(xs));
+    }
+
+    function CreateArrayWithNegativeSize() : Bool[] {
+        return [true, size = -1];
+    }
+
+    @Test("QuantumSimulator")
+    function CreateArrayWithSizeExpression() : Unit {
+        let n = 2;
+        let xs = [7, size = n + 1];
+        AssertEqual([7, 7, 7], xs);
+    }
+
+    @Test("QuantumSimulator")
+    function CreateArrayWithValueExpression() : Unit {
+        let x = "foo";
+        let xs = [x + "bar", size = 3];
+        AssertEqual(["foobar", "foobar", "foobar"], xs);
+    }
+
+    @Test("QuantumSimulator")
+    function SizedArrayShouldIncrementArrayItemRefCount() : Unit {
+        mutable item = [1];
+        let items = [item, size = 2];
+        set item w/= 0 <- 2;
+
+        AssertEqual([2], item);
+        AssertEqual([[1], [1]], items);
+    }
+
+    @Test("QuantumSimulator")
+    function ArrayOfArraysShouldCopyOnUpdate() : Unit {
+        mutable items = [[1], size = 2];
+        set items w/= 0 <- items[0] w/ 0 <- 2;
+
+        AssertEqual([[2], [1]], items);
+    }
+}