stlib arraylist

compiler/parser/parser.odin

@@ -378,7 +378,7 @@ parse_type_atom :: proc(parser: ^Parser) -> ast.Type_Syntax {
 			}
 			name = advance(parser)
 		}
-		return types.named(
+		named := types.named(
 			&parser.module.type_store,
 			u32(parser.pkg),
 			u32(name.symbol),
@@ -386,6 +386,14 @@ parse_type_atom :: proc(parser: ^Parser) -> ast.Type_Syntax {
 			u32(parser.file),
 			!symbol.is_valid(qualifier) && file_hidden_name(parser, name),
 		)
+		if current(parser).kind == .Left_Paren {
+			call := parse_call(parser, qualifier, first, name, 0)
+			return types.intern(&parser.module.type_store, types.Node{
+				kind=.Type_Call,
+				count_expr=u32(call),
+			})
+		}
+		return named
 	}
 	source.add(parser.diagnostics, tok.span, "expected a type")
 	return types.INVALID
@@ -589,6 +597,29 @@ parse_struct_literal :: proc(
 	})
 }
 
+parse_anonymous_struct_type_expr :: proc(parser: ^Parser) -> ast.Expr_Id {
+	start := advance(parser)
+	fields: [dynamic]types.Field
+	fields.allocator = parser.module.allocator
+	if !parse_record_body(parser, &fields, "expected '{' after anonymous struct type") {
+		delete(fields)
+		return invalid_expr(parser, start.span, "invalid anonymous struct type")
+	}
+	end := previous(parser)
+	field_start := u32(len(parser.module.type_fields))
+	field_count := u32(len(fields))
+	append(&parser.module.type_fields, ..fields[:])
+	delete(fields)
+	return add_expr(parser, ast.Expr{
+		kind=.Anonymous_Struct_Type,
+		span=span_from(start.span, end.span),
+		integer=u64(field_start)<<32 | u64(field_count),
+		left=ast.INVALID_EXPR,
+		right=ast.INVALID_EXPR,
+		diagnostic=source.INVALID_DIAGNOSTIC,
+	})
+}
+
 parse_integer_magnitude :: proc(text: string) -> (u64, bool) {
 	value: u64
 	for byte in transmute([]byte)text {
@@ -755,6 +786,8 @@ parse_primary :: proc(parser: ^Parser, nesting: int) -> ast.Expr_Id {
 		})
 	case .Keyword_Func:
 		return parse_function_literal(parser)
+	case .Keyword_Struct:
+		return parse_anonymous_struct_type_expr(parser)
 	case .Left_Bracket:
 		if starts_declared_type(parser) {
 			start := tok
@@ -842,7 +875,20 @@ parse_primary :: proc(parser: ^Parser, nesting: int) -> ast.Expr_Id {
 			name = advance(parser)
 		}
 		if current(parser).kind == .Left_Paren {
-			return parse_call(parser, qualifier, first, name, nesting)
+			call := parse_call(parser, qualifier, first, name, nesting)
+			if current(parser).kind == .Left_Brace && !(parser.no_struct_literal && parser.delimiter_depth == 0) {
+				left_brace := advance(parser)
+				args, right_brace := parse_keyed_initializers(parser, left_brace, nesting, "expected '}' after struct literal")
+				return add_expr(parser, ast.Expr{
+					kind=.Struct_Literal,
+					span=span_from(parser.module.exprs[call].span, right_brace.span),
+					args=args,
+					left=call,
+					right=ast.INVALID_EXPR,
+					diagnostic=source.INVALID_DIAGNOSTIC,
+				})
+			}
+			return call
 		}
 		if current(parser).kind == .Left_Brace && !(parser.no_struct_literal && parser.delimiter_depth == 0) {
 			return parse_struct_literal(parser, qualifier, first, name, nesting)