Implement ilshift and irshift operators. (#248)

Addresses #56

Author: trotterdylan

compiler/stmt.py

@@ -571,9 +571,11 @@ def visit_While(self, node):
       ast.Add: 'πg.IAdd(πF, {lhs}, {rhs})',
       ast.BitAnd: 'πg.IAnd(πF, {lhs}, {rhs})',
       ast.Div: 'πg.IDiv(πF, {lhs}, {rhs})',
+      ast.LShift: 'πg.ILShift(πF, {lhs}, {rhs})',
       ast.Mod: 'πg.IMod(πF, {lhs}, {rhs})',
       ast.Mult: 'πg.IMul(πF, {lhs}, {rhs})',
       ast.BitOr: 'πg.IOr(πF, {lhs}, {rhs})',
+      ast.RShift: 'πg.IRShift(πF, {lhs}, {rhs})',
       ast.Sub: 'πg.ISub(πF, {lhs}, {rhs})',
       ast.BitXor: 'πg.IXor(πF, {lhs}, {rhs})',
   }

runtime/core.go

@@ -287,6 +287,12 @@ func IDiv(f *Frame, v, w *Object) (*Object, *BaseException) {
 	return inplaceOp(f, v, w, v.typ.slots.IDiv, Div)
 }
 
+// ILShift returns the result of v.__ilshift__ if defined, otherwise falls back
+// to lshift.
+func ILShift(f *Frame, v, w *Object) (*Object, *BaseException) {
+	return inplaceOp(f, v, w, v.typ.slots.ILShift, LShift)
+}
+
 // IMod returns the result of v.__imod__ if defined, otherwise falls back to
 // mod.
 func IMod(f *Frame, v, w *Object) (*Object, *BaseException) {
@@ -314,6 +320,12 @@ func IOr(f *Frame, v, w *Object) (*Object, *BaseException) {
 	return inplaceOp(f, v, w, v.typ.slots.IOr, Or)
 }
 
+// IRShift returns the result of v.__irshift__ if defined, otherwise falls back
+// to rshift.
+func IRShift(f *Frame, v, w *Object) (*Object, *BaseException) {
+	return inplaceOp(f, v, w, v.typ.slots.IRShift, RShift)
+}
+
 // IsInstance returns true if the type o is an instance of classinfo, or an
 // instance of an element in classinfo (if classinfo is a tuple). It returns
 // false otherwise. The argument classinfo must be a type or a tuple whose

runtime/core_test.go

@@ -83,6 +83,9 @@ func TestBinaryOps(t *testing.T) {
 		"__idiv__": newBuiltinFunction("__idiv__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 			return args[1], nil
 		}).ToObject(),
+		"__ilshift__": newBuiltinFunction("__ilshift__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
+			return args[1], nil
+		}).ToObject(),
 		"__imod__": newBuiltinFunction("__imod__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 			return args[1], nil
 		}).ToObject(),
@@ -92,6 +95,9 @@ func TestBinaryOps(t *testing.T) {
 		"__ior__": newBuiltinFunction("__ior__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 			return args[1], nil
 		}).ToObject(),
+		"__irshift__": newBuiltinFunction("__irshift__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
+			return args[1], nil
+		}).ToObject(),
 		"__isub__": newBuiltinFunction("__isub__", func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 			return args[1], nil
 		}).ToObject(),
@@ -121,6 +127,7 @@ func TestBinaryOps(t *testing.T) {
 		{IAnd, newObject(ObjectType), newObject(fooType), nil, mustCreateException(TypeErrorType, "unsupported operand type(s) for &: 'object' and 'Foo'")},
 		{IDiv, NewInt(123).ToObject(), newObject(bazType), NewStr("123").ToObject(), nil},
 		{IDiv, newObject(inplaceType), NewInt(42).ToObject(), NewInt(42).ToObject(), nil},
+		{ILShift, newObject(inplaceType), NewInt(123).ToObject(), NewInt(123).ToObject(), nil},
 		{IMod, NewInt(24).ToObject(), NewInt(6).ToObject(), NewInt(0).ToObject(), nil},
 		{IMod, newObject(inplaceType), NewFloat(3.14).ToObject(), NewFloat(3.14).ToObject(), nil},
 		{IMul, NewStr("foo").ToObject(), NewInt(3).ToObject(), NewStr("foofoofoo").ToObject(), nil},
@@ -129,6 +136,7 @@ func TestBinaryOps(t *testing.T) {
 		{IOr, newObject(inplaceType), NewInt(42).ToObject(), NewInt(42).ToObject(), nil},
 		{IOr, NewInt(9).ToObject(), NewInt(12).ToObject(), NewInt(13).ToObject(), nil},
 		{IOr, newObject(ObjectType), newObject(fooType), nil, mustCreateException(TypeErrorType, "unsupported operand type(s) for |: 'object' and 'Foo'")},
+		{IRShift, newObject(inplaceType), NewInt(123).ToObject(), NewInt(123).ToObject(), nil},
 		{ISub, NewInt(3).ToObject(), NewInt(-3).ToObject(), NewInt(6).ToObject(), nil},
 		{ISub, newObject(inplaceType), None, None, nil},
 		{IXor, newObject(inplaceType), None, None, nil},

runtime/slots.go

@@ -392,6 +392,7 @@ type typeSlots struct {
 	IAdd         *binaryOpSlot
 	IAnd         *binaryOpSlot
 	IDiv         *binaryOpSlot
+	ILShift      *binaryOpSlot
 	IMod         *binaryOpSlot
 	IMul         *binaryOpSlot
 	Index        *unaryOpSlot
@@ -400,6 +401,7 @@ type typeSlots struct {
 	Invert       *unaryOpSlot
 	IOr          *binaryOpSlot
 	IPow         *binaryOpSlot
+	IRShift      *binaryOpSlot
 	ISub         *binaryOpSlot
 	Iter         *unaryOpSlot
 	IXor         *binaryOpSlot