Refactor kind promotion

Author: antonmedv

ast/node.go

@@ -30,8 +30,7 @@ type IntegerNode struct {
 	l file.Location
 	t reflect.Type
 
-	Value   int
-	Certain bool
+	Value int
 }
 
 type FloatNode struct {

checker/checker.go

@@ -141,15 +141,16 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 	l := v.visit(node.Left)
 	r := v.visit(node.Right)
 
+	// Kind Promotion.
+	// If the operands of a binary operation are different kinds of untyped constants,
+	// the result use the kind that appears later in this list: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64
 	if isNumber(l) && isNumber(r) && !isInterface(l) && !isInterface(r) {
-		// Real integer type is unknown until binary node,
-		// it maybe int, int64, float64, etc.
-		if !isCertain(node.Left) && isCertain(node.Right) {
+		if integerTypeWeight(l) < integerTypeWeight(r) {
+			setTypeForIntegers(node.Left, r)
 			l = r
-			setUncertainType(node.Left, dereference(r))
-		} else if isCertain(node.Left) && !isCertain(node.Right) {
+		} else if integerTypeWeight(l) > integerTypeWeight(r) {
+			setTypeForIntegers(node.Right, l)
 			r = l
-			setUncertainType(node.Right, dereference(l))
 		}
 	}
 
@@ -168,9 +169,19 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if isString(l) && isStruct(r) {
 			return boolType
 		}
-		if isArray(r) || isMap(r) {
-			if isNumber(l) && isCertain(node.Left) && !isCertain(node.Right) {
-				setUncertainType(node.Right, dereference(l))
+		if isMap(r) {
+			return boolType
+		}
+		if isArray(r) {
+			// Kind Promotion.
+			// Example:
+			//   foo in 0..9
+			// where foo is int64.
+			if b, ok := node.Right.(*ast.BinaryNode); ok {
+				if isInteger(l) && b.Operator == ".." {
+					setTypeForIntegers(b.Left, l)
+					setTypeForIntegers(b.Right, l)
+				}
 			}
 			return boolType
 		}
@@ -190,12 +201,6 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 
 	case "**":
 		if isNumber(l) && isNumber(r) && isComparable(l, r) {
-			if !isCertain(node.Left) {
-				setUncertainType(node.Left, integerType)
-			}
-			if !isCertain(node.Right) {
-				setUncertainType(node.Right, integerType)
-			}
 			return floatType
 		}
 
@@ -257,7 +262,7 @@ func (v *visitor) IndexNode(node *ast.IndexNode) reflect.Type {
 
 	if t, ok := indexType(t); ok {
 		if !isInteger(i) && !isString(i) {
-			panic(v.error(node, "invalid operation: can't use %v as index to %v", i, t))
+			panic(v.error(node, "invalid operation: cannot use %v as index to %v", i, t))
 		}
 		return t
 	}
@@ -305,13 +310,13 @@ func (v *visitor) FunctionNode(node *ast.FunctionNode) reflect.Type {
 				t := v.visit(arg)
 				in := fn.In(n)
 
-				if !isCertain(arg) {
+				if isIntegerOrArithmeticOperation(arg) {
 					t = in
-					setUncertainType(arg, in)
+					setTypeForIntegers(arg, t)
 				}
 
 				if !t.AssignableTo(in) {
-					panic(v.error(arg, "can't use %v as argument (type %v) to call %v ", t, in, node.Name))
+					panic(v.error(arg, "cannot use %v as argument (type %v) to call %v ", t, in, node.Name))
 				}
 				n++
 			}
@@ -364,13 +369,13 @@ func (v *visitor) MethodNode(node *ast.MethodNode) reflect.Type {
 				t := v.visit(arg)
 				in := fn.In(n)
 
-				if !isCertain(arg) {
+				if isIntegerOrArithmeticOperation(arg) {
 					t = in
-					setUncertainType(arg, in)
+					setTypeForIntegers(arg, t)
 				}
 
 				if !t.AssignableTo(in) {
-					panic(v.error(arg, "can't use %v as argument (type %v) to call %v ", t, in, node.Method))
+					panic(v.error(arg, "cannot use %v as argument (type %v) to call %v ", t, in, node.Method))
 				}
 				n++
 			}
@@ -465,7 +470,7 @@ func (v *visitor) PointerNode(node *ast.PointerNode) reflect.Type {
 	if t, ok := indexType(collection); ok {
 		return t
 	}
-	panic(v.error(node, "can't use %v as array", collection))
+	panic(v.error(node, "cannot use %v as array", collection))
 }
 
 func (v *visitor) ConditionalNode(node *ast.ConditionalNode) reflect.Type {

checker/checker_test.go

@@ -130,10 +130,13 @@ func TestCheck(t *testing.T) {
 		"'foo' contains 'bar'",
 		"'foo' endsWith 'bar'",
 		"'foo' startsWith 'bar'",
+		"(1 == 1) || (String matches Any)",
+		"1 + 2 + Int64",
+		"1 + 2 == FloatPtr",
+		"1 + 2 + Float + 3 + 4",
 		"1 < Float",
 		"1 <= Float",
 		"1 == 2 and true or Bool",
-		"1 == FloatPtr",
 		"1 > Float",
 		"1 >= Float",
 		"2**3 + 1",
@@ -144,6 +147,7 @@ func TestCheck(t *testing.T) {
 		"Any.Thing.Is.Bool",
 		"ArrayOfAny['string'].next.goes['any thing']",
 		"ArrayOfFoo[0].Bar.Baz",
+		"ArrayOfFoo[1].Int64 + 1",
 		"Bool && Any",
 		"BoolFn() and BoolFn()",
 		"EmbedPtr.EmbPtrStr + String",
@@ -161,6 +165,7 @@ func TestCheck(t *testing.T) {
 		"Int + Int + Int",
 		"Int == Any",
 		"Int in Int..Int",
+		"Int64 % 1",
 		"IntPtr == Int",
 		"len([])",
 		"Map.id.Bar.Baz",
@@ -175,7 +180,6 @@ func TestCheck(t *testing.T) {
 		"String in Foo",
 		"String matches 'ok'",
 		"String matches Any",
-		"(1 == 1) || (String matches Any)",
 		"String not in Foo2p",
 		"StringPtr == nil",
 		"Sub.Method(0) + String",
@@ -442,9 +446,10 @@ type bar struct {
 }
 
 type foo struct {
-	Bar bar
-	Fn  func() bool
-	Abc abc
+	Int64 int64
+	Bar   bar
+	Fn    func() bool
+	Abc   abc
 }
 
 type SubSub struct {
@@ -477,7 +482,7 @@ type mockEnv2 struct {
 	Fn         func(bool, int, string, interface{}) string
 	Bool       bool
 	Float      float64
-	Int64      int
+	Int64      int64
 	Int        int
 	String     string
 	BoolPtr    *bool

checker/types.go

@@ -268,33 +268,42 @@ func funcType(ntype reflect.Type) (reflect.Type, bool) {
 	return nil, false
 }
 
-type setVisitor struct {
-	ast.BaseVisitor
-	t reflect.Type
+func integerTypeWeight(t reflect.Type) uint {
+	return uint(t.Kind())
 }
 
-func (v setVisitor) IntegerNode(node *ast.IntegerNode) {
-	if !node.Certain {
-		node.SetType(v.t)
-		node.Certain = true
+func isIntegerOrArithmeticOperation(node ast.Node) bool {
+	switch n := node.(type) {
+	case *ast.IntegerNode:
+		return true
+	case *ast.UnaryNode:
+		switch n.Operator {
+		case "+", "-":
+			return true
+		}
+	case *ast.BinaryNode:
+		switch n.Operator {
+		case "+", "/", "-", "*":
+			return true
+		}
 	}
+	return false
 }
 
-func setUncertainType(node ast.Node, t reflect.Type) {
-	ast.Walk(&node, setVisitor{t: dereference(t)})
-}
-
-type hasVisitor struct {
-	ast.BaseVisitor
-	certain bool
-}
-
-func (v *hasVisitor) IntegerNode(node *ast.IntegerNode) {
-	v.certain = v.certain && node.Certain
-}
-
-func isCertain(node ast.Node) bool {
-	v := &hasVisitor{certain: true}
-	ast.Walk(&node, v)
-	return v.certain
+func setTypeForIntegers(node ast.Node, t reflect.Type) {
+	switch n := node.(type) {
+	case *ast.IntegerNode:
+		n.SetType(t)
+	case *ast.UnaryNode:
+		switch n.Operator {
+		case "+", "-":
+			setTypeForIntegers(n.Node, t)
+		}
+	case *ast.BinaryNode:
+		switch n.Operator {
+		case "+", "/", "-", "*":
+			setTypeForIntegers(n.Left, t)
+			setTypeForIntegers(n.Right, t)
+		}
+	}
 }

compiler/compiler.go

@@ -210,7 +210,7 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) {
 		c.emit(OpConst, c.makeConstant(uint64(node.Value))...)
 
 	default:
-		panic(fmt.Sprintf("can't compile %v to %v", node.Value, node.GetType()))
+		panic(fmt.Sprintf("cannot compile %v to %v", node.Value, node.GetType()))
 	}
 }
 

expr.go

@@ -10,12 +10,12 @@ import (
 
 // Eval parses, compiles and runs given input.
 func Eval(input string, env interface{}) (interface{}, error) {
-	node, err := parser.Parse(input)
+	tree, err := parser.Parse(input)
 	if err != nil {
 		return nil, err
 	}
 
-	program, err := compiler.Compile(node)
+	program, err := compiler.Compile(tree)
 	if err != nil {
 		return nil, err
 	}

vm/runtime.go

@@ -76,7 +76,7 @@ func fetchFn(from interface{}, name string) reflect.Value {
 			return value
 		}
 	}
-	panic(fmt.Sprintf(`can't get "%v" from %T`, name, from))
+	panic(fmt.Sprintf(`cannot get "%v" from %T`, name, from))
 }
 
 func in(needle interface{}, array interface{}) bool {

vm/vm_test.go

@@ -189,8 +189,8 @@ func TestRun(t *testing.T) {
 			true,
 		},
 		{
-			`1.5 in [1] && 1 in [1.5]`,
-			false,
+			`1.5 in [1.5] && 1 in [1]`,
+			true,
 		},
 		{
 			`(true ? 0+1 : 2+3) + (false ? -1 : -2)`,