better list support and added to readme

Author: Kolterdyx

README.md

@@ -27,7 +27,7 @@ This is a list of features that are currently implemented or planned for the fut
   - [x] **Double**.
   - [x] **String**.
   - [x] **Boolean**: Booleans do not have a type. Other types are evaluated to be truthy or falsy. Falsy values are `0`, `0.0`, `""`.
-  - [ ] **Array**.
+  - [x] **List**: Statically typed lists. Only `int`, `double`, and `str` are supported for now.
   - [ ] **Struct**: User-defined data types.
 - [x] **Comments**: Single-line comments with `#`.
 - [x] **String operations**:
@@ -209,6 +209,16 @@ func main() {
     math:acos(1.0);
     math:asin(0.0);
     math:atan(0.0);
+    
+    # Lists are statically typed, and the type must be specified when creating a list
+    # Only 'int', 'double', and 'str' are supported for now
+    let myList list<int> = [1, 2, 3, 4, 5];
+    # You can also create empty lists
+    let myList2 list<int> = [];
+    
+    # You can access or assign list elements using the [] operator
+    myList[0] = 10;
+    mcb:print(myList[0]);
 }
 ```
 

example/src/main.mcb

@@ -14,7 +14,7 @@ func fizbuzz(n int) {
     # since for/while loops aren't supported yet, here is a cut down version of the fizzbuzz function
     # that evaluates a single value at a time instead of all the numbers up to n
     if (n % 3 == 0 and n % 5 == 0) {
-        mcb:print("FizzBuzz");
+        mcb:print("FizzBuzz!");
     } else if (n % 3 == 0) {
         mcb:print("Fizz");
     } else if (n % 5 == 0) {
@@ -87,4 +87,15 @@ func main() {
     math:acos(1.0);
     math:asin(0.0);
     math:atan(0.0);
+
+    # Lists are statically typed, and the type must be specified when creating a list
+    # Only 'int', 'double', and 'str' are supported for now
+    let myList list<int> = [1, 2, 3, 4, 5];
+    # You can also create empty lists
+    let myList2 list<int> = [];
+
+    # You can access or assign list elements using the [] operator
+    myList[0] = 42;
+    mcb:print("myList = " + myList);
+    mcb:print("myList2 = " + myList2);
 }

internal/parser/statements.go

@@ -87,7 +87,9 @@ func (p *Parser) letDeclaration() (statements.Stmt, error) {
 		return nil, err
 	}
 	if initializer != nil && initializer.ReturnType() != varType {
-		return nil, p.error(p.peekCount(-2), fmt.Sprintf("Cannot assign %s to %s.", initializer.ReturnType(), varType))
+		if !(p.isListType(varType) && initializer.ReturnType() == expressions.VoidType) {
+			return nil, p.error(p.peekCount(-2), fmt.Sprintf("Cannot assign %s to %s.", initializer.ReturnType(), varType))
+		}
 	}
 	p.variables[p.currentScope] = append(p.variables[p.currentScope], statements.VarDef{
 		Name: name.Lexeme,
@@ -102,10 +104,10 @@ func (p *Parser) letDeclaration() (statements.Stmt, error) {
 
 func (p *Parser) variableAssignment() (statements.Stmt, error) {
 	name := p.previous()
-	hasIndex := false
 	var index expressions.Expr
+	var err error
 	if p.match(tokens.BracketOpen) {
-		index, err := p.expression()
+		index, err = p.expression()
 		if err != nil {
 			return nil, err
 		}
@@ -116,12 +118,11 @@ func (p *Parser) variableAssignment() (statements.Stmt, error) {
 		if index.ReturnType() != expressions.IntType {
 			return nil, p.error(p.peek(), fmt.Sprintf("Index must be of type %s.", expressions.IntType))
 		}
-		if p.isStruct(name) {
+		if !p.isList(name) {
 			return nil, p.error(name, fmt.Sprintf("Cannot index type %s.", p.getType(name)))
 		}
-		hasIndex = true
 	}
-	_, err := p.consume(tokens.Equal, "Expected '=' after variable name.")
+	_, err = p.consume(tokens.Equal, "Expected '=' after variable name.")
 	if err != nil {
 		return nil, err
 	}
@@ -133,10 +134,7 @@ func (p *Parser) variableAssignment() (statements.Stmt, error) {
 	if err != nil {
 		return nil, err
 	}
-	if hasIndex {
-		return statements.VariableAssignmentStmt{Name: name, Index: &index, Value: value}, nil
-	}
-	return statements.VariableAssignmentStmt{Name: name, Value: value}, nil
+	return statements.VariableAssignmentStmt{Name: name, Value: value, Index: index}, nil
 }
 
 func (p *Parser) functionDeclaration() (statements.Stmt, error) {

internal/parser/utils.go

@@ -115,7 +115,7 @@ func (p *Parser) getType(name tokens.Token) interfaces.ValueType {
 	return ""
 }
 
-func (p *Parser) isStruct(name tokens.Token) bool {
+func (p *Parser) isList(name tokens.Token) bool {
 	for _, v := range p.variables {
 		for _, def := range v {
 			if def.Name == name.Lexeme {
@@ -140,6 +140,19 @@ func (p *Parser) isStruct(name tokens.Token) bool {
 	return false
 }
 
+func (p *Parser) isListType(varType interfaces.ValueType) bool {
+	switch varType {
+	case expressions.ListIntType:
+		return true
+	case expressions.ListStringType:
+		return true
+	case expressions.ListDoubleType:
+		return true
+	default:
+		return false
+	}
+}
+
 func (p *Parser) getListType(valueType interfaces.ValueType) interfaces.ValueType {
 	switch valueType {
 	case expressions.IntType:
@@ -148,6 +161,8 @@ func (p *Parser) getListType(valueType interfaces.ValueType) interfaces.ValueTyp
 		return expressions.ListStringType
 	case expressions.DoubleType:
 		return expressions.ListDoubleType
+	case expressions.VoidType:
+		return expressions.VoidType
 	default:
 		log.Fatalf("Unsupported type for list: %s", valueType)
 	}

internal/statements/variableAssignment.go

@@ -7,7 +7,7 @@ import (
 
 type VariableAssignmentStmt struct {
 	Name  tokens.Token
-	Index *expressions.Expr
+	Index expressions.Expr
 	Value expressions.Expr
 }
 

internal/visitors/compiler/compiler.go

@@ -229,7 +229,7 @@ func (c *Compiler) createFunctionTags() {
 }
 
 func (c *Compiler) error(location interfaces.SourceLocation, message string) {
-	log.Errorf("[Position %d:%d] Error at '%s':\n", location.Row+1, location.Col+1, message)
+	log.Errorf("[Position %d:%d] Error: %s\n", location.Row+1, location.Col+1, message)
 }
 
 func (c *Compiler) newRegister(regName string) string {

internal/visitors/compiler/statements.go

@@ -93,13 +93,13 @@ func (c *Compiler) VisitVariableAssignment(stmt statements.VariableAssignmentStm
 	cmd := ""
 	isIndexedAssignment := stmt.Index != nil
 	if stmt.Value.ReturnType() != c.getReturnType(stmt.Name.Lexeme) && !isIndexedAssignment {
-		log.Fatalf("Assignment type mismatch: %v != %v\n", stmt.Value.ReturnType(), c.getReturnType(stmt.Name.Lexeme))
+		c.error(stmt.Name.SourceLocation, fmt.Sprintf("Assignment type mismatch: %v != %v", c.getReturnType(stmt.Name.Lexeme), stmt.Value.ReturnType()))
 	}
 	cmd += stmt.Value.Accept(c).(string)
 	valueReg := ops.Cs(c.newRegister(ops.RX))
 	cmd += c.opHandler.Move(ops.Cs(ops.RX), valueReg)
 	if isIndexedAssignment {
-		cmd += (*stmt.Index).Accept(c).(string)
+		cmd += stmt.Index.Accept(c).(string)
 		indexReg := ops.Cs(c.newRegister(ops.RX))
 		cmd += c.opHandler.Move(ops.Cs(ops.RX), indexReg)
 		cmd += c.opHandler.SetListIndex(ops.Cs(stmt.Name.Lexeme), indexReg, valueReg)