[move] Add CFGIR Ast Visitor. Clean up rough edges of T::Program. (#1…

…7787)

## Description 

- Some lints probably want to use the CFGIR, since they are easier to do
post optimizations
- Cleaned up the linter APIs

## Test plan 

- internal change 

---

## Release notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [ ] Protocol: 
- [ ] Nodes (Validators and Full nodes): 
- [ ] Indexer: 
- [ ] JSON-RPC: 
- [ ] GraphQL: 
- [ ] CLI: 
- [ ] Rust SDK:

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

@@ -1335,7 +1335,7 @@ pub fn get_symbols(
  // uwrap's are safe - this function returns earlier (during diagnostics processing)
  // when failing to produce the ASTs
  let parsed_program = parsed_ast.unwrap();
- let typed_modules = typed_ast.unwrap().inner.modules;
+ let typed_modules = typed_ast.unwrap().modules;
 
  let mut mod_outer_defs = BTreeMap::new();
  let mut mod_use_defs = BTreeMap::new();
@@ -1358,7 +1358,7 @@ pub fn get_symbols(
  if let Some(libs) = compiled_libs.clone() {
  pre_process_typed_modules(
  &parsed_program,
- &libs.typing.inner.modules,
+ &libs.typing.modules,
  &files,
  &file_id_mapping,
  &file_id_to_lines,
@@ -1422,7 +1422,7 @@ pub fn get_symbols(
  );
  if let Some(libs) = compiled_libs {
  process_typed_modules(
- &libs.typing.inner.modules,
+ &libs.typing.modules,
  &source_files,
  &mod_to_alias_lengths,
  &mut typing_symbolicator,

external-crates/move/crates/move-compiler/src/cfgir/ast.rs

@@ -10,12 +10,15 @@ use crate::{
  StructDefinition, Var, Visibility,
  },
  parser::ast::{ConstantName, DatatypeName, FunctionName, ENTRY_MODIFIER},
- shared::{ast_debug::*, unique_map::UniqueMap},
+ shared::{ast_debug::*, program_info::TypingProgramInfo, unique_map::UniqueMap},
 };
 use move_core_types::runtime_value::MoveValue;
 use move_ir_types::location::*;
 use move_symbol_pool::Symbol;
-use std::collections::{BTreeMap, VecDeque};
+use std::{
+ collections::{BTreeMap, VecDeque},
+ sync::Arc,
+};
 
 // HLIR + Unstructured Control Flow + CFG
 
@@ -25,6 +28,7 @@ use std::collections::{BTreeMap, VecDeque};
 
 #[derive(Debug, Clone)]
 pub struct Program {
+ pub info: Arc<TypingProgramInfo>,
  pub modules: UniqueMap<ModuleIdent, ModuleDefinition>,
 }
 
@@ -187,7 +191,7 @@ fn remap_labels_cmd(remapping: &BTreeMap<Label, Label>, sp!(_, cmd_): &mut Comma
 
 impl AstDebug for Program {
  fn ast_debug(&self, w: &mut AstWriter) {
- let Program { modules } = self;
+ let Program { modules, info: _ } = self;
 
  for (m, mdef) in modules.key_cloned_iter() {
  w.write(&format!("module {}", m));

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

@@ -16,7 +16,11 @@ use crate::{
  },
  naming::ast::{self as N, TParam},
  parser::ast::{Ability_, DatatypeName},
- shared::{unique_map::UniqueMap, *},
+ shared::{
+ program_info::{DatatypeKind, TypingProgramInfo},
+ unique_map::UniqueMap,
+ *,
+ },
 };
 use move_ir_types::location::*;
 use move_proc_macros::growing_stack;
@@ -30,8 +34,8 @@ use std::collections::BTreeMap;
 
 struct LocalsSafety<'a> {
  env: &'a CompilationEnv,
+ info: &'a TypingProgramInfo,
  package: Option<Symbol>,
- datatype_declared_abilities: &'a UniqueMap<ModuleIdent, UniqueMap<DatatypeName, AbilitySet>>,
  local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
  signature: &'a FunctionSignature,
  unused_mut: BTreeMap<Var, Loc>,
@@ -40,11 +44,8 @@ struct LocalsSafety<'a> {
 impl<'a> LocalsSafety<'a> {
  fn new(
  env: &'a CompilationEnv,
+ info: &'a TypingProgramInfo,
  package: Option<Symbol>,
- datatype_declared_abilities: &'a UniqueMap<
- ModuleIdent,
- UniqueMap<DatatypeName, AbilitySet>,
- >,
  local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
  signature: &'a FunctionSignature,
  ) -> Self {
@@ -60,8 +61,8 @@ impl<'a> LocalsSafety<'a> {
  .collect();
  Self {
  env,
+ info,
  package,
- datatype_declared_abilities,
  local_types,
  signature,
  unused_mut,
@@ -71,8 +72,8 @@ impl<'a> LocalsSafety<'a> {
 
 struct Context<'a, 'b> {
  env: &'a CompilationEnv,
+ info: &'a TypingProgramInfo,
  package: Option<Symbol>,
- datatype_declared_abilities: &'a UniqueMap<ModuleIdent, UniqueMap<DatatypeName, AbilitySet>>,
  local_types: &'a UniqueMap<Var, (Mutability, SingleType)>,
  unused_mut: &'a mut BTreeMap<Var, Loc>,
  local_states: &'b mut LocalStates,
@@ -83,14 +84,14 @@ 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 datatype_declared_abilities = &locals_safety.datatype_declared_abilities;
+ let info = locals_safety.info;
  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,
- datatype_declared_abilities,
  local_types,
  unused_mut,
  local_states,
@@ -138,6 +139,35 @@ impl<'a, 'b> Context<'a, 'b> {
  fn mark_mutable_usage(&mut self, _eloc: Loc, v: &Var) {
  self.unused_mut.remove(v);
  }
+
+ // let decl_loc = *context
+ // .datatype_declared_abilities
+ // .get(m)
+ // .unwrap()
+ // .get_loc(s)
+ // .unwrap();
+ // let declared_abilities = context
+ // .datatype_declared_abilities
+ // .get(m)
+ // .unwrap()
+ // .get(s)
+ // .unwrap();
+
+ fn datatype_decl_loc(&self, m: &ModuleIdent, n: &DatatypeName) -> Loc {
+ let kind = self.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),
+ }
+ }
+
+ fn datatype_declared_abilities(&self, m: &ModuleIdent, n: &DatatypeName) -> &'a AbilitySet {
+ let kind = self.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),
+ }
+ }
 }
 
 impl<'a> TransferFunctions for LocalsSafety<'a> {
@@ -164,16 +194,13 @@ pub fn verify(
  cfg: &super::cfg::MutForwardCFG,
 ) -> BTreeMap<Label, LocalStates> {
  let super::CFGContext {
- datatype_declared_abilities,
- signature,
- locals,
- ..
+ signature, locals, ..
  } = context;
  let initial_state = LocalStates::initial(&signature.parameters, locals);
  let mut locals_safety = LocalsSafety::new(
  compilation_env,
+ context.info,
  context.package,
- datatype_declared_abilities,
  locals,
  signature,
  );
@@ -539,18 +566,8 @@ fn add_drop_ability_tip(context: &Context, diag: &mut Diagnostic, st: SingleType
  (None, &owned_abilities, ty_args.clone())
  }
  T::Apply(_, sp!(_, TN::ModuleType(m, s)), ty_args) => {
- let decl_loc = *context
- .datatype_declared_abilities
- .get(m)
- .unwrap()
- .get_loc(s)
- .unwrap();
- let declared_abilities = context
- .datatype_declared_abilities
- .get(m)
- .unwrap()
- .get(s)
- .unwrap();
+ let decl_loc = context.datatype_decl_loc(m, s);
+ let declared_abilities = context.datatype_declared_abilities(m, s);
  (Some(decl_loc), declared_abilities, ty_args.clone())
  }
  t => panic!(

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

@@ -15,10 +15,9 @@ pub mod visitor;
 mod optimize;
 
 use crate::{
- expansion::ast::{AbilitySet, Attributes, ModuleIdent, Mutability},
+ expansion::ast::{Attributes, ModuleIdent, Mutability},
  hlir::ast::{FunctionSignature, Label, SingleType, Var, Visibility},
- parser::ast::DatatypeName,
- shared::{unique_map::UniqueMap, CompilationEnv, Name},
+ shared::{program_info::TypingProgramInfo, unique_map::UniqueMap, CompilationEnv, Name},
 };
 use cfg::*;
 use move_ir_types::location::Loc;
@@ -27,11 +26,10 @@ use optimize::optimize;
 use std::collections::BTreeSet;
 
 pub struct CFGContext<'a> {
+ pub info: &'a TypingProgramInfo,
  pub package: Option<Symbol>,
  pub module: ModuleIdent,
  pub member: MemberName,
- pub datatype_declared_abilities:
- &'a UniqueMap<ModuleIdent, UniqueMap<DatatypeName, AbilitySet>>,
  pub attributes: &'a Attributes,
  pub entry: Option<Loc>,
  pub visibility: Visibility,