Add Q# language support (github-linguist#4901)

* Add Q# language support

* Add a color for Q#

* Make Q# colour closer to the VSCode extension logo

* Add support for Qt Script

* Remove Q# syntax repo

* Properly remove the submodule

* Add heuristics for Q# and Qt Script

* Fine-tune the '.qs' heuristics

* Change Q# colour to "fridge gold"

* Add the official grammar for Q#

Author: JakuJ

.gitmodules

@@ -818,6 +818,9 @@
 [submodule "vendor/grammars/python-django.tmbundle"]
 	path = vendor/grammars/python-django.tmbundle
 	url = https://github.com/textmate/python-django.tmbundle
+[submodule "vendor/grammars/qsharp-compiler"]
+	path = vendor/grammars/qsharp-compiler
+	url = https://github.com/microsoft/qsharp-compiler
 [submodule "vendor/grammars/quake"]
 	path = vendor/grammars/quake
 	url = https://github.com/newgrammars/quake

grammars.yml

@@ -722,6 +722,8 @@ vendor/grammars/protobuf-tmbundle:
 vendor/grammars/python-django.tmbundle:
 - source.python.django
 - text.html.django
+vendor/grammars/qsharp-compiler:
+- source.qsharp
 vendor/grammars/quake:
 - source.quake
 vendor/grammars/r.tmbundle:

lib/linguist/heuristics.yml

@@ -407,6 +407,12 @@ disambiguations:
     pattern: '((?i:[A-Z.][\w.]*:{)|(^|\n)\\(cd?|d|l|p|ts?) )'
   - language: HiveQL
     pattern: '(?i:SELECT\s+[\w*,]+\s+FROM|(CREATE|ALTER|DROP)\s(DATABASE|SCHEMA|TABLE))'
+- extensions: ['.qs']
+  rules:
+  - language: Q#
+    pattern: '^((\/{2,3})?\s*(namespace|operation)\b)'
+  - language: Qt Script
+    pattern: '(\w+\.prototype\.\w+|===|\bvar\b)'
 - extensions: ['.r']
   rules:
   - language: Rebol

lib/linguist/languages.yml

@@ -4304,6 +4304,16 @@ Python traceback:
   tm_scope: text.python.traceback
   ace_mode: text
   language_id: 304
+Q#:
+  type: programming
+  extensions:
+  - ".qs"
+  aliases:
+  - qsharp
+  color: "#fed659"
+  ace_mode: text
+  tm_scope: source.qsharp
+  language_id: 697448245
 QML:
   type: programming
   color: "#44a51c"
@@ -4323,6 +4333,19 @@ QMake:
   tm_scope: source.qmake
   ace_mode: text
   language_id: 306
+Qt Script:
+  type: programming
+  ace_mode: javascript
+  codemirror_mode: javascript
+  codemirror_mime_type: text/javascript
+  extensions:
+  - ".qs"
+  filenames:
+  - "installscript.qs"
+  - "toolchain_installscript.qs"
+  color: "#00b841"
+  tm_scope: source.js
+  language_id: 558193693
 Quake:
   type: programming
   filenames:

samples/Q#/CustomModAdd.qs

@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Microsoft.Quantum.Numerics.Samples {
+    open Microsoft.Quantum.Intrinsic;
+    open Microsoft.Quantum.Arithmetic;
+    open Microsoft.Quantum.Diagnostics;
+    open Microsoft.Quantum.Arrays;
+
+    /// # Summary
+    /// Tests a modular addition similar to the one in Fig. 4
+    /// of https://arxiv.org/pdf/quant-ph/9511018v1.pdf.
+    ///
+    /// # Input
+    /// ## inputs1
+    /// List of integers to use for the first number
+    /// ## inputs2
+    /// List of integers to use for the second number
+    /// ## modulus
+    /// Modulus used when adding each pair of numbers
+    /// ## numBits
+    /// Number of bits to use to represent each number
+    operation CustomModAdd(inputs1 : Int[], inputs2 : Int[], modulus : Int,
+                            numBits : Int) : Int[]
+    {
+        EqualityFactI(Length(inputs1), Length(inputs2),
+                      "Input arrays need to be of equal length.");
+        mutable results = new Int[Length(inputs1)];
+        for (i in IndexRange(inputs1)) {
+            let input1 = inputs1[i];
+            let input2 = inputs2[i];
+            using ((xQubits, yQubits, mQubits, tmp, ctrl) = (Qubit[numBits], Qubit[numBits], Qubit[numBits], Qubit(), Qubit())) {
+                let x = LittleEndian(xQubits);
+                let y = LittleEndian(yQubits);
+                let m = LittleEndian(mQubits);
+                // initialize inputs
+                ApplyXorInPlace(input1, x);
+                ApplyXorInPlace(input2, y);
+                ApplyXorInPlace(modulus, m);
+
+                // first, add the two inputs
+                AddI(x, y);
+                // if the result is greater than or equal to the modulus,
+                // we have to subtract `modulus` from the result:
+                let yc = LittleEndian(yQubits + [tmp]);
+                (Adjoint AddI)(m, yc);
+                within {
+                    CNOT(tmp, ctrl);
+                } apply {
+                    // we should not have subtracted m if there is overflow:
+                    Controlled AddI([ctrl], (m, yc));
+                    // now, uncompute temporary qubits:
+                    Adjoint AddI(x, yc);
+                }
+                AddI(x, yc);
+                X(ctrl);
+
+                set results w/= i <- MeasureInteger(y);
+                ResetAll(xQubits + yQubits + mQubits);
+            }
+        }
+        return results;
+    }
+}