Merge branch 'master' into string.__repr__

Author: makarchuk

compiler/src/error.rs

@@ -1,4 +1,4 @@
-use rustpython_parser::error::{ParseError, ParseErrorType};
+use rustpython_parser::error::{LexicalErrorType, ParseError, ParseErrorType};
 use rustpython_parser::location::Location;
 
 use std::error::Error;
@@ -40,6 +40,19 @@ pub enum CompileErrorType {
     InvalidYield,
 }
 
+impl CompileError {
+    pub fn is_tab_error(&self) -> bool {
+        if let CompileErrorType::Parse(parse) = &self.error {
+            if let ParseErrorType::Lexical(lex) = parse {
+                if let LexicalErrorType::TabError = lex {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+}
+
 impl fmt::Display for CompileError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.error {

parser/src/error.rs

@@ -20,6 +20,7 @@ pub enum LexicalErrorType {
     StringError,
     UnicodeError,
     NestingError,
+    TabError,
     DefaultArgumentError,
     PositionalArgumentError,
     DuplicateKeywordArgumentError,
@@ -35,6 +36,9 @@ impl fmt::Display for LexicalErrorType {
             LexicalErrorType::FStringError(error) => write!(f, "Got error in f-string: {}", error),
             LexicalErrorType::UnicodeError => write!(f, "Got unexpected unicode"),
             LexicalErrorType::NestingError => write!(f, "Got unexpected nesting"),
+            LexicalErrorType::TabError => {
+                write!(f, "inconsistent use of tabs and spaces in indentation")
+            }
             LexicalErrorType::DefaultArgumentError => {
                 write!(f, "non-default argument follows default argument")
             }

parser/src/lexer.rs

@@ -38,9 +38,7 @@ impl IndentationLevel {
             } else {
                 Err(LexicalError {
                     location,
-                    error: LexicalErrorType::OtherError(
-                        "inconsistent use of tabs and spaces in indentation".to_string(),
-                    ),
+                    error: LexicalErrorType::TabError,
                 })
             }
         } else if self.tabs > other.tabs {
@@ -49,9 +47,7 @@ impl IndentationLevel {
             } else {
                 Err(LexicalError {
                     location,
-                    error: LexicalErrorType::OtherError(
-                        "inconsistent use of tabs and spaces in indentation".to_string(),
-                    ),
+                    error: LexicalErrorType::TabError,
                 })
             }
         } else {

tests/snippets/dict.py

@@ -251,3 +251,6 @@ def __eq__(self, other):
 assert isinstance(c, set)
 assert c == {'bla', 'c', 'd', 'f'}
 
+assert not {}.__ne__({})
+assert {}.__ne__({'a':'b'})
+assert {}.__ne__(1) == NotImplemented

tests/snippets/invalid_syntax.py

@@ -14,5 +14,14 @@ def valid_func():
 else:
     raise AssertionError("Must throw syntax error")
 
+src = """
+if True:
+    pass
+\tpass
+"""
+
+with assert_raises(TabError):
+    compile(src, '', 'exec')
+
 with assert_raises(SyntaxError):
     compile('0xX', 'test.py', 'exec')

tests/snippets/list.py

@@ -488,3 +488,47 @@ def bad_iter_assign():
 assert x == [0, 1, 2, 3, 4, 5]
 x = list(range(10))
 del x[-5:-1:-1]
+
+assert [1, 2].__ne__([])
+assert [2, 1].__ne__([1, 2])
+assert not [1, 2].__ne__([1, 2])
+assert [1, 2].__ne__(1) == NotImplemented
+
+# list gt, ge, lt, le
+assert_raises(TypeError, lambda: [0, []] < [0, 0])
+assert_raises(TypeError, lambda: [0, []] <= [0, 0])
+assert_raises(TypeError, lambda: [0, []] > [0, 0])
+assert_raises(TypeError, lambda: [0, []] >= [0, 0])
+
+assert_raises(TypeError, lambda: [0, 0] < [0, []])
+assert_raises(TypeError, lambda: [0, 0] <= [0, []])
+assert_raises(TypeError, lambda: [0, 0] > [0, []])
+assert_raises(TypeError, lambda: [0, 0] >= [0, []])
+
+assert [0, 0] < [1, -1]
+assert [0, 0] < [0, 0, 1]
+assert [0, 0] < [0, 0, -1]
+assert [0, 0] <= [0, 0, -1]
+assert not [0, 0, 0, 0] <= [0, -1]
+
+assert [0, 0] > [-1, 1]
+assert [0, 0] >= [-1, 1]
+assert [0, 0, 0] >= [-1, 1]
+
+assert [0, 0] <= [0, 1]
+assert [0, 0] <= [0, 0]
+assert [0, 0] <= [0, 0]
+assert not [0, 0] > [0, 0]
+assert not [0, 0] < [0, 0]
+
+assert not [float('nan'), float('nan')] <= [float('nan'), 1]
+assert not [float('nan'), float('nan')] <= [float('nan'), float('nan')]
+assert not [float('nan'), float('nan')] >= [float('nan'), float('nan')]
+assert not [float('nan'), float('nan')] < [float('nan'), float('nan')]
+assert not [float('nan'), float('nan')] > [float('nan'), float('nan')]
+
+assert [float('inf'), float('inf')] >= [float('inf'), 1]
+assert [float('inf'), float('inf')] <= [float('inf'), float('inf')]
+assert [float('inf'), float('inf')] >= [float('inf'), float('inf')]
+assert not [float('inf'), float('inf')] < [float('inf'), float('inf')]
+assert not [float('inf'), float('inf')] > [float('inf'), float('inf')]

tests/snippets/set.py

@@ -327,3 +327,13 @@ def __hash__(self):
 assert x == (EqObject(x) == EqObject(x))
 s = {EqObject(x)}
 assert EqObject(x) in s
+
+assert set([1, 2]).__ne__(set())
+assert not set([1, 2]).__ne__(set([2, 1]))
+assert set().__ne__(1) == NotImplemented
+
+assert frozenset([1, 2]).__ne__(set())
+assert frozenset([1, 2]).__ne__(frozenset())
+assert not frozenset([1, 2]).__ne__(set([2, 1]))
+assert not frozenset([1, 2]).__ne__(frozenset([2, 1]))
+assert frozenset().__ne__(1) == NotImplemented

tests/snippets/strings.py

@@ -1,5 +1,6 @@
 from testutils import assert_raises
 
+assert "".__eq__(1) == NotImplemented
 assert "a" == 'a'
 assert """a""" == "a"
 assert len(""" " "" " "" """) == 11
@@ -318,3 +319,8 @@ def try_mutate_str():
 assert chr(9999).__repr__() == "'✏'"
 assert chr(99999).__repr__() == "'𘚟'"
 assert chr(999999).__repr__() == "'\\U000f423f'"
+
+assert "a".__ne__("b")
+assert not "a".__ne__("a")
+assert not "".__ne__("")
+assert "".__ne__(1) == NotImplemented

tests/snippets/tuple.py

@@ -1,3 +1,5 @@
+from testutils import assert_raises
+
 assert (1,2) == (1,2)
 
 x = (1,2)
@@ -47,3 +49,45 @@ def __eq__(self, x):
 a = ()
 b = ()
 assert a is b
+
+assert (1,).__ne__((2,))
+assert not (1,).__ne__((1,))
+
+# tuple gt, ge, lt, le
+assert_raises(TypeError, lambda: (0, ()) < (0, 0))
+assert_raises(TypeError, lambda: (0, ()) <= (0, 0))
+assert_raises(TypeError, lambda: (0, ()) > (0, 0))
+assert_raises(TypeError, lambda: (0, ()) >= (0, 0))
+
+assert_raises(TypeError, lambda: (0, 0) < (0, ()))
+assert_raises(TypeError, lambda: (0, 0) <= (0, ()))
+assert_raises(TypeError, lambda: (0, 0) > (0, ()))
+assert_raises(TypeError, lambda: (0, 0) >= (0, ()))
+
+assert (0, 0) < (1, -1)
+assert (0, 0) < (0, 0, 1)
+assert (0, 0) < (0, 0, -1)
+assert (0, 0) <= (0, 0, -1)
+assert not (0, 0, 0, 0) <= (0, -1)
+
+assert (0, 0) > (-1, 1)
+assert (0, 0) >= (-1, 1)
+assert (0, 0, 0) >= (-1, 1)
+
+assert (0, 0) <= (0, 1)
+assert (0, 0) <= (0, 0)
+assert (0, 0) <= (0, 0)
+assert not (0, 0) > (0, 0)
+assert not (0, 0) < (0, 0)
+
+assert not (float('nan'), float('nan')) <= (float('nan'), 1)
+assert not (float('nan'), float('nan')) <= (float('nan'), float('nan'))
+assert not (float('nan'), float('nan')) >= (float('nan'), float('nan'))
+assert not (float('nan'), float('nan')) < (float('nan'), float('nan'))
+assert not (float('nan'), float('nan')) > (float('nan'), float('nan'))
+
+assert (float('inf'), float('inf')) >= (float('inf'), 1)
+assert (float('inf'), float('inf')) <= (float('inf'), float('inf'))
+assert (float('inf'), float('inf')) >= (float('inf'), float('inf'))
+assert not (float('inf'), float('inf')) < (float('inf'), float('inf'))
+assert not (float('inf'), float('inf')) > (float('inf'), float('inf'))

vm/src/builtins.rs

@@ -850,6 +850,8 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
         "RuntimeError" => ctx.exceptions.runtime_error.clone(),
         "ReferenceError" => ctx.exceptions.reference_error.clone(),
         "SyntaxError" =>  ctx.exceptions.syntax_error.clone(),
+        "IndentationError" =>  ctx.exceptions.indentation_error.clone(),
+        "TabError" =>  ctx.exceptions.tab_error.clone(),
         "NotImplementedError" => ctx.exceptions.not_implemented_error.clone(),
         "TypeError" => ctx.exceptions.type_error.clone(),
         "ValueError" => ctx.exceptions.value_error.clone(),

vm/src/exceptions.rs

@@ -229,6 +229,8 @@ pub struct ExceptionZoo {
     pub runtime_error: PyClassRef,
     pub stop_iteration: PyClassRef,
     pub syntax_error: PyClassRef,
+    pub indentation_error: PyClassRef,
+    pub tab_error: PyClassRef,
     pub system_error: PyClassRef,
     pub type_error: PyClassRef,
     pub value_error: PyClassRef,
@@ -284,6 +286,8 @@ impl ExceptionZoo {
         let permission_error = create_type("PermissionError", &type_type, &os_error);
         let file_exists_error = create_type("FileExistsError", &type_type, &os_error);
         let eof_error = create_type("EOFError", &type_type, &exception_type);
+        let indentation_error = create_type("IndentationError", &type_type, &syntax_error);
+        let tab_error = create_type("TabError", &type_type, &indentation_error);
         let unicode_error = create_type("UnicodeError", &type_type, &value_error);
         let unicode_decode_error = create_type("UnicodeDecodeError", &type_type, &unicode_error);
         let unicode_encode_error = create_type("UnicodeEncodeError", &type_type, &unicode_error);
@@ -327,6 +331,8 @@ impl ExceptionZoo {
             runtime_error,
             stop_iteration,
             syntax_error,
+            indentation_error,
+            tab_error,
             system_error,
             type_error,
             value_error,

vm/src/obj/objdict.rs

@@ -146,6 +146,15 @@ impl PyDictRef {
         }
     }
 
+    fn ne(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if let Some(other) = other.payload::<PyDict>() {
+            let neq = !self.inner_eq(other, vm)?;
+            Ok(vm.ctx.new_bool(neq))
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+
     fn len(self, _vm: &VirtualMachine) -> usize {
         self.entries.borrow().len()
     }
@@ -575,6 +584,7 @@ pub fn init(context: &PyContext) {
         "__contains__" => context.new_rustfunc(PyDictRef::contains),
         "__delitem__" => context.new_rustfunc(PyDictRef::inner_delitem),
         "__eq__" => context.new_rustfunc(PyDictRef::eq),
+        "__ne__" => context.new_rustfunc(PyDictRef::ne),
         "__getitem__" => context.new_rustfunc(PyDictRef::inner_getitem),
         "__iter__" => context.new_rustfunc(PyDictRef::iter),
         (slot new) => PyDictRef::new,

vm/src/obj/objenumerate.rs

@@ -26,27 +26,28 @@ impl PyValue for PyEnumerate {
     }
 }
 
-fn enumerate_new(
-    cls: PyClassRef,
-    iterable: PyObjectRef,
-    start: OptionalArg<PyIntRef>,
-    vm: &VirtualMachine,
-) -> PyResult<PyEnumerateRef> {
-    let counter = match start {
-        OptionalArg::Present(start) => start.as_bigint().clone(),
-        OptionalArg::Missing => BigInt::zero(),
-    };
+#[pyimpl]
+impl PyEnumerate {
+    #[pyslot(new)]
+    fn tp_new(
+        cls: PyClassRef,
+        iterable: PyObjectRef,
+        start: OptionalArg<PyIntRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyEnumerateRef> {
+        let counter = match start {
+            OptionalArg::Present(start) => start.as_bigint().clone(),
+            OptionalArg::Missing => BigInt::zero(),
+        };
 
-    let iterator = objiter::get_iter(vm, &iterable)?;
-    PyEnumerate {
-        counter: RefCell::new(counter.clone()),
-        iterator,
+        let iterator = objiter::get_iter(vm, &iterable)?;
+        PyEnumerate {
+            counter: RefCell::new(counter.clone()),
+            iterator,
+        }
+        .into_ref_with_type(vm, cls)
     }
-    .into_ref_with_type(vm, cls)
-}
 
-#[pyimpl]
-impl PyEnumerate {
     #[pymethod(name = "__next__")]
     fn next(&self, vm: &VirtualMachine) -> PyResult {
         let iterator = &self.iterator;
@@ -69,7 +70,4 @@ impl PyEnumerate {
 
 pub fn init(context: &PyContext) {
     PyEnumerate::extend_class(context, &context.types.enumerate_type);
-    extend_class!(context, &context.types.enumerate_type, {
-        (slot new) => enumerate_new,
-    });
 }

vm/src/obj/objfilter.rs

@@ -24,23 +24,24 @@ impl PyValue for PyFilter {
     }
 }
 
-fn filter_new(
-    cls: PyClassRef,
-    function: PyObjectRef,
-    iterable: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<PyFilterRef> {
-    let iterator = objiter::get_iter(vm, &iterable)?;
+#[pyimpl]
+impl PyFilter {
+    #[pyslot(new)]
+    fn tp_new(
+        cls: PyClassRef,
+        function: PyObjectRef,
+        iterable: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyFilterRef> {
+        let iterator = objiter::get_iter(vm, &iterable)?;
 
-    PyFilter {
-        predicate: function.clone(),
-        iterator,
+        PyFilter {
+            predicate: function.clone(),
+            iterator,
+        }
+        .into_ref_with_type(vm, cls)
     }
-    .into_ref_with_type(vm, cls)
-}
 
-#[pyimpl]
-impl PyFilter {
     #[pymethod(name = "__next__")]
     fn next(&self, vm: &VirtualMachine) -> PyResult {
         let predicate = &self.predicate;
@@ -68,7 +69,4 @@ impl PyFilter {
 
 pub fn init(context: &PyContext) {
     PyFilter::extend_class(context, &context.types.filter_type);
-    extend_class!(context, &context.types.filter_type, {
-        (slot new) => filter_new,
-    });
 }