Rework the driver docs (#2162)

examples/rustc-driver-example.rs

@@ -1,92 +1,92 @@
 #![feature(rustc_private)]
 
+extern crate rustc_ast;
+extern crate rustc_ast_pretty;
+extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_error_codes;
 extern crate rustc_errors;
 extern crate rustc_hash;
 extern crate rustc_hir;
 extern crate rustc_interface;
+extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
 
-use std::{path, process, str, sync::Arc};
+use std::io;
+use std::path::Path;
 
-use rustc_errors::registry;
-use rustc_hash::FxHashMap;
-use rustc_session::config;
+use rustc_ast_pretty::pprust::item_to_string;
+use rustc_data_structures::sync::Lrc;
+use rustc_driver::{Compilation, RunCompiler};
+use rustc_interface::interface::Compiler;
+use rustc_middle::ty::TyCtxt;
 
+struct MyFileLoader;
+
+impl rustc_span::source_map::FileLoader for MyFileLoader {
+    fn file_exists(&self, path: &Path) -> bool {
+        path == Path::new("main.rs")
+    }
+
+    fn read_file(&self, path: &Path) -> io::Result<String> {
+        if path == Path::new("main.rs") {
+            Ok(r#"
 fn main() {
-    let out = process::Command::new("rustc")
-        .arg("--print=sysroot")
-        .current_dir(".")
-        .output()
-        .unwrap();
-    let sysroot = str::from_utf8(&out.stdout).unwrap().trim();
-    let config = rustc_interface::Config {
-        // Command line options
-        opts: config::Options {
-            maybe_sysroot: Some(path::PathBuf::from(sysroot)),
-            ..config::Options::default()
-        },
-        // cfg! configuration in addition to the default ones
-        crate_cfg: Vec::new(),       // FxHashSet<(String, Option<String>)>
-        crate_check_cfg: Vec::new(), // CheckCfg
-        input: config::Input::Str {
-            name: rustc_span::FileName::Custom("main.rs".into()),
-            input: r#"
-static HELLO: &str = "Hello, world!";
-fn main() {
-    println!("{HELLO}");
+    let message = "Hello, World!";
+    println!("{message}");
 }
 "#
-            .into(),
-        },
-        output_dir: None,  // Option<PathBuf>
-        output_file: None, // Option<PathBuf>
-        file_loader: None, // Option<Box<dyn FileLoader + Send + Sync>>
-        locale_resources: rustc_driver::DEFAULT_LOCALE_RESOURCES,
-        lint_caps: FxHashMap::default(), // FxHashMap<lint::LintId, lint::Level>
-        // This is a callback from the driver that is called when [`ParseSess`] is created.
-        psess_created: None, //Option<Box<dyn FnOnce(&mut ParseSess) + Send>>
-        // This is a callback from the driver that is called when we're registering lints;
-        // it is called during plugin registration when we have the LintStore in a non-shared state.
-        //
-        // Note that if you find a Some here you probably want to call that function in the new
-        // function being registered.
-        register_lints: None, // Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>
-        // This is a callback from the driver that is called just after we have populated
-        // the list of queries.
-        //
-        // The second parameter is local providers and the third parameter is external providers.
-        override_queries: None, // Option<fn(&Session, &mut ty::query::Providers<'_>, &mut ty::query::Providers<'_>)>
-        // Registry of diagnostics codes.
-        registry: registry::Registry::new(rustc_errors::codes::DIAGNOSTICS),
-        make_codegen_backend: None,
-        expanded_args: Vec::new(),
-        ice_file: None,
-        hash_untracked_state: None,
-        using_internal_features: Arc::default(),
-    };
-    rustc_interface::run_compiler(config, |compiler| {
-        compiler.enter(|queries| {
-            // Parse the program and print the syntax tree.
-            let parse = queries.parse().unwrap().get_mut().clone();
-            println!("{parse:?}");
-            // Analyze the program and inspect the types of definitions.
-            queries.global_ctxt().unwrap().enter(|tcx| {
-                for id in tcx.hir().items() {
-                    let hir = tcx.hir();
-                    let item = hir.item(id);
-                    match item.kind {
-                        rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn(_, _, _) => {
-                            let name = item.ident;
-                            let ty = tcx.type_of(item.hir_id().owner.def_id);
-                            println!("{name:?}:\t{ty:?}")
-                        }
-                        _ => (),
-                    }
+            .to_string())
+        } else {
+            Err(io::Error::other("oops"))
+        }
+    }
+
+    fn read_binary_file(&self, _path: &Path) -> io::Result<Lrc<[u8]>> {
+        Err(io::Error::other("oops"))
+    }
+}
+
+struct MyCallbacks;
+
+impl rustc_driver::Callbacks for MyCallbacks {
+    fn after_crate_root_parsing(
+        &mut self,
+        _compiler: &Compiler,
+        krate: &rustc_ast::Crate,
+    ) -> Compilation {
+        for item in &krate.items {
+            println!("{}", item_to_string(&item));
+        }
+
+        Compilation::Continue
+    }
+
+    fn after_analysis(&mut self, _compiler: &Compiler, tcx: TyCtxt<'_>) -> Compilation {
+        // Analyze the program and inspect the types of definitions.
+        for id in tcx.hir().items() {
+            let hir = tcx.hir();
+            let item = hir.item(id);
+            match item.kind {
+                rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn(_, _, _) => {
+                    let name = item.ident;
+                    let ty = tcx.type_of(item.hir_id().owner.def_id);
+                    println!("{name:?}:\t{ty:?}")
                 }
-            })
-        });
-    });
+                _ => (),
+            }
+        }
+
+        Compilation::Stop
+    }
+}
+
+fn main() {
+    match RunCompiler::new(&["main.rs".to_string()], &mut MyCallbacks) {
+        mut compiler => {
+            compiler.set_file_loader(Some(Box::new(MyFileLoader)));
+            compiler.run();
+        }
+    }
 }

examples/rustc-driver-interacting-with-the-ast.rs

@@ -1,90 +1,99 @@
 #![feature(rustc_private)]
 
+extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_error_codes;
 extern crate rustc_errors;
 extern crate rustc_hash;
 extern crate rustc_hir;
 extern crate rustc_interface;
+extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
 
-use std::{path, process, str, sync::Arc};
+use std::io;
+use std::path::Path;
 
 use rustc_ast_pretty::pprust::item_to_string;
-use rustc_errors::registry;
-use rustc_session::config;
+use rustc_data_structures::sync::Lrc;
+use rustc_driver::{Compilation, RunCompiler};
+use rustc_interface::interface::Compiler;
+use rustc_middle::ty::TyCtxt;
 
-fn main() {
-    let out = process::Command::new("rustc")
-        .arg("--print=sysroot")
-        .current_dir(".")
-        .output()
-        .unwrap();
-    let sysroot = str::from_utf8(&out.stdout).unwrap().trim();
-    let config = rustc_interface::Config {
-        opts: config::Options {
-            maybe_sysroot: Some(path::PathBuf::from(sysroot)),
-            ..config::Options::default()
-        },
-        input: config::Input::Str {
-            name: rustc_span::FileName::Custom("main.rs".to_string()),
-            input: r#"
+struct MyFileLoader;
+
+impl rustc_span::source_map::FileLoader for MyFileLoader {
+    fn file_exists(&self, path: &Path) -> bool {
+        path == Path::new("main.rs")
+    }
+
+    fn read_file(&self, path: &Path) -> io::Result<String> {
+        if path == Path::new("main.rs") {
+            Ok(r#"
 fn main() {
     let message = "Hello, World!";
     println!("{message}");
 }
 "#
-            .to_string(),
-        },
-        crate_cfg: Vec::new(),
-        crate_check_cfg: Vec::new(),
-        output_dir: None,
-        output_file: None,
-        file_loader: None,
-        locale_resources: rustc_driver::DEFAULT_LOCALE_RESOURCES,
-        lint_caps: rustc_hash::FxHashMap::default(),
-        psess_created: None,
-        register_lints: None,
-        override_queries: None,
-        make_codegen_backend: None,
-        registry: registry::Registry::new(rustc_errors::codes::DIAGNOSTICS),
-        expanded_args: Vec::new(),
-        ice_file: None,
-        hash_untracked_state: None,
-        using_internal_features: Arc::default(),
-    };
-    rustc_interface::run_compiler(config, |compiler| {
-        compiler.enter(|queries| {
-            // TODO: add this to -Z unpretty
-            let ast_krate = queries.parse().unwrap().get_mut().clone();
-            for item in ast_krate.items {
-                println!("{}", item_to_string(&item));
-            }
-            // Analyze the crate and inspect the types under the cursor.
-            queries.global_ctxt().unwrap().enter(|tcx| {
-                // Every compilation contains a single crate.
-                let hir_krate = tcx.hir();
-                // Iterate over the top-level items in the crate, looking for the main function.
-                for id in hir_krate.items() {
-                    let item = hir_krate.item(id);
-                    // Use pattern-matching to find a specific node inside the main function.
-                    if let rustc_hir::ItemKind::Fn(_, _, body_id) = item.kind {
-                        let expr = &tcx.hir().body(body_id).value;
-                        if let rustc_hir::ExprKind::Block(block, _) = expr.kind {
-                            if let rustc_hir::StmtKind::Let(let_stmt) = block.stmts[0].kind {
-                                if let Some(expr) = let_stmt.init {
-                                    let hir_id = expr.hir_id; // hir_id identifies the string "Hello, world!"
-                                    let def_id = item.hir_id().owner.def_id; // def_id identifies the main function
-                                    let ty = tcx.typeck(def_id).node_type(hir_id);
-                                    println!("{expr:#?}: {ty:?}");
-                                }
-                            }
+            .to_string())
+        } else {
+            Err(io::Error::other("oops"))
+        }
+    }
+
+    fn read_binary_file(&self, _path: &Path) -> io::Result<Lrc<[u8]>> {
+        Err(io::Error::other("oops"))
+    }
+}
+
+struct MyCallbacks;
+
+impl rustc_driver::Callbacks for MyCallbacks {
+    fn after_crate_root_parsing(
+        &mut self,
+        _compiler: &Compiler,
+        krate: &rustc_ast::Crate,
+    ) -> Compilation {
+        for item in &krate.items {
+            println!("{}", item_to_string(&item));
+        }
+
+        Compilation::Continue
+    }
+
+    fn after_analysis(&mut self, _compiler: &Compiler, tcx: TyCtxt<'_>) -> Compilation {
+        // Every compilation contains a single crate.
+        let hir_krate = tcx.hir();
+        // Iterate over the top-level items in the crate, looking for the main function.
+        for id in hir_krate.items() {
+            let item = hir_krate.item(id);
+            // Use pattern-matching to find a specific node inside the main function.
+            if let rustc_hir::ItemKind::Fn(_, _, body_id) = item.kind {
+                let expr = &tcx.hir().body(body_id).value;
+                if let rustc_hir::ExprKind::Block(block, _) = expr.kind {
+                    if let rustc_hir::StmtKind::Let(let_stmt) = block.stmts[0].kind {
+                        if let Some(expr) = let_stmt.init {
+                            let hir_id = expr.hir_id; // hir_id identifies the string "Hello, world!"
+                            let def_id = item.hir_id().owner.def_id; // def_id identifies the main function
+                            let ty = tcx.typeck(def_id).node_type(hir_id);
+                            println!("{expr:#?}: {ty:?}");
                         }
                     }
                 }
-            })
-        });
-    });
+            }
+        }
+
+        Compilation::Stop
+    }
+}
+
+fn main() {
+    match RunCompiler::new(&["main.rs".to_string()], &mut MyCallbacks) {
+        mut compiler => {
+            compiler.set_file_loader(Some(Box::new(MyFileLoader)));
+            compiler.run();
+        }
+    }
 }