diff --git a/src/core/lombok/core/AST.java b/src/core/lombok/core/AST.java
index e6721b80..6fed0252 100644
--- a/src/core/lombok/core/AST.java
+++ b/src/core/lombok/core/AST.java
@@ -174,7 +174,7 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 			oldChild.parent = targetNode;
 		}
 		
-		targetNode.children = ImmutableList.copyOf(children);
+		targetNode.children = LombokImmutableList.copyOf(children);
 		
 		return targetNode;
 	}
diff --git a/src/core/lombok/core/LombokNode.java b/src/core/lombok/core/LombokNode.java
index 30bacc56..07c62151 100644
--- a/src/core/lombok/core/LombokNode.java
+++ b/src/core/lombok/core/LombokNode.java
@@ -42,7 +42,7 @@ public abstract class LombokNode<A extends AST<A, L, N>, L extends LombokNode<A,
 	protected final A ast;
 	protected final Kind kind;
 	protected final N node;
-	protected ImmutableList<L> children;
+	protected LombokImmutableList<L> children;
 	protected L parent;
 	
 	/** structurally significant are those nodes that can be annotated in java 1.6 or are method-like toplevels,
@@ -62,7 +62,7 @@ public abstract class LombokNode<A extends AST<A, L, N>, L extends LombokNode<A,
 		this.ast = ast;
 		this.kind = kind;
 		this.node = node;
-		this.children = children != null ? ImmutableList.copyOf(children) : ImmutableList.<L>of();
+		this.children = children != null ? LombokImmutableList.copyOf(children) : LombokImmutableList.<L>of();
 		for (L child : this.children) {
 			child.parent = (L) this;
 			if (!child.isStructurallySignificant)
@@ -176,7 +176,7 @@ public abstract class LombokNode<A extends AST<A, L, N>, L extends LombokNode<A,
 	/**
 	 * Returns all children nodes.
 	 */
-	public ImmutableList<L> down() {
+	public LombokImmutableList<L> down() {
 		return children;
 	}
 	
@@ -253,7 +253,7 @@ public abstract class LombokNode<A extends AST<A, L, N>, L extends LombokNode<A,
 		for (LombokNode child : children) child.gatherAndRemoveChildren(map);
 		ast.identityDetector.remove(get());
 		map.put(get(), (L) this);
-		children = ImmutableList.of();
+		children = LombokImmutableList.of();
 		ast.getNodeMap().remove(get());
 	}
 	
diff --git a/src/core/lombok/eclipse/EclipseAST.java b/src/core/lombok/eclipse/EclipseAST.java
index eed3c0b6..370b40fc 100644
--- a/src/core/lombok/eclipse/EclipseAST.java
+++ b/src/core/lombok/eclipse/EclipseAST.java
@@ -31,7 +31,7 @@ import java.util.List;
 
 import lombok.Lombok;
 import lombok.core.AST;
-import lombok.core.ImmutableList;
+import lombok.core.LombokImmutableList;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -92,7 +92,7 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 	}
 	
 	void traverseChildren(EclipseASTVisitor visitor, EclipseNode node) {
-		ImmutableList<EclipseNode> children = node.down();
+		LombokImmutableList<EclipseNode> children = node.down();
 		int len = children.size();
 		for (int i = 0; i < len; i++) {
 			children.get(i).traverse(visitor);
diff --git a/src/utils/lombok/core/JavaIdentifiers.java b/src/utils/lombok/core/JavaIdentifiers.java
index dfec8815..cbe90eed 100644
--- a/src/utils/lombok/core/JavaIdentifiers.java
+++ b/src/utils/lombok/core/JavaIdentifiers.java
@@ -27,7 +27,7 @@ package lombok.core;
 public class JavaIdentifiers {
 	private JavaIdentifiers() {}
 	
-	private static final ImmutableList<String> KEYWORDS = ImmutableList.of(
+	private static final LombokImmutableList<String> KEYWORDS = LombokImmutableList.of(
 			"public", "private", "protected",
 			"default", "switch", "case",
 			"for", "do", "goto", "const", "strictfp", "while", "if", "else",
diff --git a/src/utils/lombok/core/ImmutableList.java b/src/utils/lombok/core/LombokImmutableList.java
similarity index 67%
rename from src/utils/lombok/core/ImmutableList.java
rename to src/utils/lombok/core/LombokImmutableList.java
index 8b478dbc..e0e1136c 100644
--- a/src/utils/lombok/core/ImmutableList.java
+++ b/src/utils/lombok/core/LombokImmutableList.java
@@ -28,36 +28,36 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
 
-public final class ImmutableList<T> implements Iterable<T> {
+public final class LombokImmutableList<T> implements Iterable<T> {
 	private Object[] content;
-	private static final ImmutableList<?> EMPTY = new ImmutableList<Object>(new Object[0]);
+	private static final LombokImmutableList<?> EMPTY = new LombokImmutableList<Object>(new Object[0]);
 	
 	@SuppressWarnings("unchecked")
-	public static <T> ImmutableList<T> of() {
-		return (ImmutableList<T>) EMPTY;
+	public static <T> LombokImmutableList<T> of() {
+		return (LombokImmutableList<T>) EMPTY;
 	}
 	
-	public static <T> ImmutableList<T> of(T a) {
-		return new ImmutableList<T>(new Object[] {a});
+	public static <T> LombokImmutableList<T> of(T a) {
+		return new LombokImmutableList<T>(new Object[] {a});
 	}
 	
-	public static <T> ImmutableList<T> of(T a, T b) {
-		return new ImmutableList<T>(new Object[] {a, b});
+	public static <T> LombokImmutableList<T> of(T a, T b) {
+		return new LombokImmutableList<T>(new Object[] {a, b});
 	}
 	
-	public static <T> ImmutableList<T> of(T a, T b, T c) {
-		return new ImmutableList<T>(new Object[] {a, b, c});
+	public static <T> LombokImmutableList<T> of(T a, T b, T c) {
+		return new LombokImmutableList<T>(new Object[] {a, b, c});
 	}
 	
-	public static <T> ImmutableList<T> of(T a, T b, T c, T d) {
-		return new ImmutableList<T>(new Object[] {a, b, c, d});
+	public static <T> LombokImmutableList<T> of(T a, T b, T c, T d) {
+		return new LombokImmutableList<T>(new Object[] {a, b, c, d});
 	}
 	
-	public static <T> ImmutableList<T> of(T a, T b, T c, T d, T e) {
-		return new ImmutableList<T>(new Object[] {a, b, c, d, e});
+	public static <T> LombokImmutableList<T> of(T a, T b, T c, T d, T e) {
+		return new LombokImmutableList<T>(new Object[] {a, b, c, d, e});
 	}
 	
-	public static <T> ImmutableList<T> of(T a, T b, T c, T d, T e, T f, T... g) {
+	public static <T> LombokImmutableList<T> of(T a, T b, T c, T d, T e, T f, T... g) {
 		Object[] rest = g == null ? new Object[] {null} : g;
 		Object[] val = new Object[rest.length + 6];
 		System.arraycopy(rest, 0, val, 6, rest.length);
@@ -67,43 +67,43 @@ public final class ImmutableList<T> implements Iterable<T> {
 		val[3] = d;
 		val[4] = e;
 		val[5] = f;
-		return new ImmutableList<T>(val);
+		return new LombokImmutableList<T>(val);
 	}
 	
-	public static <T> ImmutableList<T> copyOf(Collection<? extends T> list) {
-		return new ImmutableList<T>(list.toArray());
+	public static <T> LombokImmutableList<T> copyOf(Collection<? extends T> list) {
+		return new LombokImmutableList<T>(list.toArray());
 	}
 	
-	public static <T> ImmutableList<T> copyOf(Iterable<? extends T> iterable) {
+	public static <T> LombokImmutableList<T> copyOf(Iterable<? extends T> iterable) {
 		List<T> list = new ArrayList<T>();
 		for (T o : iterable) list.add(o);
 		return copyOf(list);
 	}
 	
-	private ImmutableList(Object[] content) {
+	private LombokImmutableList(Object[] content) {
 		this.content = content;
 	}
 	
-	public ImmutableList<T> replaceElementAt(int idx, T newValue) {
+	public LombokImmutableList<T> replaceElementAt(int idx, T newValue) {
 		Object[] newContent = content.clone();
 		newContent[idx] = newValue;
-		return new ImmutableList<T>(newContent);
+		return new LombokImmutableList<T>(newContent);
 	}
 	
-	public ImmutableList<T> append(T newValue) {
+	public LombokImmutableList<T> append(T newValue) {
 		int len = content.length;
 		Object[] newContent = new Object[len + 1];
 		System.arraycopy(content, 0, newContent, 0, len);
 		newContent[len] = newValue;
-		return new ImmutableList<T>(newContent);
+		return new LombokImmutableList<T>(newContent);
 	}
 	
-	public ImmutableList<T> prepend(T newValue) {
+	public LombokImmutableList<T> prepend(T newValue) {
 		int len = content.length;
 		Object[] newContent = new Object[len + 1];
 		System.arraycopy(content, 0, newContent, 1, len);
 		newContent[0] = newValue;
-		return new ImmutableList<T>(newContent);
+		return new LombokImmutableList<T>(newContent);
 	}
 	
 	public int indexOf(T val) {
@@ -117,17 +117,17 @@ public final class ImmutableList<T> implements Iterable<T> {
 		return -1;
 	}
 	
-	public ImmutableList<T> removeElement(T val) {
+	public LombokImmutableList<T> removeElement(T val) {
 		int idx = indexOf(val);
 		return idx == -1 ? this : removeElementAt(idx);
 	}
 	
-	public ImmutableList<T> removeElementAt(int idx) {
+	public LombokImmutableList<T> removeElementAt(int idx) {
 		int len = content.length;
 		Object[] newContent = new Object[len - 1];
 		if (idx > 0) System.arraycopy(content, 0, newContent, 0, idx);
 		if (idx < len - 1) System.arraycopy(content, idx + 1, newContent, idx, len - idx - 1);
-		return new ImmutableList<T>(newContent);
+		return new LombokImmutableList<T>(newContent);
 	}
 	
 	public boolean isEmpty() {
@@ -177,9 +177,9 @@ public final class ImmutableList<T> implements Iterable<T> {
 	}
 	
 	@Override public boolean equals(Object obj) {
-		if (!(obj instanceof ImmutableList)) return false;
+		if (!(obj instanceof LombokImmutableList)) return false;
 		if (obj == this) return true;
-		return Arrays.equals(content, ((ImmutableList<?>) obj).content);
+		return Arrays.equals(content, ((LombokImmutableList<?>) obj).content);
 	}
 	
 	@Override public int hashCode() {