[cleanup] Various fixes after script removal (#17142)

## Description 

- Renamed various `view` related items
- Removed `Location::Script` and removed related code (which was always
unreachable)
- Moved FunctionView to the bytecode verifier

## Test plan 

- CI

---

## 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:

Author: tnowacki

crates/move-binary-format/src/binary_views.rs

@@ -135,8 +135,7 @@ impl<'a> BoundsChecker<'a> {
     }
 
     fn check_function_defs(&mut self) -> PartialVMResult<()> {
-        let view = self.module;
-        for (function_def_idx, function_def) in view.function_defs().iter().enumerate() {
+        for (function_def_idx, function_def) in self.module.function_defs().iter().enumerate() {
             self.check_function_def(function_def_idx, function_def)?
         }
         Ok(())

crates/move-binary-format/src/check_bounds.rs

@@ -19,7 +19,6 @@ pub type PartialVMResult<T> = ::std::result::Result<T, PartialVMError>;
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub enum Location {
     Undefined,
-    Script,
     Module(ModuleId),
 }
 
@@ -317,7 +316,6 @@ impl fmt::Display for Location {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Location::Undefined => write!(f, "UNDEFINED"),
-            Location::Script => write!(f, "Script"),
             Location::Module(id) => write!(f, "Module {:?}", id),
         }
     }

crates/move-binary-format/src/errors.rs

@@ -7,7 +7,6 @@
 use std::fmt;
 
 pub mod binary_config;
-pub mod binary_views;
 pub mod check_bounds;
 pub mod compatibility;
 #[macro_use]

crates/move-binary-format/src/lib.rs

@@ -36,7 +36,7 @@ impl<'a> SourceMapping<'a> {
         }
     }
 
-    pub fn new_from_view(bytecode: &'a CompiledModule, default_loc: Loc) -> Result<Self> {
+    pub fn new_without_source_map(bytecode: &'a CompiledModule, default_loc: Loc) -> Result<Self> {
         Ok(Self::new(
             SourceMap::dummy_from_view(bytecode, default_loc)?,
             bytecode,

crates/move-bytecode-source-map/src/mapping.rs

@@ -9,8 +9,7 @@ use move_ir_types::location::Spanned;
 #[test]
 fn test_empty_module() {
     let module = empty_module();
-    let view = &module;
     let location = Spanned::unsafe_no_loc(()).loc;
-    SourceMapping::new_from_view(view, location)
+    SourceMapping::new_without_source_map(&module, location)
         .expect("unable to build source mapping for empty script");
 }

crates/move-bytecode-source-map/tests/dummies.rs

@@ -98,18 +98,18 @@ impl<'a> Modules<'a> {
 }
 
 pub fn resolve_struct(
-    view: &CompiledModule,
+    module: &CompiledModule,
     sidx: StructHandleIndex,
 ) -> (&AccountAddress, &IdentStr, &IdentStr) {
-    let shandle = view.struct_handle_at(sidx);
-    let mhandle = view.module_handle_at(shandle.module);
-    let address = view.address_identifier_at(mhandle.address);
-    let module_name = view.identifier_at(mhandle.name);
-    let struct_name = view.identifier_at(shandle.name);
+    let shandle = module.struct_handle_at(sidx);
+    let mhandle = module.module_handle_at(shandle.module);
+    let address = module.address_identifier_at(mhandle.address);
+    let module_name = module.identifier_at(mhandle.name);
+    let struct_name = module.identifier_at(shandle.name);
     (address, module_name, struct_name)
 }
 
-pub fn format_signature_token(view: &CompiledModule, t: &SignatureToken) -> String {
+pub fn format_signature_token(module: &CompiledModule, t: &SignatureToken) -> String {
     match t {
         SignatureToken::Bool => "bool".to_string(),
         SignatureToken::U8 => "u8".to_string(),
@@ -121,28 +121,28 @@ pub fn format_signature_token(view: &CompiledModule, t: &SignatureToken) -> Stri
         SignatureToken::Address => "address".to_string(),
         SignatureToken::Signer => "signer".to_string(),
         SignatureToken::Vector(inner) => {
-            format!("vector<{}>", format_signature_token(view, inner))
+            format!("vector<{}>", format_signature_token(module, inner))
         }
-        SignatureToken::Reference(inner) => format!("&{}", format_signature_token(view, inner)),
+        SignatureToken::Reference(inner) => format!("&{}", format_signature_token(module, inner)),
         SignatureToken::MutableReference(inner) => {
-            format!("&mut {}", format_signature_token(view, inner))
+            format!("&mut {}", format_signature_token(module, inner))
         }
         SignatureToken::TypeParameter(i) => format!("T{}", i),
 
-        SignatureToken::Struct(idx) => format_signature_token_struct(view, *idx, &[]),
+        SignatureToken::Struct(idx) => format_signature_token_struct(module, *idx, &[]),
         SignatureToken::StructInstantiation(struct_inst) => {
             let (idx, ty_args) = &**struct_inst;
-            format_signature_token_struct(view, *idx, ty_args)
+            format_signature_token_struct(module, *idx, ty_args)
         }
     }
 }
 
 pub fn format_signature_token_struct(
-    view: &CompiledModule,
+    module: &CompiledModule,
     sidx: StructHandleIndex,
     ty_args: &[SignatureToken],
 ) -> String {
-    let (address, module_name, struct_name) = resolve_struct(view, sidx);
+    let (address, module_name, struct_name) = resolve_struct(module, sidx);
     let s;
     let ty_args_string = if ty_args.is_empty() {
         ""
@@ -151,7 +151,7 @@ pub fn format_signature_token_struct(
             "<{}>",
             ty_args
                 .iter()
-                .map(|t| format_signature_token(view, t))
+                .map(|t| format_signature_token(module, t))
                 .collect::<Vec<_>>()
                 .join(", ")
         );

crates/move-bytecode-utils/src/lib.rs

@@ -3,14 +3,29 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use move_binary_format::{
-    binary_views::FunctionView,
-    control_flow_graph::{BlockId, ControlFlowGraph},
+    control_flow_graph::{BlockId, ControlFlowGraph, VMControlFlowGraph},
     errors::PartialVMResult,
-    file_format::{Bytecode, CodeOffset},
+    file_format::{
+        AbilitySet, Bytecode, CodeOffset, CodeUnit, FunctionDefinitionIndex, FunctionHandle,
+        Signature,
+    },
+    CompiledModule,
 };
 use move_bytecode_verifier_meter::{Meter, Scope};
 use std::collections::BTreeMap;
 
+/// A `FunctionContext` holds all the information needed by the verifier for `FunctionDefinition`.`
+/// A control flow graph is built for a function when the `FunctionContext` is created.
+pub struct FunctionContext<'a> {
+    index: Option<FunctionDefinitionIndex>,
+    code: &'a CodeUnit,
+    parameters: &'a Signature,
+    return_: &'a Signature,
+    locals: &'a Signature,
+    type_parameters: &'a [AbilitySet],
+    cfg: VMControlFlowGraph,
+}
+
 /// Trait for finite-height abstract domains. Infinite height domains would require a more complex
 /// trait with widening and a partial order.
 pub trait AbstractDomain: Clone + Sized {
@@ -71,16 +86,16 @@ pub trait TransferFunctions {
 }
 
 pub trait AbstractInterpreter: TransferFunctions {
-    /// Analyze procedure local@function_view starting from pre-state local@initial_state.
+    /// Analyze procedure local@function_context starting from pre-state local@initial_state.
     fn analyze_function(
         &mut self,
         initial_state: Self::State,
-        function_view: &FunctionView,
+        function_context: &FunctionContext,
         meter: &mut (impl Meter + ?Sized),
     ) -> PartialVMResult<()> {
         meter.add(Scope::Function, ANALYZE_FUNCTION_BASE_COST)?;
         let mut inv_map = InvariantMap::new();
-        let entry_block_id = function_view.cfg().entry_block_id();
+        let entry_block_id = function_context.cfg().entry_block_id();
         let mut next_block = Some(entry_block_id);
         inv_map.insert(entry_block_id, BlockInvariant { pre: initial_state });
 
@@ -90,19 +105,19 @@ pub trait AbstractInterpreter: TransferFunctions {
                 None => {
                     // This can only happen when all predecessors have errors,
                     // so skip the block and move on to the next one
-                    next_block = function_view.cfg().next_block(block_id);
+                    next_block = function_context.cfg().next_block(block_id);
                     continue;
                 }
             };
 
             let pre_state = &block_invariant.pre;
             // Note: this will stop analysis after the first error occurs, to avoid the risk of
             // subsequent crashes
-            let post_state = self.execute_block(block_id, pre_state, function_view, meter)?;
+            let post_state = self.execute_block(block_id, pre_state, function_context, meter)?;
 
-            let mut next_block_candidate = function_view.cfg().next_block(block_id);
+            let mut next_block_candidate = function_context.cfg().next_block(block_id);
             // propagate postcondition of this block to successor blocks
-            for successor_block_id in function_view.cfg().successors(block_id) {
+            for successor_block_id in function_context.cfg().successors(block_id) {
                 meter.add(Scope::Function, PER_SUCCESSOR_COST)?;
                 match inv_map.get_mut(successor_block_id) {
                     Some(next_block_invariant) => {
@@ -118,7 +133,7 @@ pub trait AbstractInterpreter: TransferFunctions {
                             JoinResult::Changed => {
                                 // If the cur->successor is a back edge, jump back to the beginning
                                 // of the loop, instead of the normal next block
-                                if function_view
+                                if function_context
                                     .cfg()
                                     .is_back_edge(block_id, *successor_block_id)
                                 {
@@ -150,16 +165,64 @@ pub trait AbstractInterpreter: TransferFunctions {
         &mut self,
         block_id: BlockId,
         pre_state: &Self::State,
-        function_view: &FunctionView,
+        function_context: &FunctionContext,
         meter: &mut (impl Meter + ?Sized),
     ) -> PartialVMResult<Self::State> {
         meter.add(Scope::Function, EXECUTE_BLOCK_BASE_COST)?;
         let mut state_acc = pre_state.clone();
-        let block_end = function_view.cfg().block_end(block_id);
-        for offset in function_view.cfg().instr_indexes(block_id) {
-            let instr = &function_view.code().code[offset as usize];
+        let block_end = function_context.cfg().block_end(block_id);
+        for offset in function_context.cfg().instr_indexes(block_id) {
+            let instr = &function_context.code().code[offset as usize];
             self.execute(&mut state_acc, instr, offset, block_end, meter)?
         }
         Ok(state_acc)
     }
 }
+
+impl<'a> FunctionContext<'a> {
+    // Creates a `FunctionContext` for a module function.
+    pub fn new(
+        module: &'a CompiledModule,
+        index: FunctionDefinitionIndex,
+        code: &'a CodeUnit,
+        function_handle: &'a FunctionHandle,
+    ) -> Self {
+        Self {
+            index: Some(index),
+            code,
+            parameters: module.signature_at(function_handle.parameters),
+            return_: module.signature_at(function_handle.return_),
+            locals: module.signature_at(code.locals),
+            type_parameters: &function_handle.type_parameters,
+            cfg: VMControlFlowGraph::new(&code.code),
+        }
+    }
+
+    pub fn index(&self) -> Option<FunctionDefinitionIndex> {
+        self.index
+    }
+
+    pub fn code(&self) -> &CodeUnit {
+        self.code
+    }
+
+    pub fn parameters(&self) -> &Signature {
+        self.parameters
+    }
+
+    pub fn return_(&self) -> &Signature {
+        self.return_
+    }
+
+    pub fn locals(&self) -> &Signature {
+        self.locals
+    }
+
+    pub fn type_parameters(&self) -> &[AbilitySet] {
+        self.type_parameters
+    }
+
+    pub fn cfg(&self) -> &VMControlFlowGraph {
+        &self.cfg
+    }
+}