mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-20 08:14:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

add error message for method call on non method

Browse Source 
closes #199
This commit is contained in:
Andrew Kelley 2016-09-26 00:40:09 -04:00
parent 01e13de7ca
commit 4b68224c60
3 changed files with 86 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/all_types.hpp
View File

@ -452,7 +452,6 @@ struct AstNodeFieldAccessExpr {
TypeEnumField *type_enum_field;
Expr resolved_expr;
StructValExprCodeGen resolved_struct_val_expr; // for enum values
bool is_fn_call;
TypeTableEntry *bare_container_type;
bool is_member_fn;
AstNode *container_init_expr_node;

59
src/analyze.cpp
View File

@ -2798,11 +2798,11 @@ static void resolve_container_type(CodeGen *g, TypeTableEntry *type_entry) {
}
}
static TypeTableEntry *analyze_container_member_access_inner(CodeGen *g, bool wrapped_in_fn_call,
static TypeTableEntry *analyze_container_member_access_inner(CodeGen *g,
TypeTableEntry *bare_struct_type, Buf *field_name, AstNode *node, TypeTableEntry *struct_type)
{
assert(node->type == NodeTypeFieldAccessExpr);
if (wrapped_in_fn_call && !is_slice(bare_struct_type)) {
if (!is_slice(bare_struct_type)) {
BlockContext *container_block_context = get_container_block_context(bare_struct_type);
assert(container_block_context);
auto entry = container_block_context->decl_table.maybe_get(field_name);
@ -2821,19 +2821,14 @@ static TypeTableEntry *analyze_container_member_access_inner(CodeGen *g, bool wr
} else {
return resolve_expr_const_val_as_fn(g, node, fn_entry, false);
}
} else {
add_node_error(g, node, buf_sprintf("no function named '%s' in '%s'",
buf_ptr(field_name), buf_ptr(&bare_struct_type->name)));
return g->builtin_types.entry_invalid;
}
} else {
add_node_error(g, node,
buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&struct_type->name)));
return g->builtin_types.entry_invalid;
}
add_node_error(g, node,
buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&bare_struct_type->name)));
return g->builtin_types.entry_invalid;
}
static TypeTableEntry *analyze_container_member_access(CodeGen *g, bool wrapped_in_fn_call,
static TypeTableEntry *analyze_container_member_access(CodeGen *g,
Buf *field_name, AstNode *node, TypeTableEntry *struct_type)
{
TypeTableEntry *bare_type = container_ref_type(struct_type);
@ -2848,7 +2843,7 @@ static TypeTableEntry *analyze_container_member_access(CodeGen *g, bool wrapped_
if (node->data.field_access_expr.type_struct_field) {
return node->data.field_access_expr.type_struct_field->type_entry;
} else {
return analyze_container_member_access_inner(g, wrapped_in_fn_call, bare_type, field_name,
return analyze_container_member_access_inner(g, bare_type, field_name,
node, struct_type);
}
} else if (bare_type->id == TypeTableEntryIdEnum) {
@ -2856,7 +2851,7 @@ static TypeTableEntry *analyze_container_member_access(CodeGen *g, bool wrapped_
if (node->data.field_access_expr.type_enum_field) {
return node->data.field_access_expr.type_enum_field->type_entry;
} else {
return analyze_container_member_access_inner(g, wrapped_in_fn_call, bare_type, field_name,
return analyze_container_member_access_inner(g, bare_type, field_name,
node, struct_type);
}
} else if (bare_type->id == TypeTableEntryIdUnion) {
@ -2875,12 +2870,10 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
TypeTableEntry *struct_type = analyze_expression(g, import, context, nullptr, *struct_expr_node);
Buf *field_name = node->data.field_access_expr.field_name;
bool wrapped_in_fn_call = node->data.field_access_expr.is_fn_call;
if (struct_type->id == TypeTableEntryIdInvalid) {
return struct_type;
} else if (is_container_ref(struct_type)) {
return analyze_container_member_access(g, wrapped_in_fn_call, field_name, node, struct_type);
return analyze_container_member_access(g, field_name, node, struct_type);
} else if (struct_type->id == TypeTableEntryIdArray) {
if (buf_eql_str(field_name, "len")) {
return resolve_expr_const_val_as_unsigned_num_lit(g, node, expected_type,
@ -2949,8 +2942,6 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
buf_ptr(&child_type->name), buf_ptr(field_name)));
return g->builtin_types.entry_invalid;
}
} else if (wrapped_in_fn_call) { // this branch should go last, before the error in the else case
return resolve_expr_const_val_as_type(g, node, child_type, false);
} else {
add_node_error(g, node,
buf_sprintf("type '%s' does not support field access", buf_ptr(&struct_type->name)));
@ -5581,6 +5572,19 @@ static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry
zig_unreachable();
}
static TypeTableEntry *bad_method_call(CodeGen *g, AstNode *node, TypeTableEntry *container_type,
TypeTableEntry *expected_param_type, FnTableEntry *fn_table_entry)
{
ErrorMsg *msg = add_node_error(g, node,
buf_sprintf("function called as method of '%s', but first parameter is of type '%s'",
buf_ptr(&container_type->name),
buf_ptr(&expected_param_type->name)));
if (fn_table_entry) {
add_error_note(g, msg, fn_table_entry->proto_node, buf_sprintf("function declared here"));
}
return g->builtin_types.entry_invalid;
}
// Before calling this function, set node->data.fn_call_expr.fn_table_entry if the function is known
// at compile time. Otherwise this is a function pointer call.
static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
@ -5623,10 +5627,23 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import,
bool all_args_const_expr = true;
if (struct_node) {
ConstExprValue *struct_const_val = &get_resolved_expr(struct_node)->const_val;
Expr *struct_expr = get_resolved_expr(struct_node);
ConstExprValue *struct_const_val = &struct_expr->const_val;
if (!struct_const_val->ok) {
all_args_const_expr = false;
}
FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[0];
TypeTableEntry *expected_param_type = param_info->type;
TypeTableEntry *container_bare_type = container_ref_type(struct_expr->type_entry);
if (is_container_ref(expected_param_type)) {
TypeTableEntry *param_bare_type = container_ref_type(expected_param_type);
if (param_bare_type != container_bare_type) {
return bad_method_call(g, node, container_bare_type, expected_param_type, fn_table_entry);
}
} else {
return bad_method_call(g, node, container_bare_type, expected_param_type, fn_table_entry);
}
}
// analyze each parameter. in the case of a method, we already analyzed the
@ -5925,10 +5942,6 @@ static TypeTableEntry *analyze_fn_call_expr(CodeGen *g, ImportTableEntry *import
return analyze_builtin_fn_call_expr(g, import, context, expected_type, node);
}
if (fn_ref_expr->type == NodeTypeFieldAccessExpr) {
fn_ref_expr->data.field_access_expr.is_fn_call = true;
}
TypeTableEntry *invoke_type_entry = analyze_expression(g, import, context, nullptr, fn_ref_expr);
if (invoke_type_entry->id == TypeTableEntryIdInvalid) {
return g->builtin_types.entry_invalid;

51
test/run_tests.cpp
View File

@ -1533,7 +1533,56 @@ fn foo() {
}
)SOURCE", 2,
".tmp_source.zig:6:16: error: use of undeclared identifier 'JsonList'",
".tmp_source.zig:27:8: error: no function named 'init' in 'JsonNode'");
".tmp_source.zig:27:8: error: no member named 'init' in 'JsonNode'");
add_compile_fail_case("method call with first arg type primitive", R"SOURCE(
struct Foo {
x: i32,
fn init(x: i32) -> Foo {
Foo {
.x = x,
}
}
}
fn f() {
const derp = Foo.init(3);
derp.init();
}
)SOURCE", 2,
".tmp_source.zig:15:14: error: function called as method of 'Foo', but first parameter is of type 'i32'",
".tmp_source.zig:5:5: note: function declared here");
add_compile_fail_case("method call with first arg type wrong container", R"SOURCE(
pub struct List {
len: usize,
allocator: &Allocator,
pub fn init(allocator: &Allocator) -> List {
List {
.len = 0,
.allocator = allocator,
}
}
}
pub var global_allocator = Allocator {
.field = 1234,
};
pub struct Allocator {
field: i32,
}
fn foo() {
var x = List.init(&global_allocator);
x.init();
}
)SOURCE", 2,
".tmp_source.zig:24:11: error: function called as method of 'List', but first parameter is of type '&Allocator'",
".tmp_source.zig:6:9: note: function declared here");
}
//////////////////////////////////////////////////////////////////////////////