Very simple revamp of dead code elimination.

Enable DCE by default. Eliminates useless
associated function calls.

Also threw in just a few changes to Display
implementations for some nodes.

Fixes #28504

Author: mikebenfield

compiler/ast/src/common/identifier.rs

@@ -67,12 +67,12 @@ impl Identifier {
 
 impl fmt::Display for Identifier {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.name)
+        self.name.fmt(f)
     }
 }
 impl fmt::Debug for Identifier {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.name)
+        self.name.fmt(f)
     }
 }
 

compiler/ast/src/expressions/call.rs

@@ -17,6 +17,8 @@
 use super::*;
 use leo_span::Symbol;
 
+use itertools::Itertools as _;
+
 /// A function call expression, e.g.`foo(args)` or `Foo::bar(args)`.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CallExpression {
@@ -35,15 +37,7 @@ pub struct CallExpression {
 
 impl fmt::Display for CallExpression {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}(", self.function)?;
-
-        for (i, param) in self.arguments.iter().enumerate() {
-            write!(f, "{param}")?;
-            if i < self.arguments.len() - 1 {
-                write!(f, ", ")?;
-            }
-        }
-        write!(f, ")")
+        write!(f, "{}({})", self.function, self.arguments.iter().format(", "))
     }
 }
 

compiler/ast/src/expressions/mod.rs

@@ -15,7 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::{Identifier, Node, NodeID};
-use leo_span::Span;
+use leo_span::{Span, sym};
 
 use serde::{Deserialize, Serialize};
 use std::fmt;
@@ -211,6 +211,33 @@ pub(crate) enum Associativity {
 }
 
 impl Expression {
+    pub fn side_effect_free(&self) -> bool {
+        use Expression::*;
+        match self {
+            Access(AccessExpression::Array(array)) => array.array.side_effect_free() && array.index.side_effect_free(),
+            Access(AccessExpression::AssociatedConstant(_)) => true,
+            Access(AccessExpression::AssociatedFunction(func)) => {
+                func.arguments.iter().all(|expr| expr.side_effect_free())
+                    && !matches!(func.variant.name, sym::CheatCode | sym::Mapping | sym::Future)
+            }
+            Access(AccessExpression::Member(mem)) => mem.inner.side_effect_free(),
+            Access(AccessExpression::Tuple(tuple)) => tuple.tuple.side_effect_free(),
+            Array(array) => array.elements.iter().all(|expr| expr.side_effect_free()),
+            Binary(bin) => bin.left.side_effect_free() && bin.right.side_effect_free(),
+            Cast(cast) => cast.expression.side_effect_free(),
+            Struct(struct_) => {
+                struct_.members.iter().all(|mem| mem.expression.as_ref().map_or(true, |expr| expr.side_effect_free()))
+            }
+            Ternary(tern) => {
+                [&tern.condition, &tern.if_true, &tern.if_false].into_iter().all(|expr| expr.side_effect_free())
+            }
+            Tuple(tuple) => tuple.elements.iter().all(|expr| expr.side_effect_free()),
+            Unary(un) => un.receiver.side_effect_free(),
+            Call(_) | Err(_) => false,
+            Identifier(_) | Literal(_) | Locator(_) | Unit(_) => true,
+        }
+    }
+
     pub(crate) fn precedence(&self) -> u32 {
         use Expression::*;
         match self {

compiler/ast/src/expressions/tuple.rs

@@ -16,6 +16,8 @@
 
 use super::*;
 
+use itertools::Itertools as _;
+
 // TODO: Consider a restricted interface for constructing a tuple expression.
 
 /// A tuple expression, e.g., `(foo, false, 42)`.
@@ -32,7 +34,11 @@ pub struct TupleExpression {
 
 impl fmt::Display for TupleExpression {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({})", self.elements.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","))
+        if self.elements.len() == 1 {
+            write!(f, "({},)", self.elements[0])
+        } else {
+            write!(f, "({})", self.elements.iter().join(","))
+        }
     }
 }
 

compiler/ast/src/passes/reconstructor.rs

@@ -172,10 +172,7 @@ pub trait ExpressionReconstructor {
                     .into_iter()
                     .map(|member| StructVariableInitializer {
                         identifier: member.identifier,
-                        expression: match member.expression {
-                            Some(expression) => Some(self.reconstruct_expression(expression).0),
-                            None => Some(self.reconstruct_expression(Expression::Identifier(member.identifier)).0),
-                        },
+                        expression: member.expression.map(|expr| self.reconstruct_expression(expr).0),
                         span: member.span,
                         id: member.id,
                     })

compiler/ast/src/statement/console/console_statement.rs

@@ -33,13 +33,13 @@ pub struct ConsoleStatement {
 
 impl fmt::Display for ConsoleStatement {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "console.{};", self.function)
+        write!(f, "console.{}", self.function)
     }
 }
 
 impl fmt::Debug for ConsoleStatement {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "console.{};", self.function)
+        write!(f, "console.{}", self.function)
     }
 }
 

compiler/ast/src/statement/expression.rs

@@ -33,7 +33,7 @@ pub struct ExpressionStatement {
 
 impl fmt::Display for ExpressionStatement {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{};", self.expression)
+        self.expression.fmt(f)
     }
 }
 

compiler/ast/src/statement/mod.rs

@@ -78,15 +78,19 @@ pub enum Statement {
 
 impl Statement {
     /// Returns a dummy statement made from an empty block `{}`.
-    pub fn dummy(span: Span, id: NodeID) -> Self {
-        Self::Block(Block { statements: Vec::new(), span, id })
+    pub fn dummy() -> Self {
+        Self::Block(Block { statements: Vec::new(), span: Default::default(), id: Default::default() })
     }
 
     pub(crate) fn semicolon(&self) -> &'static str {
         use Statement::*;
 
         if matches!(self, Block(..) | Conditional(..) | Iteration(..)) { "" } else { ";" }
     }
+
+    pub fn is_empty(self: &Statement) -> bool {
+        matches!(self, Statement::Block(block) if block.statements.is_empty())
+    }
 }
 
 impl fmt::Display for Statement {

compiler/compiler/src/compiler.rs

@@ -309,7 +309,7 @@ impl<'a, N: Network> Compiler<'a, N> {
     /// Runs the dead code elimination pass.
     pub fn dead_code_elimination_pass(&mut self) -> Result<()> {
         if self.compiler_options.build.dce_enabled {
-            self.ast = DeadCodeEliminator::do_pass((std::mem::take(&mut self.ast), &self.node_builder))?;
+            self.ast = DeadCodeEliminator::do_pass((std::mem::take(&mut self.ast),))?;
         }
 
         if self.compiler_options.output.dce_ast {

compiler/parser/src/test.rs

@@ -16,10 +16,9 @@
 
 use crate::{ParserContext, SpannedToken, tokenizer};
 
-use leo_ast::{NodeBuilder, NodeID, Statement};
+use leo_ast::{NodeBuilder, Statement};
 use leo_errors::{LeoError, emitter::Handler};
 use leo_span::{
-    Span,
     source_map::FileName,
     symbol::{SessionGlobals, create_session_if_not_set_then},
 };
@@ -120,7 +119,7 @@ impl Namespace for ParseStatementNamespace {
         create_session_if_not_set_then(|s| {
             let tokenizer = tokenize(test, s)?;
             if all_are_comments(&tokenizer) {
-                return Ok(toml_or_fail(Statement::dummy(Span::default(), NodeID::default())));
+                return Ok(toml_or_fail(Statement::dummy()));
             }
             with_handler(tokenizer, |p| p.parse_statement()).map(toml_or_fail)
         })

compiler/passes/src/dead_code_elimination/dead_code_eliminator.rs

@@ -14,25 +14,19 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use leo_ast::NodeBuilder;
 use leo_span::Symbol;
 
 use indexmap::IndexSet;
 
-pub struct DeadCodeEliminator<'a> {
-    /// A counter to generate unique node IDs.
-    pub(crate) node_builder: &'a NodeBuilder,
+#[derive(Debug, Default)]
+pub struct DeadCodeEliminator {
     /// The set of used variables in the current function body.
     pub(crate) used_variables: IndexSet<Symbol>,
-    /// Whether or not the variables are necessary.
-    pub(crate) is_necessary: bool,
-    /// Whether or not we are currently traversing an async function.
-    pub(crate) is_async: bool,
 }
 
-impl<'a> DeadCodeEliminator<'a> {
+impl DeadCodeEliminator {
     /// Initializes a new `DeadCodeEliminator`.
-    pub fn new(node_builder: &'a NodeBuilder) -> Self {
-        Self { node_builder, used_variables: Default::default(), is_necessary: false, is_async: false }
+    pub(crate) fn new() -> Self {
+        Default::default()
     }
 }

compiler/passes/src/dead_code_elimination/eliminate_expression.rs

@@ -16,83 +16,14 @@
 
 use crate::DeadCodeEliminator;
 
-use leo_ast::{
-    AccessExpression,
-    AssociatedFunction,
-    Expression,
-    ExpressionReconstructor,
-    Identifier,
-    StructExpression,
-    StructVariableInitializer,
-};
-use leo_span::sym;
+use leo_ast::{Expression, ExpressionReconstructor, Identifier};
 
-impl ExpressionReconstructor for DeadCodeEliminator<'_> {
+impl ExpressionReconstructor for DeadCodeEliminator {
     type AdditionalOutput = ();
 
-    /// Reconstructs the associated function access expression.
-    fn reconstruct_associated_function(&mut self, input: AssociatedFunction) -> (Expression, Self::AdditionalOutput) {
-        // If the associated function manipulates a mapping, or a cheat code, mark the statement as necessary.
-        match (&input.variant.name, input.name.name) {
-            (&sym::Mapping, sym::remove)
-            | (&sym::Mapping, sym::set)
-            | (&sym::Future, sym::Await)
-            | (&sym::CheatCode, _) => {
-                self.is_necessary = true;
-            }
-            _ => {}
-        };
-        // Reconstruct the access expression.
-        let result = (
-            Expression::Access(AccessExpression::AssociatedFunction(AssociatedFunction {
-                variant: input.variant,
-                name: input.name,
-                arguments: input.arguments.into_iter().map(|arg| self.reconstruct_expression(arg).0).collect(),
-                span: input.span,
-                id: input.id,
-            })),
-            Default::default(),
-        );
-        // Unset `self.is_necessary`.
-        self.is_necessary = false;
-        result
-    }
-
-    /// Reconstruct the components of the struct init expression.
-    /// This is necessary since the reconstructor does not explicitly visit each component of the expression.
-    fn reconstruct_struct_init(&mut self, input: StructExpression) -> (Expression, Self::AdditionalOutput) {
-        (
-            Expression::Struct(StructExpression {
-                name: input.name,
-                // Reconstruct each of the struct members.
-                members: input
-                    .members
-                    .into_iter()
-                    .map(|member| StructVariableInitializer {
-                        identifier: member.identifier,
-                        expression: match member.expression {
-                            Some(expression) => Some(self.reconstruct_expression(expression).0),
-                            None => unreachable!("Static single assignment ensures that the expression always exists."),
-                        },
-                        span: member.span,
-                        id: member.id,
-                    })
-                    .collect(),
-                span: input.span,
-                id: input.id,
-            }),
-            Default::default(),
-        )
-    }
-
-    /// Marks identifiers as used.
-    /// This is necessary to determine which statements can be eliminated from the program.
+    // Use and reconstruct an identifier that may not necessarily be used.
     fn reconstruct_identifier(&mut self, input: Identifier) -> (Expression, Self::AdditionalOutput) {
-        // Add the identifier to `self.used_variables`.
-        if self.is_necessary {
-            self.used_variables.insert(input.name);
-        }
-        // Return the identifier as is.
+        self.used_variables.insert(input.name);
         (Expression::Identifier(input), Default::default())
     }
 }

compiler/passes/src/dead_code_elimination/eliminate_program.rs

@@ -18,26 +18,14 @@ use crate::DeadCodeEliminator;
 
 use leo_ast::{Function, ProgramReconstructor, StatementReconstructor};
 
-impl ProgramReconstructor for DeadCodeEliminator<'_> {
-    fn reconstruct_function(&mut self, input: Function) -> Function {
+impl ProgramReconstructor for DeadCodeEliminator {
+    fn reconstruct_function(&mut self, mut input: Function) -> Function {
         // Reset the state of the dead code eliminator.
         self.used_variables.clear();
-        self.is_necessary = false;
-        self.is_async = input.variant.is_async_function();
 
         // Traverse the function body.
-        let block = self.reconstruct_block(input.block).0;
-
-        Function {
-            annotations: input.annotations,
-            variant: input.variant,
-            identifier: input.identifier,
-            input: input.input,
-            output: input.output,
-            output_type: input.output_type,
-            block,
-            span: input.span,
-            id: input.id,
-        }
+        input.block = self.reconstruct_block(input.block).0;
+
+        input
     }
 }