Merge pull request RustPython#2006 from Lynskylate/try-to-use-local

Use loadname local replace loadname free

Author: coolreader18

Lib/_codecs.py

@@ -1485,11 +1485,11 @@ def PyUnicode_DecodeUnicodeEscape(s, size, errors):
                         message = "unknown Unicode character name"
                         st = s[pos+1:look]
                         try:
-                            chr = unicodedata.lookup("%s" % st)
+                            chr_codec = unicodedata.lookup("%s" % st)
                         except LookupError as e:
                             x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-1, look+1)
                         else:
-                            x = chr, look + 1 
+                            x = chr_codec, look + 1 
                         p += x[0]
                         pos = x[1]
                     else:        

compiler/src/compile.rs

@@ -298,7 +298,15 @@ impl<O: OutputStream> Compiler<O> {
             SymbolScope::Global => bytecode::NameScope::Global,
             SymbolScope::Nonlocal => bytecode::NameScope::NonLocal,
             SymbolScope::Unknown => bytecode::NameScope::Free,
-            SymbolScope::Local => bytecode::NameScope::Free,
+            SymbolScope::Local => {
+                // Only in function block, we use load local
+                // https://github.com/python/cpython/blob/master/Python/compile.c#L3582
+                if self.ctx.in_func() {
+                    bytecode::NameScope::Local
+                } else {
+                    bytecode::NameScope::Free
+                }
+            }
         }
     }
 

compiler/src/symboltable.rs

@@ -698,11 +698,11 @@ impl SymbolTableBuilder {
                 self.scan_expressions(vals, context)?;
             }
             Subscript { a, b } => {
-                self.scan_expression(a, context)?;
-                self.scan_expression(b, context)?;
+                self.scan_expression(a, &ExpressionContext::Load)?;
+                self.scan_expression(b, &ExpressionContext::Load)?;
             }
             Attribute { value, .. } => {
-                self.scan_expression(value, context)?;
+                self.scan_expression(value, &ExpressionContext::Load)?;
             }
             Dict { elements } => {
                 for (key, value) in elements {