Worktree add slice type

lang/assembly/tac/triple.go

@@ -23,6 +23,20 @@ type Triple struct {
 	currproc    *Proc
 }
 
+var _ ast.CodeGenerator = (*Triple)(nil)
+
+func (gen *Triple) VisitAppendExpression(node *ast.AppendExpression) error {
+	panic("unimplemented")
+}
+
+func (gen *Triple) VisitListExpression(node *ast.ListExpression) error {
+	panic("unimplemented")
+}
+
+func (gen *Triple) VisitListCountExpression(node *ast.ListCountExpression) error {
+	panic("unimplemented")
+}
+
 var _ AsmOp = (*Triple)(nil)
 
 func (gen *Triple) Gen(g AssemblyOpGenerator) error {
@@ -62,8 +76,6 @@ func (gen *Triple) Display() {
 	}
 }
 
-var _ ast.CodeGenerator = (*Triple)(nil)
-
 func NewTripleGenerator() *Triple {
 	return &Triple{
 		GlobalOps:   []AsmOp{},
@@ -117,6 +129,10 @@ func (gen *Triple) VisitArrayType(node *ast.ArrayType) error {
 	return fmt.Errorf("unimplemented")
 }
 
+func (gen *Triple) VisitSliceType(node *ast.SliceType) error {
+	return fmt.Errorf("unimplemented")
+}
+
 func (gen *Triple) VisitAssignmentExpression(node *ast.AssignmentExpression) error {
 	err := node.Value.Accept(gen)
 	if err != nil {
@@ -516,6 +532,10 @@ func (gen *Triple) ZeroOfArrayType(node *ast.ArrayType) error {
 	return fmt.Errorf("unimplemented")
 }
 
+func (gen *Triple) ZeroOfSliceType(node *ast.SliceType) error {
+	return fmt.Errorf("unimplemented")
+}
+
 func (gen *Triple) ZeroOfBoolType(node *ast.BoolType) error {
 	gen.setLastValue(BoolVal{value: "false"})
 

lang/ast/append_expression.go

@@ -0,0 +1,23 @@
+package ast
+
+import "swahili/lang/lexer"
+
+type AppendExpression struct {
+	Appendable Expression
+	Value      Expression
+	Tokens     []lexer.Token
+}
+
+var _ Expression = (*AppendExpression)(nil)
+
+func (a *AppendExpression) Accept(g CodeGenerator) error {
+	return g.VisitAppendExpression(a)
+}
+
+func (a *AppendExpression) TokenStream() []lexer.Token {
+	return a.Tokens
+}
+
+func (a *AppendExpression) VisitedSwaType() Type {
+	panic("unimplemented")
+}

lang/ast/ast.go

@@ -81,6 +81,9 @@ type ExpressionsCodeGenerator interface {
 	VisitSymbolValueExpression(node *SymbolValueExpression) error
 	VisitSymbolAdressExpression(node *SymbolAdressExpression) error
 	VisitBooleanExpression(node *BooleanExpression) error
+	VisitListExpression(node *ListExpression) error
+	VisitListCountExpression(node *ListCountExpression) error
+	VisitAppendExpression(node *AppendExpression) error
 }
 
 type TypeVisitor interface {
@@ -96,6 +99,7 @@ type TypeVisitor interface {
 	VisitVoidType(node *VoidType) error
 	VisitBoolType(node *BoolType) error
 	VisitByteType(node *ByteType) error
+	VisitSliceType(node *SliceType) error
 }
 
 type ZeroValueVisitor interface {
@@ -111,4 +115,5 @@ type ZeroValueVisitor interface {
 	ZeroOfVoidType(node *VoidType) error
 	ZeroOfBoolType(node *BoolType) error
 	ZeroOfByteType(node *ByteType) error
+	ZeroOfSliceType(node *SliceType) error
 }

lang/ast/list_expression.go

@@ -0,0 +1,43 @@
+package ast
+
+import "swahili/lang/lexer"
+
+type ListExpression struct {
+	DataType Type
+	Length   Expression
+	Capacity Expression
+	Tokens   []lexer.Token
+}
+
+var _ Expression = (*ListExpression)(nil)
+
+func (m *ListExpression) Accept(g CodeGenerator) error {
+	return g.VisitListExpression(m)
+}
+
+func (m *ListExpression) TokenStream() []lexer.Token {
+	return m.Tokens
+}
+
+func (m *ListExpression) VisitedSwaType() Type {
+	return m.DataType
+}
+
+type ListCountExpression struct {
+	Expr   Expression
+	Tokens []lexer.Token
+}
+
+var _ Expression = (*ListCountExpression)(nil)
+
+func (l *ListCountExpression) Accept(g CodeGenerator) error {
+	return g.VisitListCountExpression(l)
+}
+
+func (l *ListCountExpression) TokenStream() []lexer.Token {
+	return l.Tokens
+}
+
+func (l *ListCountExpression) VisitedSwaType() Type {
+	panic("unimplemented")
+}

lang/ast/types.go

@@ -37,6 +37,8 @@ func (dt DataType) String() string {
 		return "Bool"
 	case DataTypeByte:
 		return "Byte"
+	case DataTypeSlice:
+		return "Slice"
 	default:
 		fmt.Printf("Unmatched data type %d", dt)
 		os.Exit(1)
@@ -60,6 +62,7 @@ const (
 	DataTypeError
 	DataTypeTuple
 	DataTypeBool
+	DataTypeSlice
 )
 
 type SymbolType struct {
@@ -139,6 +142,45 @@ func (typ ArrayType) Accept(g CodeGenerator) error {
 	return g.VisitArrayType(&typ)
 }
 
+type SliceType struct {
+	Underlying Type
+}
+
+func (typ SliceType) Equals(other Type) bool {
+	if typ.Value() != other.Value() {
+		return false
+	}
+
+	oth, ok := other.(SliceType)
+	if !ok {
+		othPointer, ok := other.(*SliceType)
+		if !ok {
+			return false
+		}
+		oth = *othPointer
+	}
+
+	return typ.Underlying.Equals(oth.Underlying)
+}
+
+func (t SliceType) String() string {
+	return fmt.Sprintf("%s(%s)", t.Value(), t.Underlying.Value().String())
+}
+
+func (typ SliceType) AcceptZero(g CodeGenerator) error {
+	return g.ZeroOfSliceType(&typ)
+}
+
+var _ Type = (*SliceType)(nil)
+
+func (SliceType) Value() DataType {
+	return DataTypeSlice
+}
+
+func (typ SliceType) Accept(g CodeGenerator) error {
+	return g.VisitSliceType(&typ)
+}
+
 type ByteType struct{}
 
 var _ Type = (*ByteType)(nil)

lang/compiler/astformat/json.go

@@ -8,12 +8,12 @@ type Json struct {
 	Element map[string]any
 }
 
-// VisitByteType implements [ast.CodeGenerator].
+var _ ast.CodeGenerator = (*Json)(nil)
+
 func (j *Json) VisitByteType(node *ast.ByteType) error {
 	panic("unimplemented")
 }
 
-// ZeroOfByteType implements [ast.CodeGenerator].
 func (j *Json) ZeroOfByteType(node *ast.ByteType) error {
 	panic("unimplemented")
 }
@@ -31,7 +31,6 @@ func (j *Json) VisitBoolType(node *ast.BoolType) error {
 	return nil
 }
 
-// VisitBooleanExpression implements [ast.CodeGenerator].
 func (j *Json) VisitBooleanExpression(node *ast.BooleanExpression) error {
 	res := make(map[string]any)
 	res["BooleanExpression"] = node.Value
@@ -41,12 +40,24 @@ func (j *Json) VisitBooleanExpression(node *ast.BooleanExpression) error {
 	return nil
 }
 
+func (j *Json) VisitListExpression(node *ast.ListExpression) error {
+	m := make(map[string]any)
+
+	_ = node.DataType.Accept(j)
+	m["Type"] = j.getLastResult()
+
+	res := make(map[string]any)
+	res["ListExpression"] = m
+
+	j.setLastResult(res)
+
+	return nil
+}
+
 func NewJsonFormatter() *Json {
 	return &Json{Element: map[string]any{}}
 }
 
-var _ ast.CodeGenerator = (*Json)(nil)
-
 func (j *Json) VisitArrayAccessExpression(node *ast.ArrayAccessExpression) error {
 	m := make(map[string]any)
 
@@ -109,6 +120,27 @@ func (j *Json) VisitArrayType(node *ast.ArrayType) error {
 	return nil
 }
 
+func (j *Json) VisitSliceType(node *ast.SliceType) error {
+	res := make(map[string]any)
+	_ = node.Underlying.Accept(j)
+	res["SliceType"] = j.getLastResult()
+
+	j.setLastResult(res)
+
+	return nil
+}
+
+func (j *Json) VisitListCountExpression(node *ast.ListCountExpression) error {
+	_ = node.Expr.Accept(j)
+
+	m := make(map[string]any)
+	m["ListCountExpression"] = j.getLastResult()
+
+	j.setLastResult(m)
+
+	return nil
+}
+
 func (j *Json) VisitAssignmentExpression(node *ast.AssignmentExpression) error {
 	m := make(map[string]any)
 	m["Operator"] = node.Operator.Value
@@ -163,6 +195,22 @@ func (j *Json) VisitTupleAssignmentExpression(node *ast.TupleAssignmentExpressio
 	return nil
 }
 
+func (j *Json) VisitAppendExpression(node *ast.AppendExpression) error {
+	m := make(map[string]any)
+	_ = node.Appendable.Accept(j)
+	m["Appendable"] = j.getLastResult()
+
+	_ = node.Value.Accept(j)
+	m["Right"] = j.getLastResult()
+
+	res := make(map[string]any)
+	res["AppendExpression"] = m
+
+	j.setLastResult(res)
+
+	return nil
+}
+
 func (j *Json) VisitBinaryExpression(node *ast.BinaryExpression) error {
 	m := make(map[string]any)
 	_ = node.Left.Accept(j)
@@ -622,6 +670,13 @@ func (j *Json) ZeroOfVoidType(node *ast.VoidType) error {
 	panic("unimplemented")
 }
 
+func (j *Json) ZeroOfSliceType(node *ast.SliceType) error {
+	res := make(map[string]any)
+	res["ZeroOfSliceType"] = nil
+	j.setLastResult(res)
+	return nil
+}
+
 func (g *Json) setLastResult(res map[string]any) {
 	g.Element = res
 }