Extend compiler diagnostics with info-based diagnostics.

Author: tritao

forc-pkg/src/manifest/mod.rs

@@ -478,7 +478,7 @@ impl PackageManifestFile {
         let parse_res = parse_tree_type(&handler, entry_string);
 
         parse_res.map_err(|_| {
-            let (errors, _warnings) = handler.consume();
+            let (errors, _warnings, _infos) = handler.consume();
             parsing_failed(&self.project.name, &errors)
         })
     }

forc-pkg/src/pkg.rs

@@ -9,7 +9,7 @@ use anyhow::{anyhow, bail, Context, Error, Result};
 use byte_unit::{Byte, UnitType};
 use forc_tracing::{println_action_green, println_warning};
 use forc_util::{
-    default_output_directory, find_file_name, kebab_to_snake_case, print_compiling,
+    default_output_directory, find_file_name, kebab_to_snake_case, print_compiling, print_infos,
     print_on_failure, print_warnings,
 };
 use petgraph::{
@@ -1701,10 +1701,11 @@ pub fn compile(
     let terse_mode = profile.terse;
     let reverse_results = profile.reverse_results;
     let fail = |handler: Handler| {
-        let (errors, warnings) = handler.consume();
+        let (errors, warnings, infos) = handler.consume();
         print_on_failure(
             engines.se(),
             terse_mode,
+            &infos,
             &warnings,
             &errors,
             reverse_results,
@@ -1862,8 +1863,9 @@ pub fn compile(
         _ => return fail(handler),
     };
 
-    let (_, warnings) = handler.consume();
+    let (_, warnings, infos) = handler.consume();
 
+    print_infos(engines.se(), terse_mode, &infos);
     print_warnings(engines.se(), terse_mode, &pkg.name, &warnings, &tree_type);
 
     // Metadata to be placed into the binary.
@@ -2420,10 +2422,11 @@ pub fn build(
             manifest_file: manifest.clone(),
         };
 
-        let fail = |warnings, errors| {
+        let fail = |infos, warnings, errors| {
             print_on_failure(
                 engines.se(),
                 profile.terse,
+                infos,
                 warnings,
                 errors,
                 profile.reverse_results,
@@ -2467,7 +2470,7 @@ pub fn build(
                 dbg_generation,
             ) {
                 Ok(o) => o,
-                Err(errs) => return fail(&[], &errs),
+                Err(errs) => return fail(&[], &[], &errs),
             };
 
             let compiled_without_tests = compile(
@@ -2544,6 +2547,7 @@ pub fn build(
                     engines.se(),
                     profile.terse,
                     &[],
+                    &[],
                     &errs,
                     profile.reverse_results,
                 );

forc-util/src/lib.rs

@@ -18,7 +18,7 @@ use sway_core::language::parsed::TreeType;
 use sway_error::{
     diagnostic::{Diagnostic, Issue, Label, LabelType, Level, ToDiagnostic},
     error::CompileError,
-    warning::CompileWarning,
+    warning::{CompileInfo, CompileWarning},
 };
 use sway_types::{LineCol, LineColRange, SourceEngine, Span};
 use sway_utils::constants;
@@ -295,6 +295,18 @@ pub fn print_compiling(ty: Option<&TreeType>, name: &str, src: &dyn std::fmt::Di
     );
 }
 
+pub fn print_infos(source_engine: &SourceEngine, terse_mode: bool, infos: &[CompileInfo]) {
+    if infos.is_empty() {
+        return;
+    }
+
+    if !terse_mode {
+        infos
+            .iter()
+            .for_each(|n| format_diagnostic(&n.to_diagnostic(source_engine)));
+    }
+}
+
 pub fn print_warnings(
     source_engine: &SourceEngine,
     terse_mode: bool,
@@ -329,10 +341,13 @@ pub fn print_warnings(
 pub fn print_on_failure(
     source_engine: &SourceEngine,
     terse_mode: bool,
+    infos: &[CompileInfo],
     warnings: &[CompileWarning],
     errors: &[CompileError],
     reverse_results: bool,
 ) {
+    print_infos(source_engine, terse_mode, infos);
+
     let e_len = errors.len();
     let w_len = warnings.len();
 

sway-core/src/ir_generation/compile.rs

@@ -768,7 +768,7 @@ fn compile_encoding_v0_abi_method(
     let ast_fn_decl = engines.de().get_function(ast_fn_decl);
 
     let get_selector_result = ast_fn_decl.to_fn_selector_value(&handler, engines);
-    let (errors, _warnings) = handler.consume();
+    let (errors, _warnings, _infos) = handler.consume();
     let selector = match get_selector_result.ok() {
         Some(selector) => selector,
         None => {

sway-core/src/lib.rs

@@ -51,7 +51,7 @@ use std::sync::Arc;
 use sway_ast::AttributeDecl;
 use sway_error::convert_parse_tree_error::ConvertParseTreeError;
 use sway_error::handler::{ErrorEmitted, Handler};
-use sway_error::warning::{CompileWarning, Warning};
+use sway_error::warning::{CollectedTraitImpl, CompileInfo, CompileWarning, Info, Warning};
 use sway_features::ExperimentalFeatures;
 use sway_ir::{
     create_o1_pass_group, register_known_passes, Context, Kind, Module, PassGroup, PassManager,
@@ -1017,8 +1017,8 @@ pub fn compile_to_ast(
             let mut entry = query_engine.get_programs_cache_entry(&path).unwrap();
             entry.programs.metrics.reused_programs += 1;
 
-            let (warnings, errors) = entry.handler_data;
-            let new_handler = Handler::from_parts(warnings, errors);
+            let (warnings, errors, infos) = entry.handler_data;
+            let new_handler = Handler::from_parts(warnings, errors, infos);
             handler.append(new_handler);
             return Ok(entry.programs);
         };

sway-core/src/query_engine/mod.rs

@@ -6,7 +6,10 @@ use std::{
     sync::Arc,
     time::SystemTime,
 };
-use sway_error::{error::CompileError, warning::CompileWarning};
+use sway_error::{
+    error::CompileError,
+    warning::{CompileInfo, CompileWarning},
+};
 use sway_types::{IdentUnique, ProgramId, SourceId, Spanned};
 
 use crate::{
@@ -131,7 +134,7 @@ pub type FunctionsCacheMap = HashMap<(IdentUnique, String), FunctionCacheEntry>;
 pub struct ProgramsCacheEntry {
     pub path: Arc<PathBuf>,
     pub programs: Programs,
-    pub handler_data: (Vec<CompileError>, Vec<CompileWarning>),
+    pub handler_data: (Vec<CompileError>, Vec<CompileWarning>, Vec<CompileInfo>),
 }
 
 #[derive(Clone, Debug)]

sway-core/src/semantic_analysis/ast_node/expression/typed_expression/if_expression.rs

@@ -84,7 +84,10 @@ pub(crate) fn instantiate_if_expression(
         }));
     }
 
-    let (new_errors, new_warnings) = h.consume();
+    let (new_errors, new_warnings, new_infos) = h.consume();
+    for info in new_infos {
+        handler.emit_info(info);
+    }
     for warn in new_warnings {
         handler.emit_warn(warn);
     }

sway-core/src/semantic_analysis/namespace/contract_helpers.rs

@@ -40,8 +40,9 @@ pub fn package_with_contract_id(
         dbg_generation,
     )
     .map_err(|_| {
-        let (errors, warnings) = handler.consume();
+        let (errors, warnings, infos) = handler.consume();
         assert!(warnings.is_empty());
+        assert!(infos.is_empty());
 
         // Invariant: `.value == None` => `!errors.is_empty()`.
         vec1::Vec1::try_from_vec(errors).unwrap()

sway-core/src/type_system/unify/unifier.rs

@@ -617,7 +617,11 @@ impl<'a> Unifier<'a> {
             span,
             false,
         );
-        let (new_errors, warnings) = h.consume();
+        let (new_errors, warnings, infos) = h.consume();
+
+        for info in infos {
+            handler.emit_info(info);
+        }
 
         for warn in warnings {
             handler.emit_warn(warn);

sway-error/src/handler.rs

@@ -1,28 +1,41 @@
-use crate::{error::CompileError, warning::CompileWarning};
+use crate::{
+    error::CompileError,
+    warning::{CompileInfo, CompileWarning},
+};
 use core::cell::RefCell;
 
 /// A handler with which you can emit diagnostics.
 #[derive(Default, Debug, Clone)]
 pub struct Handler {
     /// The inner handler.
     /// This construction is used to avoid `&mut` all over the compiler.
-    inner: RefCell<HandlerInner>,
+    inner: RefCell<HandlerDiagnostics>,
 }
 
 /// Contains the actual data for `Handler`.
 /// Modelled this way to afford an API using interior mutability.
 #[derive(Default, Debug, Clone)]
-struct HandlerInner {
+struct HandlerDiagnostics {
     /// The sink through which errors will be emitted.
     errors: Vec<CompileError>,
     /// The sink through which warnings will be emitted.
     warnings: Vec<CompileWarning>,
+    /// The sink through which infos will be emitted.
+    infos: Vec<CompileInfo>,
 }
 
 impl Handler {
-    pub fn from_parts(errors: Vec<CompileError>, warnings: Vec<CompileWarning>) -> Self {
+    pub fn from_parts(
+        errors: Vec<CompileError>,
+        warnings: Vec<CompileWarning>,
+        infos: Vec<CompileInfo>,
+    ) -> Self {
         Self {
-            inner: RefCell::new(HandlerInner { errors, warnings }),
+            inner: RefCell::new(HandlerDiagnostics {
+                errors,
+                warnings,
+                infos,
+            }),
         }
     }
 
@@ -42,6 +55,11 @@ impl Handler {
         self.inner.borrow_mut().warnings.push(warn);
     }
 
+    /// Emit the info `info`.
+    pub fn emit_info(&self, info: CompileInfo) {
+        self.inner.borrow_mut().infos.push(info);
+    }
+
     pub fn has_errors(&self) -> bool {
         !self.inner.borrow().errors.is_empty()
     }
@@ -67,22 +85,25 @@ impl Handler {
         }
     }
 
-    /// Extract all the warnings and errors from this handler.
-    pub fn consume(self) -> (Vec<CompileError>, Vec<CompileWarning>) {
+    /// Extract all the diagnostics from this handler.
+    pub fn consume(self) -> (Vec<CompileError>, Vec<CompileWarning>, Vec<CompileInfo>) {
         let inner = self.inner.into_inner();
-        (inner.errors, inner.warnings)
+        (inner.errors, inner.warnings, inner.infos)
     }
 
     pub fn append(&self, other: Handler) -> Option<ErrorEmitted> {
         let other_has_errors = other.has_errors();
 
-        let (errors, warnings) = other.consume();
+        let (errors, warnings, infos) = other.consume();
         for warn in warnings {
             self.emit_warn(warn);
         }
         for err in errors {
             self.emit_err(err);
         }
+        for inf in infos {
+            self.emit_info(inf);
+        }
 
         if other_has_errors {
             Some(ErrorEmitted { _priv: () })
@@ -118,7 +139,7 @@ impl Handler {
     ) -> Result<(), ErrorEmitted> {
         let mut emitted = Ok(());
 
-        let (errs, _) = other.consume();
+        let (errs, _, _) = other.consume();
         for err in errs {
             if let Some(err) = (f)(err) {
                 emitted = Err(self.emit_err(err));