[move-compiler] Remove WarningFiltersScope from CompilationEnv

external-crates/move/crates/move-analyzer/src/analysis/typing_analysis.rs

@@ -661,7 +661,7 @@ impl TypingAnalysisContext<'_> {
 
 impl<'a> TypingVisitorContext for TypingAnalysisContext<'a> {
     // Nothing to do -- we're not producing errors.
-    fn add_warning_filter_scope(&mut self, _filter: diag::WarningFilters) {}
+    fn push_warning_filter_scope(&mut self, _filter: diag::WarningFilters) {}
 
     // Nothing to do -- we're not producing errors.
     fn pop_warning_filter_scope(&mut self) {}

external-crates/move/crates/move-analyzer/src/symbols.rs

@@ -1875,7 +1875,7 @@ pub fn get_compiled_pkg(
         eprintln!("compiled to parsed AST");
         let (compiler, parsed_program) = compiler.into_ast();
         parsed_ast = Some(parsed_program.clone());
-        mapped_files.extend_with_duplicates(compiler.compilation_env_ref().mapped_files().clone());
+        mapped_files.extend_with_duplicates(compiler.compilation_env().mapped_files().clone());
 
         // extract typed AST
         let compilation_result = compiler.at_parser(parsed_program).run::<PASS_TYPING>();
@@ -1890,17 +1890,17 @@ pub fn get_compiled_pkg(
             }
         };
         eprintln!("compiled to typed AST");
-        let (mut compiler, typed_program) = compiler.into_ast();
+        let (compiler, typed_program) = compiler.into_ast();
         typed_ast = Some(typed_program.clone());
         compiler_info = Some(CompilerInfo::from(
-            compiler.compilation_env().ide_information.clone(),
+            compiler.compilation_env().ide_information().clone(),
         ));
         edition = Some(compiler.compilation_env().edition(Some(root_pkg_name)));
 
         // compile to CFGIR for accurate diags
         eprintln!("compiling to CFGIR");
         let compilation_result = compiler.at_typing(typed_program).run::<PASS_CFGIR>();
-        let mut compiler = match compilation_result {
+        let compiler = match compilation_result {
             Ok(v) => v,
             Err((_pass, diags)) => {
                 let failure = false;

external-crates/move/crates/move-cli/src/base/test.rs

@@ -196,7 +196,7 @@ pub fn run_move_unit_tests<W: Write + Send>(
         let (files, comments_and_compiler_res) = compiler.run::<PASS_CFGIR>().unwrap();
         let (_, compiler) =
             diagnostics::unwrap_or_report_pass_diagnostics(&files, comments_and_compiler_res);
-        let (mut compiler, cfgir) = compiler.into_ast();
+        let (compiler, cfgir) = compiler.into_ast();
         let compilation_env = compiler.compilation_env();
         let built_test_plan = construct_test_plan(compilation_env, Some(root_package), &cfgir);
         let mapped_files = compilation_env.mapped_files().clone();

external-crates/move/crates/move-compiler/src/cfgir/borrows/mod.rs

@@ -13,7 +13,7 @@ use crate::{
         translate::{display_var, DisplayVar},
     },
     parser::ast::BinOp_,
-    shared::{unique_map::UniqueMap, CompilationEnv},
+    shared::unique_map::UniqueMap,
 };
 use move_proc_macros::growing_stack;
 
@@ -90,7 +90,6 @@ impl TransferFunctions for BorrowSafety {
 impl AbstractInterpreter for BorrowSafety {}
 
 pub fn verify(
-    compilation_env: &mut CompilationEnv,
     context: &super::CFGContext,
     cfg: &super::cfg::MutForwardCFG,
 ) -> BTreeMap<Label, BorrowState> {
@@ -100,21 +99,17 @@ pub fn verify(
     let mut safety = BorrowSafety::new(locals);
 
     // check for existing errors
-    let has_errors = compilation_env.has_errors();
+    let has_errors = context.env.has_errors();
     let mut initial_state = BorrowState::initial(locals, safety.mutably_used.clone(), has_errors);
     initial_state.bind_arguments(&signature.parameters);
     initial_state.canonicalize_locals(&safety.local_numbers);
     let (final_state, ds) = safety.analyze_function(cfg, initial_state);
-    compilation_env.add_diags(ds);
-    unused_mut_borrows(compilation_env, context, safety.mutably_used);
+    context.add_diags(ds);
+    unused_mut_borrows(context, safety.mutably_used);
     final_state
 }
 
-fn unused_mut_borrows(
-    compilation_env: &mut CompilationEnv,
-    context: &super::CFGContext,
-    mutably_used: RefExpInfoMap,
-) {
+fn unused_mut_borrows(context: &super::CFGContext, mutably_used: RefExpInfoMap) {
     const MSG: &str = "Mutable reference is never used mutably, \
     consider switching to an immutable reference '&' instead";
 
@@ -143,7 +138,7 @@ fn unused_mut_borrows(
             } else {
                 diag!(UnusedItem::MutReference, (*loc, MSG))
             };
-            compilation_env.add_diag(diag)
+            context.add_diag(diag)
         }
     }
 }

external-crates/move/crates/move-compiler/src/cfgir/liveness/mod.rs

@@ -13,7 +13,7 @@ use crate::{
     diagnostics::Diagnostics,
     expansion::ast::Mutability,
     hlir::ast::{self as H, *},
-    shared::{unique_map::UniqueMap, CompilationEnv},
+    shared::unique_map::UniqueMap,
 };
 use move_ir_types::location::*;
 use move_proc_macros::growing_stack;
@@ -168,11 +168,7 @@ fn exp(state: &mut LivenessState, parent_e: &Exp) {
 /// - Reports an error if an assignment/let was not used
 ///   Switches it to an `Ignore` if it has the drop ability (helps with error messages for borrows)
 
-pub fn last_usage(
-    compilation_env: &mut CompilationEnv,
-    context: &super::CFGContext,
-    cfg: &mut MutForwardCFG,
-) {
+pub fn last_usage(context: &super::CFGContext, cfg: &mut MutForwardCFG) {
     let super::CFGContext {
         infinite_loop_starts,
         ..
@@ -183,46 +179,45 @@ pub fn last_usage(
             .get(lbl)
             .unwrap_or_else(|| panic!("ICE no liveness states for {}", lbl));
         let command_states = per_command_states.get(lbl).unwrap();
-        last_usage::block(compilation_env, final_invariant, command_states, block)
+        last_usage::block(context, final_invariant, command_states, block)
     }
 }
 
 mod last_usage {
     use move_proc_macros::growing_stack;
 
     use crate::{
-        cfgir::liveness::state::LivenessState,
+        cfgir::{liveness::state::LivenessState, CFGContext},
         diag,
         hlir::{
             ast::*,
             translate::{display_var, DisplayVar},
         },
-        shared::*,
     };
     use std::collections::{BTreeSet, VecDeque};
 
     struct Context<'a, 'b> {
-        env: &'a mut CompilationEnv,
+        outer: &'a CFGContext<'a>,
         next_live: &'b BTreeSet<Var>,
         dropped_live: BTreeSet<Var>,
     }
 
     impl<'a, 'b> Context<'a, 'b> {
         fn new(
-            env: &'a mut CompilationEnv,
+            outer: &'a CFGContext<'a>,
             next_live: &'b BTreeSet<Var>,
             dropped_live: BTreeSet<Var>,
         ) -> Self {
             Context {
-                env,
+                outer,
                 next_live,
                 dropped_live,
             }
         }
     }
 
     pub fn block(
-        compilation_env: &mut CompilationEnv,
+        context: &CFGContext,
         final_invariant: &LivenessState,
         command_states: &VecDeque<LivenessState>,
         block: &mut BasicBlock,
@@ -245,10 +240,7 @@ mod last_usage {
                 .difference(next_data)
                 .cloned()
                 .collect::<BTreeSet<_>>();
-            command(
-                &mut Context::new(compilation_env, next_data, dropped_live),
-                cmd,
-            )
+            command(&mut Context::new(context, next_data, dropped_live), cmd)
         }
     }
 
@@ -300,7 +292,7 @@ mod last_usage {
                                      '_{vstr}')",
                                 );
                                 context
-                                    .env
+                                    .outer
                                     .add_diag(diag!(UnusedItem::Assignment, (l.loc, msg)));
                             }
                             *unused_assignment = true;

external-crates/move/crates/move-compiler/src/cfgir/locals/mod.rs

@@ -6,6 +6,7 @@ pub mod state;
 
 use super::absint::*;
 use crate::{
+    cfgir::CFGContext,
     diag,
     diagnostics::{Diagnostic, Diagnostics},
     editions::Edition,
@@ -16,15 +17,10 @@ use crate::{
     },
     naming::ast::{self as N, TParam},
     parser::ast::{Ability_, DatatypeName},
-    shared::{
-        program_info::{DatatypeKind, TypingProgramInfo},
-        unique_map::UniqueMap,
-        *,
-    },
+    shared::{program_info::DatatypeKind, unique_map::UniqueMap},
 };
 use move_ir_types::location::*;
 use move_proc_macros::growing_stack;
-use move_symbol_pool::Symbol;
 use state::*;
 use std::collections::BTreeMap;
 
@@ -33,19 +29,15 @@ use std::collections::BTreeMap;
 //**************************************************************************************************
 
 struct LocalsSafety<'a> {
-    env: &'a CompilationEnv,
-    info: &'a TypingProgramInfo,
-    package: Option<Symbol>,
+    context: &'a CFGContext<'a>,
     local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
     signature: &'a FunctionSignature,
     unused_mut: BTreeMap<Var, Loc>,
 }
 
 impl<'a> LocalsSafety<'a> {
     fn new(
-        env: &'a CompilationEnv,
-        info: &'a TypingProgramInfo,
-        package: Option<Symbol>,
+        context: &'a CFGContext<'a>,
         local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
         signature: &'a FunctionSignature,
     ) -> Self {
@@ -60,9 +52,7 @@ impl<'a> LocalsSafety<'a> {
             })
             .collect();
         Self {
-            env,
-            info,
-            package,
+            context,
             local_types,
             signature,
             unused_mut,
@@ -71,9 +61,7 @@ impl<'a> LocalsSafety<'a> {
 }
 
 struct Context<'a, 'b> {
-    env: &'a CompilationEnv,
-    info: &'a TypingProgramInfo,
-    package: Option<Symbol>,
+    outer: &'a CFGContext<'a>,
     local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
     unused_mut: &'a mut BTreeMap<Var, Loc>,
     local_states: &'b mut LocalStates,
@@ -83,15 +71,12 @@ struct Context<'a, 'b> {
 
 impl<'a, 'b> Context<'a, 'b> {
     fn new(locals_safety: &'a mut LocalsSafety, local_states: &'b mut LocalStates) -> Self {
-        let env = locals_safety.env;
-        let info = locals_safety.info;
+        let outer = locals_safety.context;
         let local_types = locals_safety.local_types;
         let signature = locals_safety.signature;
         let unused_mut = &mut locals_safety.unused_mut;
         Self {
-            env,
-            info,
-            package: locals_safety.package,
+            outer,
             local_types,
             unused_mut,
             local_states,
@@ -154,18 +139,18 @@ impl<'a, 'b> Context<'a, 'b> {
     //     .unwrap();
 
     fn datatype_decl_loc(&self, m: &ModuleIdent, n: &DatatypeName) -> Loc {
-        let kind = self.info.datatype_kind(m, n);
+        let kind = self.outer.info.datatype_kind(m, n);
         match kind {
-            DatatypeKind::Struct => self.info.struct_declared_loc(m, n),
-            DatatypeKind::Enum => self.info.enum_declared_loc(m, n),
+            DatatypeKind::Struct => self.outer.info.struct_declared_loc(m, n),
+            DatatypeKind::Enum => self.outer.info.enum_declared_loc(m, n),
         }
     }
 
     fn datatype_declared_abilities(&self, m: &ModuleIdent, n: &DatatypeName) -> &'a AbilitySet {
-        let kind = self.info.datatype_kind(m, n);
+        let kind = self.outer.info.datatype_kind(m, n);
         match kind {
-            DatatypeKind::Struct => self.info.struct_declared_abilities(m, n),
-            DatatypeKind::Enum => self.info.enum_declared_abilities(m, n),
+            DatatypeKind::Struct => self.outer.info.struct_declared_abilities(m, n),
+            DatatypeKind::Enum => self.outer.info.enum_declared_abilities(m, n),
         }
     }
 }
@@ -189,30 +174,23 @@ impl<'a> TransferFunctions for LocalsSafety<'a> {
 impl<'a> AbstractInterpreter for LocalsSafety<'a> {}
 
 pub fn verify(
-    compilation_env: &mut CompilationEnv,
     context: &super::CFGContext,
     cfg: &super::cfg::MutForwardCFG,
 ) -> BTreeMap<Label, LocalStates> {
     let super::CFGContext {
         signature, locals, ..
     } = context;
     let initial_state = LocalStates::initial(&signature.parameters, locals);
-    let mut locals_safety = LocalsSafety::new(
-        compilation_env,
-        context.info,
-        context.package,
-        locals,
-        signature,
-    );
+    let mut locals_safety = LocalsSafety::new(context, locals, signature);
     let (final_state, ds) = locals_safety.analyze_function(cfg, initial_state);
-    unused_let_muts(compilation_env, locals, locals_safety.unused_mut);
-    compilation_env.add_diags(ds);
+    unused_let_muts(context, locals, locals_safety.unused_mut);
+    context.add_diags(ds);
     final_state
 }
 
 /// Generates warnings for unused mut declarations
 fn unused_let_muts<T>(
-    env: &mut CompilationEnv,
+    context: &CFGContext,
     locals: &UniqueMap<Var, T>,
     unused_mut_locals: BTreeMap<Var, Loc>,
 ) {
@@ -226,7 +204,7 @@ fn unused_let_muts<T>(
             let decl_loc = *locals.get_loc(&v).unwrap();
             let decl_msg = format!("The variable '{vstr}' is never used mutably");
             let mut_msg = "Consider removing the 'mut' declaration here";
-            env.add_diag(diag!(
+            context.add_diag(diag!(
                 UnusedItem::MutModifier,
                 (decl_loc, decl_msg),
                 (mut_loc, mut_msg)
@@ -524,7 +502,7 @@ fn check_mutability(
         let usage_msg = format!("Invalid {usage} of immutable variable '{vstr}'");
         let decl_msg =
             format!("To use the variable mutably, it must be declared 'mut', e.g. 'mut {vstr}'");
-        if context.env.edition(context.package) == Edition::E2024_MIGRATION {
+        if context.outer.env.edition(context.outer.package) == Edition::E2024_MIGRATION {
             context.add_diag(diag!(Migration::NeedsLetMut, (decl_loc, decl_msg.clone())))
         } else {
             let mut diag = diag!(