refactor: move aladino type into lang package

engine/exec_test.go

@@ -322,7 +322,7 @@ func TestExecConfigurationFile(t *testing.T) {
 			builtIns := &aladino.BuiltIns{
 				Actions: map[string]*aladino.BuiltInAction{
 					builtInName: {
-						Type: aladino.BuildFunctionType([]aladino.Type{aladino.BuildStringType()}, aladino.BuildArrayOfType(aladino.BuildStringType())),
+						Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, lang.BuildArrayOfType(lang.BuildStringType())),
 						Code: func(e aladino.Env, args []lang.Value) error {
 							return nil
 						},

lang/aladino/builder.go

@@ -4,6 +4,8 @@
 
 package aladino
 
+import "github.com/reviewpad/reviewpad/v4/lang"
+
 func BuildFilter(param string, condition Expr) (Expr, error) {
 	organizationAST := BuildFunctionCall(
 		BuildVariable("organization"),
@@ -15,7 +17,7 @@ func BuildFilter(param string, condition Expr) (Expr, error) {
 		[]Expr{
 			organizationAST,
 			BuildLambda(
-				[]Expr{BuildTypedExpr(BuildVariable(param), BuildStringType())},
+				[]Expr{BuildTypedExpr(BuildVariable(param), lang.BuildStringType())},
 				condition,
 			),
 		},

lang/aladino/builder_test.go

@@ -7,6 +7,7 @@ package aladino_test
 import (
 	"testing"
 
+	"github.com/reviewpad/reviewpad/v4/lang"
 	"github.com/reviewpad/reviewpad/v4/lang/aladino"
 	"github.com/stretchr/testify/assert"
 )
@@ -26,7 +27,7 @@ func TestBuildFilter(t *testing.T) {
 				[]aladino.Expr{
 					aladino.BuildTypedExpr(
 						aladino.BuildVariable(param),
-						aladino.BuildStringType()),
+						lang.BuildStringType()),
 				},
 				condition,
 			),

lang/aladino/builtins.go

@@ -16,13 +16,13 @@ type BuiltIns struct {
 }
 
 type BuiltInFunction struct {
-	Type           Type
+	Type           lang.Type
 	Code           func(e Env, args []lang.Value) (lang.Value, error)
 	SupportedKinds []entities.TargetEntityKind
 }
 
 type BuiltInAction struct {
-	Type              Type
+	Type              lang.Type
 	Code              func(e Env, args []lang.Value) error
 	Disabled          bool
 	SupportedKinds    []entities.TargetEntityKind

lang/aladino/env.go

@@ -28,7 +28,7 @@ const (
 	SEVERITY_INFO    Severity = 4
 )
 
-type TypeEnv map[string]Type
+type TypeEnv map[string]lang.Type
 
 type RegisterMap map[string]lang.Value
 
@@ -150,7 +150,7 @@ func (e *BaseEnv) GetCheckRunID() *int64 {
 }
 
 func NewTypeEnv(e Env) TypeEnv {
-	builtInsType := make(map[string]Type)
+	builtInsType := make(map[string]lang.Type)
 	for builtInName, builtInFunction := range e.GetBuiltIns().Functions {
 		builtInsType[builtInName] = builtInFunction.Type
 	}

lang/aladino/env_test.go

@@ -21,11 +21,11 @@ import (
 func TestNewTypeEnv_WithDefaultEnv(t *testing.T) {
 	mockedEnv := aladino.MockDefaultEnv(t, nil, nil, aladino.MockBuiltIns(), nil)
 
-	wantTypeEnv := aladino.TypeEnv(map[string]aladino.Type{
-		"emptyFunction": aladino.BuildFunctionType([]aladino.Type{}, nil),
-		"emptyAction":   aladino.BuildFunctionType([]aladino.Type{}, nil),
-		"zeroConst":     aladino.BuildFunctionType([]aladino.Type{}, aladino.BuildIntType()),
-		"returnStr":     aladino.BuildFunctionType([]aladino.Type{aladino.BuildStringType()}, aladino.BuildStringType()),
+	wantTypeEnv := aladino.TypeEnv(map[string]lang.Type{
+		"emptyFunction": lang.BuildFunctionType([]lang.Type{}, nil),
+		"emptyAction":   lang.BuildFunctionType([]lang.Type{}, nil),
+		"zeroConst":     lang.BuildFunctionType([]lang.Type{}, lang.BuildIntType()),
+		"returnStr":     lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, lang.BuildStringType()),
 	})
 
 	gotTypeEnv := aladino.NewTypeEnv(mockedEnv)

lang/aladino/eval_test.go

@@ -302,7 +302,7 @@ func TestEval_OnLambda(t *testing.T) {
 	if err != nil {
 		assert.FailNow(t, "parse failed", err)
 	}
-	lambdaParam := aladino.BuildTypedExpr(variable, aladino.BuildStringType())
+	lambdaParam := aladino.BuildTypedExpr(variable, lang.BuildStringType())
 	lambdaBody, err := aladino.Parse("1 == 1")
 	if err != nil {
 		assert.FailNow(t, "parse failed", err)
@@ -327,7 +327,7 @@ func TestEval_OnTypedExpr(t *testing.T) {
 		assert.FailNow(t, "parse failed", err)
 	}
 
-	typedExpr := aladino.BuildTypedExpr(expr, aladino.BuildBoolType())
+	typedExpr := aladino.BuildTypedExpr(expr, lang.BuildBoolType())
 
 	gotVal, err := typedExpr.Eval(mockedEnv)
 

lang/aladino/exec_internal_test.go

@@ -96,7 +96,7 @@ func TestExec_WhenActionIsEnabled(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			builtInName: {
-				Type: BuildFunctionType([]Type{BuildStringType()}, BuildArrayOfType(BuildStringType())),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, lang.BuildArrayOfType(lang.BuildStringType())),
 				Code: func(e Env, args []lang.Value) error {
 					isBuiltInCalled = true
 					return nil
@@ -126,7 +126,7 @@ func TestExec_WhenActionIsDisabled(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			builtInName: {
-				Type: BuildFunctionType([]Type{BuildStringType()}, BuildArrayOfType(BuildStringType())),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, lang.BuildArrayOfType(lang.BuildStringType())),
 				Code: func(e Env, args []lang.Value) error {
 					isBuiltInCalled = true
 					return nil

lang/aladino/expr.go

@@ -18,7 +18,7 @@ import (
 
 type Expr interface {
 	Kind() string
-	typeinfer(env TypeEnv) (Type, error)
+	typeinfer(env TypeEnv) (lang.Type, error)
 	Eval(Env) (lang.Value, error)
 	equals(Expr) bool
 }
@@ -415,10 +415,10 @@ func EqualList(left []Expr, right []Expr) bool {
 
 type TypedExpr struct {
 	expr   Expr
-	typeOf Type
+	typeOf lang.Type
 }
 
-func BuildTypedExpr(expr Expr, typeOf Type) *TypedExpr {
+func BuildTypedExpr(expr Expr, typeOf lang.Type) *TypedExpr {
 	return &TypedExpr{expr, typeOf}
 }
 
@@ -434,7 +434,7 @@ func (te *TypedExpr) equals(other Expr) bool {
 	otherTypedExpr := other.(*TypedExpr)
 
 	return te.expr.equals(otherTypedExpr.expr) &&
-		te.typeOf.equals(otherTypedExpr.typeOf)
+		te.typeOf.Equals(otherTypedExpr.typeOf)
 }
 
 type Lambda struct {

lang/aladino/expr_internal_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/reviewpad/reviewpad/v4/lang"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -628,47 +629,47 @@ func TestArrayEquals_WhenEqual(t *testing.T) {
 }
 
 func TestBuildTypedExpr(t *testing.T) {
-	wantVal := &TypedExpr{&IntConst{1}, &IntType{}}
-	gotVal := BuildTypedExpr(BuildIntConst(1), BuildIntType())
+	wantVal := &TypedExpr{&IntConst{1}, &lang.IntType{}}
+	gotVal := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType())
 
 	assert.Equal(t, wantVal, gotVal)
 }
 
 func TestTypedExprKind(t *testing.T) {
 	wantVal := TYPED_EXPR
-	gotVal := BuildTypedExpr(BuildIntConst(1), BuildIntType()).Kind()
+	gotVal := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType()).Kind()
 
 	assert.Equal(t, wantVal, gotVal)
 }
 
 func TestTypedExprEquals_WhenDiffKinds(t *testing.T) {
-	typedExpr := BuildTypedExpr(BuildIntConst(1), BuildIntType())
+	typedExpr := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType())
 	otherVal := BuildIntConst(0)
 
 	assert.False(t, typedExpr.equals(otherVal))
 }
 
 func TestTypedExprEquals_WhenDiffValues(t *testing.T) {
-	typedExpr := BuildTypedExpr(BuildIntConst(1), BuildIntType())
-	otherVal := BuildTypedExpr(BuildIntConst(1), BuildStringType())
+	typedExpr := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType())
+	otherVal := BuildTypedExpr(BuildIntConst(1), lang.BuildStringType())
 
 	assert.False(t, typedExpr.equals(otherVal))
 }
 
 func TestTypedExprEquals_WhenEqual(t *testing.T) {
-	typedExpr := BuildTypedExpr(BuildIntConst(1), BuildIntType())
-	otherVal := BuildTypedExpr(BuildIntConst(1), BuildIntType())
+	typedExpr := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType())
+	otherVal := BuildTypedExpr(BuildIntConst(1), lang.BuildIntType())
 
 	assert.True(t, typedExpr.equals(otherVal))
 }
 
 func TestBuildLambda(t *testing.T) {
 	wantVal := &Lambda{
-		[]Expr{&TypedExpr{&Variable{"foo"}, &StringType{}}},
+		[]Expr{&TypedExpr{&Variable{"foo"}, &lang.StringType{}}},
 		&BinaryOp{&IntConst{1}, &EqOp{}, &IntConst{1}},
 	}
 	gotVal := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	)
 
@@ -678,7 +679,7 @@ func TestBuildLambda(t *testing.T) {
 func TestLambdaKind(t *testing.T) {
 	wantVal := LAMBDA_CONST
 	gotVal := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	).Kind()
 
@@ -687,7 +688,7 @@ func TestLambdaKind(t *testing.T) {
 
 func TestLambdaEquals_WhenDiffKinds(t *testing.T) {
 	lambda := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	)
 	otherVal := BuildIntConst(0)
@@ -696,11 +697,11 @@ func TestLambdaEquals_WhenDiffKinds(t *testing.T) {
 
 func TestLambdaEquals_WhenDiffValues(t *testing.T) {
 	lambda := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	)
 	otherVal := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("bar"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("bar"), lang.BuildStringType())},
 		BuildBinaryOp(BuildVariable("var#1"), eqOperator(), BuildVariable("var#2")),
 	)
 
@@ -709,11 +710,11 @@ func TestLambdaEquals_WhenDiffValues(t *testing.T) {
 
 func TestLambdaEquals_WhenEqual(t *testing.T) {
 	lambda := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	)
 	otherVal := BuildLambda(
-		[]Expr{BuildTypedExpr(BuildVariable("foo"), BuildStringType())},
+		[]Expr{BuildTypedExpr(BuildVariable("foo"), lang.BuildStringType())},
 		BuildBinaryOp(BuildIntConst(1), eqOperator(), BuildIntConst(1)),
 	)
 

lang/aladino/interpreter.go

@@ -43,7 +43,7 @@ func evalGroup(env Env, expr Expr) (lang.Value, error) {
 		return nil, err
 	}
 
-	if exprType.Kind() != ARRAY_TYPE && exprType.Kind() != ARRAY_OF_TYPE {
+	if exprType.Kind() != lang.ARRAY_TYPE && exprType.Kind() != lang.ARRAY_OF_TYPE {
 		return nil, fmt.Errorf("expression is not a valid group")
 	}
 
@@ -98,7 +98,7 @@ func EvalExpr(env Env, kind, expr string) (bool, error) {
 		return false, err
 	}
 
-	if exprType.Kind() != BOOL_TYPE {
+	if exprType.Kind() != lang.BOOL_TYPE {
 		return false, fmt.Errorf("expression %v is not a condition", expr)
 	}
 

lang/aladino/interpreter_internal_test.go

@@ -54,7 +54,7 @@ func TestBuildGroupAST_WhenGroupTypeFilterIsSet(t *testing.T) {
 				[]Expr{},
 			),
 			BuildLambda(
-				[]Expr{BuildTypedExpr(BuildVariable("dev"), BuildStringType())},
+				[]Expr{BuildTypedExpr(BuildVariable("dev"), lang.BuildStringType())},
 				BuildFunctionCall(
 					BuildVariable("hasFileExtensions"),
 					[]Expr{
@@ -117,7 +117,7 @@ func TestEvalGroup(t *testing.T) {
 	builtIns := &BuiltIns{
 		Functions: map[string]*BuiltInFunction{
 			"group": {
-				Type: BuildFunctionType([]Type{BuildStringType()}, BuildArrayOfType(BuildStringType())),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, lang.BuildArrayOfType(lang.BuildStringType())),
 				Code: func(e Env, args []lang.Value) (lang.Value, error) {
 					return lang.BuildArrayValue([]lang.Value{lang.BuildStringValue(devName)}), nil
 				},
@@ -344,7 +344,7 @@ func TestExecProgram(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			"addLabel": {
-				Type: BuildFunctionType([]Type{BuildStringType()}, nil),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, nil),
 				Code: func(e Env, args []lang.Value) error {
 					return nil
 				},
@@ -404,7 +404,7 @@ func TestExecAsyncProgram(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			"robin": {
-				Type: BuildFunctionType([]Type{BuildStringType()}, nil),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, nil),
 				Code: func(e Env, args []lang.Value) error {
 					return fmt.Errorf("robin error")
 				},
@@ -479,7 +479,7 @@ func TestExecStatement_WhenTypeCheckExecFails(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			"addLabel": {
-				Type: BuildFunctionType([]Type{BuildStringType()}, nil),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, nil),
 				Code: func(e Env, args []lang.Value) error {
 					return nil
 				},
@@ -506,7 +506,7 @@ func TestExecStatement_WhenActionExecFails(t *testing.T) {
 	builtIns := &BuiltIns{
 		Functions: map[string]*BuiltInFunction{
 			"author": {
-				Type: BuildFunctionType([]Type{}, BuildArrayOfType(BuildStringType())),
+				Type: lang.BuildFunctionType([]lang.Type{}, lang.BuildArrayOfType(lang.BuildStringType())),
 				Code: func(e Env, args []lang.Value) (lang.Value, error) {
 					return lang.BuildArrayValue([]lang.Value{lang.BuildStringValue(devName)}), nil
 				},
@@ -532,7 +532,7 @@ func TestExecStatement(t *testing.T) {
 	builtIns := &BuiltIns{
 		Actions: map[string]*BuiltInAction{
 			"addLabel": {
-				Type: BuildFunctionType([]Type{BuildStringType()}, nil),
+				Type: lang.BuildFunctionType([]lang.Type{lang.BuildStringType()}, nil),
 				Code: func(e Env, args []lang.Value) error {
 					return nil
 				},