fixed tests.

csharp_mod/FfiGlue.cs

@@ -15,11 +15,13 @@
 #pragma warning disable SA1500, SA1505, SA1507,
 #pragma warning disable SA1600, SA1601, SA1604, SA1605, SA1611, SA1615, SA1649,
 
-namespace Slang {
+namespace Slang
+{
     using System;
     using System.Runtime.InteropServices;
 
-public unsafe partial class Ffi {
+    public unsafe partial class Ffi
+    {
 #if IOS
         private const string RustLib = "slang.framework/slang";
 #else
@@ -47,11 +49,13 @@ public unsafe partial class Ffi {
     /// use the <c>Option< slice_ptr<_> ></c> type.
     /// </summary>
     [StructLayout(LayoutKind.Sequential, Size = 16)]
-public unsafe struct slice_ref_uint16_t {
+    public unsafe struct slice_ref_uint16_t
+    {
         /// <summary>
         /// Pointer to the first element (if any).
         /// </summary>
-    public UInt16 /*const*/ * ptr;
+        public UInt16 /*const*/
+        * ptr;
 
         /// <summary>
         /// Element count
@@ -63,7 +67,8 @@ public unsafe struct slice_ref_uint16_t {
     /// Same as [<c>Vec<T></c>][<c>rust::Vec</c>], but with guaranteed <c>#[repr(C)]</c> layout
     /// </summary>
     [StructLayout(LayoutKind.Sequential, Size = 24)]
-public unsafe struct Vec_uint8_t {
+    public unsafe struct Vec_uint8_t
+    {
         public byte* ptr;
 
         public UIntPtr len;
@@ -71,20 +76,21 @@ public unsafe struct Vec_uint8_t {
         public UIntPtr cap;
     }
 
-public unsafe partial class Ffi {
+    public unsafe partial class Ffi
+    {
         /// <summary>
         /// C# handles strings as UTF16. We do NOT want to allocate that memory in C# because
         /// we want to avoid GC. So we pass it to Rust to handle all the memory allocations.
         /// This should result in the ability to compile many times without triggering frame drops
         /// from the GC from a <c>GetBytes()</c> call on a string in C#.
         /// </summary>
-    [DllImport(RustLib, ExactSpelling = true)] public static unsafe extern
+        [DllImport(RustLib, ExactSpelling = true)]
-    Vec_uint8_t compile_from_string (
+        public static extern unsafe Vec_uint8_t compile_from_string(slice_ref_uint16_t input);
-        slice_ref_uint16_t input);
     }
 
     [StructLayout(LayoutKind.Sequential, Size = 64)]
-public unsafe struct FfiToken_t {
+    public unsafe struct FfiToken_t
+    {
         public Vec_uint8_t tooltip;
 
         public Vec_uint8_t error;
@@ -100,7 +106,8 @@ public unsafe struct FfiToken_t {
     /// Same as [<c>Vec<T></c>][<c>rust::Vec</c>], but with guaranteed <c>#[repr(C)]</c> layout
     /// </summary>
     [StructLayout(LayoutKind.Sequential, Size = 24)]
-public unsafe struct Vec_FfiToken_t {
+    public unsafe struct Vec_FfiToken_t
+    {
         public FfiToken_t* ptr;
 
         public UIntPtr len;
@@ -108,29 +115,27 @@ public unsafe struct Vec_FfiToken_t {
         public UIntPtr cap;
     }
 
-public unsafe partial class Ffi {
+    public unsafe partial class Ffi
-    [DllImport(RustLib, ExactSpelling = true)] public static unsafe extern
+    {
-    void free_ffi_token_vec (
+        [DllImport(RustLib, ExactSpelling = true)]
-        Vec_FfiToken_t v);
+        public static extern unsafe void free_ffi_token_vec(Vec_FfiToken_t v);
     }
 
-public unsafe partial class Ffi {
+    public unsafe partial class Ffi
-    [DllImport(RustLib, ExactSpelling = true)] public static unsafe extern
+    {
-    void free_string (
+        [DllImport(RustLib, ExactSpelling = true)]
-        Vec_uint8_t s);
+        public static extern unsafe void free_string(Vec_uint8_t s);
     }
 
-public unsafe partial class Ffi {
+    public unsafe partial class Ffi
+    {
         /// <summary>
         /// C# handles strings as UTF16. We do NOT want to allocate that memory in C# because
         /// we want to avoid GC. So we pass it to Rust to handle all the memory allocations.
         /// This should result in the ability to tokenize many times without triggering frame drops
         /// from the GC from a <c>GetBytes()</c> call on a string in C#.
         /// </summary>
-    [DllImport(RustLib, ExactSpelling = true)] public static unsafe extern
+        [DllImport(RustLib, ExactSpelling = true)]
-    Vec_FfiToken_t tokenize_line (
+        public static extern unsafe Vec_FfiToken_t tokenize_line(slice_ref_uint16_t input);
-        slice_ref_uint16_t input);
     }
-
-
 } /* Slang */

rust_compiler/libs/parser/src/test/mod.rs

@@ -92,7 +92,7 @@ fn test_priority_expression() -> Result<()> {
 
     let expression = parser.parse()?.unwrap();
 
-    assert_eq!("(let x = (4))", expression.to_string());
+    assert_eq!("(let x = 4)", expression.to_string());
 
     Ok(())
 }
@@ -109,7 +109,7 @@ fn test_binary_expression() -> Result<()> {
     assert_eq!("(((45 * 2) - (15 / 5)) + (5 ** 2))", expr.to_string());
 
     let expr = parser!("(5 - 2) * 10").parse()?.unwrap();
-    assert_eq!("(((5 - 2)) * 10)", expr.to_string());
+    assert_eq!("((5 - 2) * 10)", expr.to_string());
 
     Ok(())
 }