structs

parser.v

@@ -26,7 +26,7 @@ fn (p Parser) get_precedence(tok_type TokenType) Precedence {
 
 // ------------------------------------------- Symbol Table
 
-type SymbolInfo = VarSymbolInfo | FuncSymbolInfo
+type SymbolInfo = VarSymbolInfo | FuncSymbolInfo | StructTypeSymbolInfo
 
 struct VarSymbolInfo {
 	type string
@@ -37,10 +37,15 @@ struct FuncSymbolInfo {
 	block Block
 }
 
+struct StructTypeSymbolInfo {
+	name string
+}
+
 struct SymbolTable {
 mut:
 	variable_scopes []map[string]VarSymbolInfo
 	functions map[string]FuncSymbolInfo
+	structs map[string]StructTypeSymbolInfo
 }
 
 fn (mut s SymbolTable) define_var(name string, typ string) {
@@ -85,13 +90,25 @@ fn (mut s SymbolTable) lookup_func(name string) ?FuncSymbolInfo {
 	return none
 }
 
+fn (mut s SymbolTable) define_struct_type(name string) {
+	s.structs[name] = StructTypeSymbolInfo{name: name}
+}
+
+fn (mut s SymbolTable) lookup_struct_type(name string) ?StructTypeSymbolInfo {
+	if name in s.structs {
+		return s.structs[name]
+	}
+	return none
+}
+
 fn (mut s SymbolTable) is_in_global_scope() bool {
 	return s.variable_scopes.len == 1
 }
 
+
 // ------------------------------------------- Expressions
 
-type Expr = VoidExpr | UnaryExpr | BinaryExpr | IntegerLiteral | RealLiteral | BoolLiteral | Variable | TypeExpr | Function | TypeCast | ParenExpr | PrintExpr | FnCall
+type Expr = VoidExpr | UnaryExpr | BinaryExpr | IntegerLiteral | RealLiteral | BoolLiteral | Variable | TypeExpr | Function | TypeCast | ParenExpr | PrintExpr | FnCall | StructMember | StructInstantiation
 
 struct VoidExpr {}
 
@@ -126,6 +143,16 @@ struct TypeExpr {
 	name string
 }
 
+struct StructMember {
+	name string
+	type string
+}
+
+struct StructInstantiation {
+	name string
+	member_values []Expr
+}
+
 struct Function {
 	name string
 }
@@ -151,7 +178,7 @@ struct FnCall {
 
 // ------------------------------------------- Statements
 
-type Stmt = VarDecl | ExprStmt | ReturnStmt | Block | FuncDecl | Param
+type Stmt = VarDecl | ExprStmt | ReturnStmt | Block | FuncDecl | Param | StructDecl
 
 struct VarDecl {
 	name string
@@ -167,6 +194,11 @@ struct FuncDecl {
 	block Block
 }
 
+struct StructDecl {
+	name string
+	members []StructMember
+}
+
 struct ExprStmt {
 	expr Expr
 }
@@ -193,6 +225,7 @@ mut:
 	pos int
 	line int
 	statements []Stmt
+	inside_struct bool
 }
 
 fn (mut p Parser) peek() Token {
@@ -266,6 +299,17 @@ fn (mut p Parser) parse_expr(prec Precedence) Expr {
 }
 
 fn (mut p Parser) parse_ident(ident string) Expr {
+	if p.symbols.lookup_struct_type(ident) != none {
+		return match p.peek().type {
+			.lbracket {p.parse_struct_inst(ident)}
+			else {p.parse_type('struct ${ident}')}
+		}
+	}
+
+	if p.inside_struct {
+		return p.parse_struct_member(ident)
+	}
+
 	return match p.peek().type {
 		.increment, .decrement {UnaryExpr {ident: ident, op: p.next().text}}
 		.lparen {p.parse_call(ident)}
@@ -273,6 +317,36 @@ fn (mut p Parser) parse_ident(ident string) Expr {
 	}
 }
 
+fn (mut p Parser) parse_struct_member(name string) StructMember {
+	p.expect(.identifier)
+	if p.peek().type != .type {
+		dump(p.peek())
+		parse_error("Expected type after struct member ${name} in declaration, got ${p.peek().type}")
+	}
+	type := p.peek().text
+	p.expect(.type)
+	p.expect(.semicolon)
+	return StructMember{name: name, type: type}
+}
+
+fn (mut p Parser) parse_struct_inst(name string) StructInstantiation {
+	p.expect(.lbracket)
+	mut member_values := []Expr{}
+
+	if p.peek().type != .rbracket {
+		for {
+			member_values << p.parse_expr(.lowest)
+			if p.peek().type == .comma {
+				p.next()
+			} else {
+				break
+			}
+		}
+	}
+	p.expect(.rbracket)
+	return StructInstantiation{name: name, member_values: member_values}
+}
+
 fn (mut p Parser) parse_call(name string) FnCall {
 	p.expect(.lparen)
 		mut args := []Expr{}
@@ -280,11 +354,11 @@ fn (mut p Parser) parse_call(name string) FnCall {
 	if p.peek().type != .rparen {
 		for {
 			args << p.parse_expr(.lowest)
-				if p.peek().type == .comma {
-					p.next()
-				} else {
-					break
-				}
+			if p.peek().type == .comma {
+				p.next()
+			} else {
+				break
+			}
 		}
 	}
 	p.expect(.rparen)
@@ -369,10 +443,9 @@ fn (mut p Parser) get_expr_type(expr Expr) string {
 			fninfo := p.symbols.lookup_func(expr.name) or {parse_error("Tried to call undefined function ${expr.name}")}
 			fninfo.type
 		}
+		StructInstantiation {expr.name}
 		else {"Tried getting type of unexpected Expr"}
 	}
-
-
 }
 
 fn (mut p Parser) is_op_valid_for_type(type string, op string) bool {
@@ -408,12 +481,11 @@ fn (mut p Parser) parse_statement() Stmt {
 			.kw_return {return p.parse_return_stmt()}
 			.kw_fn     {return p.parse_func_decl()}
 			.lbracket  {return p.parse_block(false)}
+			.kw_struct {return p.parse_struct()}
 			else       {return p.parse_expr_stmt()}
 		}
 }
 
-
-
 fn (mut p Parser) parse_var_decl(is_const bool) VarDecl {
 	p.next()
 
@@ -423,8 +495,15 @@ fn (mut p Parser) parse_var_decl(is_const bool) VarDecl {
 	}
 
 	type_tok := p.next()
-	if type_tok.type != .type {
-		parse_error("Expected variable type after name when declaring ${name_tok.text}")
+	type_name := match type_tok.type {
+		.type {type_tok.text}
+		.identifier {
+				if p.symbols.lookup_struct_type(type_tok.text) == none {
+					parse_error("Expected variable type after name when declaring ${name_tok.text}")
+				}
+				'struct ${type_tok.text}'
+			}
+		else{parse_error("Expected variable type after name when declaring ${name_tok.text}")}
 	}
 
 	p.expect(.equals)
@@ -443,7 +522,7 @@ fn (mut p Parser) parse_var_decl(is_const bool) VarDecl {
 	return VarDecl {
 		name: name_tok.text
 		value: val
-		type: type_tok.text
+		type: type_name
 		const: is_const
 	}
 }
@@ -514,6 +593,20 @@ fn (mut p Parser) parse_func_decl() FuncDecl {
 	}
 }
 
+fn (mut p Parser) parse_struct() StructDecl {
+	p.expect(.kw_struct)
+	name := p.peek().text
+	p.expect(.identifier)
+	p.expect(.lbracket)
+	mut members := []StructMember{}
+	for p.peek().type == .identifier {
+		members << p.parse_struct_member(p.peek().text)
+	}
+	p.expect(.rbracket)
+	p.symbols.define_struct_type(name)
+	return StructDecl{name: name, members: members}
+}
+
 fn (mut p Parser) parse_return_stmt() ReturnStmt {
 	p.expect(.kw_return)