diff --git a/core/src/com/google/inject/internal/InternalContext.java b/core/src/com/google/inject/internal/InternalContext.java
index 2ff2af6..71d953c 100644
--- a/core/src/com/google/inject/internal/InternalContext.java
+++ b/core/src/com/google/inject/internal/InternalContext.java
@@ -17,12 +17,13 @@
 package com.google.inject.internal;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.inject.Key;
 import com.google.inject.spi.Dependency;
 import com.google.inject.spi.DependencyAndSource;
 
-import java.util.LinkedList;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -35,10 +36,18 @@
 final class InternalContext {
 
   private Map<Object, ConstructionContext<?>> constructionContexts = Maps.newHashMap();
+
   /** Keeps track of the type that is currently being requested for injection. */
-  private Dependency dependency;
-  /** Keeps track of the hierarchy of types needed during injection. */
-  private LinkedList<DependencyAndSource> state = new LinkedList<DependencyAndSource>();
+  private Dependency<?> dependency;
+
+  /**
+   * Keeps track of the hierarchy of types needed during injection.
+   *
+   * <p>This is a pairwise combination of dependencies and sources, with dependencies on even
+   * indices, and sources on odd indices. This structure is to avoid the memory overhead of
+   * DependencyAndSource objects, which can add to several tens of megabytes in large applications.
+   */
+  private final List<Object> state = Lists.newArrayList();
 
   @SuppressWarnings("unchecked")
   public <T> ConstructionContext<T> getConstructionContext(Object key) {
@@ -51,36 +60,44 @@
     return constructionContext;
   }
 
-  public Dependency getDependency() {
+  public Dependency<?> getDependency() {
     return dependency;
   }
 
   /** Sets the new current dependency & adds it to the state. */
-  public Dependency pushDependency(Dependency dependency, Object source) {
-    Dependency previous = this.dependency;
+  public Dependency<?> pushDependency(Dependency<?> dependency, Object source) {
+    Dependency<?> previous = this.dependency;
     this.dependency = dependency;
-    state.addLast(new DependencyAndSource(dependency, source));
+    state.add(dependency);
+    state.add(source);
     return previous;
   }
   
   /** Pops the current state & sets the new dependency. */
-  public void popStateAndSetDependency(Dependency newDependency) {
+  public void popStateAndSetDependency(Dependency<?> newDependency) {
     popState();
     this.dependency = newDependency;
   }
   
   /** Adds to the state without setting the dependency. */
   public void pushState(Key<?> key, Object source) {
-    state.addLast(new DependencyAndSource(key == null ? null : Dependency.get(key), source));
+    state.add(key == null ? null : Dependency.get(key));
+    state.add(source);
   }
   
   /** Pops from the state without setting a dependency. */
   public void popState() {
-    state.removeLast();
+    state.remove(state.size() - 1);
+    state.remove(state.size() - 1);
   }
   
   /** Returns the current dependency chain (all the state). */
   public List<DependencyAndSource> getDependencyChain() {
-    return ImmutableList.copyOf(state);
+    ImmutableList.Builder<DependencyAndSource> builder = ImmutableList.builder();
+    for (int i = 0; i < state.size(); i += 2) {
+      builder.add(new DependencyAndSource(
+          (Dependency<?>) state.get(i), state.get(i + 1)));
+    }
+    return builder.build();
   }
 }