Rename to FinalAttributeAssumptionPair

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/attributes/LookupAttributeInMRONode.java

@@ -56,7 +56,6 @@
 import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.graal.python.runtime.exception.StacktracelessCheckedException;
 import com.oracle.graal.python.runtime.sequence.storage.MroSequenceStorage;
-import com.oracle.graal.python.runtime.sequence.storage.MroSequenceStorage.FinalAttributeAssumptionNode;
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -201,21 +200,21 @@ public MROChangedException(Object result) {
         }
     }
 
-    FinalAttributeAssumptionNode findAttrAndAssumptionInMRO(Object klass) throws MROChangedException {
+    MroSequenceStorage.FinalAttributeAssumptionPair findAttrAndAssumptionInMRO(Object klass) throws MROChangedException {
         CompilerAsserts.neverPartOfCompilation();
         // Regarding potential side effects to MRO caused by __eq__ of the keys in the dicts that we
         // search through: CPython seems to read the MRO once and then compute the result also
         // ignoring the side effects. Moreover, CPython has lookup cache, so the side effects
         // may or may not be visible during subsequent lookups. We want to avoid triggering the side
         // effects twice
         MroSequenceStorage mro = GetMroStorageNode.executeUncached(klass);
-        FinalAttributeAssumptionNode assumptionNode = mro.getFinalAttributeAssumption(key);
+        MroSequenceStorage.FinalAttributeAssumptionPair assumptionNode = mro.getFinalAttributeAssumption(key);
         if (assumptionNode != null) {
             return assumptionNode;
         }
         // Put a new assumption in place in case the MRO changes during the lookup
-        FinalAttributeAssumptionNode node = new FinalAttributeAssumptionNode();
-        mro.putFinalAttributeAssumption(key, node);
+        MroSequenceStorage.FinalAttributeAssumptionPair assumptionPair = new MroSequenceStorage.FinalAttributeAssumptionPair();
+        mro.putFinalAttributeAssumption(key, assumptionPair);
         Object result = PNone.NO_VALUE;
         for (int i = 0; i < mro.length(); i++) {
             PythonAbstractClass clsObj = mro.getPythonClassItemNormalized(i);
@@ -228,13 +227,13 @@ FinalAttributeAssumptionNode findAttrAndAssumptionInMRO(Object klass) throws MRO
                 break;
             }
         }
-        if (node.getAssumption() == null) {
+        if (assumptionPair.getAssumption() == null) {
             // MRO changed during lookup. To avoid reexecuting the side-effects, return via
             // exception. This should abort the specialization
             throw new MROChangedException(result);
         }
-        node.setValue(result);
-        return node;
+        assumptionPair.setValue(result);
+        return assumptionPair;
     }
 
     @Specialization(guards = {"isSingleContext()", "isSameTypeNode.execute(inliningTarget, cachedKlass, klass)", "cachedAttrInMROInfo.getAssumption() != null"}, //
@@ -244,7 +243,7 @@ static Object lookupConstantMROCached(Object klass,
                     @Bind Node inliningTarget,
                     @Cached("klass") Object cachedKlass,
                     @Cached IsSameTypeNode isSameTypeNode,
-                    @Cached("findAttrAndAssumptionInMRO(cachedKlass)") FinalAttributeAssumptionNode cachedAttrInMROInfo) {
+                    @Cached("findAttrAndAssumptionInMRO(cachedKlass)") MroSequenceStorage.FinalAttributeAssumptionPair cachedAttrInMROInfo) {
         return cachedAttrInMROInfo.getValue();
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/sequence/storage/MroSequenceStorage.java

@@ -67,13 +67,13 @@ public final class MroSequenceStorage extends ArrayBasedSequenceStorage {
      * These assumptions will be invalidated whenever the value of the given slot changes. All
      * assumptions will be invalidated if the mro changes.
      */
-    private Map<TruffleString, FinalAttributeAssumptionNode> attributesInMROFinalAssumptions;
+    private Map<TruffleString, FinalAttributeAssumptionPair> attributesInMROFinalAssumptions;
 
-    public static final class FinalAttributeAssumptionNode {
+    public static final class FinalAttributeAssumptionPair {
         @CompilationFinal private Assumption assumption;
         @CompilationFinal private Object value;
 
-        public FinalAttributeAssumptionNode() {
+        public FinalAttributeAssumptionPair() {
             this.assumption = Truffle.getRuntime().createAssumption("attribute in MRO final");
         }
 
@@ -182,36 +182,36 @@ public Assumption getLookupStableAssumption() {
         return lookupStableAssumption.getAssumption();
     }
 
-    public FinalAttributeAssumptionNode getFinalAttributeAssumption(TruffleString name) {
+    public FinalAttributeAssumptionPair getFinalAttributeAssumption(TruffleString name) {
         CompilerAsserts.neverPartOfCompilation();
         if (attributesInMROFinalAssumptions != null) {
             return attributesInMROFinalAssumptions.get(name);
         }
         return null;
     }
 
-    public void putFinalAttributeAssumption(TruffleString name, FinalAttributeAssumptionNode node) {
+    public void putFinalAttributeAssumption(TruffleString name, FinalAttributeAssumptionPair assumptionPair) {
         CompilerAsserts.neverPartOfCompilation();
         if (attributesInMROFinalAssumptions == null) {
             attributesInMROFinalAssumptions = new HashMap<>();
         }
         assert attributesInMROFinalAssumptions.get(name) == null;
-        attributesInMROFinalAssumptions.put(name, node);
+        attributesInMROFinalAssumptions.put(name, assumptionPair);
     }
 
     public void invalidateFinalAttributeAssumption(TruffleString name) {
         CompilerAsserts.neverPartOfCompilation();
-        FinalAttributeAssumptionNode node = getFinalAttributeAssumption(name);
-        if (node != null) {
-            node.invalidate();
+        FinalAttributeAssumptionPair assumptionPair = getFinalAttributeAssumption(name);
+        if (assumptionPair != null) {
+            assumptionPair.invalidate();
         }
     }
 
     public void lookupChanged() {
         CompilerAsserts.neverPartOfCompilation();
         if (attributesInMROFinalAssumptions != null) {
-            for (FinalAttributeAssumptionNode node : attributesInMROFinalAssumptions.values()) {
-                node.invalidate();
+            for (FinalAttributeAssumptionPair assumptionPair : attributesInMROFinalAssumptions.values()) {
+                assumptionPair.invalidate();
             }
         }
         lookupStableAssumption.invalidate();