Use Memo<Boolean> for foundDeclaringModule instead of additional wrapper class

Author: ssnickolay

doc/contributor/refinements.md

@@ -94,7 +94,7 @@ R1 -> A -> B -> R2 -> D -> E -> C -> ...
 The `super` lookup [works in two modes](https://bugs.ruby-lang.org/issues/16977):
 
 1. If `super` is called from a method is directly in R, then we should search in `C` ancestors and ignore other active refinements.
-2. If `super` is called from a method placed in a module which included to R, then we should search overall active refinements (as we do for a regular lookup).
+2. If `super` is called from a method placed in a module which included to R, then we should search over all active refinements (as we do for a regular lookup).
 
 Additionally, `super` has access to the caller active refinements, so we use `InterlaMethod#activeRefinements` to keep and re-use necessary refinements.
 

spec/ruby/core/module/refine_spec.rb

@@ -841,7 +841,7 @@ def bar
         using refinement
         -> {
           refined_class.new.foo
-        }.should raise_error(NameError)
+        }.should raise_error(NameError) { |e| e.name.should == :bar }
       end
     end
 
@@ -861,22 +861,22 @@ def foo
         end
       end
 
-      refinement = Module.new do
+      refinement_a = Module.new do
         refine refined_class do
           include a
         end
       end
 
-      refinement1 = Module.new do
+      refinement_b = Module.new do
         refine refined_class do
           include b
         end
       end
 
       result = nil
       Module.new do
-        using refinement
-        using refinement1
+        using refinement_a
+        using refinement_b
         result = refined_class.new.foo
       end
 
@@ -906,7 +906,7 @@ def foo
         end
       end
 
-      refinement1 = Module.new do
+      refinement_a_b = Module.new do
         refine refined_class do
           include a
           include b
@@ -916,7 +916,7 @@ def foo
       result = nil
       Module.new do
         using refinement
-        using refinement1
+        using refinement_a_b
         result = refined_class.new.foo
       end
 

src/main/java/org/truffleruby/core/module/ModuleOperations.java

@@ -17,6 +17,7 @@
 
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
+import org.truffleruby.collections.Memo;
 import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.RubyConstant;
@@ -501,74 +502,76 @@ public static MethodLookupResult lookupSuperMethod(InternalMethod currentMethod,
 
         assert RubyGuards.isRubyModule(objectMetaClass);
         final String name = currentMethod.getSharedMethodInfo().getName(); // use the original name
+        Memo<Boolean> foundDeclaringModule = new Memo<>(false);
         return lookupSuperMethod(
                 currentMethod.getDeclaringModule(),
-                new SuperMethodLookup(null, false, null),
+                null,
                 name,
                 objectMetaClass,
-                declarationContext).getResult();
+                foundDeclaringModule,
+                declarationContext);
     }
 
 
     @TruffleBoundary
-    private static SuperMethodLookup lookupSuperMethod(DynamicObject declaringModule, SuperMethodLookup lookup,
-            String name, DynamicObject objectMetaClass, DeclarationContext declarationContext) {
+    private static MethodLookupResult lookupSuperMethod(DynamicObject declaringModule, DynamicObject lookupTo,
+            String name, DynamicObject objectMetaClass, Memo<Boolean> foundDeclaringModule,
+            DeclarationContext declarationContext) {
         assert RubyGuards.isRubyModule(declaringModule);
         assert RubyGuards.isRubyModule(objectMetaClass);
 
         final ArrayList<Assumption> assumptions = new ArrayList<>();
-        final DynamicObject lookupTo = lookup.getLookupTo();
         final boolean isRefinedMethod = Layouts.MODULE.getFields(declaringModule).isRefinement();
 
         for (DynamicObject ancestor : Layouts.MODULE.getFields(objectMetaClass).ancestors()) {
             if (ancestor == lookupTo) {
-                return lookup.withResult(new MethodLookupResult(null, toArray(assumptions)));
+                return new MethodLookupResult(null, toArray(assumptions));
             }
 
             final DynamicObject[] refinements = getRefinementsFor(declarationContext, ancestor);
 
             if (refinements != null) {
                 for (DynamicObject refinement : refinements) {
-                    lookup = lookupSuperMethod(
+                    final MethodLookupResult superMethodInRefinement = lookupSuperMethod(
                             declaringModule,
-                            lookup.withLookupTo(ancestor),
+                            ancestor,
                             name,
                             refinement,
+                            foundDeclaringModule,
                             null);
-                    final MethodLookupResult superMethodInRefinement = lookup.getResult();
                     for (Assumption assumption : superMethodInRefinement.getAssumptions()) {
                         assumptions.add(assumption);
                     }
                     if (superMethodInRefinement.isDefined()) {
                         InternalMethod method = superMethodInRefinement.getMethod();
-                        return lookup.withResult(new MethodLookupResult(
+                        return new MethodLookupResult(
                                 rememberUsedRefinements(method, declarationContext),
-                                toArray(assumptions)));
+                                toArray(assumptions));
                     }
-                    if (lookup.getFoundDeclaringModule() && isRefinedMethod) {
+                    if (foundDeclaringModule.get() && isRefinedMethod) {
                         // if method is defined in refinement module (R)
                         // we should lookup only in this active refinement and skip other
                         break;
                     }
                 }
             }
 
-            if (!lookup.getFoundDeclaringModule()) {
+            if (!foundDeclaringModule.get()) {
                 if (ancestor == declaringModule) {
-                    lookup = lookup.withFoundDeclaringModule(true);
+                    foundDeclaringModule.set(true);
                 }
             } else {
                 final ModuleFields fields = Layouts.MODULE.getFields(ancestor);
                 assumptions.add(fields.getMethodsUnmodifiedAssumption());
                 final InternalMethod method = fields.getMethod(name);
                 if (method != null) {
-                    return lookup.withResult(new MethodLookupResult(method, toArray(assumptions)));
+                    return new MethodLookupResult(method, toArray(assumptions));
                 }
             }
         }
 
         // Nothing found
-        return lookup.withResult(new MethodLookupResult(null, toArray(assumptions)));
+        return new MethodLookupResult(null, toArray(assumptions));
     }
 
     private static InternalMethod rememberUsedRefinements(InternalMethod method,