diff --git a/README.md b/README.md
index ec6798cfbd..5bc0fdf041 100644
--- a/README.md
+++ b/README.md
@@ -138,18 +138,18 @@ MultiplyExpression : CastExpression MultiplyOperator CastExpression | CastExpres
 
 MultiplyOperator : token(Star) | token(Slash) | token(Percent)
 
-CastExpression : UnaryExpression token(as) Type | UnaryExpression
+CastExpression : PrefixOpExpression token(as) Type | PrefixOpExpression
 
-UnaryExpression : UnaryOp PrimaryExpression | PrimaryExpression
+PrefixOpExpression : PrefixOp FnCallExpression | FnCallExpression
 
-UnaryOp : token(Not) | token(Dash) | token(Tilde)
+FnCallExpression : PrimaryExpression token(LParen) list(Expression, token(Comma)) token(RParen)
 
-PrimaryExpression : token(Number) | token(String) | token(Unreachable) | FnCall | GroupedExpression | Block
+PrefixOp : token(Not) | token(Dash) | token(Tilde)
+
+PrimaryExpression : token(Number) | token(String) | token(Unreachable) | GroupedExpression | Block
 
 GroupedExpression : token(LParen) Expression token(RParen)
 
-FnCall : token(Symbol) token(LParen) list(Expression, token(Comma)) token(RParen)
-
 Directive : token(NumberSign) token(Symbol) token(LParen) token(String) token(RParen)
 ```
 
diff --git a/example/math.zig b/example/math.zig
index aa135426e8..af5b9a706a 100644
--- a/example/math.zig
+++ b/example/math.zig
@@ -3,4 +3,3 @@ export library "math";
 export fn add(a: i32, b: i32) -> i32 {
     return a + b;
 }
-
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 4ecceaabdd..ba57bcb1fb 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -317,7 +317,7 @@ static void find_declarations(CodeGen *g, AstNode *node) {
         case NodeTypeAddExpr:
         case NodeTypeMultExpr:
         case NodeTypeCastExpr:
-        case NodeTypeUnaryExpr:
+        case NodeTypePrefixOpExpr:
         case NodeTypePrimaryExpr:
         case NodeTypeGroupedExpr:
             zig_unreachable();
@@ -543,7 +543,7 @@ static void analyze_node(CodeGen *g, AstNode *node) {
         case NodeTypeCastExpr:
             zig_panic("TODO");
             break;
-        case NodeTypeUnaryExpr:
+        case NodeTypePrefixOpExpr:
             zig_panic("TODO");
             break;
         case NodeTypePrimaryExpr:
@@ -744,26 +744,26 @@ static LLVMValueRef gen_primary_expr(CodeGen *g, AstNode *node) {
     zig_unreachable();
 }
 
-static LLVMValueRef gen_unary_expr(CodeGen *g, AstNode *node) {
-    assert(node->type == NodeTypeUnaryExpr);
-    assert(node->data.unary_expr.primary_expr);
+static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
+    assert(node->type == NodeTypePrefixOpExpr);
+    assert(node->data.prefix_op_expr.primary_expr);
 
-    LLVMValueRef expr = gen_expr(g, node->data.unary_expr.primary_expr);
+    LLVMValueRef expr = gen_expr(g, node->data.prefix_op_expr.primary_expr);
 
-    switch (node->data.unary_expr.unary_op) {
-        case UnaryOpNegation:
+    switch (node->data.prefix_op_expr.prefix_op) {
+        case PrefixOpNegation:
             add_debug_source_node(g, node);
             return LLVMBuildNeg(g->builder, expr, "");
-        case UnaryOpBoolNot:
+        case PrefixOpBoolNot:
             {
                 LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(expr));
                 add_debug_source_node(g, node);
                 return LLVMBuildICmp(g->builder, LLVMIntEQ, expr, zero, "");
             }
-        case UnaryOpBinNot:
+        case PrefixOpBinNot:
             add_debug_source_node(g, node);
             return LLVMBuildNot(g->builder, expr, "");
-        case UnaryOpInvalid:
+        case PrefixOpInvalid:
             zig_unreachable();
     }
 
@@ -772,7 +772,7 @@ static LLVMValueRef gen_unary_expr(CodeGen *g, AstNode *node) {
 static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
     assert(node->type == NodeTypeCastExpr);
 
-    LLVMValueRef expr = gen_expr(g, node->data.cast_expr.unary_expr);
+    LLVMValueRef expr = gen_expr(g, node->data.cast_expr.prefix_op_expr);
 
     if (!node->data.cast_expr.type)
         return expr;
@@ -1026,8 +1026,8 @@ static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) {
             return gen_bool_or_expr(g, node);
         case NodeTypeReturnExpr:
             return gen_return_expr(g, node);
-        case NodeTypeUnaryExpr:
-            return gen_unary_expr(g, node);
+        case NodeTypePrefixOpExpr:
+            return gen_prefix_op_expr(g, node);
         case NodeTypeRoot:
         case NodeTypeRootExportDecl:
         case NodeTypeFnProto:
diff --git a/src/parser.cpp b/src/parser.cpp
index 00a180dadc..fef57df58e 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -10,12 +10,12 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-static const char *unary_op_str(UnaryOp unary_op) {
-    switch (unary_op) {
-        case UnaryOpInvalid: return "(invalid)";
-        case UnaryOpNegation: return "-";
-        case UnaryOpBoolNot: return "!";
-        case UnaryOpBinNot: return "~";
+static const char *prefix_op_str(PrefixOp prefix_op) {
+    switch (prefix_op) {
+        case PrefixOpInvalid: return "(invalid)";
+        case PrefixOpNegation: return "-";
+        case PrefixOpBoolNot: return "!";
+        case PrefixOpBinNot: return "~";
     }
     zig_unreachable();
 }
@@ -126,8 +126,8 @@ const char *node_type_str(NodeType node_type) {
             return "PrimaryExpr";
         case NodeTypeGroupedExpr:
             return "GroupedExpr";
-        case NodeTypeUnaryExpr:
-            return "UnaryExpr";
+        case NodeTypePrefixOpExpr:
+            return "PrefixOpExpr";
     }
     zig_unreachable();
 }
@@ -296,14 +296,14 @@ void ast_print(AstNode *node, int indent) {
             break;
         case NodeTypeCastExpr:
             fprintf(stderr, "%s\n", node_type_str(node->type));
-            ast_print(node->data.cast_expr.unary_expr, indent + 2);
+            ast_print(node->data.cast_expr.prefix_op_expr, indent + 2);
             if (node->data.cast_expr.type)
                 ast_print(node->data.cast_expr.type, indent + 2);
             break;
-        case NodeTypeUnaryExpr:
+        case NodeTypePrefixOpExpr:
             fprintf(stderr, "%s %s\n", node_type_str(node->type),
-                    unary_op_str(node->data.unary_expr.unary_op));
-            ast_print(node->data.unary_expr.primary_expr, indent + 2);
+                    prefix_op_str(node->data.prefix_op_expr.prefix_op));
+            ast_print(node->data.prefix_op_expr.primary_expr, indent + 2);
             break;
         case NodeTypePrimaryExpr:
             switch (node->data.primary_expr.type) {
@@ -705,26 +705,26 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool
     ast_invalid_token_error(pc, token);
 }
 
-static UnaryOp tok_to_unary_op(Token *token) {
+static PrefixOp tok_to_prefix_op(Token *token) {
     switch (token->id) {
-        case TokenIdBang: return UnaryOpBoolNot;
-        case TokenIdDash: return UnaryOpNegation;
-        case TokenIdTilde: return UnaryOpBinNot;
-        default: return UnaryOpInvalid;
+        case TokenIdBang: return PrefixOpBoolNot;
+        case TokenIdDash: return PrefixOpNegation;
+        case TokenIdTilde: return PrefixOpBinNot;
+        default: return PrefixOpInvalid;
     }
 }
 
 /*
-UnaryOp : token(Not) | token(Dash) | token(Tilde)
+PrefixOp : token(Not) | token(Dash) | token(Tilde)
 */
-static UnaryOp ast_parse_unary_op(ParseContext *pc, int *token_index, bool mandatory) {
+static PrefixOp ast_parse_prefix_op(ParseContext *pc, int *token_index, bool mandatory) {
     Token *token = &pc->tokens->at(*token_index);
-    UnaryOp result = tok_to_unary_op(token);
-    if (result == UnaryOpInvalid) {
+    PrefixOp result = tok_to_prefix_op(token);
+    if (result == PrefixOpInvalid) {
         if (mandatory) {
             ast_invalid_token_error(pc, token);
         } else {
-            return UnaryOpInvalid;
+            return PrefixOpInvalid;
         }
     }
     *token_index += 1;
@@ -732,38 +732,38 @@ static UnaryOp ast_parse_unary_op(ParseContext *pc, int *token_index, bool manda
 }
 
 /*
-UnaryExpression : UnaryOp PrimaryExpression | PrimaryExpression
+PrefixOpExpression : PrefixOp PrimaryExpression | PrimaryExpression
 */
-static AstNode *ast_parse_unary_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, bool mandatory) {
     Token *token = &pc->tokens->at(*token_index);
-    UnaryOp unary_op = ast_parse_unary_op(pc, token_index, false);
-    if (unary_op == UnaryOpInvalid)
+    PrefixOp prefix_op = ast_parse_prefix_op(pc, token_index, false);
+    if (prefix_op == PrefixOpInvalid)
         return ast_parse_primary_expr(pc, token_index, mandatory);
 
     AstNode *primary_expr = ast_parse_primary_expr(pc, token_index, true);
-    AstNode *node = ast_create_node(NodeTypeUnaryExpr, token);
-    node->data.unary_expr.primary_expr = primary_expr;
-    node->data.unary_expr.unary_op = unary_op;
+    AstNode *node = ast_create_node(NodeTypePrefixOpExpr, token);
+    node->data.prefix_op_expr.primary_expr = primary_expr;
+    node->data.prefix_op_expr.prefix_op = prefix_op;
 
     return node;
 }
 
 
 /*
-CastExpression : UnaryExpression token(as) Type | UnaryExpression
+CastExpression : PrefixOpExpression token(as) Type | PrefixOpExpression
 */
 static AstNode *ast_parse_cast_expression(ParseContext *pc, int *token_index, bool mandatory) {
-    AstNode *unary_expr = ast_parse_unary_expr(pc, token_index, mandatory);
-    if (!unary_expr)
+    AstNode *prefix_op_expr = ast_parse_prefix_op_expr(pc, token_index, mandatory);
+    if (!prefix_op_expr)
         return nullptr;
 
     Token *as_kw = &pc->tokens->at(*token_index);
     if (as_kw->id != TokenIdKeywordAs)
-        return unary_expr;
+        return prefix_op_expr;
     *token_index += 1;
 
     AstNode *node = ast_create_node(NodeTypeCastExpr, as_kw);
-    node->data.cast_expr.unary_expr = unary_expr;
+    node->data.cast_expr.prefix_op_expr = prefix_op_expr;
 
     node->data.cast_expr.type = ast_parse_type(pc, *token_index, token_index);
 
diff --git a/src/parser.hpp b/src/parser.hpp
index da933c6dd4..f1a73d57b0 100644
--- a/src/parser.hpp
+++ b/src/parser.hpp
@@ -40,7 +40,7 @@ enum NodeType {
     NodeTypeCastExpr,
     NodeTypePrimaryExpr,
     NodeTypeGroupedExpr,
-    NodeTypeUnaryExpr,
+    NodeTypePrefixOpExpr,
 };
 
 struct AstNodeRoot {
@@ -205,7 +205,7 @@ struct AstNodeMultExpr {
 };
 
 struct AstNodeCastExpr {
-    AstNode *unary_expr;
+    AstNode *prefix_op_expr;
     // if type is non-null, do cast, otherwise nothing
     AstNode *type;
 };
@@ -234,15 +234,15 @@ struct AstNodeGroupedExpr {
     AstNode *expr;
 };
 
-enum UnaryOp {
-    UnaryOpInvalid,
-    UnaryOpBoolNot,
-    UnaryOpBinNot,
-    UnaryOpNegation,
+enum PrefixOp {
+    PrefixOpInvalid,
+    PrefixOpBoolNot,
+    PrefixOpBinNot,
+    PrefixOpNegation,
 };
 
-struct AstNodeUnaryExpr {
-    UnaryOp unary_op;
+struct AstNodePrefixOpExpr {
+    PrefixOp prefix_op;
     AstNode *primary_expr;
 };
 
@@ -277,7 +277,7 @@ struct AstNode {
         AstNodeCastExpr cast_expr;
         AstNodePrimaryExpr primary_expr;
         AstNodeGroupedExpr grouped_expr;
-        AstNodeUnaryExpr unary_expr;
+        AstNodePrefixOpExpr prefix_op_expr;
     } data;
 };