add support for unhygenic inline macro expansion

Author: dean-starkware

corelib/src/test/language_features/macro_test.cairo

@@ -389,3 +389,15 @@ fn test_defsite_inference() {
     let z: defsite_inference::A = defsite_inference::use_local_impl_inference!(5);
     assert_eq!(y.x, z.x);
 }
+
+macro define_and_use unhygenic {
+    () => {
+        let foo = 123;
+    };
+}
+
+#[test]
+fn test_define_and_use_unhygenic() {
+    define_and_use!();
+    let _y = foo;
+}

crates/cairo-lang-parser/src/lexer.rs

@@ -214,6 +214,7 @@ impl<'a> Lexer<'a> {
             "return" => TokenKind::Return,
             "match" => TokenKind::Match,
             "macro" => TokenKind::Macro,
+            "unhygenic" => TokenKind::Unhygenic,
             "if" => TokenKind::If,
             "loop" => TokenKind::Loop,
             "continue" => TokenKind::Continue,
@@ -372,6 +373,7 @@ enum TokenKind {
     False,
     True,
     Extern,
+    Unhygenic,
     Type,
     Function,
     Trait,
@@ -463,6 +465,7 @@ fn token_kind_to_terminal_syntax_kind(kind: TokenKind) -> SyntaxKind {
         TokenKind::False => SyntaxKind::TerminalFalse,
         TokenKind::True => SyntaxKind::TerminalTrue,
         TokenKind::Extern => SyntaxKind::TerminalExtern,
+        TokenKind::Unhygenic => SyntaxKind::TerminalUnhygenic,
         TokenKind::Type => SyntaxKind::TerminalType,
         TokenKind::Function => SyntaxKind::TerminalFunction,
         TokenKind::Trait => SyntaxKind::TerminalTrait,

crates/cairo-lang-parser/src/parser.rs

@@ -677,6 +677,10 @@ impl<'a> Parser<'a> {
     ) -> ItemMacroDeclarationGreen {
         let macro_kw = self.take::<TerminalMacro>();
         let name = self.parse_identifier();
+        let unhygenic: OptionTerminalUnhygenicGreen = match self.peek().kind {
+            SyntaxKind::TerminalUnhygenic => self.take::<TerminalUnhygenic>().into(),
+            _ => OptionTerminalUnhygenicEmpty::new_green(self.db).into(),
+        };
         let lbrace = self.parse_token::<TerminalLBrace>();
         let macro_rules = MacroRulesList::new_green(
             self.db,
@@ -689,6 +693,7 @@ impl<'a> Parser<'a> {
             visibility,
             macro_kw,
             name,
+            unhygenic,
             lbrace,
             macro_rules,
             rbrace,

crates/cairo-lang-parser/src/parser_test_data/partial_trees/inline_macro

@@ -59,6 +59,7 @@ macro some_macro {
     │       ├── visibility (kind: VisibilityDefault) []
     │       ├── macro_kw (kind: TokenMacro): 'macro'
     │       ├── name (kind: TokenIdentifier): 'some_macro'
+    │       ├── unhygenic_kw (kind: OptionTerminalUnhygenicEmpty) []
     │       ├── lbrace (kind: TokenLBrace): '{'
     │       ├── rules (kind: MacroRulesList)
     │       │   └── child #0 (kind: MacroRule)
@@ -167,6 +168,7 @@ fn use_macro() {
     │   │   ├── visibility (kind: VisibilityDefault) []
     │   │   ├── macro_kw (kind: TokenMacro): 'macro'
     │   │   ├── name (kind: TokenIdentifier): 'some_macro'
+    │   │   ├── unhygenic_kw (kind: OptionTerminalUnhygenicEmpty) []
     │   │   ├── lbrace (kind: TokenLBrace): '{'
     │   │   ├── rules (kind: MacroRulesList)
     │   │   │   ├── child #0 (kind: MacroRule)

crates/cairo-lang-parser/src/parser_test_data/partial_trees/macro_declaration

@@ -24,6 +24,7 @@ macro macro_name {
     │       ├── visibility (kind: VisibilityDefault) []
     │       ├── macro_kw (kind: TokenMacro): 'macro'
     │       ├── name (kind: TokenIdentifier): 'macro_name'
+    │       ├── unhygenic_kw (kind: OptionTerminalUnhygenicEmpty) []
     │       ├── lbrace (kind: TokenLBrace): '{'
     │       ├── rules (kind: MacroRulesList)
     │       │   └── child #0 (kind: MacroRule)
@@ -80,6 +81,7 @@ macro macro_name {
     │       ├── visibility (kind: VisibilityDefault) []
     │       ├── macro_kw (kind: TokenMacro): 'macro'
     │       ├── name (kind: TokenIdentifier): 'macro_name'
+    │       ├── unhygenic_kw (kind: OptionTerminalUnhygenicEmpty) []
     │       ├── lbrace (kind: TokenLBrace): '{'
     │       ├── rules (kind: MacroRulesList)
     │       │   ├── child #0 (kind: MacroRule)
@@ -225,6 +227,7 @@ error: Missing tokens. Expected a macro rule parameter kind.
     │       ├── visibility (kind: VisibilityDefault) []
     │       ├── macro_kw (kind: TokenMacro): 'macro'
     │       ├── name (kind: TokenIdentifier): 'macro_name'
+    │       ├── unhygenic_kw (kind: OptionTerminalUnhygenicEmpty) []
     │       ├── lbrace (kind: TokenLBrace): '{'
     │       ├── rules (kind: MacroRulesList)
     │       │   └── child #0 (kind: MacroRule)

crates/cairo-lang-semantic/src/expr/compute.rs

@@ -156,6 +156,7 @@ struct InlineMacroExpansion {
     pub name: String,
     pub code_mappings: Vec<CodeMapping>,
     pub is_plugin_macro: bool,
+    pub is_unhygenic: bool,
 }
 
 /// Context for computing the semantic model of expression trees.
@@ -529,11 +530,13 @@ fn expand_inline_macro(
         let mut matcher_ctx =
             MatcherContext { captures, placeholder_to_rep_id, ..Default::default() };
         let expanded_code = expand_macro_rule(ctx.db, rule, &mut matcher_ctx)?;
+        let is_unhygenic = ctx.db.priv_macro_declaration_data(macro_declaration_id)?.is_unhygenic;
         Ok(InlineMacroExpansion {
             content: expanded_code.text,
             name: macro_name.clone(),
             code_mappings: expanded_code.code_mappings,
             is_plugin_macro: false,
+            is_unhygenic,
         })
     } else if let Some(macro_plugin_id) =
         ctx.db.crate_inline_macro_plugins(crate_id).get(&macro_name).cloned()
@@ -573,6 +576,7 @@ fn expand_inline_macro(
             name: code.name.to_string(),
             code_mappings: code.code_mappings,
             is_plugin_macro: true,
+            is_unhygenic: false,
         })
     } else {
         return Err(ctx.diagnostics.report(
@@ -591,8 +595,14 @@ fn compute_expr_inline_macro_semantic(
 ) -> Maybe<Expr> {
     let db = ctx.db;
     let prev_macro_call_data = ctx.resolver.macro_call_data.clone();
-    let InlineMacroExpansion { content, name, code_mappings: mappings, is_plugin_macro } =
-        expand_inline_macro(ctx, syntax)?;
+    let InlineMacroExpansion {
+        content,
+        name,
+        code_mappings: mappings,
+        is_plugin_macro,
+        is_unhygenic,
+    } = expand_inline_macro(ctx, syntax)?;
+
     if !is_plugin_macro {
         let user_defined_macro = ctx.resolver.resolve_generic_path(
             &mut Default::default(),
@@ -650,6 +660,8 @@ fn compute_expr_inline_macro_semantic(
         );
         ctx.resolver.set_suppress_modifiers_diagnostics(prev_resolver_modifiers_suppression);
         result
+    } else if is_unhygenic {
+        compute_expr_semantic(ctx, &expr_syntax)
     } else {
         ctx.run_in_macro_subscope(
             |ctx| compute_expr_semantic(ctx, &expr_syntax),
@@ -659,7 +671,6 @@ fn compute_expr_inline_macro_semantic(
     ctx.resolver.macro_call_data = prev_macro_call_data;
     Ok(expr.expr)
 }
-
 /// Expands an inline macro used in statement position, computes its semantic model, and extends
 /// `statements` with it.
 fn expand_macro_for_statement(
@@ -669,8 +680,13 @@ fn expand_macro_for_statement(
     statements: &mut Vec<StatementId>,
 ) -> Maybe<()> {
     let prev_macro_call_data = ctx.resolver.macro_call_data.clone();
-    let InlineMacroExpansion { content, name, code_mappings: mappings, is_plugin_macro } =
-        expand_inline_macro(ctx, syntax)?;
+    let InlineMacroExpansion {
+        content,
+        name,
+        code_mappings: mappings,
+        is_plugin_macro,
+        is_unhygenic,
+    } = expand_inline_macro(ctx, syntax)?;
     let new_file_long_id = FileLongId::Virtual(VirtualFile {
         parent: Some(syntax.stable_ptr(ctx.db).untyped().file_id(ctx.db)),
         name: name.clone().into(),
@@ -709,6 +725,17 @@ fn expand_macro_for_statement(
         ctx.resolver.set_suppress_modifiers_diagnostics(prev_resolver_modifiers_suppression);
         ctx.resolver.macro_call_data = prev_macro_call_data;
         result
+    } else if is_unhygenic {
+        let mut ids = compute_statement_list_semantic(ctx, parsed_statements.clone());
+        if let Some(tail_expr) = tail {
+            let expr = compute_expr_semantic(ctx, &tail_expr);
+            ids.push(ctx.arenas.statements.alloc(semantic::Statement::Expr(
+                semantic::StatementExpr { expr: expr.id, stable_ptr: statement_stable_ptr },
+            )));
+        }
+        statements.extend(ids);
+        ctx.resolver.macro_call_data = prev_macro_call_data;
+        Ok(())
     } else {
         let result = ctx.run_in_macro_subscope(
             |ctx| {

crates/cairo-lang-semantic/src/expr/test_data/inline_macros

@@ -1480,3 +1480,57 @@ error: Parser error in macro-expanded code: Skipped tokens. Expected: end of exp
  _^
 |         let b = 2;
 |__________________^
+
+//! > ==========================================================================
+
+//! > Test: Variable defined in unhygienic macro is visible outside.
+
+//! > test_runner_name
+test_function_diagnostics(expect_diagnostics: false)
+
+//! > function
+fn foo() {
+    define_var_unhygienic!();
+    let _x = a;
+}
+
+//! > function_name
+foo
+
+//! > module_code
+macro define_var_unhygienic unhygenic {
+    () => {
+        let a = 42;
+    };
+}
+
+//! > expected_diagnostics
+
+//! > ==========================================================================
+
+//! > Test: Variable defined in hygenic macro is not visible outside.
+
+//! > test_runner_name
+test_function_diagnostics(expect_diagnostics: true)
+
+//! > function
+fn foo() {
+    define_var_hygenic!();
+    let _x = _a;
+}
+
+//! > function_name
+foo
+
+//! > module_code
+macro define_var_hygenic {
+    () => {
+        let _a = 42;
+    };
+}
+
+//! > expected_diagnostics
+error[E0006]: Identifier not found.
+ --> lib.cairo:8:14
+    let _x = _a;
+             ^^

crates/cairo-lang-semantic/src/items/macro_declaration.rs

@@ -68,6 +68,7 @@ pub struct MacroDeclarationData {
     attributes: Vec<Attribute>,
     diagnostics: Diagnostics<SemanticDiagnostic>,
     resolver_data: Arc<ResolverData>,
+    pub is_unhygenic: bool,
 }
 
 /// The semantic data for a single macro rule in a macro declaration.
@@ -121,6 +122,10 @@ pub fn priv_macro_declaration_data(
         );
     }
 
+    let is_unhygenic = matches!(
+        macro_declaration_syntax.unhygenic_kw(syntax_db),
+        ast::OptionTerminalUnhygenic::TerminalUnhygenic(_)
+    );
     let attributes = macro_declaration_syntax.attributes(syntax_db).structurize(syntax_db);
     let inference_id = InferenceId::LookupItemDeclaration(LookupItemId::ModuleItem(
         ModuleItemId::MacroDeclaration(macro_declaration_id),
@@ -174,7 +179,13 @@ pub fn priv_macro_declaration_data(
         rules.push(MacroRuleData { pattern, expansion });
     }
     let resolver_data = Arc::new(resolver.data);
-    Ok(MacroDeclarationData { diagnostics: diagnostics.build(), attributes, resolver_data, rules })
+    Ok(MacroDeclarationData {
+        diagnostics: diagnostics.build(),
+        attributes,
+        resolver_data,
+        rules,
+        is_unhygenic,
+    })
 }
 
 /// Helper function to extract pattern elements from a WrappedMacro.

crates/cairo-lang-syntax-codegen/src/cairo_spec.rs

@@ -900,10 +900,12 @@ pub fn get_spec() -> Vec<Node> {
         .node("visibility", "Visibility")
         .node("macro_kw", "TerminalMacro")
         .key_node("name", "TerminalIdentifier")
+        .node("unhygenic_kw", "OptionTerminalUnhygenic")
         .node("lbrace", "TerminalLBrace")
         .node("rules", "MacroRulesList")
         .node("rbrace", "TerminalRBrace")
     )
+    .add_option("TerminalUnhygenic")
     .add_list("MacroRulesList", "MacroRule")
     .add_struct(StructBuilder::new("MacroRule")
         .node("lhs", "WrappedMacro")
@@ -1022,6 +1024,7 @@ pub fn get_spec() -> Vec<Node> {
     .add_keyword_token_and_terminal("Implicits")
     .add_keyword_token_and_terminal("Let")
     .add_keyword_token_and_terminal("Macro")
+    .add_keyword_token_and_terminal("Unhygenic")
     .add_keyword_token_and_terminal("Match")
     .add_keyword_token_and_terminal("Module")
     .add_keyword_token_and_terminal("Mut")