[move-compiler] Add support for postfix ability declarations (#13782)

## Description 

Adds support for postfix ability declarations to the source language in
the move2024 edition.

## Test Plan 

Added a number of test for both pre-move2024 and move2024.

Author: tzakian

move-compiler/src/editions/mod.rs

@@ -28,6 +28,7 @@ pub struct Edition {
 #[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord)]
 pub enum FeatureGate {
     PublicPackage,
+    PostFixAbilities,
 }
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord, Default)]
@@ -41,7 +42,12 @@ pub enum Flavor {
 // Entry
 //**************************************************************************************************
 
-pub fn check_feature(env: &mut CompilationEnv, edition: Edition, feature: &FeatureGate, loc: Loc) {
+pub fn check_feature(
+    env: &mut CompilationEnv,
+    edition: Edition,
+    feature: &FeatureGate,
+    loc: Loc,
+) -> bool {
     if !edition.supports(feature) {
         let valid_editions = valid_editions_for_feature(feature)
             .into_iter()
@@ -63,6 +69,9 @@ pub fn check_feature(env: &mut CompilationEnv, edition: Edition, feature: &Featu
             or via command line flag if invoking the compiler directly.",
         );
         env.add_diag(diag);
+        false
+    } else {
+        true
     }
 }
 
@@ -81,6 +90,9 @@ pub fn valid_editions_for_feature(feature: &FeatureGate) -> Vec<Edition> {
 static SUPPORTED_FEATURES: Lazy<BTreeMap<Edition, BTreeSet<FeatureGate>>> =
     Lazy::new(|| BTreeMap::from_iter(Edition::ALL.iter().map(|e| (*e, e.features()))));
 
+const E2024_ALPHA_FEATURES: &[FeatureGate] =
+    &[FeatureGate::PublicPackage, FeatureGate::PostFixAbilities];
+
 impl Edition {
     pub const LEGACY: Self = Self {
         edition: symbol!("legacy"),
@@ -115,7 +127,7 @@ impl Edition {
             Self::LEGACY => BTreeSet::new(),
             Self::E2024_ALPHA => {
                 let mut features = self.prev().unwrap().features();
-                features.extend([FeatureGate::PublicPackage]);
+                features.extend(E2024_ALPHA_FEATURES);
                 features
             }
             _ => self.unknown_edition_panic(),

move-compiler/src/parser/mod.rs

@@ -75,7 +75,8 @@ pub(crate) fn parse_program(
         named_address_map,
     } in targets
     {
-        let (defs, comments, ds, file_hash) = parse_file(compilation_env, &mut files, path)?;
+        let (defs, comments, ds, file_hash) =
+            parse_file(compilation_env, &mut files, path, package)?;
         source_definitions.extend(defs.into_iter().map(|def| PackageDefinition {
             package,
             named_address_map,
@@ -91,7 +92,7 @@ pub(crate) fn parse_program(
         named_address_map,
     } in deps
     {
-        let (defs, _, ds, _) = parse_file(compilation_env, &mut files, path)?;
+        let (defs, _, ds, _) = parse_file(compilation_env, &mut files, path, package)?;
         lib_definitions.extend(defs.into_iter().map(|def| PackageDefinition {
             package,
             named_address_map,
@@ -164,6 +165,7 @@ fn parse_file(
     compilation_env: &mut CompilationEnv,
     files: &mut FilesSourceText,
     fname: Symbol,
+    package: Option<Symbol>,
 ) -> anyhow::Result<(
     Vec<parser::ast::Definition>,
     MatchedFileCommentMap,
@@ -184,7 +186,7 @@ fn parse_file(
         }
         Ok(()) => &source_buffer,
     };
-    let (defs, comments) = match parse_file_string(compilation_env, file_hash, buffer) {
+    let (defs, comments) = match parse_file_string(compilation_env, file_hash, buffer, package) {
         Ok(defs_and_comments) => defs_and_comments,
         Err(ds) => {
             diags.extend(ds);

move-compiler/src/parser/syntax.rs

@@ -13,19 +13,29 @@ use move_symbol_pool::{symbol, Symbol};
 use crate::{
     diag,
     diagnostics::{Diagnostic, Diagnostics},
+    editions::FeatureGate,
     parser::{ast::*, lexer::*},
     shared::*,
     MatchedFileCommentMap,
 };
 
 struct Context<'env, 'lexer, 'input> {
+    package_name: Option<Symbol>,
     env: &'env mut CompilationEnv,
     tokens: &'lexer mut Lexer<'input>,
 }
 
 impl<'env, 'lexer, 'input> Context<'env, 'lexer, 'input> {
-    fn new(env: &'env mut CompilationEnv, tokens: &'lexer mut Lexer<'input>) -> Self {
-        Self { env, tokens }
+    fn new(
+        env: &'env mut CompilationEnv,
+        tokens: &'lexer mut Lexer<'input>,
+        package_name: Option<Symbol>,
+    ) -> Self {
+        Self {
+            package_name,
+            env,
+            tokens,
+        }
     }
 }
 
@@ -1995,9 +2005,11 @@ fn parse_parameter(context: &mut Context) -> Result<(Var, Type), Box<Diagnostic>
 // Parse a struct definition:
 //      StructDecl =
 //          "struct" <StructDefName> ("has" <Ability> (, <Ability>)+)?
-//          ("{" Comma<FieldAnnot> "}" | ";")
+//          ("{" Comma<FieldAnnot> "}" ("has" <Ability> (, <Ability>)+;)? | ";")
 //      StructDefName =
 //          <Identifier> <OptionalTypeParameters>
+// Where the the two "has" statements are mutually exclusive -- a struct cannot be declared with
+// both infix and postfix ability declarations.
 fn parse_struct_decl(
     attributes: Vec<Attributes>,
     start_loc: usize,
@@ -2035,8 +2047,13 @@ fn parse_struct_decl(
     let name = StructName(parse_identifier(context)?);
     let type_parameters = parse_struct_type_parameters(context)?;
 
-    let abilities = if context.tokens.peek() == Tok::Identifier && context.tokens.content() == "has"
-    {
+    let infix_ability_declaration_loc =
+        if context.tokens.peek() == Tok::Identifier && context.tokens.content() == "has" {
+            Some(current_token_loc(context.tokens))
+        } else {
+            None
+        };
+    let mut abilities = if infix_ability_declaration_loc.is_some() {
         context.tokens.advance()?;
         parse_list(
             context,
@@ -2075,6 +2092,11 @@ fn parse_struct_decl(
                 parse_field_annot,
                 "a field",
             )?;
+            parse_postfix_ability_declarations(
+                infix_ability_declaration_loc,
+                &mut abilities,
+                context,
+            )?;
             StructFields::Defined(list)
         }
     };
@@ -2104,6 +2126,63 @@ fn parse_field_annot(context: &mut Context) -> Result<(Field, Type), Box<Diagnos
     Ok((f, st))
 }
 
+// Parse a postfix ability declaration:
+//     "has" <Ability> (, <Ability>)+;
+//  Error if:
+//      * Also has prefix ability declaration
+fn parse_postfix_ability_declarations(
+    infix_ability_declaration_loc: Option<Loc>,
+    abilities: &mut Vec<Ability>,
+    context: &mut Context,
+) -> Result<(), Box<Diagnostic>> {
+    let postfix_ability_declaration =
+        context.tokens.peek() == Tok::Identifier && context.tokens.content() == "has";
+    let has_location = current_token_loc(context.tokens);
+
+    if postfix_ability_declaration {
+        context.env.check_feature(
+            &FeatureGate::PostFixAbilities,
+            context.package_name,
+            has_location,
+        );
+
+        context.tokens.advance()?;
+
+        // Only add a diagnostic about prefix xor postfix ability declarations if the feature is
+        // supported. Otherwise we will already have an error that the `has` is not supported in
+        // that position, and the feature check diagnostic as well, so adding this additional error
+        // could be confusing.
+        if let Some(previous_declaration_loc) = infix_ability_declaration_loc {
+            let msg = "Duplicate ability declaration. Abilities can be declared before \
+                       or after the field declarations, but not both.";
+            let prev_msg = "Ability declaration previously given here";
+            context.env.add_diag(diag!(
+                Syntax::InvalidModifier,
+                (has_location, msg),
+                (previous_declaration_loc, prev_msg)
+            ));
+        }
+
+        *abilities = parse_list(
+            context,
+            |context| match context.tokens.peek() {
+                Tok::Comma => {
+                    context.tokens.advance()?;
+                    Ok(true)
+                }
+                Tok::Semicolon => Ok(false),
+                _ => Err(unexpected_token_error(
+                    context.tokens,
+                    &format!("one of: '{}' or '{}'", Tok::Comma, Tok::Semicolon),
+                )),
+            },
+            parse_ability,
+        )?;
+        consume_token(context.tokens, Tok::Semicolon)?;
+    }
+    Ok(())
+}
+
 //**************************************************************************************************
 // Constants
 //**************************************************************************************************
@@ -3226,13 +3305,14 @@ pub fn parse_file_string(
     env: &mut CompilationEnv,
     file_hash: FileHash,
     input: &str,
+    package: Option<Symbol>,
 ) -> Result<(Vec<Definition>, MatchedFileCommentMap), Diagnostics> {
     let mut tokens = Lexer::new(input, file_hash);
     match tokens.advance() {
         Err(err) => Err(Diagnostics::from(vec![*err])),
         Ok(..) => Ok(()),
     }?;
-    match parse_file(&mut Context::new(env, &mut tokens)) {
+    match parse_file(&mut Context::new(env, &mut tokens, package)) {
         Err(err) => Err(Diagnostics::from(vec![*err])),
         Ok(def) => Ok((def, tokens.check_and_get_doc_comments(env))),
     }

move-compiler/src/shared/mod.rs

@@ -523,8 +523,14 @@ impl CompilationEnv {
         self.visitors.clone()
     }
 
-    // Logs an error if the feature isn't supported.
-    pub fn check_feature(&mut self, feature: &FeatureGate, package: Option<Symbol>, loc: Loc) {
+    // Logs an error if the feature isn't supported. Returns `false` if the feature is not
+    // supported, and `true` otherwise.
+    pub fn check_feature(
+        &mut self,
+        feature: &FeatureGate,
+        package: Option<Symbol>,
+        loc: Loc,
+    ) -> bool {
         edition_check_feature(self, self.package_config(package).edition, feature, loc)
     }
 

move-compiler/tests/move_2024/parser/ability_modifier_infix_and_postfix.exp

@@ -0,0 +1,8 @@
+error[E01003]: invalid modifier
+  ┌─ tests/move_2024/parser/ability_modifier_infix_and_postfix.move:4:34
+  │
+4 │     struct Foo has copy, drop {} has store;
+  │                ---               ^^^ Duplicate ability declaration. Abilities can be declared before or after the field declarations, but not both.
+  │                │                  
+  │                Ability declaration previously given here
+

move-compiler/tests/move_2024/parser/ability_modifier_infix_and_postfix.move

@@ -0,0 +1,6 @@
+address 0x42 {
+module M {
+    // has both prefix and postfix ability declarations
+    struct Foo has copy, drop {} has store;
+}
+}

move-compiler/tests/move_2024/parser/ability_modifier_infix_and_postfix_native_struct.exp

@@ -0,0 +1,9 @@
+error[E01002]: unexpected token
+  ┌─ tests/move_2024/parser/ability_modifier_infix_and_postfix_native_struct.move:5:39
+  │
+5 │     native struct Foo has copy, drop; has store;
+  │                                       ^^^
+  │                                       │
+  │                                       Unexpected 'has'
+  │                                       Expected a module member: 'spec', 'use', 'friend', 'const', 'fun', or 'struct'
+

move-compiler/tests/move_2024/parser/ability_modifier_infix_and_postfix_native_struct.move

@@ -0,0 +1,7 @@
+address 0x42 {
+module M {
+    // has both invalid declaration since postfix ability declarations
+    // are not allowed for native structs
+    native struct Foo has copy, drop; has store;
+}
+}

move-compiler/tests/move_2024/parser/ability_modifier_infix_postfix_no_fields.exp

@@ -0,0 +1,9 @@
+error[E01002]: unexpected token
+  ┌─ tests/move_2024/parser/ability_modifier_infix_postfix_no_fields.move:4:38
+  │
+4 │     native struct Foo has copy, drop has store;
+  │                                      ^^^
+  │                                      │
+  │                                      Unexpected 'has'
+  │                                      Expected one of: ',', '{', or ';'
+

move-compiler/tests/move_2024/parser/ability_modifier_infix_postfix_no_fields.move

@@ -0,0 +1,6 @@
+address 0x42 {
+module M {
+    // has both prefix and invalid postfix ability declarations
+    native struct Foo has copy, drop has store;
+}
+}