Remove AsString and disallow callables in interpolated strings (#301)

bamarsha · web-flow · commit d069216bcbaf · 2023-05-12T11:44:53.000-07:00
Follow up to #291: * Remove the `AsString` library function, which was only added because we didn't have string interpolation. Update the samples to use string interpolation instead. * Add a type class for types that can be converted to a string. This excludes callables, because there is no clear non-arbitrary string form to convert them to.
diff --git a/compiler/qsc_eval/src/intrinsic.rs b/compiler/qsc_eval/src/intrinsic.rs
@@ -56,8 +56,6 @@ pub(crate) fn invoke_intrinsic(
                 Err(_) => Break(Reason::Error(Error::Output(name_span))),
             },
 
-            "AsString" => Continue(Value::String(args.to_string().into())),
-
             "CheckZero" => Continue(Value::Bool(qubit_is_zero(
                 args.try_into().with_span(args_span)?,
             ))),
diff --git a/compiler/qsc_eval/src/intrinsic/tests.rs b/compiler/qsc_eval/src/intrinsic/tests.rs
@@ -147,22 +147,6 @@ fn message() {
     );
 }
 
-#[test]
-fn to_string() {
-    check_intrinsic_result("", "AsString(One)", &expect![["One"]]);
-}
-
-#[test]
-fn to_string_message() {
-    check_intrinsic_output(
-        "",
-        r#"Message(AsString(PauliX))"#,
-        &expect![[r#"
-            PauliX
-        "#]],
-    );
-}
-
 #[test]
 fn check_zero() {
     check_intrinsic_result(
diff --git a/compiler/qsc_frontend/src/typeck/infer.rs b/compiler/qsc_frontend/src/typeck/infer.rs
@@ -24,13 +24,19 @@ pub(super) enum Class {
     Integral(Ty),
     Iterable { container: Ty, item: Ty },
     Num(Ty),
+    Show(Ty),
     Unwrap { wrapper: Ty, base: Ty },
 }
 
 impl Class {
     fn dependencies(&self) -> Vec<&Ty> {
         match self {
-            Self::Add(ty) | Self::Adj(ty) | Self::Eq(ty) | Self::Integral(ty) | Self::Num(ty) => {
+            Self::Add(ty)
+            | Self::Adj(ty)
+            | Self::Eq(ty)
+            | Self::Integral(ty)
+            | Self::Num(ty)
+            | Self::Show(ty) => {
                 vec![ty]
             }
             Self::Call { callee, .. } => vec![callee],
@@ -87,6 +93,7 @@ impl Class {
                 item: f(item),
             },
             Self::Num(ty) => Self::Num(f(ty)),
+            Self::Show(ty) => Self::Show(f(ty)),
             Self::Unwrap { wrapper, base } => Self::Unwrap {
                 wrapper: f(wrapper),
                 base: f(base),
@@ -127,6 +134,7 @@ impl Class {
             Class::Num(ty) => check_num(&ty)
                 .then_some(Vec::new())
                 .ok_or(ClassError(Class::Num(ty), span)),
+            Class::Show(ty) => check_show(ty, span),
             Class::Unwrap { wrapper, base } => {
                 // TODO: If the wrapper type is a user-defined type, look up its underlying type.
                 // https://github.com/microsoft/qsharp/issues/148
@@ -152,6 +160,7 @@ impl Display for Class {
             Class::Integral(ty) => write!(f, "Integral<{ty}>"),
             Class::Iterable { container, .. } => write!(f, "Iterable<{container}>"),
             Class::Num(ty) => write!(f, "Num<{ty}>"),
+            Class::Show(ty) => write!(f, "Show<{ty}>"),
             Class::Unwrap { wrapper, .. } => write!(f, "Unwrap<{wrapper}>"),
         }
     }
@@ -556,6 +565,18 @@ fn check_num(ty: &Ty) -> bool {
     matches!(ty, Ty::Prim(PrimTy::BigInt | PrimTy::Double | PrimTy::Int))
 }
 
+fn check_show(ty: Ty, span: Span) -> Result<Vec<Constraint>, ClassError> {
+    match ty {
+        Ty::Array(item) => Ok(vec![Constraint::Class(Class::Show(*item), span)]),
+        Ty::Prim(_) => Ok(Vec::new()),
+        Ty::Tuple(items) => Ok(items
+            .into_iter()
+            .map(|item| Constraint::Class(Class::Show(item), span))
+            .collect()),
+        _ => Err(ClassError(Class::Show(ty), span)),
+    }
+}
+
 fn check_has_field(
     record: Ty,
     name: String,
diff --git a/compiler/qsc_frontend/src/typeck/rules.rs b/compiler/qsc_frontend/src/typeck/rules.rs
@@ -280,7 +280,9 @@ impl<'a> Context<'a> {
                 for component in components {
                     match component {
                         StringComponent::Expr(expr) => {
+                            let span = expr.span;
                             let expr = self.infer_expr(expr);
+                            self.inferrer.class(span, Class::Show(expr.ty));
                             diverges = diverges || expr.diverges;
                         }
                         StringComponent::Lit(_) => {}
diff --git a/compiler/qsc_frontend/src/typeck/tests.rs b/compiler/qsc_frontend/src/typeck/tests.rs
@@ -1458,6 +1458,158 @@ fn range_full_field_end() {
     );
 }
 
+#[test]
+fn interpolate_int() {
+    check(
+        "",
+        r#"$"{4}""#,
+        &expect![[r##"
+            #0 0-6 "$\"{4}\"" : String
+            #1 3-4 "4" : Int
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_string() {
+    check(
+        "",
+        r#"$"{"foo"}""#,
+        &expect![[r##"
+            #0 0-10 "$\"{\"foo\"}\"" : String
+            #1 3-8 "\"foo\"" : String
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_qubit() {
+    check(
+        "",
+        r#"{ use q = Qubit(); $"{q}" }"#,
+        &expect![[r##"
+            #0 0-27 "{ use q = Qubit(); $\"{q}\" }" : String
+            #1 0-27 "{ use q = Qubit(); $\"{q}\" }" : String
+            #3 6-7 "q" : Qubit
+            #5 10-17 "Qubit()" : Qubit
+            #7 19-25 "$\"{q}\"" : String
+            #8 22-23 "q" : Qubit
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_function() {
+    check(
+        indoc! {"
+            namespace A {
+                function Foo() : () {}
+            }
+        "},
+        r#"$"{A.Foo}""#,
+        &expect![[r##"
+            #2 30-32 "()" : ()
+            #3 38-40 "{}" : ()
+            #5 43-53 "$\"{A.Foo}\"" : String
+            #6 46-51 "A.Foo" : (() -> ())
+            Error(Type(Error(MissingClass(Show(Arrow(Function, Tuple([]), Tuple([]), {})), Span { lo: 46, hi: 51 }))))
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_operation() {
+    check(
+        indoc! {"
+            namespace A {
+                operation Foo() : () {}
+            }
+        "},
+        r#"$"{A.Foo}""#,
+        &expect![[r##"
+            #2 31-33 "()" : ()
+            #3 39-41 "{}" : ()
+            #5 44-54 "$\"{A.Foo}\"" : String
+            #6 47-52 "A.Foo" : (() => ())
+            Error(Type(Error(MissingClass(Show(Arrow(Operation, Tuple([]), Tuple([]), {})), Span { lo: 47, hi: 52 }))))
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_int_array() {
+    check(
+        "",
+        r#"$"{[1, 2, 3]}""#,
+        &expect![[r##"
+            #0 0-14 "$\"{[1, 2, 3]}\"" : String
+            #1 3-12 "[1, 2, 3]" : (Int)[]
+            #2 4-5 "1" : Int
+            #3 7-8 "2" : Int
+            #4 10-11 "3" : Int
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_function_array() {
+    check(
+        indoc! {"
+            namespace A {
+                function Foo() : () {}
+                function Bar() : () {}
+            }
+        "},
+        r#"$"{[A.Foo, A.Bar]}""#,
+        &expect![[r##"
+            #2 30-32 "()" : ()
+            #3 38-40 "{}" : ()
+            #6 57-59 "()" : ()
+            #7 65-67 "{}" : ()
+            #9 70-89 "$\"{[A.Foo, A.Bar]}\"" : String
+            #10 73-87 "[A.Foo, A.Bar]" : ((() -> ()))[]
+            #11 74-79 "A.Foo" : (() -> ())
+            #12 81-86 "A.Bar" : (() -> ())
+            Error(Type(Error(MissingClass(Show(Arrow(Function, Tuple([]), Tuple([]), {})), Span { lo: 73, hi: 87 }))))
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_int_string_tuple() {
+    check(
+        "",
+        r#"$"{(1, "foo")}""#,
+        &expect![[r##"
+            #0 0-15 "$\"{(1, \"foo\")}\"" : String
+            #1 3-13 "(1, \"foo\")" : (Int, String)
+            #2 4-5 "1" : Int
+            #3 7-12 "\"foo\"" : String
+        "##]],
+    );
+}
+
+#[test]
+fn interpolate_int_function_tuple() {
+    check(
+        indoc! {"
+            namespace A {
+                function Foo() : () {}
+            }
+        "},
+        r#"$"{(1, A.Foo)}""#,
+        &expect![[r##"
+            #2 30-32 "()" : ()
+            #3 38-40 "{}" : ()
+            #5 43-58 "$\"{(1, A.Foo)}\"" : String
+            #6 46-56 "(1, A.Foo)" : (Int, (() -> ()))
+            #7 47-48 "1" : Int
+            #8 50-55 "A.Foo" : (() -> ())
+            Error(Type(Error(MissingClass(Show(Arrow(Function, Tuple([]), Tuple([]), {})), Span { lo: 46, hi: 56 }))))
+        "##]],
+    );
+}
+
 #[test]
 fn newtype_cons() {
     check(
diff --git a/library/std/core.qs b/library/std/core.qs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Core {
-
     /// # Summary
     /// Returns the number of elements in an array.
     ///
@@ -97,9 +96,4 @@ namespace Microsoft.Quantum.Core {
         let start = r::Start + ((r::End - r::Start) / r::Step) * r::Step;
         start..-r::Step..r::Start
     }
-
-    function AsString<'T>(v : 'T) : String {
-        body intrinsic;
-    }
-
 }
diff --git a/pip/samples/sample.ipynb b/pip/samples/sample.ipynb
@@ -205,7 +205,7 @@
     "    X(q);\n",
     "    Microsoft.Quantum.Diagnostics.DumpMachine();\n",
     "    let r = M(q);\n",
-    "    Message(\"The result of the measurement is \" + AsString(r));\n",
+    "    Message($\"The result of the measurement is {r}\");\n",
     "    Reset(q);\n",
     "    r\n",
     "}\n",
@@ -750,7 +750,7 @@
     "        let r = M(q);\n",
     "        if (i % 100000) == 0 {\n",
     "            DumpMachine();\n",
-    "            Message(\"Result: \" + AsString(r));\n",
+    "            Message($\"Result: {r}\");\n",
     "        }\n",
     "        Reset(q);\n",
     "    }\n",
diff --git a/samples/Grover.qs b/samples/Grover.qs
@@ -119,7 +119,7 @@ namespace Microsoft.Quantum.Samples.SimpleGrover {
         // the result is still detected with the sufficient
         // probability.
         let nIterations = NIterations(nQubits); // Try setting to 1.
-        Message("Number of iterations: " + AsString(nIterations));
+        Message($"Number of iterations: {nIterations}");
 
         let results =  GroverSearch(
             nQubits,
diff --git a/samples/Teleportation.qs b/samples/Teleportation.qs
@@ -163,10 +163,7 @@ namespace Microsoft.Quantum.Samples.Teleportation {
         for idxRun in 1 .. 10 {
             let sent = DrawRandomInt(0, 1) == 1;
             let received = TeleportClassicalMessage(sent);
-            Message(
-                "Round " + AsString(idxRun) +
-                ": Sent " + AsString(sent) +
-                ", got " + AsString(received) + ".");
+            Message($"Round {idxRun}: Sent {sent}, got {received}.");
             Message(sent==received ? "Teleportation successful!" | "");
         }
         for idxRun in 1 .. 10 {
diff --git a/samples/qrng.qs b/samples/qrng.qs
@@ -44,8 +44,7 @@ namespace Microsoft.Quantum.Samples.Qrng {
     @EntryPoint()
     operation Main() : Int {
         let max = 50;
-        Message("Sampling a random number between 0 and " +
-            AsString(max) + ": ");
+        Message($"Sampling a random number between 0 and {max}: ");
         return SampleRandomNumberInRange(max);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -44,8 +44,7 @@ namespace Microsoft.Quantum.Samples.Qrng {`
`44`	`44`	`@EntryPoint()`
`45`	`45`	`operation Main() : Int {`
`46`	`46`	`let max = 50;`
`47`		`- Message("Sampling a random number between 0 and " +`
`48`		`- AsString(max) + ": ");`
	`47`	`+ Message($"Sampling a random number between 0 and {max}: ");`
`49`	`48`	`return SampleRandomNumberInRange(max);`
`50`	`49`	`}`
`51`	`50`	`}`