feat: add semantic analyzer to do type inference and add semi colons to support multiple statements

Author: ProgrammingMuffin

lex/lex.go

@@ -5,14 +5,18 @@ import (
 	"os"
 	"strings"
 	"unicode"
-
-	"github.com/k0kubun/pp"
 )
 
 type Token interface {
 	GetPos() (int, int)
 }
 
+type Semicolon struct {
+	Token
+	Pos int
+	End int
+}
+
 type LBrace struct {
 	Token
 	Pos int
@@ -145,7 +149,7 @@ func LexSourceFile(sourceFile string) []Token {
 					tokens = append(tokens, Number{Pos: pos, End: end, Value: numberValue.String(), Kind: kind})
 					numberValue.Reset()
 				}
-			} else if isSymbol(char) && (unicode.IsLetter(rune(data[index+1])) || unicode.IsNumber(rune(data[index+1])) || data[index+1] == '(' || data[index+1] == ')' || data[index+1] == ' ' || data[index+1] == '\t' || data[index+1] == '\n') {
+			} else if isSymbol(char) && (unicode.IsLetter(rune(data[index+1])) || unicode.IsNumber(rune(data[index+1])) || data[index+1] == '(' || data[index+1] == ')' || data[index+1] == ';' || data[index+1] == ' ' || data[index+1] == '\t' || data[index+1] == '\n') {
 				if symbol.Len() != 0 {
 					pos := index - len(symbol.String())
 					end := index
@@ -170,14 +174,16 @@ func LexSourceFile(sourceFile string) []Token {
 						tokens = append(tokens, Operator{Pos: pos, End: end, Kind: "-"})
 					case "=":
 						tokens = append(tokens, Operator{Pos: pos, End: end, Kind: "="})
+					case ";":
+						tokens = append(tokens, Semicolon{Pos: pos, End: end})
 					}
 					symbol.Reset()
 				}
 			}
 		}
 	}
-	fmt.Println("The tokens are: ")
-	pp.Println(tokens)
+	// fmt.Println("The tokens are: ")
+	// pp.Println(tokens)
 	return tokens
 }
 
@@ -191,5 +197,5 @@ func charIn(char byte, chars ...byte) bool {
 }
 
 func isSymbol(char byte) bool {
-	return charIn(char, '{', '}', '(', ')', ';', '+', '*', '/', '-', '=', '.')
+	return charIn(char, '{', '}', '(', ')', ';', '+', '*', '/', '-', '=', '.', ';')
 }

main.fig

@@ -1,6 +1,8 @@
 func Test {
-    x = 100.50 + y * (3 + 5)
+    y = 1 + 2;
+    x = 1 + y * (3 + 5);
+    z = x * y;
 }
 
-func Test2 {
+func main {
 }

main.go

@@ -6,12 +6,16 @@ import (
 	_gen "github.com/ProgrammingMuffin/Fig/gen"
 	_lex "github.com/ProgrammingMuffin/Fig/lex"
 	_parse "github.com/ProgrammingMuffin/Fig/parse"
+	_semantic "github.com/ProgrammingMuffin/Fig/semantic"
 	"github.com/k0kubun/pp/v3"
 )
 
 func main() {
 	tokens := _lex.LexSourceFile("main.fig")
 	ast := _parse.ParseTokens(tokens)
+	for _, astVal := range ast {
+		_semantic.VisitNode(astVal)
+	}
 	pp.Println(ast)
 	for _, astVal := range ast {
 		_gen.VisitTree(astVal)

parse/parse.go

@@ -89,7 +89,6 @@ func ParseBlock() (*_ast.Block, error) {
 		block.RBrace = x.Pos
 		return &block, nil
 	}
-	SafeInc()
 	switch x := Tokens[Scan].(type) {
 	case _lex.RBrace:
 		block.RBrace = x.Pos
@@ -114,6 +113,10 @@ func ParseStatements() ([]_ast.Stmt, error) {
 		if stmt != nil {
 			stmts = append(stmts, stmt)
 		} else {
+			if err != nil {
+				stmt, err = ParseStatement()
+				stmts = append(stmts, stmt)
+			}
 			goto OUTSIDE
 		}
 	}
@@ -172,7 +175,11 @@ func ParseAssignStatement() (_ast.Stmt, error) {
 	}
 	switch Tokens[Scan].(type) {
 	case _lex.Ident:
-		return ParseStatement()
+		nextStmt, err := ParseStatement()
+		if err != nil {
+			return nil, err
+		}
+		stmt.Rhs = nextStmt
 	case _lex.LParen:
 		term, err := ParseTerm()
 		if err != nil {
@@ -183,13 +190,17 @@ func ParseAssignStatement() (_ast.Stmt, error) {
 			return nil, err
 		}
 		stmt.Rhs = term
-		return &stmt, nil
 	case _lex.Number:
 		nextStmt, err := ParseStatement()
 		if err != nil {
 			return nil, err
 		}
 		stmt.Rhs = nextStmt
+	}
+	SafeInc()
+	switch Tokens[Scan].(type) {
+	case _lex.Semicolon:
+		SafeInc()
 		return &stmt, nil
 	}
 	fmt.Println("error parsing assignment statement")
@@ -220,6 +231,8 @@ func ParseBinaryExpr(prev *_ast.BinaryExpr, prevTerm _ast.ExprStmt, prec int) (*
 	binaryExpr := _ast.BinaryExpr{}
 	if Scan+2 < len(Tokens) {
 		switch x := Tokens[Scan+1].(type) {
+		case _lex.Semicolon:
+			return nil, nil
 		case _lex.RBrace:
 			return nil, nil
 		case _lex.RParen:
@@ -236,6 +249,7 @@ func ParseBinaryExpr(prev *_ast.BinaryExpr, prevTerm _ast.ExprStmt, prec int) (*
 			case _lex.Number:
 				binaryExpr.Lhs = &_ast.BasicLit{
 					Value: x.Value,
+					Kind:  x.Kind,
 				}
 			}
 			if prev != nil {
@@ -265,7 +279,7 @@ func ParseBinaryExpr(prev *_ast.BinaryExpr, prevTerm _ast.ExprStmt, prec int) (*
 				case _lex.Ident:
 					binaryExpr.Rhs = &_ast.Ident{Value: x.Value, Pos: x.Pos, End: x.End}
 				case _lex.Number:
-					binaryExpr.Rhs = &_ast.BasicLit{Value: x.Value}
+					binaryExpr.Rhs = &_ast.BasicLit{Value: x.Value, Kind: x.Kind}
 				}
 			}
 			return &binaryExpr, nil

semantic/semantic.go

@@ -0,0 +1,78 @@
+package _semantic
+
+import (
+	"fmt"
+	"os"
+
+	_ast "github.com/ProgrammingMuffin/Fig/ast"
+	"github.com/k0kubun/pp"
+)
+
+var Symtab map[string]string = make(map[string]string) //matches symbol with type names
+
+func VisitNode(node _ast.Node) {
+	switch x := node.(type) {
+	case *_ast.FuncDecl:
+		VisitBlock(x.Block)
+	}
+}
+
+func VisitBlock(node _ast.Block) {
+	for _, stmt := range node.Stmts {
+		VisitStatement(stmt)
+	}
+}
+
+func VisitStatement(node _ast.Stmt) string {
+	switch x := node.(type) {
+	case *_ast.AssignStmt:
+		x.Lhs.Type = VisitStatement(x.Rhs)
+		Symtab[x.Lhs.Value] = x.Lhs.Type
+		return x.Lhs.Type
+	case *_ast.Term:
+		return VisitStatement(x.ExprStmt)
+	case *_ast.BinaryExpr:
+		return VisitBinaryExpression(*x)
+	}
+	fmt.Println("type mismatch in statement")
+	return ""
+}
+
+func VisitBinaryExpression(node _ast.BinaryExpr) string {
+	fmt.Println("symtab is : ")
+	pp.Println(Symtab)
+	type1 := ""
+	type2 := ""
+	switch x := node.Lhs.(type) {
+	case *_ast.BasicLit:
+		type1 = x.Kind
+	case *_ast.BinaryExpr:
+		type1 = VisitBinaryExpression(*x)
+	case *_ast.Term:
+		type1 = VisitStatement(x.ExprStmt)
+	case *_ast.Ident:
+		if val, ok := Symtab[x.Value]; ok {
+			type1 = val
+			x.Type = val
+		}
+	}
+	switch x := node.Rhs.(type) {
+	case *_ast.BasicLit:
+		type2 = x.Kind
+	case *_ast.BinaryExpr:
+		type2 = VisitBinaryExpression(*x)
+	case *_ast.Term:
+		type2 = VisitStatement(x.ExprStmt)
+	case *_ast.Ident:
+		if val, ok := Symtab[x.Value]; ok {
+			type2 = val
+			x.Type = val
+		}
+	}
+	if type1 == type2 && type1 != "" {
+		return type1
+	}
+	fmt.Println("Type mismatch in binary expression")
+	os.Exit(0)
+	return type1
+}