added: _ in all places where #auto was used

Author: brendanfh

compiler/src/parser.c

@@ -529,7 +529,7 @@ static void parse_arguments(OnyxParser* parser, TokenType end_token, Arguments*
     }
 }
 
-static b32 arg_is_placeholder(AstTyped *arg) {
+static b32 value_is_placeholder(AstTyped *arg) {
     if (arg->kind != Ast_Kind_Symbol) return 0;
     if (arg->token->length > 1) return 0;
     if (arg->token->text[0] != '_') return 0;
@@ -559,7 +559,7 @@ static AstCall* parse_function_call(OnyxParser *parser, AstTyped *callee) {
     bh_arr_each(AstTyped *, arg, call_node->args.values) {
         if ((*arg) == NULL) continue;
 
-        if (arg_is_placeholder(*arg)) {
+        if (value_is_placeholder(*arg)) {
             if (call_node->placeholder_argument_position > 0) {
                 onyx_report_error((*arg)->token->pos, Error_Critical, "Cannot have more than one placeholder argument ('_').");
             }
@@ -1763,6 +1763,11 @@ static i32 parse_possible_compound_symbol_declaration(OnyxParser* parser, AstNod
         // See comment in parse_possible_symbol_declaration about "#auto"
         if (!parse_possible_directive(parser, "auto")) {
             type_for_all = parse_type(parser);
+
+            // Placeholders (_) are discarded and allow for type inference.
+            if (value_is_placeholder((AstTyped *) type_for_all)) {
+                type_for_all = NULL;
+            }
         }
 
         forll (AstLocal, local, first_local, next) {
@@ -1820,6 +1825,11 @@ static i32 parse_possible_symbol_declaration(OnyxParser* parser, AstNode** ret)
             // typed on the first assignment.
         } else {
             type_node = parse_type(parser);
+
+            // Placeholders (_) are discarded and allow for type inference.
+            if (value_is_placeholder((AstTyped *) type_node)) {
+                type_node = NULL;
+            }
         }
     }
 
@@ -3264,6 +3274,10 @@ static AstFunction* parse_function_definition(OnyxParser* parser, OnyxToken* tok
             func_def->return_type = (AstType *) &basic_type_auto_return;
         } else {
             func_def->return_type = parse_return_type(parser, &func_def->named_return_locals);
+
+            if (value_is_placeholder((AstTyped *) func_def->return_type)) {
+                func_def->return_type = (AstType *) &basic_type_auto_return;
+            }
         }
     }
 

examples/20_auto_return.onyx

@@ -6,7 +6,7 @@
 main :: (args: [] cstr) {
     // If you don't want to explicitly write the return type
     // of a function, you can use #auto:
-    f :: (x: i32) -> #auto {
+    f :: (x: i32) -> _ {
         return x * 2;
     }
 
@@ -27,7 +27,7 @@ main :: (args: [] cstr) {
     // come from? The only way to do this is use an auto-return
     // type and let the compiler fill it in.
 
-    consume :: (it: $T) -> #auto where iter.Iterable(T) {
+    consume :: (it: $T) -> _ where iter.Iterable(T) {
         consume_inner :: macro (it: Iterator($V)) -> [] V {
             arr: [..] V;
             for v in it do arr << v;

examples/21_quick_functions.onyx

@@ -3,7 +3,7 @@
 // determine a return type with #auto, you can write a completely type free
 // procedure like so:
 
-no_types :: (x: $__type_x, y: $__type_y) -> #auto {
+no_types :: (x: $__type_x, y: $__type_y) -> _ {
     return x + ~~ y;
 }
 

tests/new_auto_types

@@ -0,0 +1,6 @@
+100
+i32
+123
+[] u8
+Allocator
+f64

tests/new_auto_types.onyx

@@ -0,0 +1,24 @@
+use core {*}
+
+main :: () {
+	x: _
+	x = 100
+	println(x)
+	println(typeof x)
+
+	func_with_auto_return() |> println()
+
+	a, b, c: _
+	a = "Test"
+	b = context.allocator
+	c = 45.56
+	println(typeof a)
+	println(typeof b)
+	println(typeof c)
+}
+
+func_with_auto_return :: () -> _ {
+	return 123
+}
+
+