Implement mutability check for yul (#722)

Signed-off-by: Lucas Steuernagel <lucas.tnagel@gmail.com>

src/bin/solang.rs

@@ -331,12 +331,14 @@ fn main() {
             }
         }
 
+        if let Some("ast-dot") = matches.value_of("EMIT") {
+            std::process::exit(0);
+        }
+
         if errors {
             if matches.is_present("STD-JSON") {
                 println!("{}", serde_json::to_string(&json).unwrap());
                 std::process::exit(0);
-            } else if let Some("ast-dot") = matches.value_of("EMIT") {
-                std::process::exit(0);
             } else {
                 eprintln!("error: not all contracts are valid");
                 std::process::exit(1);
@@ -471,10 +473,6 @@ fn process_file(
             std::process::exit(1);
         }
 
-        if ns.contracts.is_empty() || diagnostics::any_errors(&ns.diagnostics) {
-            return Err(());
-        }
-
         return Ok(ns);
     }
 

src/codegen/mod.rs

@@ -87,8 +87,8 @@ impl Default for Options {
     }
 }
 
-/// The contracts are fully resolved but they do not have any a CFG which is needed for
-/// the llvm code emitter. This will also do addition code checks.
+/// The contracts are fully resolved but they do not have any CFGs which is needed for
+/// the llvm code emitter. This will also do additional code checks.
 pub fn codegen(ns: &mut Namespace, opt: &Options) {
     if any_errors(&ns.diagnostics) {
         return;

src/sema/dotgraphviz.rs

@@ -1553,7 +1553,7 @@ impl Dot {
                     local_parent = parent;
                     for (item_no, item) in inline_assembly.body.iter().enumerate() {
                         local_parent = self.add_yul_statement(
-                            &item.0,
+                            item,
                             local_parent,
                             format!("statement #{}", item_no),
                             &inline_assembly.functions,
@@ -1623,7 +1623,7 @@ impl Dot {
         local_parent = func_node;
         for (item_no, item) in avail_functions[func_no].body.iter().enumerate() {
             local_parent = self.add_yul_statement(
-                &item.0,
+                item,
                 local_parent,
                 format!("statement #{}", item_no),
                 avail_functions,
@@ -1834,7 +1834,7 @@ impl Dot {
         ns: &Namespace,
     ) -> usize {
         match statement {
-            YulStatement::FunctionCall(loc, func_no, args) => self.add_yul_function_call(
+            YulStatement::FunctionCall(loc, _, func_no, args) => self.add_yul_function_call(
                 loc,
                 func_no,
                 args,
@@ -1844,7 +1844,7 @@ impl Dot {
                 symtable,
                 ns,
             ),
-            YulStatement::BuiltInCall(loc, builtin_ty, args) => self.add_yul_builtin_call(
+            YulStatement::BuiltInCall(loc, _, builtin_ty, args) => self.add_yul_builtin_call(
                 loc,
                 builtin_ty,
                 args,
@@ -1857,7 +1857,7 @@ impl Dot {
             YulStatement::Block(block) => {
                 self.add_yul_block(block, parent, parent_rel, avail_functions, symtable, ns)
             }
-            YulStatement::VariableDeclaration(loc, declared_vars, initializer) => {
+            YulStatement::VariableDeclaration(loc, _, declared_vars, initializer) => {
                 let labels = vec![
                     "yul variable declaration".to_string(),
                     ns.loc_to_string(loc),
@@ -1901,7 +1901,7 @@ impl Dot {
 
                 node
             }
-            YulStatement::Assignment(loc, lhs, rhs) => {
+            YulStatement::Assignment(loc, _, lhs, rhs) => {
                 let labels = vec!["yul assignment".to_string(), ns.loc_to_string(loc)];
 
                 let node = self.add_node(
@@ -1931,7 +1931,7 @@ impl Dot {
                 );
                 node
             }
-            YulStatement::IfBlock(loc, condition, block) => {
+            YulStatement::IfBlock(loc, _, condition, block) => {
                 let labels = vec!["yul if".to_string(), ns.loc_to_string(loc)];
 
                 let node = self.add_node(Node::new("if", labels), Some(parent), Some(parent_rel));
@@ -1959,6 +1959,7 @@ impl Dot {
                 condition,
                 cases,
                 default,
+                ..
             } => {
                 let labels = vec!["yul switch".to_string(), ns.loc_to_string(loc)];
 
@@ -2030,6 +2031,7 @@ impl Dot {
                 condition,
                 post_block,
                 execution_block,
+                ..
             } => {
                 let labels = vec!["yul for".to_string(), ns.loc_to_string(loc)];
 
@@ -2069,15 +2071,15 @@ impl Dot {
                 );
                 node
             }
-            YulStatement::Leave(loc) => {
+            YulStatement::Leave(loc, _) => {
                 let labels = vec!["leave".to_string(), ns.loc_to_string(loc)];
                 self.add_node(Node::new("leave", labels), Some(parent), Some(parent_rel))
             }
-            YulStatement::Break(loc) => {
+            YulStatement::Break(loc, _) => {
                 let labels = vec!["break".to_string(), ns.loc_to_string(loc)];
                 self.add_node(Node::new("break", labels), Some(parent), Some(parent_rel))
             }
-            YulStatement::Continue(loc) => {
+            YulStatement::Continue(loc, _) => {
                 let labels = vec!["continue".to_string(), ns.loc_to_string(loc)];
                 self.add_node(
                     Node::new("continue", labels),
@@ -2108,7 +2110,7 @@ impl Dot {
         parent = node;
         for (statement_no, child_statement) in block.body.iter().enumerate() {
             parent = self.add_yul_statement(
-                &child_statement.0,
+                child_statement,
                 parent,
                 format!("statement #{}", statement_no),
                 avail_functions,

src/sema/mod.rs

@@ -162,7 +162,7 @@ fn sema_file(file: &ResolvedFile, resolver: &mut FileResolver, ns: &mut ast::Nam
     }
 
     // now check state mutability for all contracts
-    mutability::mutablity(file_no, ns);
+    mutability::mutability(file_no, ns);
 }
 
 /// Find import file, resolve it by calling sema and add it to the namespace

src/sema/mutability.rs

@@ -4,9 +4,10 @@ use super::ast::{
 };
 use super::diagnostics;
 use crate::parser::pt;
+use crate::sema::yul::ast::{YulExpression, YulStatement};
 
-/// check state mutablity
-pub fn mutablity(file_no: usize, ns: &mut Namespace) {
+/// check state mutability
+pub fn mutability(file_no: usize, ns: &mut Namespace) {
     if !diagnostics::any_errors(&ns.diagnostics) {
         for func in &ns.functions {
             if func.loc.file_no() != file_no {
@@ -59,6 +60,14 @@ impl<'a> StateCheck<'a> {
 
         self.does_read_state = true;
     }
+
+    //TODO: This is a temporary solution while inline assembly is not supported in codegen
+    fn has_yul(&mut self, loc: &pt::Loc) {
+        self.diagnostics.push(Diagnostic::error(
+            *loc,
+            "inline assembly is not yet supported".to_string(),
+        ));
+    }
 }
 
 fn check_mutability(func: &Function, ns: &Namespace) -> Vec<Diagnostic> {
@@ -215,8 +224,12 @@ fn recurse_statements(stmts: &[Statement], state: &mut StateCheck) {
             }
             Statement::Emit { loc, .. } => state.write(loc),
             Statement::Break(_) | Statement::Continue(_) | Statement::Underscore(_) => (),
-            Statement::Assembly(..) => {
-                unimplemented!("Assembly block mutability not ready yet");
+            Statement::Assembly(inline_assembly, _) => {
+                state.has_yul(&inline_assembly.loc);
+                for item in &inline_assembly.functions {
+                    recurse_yul_statements(&item.body, state);
+                }
+                recurse_yul_statements(&inline_assembly.body, state);
             }
         }
     }
@@ -313,3 +326,82 @@ fn write_expression(expr: &Expression, state: &mut StateCheck) -> bool {
 
     true
 }
+
+fn recurse_yul_statements(stmts: &[YulStatement], state: &mut StateCheck) {
+    for stmt in stmts {
+        match stmt {
+            YulStatement::FunctionCall(_, _, _, args) => {
+                for arg in args {
+                    arg.recurse(state, check_expression_mutability_yul);
+                }
+            }
+            YulStatement::BuiltInCall(loc, _, builtin_ty, args) => {
+                if builtin_ty.read_state() {
+                    state.read(loc);
+                } else if builtin_ty.modify_state() {
+                    state.write(loc);
+                }
+                for arg in args {
+                    arg.recurse(state, check_expression_mutability_yul);
+                }
+            }
+            YulStatement::Block(block) => {
+                recurse_yul_statements(&block.body, state);
+            }
+            YulStatement::Assignment(_, _, _, value)
+            | YulStatement::VariableDeclaration(_, _, _, Some(value)) => {
+                value.recurse(state, check_expression_mutability_yul);
+            }
+            YulStatement::IfBlock(_, _, condition, block) => {
+                condition.recurse(state, check_expression_mutability_yul);
+                recurse_yul_statements(&block.body, state);
+            }
+            YulStatement::Switch {
+                condition,
+                cases,
+                default,
+                ..
+            } => {
+                condition.recurse(state, check_expression_mutability_yul);
+                for item in cases {
+                    item.condition
+                        .recurse(state, check_expression_mutability_yul);
+                    recurse_yul_statements(&item.block.body, state);
+                }
+
+                if let Some(block) = default {
+                    recurse_yul_statements(&block.body, state);
+                }
+            }
+            YulStatement::For {
+                init_block,
+                condition,
+                post_block,
+                execution_block,
+                ..
+            } => {
+                recurse_yul_statements(&init_block.body, state);
+                condition.recurse(state, check_expression_mutability_yul);
+                recurse_yul_statements(&post_block.body, state);
+                recurse_yul_statements(&execution_block.body, state);
+            }
+
+            _ => (),
+        }
+    }
+}
+
+fn check_expression_mutability_yul(expr: &YulExpression, state: &mut StateCheck) -> bool {
+    match expr {
+        YulExpression::BuiltInCall(loc, builtin_ty, _) => {
+            if builtin_ty.read_state() {
+                state.read(loc);
+            } else if builtin_ty.modify_state() {
+                state.write(loc);
+            }
+            true
+        }
+        YulExpression::FunctionCall(..) => true,
+        _ => false,
+    }
+}

src/sema/statements.rs

@@ -804,12 +804,6 @@ fn statement(
             dialect,
             block,
         } => {
-            // TODO: Remove this error when sema is ready
-            ns.diagnostics.push(Diagnostic::error(
-                *loc,
-                format!("evm assembly not supported on target {}", ns.target),
-            ));
-
             if dialect.is_some() && dialect.as_ref().unwrap().string != "evmasm" {
                 ns.diagnostics.push(Diagnostic::error(
                     dialect.as_ref().unwrap().loc,

src/sema/yul/ast.rs

@@ -9,14 +9,15 @@ use std::sync::Arc;
 #[derive(Debug, Clone)]
 pub struct InlineAssembly {
     pub loc: pt::Loc,
-    pub body: Vec<(YulStatement, bool)>,
+    pub body: Vec<YulStatement>,
     pub functions: Vec<YulFunction>,
 }
 
 #[derive(Debug, Clone)]
 pub struct YulBlock {
     pub loc: pt::Loc,
-    pub body: Vec<(YulStatement, bool)>,
+    pub reachable: bool,
+    pub body: Vec<YulStatement>,
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -79,7 +80,7 @@ pub struct YulFunction {
     pub name: String,
     pub params: Arc<Vec<YulFunctionParameter>>,
     pub returns: Arc<Vec<YulFunctionParameter>>,
-    pub body: Vec<(YulStatement, bool)>,
+    pub body: Vec<YulStatement>,
     pub symtable: Symtable,
     pub called: bool,
 }
@@ -93,28 +94,30 @@ pub struct YulFunctionParameter {
 
 #[derive(Clone, Debug)]
 pub enum YulStatement {
-    FunctionCall(pt::Loc, usize, Vec<YulExpression>),
-    BuiltInCall(pt::Loc, YulBuiltInFunction, Vec<YulExpression>),
+    FunctionCall(pt::Loc, bool, usize, Vec<YulExpression>),
+    BuiltInCall(pt::Loc, bool, YulBuiltInFunction, Vec<YulExpression>),
     Block(Box<YulBlock>),
-    VariableDeclaration(pt::Loc, Vec<usize>, Option<YulExpression>),
-    Assignment(pt::Loc, Vec<YulExpression>, YulExpression),
-    IfBlock(pt::Loc, YulExpression, Box<YulBlock>),
+    VariableDeclaration(pt::Loc, bool, Vec<usize>, Option<YulExpression>),
+    Assignment(pt::Loc, bool, Vec<YulExpression>, YulExpression),
+    IfBlock(pt::Loc, bool, YulExpression, Box<YulBlock>),
     Switch {
         loc: pt::Loc,
+        reachable: bool,
         condition: YulExpression,
         cases: Vec<CaseBlock>,
         default: Option<YulBlock>,
     },
     For {
         loc: pt::Loc,
+        reachable: bool,
         init_block: YulBlock,
         condition: YulExpression,
         post_block: YulBlock,
         execution_block: YulBlock,
     },
-    Leave(pt::Loc),
-    Break(pt::Loc),
-    Continue(pt::Loc),
+    Leave(pt::Loc, bool),
+    Break(pt::Loc, bool),
+    Continue(pt::Loc, bool),
 }
 
 #[derive(Debug, Clone)]
@@ -123,3 +126,24 @@ pub struct CaseBlock {
     pub condition: YulExpression,
     pub block: YulBlock,
 }
+
+impl YulExpression {
+    /// Recurse over the expressions
+    pub fn recurse<T>(&self, cx: &mut T, f: fn(expr: &YulExpression, ctx: &mut T) -> bool) {
+        if !f(self, cx) {
+            return;
+        }
+        match self {
+            YulExpression::BuiltInCall(_, _, args) | YulExpression::FunctionCall(_, _, args) => {
+                for arg in args {
+                    arg.recurse(cx, f);
+                }
+            }
+            YulExpression::MemberAccess(_, expr, _) => {
+                expr.recurse(cx, f);
+            }
+
+            _ => (),
+        }
+    }
+}

src/sema/yul/block.rs

@@ -14,7 +14,7 @@ pub fn resolve_yul_block(
     loc: &pt::Loc,
     statements: &[pt::YulStatement],
     context: &ExprContext,
-    mut reachable: bool,
+    reachable: bool,
     loop_scope: &mut LoopScopes,
     function_table: &mut FunctionsTable,
     symtable: &mut Symtable,
@@ -23,7 +23,7 @@ pub fn resolve_yul_block(
     function_table.new_scope();
     symtable.new_scope();
 
-    let (body, local_reachable) = process_statements(
+    let (body, mut next_reachable) = process_statements(
         statements,
         context,
         reachable,
@@ -33,12 +33,18 @@ pub fn resolve_yul_block(
         ns,
     );
 
-    reachable &= local_reachable;
-
+    next_reachable &= reachable;
     symtable.leave_scope();
     function_table.leave_scope(ns);
 
-    (YulBlock { loc: *loc, body }, reachable)
+    (
+        YulBlock {
+            loc: *loc,
+            reachable,
+            body,
+        },
+        next_reachable,
+    )
 }
 
 /// Resolves an array of yul statements.
@@ -52,7 +58,7 @@ pub(crate) fn process_statements(
     loop_scope: &mut LoopScopes,
     functions_table: &mut FunctionsTable,
     ns: &mut Namespace,
-) -> (Vec<(YulStatement, bool)>, bool) {
+) -> (Vec<YulStatement>, bool) {
     let mut func_count: usize = 0;
     for item in statements {
         if let pt::YulStatement::FunctionDefinition(fun_def) = item {
@@ -71,7 +77,7 @@ pub(crate) fn process_statements(
         }
     }
 
-    let mut body: Vec<(YulStatement, bool)> = Vec::with_capacity(statements.len() - func_count);
+    let mut body: Vec<YulStatement> = Vec::with_capacity(statements.len() - func_count);
     let mut has_unreachable = false;
     for item in statements {
         match resolve_yul_statement(

src/sema/yul/builtin.rs

@@ -192,6 +192,51 @@ impl YulBuiltInFunction {
         let index = self as usize;
         &YUL_BUILTIN[index]
     }
+
+    pub(crate) fn modify_state(&self) -> bool {
+        matches!(
+            self,
+            YulBuiltInFunction::SStore
+                | YulBuiltInFunction::Log0
+                | YulBuiltInFunction::Log1
+                | YulBuiltInFunction::Log2
+                | YulBuiltInFunction::Log3
+                | YulBuiltInFunction::Log4
+                | YulBuiltInFunction::Create
+                | YulBuiltInFunction::Call
+                | YulBuiltInFunction::CallCode
+                | YulBuiltInFunction::DelegateCall
+                | YulBuiltInFunction::Create2
+                | YulBuiltInFunction::SelfDestruct
+        )
+    }
+
+    pub(crate) fn read_state(&self) -> bool {
+        matches!(
+            self,
+            YulBuiltInFunction::Address
+                | YulBuiltInFunction::SelfBalance
+                | YulBuiltInFunction::Balance
+                | YulBuiltInFunction::Origin
+                | YulBuiltInFunction::Caller
+                | YulBuiltInFunction::CallValue
+                | YulBuiltInFunction::ChainId
+                | YulBuiltInFunction::BaseFee
+                | YulBuiltInFunction::Gas
+                | YulBuiltInFunction::GasPrice
+                | YulBuiltInFunction::ExtCodeSize
+                | YulBuiltInFunction::ExtCodeCopy
+                | YulBuiltInFunction::ExtCodeHash
+                | YulBuiltInFunction::BlockHash
+                | YulBuiltInFunction::CoinBase
+                | YulBuiltInFunction::Timestamp
+                | YulBuiltInFunction::Number
+                | YulBuiltInFunction::Difficulty
+                | YulBuiltInFunction::GasLimit
+                | YulBuiltInFunction::StaticCall
+                | YulBuiltInFunction::SLoad
+        )
+    }
 }
 
 impl ToString for YulBuiltInFunction {
@@ -503,7 +548,7 @@ static YUL_BUILTIN: [YulBuiltinPrototype; 76] =
         },
         YulBuiltinPrototype {
             name: "balance",
-            no_args: 2,
+            no_args: 1,
             no_returns: 1,
             doc: "balance(a) returns the wei balance at address a",
             ty: YulBuiltInFunction::Balance,

src/sema/yul/for_loop.rs

@@ -12,7 +12,7 @@ use solang_parser::{pt, Diagnostic};
 pub(crate) fn resolve_for_loop(
     yul_for: &pt::YulFor,
     context: &ExprContext,
-    mut reachable: bool,
+    reachable: bool,
     loop_scope: &mut LoopScopes,
     symtable: &mut Symtable,
     function_table: &mut FunctionsTable,
@@ -20,16 +20,17 @@ pub(crate) fn resolve_for_loop(
 ) -> Result<(YulStatement, bool), ()> {
     symtable.new_scope();
     function_table.new_scope();
-
+    let mut next_reachable = reachable;
     let resolved_init_block = resolve_for_init_block(
         &yul_for.init_block,
         context,
+        next_reachable,
         loop_scope,
         symtable,
         function_table,
         ns,
     )?;
-    reachable &= resolved_init_block.1;
+    next_reachable &= resolved_init_block.1;
 
     let resolved_cond =
         resolve_condition(&yul_for.condition, context, symtable, function_table, ns)?;
@@ -40,13 +41,13 @@ pub(crate) fn resolve_for_loop(
         &yul_for.execution_block.loc,
         &yul_for.execution_block.statements,
         context,
-        reachable,
+        next_reachable,
         loop_scope,
         function_table,
         symtable,
         ns,
     );
-    reachable &= resolved_exec_block.1;
+    next_reachable &= resolved_exec_block.1;
 
     loop_scope.leave_scope();
 
@@ -54,7 +55,7 @@ pub(crate) fn resolve_for_loop(
         &yul_for.post_block.loc,
         &yul_for.post_block.statements,
         context,
-        reachable,
+        next_reachable,
         loop_scope,
         function_table,
         symtable,
@@ -67,6 +68,7 @@ pub(crate) fn resolve_for_loop(
     Ok((
         YulStatement::For {
             loc: yul_for.loc,
+            reachable,
             init_block: resolved_init_block.0,
             condition: resolved_cond,
             post_block: resolved_post_block.0,
@@ -81,6 +83,7 @@ pub(crate) fn resolve_for_loop(
 fn resolve_for_init_block(
     init_block: &pt::YulBlock,
     context: &ExprContext,
+    reachable: bool,
     loop_scope: &mut LoopScopes,
     symtable: &mut Symtable,
     function_table: &mut FunctionsTable,
@@ -96,10 +99,10 @@ fn resolve_for_init_block(
         }
     }
 
-    let (body, reachable) = process_statements(
+    let (body, next_reachable) = process_statements(
         &init_block.statements,
         context,
-        true,
+        reachable,
         symtable,
         loop_scope,
         function_table,
@@ -109,8 +112,9 @@ fn resolve_for_init_block(
     Ok((
         YulBlock {
             loc: init_block.loc,
+            reachable,
             body,
         },
-        reachable,
+        next_reachable,
     ))
 }

src/sema/yul/statements.rs

@@ -20,16 +20,22 @@ pub(crate) fn resolve_yul_statement(
     reachable: bool,
     loop_scope: &mut LoopScopes,
     symtable: &mut Symtable,
-    resolved_statements: &mut Vec<(YulStatement, bool)>,
+    resolved_statements: &mut Vec<YulStatement>,
     function_table: &mut FunctionsTable,
     ns: &mut Namespace,
 ) -> Result<bool, ()> {
     match statement {
         pt::YulStatement::FunctionDefinition(_) => Ok(true),
         pt::YulStatement::FunctionCall(func_call) => {
-            let data =
-                resolve_top_level_function_call(func_call, function_table, context, symtable, ns)?;
-            resolved_statements.push((data.0, reachable));
+            let data = resolve_top_level_function_call(
+                func_call,
+                reachable,
+                function_table,
+                context,
+                symtable,
+                ns,
+            )?;
+            resolved_statements.push(data.0);
             Ok(data.1)
         }
 
@@ -44,49 +50,50 @@ pub(crate) fn resolve_yul_statement(
                 symtable,
                 ns,
             );
-            resolved_statements.push((YulStatement::Block(Box::new(data.0)), reachable));
+            resolved_statements.push(YulStatement::Block(Box::new(data.0)));
             Ok(data.1)
         }
 
         pt::YulStatement::VariableDeclaration(loc, variables, initializer) => {
-            resolved_statements.push((
-                resolve_variable_declaration(
-                    loc,
-                    variables,
-                    initializer,
-                    function_table,
-                    context,
-                    symtable,
-                    ns,
-                )?,
+            resolved_statements.push(resolve_variable_declaration(
+                loc,
+                variables,
+                initializer,
                 reachable,
-            ));
+                function_table,
+                context,
+                symtable,
+                ns,
+            )?);
             Ok(true)
         }
 
         pt::YulStatement::Assign(loc, lhs, rhs) => {
-            resolved_statements.push((
-                resolve_assignment(loc, lhs, rhs, context, function_table, symtable, ns)?,
+            resolved_statements.push(resolve_assignment(
+                loc,
+                lhs,
+                rhs,
+                context,
                 reachable,
-            ));
+                function_table,
+                symtable,
+                ns,
+            )?);
             Ok(true)
         }
 
         pt::YulStatement::If(loc, condition, body) => {
-            resolved_statements.push((
-                resolve_if_block(
-                    loc,
-                    condition,
-                    &body.statements,
-                    context,
-                    reachable,
-                    loop_scope,
-                    function_table,
-                    symtable,
-                    ns,
-                )?,
+            resolved_statements.push(resolve_if_block(
+                loc,
+                condition,
+                &body.statements,
+                context,
                 reachable,
-            ));
+                loop_scope,
+                function_table,
+                symtable,
+                ns,
+            )?);
             Ok(true)
         }
 
@@ -100,13 +107,13 @@ pub(crate) fn resolve_yul_statement(
                 symtable,
                 ns,
             )?;
-            resolved_statements.push((resolved_switch.0, reachable));
+            resolved_statements.push(resolved_switch.0);
             Ok(resolved_switch.1)
         }
 
         pt::YulStatement::Break(loc) => {
             if loop_scope.do_break() {
-                resolved_statements.push((YulStatement::Break(*loc), reachable));
+                resolved_statements.push(YulStatement::Break(*loc, reachable));
                 Ok(false)
             } else {
                 ns.diagnostics.push(Diagnostic::error(
@@ -119,7 +126,7 @@ pub(crate) fn resolve_yul_statement(
 
         pt::YulStatement::Continue(loc) => {
             if loop_scope.do_continue() {
-                resolved_statements.push((YulStatement::Continue(*loc), reachable));
+                resolved_statements.push(YulStatement::Continue(*loc, reachable));
                 Ok(false)
             } else {
                 ns.diagnostics.push(Diagnostic::error(
@@ -138,7 +145,7 @@ pub(crate) fn resolve_yul_statement(
                 ));
                 return Err(());
             }
-            resolved_statements.push((YulStatement::Leave(*loc), reachable));
+            resolved_statements.push(YulStatement::Leave(*loc, reachable));
             Ok(false)
         }
 
@@ -152,7 +159,7 @@ pub(crate) fn resolve_yul_statement(
                 function_table,
                 ns,
             )?;
-            resolved_statements.push((resolved_for.0, reachable));
+            resolved_statements.push(resolved_for.0);
             Ok(resolved_for.1)
         }
     }
@@ -161,6 +168,7 @@ pub(crate) fn resolve_yul_statement(
 /// Top-leve function calls must not return anything, so there is a special function to handle them.
 fn resolve_top_level_function_call(
     func_call: &pt::YulFunctionCall,
+    reachable: bool,
     function_table: &mut FunctionsTable,
     context: &ExprContext,
     symtable: &mut Symtable,
@@ -177,7 +185,7 @@ fn resolve_top_level_function_call(
                 return Err(());
             }
             Ok((
-                YulStatement::BuiltInCall(loc, ty, args),
+                YulStatement::BuiltInCall(loc, reachable, ty, args),
                 !func_prototype.stops_execution,
             ))
         }
@@ -190,7 +198,10 @@ fn resolve_top_level_function_call(
                 ));
                 return Err(());
             }
-            Ok((YulStatement::FunctionCall(loc, function_no, args), true))
+            Ok((
+                YulStatement::FunctionCall(loc, reachable, function_no, args),
+                true,
+            ))
         }
 
         Ok(_) => {
@@ -205,6 +216,7 @@ fn resolve_variable_declaration(
     loc: &pt::Loc,
     variables: &[YulTypedIdentifier],
     initializer: &Option<pt::YulExpression>,
+    reachable: bool,
     function_table: &mut FunctionsTable,
     context: &ExprContext,
     symtable: &mut Symtable,
@@ -278,6 +290,7 @@ fn resolve_variable_declaration(
 
     Ok(YulStatement::VariableDeclaration(
         *loc,
+        reachable,
         added_variables,
         resolved_init,
     ))
@@ -288,6 +301,7 @@ fn resolve_assignment(
     lhs: &[pt::YulExpression],
     rhs: &pt::YulExpression,
     context: &ExprContext,
+    reachable: bool,
     function_table: &mut FunctionsTable,
     symtable: &mut Symtable,
     ns: &mut Namespace,
@@ -316,7 +330,12 @@ fn resolve_assignment(
         ns,
     );
 
-    Ok(YulStatement::Assignment(*loc, resolved_lhs, resolved_rhs))
+    Ok(YulStatement::Assignment(
+        *loc,
+        reachable,
+        resolved_lhs,
+        resolved_rhs,
+    ))
 }
 
 /// Checks the the left hand side of an assignment is compatible with it right hand side
@@ -397,6 +416,7 @@ fn resolve_if_block(
 
     Ok(YulStatement::IfBlock(
         *loc,
+        reachable,
         resolved_condition,
         Box::new(resolved_block.0),
     ))

src/sema/yul/switch.rs

@@ -14,7 +14,7 @@ use solang_parser::{pt, Diagnostic};
 pub(crate) fn resolve_switch(
     yul_switch: &pt::YulSwitch,
     context: &ExprContext,
-    mut reachable: bool,
+    reachable: bool,
     function_table: &mut FunctionsTable,
     loop_scope: &mut LoopScopes,
     symtable: &mut Symtable,
@@ -24,19 +24,20 @@ pub(crate) fn resolve_switch(
         resolve_condition(&yul_switch.condition, context, symtable, function_table, ns)?;
     let mut default_block: Option<YulBlock> = None;
     let mut case_blocks: Vec<CaseBlock> = Vec::with_capacity(yul_switch.cases.len());
+    let mut next_reachable = reachable;
     for item in &yul_switch.cases {
         let block_reachable = resolve_case_or_default(
             item,
             &mut default_block,
             &mut case_blocks,
             context,
-            reachable,
+            next_reachable,
             function_table,
             loop_scope,
             symtable,
             ns,
         )?;
-        reachable |= block_reachable;
+        next_reachable |= block_reachable;
     }
 
     if yul_switch.default.is_some() && default_block.is_some() {
@@ -51,25 +52,26 @@ pub(crate) fn resolve_switch(
             &mut default_block,
             &mut case_blocks,
             context,
-            reachable,
+            next_reachable,
             function_table,
             loop_scope,
             symtable,
             ns,
         )?;
-        reachable |= block_reachable;
+        next_reachable |= block_reachable;
     } else if yul_switch.default.is_none() && default_block.is_none() {
-        reachable |= true;
+        next_reachable |= true;
     }
 
     Ok((
         YulStatement::Switch {
             loc: yul_switch.loc,
+            reachable,
             condition: resolved_condition,
             cases: case_blocks,
             default: default_block,
         },
-        reachable,
+        next_reachable,
     ))
 }
 

src/sema/yul/tests/block.rs

@@ -51,7 +51,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
@@ -113,7 +113,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -171,7 +171,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -242,7 +242,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 
     let file = r#"
@@ -273,7 +273,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -324,7 +324,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,

src/sema/yul/tests/expression.rs

@@ -1066,7 +1066,7 @@ contract testTypes {
     }
 
     test tt1;
-    function testAsm(uint[] calldata vl) public pure {
+    function testAsm(uint[] calldata vl) public view {
         test storage tt2 = tt1;
         assembly {
             {
@@ -1092,7 +1092,7 @@ contract testTypes {
     }
 
     test tt1;
-    function testAsm(uint[] calldata vl) public pure {
+    function testAsm(uint[] calldata vl) public view {
         test storage tt2 = tt1;
         assembly {
             {
@@ -1111,7 +1111,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
@@ -1419,7 +1419,7 @@ contract C {
     assert_eq!(ns.diagnostics.len(), 2);
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 
     assert!(assert_message_in_diagnostics(

src/sema/yul/tests/for_loop.rs

@@ -121,7 +121,7 @@ contract testTypes {
 
     let file = r#"
 contract testTypes {
-    function testAsm() public {
+    function testAsm() public pure {
         assembly {
 
             let a := 0
@@ -148,7 +148,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,

src/sema/yul/tests/mod.rs

@@ -8,6 +8,7 @@ mod block;
 mod expression;
 mod for_loop;
 mod functions;
+mod mutability;
 mod statements;
 mod switch;
 mod types;

src/sema/yul/tests/mutability.rs

@@ -0,0 +1,444 @@
+use crate::sema::yul::tests::{assert_message_in_diagnostics, parse};
+
+#[test]
+fn inside_function() {
+    let file = r#"
+        contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly
+            {
+                function foo(a, b) -> ret {
+                    let x := address()
+                    ret := add(sub(b, x), a)
+                }
+            }
+        }
+    }
+    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn inside_argument() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                foo(balance(4), 5)
+                function foo(a, b) {
+                    let x := 5
+                    let ret := add(sub(b, x), a)
+                }
+            }
+        }
+    }
+}
+    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                return(balance(4), 5)
+                function foo(a, b) {
+                    let x := 5
+                    let ret := add(sub(b, x), a)
+                }
+            }
+        }
+    }
+}
+    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn block() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                {
+                    foo(balance(4), 5)
+                }
+                function foo(a, b) {
+                    let x := 5
+                    let ret := add(sub(b, x), a)
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn assign_declaration() {
+    let file = r#"
+        contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                function foo(a, b) -> ret {
+                    let x := 5
+                    ret := balance(x)
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                function foo(a, b) -> ret {
+                    let x := balance(4)
+                    ret := x
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn if_block() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                if balance(5) {
+                    return(0, 1)
+                }
+            }
+        }
+    }
+}    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                let x := 2
+                if gt(x, 4) {
+                    x := balance(4)
+                    return(0, x)
+                }
+            }
+        }
+    }
+}    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn switch() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                switch balance(4)
+                case 0 {let x := 5}
+                default {
+                    let y := 4
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                let y := 9
+                switch y
+                case 0 {let x := balance(4)}
+                default {
+                    let p := 4
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                let y := 6
+                switch y
+                case 0 {let x := 5}
+                default {
+                    let p := balance(3)
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn test_for() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := balance(4)} gt(i, 0) {i := sub(i, 2)} {
+                    let x := shr(i, 6)
+                }
+            }
+        }
+    }
+}    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := 6} balance(4) {i := sub(i, 2)} {
+                    let x := shr(i, 6)
+                }
+            }
+        }
+    }
+}    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := 6} gt(i, 0) {i := balance(4)} {
+                    let x := shr(i, 6)
+                }
+            }
+        }
+    }
+}
+    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := 6} gt(i, 0) {i := sub(i, 2)} {
+                    let x := balance(4)
+                }
+            }
+        }
+    }
+}    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+}
+
+#[test]
+fn pure_function() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := balance(4)} gt(i, 0) {i := sub(i, 2)} {
+                    let x := shr(i, 6)
+                }
+            }
+        }
+    }
+}    "#;
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression reads from state"
+    ));
+
+    let file = r#"
+        contract testTypes {
+    function testAsm(uint[] calldata vl) public pure {
+        assembly {
+            {
+                for {let i := 6} gt(i, 0) {i := sub(i, 2)} {
+                    log0(i, 0)
+                }
+            }
+        }
+    }
+}    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘pure’ but this expression writes to state"
+    ));
+}
+
+#[test]
+fn view_function() {
+    let file = r#"
+    contract testTypes {
+    function testAsm(uint[] calldata vl) public view {
+        assembly {
+            {
+                for {let i := 6} gt(i, 0) {i := sub(i, 2)} {
+                    let y := create(3, 2, 1)
+                }
+            }
+        }
+    }
+}
+    "#;
+
+    let ns = parse(file);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "function declared ‘view’ but this expression writes to state"
+    ));
+
+    let file = r#"
+    contract testTypes {
+    function testAsm() public view {
+        assembly {
+            {
+                for {let i := 6} gt(i, 0) {} {
+                    return(selfbalance(), i)
+                }
+            }
+        }
+    }
+}    "#;
+
+    let ns = parse(file);
+    assert_eq!(ns.diagnostics.len(), 2);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "found contract ‘testTypes’"
+    ));
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "inline assembly is not yet supported"
+    ));
+}
+
+#[test]
+fn function_without_modifier() {
+    let file = r#"
+    contract testTypes {
+    function testAsm() public {
+        assembly {
+            {
+                for {let i := caller()} gt(i, 0) {} {
+                    return(create(1, 2, 3), i)
+                }
+            }
+        }
+    }
+}
+    "#;
+    let ns = parse(file);
+    assert_eq!(ns.diagnostics.len(), 2);
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "found contract ‘testTypes’"
+    ));
+    assert!(assert_message_in_diagnostics(
+        &ns.diagnostics,
+        "inline assembly is not yet supported"
+    ));
+}

src/sema/yul/tests/statements.rs

@@ -205,7 +205,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -254,7 +254,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -312,7 +312,7 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }
 
@@ -370,6 +370,6 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }

src/sema/yul/tests/switch.rs

@@ -108,6 +108,6 @@ contract testTypes {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }

src/sema/yul/tests/unused_variable.rs

@@ -120,6 +120,6 @@ fn correct_contracts() {
     ));
     assert!(assert_message_in_diagnostics(
         &ns.diagnostics,
-        "evm assembly not supported on target solana"
+        "inline assembly is not yet supported"
     ));
 }

tests/contract_testcases/solana/assembly/function_cal_cond.dot → tests/contract_testcases/solana/yul/function_cal_cond.dot

@@ -1,79 +1,79 @@
-strict digraph "tests/contract_testcases/solana/assembly/function_cal_cond.sol" {
-	contract [label="contract testTypes\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:1:1-20"]
-	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:2:5-35\nsignature testAsm()\nvisibility public\nmutability pure"]
-	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:3:9-33:10"]
-	yul_function_definition [label="function definition tryThis\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:5:17-13:18"]
-	yul_function_parameter [label="function parameter uint256: b\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:5:34-35"]
-	yul_function_parameter_7 [label="function parameter uint256: a\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:5:37-38"]
-	yul_function_return [label="return parameter uint256: c\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:5:43-44"]
-	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:6:21-35"]
-	yul_variable [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:6:21-22"]
-	yul_builtin_call [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:6:26-35"]
-	yul_variable_12 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:6:30-31"]
-	yul_number_literal [label="uint256 literal: 4\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:6:33-34"]
-	if [label="yul if\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:7:21-9:22"]
-	yul_builtin_call_15 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:7:24-32"]
-	yul_variable_16 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:7:27-28"]
-	yul_number_literal_17 [label="uint256 literal: 5\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:7:30-31"]
-	assembly_block [label="assembly block\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:7:21-9:22"]
-	leave [label="leave\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:8:25-30"]
-	yul_assignment_20 [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:10:21-35"]
-	yul_variable_21 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:10:21-22"]
-	yul_builtin_call_22 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:10:26-35"]
-	yul_variable_23 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:10:30-31"]
-	yul_number_literal_24 [label="uint256 literal: 6\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:10:33-34"]
-	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:11:21-39"]
-	yul_variable_26 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:11:21-22"]
-	yul_function_call [label="yul function call ‘tryThat‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:11:26-33"]
-	yul_variable_28 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:11:34-35"]
-	yul_number_literal_29 [label="uint256 literal: 2\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:11:37-38"]
-	yul_builtin_call_30 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:12:21-33"]
-	yul_variable_31 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:12:28-29"]
-	yul_number_literal_32 [label="uint256 literal: 0\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:12:31-32"]
-	yul_function_definition_33 [label="function definition tryThat\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:23:17-30:18"]
-	yul_function_parameter_34 [label="function parameter uint256: b\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:23:34-35"]
-	yul_function_parameter_35 [label="function parameter uint256: a\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:23:37-38"]
-	yul_function_return_36 [label="return parameter uint256: c\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:23:43-44"]
-	yul_assignment_37 [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:24:21-35"]
-	yul_variable_38 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:24:21-22"]
-	yul_builtin_call_39 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:24:26-35"]
-	yul_variable_40 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:24:30-31"]
-	yul_number_literal_41 [label="uint256 literal: 4\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:24:33-34"]
-	if_42 [label="yul if\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:25:21-27:22"]
-	yul_builtin_call_43 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:25:24-32"]
-	yul_variable_44 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:25:27-28"]
-	yul_number_literal_45 [label="uint256 literal: 5\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:25:30-31"]
-	assembly_block_46 [label="assembly block\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:25:21-27:22"]
-	leave_47 [label="leave\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:26:25-30"]
-	yul_assignment_48 [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:28:21-27"]
-	yul_variable_49 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:28:21-22"]
-	yul_number_literal_50 [label="uint256 literal: 5\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:28:26-27"]
-	yul_builtin_call_51 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:29:21-33"]
-	yul_variable_52 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:29:28-29"]
-	yul_number_literal_53 [label="uint256 literal: 0\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:29:31-32"]
-	yul_function_definition_54 [label="function definition foo\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:16:21-18:22"]
-	yul_function_parameter_55 [label="function parameter uint256: d\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:16:34-35"]
-	yul_function_return_56 [label="return parameter uint256: e\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:16:40-41"]
-	yul_assignment_57 [label="yul assignment\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:17:25-39"]
-	yul_variable_58 [label="yul variable: e\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:17:25-26"]
-	yul_builtin_call_59 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:17:30-39"]
-	yul_variable_60 [label="yul variable: d\nuint256\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:17:34-35"]
-	yul_number_literal_61 [label="uint256 literal: 3\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:17:37-38"]
-	assembly_block_62 [label="assembly block\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:4:13-32:14"]
-	assembly_block_63 [label="assembly block\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:15:17-21:18"]
-	yul_builtin_call_64 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:21-50"]
-	yul_function_call_65 [label="yul function call ‘tryThis‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:28-35"]
-	yul_function_call_66 [label="yul function call ‘foo‘\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:36-39"]
-	yul_number_literal_67 [label="uint256 literal: 3\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:40-41"]
-	yul_number_literal_68 [label="uint256 literal: 2\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:44-45"]
-	yul_number_literal_69 [label="uint256 literal: 4\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:20:48-49"]
-	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:31:17-27"]
-	var_decl_item [label="yul variable declaration uint256 x\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:31:21-22"]
-	yul_number_literal_72 [label="uint256 literal: 5\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:31:26-27"]
-	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:1:1-20"]
-	diagnostic_75 [label="evm assembly not supported on target solana\nlevel Error\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:3:9-33:10"]
-	diagnostic_76 [label="unreachable yul statement\nlevel Warning\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:31:17-27"]
-	diagnostic_77 [label="yul variable ‘x‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/assembly/function_cal_cond.sol:31:21-22"]
+strict digraph "tests/contract_testcases/solana/yul/function_cal_cond.sol" {
+	contract [label="contract testTypes\ntests/contract_testcases/solana/yul/function_cal_cond.sol:1:1-20"]
+	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/solana/yul/function_cal_cond.sol:2:5-35\nsignature testAsm()\nvisibility public\nmutability pure"]
+	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/function_cal_cond.sol:3:9-33:10"]
+	yul_function_definition [label="function definition tryThis\ntests/contract_testcases/solana/yul/function_cal_cond.sol:5:17-13:18"]
+	yul_function_parameter [label="function parameter uint256: b\ntests/contract_testcases/solana/yul/function_cal_cond.sol:5:34-35"]
+	yul_function_parameter_7 [label="function parameter uint256: a\ntests/contract_testcases/solana/yul/function_cal_cond.sol:5:37-38"]
+	yul_function_return [label="return parameter uint256: c\ntests/contract_testcases/solana/yul/function_cal_cond.sol:5:43-44"]
+	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:21-35"]
+	yul_variable [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:21-22"]
+	yul_builtin_call [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:26-35"]
+	yul_variable_12 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:30-31"]
+	yul_number_literal [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:6:33-34"]
+	if [label="yul if\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:21-9:22"]
+	yul_builtin_call_15 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:24-32"]
+	yul_variable_16 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:27-28"]
+	yul_number_literal_17 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:30-31"]
+	assembly_block [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:7:21-9:22"]
+	leave [label="leave\ntests/contract_testcases/solana/yul/function_cal_cond.sol:8:25-30"]
+	yul_assignment_20 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:21-35"]
+	yul_variable_21 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:21-22"]
+	yul_builtin_call_22 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:26-35"]
+	yul_variable_23 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:30-31"]
+	yul_number_literal_24 [label="uint256 literal: 6\ntests/contract_testcases/solana/yul/function_cal_cond.sol:10:33-34"]
+	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:21-39"]
+	yul_variable_26 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:21-22"]
+	yul_function_call [label="yul function call ‘tryThat‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:26-33"]
+	yul_variable_28 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:34-35"]
+	yul_number_literal_29 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/function_cal_cond.sol:11:37-38"]
+	yul_builtin_call_30 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:21-33"]
+	yul_variable_31 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:28-29"]
+	yul_number_literal_32 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/function_cal_cond.sol:12:31-32"]
+	yul_function_definition_33 [label="function definition tryThat\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:17-30:18"]
+	yul_function_parameter_34 [label="function parameter uint256: b\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:34-35"]
+	yul_function_parameter_35 [label="function parameter uint256: a\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:37-38"]
+	yul_function_return_36 [label="return parameter uint256: c\ntests/contract_testcases/solana/yul/function_cal_cond.sol:23:43-44"]
+	yul_assignment_37 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:21-35"]
+	yul_variable_38 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:21-22"]
+	yul_builtin_call_39 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:26-35"]
+	yul_variable_40 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:30-31"]
+	yul_number_literal_41 [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:24:33-34"]
+	if_42 [label="yul if\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:21-27:22"]
+	yul_builtin_call_43 [label="yul builtin call ‘gt‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:24-32"]
+	yul_variable_44 [label="yul variable: a\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:27-28"]
+	yul_number_literal_45 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:30-31"]
+	assembly_block_46 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:25:21-27:22"]
+	leave_47 [label="leave\ntests/contract_testcases/solana/yul/function_cal_cond.sol:26:25-30"]
+	yul_assignment_48 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:21-27"]
+	yul_variable_49 [label="yul variable: c\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:21-22"]
+	yul_number_literal_50 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:28:26-27"]
+	yul_builtin_call_51 [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:21-33"]
+	yul_variable_52 [label="yul variable: b\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:28-29"]
+	yul_number_literal_53 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/function_cal_cond.sol:29:31-32"]
+	yul_function_definition_54 [label="function definition foo\ntests/contract_testcases/solana/yul/function_cal_cond.sol:16:21-18:22"]
+	yul_function_parameter_55 [label="function parameter uint256: d\ntests/contract_testcases/solana/yul/function_cal_cond.sol:16:34-35"]
+	yul_function_return_56 [label="return parameter uint256: e\ntests/contract_testcases/solana/yul/function_cal_cond.sol:16:40-41"]
+	yul_assignment_57 [label="yul assignment\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:25-39"]
+	yul_variable_58 [label="yul variable: e\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:25-26"]
+	yul_builtin_call_59 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:30-39"]
+	yul_variable_60 [label="yul variable: d\nuint256\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:34-35"]
+	yul_number_literal_61 [label="uint256 literal: 3\ntests/contract_testcases/solana/yul/function_cal_cond.sol:17:37-38"]
+	assembly_block_62 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:4:13-32:14"]
+	assembly_block_63 [label="assembly block\ntests/contract_testcases/solana/yul/function_cal_cond.sol:15:17-21:18"]
+	yul_builtin_call_64 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:21-50"]
+	yul_function_call_65 [label="yul function call ‘tryThis‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:28-35"]
+	yul_function_call_66 [label="yul function call ‘foo‘\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:36-39"]
+	yul_number_literal_67 [label="uint256 literal: 3\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:40-41"]
+	yul_number_literal_68 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:44-45"]
+	yul_number_literal_69 [label="uint256 literal: 4\ntests/contract_testcases/solana/yul/function_cal_cond.sol:20:48-49"]
+	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:17-27"]
+	var_decl_item [label="yul variable declaration uint256 x\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:21-22"]
+	yul_number_literal_72 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:26-27"]
+	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/yul/function_cal_cond.sol:1:1-20"]
+	diagnostic_75 [label="unreachable yul statement\nlevel Warning\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:17-27"]
+	diagnostic_76 [label="yul variable ‘x‘ has never been read\nlevel Warning\ntests/contract_testcases/solana/yul/function_cal_cond.sol:31:21-22"]
+	diagnostic_77 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/function_cal_cond.sol:3:9-33:10"]
 	contracts -> contract
 	contract -> testAsm [label="function"]
 	testAsm -> inline_assembly [label="body"]
@@ -146,7 +146,7 @@ strict digraph "tests/contract_testcases/solana/assembly/function_cal_cond.sol"
 	yul_var_decl -> var_decl_item [label="decl item #0"]
 	yul_var_decl -> yul_number_literal_72 [label="init"]
 	diagnostics -> diagnostic [label="Debug"]
-	diagnostics -> diagnostic_75 [label="Error"]
+	diagnostics -> diagnostic_75 [label="Warning"]
 	diagnostics -> diagnostic_76 [label="Warning"]
-	diagnostics -> diagnostic_77 [label="Warning"]
+	diagnostics -> diagnostic_77 [label="Error"]
 }

tests/contract_testcases/solana/assembly/parse.dot → tests/contract_testcases/solana/yul/parse.dot

@@ -1,19 +1,20 @@
-strict digraph "tests/contract_testcases/solana/assembly/parse.sol" {
-	contract [label="contract foo\ntests/contract_testcases/solana/assembly/parse.sol:2:9-22"]
-	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/assembly/parse.sol:3:13-51\nsignature get()\nvisibility public\nmutability nonpayable"]
+strict digraph "tests/contract_testcases/solana/yul/parse.sol" {
+	contract [label="contract foo\ntests/contract_testcases/solana/yul/parse.sol:2:9-22"]
+	get [label="function get\ncontract: foo\ntests/contract_testcases/solana/yul/parse.sol:3:13-51\nsignature get()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nbytes4 "]
-	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/assembly/parse.sol:4:17-7:18"]
-	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/assembly/parse.sol:5:21-55"]
-	var_decl_item [label="yul variable declaration uint256 returndata_size\ntests/contract_testcases/solana/assembly/parse.sol:5:25-40"]
-	yul_builtin_call [label="yul builtin call ‘mload‘\ntests/contract_testcases/solana/assembly/parse.sol:5:44-55"]
-	yul_number_literal [label="uint256 literal: 64\ntests/contract_testcases/solana/assembly/parse.sol:5:50-54"]
-	yul_builtin_call_10 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/assembly/parse.sol:6:21-59"]
-	yul_builtin_call_11 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/assembly/parse.sol:6:28-41"]
-	yul_number_literal_12 [label="uint256 literal: 32\ntests/contract_testcases/solana/assembly/parse.sol:6:32-34"]
-	yul_number_literal_13 [label="uint256 literal: 64\ntests/contract_testcases/solana/assembly/parse.sol:6:36-40"]
-	yul_variable [label="yul variable: returndata_size\nuint256\ntests/contract_testcases/solana/assembly/parse.sol:6:43-58"]
-	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/assembly/parse.sol:2:9-22"]
-	diagnostic_17 [label="evm assembly not supported on target solana\nlevel Error\ntests/contract_testcases/solana/assembly/parse.sol:4:17-7:18"]
+	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/parse.sol:4:17-7:18"]
+	yul_var_decl [label="yul variable declaration\ntests/contract_testcases/solana/yul/parse.sol:5:21-55"]
+	var_decl_item [label="yul variable declaration uint256 returndata_size\ntests/contract_testcases/solana/yul/parse.sol:5:25-40"]
+	yul_builtin_call [label="yul builtin call ‘mload‘\ntests/contract_testcases/solana/yul/parse.sol:5:44-55"]
+	yul_number_literal [label="uint256 literal: 64\ntests/contract_testcases/solana/yul/parse.sol:5:50-54"]
+	yul_builtin_call_10 [label="yul builtin call ‘revert‘\ntests/contract_testcases/solana/yul/parse.sol:6:21-59"]
+	yul_builtin_call_11 [label="yul builtin call ‘add‘\ntests/contract_testcases/solana/yul/parse.sol:6:28-41"]
+	yul_number_literal_12 [label="uint256 literal: 32\ntests/contract_testcases/solana/yul/parse.sol:6:32-34"]
+	yul_number_literal_13 [label="uint256 literal: 64\ntests/contract_testcases/solana/yul/parse.sol:6:36-40"]
+	yul_variable [label="yul variable: returndata_size\nuint256\ntests/contract_testcases/solana/yul/parse.sol:6:43-58"]
+	diagnostic [label="found contract ‘foo’\nlevel Debug\ntests/contract_testcases/solana/yul/parse.sol:2:9-22"]
+	diagnostic_17 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/parse.sol:4:17-7:18"]
+	diagnostic_18 [label="function can be declared ‘pure’\nlevel Warning\ntests/contract_testcases/solana/yul/parse.sol:3:13-51"]
 	contracts -> contract
 	contract -> get [label="function"]
 	get -> returns [label="returns"]
@@ -29,4 +30,5 @@ strict digraph "tests/contract_testcases/solana/assembly/parse.sol" {
 	yul_builtin_call_10 -> yul_variable [label="arg #1"]
 	diagnostics -> diagnostic [label="Debug"]
 	diagnostics -> diagnostic_17 [label="Error"]
+	diagnostics -> diagnostic_18 [label="Warning"]
 }

tests/contract_testcases/solana/assembly/return_in_asm.dot → tests/contract_testcases/solana/yul/return_in_asm.dot

@@ -1,12 +1,12 @@
-strict digraph "tests/contract_testcases/solana/assembly/return_in_asm.sol" {
-	contract [label="contract Contract\ntests/contract_testcases/solana/assembly/return_in_asm.sol:1:1-19"]
-	node_3 [label="constructor \ncontract: Contract\ntests/contract_testcases/solana/assembly/return_in_asm.sol:2:5-19\nsignature ()\nvisibility public\nmutability nonpayable"]
-	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/assembly/return_in_asm.sol:3:9-5:10"]
-	yul_builtin_call [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/assembly/return_in_asm.sol:4:13-25"]
-	yul_number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/assembly/return_in_asm.sol:4:20-21"]
-	yul_number_literal_7 [label="uint256 literal: 0\ntests/contract_testcases/solana/assembly/return_in_asm.sol:4:23-24"]
-	diagnostic [label="found contract ‘Contract’\nlevel Debug\ntests/contract_testcases/solana/assembly/return_in_asm.sol:1:1-19"]
-	diagnostic_10 [label="evm assembly not supported on target solana\nlevel Error\ntests/contract_testcases/solana/assembly/return_in_asm.sol:3:9-5:10"]
+strict digraph "tests/contract_testcases/solana/yul/return_in_asm.sol" {
+	contract [label="contract Contract\ntests/contract_testcases/solana/yul/return_in_asm.sol:1:1-19"]
+	node_3 [label="constructor \ncontract: Contract\ntests/contract_testcases/solana/yul/return_in_asm.sol:2:5-19\nsignature ()\nvisibility public\nmutability nonpayable"]
+	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/return_in_asm.sol:3:9-5:10"]
+	yul_builtin_call [label="yul builtin call ‘return‘\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:13-25"]
+	yul_number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:20-21"]
+	yul_number_literal_7 [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/return_in_asm.sol:4:23-24"]
+	diagnostic [label="found contract ‘Contract’\nlevel Debug\ntests/contract_testcases/solana/yul/return_in_asm.sol:1:1-19"]
+	diagnostic_10 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/return_in_asm.sol:3:9-5:10"]
 	contracts -> contract
 	contract -> node_3 [label="constructor"]
 	node_3 -> inline_assembly [label="body"]

tests/contract_testcases/solana/assembly/yul_switch.dot → tests/contract_testcases/solana/yul/yul_switch.dot

@@ -1,47 +1,47 @@
-strict digraph "tests/contract_testcases/solana/assembly/yul_switch.sol" {
-	contract [label="contract testTypes\ntests/contract_testcases/solana/assembly/yul_switch.sol:1:1-20"]
-	var [label="variable b\nvisibility internal\ntests/contract_testcases/solana/assembly/yul_switch.sol:2:5-14"]
-	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/solana/assembly/yul_switch.sol:3:5-74\nsignature testAsm(uint128[])\nvisibility public\nmutability pure"]
+strict digraph "tests/contract_testcases/solana/yul/yul_switch.sol" {
+	contract [label="contract testTypes\ntests/contract_testcases/solana/yul/yul_switch.sol:1:1-20"]
+	var [label="variable b\nvisibility internal\ntests/contract_testcases/solana/yul/yul_switch.sol:2:5-14"]
+	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/solana/yul/yul_switch.sol:3:5-74\nsignature testAsm(uint128[])\nvisibility public\nmutability pure"]
 	parameters [label="parameters\nuint128[] vl"]
 	returns [label="returns\nuint256 "]
-	var_decl [label="variable decl uint256 y\ntests/contract_testcases/solana/assembly/yul_switch.sol:4:9-22"]
-	number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/assembly/yul_switch.sol:4:21-22"]
-	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/assembly/yul_switch.sol:5:9-14:10"]
-	switch [label="yul switch\ntests/contract_testcases/solana/assembly/yul_switch.sol:6:13-11:14"]
-	yul_member_access [label="yul member ‘length‘ access\ntests/contract_testcases/solana/assembly/yul_switch.sol:6:20-29"]
-	solidity_variable [label="solidity variable: vl\nuint128[]\ntests/contract_testcases/solana/assembly/yul_switch.sol:6:20-22"]
-	case [label="yul switch case\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:13-41"]
-	yul_number_literal [label="uint256 literal: 1\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:18-19"]
-	assembly_block [label="assembly block\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:13-41"]
-	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:21-40"]
-	solidity_variable_17 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:21-22"]
-	yul_builtin_call [label="yul builtin call ‘mul‘\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:26-40"]
-	yul_member_access_19 [label="yul member ‘slot‘ access\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:30-36"]
-	storage_var [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:30-31"]
-	yul_number_literal_21 [label="uint256 literal: 2\ntests/contract_testcases/solana/assembly/yul_switch.sol:7:38-39"]
-	case_22 [label="yul switch case\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:13-43"]
-	yul_number_literal_23 [label="uint256 literal: 2\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:18-19"]
-	assembly_block_24 [label="assembly block\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:13-43"]
-	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:21-42"]
-	solidity_variable_26 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:21-22"]
-	yul_builtin_call_27 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:26-42"]
-	yul_member_access_28 [label="yul member ‘offset‘ access\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:30-38"]
-	storage_var_29 [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:30-31"]
-	yul_number_literal_30 [label="uint256 literal: 2\ntests/contract_testcases/solana/assembly/yul_switch.sol:8:40-41"]
-	default [label="yul switch default\ntests/contract_testcases/solana/assembly/yul_switch.sol:9:13-11:14"]
-	assembly_block_32 [label="assembly block\ntests/contract_testcases/solana/assembly/yul_switch.sol:9:13-11:14"]
-	yul_assignment_33 [label="yul assignment\ntests/contract_testcases/solana/assembly/yul_switch.sol:10:17-23"]
-	solidity_variable_34 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:10:17-18"]
-	yul_number_literal_35 [label="uint256 literal: 5\ntests/contract_testcases/solana/assembly/yul_switch.sol:10:22-23"]
-	yul_assignment_36 [label="yul assignment\ntests/contract_testcases/solana/assembly/yul_switch.sol:13:13-27"]
-	solidity_variable_37 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:13:13-14"]
-	yul_builtin_call_38 [label="yul builtin call ‘sub‘\ntests/contract_testcases/solana/assembly/yul_switch.sol:13:18-27"]
-	solidity_variable_39 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:13:22-23"]
-	yul_number_literal_40 [label="uint256 literal: 1\ntests/contract_testcases/solana/assembly/yul_switch.sol:13:25-26"]
-	return [label="return\ntests/contract_testcases/solana/assembly/yul_switch.sol:16:9-17"]
-	variable [label="variable: y\nuint256\ntests/contract_testcases/solana/assembly/yul_switch.sol:16:16-17"]
-	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/assembly/yul_switch.sol:1:1-20"]
-	diagnostic_45 [label="evm assembly not supported on target solana\nlevel Error\ntests/contract_testcases/solana/assembly/yul_switch.sol:5:9-14:10"]
+	var_decl [label="variable decl uint256 y\ntests/contract_testcases/solana/yul/yul_switch.sol:4:9-22"]
+	number_literal [label="uint256 literal: 0\ntests/contract_testcases/solana/yul/yul_switch.sol:4:21-22"]
+	inline_assembly [label="inline assembly\ntests/contract_testcases/solana/yul/yul_switch.sol:5:9-14:10"]
+	switch [label="yul switch\ntests/contract_testcases/solana/yul/yul_switch.sol:6:13-11:14"]
+	yul_member_access [label="yul member ‘length‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:6:20-29"]
+	solidity_variable [label="solidity variable: vl\nuint128[]\ntests/contract_testcases/solana/yul/yul_switch.sol:6:20-22"]
+	case [label="yul switch case\ntests/contract_testcases/solana/yul/yul_switch.sol:7:13-41"]
+	yul_number_literal [label="uint256 literal: 1\ntests/contract_testcases/solana/yul/yul_switch.sol:7:18-19"]
+	assembly_block [label="assembly block\ntests/contract_testcases/solana/yul/yul_switch.sol:7:13-41"]
+	yul_assignment [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:7:21-40"]
+	solidity_variable_17 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:7:21-22"]
+	yul_builtin_call [label="yul builtin call ‘mul‘\ntests/contract_testcases/solana/yul/yul_switch.sol:7:26-40"]
+	yul_member_access_19 [label="yul member ‘slot‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:7:30-36"]
+	storage_var [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:7:30-31"]
+	yul_number_literal_21 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/yul_switch.sol:7:38-39"]
+	case_22 [label="yul switch case\ntests/contract_testcases/solana/yul/yul_switch.sol:8:13-43"]
+	yul_number_literal_23 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/yul_switch.sol:8:18-19"]
+	assembly_block_24 [label="assembly block\ntests/contract_testcases/solana/yul/yul_switch.sol:8:13-43"]
+	yul_assignment_25 [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:8:21-42"]
+	solidity_variable_26 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:8:21-22"]
+	yul_builtin_call_27 [label="yul builtin call ‘shr‘\ntests/contract_testcases/solana/yul/yul_switch.sol:8:26-42"]
+	yul_member_access_28 [label="yul member ‘offset‘ access\ntests/contract_testcases/solana/yul/yul_switch.sol:8:30-38"]
+	storage_var_29 [label="storage variable\ntestTypes.b\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:8:30-31"]
+	yul_number_literal_30 [label="uint256 literal: 2\ntests/contract_testcases/solana/yul/yul_switch.sol:8:40-41"]
+	default [label="yul switch default\ntests/contract_testcases/solana/yul/yul_switch.sol:9:13-11:14"]
+	assembly_block_32 [label="assembly block\ntests/contract_testcases/solana/yul/yul_switch.sol:9:13-11:14"]
+	yul_assignment_33 [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:10:17-23"]
+	solidity_variable_34 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:10:17-18"]
+	yul_number_literal_35 [label="uint256 literal: 5\ntests/contract_testcases/solana/yul/yul_switch.sol:10:22-23"]
+	yul_assignment_36 [label="yul assignment\ntests/contract_testcases/solana/yul/yul_switch.sol:13:13-27"]
+	solidity_variable_37 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:13:13-14"]
+	yul_builtin_call_38 [label="yul builtin call ‘sub‘\ntests/contract_testcases/solana/yul/yul_switch.sol:13:18-27"]
+	solidity_variable_39 [label="solidity variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:13:22-23"]
+	yul_number_literal_40 [label="uint256 literal: 1\ntests/contract_testcases/solana/yul/yul_switch.sol:13:25-26"]
+	return [label="return\ntests/contract_testcases/solana/yul/yul_switch.sol:16:9-17"]
+	variable [label="variable: y\nuint256\ntests/contract_testcases/solana/yul/yul_switch.sol:16:16-17"]
+	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/solana/yul/yul_switch.sol:1:1-20"]
+	diagnostic_45 [label="inline assembly is not yet supported\nlevel Error\ntests/contract_testcases/solana/yul/yul_switch.sol:5:9-14:10"]
 	contracts -> contract
 	contract -> var [label="variable"]
 	contract -> testAsm [label="function"]

tests/contract_testcases/substrate/assembly/unreachable_after_asm.dot

@@ -1,16 +0,0 @@
-strict digraph "tests/contract_testcases/substrate/assembly/unreachable_after_asm.sol" {
-	contract [label="contract testTypes\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:1:1-20"]
-	var [label="variable b\nvisibility internal\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:2:5-14"]
-	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:3:5-51\nsignature testAsm(uint128[])\nvisibility public\nmutability nonpayable"]
-	parameters [label="parameters\nuint128[] vl"]
-	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:1:1-20"]
-	diagnostic_7 [label="evm assembly not supported on target substrate\nlevel Error\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:5:9-15:10"]
-	diagnostic_8 [label="unreachable statement\nlevel Error\ntests/contract_testcases/substrate/assembly/unreachable_after_asm.sol:17:9-19:10"]
-	contracts -> contract
-	contract -> var [label="variable"]
-	contract -> testAsm [label="function"]
-	testAsm -> parameters [label="parameters"]
-	diagnostics -> diagnostic [label="Debug"]
-	diagnostics -> diagnostic_7 [label="Error"]
-	diagnostics -> diagnostic_8 [label="Error"]
-}

tests/contract_testcases/substrate/yul/unreachable_after_asm.dot

@@ -0,0 +1,14 @@
+strict digraph "tests/contract_testcases/substrate/yul/unreachable_after_asm.sol" {
+	contract [label="contract testTypes\ntests/contract_testcases/substrate/yul/unreachable_after_asm.sol:1:1-20"]
+	var [label="variable b\nvisibility internal\ntests/contract_testcases/substrate/yul/unreachable_after_asm.sol:2:5-14"]
+	testAsm [label="function testAsm\ncontract: testTypes\ntests/contract_testcases/substrate/yul/unreachable_after_asm.sol:3:5-51\nsignature testAsm(uint128[])\nvisibility public\nmutability nonpayable"]
+	parameters [label="parameters\nuint128[] vl"]
+	diagnostic [label="found contract ‘testTypes’\nlevel Debug\ntests/contract_testcases/substrate/yul/unreachable_after_asm.sol:1:1-20"]
+	diagnostic_7 [label="unreachable statement\nlevel Error\ntests/contract_testcases/substrate/yul/unreachable_after_asm.sol:17:9-19:10"]
+	contracts -> contract
+	contract -> var [label="variable"]
+	contract -> testAsm [label="function"]
+	testAsm -> parameters [label="parameters"]
+	diagnostics -> diagnostic [label="Debug"]
+	diagnostics -> diagnostic_7 [label="Error"]
+}