Refactored and cleaned up code for address-of and dereference operators

IsaacShelton · IsaacShelton · commit dae296e385d5 · 2024-09-14T07:41:58.000-05:00
diff --git a/src/ast/expr/unary/math.rs b/src/ast/expr/unary/math.rs
@@ -14,7 +14,6 @@ pub enum UnaryMathOperator {
     BitComplement,
     Negate,
     IsNonZero,
-    Dereference,
 }
 
 impl Display for UnaryMathOperator {
@@ -24,7 +23,6 @@ impl Display for UnaryMathOperator {
             Self::BitComplement => "~",
             Self::Negate => "-",
             Self::IsNonZero => "bool()",
-            Self::Dereference => "(dereference) *",
         })
     }
 }
diff --git a/src/ast/expr/unary/mod.rs b/src/ast/expr/unary/mod.rs
@@ -3,6 +3,13 @@ mod math;
 use crate::ast::Expr;
 pub use math::*;
 
+#[derive(Clone, Debug)]
+pub enum UnaryOperator {
+    Math(UnaryMathOperator),
+    AddressOf,
+    Dereference,
+}
+
 #[derive(Clone, Debug)]
 pub struct UnaryOperation {
     pub operator: UnaryOperator,
@@ -21,9 +28,3 @@ impl UnaryOperation {
         }
     }
 }
-
-#[derive(Clone, Debug)]
-pub enum UnaryOperator {
-    Math(UnaryMathOperator),
-    AddressOf,
-}
diff --git a/src/lower/mod.rs b/src/lower/mod.rs
@@ -737,25 +737,28 @@ fn lower_expr(
         }
         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(instruction))
         }
-        ExprKind::AddressOf(destination) => {
-            let subject_pointer =
-                lower_destination(builder, ir_module, destination, function, resolved_ast)?;
-
-            Ok(subject_pointer)
+        ExprKind::AddressOf(destination) => Ok(lower_destination(
+            builder,
+            ir_module,
+            destination,
+            function,
+            resolved_ast,
+        )?),
+        ExprKind::Dereference(subject) => {
+            let ir_type = lower_type(ir_module.target, &subject.resolved_type, resolved_ast)?;
+            let value = lower_expr(builder, ir_module, &subject.expr, function, resolved_ast)?;
+            Ok(builder.push(ir::Instruction::Load((value, ir_type))))
         }
         ExprKind::Conditional(conditional) => {
             let resume_basicblock_id = builder.new_block();
diff --git a/src/parser/parse_expr/primary/mod.rs b/src/parser/parse_expr/primary/mod.rs
@@ -161,8 +161,8 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             TokenKind::Dereference => {
                 self.input.advance();
 
-                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new_math(
-                    UnaryMathOperator::Dereference,
+                Ok(ExprKind::UnaryOperation(Box::new(UnaryOperation::new(
+                    UnaryOperator::Dereference,
                     self.parse_expr_primary()?,
                 )))
                 .at(source))
diff --git a/src/resolve/destination.rs b/src/resolve/destination.rs
@@ -24,11 +24,7 @@ pub fn resolve_expr_to_destination(typed_expr: TypedExpr) -> Result<Destination,
                 }
             }
             ExprKind::ArrayAccess(array_access) => DestinationKind::ArrayAccess(array_access),
-            ExprKind::UnaryMathOperation(unary_operation)
-                if unary_operation.operator.is_dereference() =>
-            {
-                DestinationKind::Dereference(unary_operation.inner.expr)
-            }
+            ExprKind::Dereference(subject) => DestinationKind::Dereference(subject.expr),
             _ => {
                 return Err(ResolveErrorKind::CannotMutate {
                     bad_type: typed_expr.resolved_type.to_string(),
diff --git a/src/resolve/expr/mod.rs b/src/resolve/expr/mod.rs
@@ -37,7 +37,7 @@ use crate::{
         },
         resolve_stmts, resolve_type,
     },
-    resolved::{self, Expr, ExprKind, FunctionRef, StructureRef, TypedExpr},
+    resolved::{self, Expr, ExprKind, FunctionRef, StructureRef, TypeKind, TypedExpr},
 };
 use ast::FloatSize;
 pub use basic_binary_operation::resolve_basic_binary_operator;
@@ -227,6 +227,34 @@ pub fn resolve_expr(
                 let expr = Expr::new(ExprKind::AddressOf(Box::new(destination)), source);
                 return Ok(TypedExpr::new(result_type, expr));
             }
+            UnaryOperator::Dereference => {
+                let resolved_expr = resolve_expr(
+                    ctx,
+                    &unary_operation.inner,
+                    preferred_type,
+                    Initialized::Require,
+                )?;
+
+                let result_type = match &resolved_expr.resolved_type.kind {
+                    TypeKind::Pointer(inner)
+                        if !resolved_expr.resolved_type.kind.is_ambiguous() =>
+                    {
+                        (**inner).clone()
+                    }
+                    _ => {
+                        return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
+                            operator: "(dereference) *".into(),
+                            bad_type: resolved_expr.resolved_type.to_string(),
+                        }
+                        .at(source));
+                    }
+                };
+
+                return Ok(TypedExpr::new(
+                    result_type,
+                    Expr::new(ExprKind::Dereference(Box::new(resolved_expr)), source),
+                ));
+            }
         },
         ast::ExprKind::Conditional(conditional) => {
             resolve_conditional_expr(ctx, conditional, preferred_type, source)
diff --git a/src/resolve/expr/unary_operation.rs b/src/resolve/expr/unary_operation.rs
@@ -2,7 +2,7 @@ use super::{resolve_expr, PreferredType, ResolveExprCtx};
 use crate::{
     ast::{self, UnaryMathOperator},
     resolve::{
-        conform::to_default::conform_integer_literal_to_default_or_error,
+        conform::to_default::conform_expr_to_default,
         error::{ResolveError, ResolveErrorKind},
         Initialized,
     },
@@ -17,70 +17,32 @@ pub fn resolve_unary_math_operation_expr(
     preferred_type: Option<PreferredType>,
     source: Source,
 ) -> Result<TypedExpr, ResolveError> {
-    let resolved_expr = resolve_expr(ctx, inner, preferred_type, Initialized::Require)?;
+    let resolved_expr = resolve_expr(ctx, inner, preferred_type, Initialized::Require)
+        .and_then(conform_expr_to_default)?;
 
-    if operator.is_dereference() {
-        if resolved_expr.resolved_type.kind.is_ambiguous_type() {
-            return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: operator.to_string(),
-                bad_type: resolved_expr.resolved_type.to_string(),
-            }
-            .at(source));
+    if resolved_expr.resolved_type.is_ambiguous() {
+        return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
+            operator: operator.to_string(),
+            bad_type: resolved_expr.resolved_type.to_string(),
         }
-
-        let result_type = if let TypeKind::Pointer(inner) = &resolved_expr.resolved_type.kind {
-            (**inner).clone()
-        } else {
-            return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: operator.to_string(),
-                bad_type: resolved_expr.resolved_type.to_string(),
-            }
-            .at(source));
-        };
-
-        let expr = Expr::new(
-            ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
-                operator: operator.clone(),
-                inner: resolved_expr,
-            })),
-            source,
-        );
-
-        return Ok(TypedExpr::new(result_type, expr));
+        .at(source));
     }
 
-    let resolved_expr = match &resolved_expr.resolved_type.kind {
-        TypeKind::Boolean => resolved_expr,
-        TypeKind::Integer(..) => resolved_expr,
-        TypeKind::IntegerLiteral(value) => {
-            conform_integer_literal_to_default_or_error(value, resolved_expr.expr.source)?
-        }
-        _ => {
-            return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                operator: operator.to_string(),
-                bad_type: resolved_expr.resolved_type.to_string(),
-            }
-            .at(source));
-        }
-    };
-
     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::UnaryMathOperation(Box::new(UnaryMathOperation {
-            operator: operator.clone(),
-            inner: resolved_expr,
-        })),
-        source,
-    );
-
-    Ok(TypedExpr::new(result_type, expr))
+    Ok(TypedExpr::new(
+        result_type,
+        Expr::new(
+            ExprKind::UnaryMathOperation(Box::new(UnaryMathOperation {
+                operator: operator.clone(),
+                inner: resolved_expr,
+            })),
+            source,
+        ),
+    ))
 }
diff --git a/src/resolved/mod.rs b/src/resolved/mod.rs
@@ -126,6 +126,10 @@ impl Type {
     pub fn pointer(self, source: Source) -> Self {
         TypeKind::Pointer(Box::new(self)).at(source)
     }
+
+    pub fn is_ambiguous(&self) -> bool {
+        self.kind.is_ambiguous()
+    }
 }
 
 impl Display for Type {
@@ -214,7 +218,7 @@ impl TypeKind {
         )
     }
 
-    pub fn is_ambiguous_type(&self) -> bool {
+    pub fn is_ambiguous(&self) -> bool {
         self.is_integer_literal()
     }
 }
@@ -424,6 +428,7 @@ pub enum ExprKind {
     Member(Box<Member>),
     StructureLiteral(Box<StructureLiteral>),
     UnaryMathOperation(Box<UnaryMathOperation>),
+    Dereference(Box<TypedExpr>),
     AddressOf(Box<Destination>),
     Conditional(Box<Conditional>),
     While(Box<While>),

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ pub enum UnaryMathOperator {`
`14`	`14`	`BitComplement,`
`15`	`15`	`Negate,`
`16`	`16`	`IsNonZero,`
`17`		`- Dereference,`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`impl Display for UnaryMathOperator {`
`@@ -24,7 +23,6 @@ impl Display for UnaryMathOperator {`
`24`	`23`	`Self::BitComplement => "~",`
`25`	`24`	`Self::Negate => "-",`
`26`	`25`	`Self::IsNonZero => "bool()",`
`27`		`- Self::Dereference => "(dereference) *",`
`28`	`26`	`})`
`29`	`27`	`}`
`30`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,7 @@ pub fn resolve_expr_to_destination(typed_expr: TypedExpr) -> Result<Destination,`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`ExprKind::ArrayAccess(array_access) => DestinationKind::ArrayAccess(array_access),`
`27`		`- ExprKind::UnaryMathOperation(unary_operation)`
`28`		`- if unary_operation.operator.is_dereference() =>`
`29`		`- {`
`30`		`- DestinationKind::Dereference(unary_operation.inner.expr)`
`31`		`- }`
	`27`	`+ ExprKind::Dereference(subject) => DestinationKind::Dereference(subject.expr),`
`32`	`28`	`_ => {`
`33`	`29`	`return Err(ResolveErrorKind::CannotMutate {`
`34`	`30`	`bad_type: typed_expr.resolved_type.to_string(),`
Original file line number	Diff line number	Diff line change
`@@ -126,6 +126,10 @@ impl Type {`
`126`	`126`	`pub fn pointer(self, source: Source) -> Self {`
`127`	`127`	`TypeKind::Pointer(Box::new(self)).at(source)`
`128`	`128`	`}`
	`129`	`+`
	`130`	`+ pub fn is_ambiguous(&self) -> bool {`
	`131`	`+ self.kind.is_ambiguous()`
	`132`	`+ }`
`129`	`133`	`}`
`130`	`134`
`131`	`135`	`impl Display for Type {`
`@@ -214,7 +218,7 @@ impl TypeKind {`
`214`	`218`	`)`
`215`	`219`	`}`
`216`	`220`
`217`		`- pub fn is_ambiguous_type(&self) -> bool {`
	`221`	`+ pub fn is_ambiguous(&self) -> bool {`
`218`	`222`	`self.is_integer_literal()`
`219`	`223`	`}`
`220`	`224`	`}`
`@@ -424,6 +428,7 @@ pub enum ExprKind {`
`424`	`428`	`Member(Box<Member>),`
`425`	`429`	`StructureLiteral(Box<StructureLiteral>),`
`426`	`430`	`UnaryMathOperation(Box<UnaryMathOperation>),`
	`431`	`+ Dereference(Box<TypedExpr>),`
`427`	`432`	`AddressOf(Box<Destination>),`
`428`	`433`	`Conditional(Box<Conditional>),`
`429`	`434`	`While(Box<While>),`