Finished initial implementation of address-of and dereference operators

Author: IsaacShelton

Diff for: src/lower/mod.rs

@@ -437,15 +437,13 @@ fn lower_destination(
                 index,
             }))
         }
-        DestinationKind::Dereference(pointer_lvalue) => {
-            let pointer_rvalue =
-                lower_expr(builder, ir_module, pointer_lvalue, function, resolved_ast)?;
-
-            let result_pointer_type =
-                lower_type(&ir_module.target, &destination.resolved_type, resolved_ast)?;
-
-            Ok(builder.push(ir::Instruction::Load((pointer_rvalue, result_pointer_type))))
-        }
+        DestinationKind::Dereference(lvalue) => Ok(lower_expr(
+            builder,
+            ir_module,
+            lvalue,
+            function,
+            resolved_ast,
+        )?),
     }
 }
 
@@ -756,12 +754,16 @@ fn lower_expr(
                 resolved::UnaryOperator::BitComplement => ir::Instruction::BitComplement(inner),
                 resolved::UnaryOperator::Negate => ir::Instruction::Negate(inner),
                 resolved::UnaryOperator::IsNonZero => ir::Instruction::IsNonZero(inner),
-                resolved::UnaryOperator::AddressOf => {
-                    unimplemented!("address of operator");
-                }
+                resolved::UnaryOperator::AddressOf => unreachable!(),
                 resolved::UnaryOperator::Dereference => ir::Instruction::Load((inner, inner_type)),
             }))
         }
+        ExprKind::AddressOf(destination) => {
+            let subject_pointer =
+                lower_destination(builder, ir_module, destination, function, resolved_ast)?;
+
+            Ok(subject_pointer)
+        }
         ExprKind::Conditional(conditional) => {
             let resume_basicblock_id = builder.new_block();
 

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -88,10 +88,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                             let ast_type = self.parse_type_from_parts(name, generics, source)?;
                             self.parse_structure_literal_with(ast_type)
                         } else {
-                            let next_three =
+                            let last_two =
                                 array_last::<2, 4, _>(self.input.peek_n()).map(|token| &token.kind);
 
-                            match &next_three[..] {
+                            match &last_two[..] {
                                 [TokenKind::Colon, ..]
                                 | [TokenKind::Identifier(_), TokenKind::Colon, ..] => {
                                     let ast_type =

Diff for: src/resolve/expr/unary_operation.rs

@@ -3,6 +3,7 @@ use crate::{
     ast::{self, UnaryOperator},
     resolve::{
         conform::to_default::conform_integer_literal_to_default_or_error,
+        destination::resolve_expr_to_destination,
         error::{ResolveError, ResolveErrorKind},
         Initialized,
     },
@@ -25,7 +26,14 @@ pub fn resolve_unary_operation_expr(
 
     let operator = &unary_operation.operator;
 
-    if operator.is_address_of() || operator.is_dereference() {
+    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));
+    }
+
+    if operator.is_dereference() {
         if resolved_expr.resolved_type.kind.is_ambiguous_type() {
             return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
                 operator: unary_operation.operator.to_string(),
@@ -34,20 +42,15 @@ pub fn resolve_unary_operation_expr(
             .at(source));
         }
 
-        let mut result_type = resolved_expr.resolved_type.clone();
-        if operator.is_dereference() {
-            if let TypeKind::Pointer(inner) = result_type.kind {
-                result_type = *inner;
-            } else {
-                return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
-                    operator: unary_operation.operator.to_string(),
-                    bad_type: resolved_expr.resolved_type.to_string(),
-                }
-                .at(source));
+        let result_type = if let TypeKind::Pointer(inner) = &resolved_expr.resolved_type.kind {
+            (**inner).clone()
+        } else {
+            return Err(ResolveErrorKind::CannotPerformUnaryOperationForType {
+                operator: unary_operation.operator.to_string(),
+                bad_type: resolved_expr.resolved_type.to_string(),
             }
-        } else if operator.is_address_of() {
-            result_type = TypeKind::Pointer(Box::new(result_type)).at(source);
-        }
+            .at(source));
+        };
 
         let expr = Expr::new(
             ExprKind::UnaryOperation(Box::new(UnaryOperation {
@@ -78,10 +81,9 @@ pub fn resolve_unary_operation_expr(
     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::AddressOf => {
-            TypeKind::Pointer(Box::new(resolved_expr.resolved_type.clone())).at(source)
+        UnaryOperator::Dereference | UnaryOperator::AddressOf => {
+            unreachable!("should've already handled address-of/dereference operators")
         }
-        UnaryOperator::Dereference => resolved_expr.resolved_type.clone(),
     };
 
     let expr = Expr::new(

Diff for: src/resolved/mod.rs

@@ -122,6 +122,12 @@ pub struct Type {
     pub source: Source,
 }
 
+impl Type {
+    pub fn pointer(self, source: Source) -> Self {
+        TypeKind::Pointer(Box::new(self)).at(source)
+    }
+}
+
 impl Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(&self.kind, f)
@@ -418,6 +424,7 @@ pub enum ExprKind {
     Member(Box<Member>),
     StructureLiteral(Box<StructureLiteral>),
     UnaryOperation(Box<UnaryOperation>),
+    AddressOf(Box<Destination>),
     Conditional(Box<Conditional>),
     While(Box<While>),
     ArrayAccess(Box<ArrayAccess>),

Diff for: tests/pointers/main.adept

@@ -0,0 +1,19 @@
+
+#[foreign]
+func printf(format ptr<char>, ...) int
+
+func main {
+    message i32 = 0x41000041
+    printf(c"&message = %s\n", &message)
+
+    stair long = 0
+    stair_ptr ptr<long> = &stair
+    *stair_ptr = 1234
+    printf(c"*stair_ptr = %ld\n", *stair_ptr)
+
+    pi := 0.0
+    pi_ptr ptr<double> = &pi
+    *pi_ptr = 3.14159
+    printf(c"PI = %f\n", pi)
+}
+

Diff for: tests/run.sh

@@ -51,6 +51,7 @@ compile nested_expressions
 compile object_mutation
 compile op_then_assign
 compile_module preprocessor_toggle
+compile pointers
 compile reference_counted
 compile return
 compile return_message