Merge branch 'master' into zip-with-macro

Author: lerno

CMakeLists.txt

@@ -390,6 +390,7 @@ add_executable(c3c
         src/utils/unzipper.c
         src/compiler/c_codegen.c
         src/compiler/decltable.c
+        src/compiler/methodtable.c
         src/compiler/mac_support.c
         src/compiler/windows_support.c
         src/compiler/codegen_asm.c

lib/std/core/string.c3

@@ -187,7 +187,7 @@ fn String String.replace(self, Allocator allocator, String needle, String new_st
 	@pool()
 	{
 		String[] split = self.tsplit(needle);
-		return dstring::join(tmem, split, new_str).copy_str(mem);
+		return dstring::join(tmem, split, new_str).copy_str(allocator);
 	};
 }
 

releasenotes.md

@@ -11,6 +11,7 @@
 - Deprecate `@compact` use for comparison. Old behaviour is enabled using `--use-old-compact-eq`.
 - Switch available for types implementing `@operator(==)`.
 - `Type.is_eq` is now true for types with `==` overload.
+- Methods ignore visibility settings.
 - Allow inout etc on untyped macro parameters even if they are not pointers.
 - Deprecate `add_array` in favour of `push_all` on lists.
 
@@ -39,6 +40,8 @@
 - Compile time indexing at compile time in a $typeof was no considered compile time.
 - Slicing a constant array with designated initialization would not update the indexes.
 - Fix for bug when `@format` encountered `*` in some cases.
+- Compiler segfault on global slice initialization with null[:0] #2404.
+- Use correct allocator in `replace`.
 
 ### Stdlib changes
 - Add `==` to `Pair`, `Triple` and TzDateTime. Add print to `Pair` and `Triple`.

src/compiler/compiler.c

@@ -75,9 +75,10 @@ void compiler_init(BuildOptions *build_options)
 
 	htable_init(&compiler.context.features, 1024);
 	htable_init(&compiler.context.compiler_defines, 16 * 1024);
+	methodtable_init(&compiler.context.method_extensions, 16 * 1024);
 	compiler.context.module_list = NULL;
 	compiler.context.generic_module_list = NULL;
-	compiler.context.method_extensions = NULL;
+	compiler.context.method_extension_list = NULL;
 
 	vmem_init(&ast_arena, START_VMEM_SIZE);
 	ast_calloc();

src/compiler/compiler_internal.h

@@ -121,6 +121,22 @@ typedef struct
 	TypeKind type;
 } Float;
 
+typedef struct
+{
+	uint32_t count;
+	uint32_t capacity;
+	uint32_t max_load;
+	DeclId *methods;
+} MethodTable;
+
+typedef struct
+{
+	uint32_t count;
+	uint32_t capacity;
+	uint32_t max_load;
+	DeclId *entries;
+} DeclTable;
+
 struct ConstInitializer_
 {
 	ConstInitType kind;
@@ -619,6 +635,13 @@ typedef struct
 	AstId parent;
 } LabelDecl;
 
+typedef struct
+{
+	DeclId overloads[OVERLOADS_COUNT + 1];
+	DeclTable method_table;
+	Decl **methods;
+} Methods;
+
 typedef struct Decl_
 {
 	const char *name;
@@ -678,7 +701,7 @@ typedef struct Decl_
 		struct
 		{
 			TypeInfo **interfaces;
-			Decl **methods;
+			Methods *method_table;
 			union
 			{
 				// Enums and Fault
@@ -1570,7 +1593,6 @@ typedef struct Module_
 	AnalysisStage stage : 6;
 
 	AstId contracts;
-	Decl** private_method_extensions;
 	HTable symbols;
 	struct CompilationUnit_ **units;
 	Module *generic_module;
@@ -1652,14 +1674,6 @@ typedef struct
 	LexMode mode;
 } Lexer;
 
-typedef struct
-{
-	uint32_t count;
-	uint32_t capacity;
-	uint32_t max_load;
-	DeclId *entries;
-} DeclTable;
-
 struct CompilationUnit_
 {
 	Module *module;
@@ -1697,7 +1711,6 @@ struct CompilationUnit_
 	Decl *main_function;
 	HTable local_symbols;
 	int lambda_count;
-	Decl **local_method_extensions;
 	TypeInfo **check_type_variable_array;
 	struct
 	{
@@ -1899,7 +1912,6 @@ typedef struct
 	Module **module_list;
 	Module **generic_module_list;
 	Type **type;
-	Decl **method_extensions;
 	const char *lib_dir;
 	const char **sources;
 	File **loaded_sources;
@@ -1911,6 +1923,8 @@ typedef struct
 	HTable compiler_defines;
 	HTable features;
 	Module std_module;
+	MethodTable method_extensions;
+	Decl **method_extension_list;
 	DeclTable symbols;
 	PathTable path_symbols;
 	DeclTable generic_symbols;
@@ -2160,6 +2174,7 @@ UNUSED bool i128_get_bit(const Int128 *op, int bit);
 #define MACRO_COPY_DECL(x) x = copy_decl(c, x)
 #define MACRO_COPY_DECLID(x) x = declid_copy_deep(c, x)
 #define MACRO_COPY_DECL_LIST(x) x = copy_decl_list(c, x)
+#define MACRO_COPY_DECL_METHODS(x) x = copy_decl_methods(c, x)
 #define MACRO_COPY_EXPR(x) x = copy_expr(c, x)
 #define MACRO_COPY_EXPRID(x) x = exprid_copy_deep(c, x)
 #define MACRO_COPY_TYPE(x) x = copy_type_info(c, x)
@@ -2370,6 +2385,7 @@ Path *path_create_from_string(const char *string, uint32_t len, SourceSpan span)
 typedef enum FindMember
 {
 	METHODS_AND_FIELDS,
+	METHODS_INTERFACES_AND_FIELDS,
 	FIELDS_ONLY
 } FindMember;
 
@@ -2418,8 +2434,9 @@ void sema_expr_convert_enum_to_int(Expr *expr);
 Decl *sema_decl_stack_resolve_symbol(const char *symbol);
 Decl *sema_find_decl_in_modules(Module **module_list, Path *path, const char *interned_name);
 bool unit_resolve_parameterized_symbol(SemaContext *context, NameResolve *name_resolve);
-Decl *sema_resolve_type_method(CompilationUnit *unit, Type *type, const char *method_name, Decl **ambiguous_ref, Decl **private_ref);
-Decl *sema_resolve_method(CompilationUnit *unit, Decl *type, const char *method_name, Decl **ambiguous_ref, Decl **private_ref);
+Decl *sema_resolve_type_method(CanonicalType *type, const char *method_name);
+Decl *sema_resolve_method(Decl *type, const char *method_name);
+Decl *sema_resolve_method_only(Decl *type, const char *method_name);
 Decl *sema_find_extension_method_in_list(Decl **extensions, Type *type, const char *method_name);
 bool sema_resolve_type_decl(SemaContext *context, Type *type);
 bool sema_check_type_variable_array(SemaContext *context, TypeInfo *type);
@@ -2476,6 +2493,10 @@ void decltable_init(DeclTable *table, uint32_t initial_size);
 DeclId decltable_get(DeclTable *table, const char *name);
 void decltable_set(DeclTable *table, Decl *decl);
 
+void methodtable_init(MethodTable *table, uint32_t initial_size);
+DeclId methodtable_get(MethodTable *table, Type *type, const char *name);
+DeclId methodtable_set(MethodTable *table, Decl *method);
+
 const char *scratch_buffer_interned(void);
 const char *scratch_buffer_interned_as(TokenType *type);
 
@@ -2542,7 +2563,6 @@ bool type_is_abi_aggregate(Type *type);
 bool type_is_int128(Type *type);
 
 Type *type_from_token(TokenType type);
-bool type_is_user_defined(Type *type);
 bool type_is_structurally_equivalent(Type *type1, Type *type);
 bool type_flat_is_floatlike(Type *type);
 bool type_flat_is_intlike(Type *type);
@@ -2608,6 +2628,7 @@ INLINE TypeInfo *type_info_new(TypeInfoKind kind, SourceSpan span);
 INLINE TypeInfo *type_info_new_base(Type *type, SourceSpan span);
 INLINE bool type_info_ok(TypeInfo *type_info);
 INLINE bool type_info_poison(TypeInfo *type);
+INLINE bool type_is_user_defined(Type *type);
 
 int type_kind_bitsize(TypeKind kind);
 INLINE bool type_kind_is_signed(TypeKind kind);
@@ -3019,6 +3040,46 @@ INLINE Type *type_flatten_for_bitstruct(Type *type)
 	return type;
 }
 
+static inline void methods_add(Methods *methods, Decl *method)
+{
+	vec_add(methods->methods, method);
+	OperatorOverload operator = method->func_decl.operator;
+	if (operator)
+	{
+		unsigned len = vec_size(method->func_decl.signature.params);
+		if (operator == OVERLOAD_MINUS && len == 1)
+		{
+			method->func_decl.operator = operator = OVERLOAD_UNARY_MINUS;
+		}
+
+		if (len > 1 && !method->func_decl.signature.params[1]->var.type_info)
+		{
+			method->func_decl.is_wildcard_overload = true;
+		}
+		DeclId *decl = &methods->overloads[operator];
+		if (!*decl)
+		{
+			*decl = declid(method);
+		}
+		else
+		{
+			Decl *current = declptr(*decl);
+			if (current->decl_kind != DECL_DECLARRAY)
+			{
+				Decl *decl_array = decl_new(DECL_DECLARRAY, NULL,  INVALID_SPAN);
+				vec_add(decl_array->decls, declptr(*decl));
+				vec_add(decl_array->decls, method);
+				*decl = declid(decl_array);
+			}
+			else
+			{
+				vec_add(current->decls, method);
+			}
+		}
+	}
+	decltable_set(&methods->method_table, method);
+}
+
 static inline Type *type_base(Type *type)
 {
 	while (1)
@@ -3147,6 +3208,21 @@ static inline Type *type_flat_distinct_enum_inline(Type *type)
 	}
 }
 
+INLINE bool type_is_user_defined(Type *type)
+{
+	static const bool user_defined_types[TYPE_LAST + 1] = {
+		[TYPE_ENUM] = true,
+		[TYPE_STRUCT] = true,
+		[TYPE_FUNC_RAW] = true,
+		[TYPE_UNION] = true,
+		[TYPE_DISTINCT] = true,
+		[TYPE_BITSTRUCT] = true,
+		[TYPE_TYPEDEF] = true,
+		[TYPE_INTERFACE] = true,
+	};
+	return user_defined_types[type->type_kind];
+}
+
 static inline Type *type_flatten_to_int(Type *type)
 {
 	while (1)

src/compiler/copying.c

@@ -16,6 +16,7 @@ static Ast *ast_copy_deep(CopyStruct *c, Ast *source);
 static Ast **copy_ast_list(CopyStruct *c, Ast **to_copy);
 static Decl *copy_decl(CopyStruct *c, Decl *decl);
 static Decl **copy_decl_list(CopyStruct *c, Decl **decl_list);
+static Methods *copy_decl_methods(CopyStruct *c, Methods *methods);
 static TypeInfo *copy_type_info(CopyStruct *c, TypeInfo *source);
 
 static inline void copy_reg_ref(CopyStruct *c, void *original, void *result)
@@ -871,8 +872,6 @@ static ResolvedAttrData *copy_attrs_resolved(CopyStruct *c, ResolvedAttrData *da
 			.section = data->section,
 			.wasm_module = data->wasm_module
 	};
-	const char **new = NULL;
-
 	return copy;
 }
 
@@ -913,6 +912,19 @@ Decl **copy_decl_list(CopyStruct *c, Decl **decl_list)
 	return result;
 }
 
+static Methods *copy_decl_methods(CopyStruct *c, Methods *methods)
+{
+	if (!methods) return NULL;
+	Methods *copy = CALLOCS(Methods);
+	decltable_init(&copy->method_table, 64);
+
+	FOREACH(Decl *, method, methods->methods)
+	{
+		methods_add(copy, copy_decl(c, method));
+	}
+	return copy;
+}
+
 TypeInfo *copy_type_info(CopyStruct *c, TypeInfo *source)
 {
 	if (!source) return NULL;
@@ -1004,7 +1016,7 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
 		case DECL_INTERFACE:
 			copy_decl_type(copy);
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			MACRO_COPY_DECL_LIST(copy->interface_methods);
 			break;
 		case DECL_CT_EXEC:
@@ -1024,7 +1036,7 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
 			MACRO_COPY_DECL_LIST(copy->strukt.members);
 			MACRO_COPY_DECLID(copy->strukt.padded_decl_id);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			break;
 		case DECL_DECLARRAY:
 		case DECL_GROUP:
@@ -1035,21 +1047,21 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
 			MACRO_COPY_DECL_LIST(copy->strukt.members);
 			MACRO_COPY_TYPE(copy->strukt.container_type);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			break;
 		case DECL_FAULT:
 			break;
 		case DECL_CONST_ENUM:
 			copy_decl_type(copy);
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			MACRO_COPY_TYPE(copy->enums.type_info);
 			MACRO_COPY_DECL_LIST(copy->enums.values);
 			break;
 		case DECL_ENUM:
 			copy_decl_type(copy);
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			MACRO_COPY_DECL_LIST(copy->enums.parameters);
 			MACRO_COPY_TYPE(copy->enums.type_info);
 			MACRO_COPY_DECL_LIST(copy->enums.values);
@@ -1112,7 +1124,7 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
 		case DECL_DISTINCT:
 			copy_decl_type(copy);
 			MACRO_COPY_TYPE_LIST(copy->interfaces);
-			MACRO_COPY_DECL_LIST(copy->methods);
+			MACRO_COPY_DECL_METHODS(copy->method_table);
 			MACRO_COPY_TYPE(copy->distinct);
 			break;
 		case DECL_CT_ECHO:

src/compiler/decltable.c

@@ -89,4 +89,4 @@ void decltable_init(DeclTable *table, uint32_t initial_size)
 	table->capacity = initial_size;
 	table->max_load = (uint32_t)(initial_size * TABLE_MAX_LOAD);
 	table->entries = entries;
-}
+}

src/compiler/llvm_codegen_expr.c

@@ -2638,19 +2638,26 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r
 	ASSERT(slice->expr_kind == EXPR_SLICE);
 
 	Expr *parent_expr = exprptr(slice->subscript_expr.expr);
-
 	Type *parent_type = type_flatten(parent_expr->type);
+	parent_type = type_no_optional(parent_type);
 	BEValue parent_addr_x;
 	llvm_emit_expr(c, &parent_addr_x, parent_expr);
-	llvm_value_addr(c, &parent_addr_x);
-	LLVMValueRef parent_addr = parent_addr_x.value;
 	LLVMValueRef parent_load_value = NULL;
 	LLVMValueRef parent_base;
-	parent_type = type_no_optional(parent_type);
+	LLVMValueRef parent_addr;
+	if (parent_type->type_kind == TYPE_POINTER)
+	{
+		llvm_value_rvalue(c, &parent_addr_x);
+		parent_load_value = parent_base = parent_addr_x.value;
+	}
+	else
+	{
+		llvm_value_addr(c, &parent_addr_x);
+		parent_addr = parent_addr_x.value;
+	}
 	switch (parent_type->type_kind)
 	{
 		case TYPE_POINTER:
-			parent_load_value = parent_base = LLVMBuildLoad2(c->builder, llvm_get_type(c, parent_type), parent_addr, "");
 			break;
 		case TYPE_SLICE:
 			parent_load_value = LLVMBuildLoad2(c->builder, llvm_get_type(c, parent_type), parent_addr, "");