exclude .ll, .exe, and .out from git, added guard in match

.gitignore

@@ -1,3 +1,6 @@
 dist/
 example/ffi.go
-example/ffi_go.flint
+example/ffi_go.flint
+*.exe
+*.out
+*.ll

example/match.flint

@@ -4,6 +4,7 @@ pub fn print(string: String) Nil
 fn test(i: Int) String {
     match i {
         | 1 -> "Hello"
+        | x if x == 2 -> "Bye"
         | _ -> match i == 10 {
             | True -> "true"
             | False -> "false"
@@ -12,5 +13,5 @@ fn test(i: Int) String {
 }
 
 pub fn main() Nil {
-    print(test(3))
+    print(test(3) <> "\n")
 }

internal/codegen/codegen.go

@@ -266,27 +266,27 @@ func (cg *CodeGen) emitMatchCond(b *ir.Block, scr value.Value, pat parser.Expr,
 		if p.Pos.Kind == lexer.Underscore {
 			baseCond = constant.True
 		} else {
-			// alloc := b.NewAlloca(scr.Type())
-			// b.NewStore(scr, alloc)
-			// cg.locals[p.Name] = alloc
+			alloc := b.NewAlloca(scr.Type())
+			b.NewStore(scr, alloc)
+			cg.locals[p.Name] = alloc
 			baseCond = constant.True
 		}
 	default:
 		panic("unsupported match pattern: " + pat.NodeType())
 	}
 	// disable guards for now
 
-	// if guard != nil {
-	// 	guardVal := cg.emitExpr(b, guard, false)
-	// 	if _, ok := guardVal.Type().(*types.IntType); ok {
-	// 		if guardVal.Type() != types.I1 {
-	// 			guardVal = b.NewTrunc(guardVal, types.I1)
-	// 		}
-	// 	} else {
-	// 		panic("guard expression is not a boolean")
-	// 	}
-	// 	baseCond = b.NewAnd(baseCond, guardVal)
-	// }
+	if guard != nil {
+		guardVal := cg.emitExpr(b, guard, false)
+		if _, ok := guardVal.Type().(*types.IntType); ok {
+			if guardVal.Type() != types.I1 {
+				guardVal = b.NewTrunc(guardVal, types.I1)
+			}
+		} else {
+			panic("guard expression is not a boolean")
+		}
+		baseCond = b.NewAnd(baseCond, guardVal)
+	}
 	return baseCond
 }
 

internal/codegen/expr.go

@@ -2,7 +2,6 @@ package codegen
 
 import (
 	"flint/internal/parser"
-	"reflect"
 
 	"github.com/llir/llvm/ir"
 	"github.com/llir/llvm/ir/constant"
@@ -32,10 +31,7 @@ func (cg *CodeGen) emitExpr(b *ir.Block, e parser.Expr, isTail bool) value.Value
 		if ptr == nil {
 			panic("undefined variable: " + v.Name)
 		}
-		if reflect.TypeOf(ptr.Type()).String() == "*types.PointerType" {
-			return b.NewLoad(ptr.Type().(*types.PointerType).ElemType, ptr)
-		}
-		return b.NewLoad(ptr.Type(), ptr)
+		return b.NewLoad(ptr.Type().(*types.PointerType).ElemType, ptr)
 	case *parser.InfixExpr:
 		return cg.emitInfix(b, v)
 	case *parser.IfExpr:

internal/codegen/infix.go

@@ -52,7 +52,7 @@ func (cg *CodeGen) emitInfix(b *ir.Block, e *parser.InfixExpr) value.Value {
 	case lexer.GreaterEqualDot:
 		return b.NewFCmp(enum.FPredOGE, l, r)
 	case lexer.LtGt:
-		return nil // Add string
+		return nil
 	case lexer.AmperAmper:
 		return b.NewAnd(l, r)
 	case lexer.VbarVbar:

internal/codegen/match.go

@@ -3,7 +3,6 @@ package codegen
 import (
 	"flint/internal/parser"
 	"fmt"
-	"reflect"
 
 	"github.com/llir/llvm/ir"
 	"github.com/llir/llvm/ir/constant"
@@ -26,15 +25,15 @@ func (cg *CodeGen) emitMatch(b *ir.Block, m *parser.MatchExpr, isTail bool) valu
 
 	checkList = append(checkList, b)
 
-	// wildCardName := fmt.Sprintf("match.%d.wild", matchId)
+	wildCardName := fmt.Sprintf("match.%d.wild", matchId)
 
 	for caseId, arm := range m.Arms {
 		var name string
-		// if arm.IsWildCardArm() {
-		// name = wildCardName
-		// } else {
-		name = fmt.Sprintf("match.%d.arm.%d", matchId, caseId)
-		// }
+		if arm.IsWildCardArm() {
+			name = wildCardName
+		} else {
+			name = fmt.Sprintf("match.%d.arm.%d", matchId, caseId)
+		}
 
 		armBlock := parent.NewBlock(name)
 		if caseId != 0 && !arm.IsWildCardArm() {
@@ -110,33 +109,19 @@ func (cg *CodeGen) emitMatch(b *ir.Block, m *parser.MatchExpr, isTail bool) valu
 		return nil
 	}
 
-	for _, v := range checkList {
-		if v != nil {
-			opLen := len(b.Term.Operands())
-			for i := range opLen {
-				op := *v.Term.Operands()[i]
-				if reflect.TypeOf(op) == reflect.TypeOf(mergeBlock) {
-					if op.(*ir.Block) == mergeBlock {
-						incomings = append(incomings, ir.NewIncoming(
-							constant.NewUndef(phiType),
-							v,
-						))
-					}
-				}
-			}
-		}
+	if referencesBlock(b, mergeBlock) {
+		incomings = append(incomings, ir.NewIncoming(
+			constant.NewUndef(phiType),
+			b,
+		))
 	}
 
-	opLen := len(b.Term.Operands())
-	for i := range opLen {
-		op := *b.Term.Operands()[i]
-		if reflect.TypeOf(op) == reflect.TypeOf(mergeBlock) {
-			if op.(*ir.Block) == mergeBlock {
-				incomings = append(incomings, ir.NewIncoming(
-					constant.NewUndef(phiType),
-					b,
-				))
-			}
+	for _, v := range checkList {
+		if referencesBlock(v, mergeBlock) {
+			incomings = append(incomings, ir.NewIncoming(
+				constant.NewUndef(phiType),
+				v,
+			))
 		}
 	}
 

internal/codegen/reflect.go

@@ -29,3 +29,17 @@ func parentBlockOfValue(v value.Value) *ir.Block {
 	}
 	return parent
 }
+
+func referencesBlock(b *ir.Block, blockToFind *ir.Block) bool {
+	if b != nil && b.Term != nil {
+		opLen := len(b.Term.Operands())
+		for i := range opLen {
+			op := *b.Term.Operands()[i]
+			v, ok := op.(*ir.Block)
+			if ok && v == blockToFind {
+				return true
+			}
+		}
+	}
+	return false
+}