Dont lose lexical scope refinements for super call

Author: ssnickolay

spec/ruby/core/module/refine_spec.rb

@@ -817,7 +817,7 @@ def bar
       end
     end
 
-    it "does't have access to refinement from included module" do
+    it "does't have access to active refinements for C from included module" do
       refined_class = ModuleSpecs.build_refined_class
 
       a = Module.new do
@@ -836,9 +836,40 @@ def bar
         end
       end
 
+      Module.new do
+        using refinement
+        -> {
+          refined_class.new.foo
+        }.should raise_error(NameError) { |e| e.name.should == :bar }
+      end
+    end
+
+    it "does't have access to other active refinements from included module" do
+      refined_class = ModuleSpecs.build_refined_class
+
+      refinement_integer = Module.new do
+        refine Integer do
+          def bar
+            "bar is not seen from A methods"
+          end
+        end
+      end
+
+      a = Module.new do
+        def foo
+          super + 1.bar
+        end
+      end
+
+      refinement = Module.new do
+        refine refined_class do
+          include a
+        end
+      end
 
       Module.new do
         using refinement
+        using refinement_integer
         -> {
           refined_class.new.foo
         }.should raise_error(NameError) { |e| e.name.should == :bar }
@@ -922,6 +953,40 @@ def foo
 
       result.should == [:B, :A, :LAST, :C]
     end
+
+    it "looks in the lexical scope refinements before other active refinements" do
+      refined_class = ModuleSpecs.build_refined_class(for_super: true)
+
+      refinement_local = Module.new do
+        refine refined_class do
+          def foo
+            [:LOCAL] + super
+          end
+        end
+      end
+
+      a = Module.new do
+        using refinement_local
+
+        def foo
+          [:A] + super
+        end
+      end
+
+      refinement = Module.new do
+        refine refined_class do
+          include a
+        end
+      end
+
+      result = nil
+      Module.new do
+        using refinement
+        result = refined_class.new.foo
+      end
+
+      result.should == [:A, :LOCAL, :C]
+    end
   end
 
   it 'and alias aliases a method within a refinement module, but not outside it' do

src/main/java/org/truffleruby/language/methods/UsingNode.java

@@ -63,14 +63,14 @@ private Map<DynamicObject, DynamicObject[]> usingModule(DeclarationContext decla
                     .getFields(ancestor)
                     .getRefinements();
             for (Map.Entry<DynamicObject, DynamicObject> entry : refinements.entrySet()) {
-                usingRefinement(entry.getKey(), entry.getValue(), newRefinements);
+                applyRefinements(entry.getKey(), entry.getValue(), newRefinements);
             }
         }
 
         return newRefinements;
     }
 
-    private void usingRefinement(DynamicObject refinedModule, DynamicObject refinementModule,
+    public static void applyRefinements(DynamicObject refinedModule, DynamicObject refinementModule,
             Map<DynamicObject, DynamicObject[]> newRefinements) {
         final DynamicObject[] refinements = newRefinements.get(refinedModule);
         if (refinements == null) {

src/main/java/org/truffleruby/language/supercall/LookupSuperMethodNode.java

@@ -16,6 +16,7 @@
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.methods.DeclarationContext;
 import org.truffleruby.language.methods.InternalMethod;
+import org.truffleruby.language.methods.UsingNode;
 import org.truffleruby.language.objects.MetaClassNode;
 
 import com.oracle.truffle.api.CompilerDirectives;
@@ -95,18 +96,21 @@ protected int getCacheLimit() {
     private DeclarationContext getDeclarationContext(InternalMethod currentMethod,
             DynamicObject selfMetaClass) {
         final DeclarationContext context = currentMethod.getDeclarationContext();
-        final DeclarationContext activeRefinements = currentMethod.getActiveRefinements();
+        final DeclarationContext callerContext = currentMethod.getActiveRefinements();
 
-        if (activeRefinements != null) {
+        if (callerContext != null) {
             // super from the refined method has access to the parent's active refinements for the selfMetaClass
-            final DynamicObject[] classRefinements = activeRefinements.getRefinementsFor(selfMetaClass);
+            final DynamicObject[] activeRefinements = callerContext.getRefinementsFor(selfMetaClass);
 
-            if (classRefinements == null) {
+            if (activeRefinements == null) {
                 return context;
             } else {
-                // add to the context active refinements for the selfMetaClass
                 final Map<DynamicObject, DynamicObject[]> newRefinements = new HashMap<>(context.getRefinements());
-                newRefinements.put(selfMetaClass, classRefinements);
+
+                // add class refinements in reverse order to keep the original positions
+                for (int i = activeRefinements.length - 1; i >= 0; i--) {
+                    UsingNode.applyRefinements(selfMetaClass, activeRefinements[i], newRefinements);
+                }
 
                 return context.withRefinements(newRefinements);
             }