Merge branch 'master' of https://github.com/RustPython/RustPython into extend-socket

Author: Lynskylate

Lib/datetime.py

@@ -59,10 +59,19 @@ bitflags! {
 pub type Label = usize;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+/// An indication where the name must be accessed.
 pub enum NameScope {
+    /// The name will be in the local scope.
     Local,
+
+    /// The name will be located in scope surrounding the current scope.
     NonLocal,
+
+    /// The name will be in global scope.
     Global,
+
+    /// The name will be located in any scope between the current scope and the top scope.
+    Free,
 }
 
 /// Transforms a value prior to formatting it.

bytecode/src/bytecode.rs

@@ -282,8 +282,8 @@ impl<O: OutputStream> Compiler<O> {
         match symbol.scope {
             SymbolScope::Global => bytecode::NameScope::Global,
             SymbolScope::Nonlocal => bytecode::NameScope::NonLocal,
-            SymbolScope::Unknown => bytecode::NameScope::Local,
-            SymbolScope::Local => bytecode::NameScope::Local,
+            SymbolScope::Unknown => bytecode::NameScope::Free,
+            SymbolScope::Local => bytecode::NameScope::Free,
         }
     }
 
@@ -500,7 +500,7 @@ impl<O: OutputStream> Compiler<O> {
                     self.compile_jump_if(test, true, end_label)?;
                     self.emit(Instruction::LoadName {
                         name: String::from("AssertionError"),
-                        scope: bytecode::NameScope::Local,
+                        scope: bytecode::NameScope::Global,
                     });
                     match msg {
                         Some(e) => {
@@ -736,7 +736,7 @@ impl<O: OutputStream> Compiler<O> {
                 // Check exception type:
                 self.emit(Instruction::LoadName {
                     name: String::from("isinstance"),
-                    scope: bytecode::NameScope::Local,
+                    scope: bytecode::NameScope::Global,
                 });
                 self.emit(Instruction::Rotate { amount: 2 });
                 self.compile_expression(exc_type)?;
@@ -931,11 +931,11 @@ impl<O: OutputStream> Compiler<O> {
 
         self.emit(Instruction::LoadName {
             name: "__name__".to_string(),
-            scope: bytecode::NameScope::Local,
+            scope: bytecode::NameScope::Free,
         });
         self.emit(Instruction::StoreName {
             name: "__module__".to_string(),
-            scope: bytecode::NameScope::Local,
+            scope: bytecode::NameScope::Free,
         });
         self.compile_statements(new_body)?;
         self.emit(Instruction::LoadConst {

compiler/src/compile.rs

@@ -31,6 +31,9 @@ pub fn statements_to_symbol_table(
 /// Captures all symbols in the current scope, and has a list of subscopes in this scope.
 #[derive(Clone, Default)]
 pub struct SymbolTable {
+    /// The name of this symbol table. Often the name of the class or function.
+    pub name: String,
+
     /// A set of symbols present on this scope level.
     pub symbols: IndexMap<String, Symbol>,
 
@@ -40,8 +43,9 @@ pub struct SymbolTable {
 }
 
 impl SymbolTable {
-    fn new() -> Self {
+    fn new(name: String) -> Self {
         SymbolTable {
+            name,
             symbols: Default::default(),
             sub_tables: vec![],
         }
@@ -209,20 +213,22 @@ impl SymbolTableAnalyzer {
                 if symbol.is_assigned || symbol.is_parameter {
                     symbol.scope = SymbolScope::Local;
                 } else {
-                    // TODO: comment this out and make it work properly:
-                    /*
-                    let found_in_outer_scope = self
-                        .tables
-                        .iter()
-                        .any(|t| t.symbols.contains_key(&symbol.name));
+                    // Interesting stuff about the __class__ variable:
+                    // https://docs.python.org/3/reference/datamodel.html?highlight=__class__#creating-the-class-object
+                    let found_in_outer_scope = (symbol.name == "__class__")
+                        || self
+                            .tables
+                            .iter()
+                            .skip(1)
+                            .any(|t| t.symbols.contains_key(&symbol.name));
+
                     if found_in_outer_scope {
                         // Symbol is in some outer scope.
-
+                        symbol.is_free = true;
                     } else {
                         // Well, it must be a global then :)
-                        // symbol.scope = SymbolScope::Global;
+                        symbol.scope = SymbolScope::Global;
                     }
-                    */
                 }
             }
         }
@@ -257,8 +263,7 @@ enum ExpressionContext {
 
 impl SymbolTableBuilder {
     fn prepare(&mut self) {
-        let table = SymbolTable::new();
-        self.tables.push(table);
+        self.enter_block("top")
     }
 
     fn finish(&mut self) -> Result<SymbolTable, SymbolTableError> {
@@ -268,9 +273,9 @@ impl SymbolTableBuilder {
         Ok(symbol_table)
     }
 
-    fn enter_block(&mut self) {
+    fn enter_block(&mut self, name: &str) {
         // let parent = Some(self.tables.last().unwrap().clone());
-        let table = SymbolTable::new();
+        let table = SymbolTable::new(name.to_string());
         self.tables.push(table);
     }
 
@@ -343,7 +348,7 @@ impl SymbolTableBuilder {
                 if let Some(expression) = returns {
                     self.scan_expression(expression, &ExpressionContext::Load)?;
                 }
-                self.enter_function(args)?;
+                self.enter_function(name, args)?;
                 self.scan_statements(body)?;
                 self.leave_block();
             }
@@ -355,7 +360,7 @@ impl SymbolTableBuilder {
                 decorator_list,
             } => {
                 self.register_name(name, SymbolUsage::Assigned)?;
-                self.enter_block();
+                self.enter_block(name);
                 self.scan_statements(body)?;
                 self.leave_block();
                 self.scan_expressions(bases, &ExpressionContext::Load)?;
@@ -607,7 +612,7 @@ impl SymbolTableBuilder {
                 }
             }
             Lambda { args, body } => {
-                self.enter_function(args)?;
+                self.enter_function("lambda", args)?;
                 self.scan_expression(body, &ExpressionContext::Load)?;
                 self.leave_block();
             }
@@ -620,7 +625,7 @@ impl SymbolTableBuilder {
         Ok(())
     }
 
-    fn enter_function(&mut self, args: &ast::Parameters) -> SymbolTableResult {
+    fn enter_function(&mut self, name: &str, args: &ast::Parameters) -> SymbolTableResult {
         // Evaluate eventual default parameters:
         self.scan_expressions(&args.defaults, &ExpressionContext::Load)?;
         for kw_default in &args.kw_defaults {
@@ -639,7 +644,7 @@ impl SymbolTableBuilder {
             self.scan_parameter_annotation(name)?;
         }
 
-        self.enter_block();
+        self.enter_block(name);
 
         // Fill scope with parameter names:
         self.scan_parameters(&args.args)?;

compiler/src/symboltable.rs

@@ -73,4 +73,4 @@ def print_table(table, indent=0):
 print('======== dis.dis ========')
 print()
 co = compile(source, filename, 'exec')
-print(dis.dis(co))
+dis.dis(co)

crawl_sourcecode.py

@@ -0,0 +1,15 @@
+from array import array
+
+a1 = array("b", [0, 1, 2, 3])
+
+assert a1.tobytes() == b"\x00\x01\x02\x03"
+assert a1[2] == 2
+
+assert list(a1) == [0, 1, 2, 3]
+
+a1.reverse()
+assert a1 == array("B", [3, 2, 1, 0])
+
+a1.extend([4, 5, 6, 7])
+
+assert a1 == array("h", [3, 2, 1, 0, 4, 5, 6, 7])

tests/snippets/arraymodule.py

@@ -97,14 +97,57 @@
 assert -10 // -4 == 2
 
 assert int() == 0
+assert int(1) == 1
 assert int("101", 2) == 5
 assert int("101", base=2) == 5
-assert int(1) == 1
+
+# implied base
+assert int('1', base=0) == 1
+assert int('123', base=0) == 123
+assert int('0b101', base=0) == 5
+assert int('0B101', base=0) == 5
+assert int('0o100', base=0) == 64
+assert int('0O100', base=0) == 64
+assert int('0xFF', base=0) == 255
+assert int('0XFF', base=0) == 255
+with assertRaises(ValueError):
+    int('0xFF', base=10)
+with assertRaises(ValueError):
+    int('0oFF', base=10)
+with assertRaises(ValueError):
+    int('0bFF', base=10)
+with assertRaises(ValueError):
+    int('0bFF', base=10)
+with assertRaises(ValueError):
+    int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
+with assertRaises(ValueError):
+    int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
+
+# underscore
+assert int('0xFF_FF_FF', base=16) == 16_777_215
+with assertRaises(ValueError):
+    int("_123_")
+with assertRaises(ValueError):
+    int("123_")
+with assertRaises(ValueError):
+    int("_123")
+with assertRaises(ValueError):
+    int("1__23")
+
+# signed
+assert int('-123') == -123
+assert int('+0b101', base=2) == +5
+
+# trailing spaces
 assert int(' 1') == 1
 assert int('1 ') == 1
 assert int(' 1 ') == 1
 assert int('10', base=0) == 10
 
+# type byte, signed, implied base
+assert int(b'     -0XFF ', base=0) == -255
+
+
 assert int.from_bytes(b'\x00\x10', 'big') == 16
 assert int.from_bytes(b'\x00\x10', 'little') == 4096
 assert int.from_bytes(b'\xfc\x00', 'big', signed=True) == -1024
@@ -179,4 +222,4 @@ def __int__(self):
 assert_raises(TypeError, lambda: (0).__round__(None))
 assert_raises(TypeError, lambda: (1).__round__(None))
 assert_raises(TypeError, lambda: (0).__round__(0.0))
-assert_raises(TypeError, lambda: (1).__round__(0.0))
+assert_raises(TypeError, lambda: (1).__round__(0.0))