Prefer local class namespace over lexical scoping (#1151)

* Prefer local class namespace over lexical scoping

* Move some expression code to C#

* Add failing metaclass scope test

Author: BCSharp

Src/IronPython/Compiler/Ast/AstMethods.cs

@@ -61,6 +61,7 @@ internal static class AstMethods {
         public static readonly MethodInfo MakeClosureCell = GetMethod((Func<ClosureCell>)PythonOps.MakeClosureCell);
         public static readonly MethodInfo MakeClosureCellWithValue = GetMethod((Func<object, ClosureCell>)PythonOps.MakeClosureCellWithValue);
         public static readonly MethodInfo LookupName = GetMethod((Func<CodeContext, string, object>)PythonOps.LookupName);
+        public static readonly MethodInfo LookupLocalName = GetMethod((Func<CodeContext, string, object, object>)PythonOps.LookupLocalName);
         public static readonly MethodInfo RemoveName = GetMethod((Action<CodeContext, string>)PythonOps.RemoveName);
         public static readonly MethodInfo SetName = GetMethod((Func<CodeContext, string, object, object>)PythonOps.SetName);
         public static readonly MethodInfo KeepAlive = GetMethod((Action<object>)GC.KeepAlive);

Src/IronPython/Compiler/Ast/ClassDefinition.cs

@@ -145,6 +145,16 @@ internal override PythonVariable BindReference(PythonNameBinder binder, PythonRe
             return null;
         }
 
+        internal override Ast LookupVariableExpression(PythonVariable variable) {
+            // Emulates opcode LOAD_CLASSDEREF
+            return Ast.Call(
+                AstMethods.LookupLocalName,
+                LocalContext,
+                Ast.Constant(variable.Name),
+                GetVariableExpression(variable)
+            );
+        }
+
         private static readonly MSAst.Expression NullLambda = AstUtils.Default(typeof(Func<CodeContext, CodeContext>));
 
         public override MSAst.Expression Reduce() {

Src/IronPython/Compiler/Ast/NameExpression.cs

@@ -39,7 +39,7 @@ public override MSAst.Expression Reduce() {
                     Ast.Constant(Name)
                 );
             } else {
-                read = Parent.GetVariableExpression(Reference.PythonVariable);
+                read = Parent.LookupVariableExpression(Reference.PythonVariable);
             }
 
             if (!Assigned && !(read is IPythonGlobalExpression)) {

Src/IronPython/Compiler/Ast/ScopeStatement.cs

@@ -698,6 +698,9 @@ internal virtual MSAst.Expression GetVariableExpression(PythonVariable variable)
             return _variableMapping[variable.LimitVariable];
         }
 
+        internal virtual Ast LookupVariableExpression(PythonVariable variable)
+            => GetVariableExpression(variable);
+
         internal void CreateVariables(ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
             if (Variables != null) {
                 foreach (PythonVariable variable in Variables.Values) {

Src/IronPython/Runtime/Operations/PythonOps.cs

@@ -3360,6 +3360,10 @@ public static void RemoveName(CodeContext/*!*/ context, string name) {
             throw PythonOps.NameError(name);
         }
 
+        public static object? LookupLocalName(CodeContext context, string name, object? defaultValue) {
+            return context.TryGetVariable(name, out object? value) ? value : defaultValue;
+        }
+
         /// <summary>
         /// Called from generated code, helper to do name assignment
         /// </summary>

Tests/test_class.py

@@ -2749,6 +2749,27 @@ class Child(Parent, Mixin):
 
         self.assertEqual(Child.attr_Child, 'attribute set on Child by MetaClass')
 
+    def test_metaclass_scope(self):
+        class MetaClass(type): pass
+
+        def foo():
+            outer = "lexically scoped"
+            class C(metaclass=MetaClass):
+                x = outer
+            return C.x
+
+        self.assertEqual(foo(), "lexically scoped")
+
+        class MetaClass(type):
+            def __prepare__(*args):
+                return dict(outer="from metaclass")
+
+        if is_cli:
+            # https://github.com/IronLanguages/ironpython3/issues/1154
+            self.assertEqual(foo(), "lexically scoped")
+        else:
+            self.assertEqual(foo(), "from metaclass")
+
     def test_binary_operator_subclass(self):
         """subclassing but not overriding shouldn't call __radd__"""
         class A(object):

Tests/test_namebinding.py

@@ -211,10 +211,7 @@ class C:
         locals()["xyz"] = True
         passed = xyz
 
-    if is_cli: # https://github.com/IronLanguages/ironpython3/issues/1030
-        selph.assertTrue(C.passed == False)
-    else:
-        selph.assertTrue(C.passed == True)
+    selph.assertTrue(C.passed == True)
 
 def localsAfterExpr():
     exec("pass")
@@ -293,10 +290,7 @@ class c:
                 abc = a
             return c
 
-        if is_cli: # https://github.com/IronLanguages/ironpython3/issues/1030
-            self.assertEqual(f().abc, 2)
-        else:
-            self.assertEqual(f().abc, 42)
+        self.assertEqual(f().abc, 42)
 
     def test_DelBuiltin(self):
         # Check that "pow" is defined

Tests/test_scope_stdlib.py

@@ -20,7 +20,7 @@ def load_tests(loader, standard_tests, pattern):
         suite.addTest(test.test_scope.ScopeTests('testCellIsKwonlyArg'))
         suite.addTest(test.test_scope.ScopeTests('testCellLeak'))
         suite.addTest(test.test_scope.ScopeTests('testClassAndGlobal'))
-        suite.addTest(unittest.expectedFailure(test.test_scope.ScopeTests('testClassNamespaceOverridesClosure'))) # TODO: figure out
+        suite.addTest(test.test_scope.ScopeTests('testClassNamespaceOverridesClosure'))
         suite.addTest(test.test_scope.ScopeTests('testComplexDefinitions'))
         suite.addTest(test.test_scope.ScopeTests('testEvalExecFreeVars'))
         suite.addTest(test.test_scope.ScopeTests('testEvalFreeVars'))