add stable_mir output test

Author: ouz-a

compiler/rustc_smir/src/rustc_smir/context.rs

@@ -3,6 +3,7 @@
 //! This trait is currently the main interface between the Rust compiler,
 //! and the `stable_mir` crate.
 
+use crate::rustc_smir::stable_mir::opaque;
 use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
 use rustc_middle::ty::{GenericPredicates, Instance, ParamEnv, ScalarInt, ValTree};
 use rustc_span::def_id::LOCAL_CRATE;
@@ -14,6 +15,7 @@ use stable_mir::ty::{
     AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, Const, FnDef, GenericArgs, LineInfo,
     RigidTy, Span, TyKind,
 };
+use stable_mir::Opaque;
 use stable_mir::{self, Crate, CrateItem, Error, Filename, ItemKind, Symbol};
 use std::cell::RefCell;
 
@@ -230,6 +232,12 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         internal(cnst).to_string()
     }
 
+    fn adt_literal(&self, adt: &AdtDef) -> Opaque {
+        let mut tables = self.0.borrow_mut();
+        let internal = adt.internal(&mut *tables);
+        opaque(&internal)
+    }
+
     fn span_of_an_item(&self, def_id: stable_mir::DefId) -> Span {
         let mut tables = self.0.borrow_mut();
         tables.tcx.def_span(tables[def_id]).stable(&mut *tables)

compiler/stable_mir/src/compiler_interface.rs

@@ -14,8 +14,8 @@ use crate::ty::{
     Ty, TyKind,
 };
 use crate::{
-    mir, Crate, CrateItem, CrateItems, DefId, Error, Filename, ImplTraitDecls, ItemKind, Symbol,
-    TraitDecls,
+    mir, Crate, CrateItem, CrateItems, DefId, Error, Filename, ImplTraitDecls, ItemKind, Opaque,
+    Symbol, TraitDecls,
 };
 
 /// This trait defines the interface between stable_mir and the Rust compiler.
@@ -79,6 +79,9 @@ pub trait Context {
     /// Returns literal value of a const as a string.
     fn const_literal(&self, cnst: &Const) -> String;
 
+    /// Returns literal version of a Adt as a Opaque
+    fn adt_literal(&self, adt: &AdtDef) -> Opaque;
+
     /// `Span` of an item
     fn span_of_an_item(&self, def_id: DefId) -> Span;
 

compiler/stable_mir/src/mir/body.rs

@@ -88,6 +88,7 @@ impl Body {
                 Ok(())
             })
             .collect::<Result<Vec<_>, _>>()?;
+        writeln!(w, "}}")?;
         Ok(())
     }
 }

compiler/stable_mir/src/mir/pretty.rs

@@ -7,6 +7,8 @@ use std::{io, iter};
 
 use super::{AssertMessage, BinOp, TerminatorKind};
 
+use super::BorrowKind;
+
 pub fn function_name(item: CrateItem) -> String {
     let mut pretty_name = String::new();
     let body = item.body();
@@ -40,7 +42,6 @@ pub fn function_body(body: &Body) -> String {
         pretty_body.push_str(format!("{}", pretty_ty(local.ty.kind())).as_str());
         pretty_body.push_str(";\n");
     });
-    pretty_body.push_str("}");
     pretty_body
 }
 
@@ -305,6 +306,7 @@ pub fn pretty_rvalue(rval: &Rvalue) -> String {
             pretty.push_str(format!("(*_{})", addr.local).as_str());
         }
         Rvalue::Aggregate(aggregatekind, operands) => {
+            // FIXME: Add pretty_aggregate function that returns a pretty string
             pretty.push_str(format!("{:#?}", aggregatekind).as_str());
             pretty.push_str("(");
             operands.iter().enumerate().for_each(|(i, op)| {
@@ -315,24 +317,26 @@ pub fn pretty_rvalue(rval: &Rvalue) -> String {
             });
             pretty.push_str(")");
         }
-        Rvalue::BinaryOp(bin, op, op2) => {
-            pretty.push_str(&pretty_operand(op));
-            pretty.push_str(" ");
+        Rvalue::BinaryOp(bin, op1, op2) => {
             pretty.push_str(format!("{:#?}", bin).as_str());
-            pretty.push_str(" ");
-            pretty.push_str(&pretty_operand(op2));
+            pretty.push_str("(");
+            pretty.push_str(format!("_{}", &pretty_operand(op1)).as_str());
+            pretty.push_str(", ");
+            pretty.push_str(format!("{}", &pretty_operand(op2)).as_str());
+            pretty.push_str(")");
         }
         Rvalue::Cast(_, op, ty) => {
             pretty.push_str(&pretty_operand(op));
             pretty.push_str(" as ");
             pretty.push_str(&pretty_ty(ty.kind()));
         }
         Rvalue::CheckedBinaryOp(bin, op1, op2) => {
-            pretty.push_str(&pretty_operand(op1));
-            pretty.push_str(" ");
-            pretty.push_str(format!("{:#?}", bin).as_str());
-            pretty.push_str(" ");
-            pretty.push_str(&pretty_operand(op2));
+            pretty.push_str(format!("Checked{:#?}", bin).as_str());
+            pretty.push_str("(");
+            pretty.push_str(format!("_{}", &pretty_operand(op1)).as_str());
+            pretty.push_str(", ");
+            pretty.push_str(format!("{}", &pretty_operand(op2)).as_str());
+            pretty.push_str(")");
         }
         Rvalue::CopyForDeref(deref) => {
             pretty.push_str("CopyForDeref");
@@ -347,8 +351,11 @@ pub fn pretty_rvalue(rval: &Rvalue) -> String {
             pretty.push_str(format!("{}", len.local).as_str());
         }
         Rvalue::Ref(_, borrowkind, place) => {
-            pretty.push_str("ref");
-            pretty.push_str(format!("{:#?}", borrowkind).as_str());
+            match borrowkind {
+                BorrowKind::Shared => pretty.push_str("&"),
+                BorrowKind::Fake => pretty.push_str("&fake "),
+                BorrowKind::Mut { .. } => pretty.push_str("&mut "),
+            }
             pretty.push_str(format!("{}", place.local).as_str());
         }
         Rvalue::Repeat(op, cnst) => {
@@ -403,7 +410,7 @@ pub fn pretty_ty(ty: TyKind) -> String {
                 FloatTy::F64 => "f64".to_string(),
             },
             RigidTy::Adt(def, _) => {
-                format!("{:#?}", with(|cx| cx.def_ty(def.0)))
+                format!("{}", with(|cx| cx.adt_literal(&def)))
             }
             RigidTy::Str => "str".to_string(),
             RigidTy::Array(ty, len) => {

src/tools/tidy/src/ui_tests.rs

@@ -11,7 +11,7 @@ use std::path::{Path, PathBuf};
 const ENTRY_LIMIT: usize = 900;
 // FIXME: The following limits should be reduced eventually.
 const ISSUES_ENTRY_LIMIT: usize = 1852;
-const ROOT_ENTRY_LIMIT: usize = 867;
+const ROOT_ENTRY_LIMIT: usize = 868;
 
 const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
     "rs",     // test source files

tests/ui/stable-mir-print/basic_function.rs

@@ -0,0 +1,14 @@
+// compile-flags: -Z unpretty=stable-mir -Z mir-opt-level=3
+// check-pass
+
+fn foo(i:i32) -> i32 {
+    i + 1
+}
+
+fn bar(vec: &mut Vec<i32>) -> Vec<i32> {
+    let mut new_vec = vec.clone();
+    new_vec.push(1);
+    new_vec
+}
+
+fn main(){}

tests/ui/stable-mir-print/basic_function.stdout

@@ -0,0 +1,45 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn foo(_0: i32) -> i32 {
+    let mut _0: (i32, bool);
+
+    bb0: {
+        _2 = CheckedAdd(_1, const 1_i32)
+        assert(!move _2 bool),"attempt to compute `{} + {}`, which would overflow", 1, const 1_i32) -> [success: bb1, unwind continue]
+    }
+    bb1: {
+        _0 = move _2
+        return
+    }
+}
+fn bar(_0: &mut std::vec::Vec) -> std::vec::Vec {
+    let mut _0: std::vec::Vec;
+    let mut _1: &std::vec::Vec;
+    let _2: ();
+    let mut _3: &mut std::vec::Vec;
+
+    bb0: {
+        _3 = &1
+        _2 = const <Vec<i32> as Clone>::clone(move _3) -> [return: bb1, unwind continue]
+    }
+    bb1: {
+        _5 = &mut 2
+        _4 = const Vec::<i32>::push(move _5, const 1_i32) -> [return: bb2, unwind: bb3]
+    }
+    bb2: {
+        _0 = move _2
+        return
+    }
+    bb3: {
+        drop(_2) -> [return: bb4, unwind terminate]
+    }
+    bb4: {
+        resume
+    }
+}
+fn main() -> () {
+
+    bb0: {
+        return
+    }
+}