diff --git a/config/src/main/java/com/typesafe/config/impl/MemoKey.java b/config/src/main/java/com/typesafe/config/impl/MemoKey.java
index 81f0ae7c..7237234f 100644
--- a/config/src/main/java/com/typesafe/config/impl/MemoKey.java
+++ b/config/src/main/java/com/typesafe/config/impl/MemoKey.java
@@ -10,10 +10,6 @@ final class MemoKey {
     final private AbstractConfigValue value;
     final private Path restrictToChildOrNull;
 
-    AbstractConfigValue value() {
-        return value;
-    }
-
     @Override
     public final int hashCode() {
         int h = System.identityHashCode(value);
diff --git a/config/src/main/java/com/typesafe/config/impl/ResolveContext.java b/config/src/main/java/com/typesafe/config/impl/ResolveContext.java
index 08af2f74..05a5d29e 100644
--- a/config/src/main/java/com/typesafe/config/impl/ResolveContext.java
+++ b/config/src/main/java/com/typesafe/config/impl/ResolveContext.java
@@ -161,9 +161,7 @@ final class ResolveContext {
         if (cached != null) {
             return cached;
         } else {
-            MemoKey key = restrictedKey != null ? restrictedKey : fullKey;
-
-            AbstractConfigValue resolved = source.resolveCheckingReplacement(this, key);
+            AbstractConfigValue resolved = source.resolveCheckingReplacement(this, original);
 
             if (resolved == null || resolved.resolveStatus() == ResolveStatus.RESOLVED) {
                 // if the resolved object is fully resolved by resolving
diff --git a/config/src/main/java/com/typesafe/config/impl/ResolveSource.java b/config/src/main/java/com/typesafe/config/impl/ResolveSource.java
index c9df7a92..ebba168d 100644
--- a/config/src/main/java/com/typesafe/config/impl/ResolveSource.java
+++ b/config/src/main/java/com/typesafe/config/impl/ResolveSource.java
@@ -1,6 +1,6 @@
 package com.typesafe.config.impl;
 
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.LinkedList;
 import java.util.Map;
 
@@ -18,11 +18,11 @@ final class ResolveSource {
     // traversed node and therefore avoid circular dependencies.
     // We implement it with this somewhat hacky "patch a replacement"
     // mechanism instead of actually transforming the tree.
-    final private Map<MemoKey, LinkedList<ResolveReplacer>> replacements;
+    final private Map<AbstractConfigValue, LinkedList<ResolveReplacer>> replacements;
 
     ResolveSource(AbstractConfigObject root) {
         this.root = root;
-        this.replacements = new HashMap<MemoKey, LinkedList<ResolveReplacer>>();
+        this.replacements = new IdentityHashMap<AbstractConfigValue, LinkedList<ResolveReplacer>>();
     }
 
     static private AbstractConfigValue findInObject(final AbstractConfigObject obj,
@@ -73,28 +73,26 @@ final class ResolveSource {
     }
 
     void replace(AbstractConfigValue value, ResolveReplacer replacer) {
-        MemoKey key = new MemoKey(value, null /* restrictToChild */);
-        LinkedList<ResolveReplacer> stack = replacements.get(key);
+        LinkedList<ResolveReplacer> stack = replacements.get(value);
         if (stack == null) {
             stack = new LinkedList<ResolveReplacer>();
-            replacements.put(key, stack);
+            replacements.put(value, stack);
         }
         stack.addFirst(replacer);
     }
 
     void unreplace(AbstractConfigValue value) {
-        MemoKey key = new MemoKey(value, null /* restrictToChild */);
-        LinkedList<ResolveReplacer> stack = replacements.get(key);
+        LinkedList<ResolveReplacer> stack = replacements.get(value);
         if (stack == null)
             throw new ConfigException.BugOrBroken("unreplace() without replace(): " + value);
 
         stack.removeFirst();
     }
 
-    private AbstractConfigValue replacement(MemoKey key) throws Undefined {
-        LinkedList<ResolveReplacer> stack = replacements.get(new MemoKey(key.value(), null));
+    private AbstractConfigValue replacement(AbstractConfigValue value) throws Undefined {
+        LinkedList<ResolveReplacer> stack = replacements.get(value);
         if (stack == null || stack.isEmpty())
-            return key.value();
+            return value;
         else
             return stack.peek().replace();
     }
@@ -103,14 +101,12 @@ final class ResolveSource {
      * Conceptually, this is key.value().resolveSubstitutions() but using the
      * replacement for key.value() if any.
      */
-    AbstractConfigValue resolveCheckingReplacement(ResolveContext context, MemoKey key)
-            throws NotPossibleToResolve {
-        AbstractConfigValue original = key.value();
-
+    AbstractConfigValue resolveCheckingReplacement(ResolveContext context,
+            AbstractConfigValue original) throws NotPossibleToResolve {
         AbstractConfigValue replacement;
         boolean forceUndefined = false;
         try {
-            replacement = replacement(key);
+            replacement = replacement(original);
         } catch (Undefined e) {
             replacement = original;
             forceUndefined = true;