Parse raw identifiers (r#<identifier>) in expressions

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs

@@ -36,7 +36,7 @@ where
         let type_parameters_constraints =
             self.generate_type_parameters_constraints_code(type_parameters, Some("AbiEncode"));
 
-        let name = name.as_str();
+        let name = name.as_raw_ident_str();
 
         if body.is_empty() {
             format!("#[allow(dead_code, deprecated)] impl{type_parameters_declaration} AbiEncode for {name}{type_parameters_declaration}{type_parameters_constraints} {{
@@ -67,7 +67,7 @@ where
         let type_parameters_constraints =
             self.generate_type_parameters_constraints_code(type_parameters, Some("AbiDecode"));
 
-        let name = name.as_str();
+        let name = name.as_raw_ident_str();
 
         if body == "Self {  }" {
             format!("#[allow(dead_code, deprecated)] impl{type_parameters_declaration} AbiDecode for {name}{type_parameters_declaration}{type_parameters_constraints} {{
@@ -92,7 +92,7 @@ where
         for f in decl.fields.iter() {
             code.push_str(&format!(
                 "let buffer = self.{field_name}.abi_encode(buffer);\n",
-                field_name = f.name.as_str(),
+                field_name = f.name.as_raw_ident_str(),
             ));
         }
 
@@ -108,7 +108,7 @@ where
         for f in decl.fields.iter() {
             code.push_str(&format!(
                 "{field_name}: buffer.decode::<{field_type_name}>(),",
-                field_name = f.name.as_str(),
+                field_name = f.name.as_raw_ident_str(),
                 field_type_name = Self::generate_type(engines, &f.type_argument)?,
             ));
         }
@@ -121,10 +121,10 @@ where
         engines: &Engines,
         decl: &TyEnumDecl,
     ) -> Option<String> {
-        let enum_name = decl.call_path.suffix.as_str();
+        let enum_name = decl.call_path.suffix.as_raw_ident_str();
         let arms = decl.variants.iter()
             .map(|x| {
-                let name = x.name.as_str();
+                let name = x.name.as_raw_ident_str();
                 Some(match &*engines.te().get(x.type_argument.type_id()) {
                     // unit
                     TypeInfo::Tuple(fields) if fields.is_empty() => {
@@ -156,12 +156,12 @@ where
             return "".into();
         }
 
-        let enum_name = decl.call_path.suffix.as_str();
+        let enum_name = decl.call_path.suffix.as_raw_ident_str();
         let arms = decl
             .variants
             .iter()
             .map(|x| {
-                let name = x.name.as_str();
+                let name = x.name.as_raw_ident_str();
                 if engines.te().get(x.type_argument.type_id()).is_unit() {
                     format!(
                         "{enum_name}::{variant_name} => {{
@@ -320,6 +320,9 @@ where
         for r in contract_fns {
             let decl = engines.de().get(r);
 
+            // For contract methods, even if their names are raw identifiers,
+            // we use just the name, because the generated methods will be prefixed
+            // with `__contract_entry_`.
             let name = decl.name.as_str();
             if !contract_methods.contains_key(name) {
                 contract_methods.insert(name.to_string(), vec![]);
@@ -424,7 +427,7 @@ where
                 });
                 return Err(err);
             };
-            let method_name = fallback_fn.name.as_str();
+            let method_name = fallback_fn.name.as_raw_ident_str();
             match fallback_fn.purity {
                 Purity::Pure => {}
                 Purity::Reads => reads = true,

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/debug.rs

@@ -78,7 +78,7 @@ where
         let type_parameters_constraints =
             self.generate_type_parameters_constraints_code(type_parameters, Some("Debug"));
 
-        let name = name.as_str();
+        let name = name.as_raw_ident_str();
 
         format!("#[allow(dead_code, deprecated)] impl{type_parameters_declaration} Debug for {name}{type_parameters_declaration}{type_parameters_constraints} {{
             #[allow(dead_code, deprecated)]
@@ -94,13 +94,13 @@ where
         for field in decl.fields.iter() {
             fields.push_str(&format!(
                 ".field(\"{field_name}\", self.{field_name})\n",
-                field_name = field.name.as_str(),
+                field_name = field.name.as_raw_ident_str(),
             ));
         }
 
         format!(
             "_f.debug_struct(\"{}\"){fields}.finish();",
-            decl.name().as_str()
+            decl.name().as_raw_ident_str()
         )
     }
 
@@ -126,13 +126,13 @@ where
     }
 
     fn generate_fmt_enum_body(&self, engines: &Engines, decl: &TyEnumDecl) -> String {
-        let enum_name = decl.call_path.suffix.as_str();
+        let enum_name = decl.call_path.suffix.as_raw_ident_str();
 
         let arms = decl
             .variants
             .iter()
             .map(|variant| {
-                let variant_name = variant.name.as_str();
+                let variant_name = variant.name.as_raw_ident_str();
                 if engines.te().get(variant.type_argument.type_id()).is_unit() {
                     format!(
                         "{enum_name}::{variant_name} => {{

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/marker_traits.rs

@@ -54,7 +54,7 @@ where
 
         let impl_marker_trait_code = format!(
             "#[allow(dead_code, deprecated)] impl{type_parameters_declaration} {marker_trait_name} for {}{type_parameters_declaration}{type_parameters_constraints} {{ }}",
-            enum_decl.name()
+            enum_decl.name().as_raw_ident_str()
         );
 
         let impl_enum_node = self.parse_impl_trait_to_ty_ast_node(

sway-parse/src/keywords.rs

@@ -6,7 +6,7 @@ use sway_types::Spanned;
 
 fn peek_keyword<T: Keyword>(peeker: Peeker<'_>) -> Option<T> {
     let ident = peeker.peek_ident().ok()?;
-    (ident.as_str() == T::AS_STR).then(|| T::new(ident.span()))
+    (!ident.is_raw_ident() && ident.as_str() == T::AS_STR).then(|| T::new(ident.span()))
 }
 
 fn parse_keyword<T: Keyword + Peek>(parser: &mut Parser) -> ParseResult<T> {

sway-types/src/ident.rs

@@ -1,6 +1,7 @@
 use crate::{span::Span, Spanned};
 use serde::{Deserialize, Serialize};
 use std::{
+    borrow::Cow,
     cmp::{Ord, Ordering},
     fmt,
     hash::{Hash, Hasher},
@@ -26,6 +27,15 @@ impl BaseIdent {
             .unwrap_or_else(|| self.span.as_str())
     }
 
+    /// Returns the identifier as a string, prefixed with `r#` if it is a raw identifier.
+    pub fn as_raw_ident_str(&self) -> Cow<str> {
+        if self.is_raw_ident {
+            Cow::Owned(format!("r#{}", self.as_str()))
+        } else {
+            Cow::Borrowed(self.as_str())
+        }
+    }
+
     pub fn is_raw_ident(&self) -> bool {
         self.is_raw_ident
     }

test/src/e2e_vm_tests/test_programs/should_fail/reserved_identifiers/Forc.lock

@@ -1,3 +1,8 @@
 [[package]]
-name = 'reserved_identifiers'
-source = 'member'
+name = "reserved_identifiers"
+source = "member"
+dependencies = ["std"]
+
+[[package]]
+name = "std"
+source = "path+from-root-E00F3FB2E032AF39"

test/src/e2e_vm_tests/test_programs/should_fail/reserved_identifiers/Forc.toml

@@ -3,4 +3,6 @@ authors = ["Fuel Labs <[email protected]>"]
 license = "Apache-2.0"
 name = "reserved_identifiers"
 entry = "main.sw"
-implicit-std = false
+
+[dependencies]
+std = { path = "../../../reduced_std_libs/sway-lib-std-core" }

test/src/e2e_vm_tests/test_programs/should_fail/reserved_identifiers/snapshot.toml

@@ -0,0 +1 @@
+cmds = ["forc build --path {root} --release --experimental error_type"]

test/src/e2e_vm_tests/test_programs/should_fail/reserved_identifiers/src/main.sw

@@ -33,5 +33,5 @@ fn main() {
     let mut deref = 0;
     let mut true = 0;
     let mut false = 0;
+    let mut panic = 0;
 }
-