Refactored and cleaned up code for address-of operator

Author: IsaacShelton

src/ast/expr/unary.rs src/ast/expr/unary/math.rssrc/ast/expr/unary.rs renamed to src/ast/expr/unary/math.rs

@@ -3,29 +3,27 @@ use derive_more::IsVariant;
 use std::fmt::Display;
 
 #[derive(Clone, Debug)]
-pub struct UnaryOperation {
-    pub operator: UnaryOperator,
+pub struct UnaryMathOperation {
+    pub operator: UnaryMathOperator,
     pub inner: Expr,
 }
 
-#[derive(Clone, Debug, IsVariant)]
-pub enum UnaryOperator {
+#[derive(Copy, Clone, Debug, IsVariant)]
+pub enum UnaryMathOperator {
     Not,
     BitComplement,
     Negate,
     IsNonZero,
-    AddressOf,
     Dereference,
 }
 
-impl Display for UnaryOperator {
+impl Display for UnaryMathOperator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(match self {
             Self::Not => "!",
             Self::BitComplement => "~",
             Self::Negate => "-",
             Self::IsNonZero => "bool()",
-            Self::AddressOf => "(address of) &",
             Self::Dereference => "(dereference) *",
         })
     }

src/ast/expr/unary/mod.rs

@@ -0,0 +1,29 @@
+mod math;
+
+use crate::ast::Expr;
+pub use math::*;
+
+#[derive(Clone, Debug)]
+pub struct UnaryOperation {
+    pub operator: UnaryOperator,
+    pub inner: Expr,
+}
+
+impl UnaryOperation {
+    pub fn new(operator: UnaryOperator, inner: Expr) -> Self {
+        Self { operator, inner }
+    }
+
+    pub fn new_math(operator: UnaryMathOperator, inner: Expr) -> Self {
+        Self {
+            operator: UnaryOperator::Math(operator),
+            inner,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum UnaryOperator {
+    Math(UnaryMathOperator),
+    AddressOf,
+}

src/lower/mod.rs

@@ -9,7 +9,8 @@ use crate::{
     ir::{self, BasicBlocks, Global, Literal, OverflowOperator, Value, ValueReference},
     resolved::{
         self, Destination, DestinationKind, Expr, ExprKind, FloatOrInteger, FloatSize, Member,
-        NumericMode, SignOrIndeterminate, StmtKind, StructureLiteral, VariableStorageKey,
+        NumericMode, SignOrIndeterminate, StmtKind, StructureLiteral, UnaryMathOperation,
+        VariableStorageKey,
     },
     tag::Tag,
     target::{Target, TargetOsExt},
@@ -734,29 +735,21 @@ fn lower_expr(
 
             Ok(builder.push(ir::Instruction::StructureLiteral(result_ir_type, values)))
         }
-        ExprKind::UnaryOperation(unary_operation) => {
-            let inner = lower_expr(
-                builder,
-                ir_module,
-                &unary_operation.inner.expr,
-                function,
-                resolved_ast,
-            )?;
-
-            let inner_type = lower_type(
-                ir_module.target,
-                &unary_operation.inner.resolved_type,
-                resolved_ast,
-            )?;
+        ExprKind::UnaryMathOperation(operation) => {
+            let UnaryMathOperation { operator, inner } = &**operation;
+
+            let ir_type = lower_type(ir_module.target, &inner.resolved_type, resolved_ast)?;
+            let value = lower_expr(builder, ir_module, &inner.expr, function, resolved_ast)?;
+
+            let instruction = match operator {
+                resolved::UnaryMathOperator::Not => ir::Instruction::IsZero(value),
+                resolved::UnaryMathOperator::BitComplement => ir::Instruction::BitComplement(value),
+                resolved::UnaryMathOperator::Negate => ir::Instruction::Negate(value),
+                resolved::UnaryMathOperator::IsNonZero => ir::Instruction::IsNonZero(value),
+                resolved::UnaryMathOperator::Dereference => ir::Instruction::Load((value, ir_type)),
+            };
 
-            Ok(builder.push(match unary_operation.operator {
-                resolved::UnaryOperator::Not => ir::Instruction::IsZero(inner),
-                resolved::UnaryOperator::BitComplement => ir::Instruction::BitComplement(inner),
-                resolved::UnaryOperator::Negate => ir::Instruction::Negate(inner),
-                resolved::UnaryOperator::IsNonZero => ir::Instruction::IsNonZero(inner),
-                resolved::UnaryOperator::AddressOf => unreachable!(),
-                resolved::UnaryOperator::Dereference => ir::Instruction::Load((inner, inner_type)),
-            }))
+            Ok(builder.push(instruction))
         }
         ExprKind::AddressOf(destination) => {
             let subject_pointer =

src/parser/parse_expr/primary/mod.rs

@@ -6,7 +6,10 @@ mod structure_literal;
 
 use super::{super::error::ParseError, is_right_associative, is_terminating_token, Parser};
 use crate::{
-    ast::{Block, Conditional, Expr, ExprKind, Integer, UnaryOperation, UnaryOperator, While},
+    ast::{
+        Block, Conditional, Expr, ExprKind, Integer, UnaryMathOperator, UnaryOperation,
+        UnaryOperator, While,
+    },
     inflow::Inflow,
     parser::{array_last, error::ParseErrorKind},
     token::{StringLiteral, StringModifier, Token, TokenKind},
@@ -119,29 +122,50 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                     }
                 }
             }
-            TokenKind::Not
-            | TokenKind::BitComplement
-            | TokenKind::Subtract
-            | TokenKind::AddressOf
-            | TokenKind::Dereference => {
-                let operator = match kind {
-                    TokenKind::Not => UnaryOperator::Not,
-                    TokenKind::BitComplement => UnaryOperator::BitComplement,
-                    TokenKind::Subtract => UnaryOperator::Negate,
-                    TokenKind::AddressOf => UnaryOperator::AddressOf,
-                    TokenKind::Dereference => UnaryOperator::Dereference,
-                    _ => unreachable!(),
-                };
+            TokenKind::Not => {
+                self.input.advance();
 
-                // Eat unary operator
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new_math(
+                    UnaryMathOperator::Not,
+                    self.parse_expr_primary()?,
+                )))
+                .at(source))
+            }
+            TokenKind::BitComplement => {
                 self.input.advance();
 
-                let inner = self.parse_expr_primary()?;
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new_math(
+                    UnaryMathOperator::BitComplement,
+                    self.parse_expr_primary()?,
+                )))
+                .at(source))
+            }
+            TokenKind::Subtract => {
+                self.input.advance();
 
-                Ok(Expr::new(
-                    ExprKind::UnaryOperation(Box::new(UnaryOperation { operator, inner })),
-                    source,
-                ))
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new_math(
+                    UnaryMathOperator::Negate,
+                    self.parse_expr_primary()?,
+                )))
+                .at(source))
+            }
+            TokenKind::AddressOf => {
+                self.input.advance();
+
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new(
+                    UnaryOperator::AddressOf,
+                    self.parse_expr_primary()?,
+                )))
+                .at(source))
+            }
+            TokenKind::Dereference => {
+                self.input.advance();
+
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new_math(
+                    UnaryMathOperator::Dereference,
+                    self.parse_expr_primary()?,
+                )))
+                .at(source))
             }
             TokenKind::IfKeyword => {
                 self.input.advance().kind.unwrap_if_keyword();

src/resolve/conform/from_c_integer.rs

@@ -3,8 +3,8 @@ use crate::{
     ast::{CInteger, IntegerBits, OptionIntegerSignExt},
     logic::implies,
     resolved::{
-        Cast, CastFrom, ExprKind, IntegerSign, Type, TypeKind, TypedExpr, UnaryOperation,
-        UnaryOperator,
+        Cast, CastFrom, ExprKind, IntegerSign, Type, TypeKind, TypedExpr, UnaryMathOperation,
+        UnaryMathOperator,
     },
     source_files::Source,
 };
@@ -52,8 +52,8 @@ fn from_c_integer_to_bool(
 
     Some(TypedExpr::new(
         TypeKind::Boolean.at(source),
-        ExprKind::UnaryOperation(Box::new(UnaryOperation {
-            operator: UnaryOperator::IsNonZero,
+        ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
+            operator: UnaryMathOperator::IsNonZero,
             inner: expr.clone(),
         }))
         .at(source),

src/resolve/destination.rs

@@ -24,7 +24,7 @@ pub fn resolve_expr_to_destination(typed_expr: TypedExpr) -> Result<Destination,
                 }
             }
             ExprKind::ArrayAccess(array_access) => DestinationKind::ArrayAccess(array_access),
-            ExprKind::UnaryOperation(unary_operation)
+            ExprKind::UnaryMathOperation(unary_operation)
                 if unary_operation.operator.is_dereference() =>
             {
                 DestinationKind::Dereference(unary_operation.inner.expr)

src/resolve/expr/mod.rs

@@ -16,6 +16,7 @@ use self::{
 };
 use super::{
     conform::{conform_expr_or_error, ConformMode},
+    destination::resolve_expr_to_destination,
     error::ResolveError,
     function_search_ctx::FunctionSearchCtx,
     global_search_ctx::GlobalSearchCtx,
@@ -24,19 +25,19 @@ use super::{
     Initialized,
 };
 use crate::{
-    ast::{self, CInteger, ConformBehavior},
+    ast::{self, CInteger, ConformBehavior, UnaryOperator},
     resolve::{
         ensure_initialized,
         error::ResolveErrorKind,
         expr::{
             call::resolve_call_expr, conditional::resolve_conditional_expr,
             declare_assign::resolve_declare_assign_expr, member_expr::resolve_member_expr,
             struct_literal::resolve_struct_literal_expr,
-            unary_operation::resolve_unary_operation_expr, variable::resolve_variable_expr,
+            unary_operation::resolve_unary_math_operation_expr, variable::resolve_variable_expr,
         },
         resolve_stmts, resolve_type,
     },
-    resolved::{self, FunctionRef, StructureRef, TypedExpr},
+    resolved::{self, Expr, ExprKind, FunctionRef, StructureRef, TypedExpr},
 };
 use ast::FloatSize;
 pub use basic_binary_operation::resolve_basic_binary_operator;
@@ -206,9 +207,27 @@ pub fn resolve_expr(
                 source,
             )
         }
-        ast::ExprKind::UnaryOperation(unary_operation) => {
-            resolve_unary_operation_expr(ctx, unary_operation, preferred_type, source)
-        }
+        ast::ExprKind::UnaryOperation(unary_operation) => match &unary_operation.operator {
+            UnaryOperator::Math(operator) => resolve_unary_math_operation_expr(
+                ctx,
+                operator,
+                &unary_operation.inner,
+                preferred_type,
+                source,
+            ),
+            UnaryOperator::AddressOf => {
+                let resolved_expr = resolve_expr(
+                    ctx,
+                    &unary_operation.inner,
+                    preferred_type,
+                    Initialized::Require,
+                )?;
+                let result_type = resolved_expr.resolved_type.clone().pointer(source);
+                let destination = resolve_expr_to_destination(resolved_expr)?;
+                let expr = Expr::new(ExprKind::AddressOf(Box::new(destination)), source);
+                return Ok(TypedExpr::new(result_type, expr));
+            }
+        },
         ast::ExprKind::Conditional(conditional) => {
             resolve_conditional_expr(ctx, conditional, preferred_type, source)
         }

src/resolve/expr/unary_operation.rs

@@ -1,42 +1,28 @@
 use super::{resolve_expr, PreferredType, ResolveExprCtx};
 use crate::{
-    ast::{self, UnaryOperator},
+    ast::{self, UnaryMathOperator},
     resolve::{
         conform::to_default::conform_integer_literal_to_default_or_error,
-        destination::resolve_expr_to_destination,
         error::{ResolveError, ResolveErrorKind},
         Initialized,
     },
-    resolved::{Expr, ExprKind, TypeKind, TypedExpr, UnaryOperation},
+    resolved::{Expr, ExprKind, TypeKind, TypedExpr, UnaryMathOperation},
     source_files::Source,
 };
 
-pub fn resolve_unary_operation_expr(
+pub fn resolve_unary_math_operation_expr(
     ctx: &mut ResolveExprCtx<'_, '_>,
-    unary_operation: &ast::UnaryOperation,
+    operator: &UnaryMathOperator,
+    inner: &ast::Expr,
     preferred_type: Option<PreferredType>,
     source: Source,
 ) -> Result<TypedExpr, ResolveError> {
-    let resolved_expr = resolve_expr(
-        ctx,
-        &unary_operation.inner,
-        preferred_type,
-        Initialized::Require,
-    )?;
-
-    let operator = &unary_operation.operator;
-
-    if operator.is_address_of() {
-        let result_type = resolved_expr.resolved_type.clone().pointer(source);
-        let destination = resolve_expr_to_destination(resolved_expr)?;
-        let expr = Expr::new(ExprKind::AddressOf(Box::new(destination)), source);
-        return Ok(TypedExpr::new(result_type, expr));
-    }
+    let resolved_expr = resolve_expr(ctx, inner, preferred_type, Initialized::Require)?;
 
     if operator.is_dereference() {
         if resolved_expr.resolved_type.kind.is_ambiguous_type() {
             return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: unary_operation.operator.to_string(),
+                operator: operator.to_string(),
                 bad_type: resolved_expr.resolved_type.to_string(),
             }
             .at(source));
@@ -46,15 +32,15 @@ pub fn resolve_unary_operation_expr(
             (**inner).clone()
         } else {
             return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: unary_operation.operator.to_string(),
+                operator: operator.to_string(),
                 bad_type: resolved_expr.resolved_type.to_string(),
             }
             .at(source));
         };
 
         let expr = Expr::new(
-            ExprKind::UnaryOperation(Box::new(UnaryOperation {
-                operator: unary_operation.operator.clone(),
+            ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
+                operator: operator.clone(),
                 inner: resolved_expr,
             })),
             source,
@@ -71,24 +57,26 @@ pub fn resolve_unary_operation_expr(
         }
         _ => {
             return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: unary_operation.operator.to_string(),
+                operator: operator.to_string(),
                 bad_type: resolved_expr.resolved_type.to_string(),
             }
             .at(source));
         }
     };
 
-    let result_type = match unary_operation.operator {
-        UnaryOperator::Not | UnaryOperator::IsNonZero => TypeKind::Boolean.at(source),
-        UnaryOperator::BitComplement | UnaryOperator::Negate => resolved_expr.resolved_type.clone(),
-        UnaryOperator::Dereference | UnaryOperator::AddressOf => {
+    let result_type = match operator {
+        UnaryMathOperator::Not | UnaryMathOperator::IsNonZero => TypeKind::Boolean.at(source),
+        UnaryMathOperator::BitComplement | UnaryMathOperator::Negate => {
+            resolved_expr.resolved_type.clone()
+        }
+        UnaryMathOperator::Dereference => {
             unreachable!("should've already handled address-of/dereference operators")
         }
     };
 
     let expr = Expr::new(
-        ExprKind::UnaryOperation(Box::new(UnaryOperation {
-            operator: unary_operation.operator.clone(),
+        ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
+            operator: operator.clone(),
             inner: resolved_expr,
         })),
         source,