add array multiplication operator

doc/langref.md

@@ -121,7 +121,7 @@ MultiplyExpression = CurlySuffixExpression MultiplyOperator MultiplyExpression |
 
 CurlySuffixExpression = TypeExpr option(ContainerInitExpression)
 
-MultiplyOperator = "*" | "/" | "%"
+MultiplyOperator = "*" | "/" | "%" | "**"
 
 PrefixOpExpression = PrefixOp PrefixOpExpression | SuffixOpExpression
 

src/all_types.hpp

@@ -342,6 +342,7 @@ enum BinOpType {
     BinOpTypeMod,
     BinOpTypeUnwrapMaybe,
     BinOpTypeStrCat,
+    BinOpTypeArrayMult,
 };
 
 struct AstNodeBinOpExpr {

src/analyze.cpp

@@ -2937,6 +2937,7 @@ static bool is_op_allowed(TypeTableEntry *type, BinOpType op) {
         case BinOpTypeMod:
         case BinOpTypeUnwrapMaybe:
         case BinOpTypeStrCat:
+        case BinOpTypeArrayMult:
             zig_unreachable();
     }
     zig_unreachable();
@@ -3121,9 +3122,93 @@ static TypeTableEntry *analyze_logic_bin_op_expr(CodeGen *g, ImportTableEntry *i
     return g->builtin_types.entry_bool;
 }
 
+static TypeTableEntry *analyze_array_mult(CodeGen *g, ImportTableEntry *import, BlockContext *context,
+        TypeTableEntry *expected_type, AstNode *node)
+{
+    assert(node->type == NodeTypeBinOpExpr);
+    assert(node->data.bin_op_expr.bin_op == BinOpTypeArrayMult);
+
+    AstNode **op1 = node->data.bin_op_expr.op1->parent_field;
+    AstNode **op2 = node->data.bin_op_expr.op2->parent_field;
+
+    TypeTableEntry *op1_type = analyze_expression(g, import, context, nullptr, *op1);
+    TypeTableEntry *op2_type = analyze_expression(g, import, context, nullptr, *op2);
+
+    if (op1_type->id == TypeTableEntryIdInvalid ||
+        op2_type->id == TypeTableEntryIdInvalid)
+    {
+        return g->builtin_types.entry_invalid;
+    }
+
+    ConstExprValue *op1_val = &get_resolved_expr(*op1)->const_val;
+    ConstExprValue *op2_val = &get_resolved_expr(*op2)->const_val;
+
+    AstNode *bad_node;
+    if (!op1_val->ok) {
+        bad_node = *op1;
+    } else if (!op2_val->ok) {
+        bad_node = *op2;
+    } else {
+        bad_node = nullptr;
+    }
+    if (bad_node) {
+        add_node_error(g, bad_node, buf_sprintf("array multiplication requires constant expression"));
+        return g->builtin_types.entry_invalid;
+    }
+
+    if (op1_type->id != TypeTableEntryIdArray) {
+        add_node_error(g, *op1,
+            buf_sprintf("expected array type, got '%s'", buf_ptr(&op1_type->name)));
+        return g->builtin_types.entry_invalid;
+    }
+
+    if (op2_type->id != TypeTableEntryIdNumLitInt &&
+        op2_type->id != TypeTableEntryIdInt)
+    {
+        add_node_error(g, *op2, buf_sprintf("expected integer type, got '%s'", buf_ptr(&op2_type->name)));
+        return g->builtin_types.entry_invalid;
+    }
+
+    if (op2_val->data.x_bignum.is_negative) {
+        add_node_error(g, *op2, buf_sprintf("expected positive number"));
+        return g->builtin_types.entry_invalid;
+    }
+
+    ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
+    const_val->ok = true;
+    const_val->depends_on_compile_var = op1_val->depends_on_compile_var || op2_val->depends_on_compile_var;
+
+    TypeTableEntry *child_type = op1_type->data.array.child_type;
+    BigNum old_array_len;
+    bignum_init_unsigned(&old_array_len, op1_type->data.array.len);
+
+    BigNum new_array_len;
+    if (bignum_mul(&new_array_len, &old_array_len, &op2_val->data.x_bignum)) {
+        add_node_error(g, node, buf_sprintf("operation results in overflow"));
+        return g->builtin_types.entry_invalid;
+    }
+
+    uint64_t old_array_len_bare = op1_type->data.array.len;
+    uint64_t operand_amt = op2_val->data.x_bignum.data.x_uint;
+
+    uint64_t new_array_len_bare = new_array_len.data.x_uint;
+    const_val->data.x_array.fields = allocate<ConstExprValue*>(new_array_len_bare);
+
+    uint64_t i = 0;
+    for (uint64_t x = 0; x < operand_amt; x += 1) {
+        for (uint64_t y = 0; y < old_array_len_bare; y += 1) {
+            const_val->data.x_array.fields[i] = op1_val->data.x_array.fields[y];
+            i += 1;
+        }
+    }
+
+    return get_array_type(g, child_type, new_array_len_bare);
+}
+
 static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
         TypeTableEntry *expected_type, AstNode *node)
 {
+    assert(node->type == NodeTypeBinOpExpr);
     BinOpType bin_op_type = node->data.bin_op_expr.bin_op;
     switch (bin_op_type) {
         case BinOpTypeAssign:
@@ -3320,6 +3405,8 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import,
 
                 return str_type;
             }
+        case BinOpTypeArrayMult:
+            return analyze_array_mult(g, import, context, expected_type, node);
         case BinOpTypeInvalid:
             zig_unreachable();
     }

src/ast_render.cpp

@@ -38,6 +38,7 @@ static const char *bin_op_str(BinOpType bin_op) {
         case BinOpTypeAssignBoolOr:        return "||=";
         case BinOpTypeUnwrapMaybe:         return "??";
         case BinOpTypeStrCat:              return "++";
+        case BinOpTypeArrayMult:           return "**";
     }
     zig_unreachable();
 }

src/codegen.cpp

@@ -1466,6 +1466,7 @@ static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
         case BinOpTypeAssignBoolOr:
         case BinOpTypeUnwrapMaybe:
         case BinOpTypeStrCat:
+        case BinOpTypeArrayMult:
             zig_unreachable();
     }
     zig_unreachable();
@@ -1772,6 +1773,7 @@ static LLVMValueRef gen_bin_op_expr(CodeGen *g, AstNode *node) {
     switch (node->data.bin_op_expr.bin_op) {
         case BinOpTypeInvalid:
         case BinOpTypeStrCat:
+        case BinOpTypeArrayMult:
             zig_unreachable();
         case BinOpTypeAssign:
         case BinOpTypeAssignTimes:

src/eval.cpp

@@ -232,7 +232,7 @@ int eval_const_expr_bin_op(ConstExprValue *op1_val, TypeTableEntry *op1_type,
         case BinOpTypeUnwrapMaybe:
             zig_panic("TODO");
         case BinOpTypeStrCat:
-            zig_panic("TODO");
+        case BinOpTypeArrayMult:
         case BinOpTypeInvalid:
             zig_unreachable();
     }

src/parser.cpp

@@ -1297,6 +1297,7 @@ static PrefixOp tok_to_prefix_op(Token *token) {
         case TokenIdPercentPercent: return PrefixOpUnwrapError;
         case TokenIdDoubleQuestion: return PrefixOpUnwrapMaybe;
         case TokenIdBoolAnd: return PrefixOpAddressOf;
+        case TokenIdStarStar: return PrefixOpDereference;
         default: return PrefixOpInvalid;
     }
 }
@@ -1331,6 +1332,14 @@ static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, boo
         parent_node->data.prefix_op_expr.primary_expr = node;
         parent_node->data.prefix_op_expr.prefix_op = PrefixOpAddressOf;
 
+        node->column += 1;
+    } else if (token->id == TokenIdStarStar) {
+        // pretend that we got 2 star tokens
+
+        parent_node = ast_create_node(pc, NodeTypePrefixOpExpr, token);
+        parent_node->data.prefix_op_expr.primary_expr = node;
+        parent_node->data.prefix_op_expr.prefix_op = PrefixOpDereference;
+
         node->column += 1;
     }
 
@@ -1355,6 +1364,7 @@ static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, boo
 static BinOpType tok_to_mult_op(Token *token) {
     switch (token->id) {
         case TokenIdStar: return BinOpTypeMult;
+        case TokenIdStarStar: return BinOpTypeArrayMult;
         case TokenIdSlash: return BinOpTypeDiv;
         case TokenIdPercent: return BinOpTypeMod;
         default: return BinOpTypeInvalid;
@@ -1362,7 +1372,7 @@ static BinOpType tok_to_mult_op(Token *token) {
 }
 
 /*
-MultiplyOperator : token(Star) | token(Slash) | token(Percent)
+MultiplyOperator = "*" | "/" | "%" | "**"
 */
 static BinOpType ast_parse_mult_op(ParseContext *pc, int *token_index, bool mandatory) {
     Token *token = &pc->tokens->at(*token_index);

src/tokenizer.cpp

@@ -626,6 +626,11 @@ void tokenize(Buf *buf, Tokenization *out) {
                         end_token(&t);
                         t.state = TokenizeStateStart;
                         break;
+                    case '*':
+                        t.cur_tok->id = TokenIdStarStar;
+                        end_token(&t);
+                        t.state = TokenizeStateStart;
+                        break;
                     default:
                         t.pos -= 1;
                         end_token(&t);
@@ -1235,6 +1240,7 @@ const char * token_name(TokenId id) {
         case TokenIdRParen: return ")";
         case TokenIdComma: return ",";
         case TokenIdStar: return "*";
+        case TokenIdStarStar: return "**";
         case TokenIdLBrace: return "{";
         case TokenIdRBrace: return "}";
         case TokenIdLBracket: return "[";

src/tokenizer.hpp

@@ -47,6 +47,7 @@ enum TokenId {
     TokenIdRParen,
     TokenIdComma,
     TokenIdStar,
+    TokenIdStarStar,
     TokenIdLBrace,
     TokenIdRBrace,
     TokenIdLBracket,

test/self_hosted.zig

@@ -1392,3 +1392,9 @@ fn test_take_address_of_parameter_noeval(f: f32) {
     const f_ptr = &f;
     assert(*f_ptr == 12.34);
 }
+
+
+#attribute("test")
+fn array_mult_operator() {
+    assert(str.eql("ab" ** 5, "ababababab"));
+}