Added support for C address-of expressions

Author: IsaacShelton

Diff for: src/c/parser/expr.rs

@@ -41,6 +41,7 @@ pub enum ExprKind {
     Identifier(String),
     EnumConstant(String, Integer),
     CompoundLiteral(Box<CompoundLiteral>),
+    AddressOf(Box<Expr>),
 }
 
 impl ExprKind {
@@ -353,8 +354,13 @@ impl<'a> Parser<'a> {
     pub fn parse_expr_primary_base(&mut self) -> Result<Expr, ParseError> {
         // Parse sequence of unary operators and casts
 
+        let source = self.input.peek().source;
+
         match &self.input.peek().kind {
-            CTokenKind::Punctuator(Punctuator::Ampersand) => todo!(),
+            CTokenKind::Punctuator(Punctuator::Ampersand) => {
+                let inner = self.parse_expr_primary()?;
+                return Ok(ExprKind::AddressOf(Box::new(inner)).at(source));
+            }
             CTokenKind::Punctuator(Punctuator::Multiply) => todo!(),
             CTokenKind::Punctuator(Punctuator::Add) => todo!(),
             CTokenKind::Punctuator(Punctuator::Subtract) => todo!(),

Diff for: src/c/translation/eval.rs

@@ -45,7 +45,8 @@ pub fn evaluate_to_const_integer(expr: &Expr) -> Result<BigInt, ParseError> {
         | ExprKind::Compound(_)
         | ExprKind::PostIncrement(_)
         | ExprKind::PostDecrement(_)
-        | ExprKind::CompoundLiteral(_) => (),
+        | ExprKind::CompoundLiteral(_)
+        | ExprKind::AddressOf(_) => (),
     }
 
     Err(ParseErrorKind::MustBeConstantInteger.at(expr.source))

Diff for: src/c/translation/expr/mod.rs

@@ -8,7 +8,7 @@ use self::{
     string::translate_expr_string,
 };
 use crate::{
-    ast::{self, AstFile},
+    ast::{self, AstFile, UnaryOperation, UnaryOperator},
     c::parser::{
         error::ParseErrorKind,
         expr::{Expr, ExprKind},
@@ -52,5 +52,10 @@ pub fn translate_expr(
             expr.source,
             diagnostics,
         )?,
+        ExprKind::AddressOf(inner) => ast::ExprKind::UnaryOperation(Box::new(UnaryOperation {
+            operator: UnaryOperator::AddressOf,
+            inner: translate_expr(ast_file, typedefs, inner, diagnostics)?,
+        }))
+        .at(expr.source),
     })
 }

Diff for: src/resolve/polymorph/resolver.rs

@@ -44,7 +44,7 @@ impl<'a> PolyRecipeResolver<'a> {
 
     pub fn resolve_type(&self, ty: &asg::Type) -> Result<asg::Type, PolymorphError> {
         Ok(match &ty.kind {
-            asg::TypeKind::Unresolved => panic!(),
+            asg::TypeKind::Unresolved => panic!("unresolved type"),
             asg::TypeKind::Boolean
             | asg::TypeKind::Integer(_, _)
             | asg::TypeKind::CInteger(_, _)