[move 2024][alpha] Method syntax (#13933)

## Description 

See 'Release Notes' for feature description.

This PR:
- Resurrects original method style syntax
- Adds a `defines_primitive` annotation so that method style syntax can
be used with primitive/builtin types
- Adds use fun declarations 

Some notes about implementation details
- A normal use alias, `use a::m::f as g` introduces an implicit `use fun
a::m::f as a::m::S.g` in situations where the first argument of
`a::m::f` is `a::m::S`. This ensures that there isn't any weird
precedence/shadowing between `use` and `use fun` in a given scope.
- There are some nuances here, but the rules are ensuring that once you
have a module that calls `x.foo()`, it always resolves to the same
function `a::m::bar`, even if new `public use fun`s are added elsewhere.
- I had to move `ProgramInfo` into the `naming::ast::program` and
`typing::ast::program` to properly resolve `use funs` (particularly with
this implicit setup described above)

Follow up 
- `let mut` and `mut` variable modifiers
- I think I will rewrite alias maps in expansion to reduce clones (as I
did with use fun declarations

## Test Plan 

- New tests 

---
If your changes are not user-facing and not a breaking change, you can
skip the following section. Otherwise, please indicate what changed, and
then add to the Release Notes section as highlighted during the release
process.

### Type of Change (Check all that apply)

- [ ] protocol change
- [X] user-visible impact
- [ ] breaking change for a client SDKs
- [ ] breaking change for FNs (FN binary must upgrade)
- [ ] breaking change for validators or node operators (must upgrade
binaries)
- [ ] breaking change for on-chain data layout
- [ ] necessitate either a data wipe or data migration

### Release notes

Method style syntax has been added to Move 2024.alpha. This means
functions can now be invoked with the syntax, `e.foo(arg1, arg2)`.
Assuming `e: a::m::S` (or `&a::m::S` or `&mut a::m::S`), `e.foo(arg1,
arg2)` will resolve to `a::m::foo(e, arg1, arg2)`. Additionally, the
compiler will borrow `e` when necessary.
For instances where the desired target function is not declared in the
same module as the type (or is not declared with the desired name), a
`use fun` alias can be used instead. For example, `use b::n::bar as
S.baz` will allow `e.baz()` to resolve as `b::n::bar(e)`. A `public use
fun` can be declared in the types defining module, allowing the alias to
be used outside of the module.

Author: tnowacki

move-analyzer/src/symbols.rs

@@ -702,7 +702,7 @@ impl Symbolicator {
             }
         }
 
-        let modules = &typed_ast.unwrap().modules;
+        let modules = &typed_ast.unwrap().inner.modules;
 
         let mut mod_outer_defs = BTreeMap::new();
         let mut mod_use_defs = BTreeMap::new();

move-compiler/src/cfgir/cfg.rs

@@ -272,7 +272,7 @@ impl<T: Deref<Target = BasicBlocks>> CFG for ForwardCFG<T> {
     }
 
     fn debug(&self) {
-        crate::shared::ast_debug::print(self);
+        self.print();
     }
 }
 
@@ -733,7 +733,7 @@ impl<'forward, Blocks: Deref<Target = BasicBlocks>> CFG for ReverseCFG<'forward,
     }
 
     fn debug(&self) {
-        crate::shared::ast_debug::print(self);
+        self.print();
     }
 }
 

move-compiler/src/diagnostics/codes.rs

@@ -204,6 +204,7 @@ codes!(
         InvalidAttribute: { msg: "invalid attribute", severity: NonblockingError },
         InvalidVisibilityModifier:
             { msg: "invalid visibility modifier", severity: NonblockingError },
+        InvalidUseFun: { msg: "invalid 'use fun' declaration", severity: NonblockingError },
     ],
     // errors name resolution, mostly expansion/translate and naming/translate
     NameResolution: [
@@ -250,6 +251,7 @@ codes!(
                 (NOTE: this may become an error in the future)",
             severity: Warning
         },
+        InvalidMethodCall: { msg: "invalid method call", severity: BlockingError },
     ],
     // errors for ability rules. mostly typing/translate
     AbilitySafety: [

move-compiler/src/editions/mod.rs

@@ -30,6 +30,7 @@ pub enum FeatureGate {
     PublicPackage,
     PostFixAbilities,
     StructTypeVisibility,
+    DotCall,
 }
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord, Default)]
@@ -46,7 +47,7 @@ pub enum Flavor {
 pub fn check_feature(
     env: &mut CompilationEnv,
     edition: Edition,
-    feature: &FeatureGate,
+    feature: FeatureGate,
     loc: Loc,
 ) -> bool {
     let supports_feature = edition.supports(feature);
@@ -61,8 +62,9 @@ pub fn check_feature(
             (
                 loc,
                 format!(
-                    "{feature} not supported by current edition '{edition}', \
-                    only '{valid_editions}' support this feature"
+                    "{} not supported by current edition '{edition}', \
+                    only '{valid_editions}' support this feature",
+                    feature.error_prefix(),
                 )
             )
         );
@@ -75,7 +77,7 @@ pub fn check_feature(
     supports_feature
 }
 
-pub fn valid_editions_for_feature(feature: &FeatureGate) -> Vec<Edition> {
+pub fn valid_editions_for_feature(feature: FeatureGate) -> Vec<Edition> {
     Edition::ALL
         .iter()
         .filter(|e| e.supports(feature))
@@ -94,6 +96,7 @@ const E2024_ALPHA_FEATURES: &[FeatureGate] = &[
     FeatureGate::PublicPackage,
     FeatureGate::PostFixAbilities,
     FeatureGate::StructTypeVisibility,
+    FeatureGate::DotCall,
 ];
 
 impl Edition {
@@ -110,8 +113,8 @@ impl Edition {
 
     pub const ALL: &[Self] = &[Self::LEGACY, Self::E2024_ALPHA];
 
-    pub fn supports(&self, feature: &FeatureGate) -> bool {
-        SUPPORTED_FEATURES.get(self).unwrap().contains(feature)
+    pub fn supports(&self, feature: FeatureGate) -> bool {
+        SUPPORTED_FEATURES.get(self).unwrap().contains(&feature)
     }
 
     // Intended only for implementing the lazy static (supported feature map) above
@@ -159,6 +162,17 @@ impl Flavor {
     pub const ALL: &[Self] = &[Self::GlobalStorage, Self::Sui];
 }
 
+impl FeatureGate {
+    fn error_prefix(&self) -> &'static str {
+        match self {
+            FeatureGate::PublicPackage => "'public(package)' is",
+            FeatureGate::PostFixAbilities => "Postfix abilities are",
+            FeatureGate::StructTypeVisibility => "Struct visibility modifiers are",
+            FeatureGate::DotCall => "Method syntax is",
+        }
+    }
+}
+
 //**************************************************************************************************
 // Parsing/Deserialize
 //**************************************************************************************************
@@ -263,12 +277,6 @@ impl Serialize for Flavor {
     }
 }
 
-impl Display for FeatureGate {
-    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Ok(())
-    }
-}
-
 //**************************************************************************************************
 // traits
 //**************************************************************************************************

move-compiler/src/expansion/aliases.rs

@@ -3,8 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    expansion::ast::{ModuleIdent, ModuleIdent_},
-    parser::ast::ModuleName,
+    expansion::ast::{self as E, ModuleIdent, ModuleIdent_},
+    parser::ast::{self as P, ModuleName},
     shared::{unique_map::UniqueMap, unique_set::UniqueSet, *},
 };
 use move_ir_types::location::*;
@@ -33,6 +33,20 @@ pub struct AliasMap {
 
 pub struct OldAliasMap(Option<AliasMap>);
 
+pub struct ParserExplicitUseFun {
+    pub loc: Loc,
+    pub attributes: E::Attributes,
+    pub is_public: Option<Loc>,
+    pub function: Box<P::NameAccessChain>,
+    pub ty: Box<P::NameAccessChain>,
+    pub method: Name,
+}
+
+pub struct UseFunsBuilder {
+    pub explicit: Vec<ParserExplicitUseFun>,
+    pub implicit: UniqueMap<Name, E::ImplicitUseFunCandidate>,
+}
+
 impl AliasSet {
     pub fn new() -> Self {
         Self {
@@ -276,3 +290,12 @@ impl OldAliasMap {
         }
     }
 }
+
+impl UseFunsBuilder {
+    pub fn new() -> Self {
+        Self {
+            explicit: vec![],
+            implicit: UniqueMap::new(),
+        }
+    }
+}