gitback/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

implicit casts rewrite the AST

Browse Source
This commit is contained in:
Andrew Kelley 2016-01-22 15:31:35 -07:00
parent b09a0cd072
commit 272fe1c54c
6 changed files with 637 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/all_types.hpp
View File

@ -22,7 +22,6 @@ struct FnTableEntry;
struct BlockContext;
struct TypeTableEntry;
struct VariableTableEntry;
struct Cast;
struct BuiltinFnEntry;
struct LabelTableEntry;
struct TypeStructField;
@ -41,15 +40,6 @@ enum CodeGenBuildType {
CodeGenBuildTypeRelease,
};
enum CastOp {
CastOpNothing,
CastOpPtrToInt,
CastOpIntWidenOrShorten,
CastOpToUnknownSizeArray,
CastOpMaybeWrap,
CastOpPointerReinterpret,
};
struct ConstEnumValue {
uint64_t tag;
ConstExprValue *payload;
@ -69,29 +59,15 @@ struct ConstExprValue {
} data;
};
struct Cast {
CastOp op;
// if op is CastOpArrayToString, this will be a pointer to
// the string struct on the stack
LLVMValueRef ptr;
TypeTableEntry *after_type;
AstNode *source_node;
ConstExprValue const_val;
};
struct Expr {
TypeTableEntry *type_entry;
TypeTableEntry *resolved_type;
// the context in which this expression is evaluated.
// for blocks, this points to the containing scope, not the block's own scope for its children.
BlockContext *block_context;
// may be null for no cast
Cast implicit_cast; // happens first
Cast implicit_maybe_cast; // happens second
LLVMValueRef const_llvm_val;
ConstExprValue const_val;
bool has_global_const;
};
struct StructValExprCodeGen {
@ -305,6 +281,16 @@ struct AstNodeBinOpExpr {
Expr resolved_expr;
};
enum CastOp {
CastOpNoCast, // signifies the function call expression is not a cast
CastOpNoop, // fn call expr is a cast, but does nothing
CastOpPtrToInt,
CastOpIntWidenOrShorten,
CastOpToUnknownSizeArray,
CastOpMaybeWrap,
CastOpPointerReinterpret,
};
struct AstNodeFnCallExpr {
AstNode *fn_ref_expr;
ZigList<AstNode *> params;
@ -313,8 +299,11 @@ struct AstNodeFnCallExpr {
// populated by semantic analyzer:
BuiltinFnEntry *builtin_fn;
Expr resolved_expr;
Cast cast;
FnTableEntry *fn_entry;
CastOp cast_op;
// if cast_op is CastOpArrayToString, this will be a pointer to
// the string struct on the stack
LLVMValueRef tmp_ptr;
};
struct AstNodeArrayAccessExpr {
@ -610,6 +599,8 @@ struct AstNodeSymbolExpr {
Expr resolved_expr;
VariableTableEntry *variable;
FnTableEntry *fn_entry;
// set this to instead of analyzing the node, pretend it's a type entry and it's this one.
TypeTableEntry *override_type_entry;
};
struct AstNodeBoolLiteral {
@ -644,6 +635,7 @@ struct AstNode {
int column;
uint32_t create_index; // for determinism purposes
ImportTableEntry *owner;
AstNode **parent_field; // for AST rewriting
union {
AstNodeRoot root;
AstNodeRootExportDecl root_export_decl;
@ -997,7 +989,7 @@ struct BlockContext {
BlockContext *parent; // null when this is the root
HashMap<Buf *, VariableTableEntry *, buf_hash, buf_eql_buf> variable_table;
HashMap<Buf *, TypeTableEntry *, buf_hash, buf_eql_buf> type_table;
ZigList<Cast *> cast_expr_alloca_list;
ZigList<AstNode *> cast_alloca_list;
ZigList<StructValExprCodeGen *> struct_val_expr_alloca_list;
ZigList<VariableTableEntry *> variable_list;
AstNode *parent_loop_node;

471
src/analyze.cpp
View File

@ -17,6 +17,8 @@ static VariableTableEntry *analyze_variable_declaration(CodeGen *g, ImportTableE
BlockContext *context, TypeTableEntry *expected_type, AstNode *node);
static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableEntry *struct_type);
static TypeTableEntry *unwrapped_node_type(AstNode *node);
static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
AstNode *node);
static AstNode *first_executing_node(AstNode *node) {
switch (node->type) {
@ -369,6 +371,9 @@ static TypeTableEntry *get_unknown_size_array_type(CodeGen *g, TypeTableEntry *c
// and returns invalid type. Otherwise, returns the type of the constant expression value.
// Must be called after analyze_expression on the same node.
static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
if (node->type == NodeTypeSymbol && node->data.symbol_expr.override_type_entry) {
return node->data.symbol_expr.override_type_entry;
}
Expr *expr = get_resolved_expr(node);
assert(expr->type_entry);
if (expr->type_entry->id == TypeTableEntryIdInvalid) {
@ -393,8 +398,9 @@ static TypeTableEntry *resolve_type(CodeGen *g, AstNode *node) {
static TypeTableEntry *analyze_type_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
AstNode *node)
{
analyze_expression(g, import, context, nullptr, node);
return resolve_type(g, node);
AstNode **node_ptr = node->parent_field;
analyze_expression(g, import, context, nullptr, *node_ptr);
return resolve_type(g, *node_ptr);
}
static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_table_entry,
@ -1044,12 +1050,43 @@ static TypeTableEntry *get_return_type(BlockContext *context) {
return unwrapped_node_type(return_type_node);
}
static bool type_has_codegen_value(TypeTableEntryId id) {
switch (id) {
case TypeTableEntryIdInvalid:
case TypeTableEntryIdMetaType:
case TypeTableEntryIdVoid:
case TypeTableEntryIdUnreachable:
case TypeTableEntryIdNumLitFloat:
case TypeTableEntryIdNumLitInt:
return false;
case TypeTableEntryIdBool:
case TypeTableEntryIdInt:
case TypeTableEntryIdFloat:
case TypeTableEntryIdPointer:
case TypeTableEntryIdArray:
case TypeTableEntryIdStruct:
case TypeTableEntryIdMaybe:
case TypeTableEntryIdError:
case TypeTableEntryIdEnum:
case TypeTableEntryIdFn:
return true;
}
zig_unreachable();
}
static void add_global_const_expr(CodeGen *g, Expr *expr) {
if (expr->const_val.ok && type_has_codegen_value(expr->type_entry->id) && !expr->has_global_const) {
g->global_const_list.append(expr);
expr->has_global_const = true;
}
}
static bool num_lit_fits_in_other_type(CodeGen *g, AstNode *literal_node, TypeTableEntry *other_type) {
Expr *expr = get_resolved_expr(literal_node);
ConstExprValue *const_val = &expr->const_val;
assert(const_val->ok);
if (other_type->id == TypeTableEntryIdFloat) {
expr->resolved_type = other_type;
return true;
} else if (other_type->id == TypeTableEntryIdInt &&
const_val->data.x_bignum.kind == BigNumKindInt)
@ -1057,7 +1094,6 @@ static bool num_lit_fits_in_other_type(CodeGen *g, AstNode *literal_node, TypeTa
if (bignum_fits_in_bits(&const_val->data.x_bignum, other_type->size_in_bits,
other_type->data.integral.is_signed))
{
expr->resolved_type = other_type;
return true;
}
} else if (other_type->id == TypeTableEntryIdNumLitFloat ||
@ -1145,39 +1181,74 @@ static TypeTableEntry *determine_peer_type_compatibility(CodeGen *g, AstNode *pa
return prev_type;
}
static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *context, AstNode *node,
TypeTableEntry *expected_type, TypeTableEntry *actual_type)
{
if (expected_type == nullptr)
return actual_type; // anything will do
static bool types_match_const_cast_only(TypeTableEntry *expected_type, TypeTableEntry *actual_type) {
if (expected_type == actual_type)
return expected_type; // match
if (expected_type->id == TypeTableEntryIdInvalid || actual_type->id == TypeTableEntryIdInvalid)
return expected_type; // already complained
if (actual_type->id == TypeTableEntryIdUnreachable)
return actual_type; // sorry toots; gotta run. good luck with that expected type.
return true;
// pointer const
if (expected_type->id == TypeTableEntryIdPointer &&
actual_type->id == TypeTableEntryIdPointer &&
(!actual_type->data.pointer.is_const || expected_type->data.pointer.is_const))
{
return types_match_const_cast_only(expected_type->data.pointer.child_type,
actual_type->data.pointer.child_type);
}
// unknown size array const
if (expected_type->id == TypeTableEntryIdStruct &&
actual_type->id == TypeTableEntryIdStruct &&
expected_type->data.structure.is_unknown_size_array &&
actual_type->data.structure.is_unknown_size_array &&
(!actual_type->data.structure.fields[0].type_entry->data.pointer.is_const ||
expected_type->data.structure.fields[0].type_entry->data.pointer.is_const))
{
return types_match_const_cast_only(
expected_type->data.structure.fields[0].type_entry->data.pointer.child_type,
actual_type->data.structure.fields[0].type_entry->data.pointer.child_type);
}
// maybe
if (expected_type->id == TypeTableEntryIdMaybe &&
actual_type->id == TypeTableEntryIdMaybe)
{
TypeTableEntry *expected_child = expected_type->data.maybe.child_type;
TypeTableEntry *actual_child = actual_type->data.maybe.child_type;
return resolve_type_compatibility(g, context, node, expected_child, actual_child);
return types_match_const_cast_only(
expected_type->data.maybe.child_type,
actual_type->data.maybe.child_type);
}
// error
if (expected_type->id == TypeTableEntryIdError &&
actual_type->id == TypeTableEntryIdError)
{
return types_match_const_cast_only(
expected_type->data.error.child_type,
actual_type->data.error.child_type);
}
// fn
if (expected_type->id == TypeTableEntryIdFn &&
actual_type->id == TypeTableEntryIdFn)
{
zig_panic("TODO types_match_const_cast_only for fns");
}
return false;
}
static bool types_match_with_implicit_cast(CodeGen *g, TypeTableEntry *expected_type,
TypeTableEntry *actual_type, AstNode *literal_node, bool *reported_err)
{
if (types_match_const_cast_only(expected_type, actual_type)) {
return true;
}
// implicit conversion from non maybe type to maybe type
if (expected_type->id == TypeTableEntryIdMaybe) {
TypeTableEntry *resolved_type = resolve_type_compatibility(g, context, node,
expected_type->data.maybe.child_type, actual_type);
if (resolved_type->id == TypeTableEntryIdInvalid) {
return resolved_type;
}
Expr *expr = get_resolved_expr(node);
expr->implicit_maybe_cast.op = CastOpMaybeWrap;
expr->implicit_maybe_cast.after_type = expected_type;
expr->implicit_maybe_cast.source_node = node;
context->cast_expr_alloca_list.append(&expr->implicit_maybe_cast);
return expected_type;
if (expected_type->id == TypeTableEntryIdMaybe &&
types_match_with_implicit_cast(g, expected_type->data.maybe.child_type, actual_type,
literal_node, reported_err))
{
return true;
}
// implicit widening conversion
@ -1186,78 +1257,94 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, BlockContext *cont
expected_type->data.integral.is_signed == actual_type->data.integral.is_signed &&
expected_type->size_in_bits >= actual_type->size_in_bits)
{
Expr *expr = get_resolved_expr(node);
expr->implicit_cast.after_type = expected_type;
expr->implicit_cast.op = CastOpIntWidenOrShorten;
expr->implicit_cast.source_node = node;
return expected_type;
return true;
}
// implicit constant sized array to unknown size array conversion
if (expected_type->id == TypeTableEntryIdStruct &&
expected_type->data.structure.is_unknown_size_array &&
actual_type->id == TypeTableEntryIdArray &&
actual_type->data.array.child_type == expected_type->data.structure.fields[0].type_entry->data.pointer.child_type)
{
Expr *expr = get_resolved_expr(node);
expr->implicit_cast.after_type = expected_type;
expr->implicit_cast.op = CastOpToUnknownSizeArray;
expr->implicit_cast.source_node = node;
context->cast_expr_alloca_list.append(&expr->implicit_cast);
return expected_type;
}
// implicit non-const to const for pointers
if (expected_type->id == TypeTableEntryIdPointer &&
actual_type->id == TypeTableEntryIdPointer &&
(!actual_type->data.pointer.is_const || expected_type->data.pointer.is_const))
{
TypeTableEntry *resolved_type = resolve_type_compatibility(g, context, node,
expected_type->data.pointer.child_type,
actual_type->data.pointer.child_type);
if (resolved_type->id == TypeTableEntryIdInvalid) {
return resolved_type;
}
return expected_type;
}
// implicit non-const to const for unknown size arrays
if (expected_type->id == TypeTableEntryIdStruct &&
actual_type->id == TypeTableEntryIdStruct &&
expected_type->data.structure.is_unknown_size_array &&
actual_type->data.structure.is_unknown_size_array &&
(!actual_type->data.structure.fields[0].type_entry->data.pointer.is_const ||
expected_type->data.structure.fields[0].type_entry->data.pointer.is_const))
{
TypeTableEntry *resolved_type = resolve_type_compatibility(g, context, node,
types_match_const_cast_only(
expected_type->data.structure.fields[0].type_entry->data.pointer.child_type,
actual_type->data.structure.fields[0].type_entry->data.pointer.child_type);
if (resolved_type->id == TypeTableEntryIdInvalid) {
return resolved_type;
}
return expected_type;
actual_type->data.array.child_type))
{
return true;
}
// implicit number literal to typed number
if ((actual_type->id == TypeTableEntryIdNumLitFloat ||
actual_type->id == TypeTableEntryIdNumLitInt))
{
if (num_lit_fits_in_other_type(g, node, expected_type)) {
return expected_type;
if (num_lit_fits_in_other_type(g, literal_node, expected_type)) {
return true;
} else {
return g->builtin_types.entry_invalid;
*reported_err = true;
}
}
return false;
}
static AstNode *create_ast_node(CodeGen *g, ImportTableEntry *import, NodeType kind) {
AstNode *node = allocate<AstNode>(1);
node->type = kind;
node->owner = import;
node->create_index = g->next_node_index;
g->next_node_index += 1;
return node;
}
static AstNode *create_ast_type_node(CodeGen *g, ImportTableEntry *import, TypeTableEntry *type_entry) {
AstNode *node = create_ast_node(g, import, NodeTypeSymbol);
node->data.symbol_expr.override_type_entry = type_entry;
return node;
}
static TypeTableEntry *create_and_analyze_cast_node(CodeGen *g, ImportTableEntry *import,
BlockContext *context, TypeTableEntry *cast_to_type, AstNode *node)
{
AstNode *new_parent_node = create_ast_node(g, import, NodeTypeFnCallExpr);
*node->parent_field = new_parent_node;
new_parent_node->parent_field = node->parent_field;
new_parent_node->data.fn_call_expr.fn_ref_expr = create_ast_type_node(g, import, cast_to_type);
new_parent_node->data.fn_call_expr.params.append(node);
normalize_parent_ptrs(new_parent_node);
return analyze_expression(g, import, context, cast_to_type, new_parent_node);
}
static TypeTableEntry *resolve_type_compatibility(CodeGen *g, ImportTableEntry *import,
BlockContext *context, AstNode *node,
TypeTableEntry *expected_type, TypeTableEntry *actual_type)
{
if (expected_type == nullptr)
return actual_type; // anything will do
if (expected_type == actual_type)
return expected_type; // match
if (expected_type->id == TypeTableEntryIdInvalid || actual_type->id == TypeTableEntryIdInvalid)
return g->builtin_types.entry_invalid;
if (actual_type->id == TypeTableEntryIdUnreachable)
return actual_type;
bool reported_err = false;
if (types_match_with_implicit_cast(g, expected_type, actual_type, node, &reported_err)) {
return create_and_analyze_cast_node(g, import, context, expected_type, node);
}
if (!reported_err) {
add_node_error(g, first_executing_node(node),
buf_sprintf("expected type '%s', got '%s'",
buf_ptr(&expected_type->name),
buf_ptr(&actual_type->name)));
}
return g->builtin_types.entry_invalid;
}
static TypeTableEntry *resolve_peer_type_compatibility(CodeGen *g, BlockContext *block_context,
AstNode *parent_source_node,
static TypeTableEntry *resolve_peer_type_compatibility(CodeGen *g, ImportTableEntry *import,
BlockContext *block_context, AstNode *parent_source_node,
AstNode **child_nodes, TypeTableEntry **child_types, int child_count)
{
assert(child_count > 0);
@ -1270,7 +1357,14 @@ static TypeTableEntry *resolve_peer_type_compatibility(CodeGen *g, BlockContext
}
for (int i = 0; i < child_count; i += 1) {
resolve_type_compatibility(g, block_context, child_nodes[i], expected_type, child_types[i]);
if (!child_nodes[i]) {
continue;
}
Expr *expr = get_resolved_expr(child_nodes[i]);
TypeTableEntry *resolved_type = resolve_type_compatibility(g, import, block_context,
child_nodes[i], expected_type, child_types[i]);
expr->type_entry = resolved_type;
add_global_const_expr(g, expr);
}
return expected_type;
@ -1667,13 +1761,7 @@ static TypeTableEntry *resolve_expr_const_val_as_type(CodeGen *g, AstNode *node,
static TypeTableEntry *resolve_expr_const_val_as_other_expr(CodeGen *g, AstNode *node, AstNode *other) {
Expr *expr = get_resolved_expr(node);
Expr *other_expr = get_resolved_expr(other);
ConstExprValue *other_const_val;
if (other_expr->implicit_maybe_cast.after_type) {
other_const_val = &other_expr->implicit_maybe_cast.const_val;
} else {
other_const_val = &other_expr->const_val;
}
expr->const_val = *other_const_val;
expr->const_val = other_expr->const_val;
return other_expr->type_entry;
}
@ -1758,6 +1846,10 @@ static TypeTableEntry *resolve_expr_const_val_as_bignum_op(CodeGen *g, AstNode *
static TypeTableEntry *analyze_symbol_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *node)
{
if (node->data.symbol_expr.override_type_entry) {
return resolve_expr_const_val_as_type(g, node, node->data.symbol_expr.override_type_entry);
}
Buf *variable_name = &node->data.symbol_expr.symbol;
auto primitive_table_entry = g->primitive_type_table.maybe_get(variable_name);
@ -1772,13 +1864,7 @@ static TypeTableEntry *analyze_symbol_expr(CodeGen *g, ImportTableEntry *import,
AstNode *decl_node = var->decl_node;
if (decl_node->type == NodeTypeVariableDeclaration) {
AstNode *expr_node = decl_node->data.variable_declaration.expr;
Expr *other_expr = get_resolved_expr(expr_node);
ConstExprValue *other_const_val;
if (other_expr->implicit_maybe_cast.after_type) {
other_const_val = &other_expr->implicit_maybe_cast.const_val;
} else {
other_const_val = &other_expr->const_val;
}
ConstExprValue *other_const_val = &get_resolved_expr(expr_node)->const_val;
if (other_const_val->ok) {
return resolve_expr_const_val_as_other_expr(g, node, expr_node);
}
@ -1955,7 +2041,7 @@ static TypeTableEntry *analyze_bool_bin_op_expr(CodeGen *g, ImportTableEntry *im
AstNode *op_nodes[] = {op1, op2};
TypeTableEntry *op_types[] = {op1_type, op2_type};
TypeTableEntry *resolved_type = resolve_peer_type_compatibility(g, context, node,
TypeTableEntry *resolved_type = resolve_peer_type_compatibility(g, import, context, node,
op_nodes, op_types, 2);
if (resolved_type->id == TypeTableEntryIdInvalid) {
@ -2109,7 +2195,7 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import,
AstNode *op_nodes[] = {op1, op2};
TypeTableEntry *op_types[] = {lhs_type, rhs_type};
TypeTableEntry *resolved_type = resolve_peer_type_compatibility(g, context, node,
TypeTableEntry *resolved_type = resolve_peer_type_compatibility(g, import, context, node,
op_nodes, op_types, 2);
if (resolved_type->id == TypeTableEntryIdInvalid) {
@ -2162,6 +2248,7 @@ static TypeTableEntry *analyze_bin_op_expr(CodeGen *g, ImportTableEntry *import,
add_node_error(g, op1,
buf_sprintf("expected maybe type, got '%s'",
buf_ptr(&lhs_type->name)));
return g->builtin_types.entry_invalid;
}
}
case BinOpTypeInvalid:
@ -2502,8 +2589,8 @@ static TypeTableEntry *analyze_if_then_else(CodeGen *g, ImportTableEntry *import
if (else_node) {
else_type = analyze_expression(g, import, context, expected_type, else_node);
} else {
else_type = g->builtin_types.entry_void;
else_type = resolve_type_compatibility(g, context, parent_node, expected_type, else_type);
else_type = resolve_type_compatibility(g, import, context, parent_node, expected_type,
g->builtin_types.entry_void);
}
@ -2512,7 +2599,7 @@ static TypeTableEntry *analyze_if_then_else(CodeGen *g, ImportTableEntry *import
} else {
AstNode *op_nodes[] = {then_block, else_node};
TypeTableEntry *op_types[] = {then_type, else_type};
return resolve_peer_type_compatibility(g, context, parent_node, op_nodes, op_types, 2);
return resolve_peer_type_compatibility(g, import, context, parent_node, op_nodes, op_types, 2);
}
}
@ -2616,38 +2703,31 @@ static TypeTableEntry *analyze_min_max_value(CodeGen *g, ImportTableEntry *impor
}
}
static void eval_const_expr_implicit_cast(CodeGen *g, ImportTableEntry *import, BlockContext *context,
AstNode *node, Cast *cast, AstNode *expr_node)
{
switch (cast->op) {
case CastOpNothing:
static void eval_const_expr_implicit_cast(CodeGen *g, AstNode *node, AstNode *expr_node) {
assert(node->type == NodeTypeFnCallExpr);
ConstExprValue *other_val = &get_resolved_expr(expr_node)->const_val;
ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
if (!other_val->ok) {
return;
}
assert(other_val != const_val);
switch (node->data.fn_call_expr.cast_op) {
case CastOpNoCast:
zig_unreachable();
case CastOpNoop:
case CastOpPtrToInt:
case CastOpIntWidenOrShorten:
case CastOpPointerReinterpret:
{
ConstExprValue *other_val = &get_resolved_expr(expr_node)->const_val;
ConstExprValue *const_val = &cast->const_val;
assert(const_val != other_val);
*const_val = *other_val;
break;
}
case CastOpToUnknownSizeArray:
// TODO eval const expr
zig_panic("TODO CastOpToUnknownSizeArray");
break;
case CastOpMaybeWrap:
{
ConstExprValue *other_val = &get_resolved_expr(expr_node)->const_val;
ConstExprValue *const_val = &cast->const_val;
if (!other_val->ok) {
break;
}
assert(const_val != other_val);
const_val->data.x_maybe = other_val;
const_val->ok = true;
break;
}
}
}
static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
@ -2673,51 +2753,91 @@ static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, B
return g->builtin_types.entry_invalid;
}
Cast *cast = &node->data.fn_call_expr.cast;
cast->source_node = node;
cast->after_type = wanted_type;
// explicit match or non-const to const
if (types_match_const_cast_only(wanted_type, actual_type)) {
node->data.fn_call_expr.cast_op = CastOpNoop;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
}
// explicit cast from pointer to isize or usize
if ((wanted_type == g->builtin_types.entry_isize || wanted_type == g->builtin_types.entry_usize) &&
actual_type->id == TypeTableEntryIdPointer)
{
cast->op = CastOpPtrToInt;
eval_const_expr_implicit_cast(g, import, context, node, cast, expr_node);
node->data.fn_call_expr.cast_op = CastOpPtrToInt;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else if (wanted_type->id == TypeTableEntryIdInt &&
}
// explicit cast from any int to any other int
if (wanted_type->id == TypeTableEntryIdInt &&
actual_type->id == TypeTableEntryIdInt)
{
cast->op = CastOpIntWidenOrShorten;
eval_const_expr_implicit_cast(g, import, context, node, cast, expr_node);
node->data.fn_call_expr.cast_op = CastOpIntWidenOrShorten;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else if (wanted_type->id == TypeTableEntryIdStruct &&
}
// explicit cast from fixed size array to unknown size array
if (wanted_type->id == TypeTableEntryIdStruct &&
wanted_type->data.structure.is_unknown_size_array &&
actual_type->id == TypeTableEntryIdArray &&
actual_type->data.array.child_type == wanted_type->data.structure.fields[0].type_entry)
types_match_const_cast_only(
wanted_type->data.structure.fields[0].type_entry->data.pointer.child_type,
actual_type->data.array.child_type))
{
cast->op = CastOpToUnknownSizeArray;
context->cast_expr_alloca_list.append(cast);
eval_const_expr_implicit_cast(g, import, context, node, cast, expr_node);
node->data.fn_call_expr.cast_op = CastOpToUnknownSizeArray;
context->cast_alloca_list.append(node);
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else if (actual_type->id == TypeTableEntryIdNumLitFloat ||
actual_type->id == TypeTableEntryIdNumLitInt)
{
num_lit_fits_in_other_type(g, expr_node, wanted_type);
cast->op = CastOpNothing;
eval_const_expr_implicit_cast(g, import, context, node, cast, expr_node);
return wanted_type;
} else if (actual_type->id == TypeTableEntryIdPointer &&
}
// explicit cast from pointer to another pointer
if (actual_type->id == TypeTableEntryIdPointer &&
wanted_type->id == TypeTableEntryIdPointer)
{
cast->op = CastOpPointerReinterpret;
eval_const_expr_implicit_cast(g, import, context, node, cast, expr_node);
node->data.fn_call_expr.cast_op = CastOpPointerReinterpret;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
}
// explicit cast from child type of maybe type to maybe type
if (wanted_type->id == TypeTableEntryIdMaybe) {
if (types_match_const_cast_only(wanted_type->data.maybe.child_type, actual_type)) {
node->data.fn_call_expr.cast_op = CastOpMaybeWrap;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else if (actual_type->id == TypeTableEntryIdNumLitInt ||
actual_type->id == TypeTableEntryIdNumLitFloat)
{
if (num_lit_fits_in_other_type(g, expr_node, wanted_type->data.maybe.child_type)) {
node->data.fn_call_expr.cast_op = CastOpMaybeWrap;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else {
return g->builtin_types.entry_invalid;
}
}
}
// explicit cast from number literal to another type
if (actual_type->id == TypeTableEntryIdNumLitFloat ||
actual_type->id == TypeTableEntryIdNumLitInt)
{
if (num_lit_fits_in_other_type(g, expr_node, wanted_type)) {
node->data.fn_call_expr.cast_op = CastOpNoop;
eval_const_expr_implicit_cast(g, node, expr_node);
return wanted_type;
} else {
return g->builtin_types.entry_invalid;
}
}
add_node_error(g, node,
buf_sprintf("invalid cast from type '%s' to '%s'",
buf_ptr(&actual_type->name),
buf_ptr(&wanted_type->name)));
return g->builtin_types.entry_invalid;
}
}
static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
@ -3281,39 +3401,14 @@ static TypeTableEntry *analyze_return_expr(CodeGen *g, ImportTableEntry *import,
actual_return_type = g->builtin_types.entry_invalid;
}
resolve_type_compatibility(g, context, node, expected_return_type, actual_return_type);
resolve_type_compatibility(g, import, context, node, expected_return_type, actual_return_type);
return g->builtin_types.entry_unreachable;
}
static bool type_has_codegen_value(TypeTableEntryId id) {
switch (id) {
case TypeTableEntryIdInvalid:
case TypeTableEntryIdMetaType:
case TypeTableEntryIdVoid:
case TypeTableEntryIdUnreachable:
return false;
// TODO make num lits return false when we make implicit casts insert ast nodes
case TypeTableEntryIdNumLitFloat:
case TypeTableEntryIdNumLitInt:
case TypeTableEntryIdBool:
case TypeTableEntryIdInt:
case TypeTableEntryIdFloat:
case TypeTableEntryIdPointer:
case TypeTableEntryIdArray:
case TypeTableEntryIdStruct:
case TypeTableEntryIdMaybe:
case TypeTableEntryIdError:
case TypeTableEntryIdEnum:
case TypeTableEntryIdFn:
return true;
}
zig_unreachable();
}
static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import, BlockContext *context,
// When you call analyze_expression, the node you pass might no longer be the child node
// you thought it was due to implicit casting rewriting the AST.
static TypeTableEntry *analyze_expression(CodeGen *g, ImportTableEntry *import, BlockContext *context,
TypeTableEntry *expected_type, AstNode *node)
{
TypeTableEntry *return_type = nullptr;
@ -3494,39 +3589,19 @@ static TypeTableEntry * analyze_expression(CodeGen *g, ImportTableEntry *import,
zig_unreachable();
}
assert(return_type);
resolve_type_compatibility(g, context, node, expected_type, return_type);
// resolve_type_compatibility might do implicit cast which means node is now a child
// of the actual node that we want to return the type of.
//AstNode **field = node->parent_field;
TypeTableEntry *resolved_type = resolve_type_compatibility(g, import, context, node,
expected_type, return_type);
Expr *expr = get_resolved_expr(node);
if (!expr->resolved_type) {
expr->resolved_type = return_type;
}
expr->type_entry = expr->resolved_type;
expr->type_entry = return_type;
expr->block_context = context;
if (expr->const_val.ok && type_has_codegen_value(expr->resolved_type->id)) {
g->global_const_list.append(expr);
}
add_global_const_expr(g, expr);
if (expr->type_entry->id == TypeTableEntryIdUnreachable) {
return expr->type_entry;
}
/* TODO delete this code when we make implicit casts insert ast nodes
Cast *cast_node = &expr->implicit_cast;
if (cast_node->after_type) {
eval_const_expr_implicit_cast(g, import, context, node, cast_node, node);
expr->type_entry = cast_node->after_type;
}
*/
Cast *cast_node = &expr->implicit_maybe_cast;
if (cast_node->after_type) {
eval_const_expr_implicit_cast(g, import, context, node, cast_node, node);
expr->type_entry = cast_node->after_type;
}
return expr->type_entry;
return resolved_type;
}
static void analyze_top_level_fn_def(CodeGen *g, ImportTableEntry *import, AstNode *node) {

202
src/codegen.cpp
View File

@ -71,8 +71,6 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
static LLVMValueRef gen_assign_raw(CodeGen *g, AstNode *source_node, BinOpType bin_op,
LLVMValueRef target_ref, LLVMValueRef value,
TypeTableEntry *op1_type, TypeTableEntry *op2_type);
static LLVMValueRef gen_bare_cast(CodeGen *g, AstNode *node, LLVMValueRef expr_val,
TypeTableEntry *actual_type, TypeTableEntry *wanted_type, Cast *cast_node);
static TypeTableEntry *get_type_for_type_node(AstNode *node) {
Expr *expr = get_resolved_expr(node);
@ -111,17 +109,7 @@ static LLVMValueRef find_or_create_string(CodeGen *g, Buf *str, bool c) {
}
static TypeTableEntry *get_expr_type(AstNode *node) {
Expr *expr = get_resolved_expr(node);
if (expr->implicit_maybe_cast.after_type) {
return expr->implicit_maybe_cast.after_type;
}
if (expr->implicit_cast.after_type) {
return expr->implicit_cast.after_type;
}
if (expr->resolved_type) {
return expr->resolved_type;
}
return expr->type_entry;
return get_resolved_expr(node)->type_entry;
}
static TypeTableEntry *fn_proto_type_from_type_node(CodeGen *g, AstNode *type_node) {
@ -305,18 +293,84 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
TypeTableEntry *actual_type = get_expr_type(expr_node);
TypeTableEntry *wanted_type = get_expr_type(node);
Cast *cast_node = &node->data.fn_call_expr.cast;
AstNodeFnCallExpr *cast_expr = &node->data.fn_call_expr;
return gen_bare_cast(g, node, expr_val, actual_type, wanted_type, cast_node);
switch (cast_expr->cast_op) {
case CastOpNoCast:
zig_unreachable();
case CastOpNoop:
return expr_val;
case CastOpMaybeWrap:
{
assert(cast_expr->tmp_ptr);
assert(wanted_type->id == TypeTableEntryIdMaybe);
assert(actual_type);
add_debug_source_node(g, node);
LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 0, "");
gen_assign_raw(g, node, BinOpTypeAssign,
val_ptr, expr_val, wanted_type->data.maybe.child_type, actual_type);
add_debug_source_node(g, node);
LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 1, "");
LLVMBuildStore(g->builder, LLVMConstAllOnes(LLVMInt1Type()), maybe_ptr);
return cast_expr->tmp_ptr;
}
case CastOpPtrToInt:
add_debug_source_node(g, node);
return LLVMBuildPtrToInt(g->builder, expr_val, wanted_type->type_ref, "");
case CastOpPointerReinterpret:
add_debug_source_node(g, node);
return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
case CastOpIntWidenOrShorten:
if (actual_type->size_in_bits == wanted_type->size_in_bits) {
return expr_val;
} else if (actual_type->size_in_bits < wanted_type->size_in_bits) {
if (actual_type->data.integral.is_signed) {
add_debug_source_node(g, node);
return LLVMBuildSExt(g->builder, expr_val, wanted_type->type_ref, "");
} else {
add_debug_source_node(g, node);
return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
}
} else {
assert(actual_type->size_in_bits > wanted_type->size_in_bits);
add_debug_source_node(g, node);
return LLVMBuildTrunc(g->builder, expr_val, wanted_type->type_ref, "");
}
case CastOpToUnknownSizeArray:
{
assert(cast_expr->tmp_ptr);
assert(wanted_type->id == TypeTableEntryIdStruct);
assert(wanted_type->data.structure.is_unknown_size_array);
TypeTableEntry *pointer_type = wanted_type->data.structure.fields[0].type_entry;
add_debug_source_node(g, node);
LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 0, "");
LLVMValueRef expr_bitcast = LLVMBuildBitCast(g->builder, expr_val, pointer_type->type_ref, "");
LLVMBuildStore(g->builder, expr_bitcast, ptr_ptr);
LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, 1, "");
LLVMValueRef len_val = LLVMConstInt(g->builtin_types.entry_isize->type_ref,
actual_type->data.array.len, false);
LLVMBuildStore(g->builder, len_val, len_ptr);
return cast_expr->tmp_ptr;
}
}
zig_unreachable();
}
static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
assert(node->type == NodeTypeFnCallExpr);
if (node->data.fn_call_expr.is_builtin) {
return gen_builtin_fn_call_expr(g, node);
} else if (node->data.fn_call_expr.cast.after_type) {
} else if (node->data.fn_call_expr.cast_op != CastOpNoCast) {
return gen_cast_expr(g, node);
}
@ -752,74 +806,6 @@ static LLVMValueRef gen_prefix_op_expr(CodeGen *g, AstNode *node) {
zig_unreachable();
}
static LLVMValueRef gen_bare_cast(CodeGen *g, AstNode *node, LLVMValueRef expr_val,
TypeTableEntry *actual_type, TypeTableEntry *wanted_type, Cast *cast_node)
{
switch (cast_node->op) {
case CastOpNothing:
return expr_val;
case CastOpMaybeWrap:
{
assert(cast_node->ptr);
assert(wanted_type->id == TypeTableEntryIdMaybe);
assert(actual_type);
add_debug_source_node(g, node);
LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, cast_node->ptr, 0, "");
gen_assign_raw(g, node, BinOpTypeAssign,
val_ptr, expr_val, wanted_type->data.maybe.child_type, actual_type);
add_debug_source_node(g, node);
LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, cast_node->ptr, 1, "");
LLVMBuildStore(g->builder, LLVMConstAllOnes(LLVMInt1Type()), maybe_ptr);
return cast_node->ptr;
}
case CastOpPtrToInt:
add_debug_source_node(g, node);
return LLVMBuildPtrToInt(g->builder, expr_val, wanted_type->type_ref, "");
case CastOpPointerReinterpret:
add_debug_source_node(g, node);
return LLVMBuildBitCast(g->builder, expr_val, wanted_type->type_ref, "");
case CastOpIntWidenOrShorten:
if (actual_type->size_in_bits == wanted_type->size_in_bits) {
return expr_val;
} else if (actual_type->size_in_bits < wanted_type->size_in_bits) {
if (actual_type->data.integral.is_signed) {
add_debug_source_node(g, node);
return LLVMBuildSExt(g->builder, expr_val, wanted_type->type_ref, "");
} else {
add_debug_source_node(g, node);
return LLVMBuildZExt(g->builder, expr_val, wanted_type->type_ref, "");
}
} else {
assert(actual_type->size_in_bits > wanted_type->size_in_bits);
add_debug_source_node(g, node);
return LLVMBuildTrunc(g->builder, expr_val, wanted_type->type_ref, "");
}
case CastOpToUnknownSizeArray:
{
assert(cast_node->ptr);
TypeTableEntry *pointer_type = wanted_type->data.structure.fields[0].type_entry;
add_debug_source_node(g, node);
LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, cast_node->ptr, 0, "");
LLVMValueRef expr_bitcast = LLVMBuildBitCast(g->builder, expr_val, pointer_type->type_ref, "");
LLVMBuildStore(g->builder, expr_bitcast, ptr_ptr);
LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, cast_node->ptr, 1, "");
LLVMValueRef len_val = LLVMConstInt(g->builtin_types.entry_isize->type_ref,
actual_type->data.array.len, false);
LLVMBuildStore(g->builder, len_val, len_ptr);
return cast_node->ptr;
}
}
zig_unreachable();
}
static LLVMValueRef gen_arithmetic_bin_op(CodeGen *g, AstNode *source_node,
LLVMValueRef val1, LLVMValueRef val2,
TypeTableEntry *op1_type, TypeTableEntry *op2_type,
@ -1970,7 +1956,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
return phi;
}
static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) {
Expr *expr = get_resolved_expr(node);
if (expr->const_val.ok) {
assert(expr->const_llvm_val);
@ -2072,33 +2058,6 @@ static LLVMValueRef gen_expr_no_cast(CodeGen *g, AstNode *node) {
zig_unreachable();
}
static LLVMValueRef gen_expr(CodeGen *g, AstNode *node) {
LLVMValueRef val = gen_expr_no_cast(g, node);
if (is_node_void_expr(node)) {
return val;
}
Expr *expr = get_resolved_expr(node);
TypeTableEntry *before_type = expr->type_entry;
if (before_type && before_type->id == TypeTableEntryIdUnreachable) {
return val;
}
Cast *cast_node = &expr->implicit_cast;
if (cast_node->after_type) {
val = gen_bare_cast(g, node, val, before_type, cast_node->after_type, cast_node);
before_type = cast_node->after_type;
}
cast_node = &expr->implicit_maybe_cast;
if (cast_node->after_type) {
val = gen_bare_cast(g, node, val, before_type, cast_node->after_type, cast_node);
}
return val;
}
static void build_label_blocks(CodeGen *g, AstNode *block_node) {
assert(block_node->type == NodeTypeBlock);
for (int i = 0; i < block_node->data.block.statements.length; i += 1) {
@ -2180,14 +2139,7 @@ static void gen_const_globals(CodeGen *g) {
Expr *expr = g->global_const_list.at(i);
ConstExprValue *const_val = &expr->const_val;
assert(const_val->ok);
TypeTableEntry *type_entry = expr->resolved_type;
// TODO delete this if when we make implicit casts insert ast nodes
if (type_entry->id == TypeTableEntryIdNumLitFloat ||
type_entry->id == TypeTableEntryIdNumLitInt)
{
continue;
}
TypeTableEntry *type_entry = expr->type_entry;
if (handle_is_ptr(type_entry)) {
LLVMValueRef global_value = LLVMAddGlobal(g->module, type_entry->type_ref, "");
@ -2330,10 +2282,12 @@ static void do_code_gen(CodeGen *g) {
}
// allocate structs which are the result of casts
for (int cea_i = 0; cea_i < block_context->cast_expr_alloca_list.length; cea_i += 1) {
Cast *cast_node = block_context->cast_expr_alloca_list.at(cea_i);
add_debug_source_node(g, cast_node->source_node);
cast_node->ptr = LLVMBuildAlloca(g->builder, cast_node->after_type->type_ref, "");
for (int cea_i = 0; cea_i < block_context->cast_alloca_list.length; cea_i += 1) {
AstNode *fn_call_node = block_context->cast_alloca_list.at(cea_i);
add_debug_source_node(g, fn_call_node);
Expr *expr = &fn_call_node->data.fn_call_expr.resolved_expr;
fn_call_node->data.fn_call_expr.tmp_ptr = LLVMBuildAlloca(g->builder,
expr->type_entry->type_ref, "");
}
// allocate structs which are struct value expressions

242
src/parser.cpp
View File

@ -173,6 +173,7 @@ void ast_print(AstNode *node, int indent) {
for (int i = 0; i < indent; i += 1) {
fprintf(stderr, " ");
}
assert(node->type == NodeTypeRoot || *node->parent_field == node);
switch (node->type) {
case NodeTypeRoot:
@ -1008,6 +1009,7 @@ static AstNode *ast_parse_directive(ParseContext *pc, int *token_index) {
*token_index += 1;
ast_expect_token(pc, r_paren, TokenIdRParen);
normalize_parent_ptrs(node);
return node;
}
@ -1059,6 +1061,7 @@ static AstNode *ast_parse_param_decl(ParseContext *pc, int *token_index) {
node->data.param_decl.type = ast_parse_prefix_op_expr(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
}
@ -1175,6 +1178,7 @@ static AstNode *ast_parse_array_type_expr(ParseContext *pc, int *token_index, bo
node->data.array_type.child_type = ast_parse_prefix_op_expr(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
}
@ -1358,6 +1362,7 @@ static AstNode *ast_parse_asm_expr(ParseContext *pc, int *token_index, bool mand
ast_expect_token(pc, rparen_tok, TokenIdRParen);
*token_index += 1;
normalize_parent_ptrs(node);
return node;
}
@ -1416,6 +1421,8 @@ static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool
ast_eat_token(pc, token_index, TokenIdLParen);
ast_parse_fn_call_param_list(pc, token_index, &node->data.fn_call_expr.params);
node->data.fn_call_expr.is_builtin = true;
normalize_parent_ptrs(node);
return node;
} else if (token->id == TokenIdSymbol) {
*token_index += 1;
@ -1499,6 +1506,7 @@ static AstNode *ast_parse_curly_suffix_expr(ParseContext *pc, int *token_index,
ast_buf_from_token(pc, field_name_tok, &field_node->data.struct_val_field.name);
field_node->data.struct_val_field.expr = ast_parse_expression(pc, token_index, true);
normalize_parent_ptrs(field_node);
node->data.container_init_expr.entries.append(field_node);
Token *comma_tok = &pc->tokens->at(*token_index);
@ -1545,6 +1553,7 @@ static AstNode *ast_parse_curly_suffix_expr(ParseContext *pc, int *token_index,
}
}
normalize_parent_ptrs(node);
prefix_op_expr = node;
} else {
return prefix_op_expr;
@ -1575,6 +1584,7 @@ static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, int *token_index, boo
node->data.fn_call_expr.fn_ref_expr = primary_expr;
ast_parse_fn_call_param_list(pc, token_index, &node->data.fn_call_expr.params);
normalize_parent_ptrs(node);
primary_expr = node;
} else if (first_token->id == TokenIdLBracket) {
*token_index += 1;
@ -1599,6 +1609,7 @@ static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, int *token_index, boo
node->data.slice_expr.is_const = true;
}
normalize_parent_ptrs(node);
primary_expr = node;
} else if (ellipsis_or_r_bracket->id == TokenIdRBracket) {
*token_index += 1;
@ -1607,6 +1618,7 @@ static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, int *token_index, boo
node->data.array_access_expr.array_ref_expr = primary_expr;
node->data.array_access_expr.subscript = expr_node;
normalize_parent_ptrs(node);
primary_expr = node;
} else {
ast_invalid_token_error(pc, first_token);
@ -1620,6 +1632,7 @@ static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, int *token_index, boo
node->data.field_access_expr.struct_expr = primary_expr;
ast_buf_from_token(pc, name_token, &node->data.field_access_expr.field_name);
normalize_parent_ptrs(node);
primary_expr = node;
} else {
return primary_expr;
@ -1677,6 +1690,8 @@ static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, boo
node->data.prefix_op_expr.primary_expr = prefix_op_expr;
node->data.prefix_op_expr.prefix_op = prefix_op;
normalize_parent_ptrs(node);
normalize_parent_ptrs(parent_node);
return parent_node;
}
@ -1728,6 +1743,7 @@ static AstNode *ast_parse_mult_expr(ParseContext *pc, int *token_index, bool man
node->data.bin_op_expr.bin_op = mult_op;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1778,6 +1794,7 @@ static AstNode *ast_parse_add_expr(ParseContext *pc, int *token_index, bool mand
node->data.bin_op_expr.bin_op = add_op;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1828,6 +1845,7 @@ static AstNode *ast_parse_bit_shift_expr(ParseContext *pc, int *token_index, boo
node->data.bin_op_expr.bin_op = bit_shift_op;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1854,6 +1872,7 @@ static AstNode *ast_parse_bin_and_expr(ParseContext *pc, int *token_index, bool
node->data.bin_op_expr.bin_op = BinOpTypeBinAnd;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1879,6 +1898,7 @@ static AstNode *ast_parse_bin_xor_expr(ParseContext *pc, int *token_index, bool
node->data.bin_op_expr.bin_op = BinOpTypeBinXor;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1904,6 +1924,7 @@ static AstNode *ast_parse_bin_or_expr(ParseContext *pc, int *token_index, bool m
node->data.bin_op_expr.bin_op = BinOpTypeBinOr;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -1954,6 +1975,7 @@ static AstNode *ast_parse_comparison_expr(ParseContext *pc, int *token_index, bo
node->data.bin_op_expr.bin_op = cmp_op;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
return node;
}
@ -1978,6 +2000,7 @@ static AstNode *ast_parse_bool_and_expr(ParseContext *pc, int *token_index, bool
node->data.bin_op_expr.bin_op = BinOpTypeBoolAnd;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -2043,6 +2066,8 @@ static AstNode *ast_parse_if_expr(ParseContext *pc, int *token_index, bool manda
ast_eat_token(pc, token_index, TokenIdRParen);
node->data.if_var_expr.then_block = ast_parse_expression(pc, token_index, true);
node->data.if_var_expr.else_node = ast_parse_else(pc, token_index, false);
normalize_parent_ptrs(node);
return node;
} else {
AstNode *node = ast_create_node(pc, NodeTypeIfBoolExpr, if_tok);
@ -2050,6 +2075,8 @@ static AstNode *ast_parse_if_expr(ParseContext *pc, int *token_index, bool manda
ast_eat_token(pc, token_index, TokenIdRParen);
node->data.if_bool_expr.then_block = ast_parse_expression(pc, token_index, true);
node->data.if_bool_expr.else_node = ast_parse_else(pc, token_index, false);
normalize_parent_ptrs(node);
return node;
}
}
@ -2094,6 +2121,8 @@ static AstNode *ast_parse_return_expr(ParseContext *pc, int *token_index, bool m
AstNode *node = ast_create_node(pc, NodeTypeReturnExpr, token);
node->data.return_expr.kind = kind;
node->data.return_expr.expr = ast_parse_expression(pc, token_index, false);
normalize_parent_ptrs(node);
return node;
}
@ -2156,6 +2185,8 @@ static AstNode *ast_parse_variable_declaration_expr(ParseContext *pc, int *token
*token_index += 1;
if (eq_or_colon->id == TokenIdEq) {
node->data.variable_declaration.expr = ast_parse_expression(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
} else if (eq_or_colon->id == TokenIdColon) {
node->data.variable_declaration.type = ast_parse_prefix_op_expr(pc, token_index, true);
@ -2165,6 +2196,8 @@ static AstNode *ast_parse_variable_declaration_expr(ParseContext *pc, int *token
node->data.variable_declaration.expr = ast_parse_expression(pc, token_index, true);
}
normalize_parent_ptrs(node);
return node;
} else {
ast_invalid_token_error(pc, eq_or_colon);
@ -2192,6 +2225,7 @@ static AstNode *ast_parse_bool_or_expr(ParseContext *pc, int *token_index, bool
node->data.bin_op_expr.bin_op = BinOpTypeBoolOr;
node->data.bin_op_expr.op2 = operand_2;
normalize_parent_ptrs(node);
operand_1 = node;
}
}
@ -2220,7 +2254,7 @@ static AstNode *ast_parse_while_expr(ParseContext *pc, int *token_index, bool ma
node->data.while_expr.body = ast_parse_expression(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
}
@ -2262,6 +2296,8 @@ static AstNode *ast_parse_for_expr(ParseContext *pc, int *token_index, bool mand
ast_eat_token(pc, token_index, TokenIdRParen);
node->data.for_expr.body = ast_parse_expression(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
}
@ -2294,6 +2330,8 @@ static AstNode *ast_parse_switch_expr(ParseContext *pc, int *token_index, bool m
if (token->id == TokenIdRBrace) {
*token_index += 1;
normalize_parent_ptrs(node);
return node;
}
@ -2313,6 +2351,8 @@ static AstNode *ast_parse_switch_expr(ParseContext *pc, int *token_index, bool m
range_node->data.switch_range.start = expr1;
range_node->data.switch_range.end = ast_parse_expression(pc, token_index, true);
normalize_parent_ptrs(range_node);
} else {
prong_node->data.switch_prong.items.append(expr1);
}
@ -2335,6 +2375,8 @@ static AstNode *ast_parse_switch_expr(ParseContext *pc, int *token_index, bool m
ast_eat_token(pc, token_index, TokenIdFatArrow);
prong_node->data.switch_prong.expr = ast_parse_expression(pc, token_index, true);
ast_eat_token(pc, token_index, TokenIdComma);
normalize_parent_ptrs(prong_node);
}
}
@ -2430,6 +2472,7 @@ static AstNode *ast_parse_unwrap_maybe_expr(ParseContext *pc, int *token_index,
node->data.bin_op_expr.bin_op = BinOpTypeUnwrapMaybe;
node->data.bin_op_expr.op2 = rhs;
normalize_parent_ptrs(node);
return node;
}
@ -2453,6 +2496,7 @@ static AstNode *ast_parse_ass_expr(ParseContext *pc, int *token_index, bool mand
node->data.bin_op_expr.bin_op = ass_op;
node->data.bin_op_expr.op2 = rhs;
normalize_parent_ptrs(node);
return node;
}
@ -2530,6 +2574,7 @@ static AstNode *ast_create_void_expr(ParseContext *pc, Token *token) {
node->data.container_init_expr.type = ast_create_node(pc, NodeTypeSymbol, token);
node->data.container_init_expr.kind = ContainerInitKindArray;
buf_init_from_str(&node->data.container_init_expr.type->data.symbol_expr.symbol, "void");
normalize_parent_ptrs(node);
return node;
}
@ -2581,6 +2626,8 @@ static AstNode *ast_parse_block(ParseContext *pc, int *token_index, bool mandato
last_token = &pc->tokens->at(*token_index);
if (last_token->id == TokenIdRBrace) {
*token_index += 1;
normalize_parent_ptrs(node);
return node;
} else if (!semicolon_expected) {
continue;
@ -2651,6 +2698,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc, int *token_index, bool mand
node->data.fn_proto.return_type = ast_create_void_type_node(pc, next_token);
}
normalize_parent_ptrs(node);
return node;
}
@ -2667,6 +2715,7 @@ static AstNode *ast_parse_fn_def(ParseContext *pc, int *token_index, bool mandat
ast_eat_token(pc, token_index, TokenIdFatArrow);
node->data.fn_def.body = ast_parse_block(pc, token_index, true);
normalize_parent_ptrs(node);
return node;
}
@ -2683,6 +2732,7 @@ static AstNode *ast_parse_fn_decl(ParseContext *pc, int *token_index) {
*token_index += 1;
ast_expect_token(pc, semicolon, TokenIdSemicolon);
normalize_parent_ptrs(node);
return node;
}
@ -2725,6 +2775,8 @@ static AstNode *ast_parse_extern_block(ParseContext *pc, int *token_index, bool
pc->directive_list = nullptr;
*token_index += 1;
normalize_parent_ptrs(node);
return node;
} else {
AstNode *child = ast_parse_fn_decl(pc, token_index);
@ -2768,6 +2820,7 @@ static AstNode *ast_parse_root_export_decl(ParseContext *pc, int *token_index, b
*token_index += 1;
ast_expect_token(pc, semicolon, TokenIdSemicolon);
normalize_parent_ptrs(node);
return node;
}
@ -2795,6 +2848,7 @@ static AstNode *ast_parse_use(ParseContext *pc, int *token_index) {
node->data.use.directives = pc->directive_list;
pc->directive_list = nullptr;
normalize_parent_ptrs(node);
return node;
}
@ -2895,12 +2949,13 @@ static AstNode *ast_parse_struct_decl(ParseContext *pc, int *token_index) {
}
node->data.struct_decl.fields.append(field_node);
normalize_parent_ptrs(field_node);
} else {
ast_invalid_token_error(pc, token);
}
}
normalize_parent_ptrs(node);
return node;
}
@ -2948,6 +3003,7 @@ static AstNode *ast_parse_error_value_decl(ParseContext *pc, int *token_index, b
node->data.error_value_decl.visib_mod = visib_mod;
ast_buf_from_token(pc, name_tok, &node->data.error_value_decl.name);
normalize_parent_ptrs(node);
return node;
}
@ -3026,6 +3082,7 @@ static AstNode *ast_parse_root(ParseContext *pc, int *token_index) {
ast_invalid_token_error(pc, &pc->tokens->at(*token_index));
}
normalize_parent_ptrs(node);
return node;
}
@ -3042,3 +3099,184 @@ AstNode *ast_parse(Buf *buf, ZigList<Token> *tokens, ImportTableEntry *owner,
pc.root = ast_parse_root(&pc, &token_index);
return pc.root;
}
static void set_field(AstNode **field) {
if (*field) {
(*field)->parent_field = field;
}
}
static void set_list_fields(ZigList<AstNode*> *list) {
for (int i = 0; i < list->length; i += 1) {
set_field(&list->at(i));
}
}
void normalize_parent_ptrs(AstNode *node) {
switch (node->type) {
case NodeTypeRoot:
set_list_fields(&node->data.root.top_level_decls);
break;
case NodeTypeRootExportDecl:
set_list_fields(node->data.root_export_decl.directives);
break;
case NodeTypeFnProto:
set_field(&node->data.fn_proto.return_type);
set_list_fields(node->data.fn_proto.directives);
set_list_fields(&node->data.fn_proto.params);
break;
case NodeTypeFnDef:
set_field(&node->data.fn_def.fn_proto);
set_field(&node->data.fn_def.body);
break;
case NodeTypeFnDecl:
set_field(&node->data.fn_decl.fn_proto);
break;
case NodeTypeParamDecl:
set_field(&node->data.param_decl.type);
break;
case NodeTypeBlock:
set_list_fields(&node->data.block.statements);
break;
case NodeTypeExternBlock:
set_list_fields(node->data.extern_block.directives);
set_list_fields(&node->data.extern_block.fn_decls);
break;
case NodeTypeDirective:
// none
break;
case NodeTypeReturnExpr:
set_field(&node->data.return_expr.expr);
break;
case NodeTypeVariableDeclaration:
set_field(&node->data.variable_declaration.type);
set_field(&node->data.variable_declaration.expr);
break;
case NodeTypeErrorValueDecl:
// none
break;
case NodeTypeBinOpExpr:
set_field(&node->data.bin_op_expr.op1);
set_field(&node->data.bin_op_expr.op2);
break;
case NodeTypeNumberLiteral:
// none
break;
case NodeTypeStringLiteral:
// none
break;
case NodeTypeCharLiteral:
// none
break;
case NodeTypeErrorLiteral:
// none
break;
case NodeTypeSymbol:
// none
break;
case NodeTypePrefixOpExpr:
set_field(&node->data.prefix_op_expr.primary_expr);
break;
case NodeTypeFnCallExpr:
set_field(&node->data.fn_call_expr.fn_ref_expr);
set_list_fields(&node->data.fn_call_expr.params);
break;
case NodeTypeArrayAccessExpr:
set_field(&node->data.array_access_expr.array_ref_expr);
set_field(&node->data.array_access_expr.subscript);
break;
case NodeTypeSliceExpr:
set_field(&node->data.slice_expr.array_ref_expr);
set_field(&node->data.slice_expr.start);
set_field(&node->data.slice_expr.end);
break;
case NodeTypeFieldAccessExpr:
set_field(&node->data.field_access_expr.struct_expr);
break;
case NodeTypeUse:
set_list_fields(node->data.use.directives);
break;
case NodeTypeBoolLiteral:
// none
break;
case NodeTypeNullLiteral:
// none
break;
case NodeTypeIfBoolExpr:
set_field(&node->data.if_bool_expr.condition);
set_field(&node->data.if_bool_expr.then_block);
set_field(&node->data.if_bool_expr.else_node);
break;
case NodeTypeIfVarExpr:
set_field(&node->data.if_var_expr.var_decl.type);
set_field(&node->data.if_var_expr.var_decl.expr);
set_field(&node->data.if_var_expr.then_block);
set_field(&node->data.if_var_expr.else_node);
break;
case NodeTypeWhileExpr:
set_field(&node->data.while_expr.condition);
set_field(&node->data.while_expr.body);
break;
case NodeTypeForExpr:
set_field(&node->data.for_expr.elem_node);
set_field(&node->data.for_expr.array_expr);
set_field(&node->data.for_expr.index_node);
set_field(&node->data.for_expr.body);
break;
case NodeTypeSwitchExpr:
set_field(&node->data.switch_expr.expr);
set_list_fields(&node->data.switch_expr.prongs);
break;
case NodeTypeSwitchProng:
set_list_fields(&node->data.switch_prong.items);
set_field(&node->data.switch_prong.var_symbol);
set_field(&node->data.switch_prong.expr);
break;
case NodeTypeSwitchRange:
set_field(&node->data.switch_range.start);
set_field(&node->data.switch_range.end);
break;
case NodeTypeLabel:
// none
break;
case NodeTypeGoto:
// none
break;
case NodeTypeBreak:
// none
break;
case NodeTypeContinue:
// none
break;
case NodeTypeAsmExpr:
for (int i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
set_field(&asm_input->expr);
}
for (int i = 0; i < node->data.asm_expr.output_list.length; i += 1) {
AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
set_field(&asm_output->return_type);
}
break;
case NodeTypeStructDecl:
set_list_fields(&node->data.struct_decl.fields);
set_list_fields(&node->data.struct_decl.fns);
set_list_fields(node->data.struct_decl.directives);
break;
case NodeTypeStructField:
set_field(&node->data.struct_field.type);
set_list_fields(node->data.struct_field.directives);
break;
case NodeTypeContainerInitExpr:
set_field(&node->data.container_init_expr.type);
set_list_fields(&node->data.container_init_expr.entries);
break;
case NodeTypeStructValueField:
set_field(&node->data.struct_val_field.expr);
break;
case NodeTypeArrayType:
set_field(&node->data.array_type.size);
set_field(&node->data.array_type.child_type);
break;
}
}

2
src/parser.hpp
View File

@ -24,4 +24,6 @@ const char *node_type_str(NodeType node_type);
void ast_print(AstNode *node, int indent);
void normalize_parent_ptrs(AstNode *node);
#endif

2
test/run_tests.cpp
View File

@ -1317,7 +1317,7 @@ fn f() i32 => {
const a = c"a";
a
}
)SOURCE", 1, ".tmp_source.zig:2:15: error: expected type 'i32', got '&const u8'");
)SOURCE", 1, ".tmp_source.zig:4:5: error: expected type 'i32', got '&const u8'");
add_compile_fail_case("if condition is bool, not int", R"SOURCE(
fn f() => {