remove Symbol.create, all callers use Symbol.intern #182

Signed-off-by: Stuart Halloway <stu@thinkrelevance.com>

5 files changed, 256 insertions, 264 deletions

diff --git a/src/jvm/clojure/lang/Compiler.java b/src/jvm/clojure/lang/Compiler.java
index 24cb9359..b1b4d84e 100644
--- a/src/jvm/clojure/lang/Compiler.java
+++ b/src/jvm/clojure/lang/Compiler.java
@@ -34,51 +34,51 @@ import java.lang.reflect.Modifier;
 
 public class Compiler implements Opcodes{
 
-static final Symbol DEF = Symbol.create("def");
-static final Symbol LOOP = Symbol.create("loop*");
-static final Symbol RECUR = Symbol.create("recur");
-static final Symbol IF = Symbol.create("if");
-static final Symbol LET = Symbol.create("let*");
-static final Symbol LETFN = Symbol.create("letfn*");
-static final Symbol DO = Symbol.create("do");
-static final Symbol FN = Symbol.create("fn*");
-static final Symbol QUOTE = Symbol.create("quote");
-static final Symbol THE_VAR = Symbol.create("var");
-static final Symbol DOT = Symbol.create(".");
-static final Symbol ASSIGN = Symbol.create("set!");
-//static final Symbol TRY_FINALLY = Symbol.create("try-finally");
-static final Symbol TRY = Symbol.create("try");
-static final Symbol CATCH = Symbol.create("catch");
-static final Symbol FINALLY = Symbol.create("finally");
-static final Symbol THROW = Symbol.create("throw");
-static final Symbol MONITOR_ENTER = Symbol.create("monitor-enter");
-static final Symbol MONITOR_EXIT = Symbol.create("monitor-exit");
-static final Symbol IMPORT = Symbol.create("clojure.core", "import*");
-//static final Symbol INSTANCE = Symbol.create("instance?");
-static final Symbol DEFTYPE = Symbol.create("deftype*");
-static final Symbol CASE = Symbol.create("case*");
-
-//static final Symbol THISFN = Symbol.create("thisfn");
-static final Symbol CLASS = Symbol.create("Class");
-static final Symbol NEW = Symbol.create("new");
-static final Symbol THIS = Symbol.create("this");
-static final Symbol REIFY = Symbol.create("reify*");
-//static final Symbol UNQUOTE = Symbol.create("unquote");
-//static final Symbol UNQUOTE_SPLICING = Symbol.create("unquote-splicing");
-//static final Symbol SYNTAX_QUOTE = Symbol.create("clojure.core", "syntax-quote");
-static final Symbol LIST = Symbol.create("clojure.core", "list");
-static final Symbol HASHMAP = Symbol.create("clojure.core", "hash-map");
-static final Symbol VECTOR = Symbol.create("clojure.core", "vector");
-static final Symbol IDENTITY = Symbol.create("clojure.core", "identity");
-
-static final Symbol _AMP_ = Symbol.create("&");
-static final Symbol ISEQ = Symbol.create("clojure.lang.ISeq");
+static final Symbol DEF = Symbol.intern("def");
+static final Symbol LOOP = Symbol.intern("loop*");
+static final Symbol RECUR = Symbol.intern("recur");
+static final Symbol IF = Symbol.intern("if");
+static final Symbol LET = Symbol.intern("let*");
+static final Symbol LETFN = Symbol.intern("letfn*");
+static final Symbol DO = Symbol.intern("do");
+static final Symbol FN = Symbol.intern("fn*");
+static final Symbol QUOTE = Symbol.intern("quote");
+static final Symbol THE_VAR = Symbol.intern("var");
+static final Symbol DOT = Symbol.intern(".");
+static final Symbol ASSIGN = Symbol.intern("set!");
+//static final Symbol TRY_FINALLY = Symbol.intern("try-finally");
+static final Symbol TRY = Symbol.intern("try");
+static final Symbol CATCH = Symbol.intern("catch");
+static final Symbol FINALLY = Symbol.intern("finally");
+static final Symbol THROW = Symbol.intern("throw");
+static final Symbol MONITOR_ENTER = Symbol.intern("monitor-enter");
+static final Symbol MONITOR_EXIT = Symbol.intern("monitor-exit");
+static final Symbol IMPORT = Symbol.intern("clojure.core", "import*");
+//static final Symbol INSTANCE = Symbol.intern("instance?");
+static final Symbol DEFTYPE = Symbol.intern("deftype*");
+static final Symbol CASE = Symbol.intern("case*");
+
+//static final Symbol THISFN = Symbol.intern("thisfn");
+static final Symbol CLASS = Symbol.intern("Class");
+static final Symbol NEW = Symbol.intern("new");
+static final Symbol THIS = Symbol.intern("this");
+static final Symbol REIFY = Symbol.intern("reify*");
+//static final Symbol UNQUOTE = Symbol.intern("unquote");
+//static final Symbol UNQUOTE_SPLICING = Symbol.intern("unquote-splicing");
+//static final Symbol SYNTAX_QUOTE = Symbol.intern("clojure.core", "syntax-quote");
+static final Symbol LIST = Symbol.intern("clojure.core", "list");
+static final Symbol HASHMAP = Symbol.intern("clojure.core", "hash-map");
+static final Symbol VECTOR = Symbol.intern("clojure.core", "vector");
+static final Symbol IDENTITY = Symbol.intern("clojure.core", "identity");
+
+static final Symbol _AMP_ = Symbol.intern("&");
+static final Symbol ISEQ = Symbol.intern("clojure.lang.ISeq");
 
 static final Keyword inlineKey = Keyword.intern(null, "inline");
 static final Keyword inlineAritiesKey = Keyword.intern(null, "inline-arities");
 static final Keyword staticKey = Keyword.intern(null, "static");
 static final Keyword arglistsKey = Keyword.intern(null, "arglists");
-static final Symbol INVOKE_STATIC = Symbol.create("invokeStatic");
+static final Symbol INVOKE_STATIC = Symbol.intern("invokeStatic");
 
 static final Keyword volatileKey = Keyword.intern(null, "volatile");
 static final Keyword implementsKey = Keyword.intern(null, "implements");
@@ -87,13 +87,13 @@ static final String COMPILE_STUB_PREFIX = "compile__stub";
 static final Keyword protocolKey = Keyword.intern(null, "protocol");
 static final Keyword onKey = Keyword.intern(null, "on");
 
-static final Symbol NS = Symbol.create("ns");
-static final Symbol IN_NS = Symbol.create("in-ns");
+static final Symbol NS = Symbol.intern("ns");
+static final Symbol IN_NS = Symbol.intern("in-ns");
 
-//static final Symbol IMPORT = Symbol.create("import");
-//static final Symbol USE = Symbol.create("use");
+//static final Symbol IMPORT = Symbol.intern("import");
+//static final Symbol USE = Symbol.intern("use");
 
-//static final Symbol IFN = Symbol.create("clojure.lang", "IFn");
+//static final Symbol IFN = Symbol.intern("clojure.lang", "IFn");
 
 static final public IPersistentMap specials = PersistentHashMap.create(
 		DEF, new DefExpr.Parser(),
@@ -213,25 +213,25 @@ static final public Var IN_CATCH_FINALLY = Var.create(null);
 static final public Var LOADER = Var.create();
 
 //String
-static final public Var SOURCE = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                            Symbol.create("*source-path*"), "NO_SOURCE_FILE");
+static final public Var SOURCE = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                            Symbol.intern("*source-path*"), "NO_SOURCE_FILE");
 
 //String
-static final public Var SOURCE_PATH = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                                 Symbol.create("*file*"), "NO_SOURCE_PATH");
+static final public Var SOURCE_PATH = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                                 Symbol.intern("*file*"), "NO_SOURCE_PATH");
 
 //String
-static final public Var COMPILE_PATH = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                                  Symbol.create("*compile-path*"), null);
+static final public Var COMPILE_PATH = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                                  Symbol.intern("*compile-path*"), null);
 //boolean
-static final public Var COMPILE_FILES = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                                   Symbol.create("*compile-files*"), Boolean.FALSE);
+static final public Var COMPILE_FILES = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                                   Symbol.intern("*compile-files*"), Boolean.FALSE);
 
-static final public Var INSTANCE = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                            Symbol.create("instance?"));
+static final public Var INSTANCE = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                            Symbol.intern("instance?"));
 
-static final public Var ADD_ANNOTATIONS = Var.intern(Namespace.findOrCreate(Symbol.create("clojure.core")),
-                                            Symbol.create("add-annotations"));
+static final public Var ADD_ANNOTATIONS = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                            Symbol.intern("add-annotations"));
 
 //Integer
 static final public Var LINE = Var.create(0);
@@ -305,7 +305,7 @@ static Symbol resolveSymbol(Symbol sym){
 		Namespace ns = namespaceFor(sym);
 		if(ns == null || ns.name.name == sym.ns)
 			return sym;
-		return Symbol.create(ns.name.name, sym.name);
+		return Symbol.intern(ns.name.name, sym.name);
 		}
 	Object o = currentNS().getMapping(sym);
 	if(o == null)
@@ -315,7 +315,7 @@ static Symbol resolveSymbol(Symbol sym){
 	else if(o instanceof Var)
 			{
 			Var v = (Var) o;
-			return Symbol.create(v.ns.name.name, v.sym.name);
+			return Symbol.intern(v.ns.name.name, v.sym.name);
 			}
 	return null;
 
@@ -331,7 +331,7 @@ static class DefExpr implements Expr{
 	final static Method bindRootMethod = Method.getMethod("void bindRoot(Object)");
 	final static Method setTagMethod = Method.getMethod("void setTag(clojure.lang.Symbol)");
 	final static Method setMetaMethod = Method.getMethod("void setMeta(clojure.lang.IPersistentMap)");
-	final static Method symcreate = Method.getMethod("clojure.lang.Symbol create(String, String)");
+	final static Method symintern = Method.getMethod("clojure.lang.Symbol intern(String, String)");
 
 	public DefExpr(String source, int line, Var var, Expr init, Expr meta, boolean initProvided){
 		this.source = source;
@@ -3610,7 +3610,7 @@ static public class ObjExpr implements Expr{
 	}
 
 	final static Method kwintern = Method.getMethod("clojure.lang.Keyword intern(String, String)");
-	final static Method symcreate = Method.getMethod("clojure.lang.Symbol create(String)");
+	final static Method symintern = Method.getMethod("clojure.lang.Symbol intern(String)");
 	final static Method varintern =
 			Method.getMethod("clojure.lang.Var intern(clojure.lang.Symbol, clojure.lang.Symbol)");
 
@@ -4093,7 +4093,7 @@ static public class ObjExpr implements Expr{
 			gen.push(((Symbol) value).ns);
 			gen.push(((Symbol) value).name);
 			gen.invokeStatic(Type.getType(Symbol.class),
-							 Method.getMethod("clojure.lang.Symbol create(String,String)"));
+							 Method.getMethod("clojure.lang.Symbol intern(String,String)"));
 			}
 		else if(value instanceof Keyword)
 			{
@@ -6148,7 +6148,7 @@ private static Expr analyzeSymbol(Symbol sym) throws Exception{
 		{
 		if(namespaceFor(sym) == null)
 			{
-			Symbol nsSym = Symbol.create(sym.ns);
+			Symbol nsSym = Symbol.intern(sym.ns);
 			Class c = HostExpr.maybeClass(nsSym, false);
 			if(c != null)
 				{
@@ -6209,7 +6209,7 @@ static Namespace namespaceFor(Symbol sym){
 static Namespace namespaceFor(Namespace inns, Symbol sym){
 	//note, presumes non-nil sym.ns
 	// first check against currentNS' aliases...
-	Symbol nsSym = Symbol.create(sym.ns);
+	Symbol nsSym = Symbol.intern(sym.ns);
 	Namespace ns = inns.lookupAlias(nsSym);
 	if(ns == null)
 		{
@@ -6227,7 +6227,7 @@ static public Object resolveIn(Namespace n, Symbol sym, boolean allowPrivate) th
 		if(ns == null)
 			throw new Exception("No such namespace: " + sym.ns);
 
-		Var v = ns.findInternedVar(Symbol.create(sym.name));
+		Var v = ns.findInternedVar(Symbol.intern(sym.name));
 		if(v == null)
 			throw new Exception("No such var: " + sym);
 		else if(v.ns != currentNS() && !v.isPublic() && !allowPrivate)
@@ -6270,7 +6270,7 @@ static public Object maybeResolveIn(Namespace n, Symbol sym) throws Exception{
 		Namespace ns = namespaceFor(n, sym);
 		if(ns == null)
 			return null;
-		Var v = ns.findInternedVar(Symbol.create(sym.name));
+		Var v = ns.findInternedVar(Symbol.intern(sym.name));
 		if(v == null)
 			return null;
 		return v;
@@ -6302,7 +6302,7 @@ static Var lookupVar(Symbol sym, boolean internNew) throws Exception{
 		if(ns == null)
 			return null;
 		//throw new Exception("No such namespace: " + sym.ns);
-		Symbol name = Symbol.create(sym.name);
+		Symbol name = Symbol.intern(sym.name);
 		if(internNew && ns == currentNS())
 			var = currentNS().intern(name);
 		else
@@ -6320,7 +6320,7 @@ static Var lookupVar(Symbol sym, boolean internNew) throws Exception{
 				{
 				//introduce a new var in the current ns
 				if(internNew)
-					var = currentNS().intern(Symbol.create(sym.name));
+					var = currentNS().intern(Symbol.intern(sym.name));
 				}
 			else if(o instanceof Var)
 				{
@@ -6478,8 +6478,8 @@ static public void writeClassFile(String internalName, byte[] bytecode) throws E
 }
 
 public static void pushNS(){
-	Var.pushThreadBindings(PersistentHashMap.create(Var.intern(Symbol.create("clojure.core"),
-	                                                           Symbol.create("*ns*")), null));
+	Var.pushThreadBindings(PersistentHashMap.create(Var.intern(Symbol.intern("clojure.core"),
+	                                                           Symbol.intern("*ns*")), null));
 }
 
 public static ILookupThunk getLookupThunk(Object target, Keyword k){
@@ -7124,7 +7124,7 @@ public static class NewInstanceMethod extends ObjMethod{
 				if(tag != null)
 					hinted = true;
 				if(p.getNamespace() != null)
-					p = Symbol.create(p.name);
+					p = Symbol.intern(p.name);
 				Class pclass = tagClass(tag);
 				pclasses[i] = pclass;
 				psyms[i] = p;
diff --git a/src/jvm/clojure/lang/LispReader.java b/src/jvm/clojure/lang/LispReader.java
index 91a854e7..35addd7c 100644
--- a/src/jvm/clojure/lang/LispReader.java
+++ b/src/jvm/clojure/lang/LispReader.java
@@ -22,22 +22,22 @@ import java.lang.*;
 
 public class LispReader{
 
-static final Symbol QUOTE = Symbol.create("quote");
-static final Symbol THE_VAR = Symbol.create("var");
-//static Symbol SYNTAX_QUOTE = Symbol.create(null, "syntax-quote");
-static Symbol UNQUOTE = Symbol.create("clojure.core", "unquote");
-static Symbol UNQUOTE_SPLICING = Symbol.create("clojure.core", "unquote-splicing");
-static Symbol CONCAT = Symbol.create("clojure.core", "concat");
-static Symbol SEQ = Symbol.create("clojure.core", "seq");
-static Symbol LIST = Symbol.create("clojure.core", "list");
-static Symbol APPLY = Symbol.create("clojure.core", "apply");
-static Symbol HASHMAP = Symbol.create("clojure.core", "hash-map");
-static Symbol HASHSET = Symbol.create("clojure.core", "hash-set");
-static Symbol VECTOR = Symbol.create("clojure.core", "vector");
-static Symbol WITH_META = Symbol.create("clojure.core", "with-meta");
-static Symbol META = Symbol.create("clojure.core", "meta");
-static Symbol DEREF = Symbol.create("clojure.core", "deref");
-//static Symbol DEREF_BANG = Symbol.create("clojure.core", "deref!");
+static final Symbol QUOTE = Symbol.intern("quote");
+static final Symbol THE_VAR = Symbol.intern("var");
+//static Symbol SYNTAX_QUOTE = Symbol.intern(null, "syntax-quote");
+static Symbol UNQUOTE = Symbol.intern("clojure.core", "unquote");
+static Symbol UNQUOTE_SPLICING = Symbol.intern("clojure.core", "unquote-splicing");
+static Symbol CONCAT = Symbol.intern("clojure.core", "concat");
+static Symbol SEQ = Symbol.intern("clojure.core", "seq");
+static Symbol LIST = Symbol.intern("clojure.core", "list");
+static Symbol APPLY = Symbol.intern("clojure.core", "apply");
+static Symbol HASHMAP = Symbol.intern("clojure.core", "hash-map");
+static Symbol HASHSET = Symbol.intern("clojure.core", "hash-set");
+static Symbol VECTOR = Symbol.intern("clojure.core", "vector");
+static Symbol WITH_META = Symbol.intern("clojure.core", "with-meta");
+static Symbol META = Symbol.intern("clojure.core", "meta");
+static Symbol DEREF = Symbol.intern("clojure.core", "deref");
+//static Symbol DEREF_BANG = Symbol.intern("clojure.core", "deref!");
 
 static IFn[] macros = new IFn[256];
 static IFn[] dispatchMacros = new IFn[256];
@@ -50,8 +50,8 @@ static Pattern intPat =
 				"([-+]?)(?:(0)|([1-9][0-9]*)|0[xX]([0-9A-Fa-f]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9A-Za-z]+)|0[0-9]+)(N)?");
 static Pattern ratioPat = Pattern.compile("([-+]?[0-9]+)/([0-9]+)");
 static Pattern floatPat = Pattern.compile("([-+]?[0-9]+(\\.[0-9]*)?([eE][-+]?[0-9]+)?)(M)?");
-static final Symbol SLASH = Symbol.create("/");
-static final Symbol CLOJURE_SLASH = Symbol.create("clojure.core","/");
+static final Symbol SLASH = Symbol.intern("/");
+static final Symbol CLOJURE_SLASH = Symbol.intern("clojure.core","/");
 //static Pattern accessorPat = Pattern.compile("\\.[a-zA-Z_]\\w*");
 //static Pattern instanceMemberPat = Pattern.compile("\\.([a-zA-Z_][\\w\\.]*)\\.([a-zA-Z_]\\w*)");
 //static Pattern staticMemberPat = Pattern.compile("([a-zA-Z_][\\w\\.]*)\\.([a-zA-Z_]\\w*)");
@@ -929,7 +929,7 @@ public static class ListReader extends AFn{
 }
 
 static class CtorReader extends AFn{
-	static final Symbol cls = Symbol.create("class");
+	static final Symbol cls = Symbol.intern("class");
 
 	public Object invoke(Object reader, Object leftangle) throws Exception{
 		PushbackReader r = (PushbackReader) reader;
diff --git a/src/jvm/clojure/lang/RT.java b/src/jvm/clojure/lang/RT.java
index c0d3e4ce..97abd85a 100644
--- a/src/jvm/clojure/lang/RT.java
+++ b/src/jvm/clojure/lang/RT.java
@@ -29,189 +29,189 @@ import java.nio.charset.Charset;
 
 public class RT{
 
-static final public Boolean T = Boolean.TRUE;//Keyword.intern(Symbol.create(null, "t"));
-static final public Boolean F = Boolean.FALSE;//Keyword.intern(Symbol.create(null, "t"));
+static final public Boolean T = Boolean.TRUE;//Keyword.intern(Symbol.intern(null, "t"));
+static final public Boolean F = Boolean.FALSE;//Keyword.intern(Symbol.intern(null, "t"));
 static final public String LOADER_SUFFIX = "__init";
 
 //simple-symbol->class
 final static IPersistentMap DEFAULT_IMPORTS = map(
-//												  Symbol.create("RT"), "clojure.lang.RT",
-//                                                  Symbol.create("Num"), "clojure.lang.Num",
-//                                                  Symbol.create("Symbol"), "clojure.lang.Symbol",
-//                                                  Symbol.create("Keyword"), "clojure.lang.Keyword",
-//                                                  Symbol.create("Var"), "clojure.lang.Var",
-//                                                  Symbol.create("Ref"), "clojure.lang.Ref",
-//                                                  Symbol.create("IFn"), "clojure.lang.IFn",
-//                                                  Symbol.create("IObj"), "clojure.lang.IObj",
-//                                                  Symbol.create("ISeq"), "clojure.lang.ISeq",
-//                                                  Symbol.create("IPersistentCollection"),
+//												  Symbol.intern("RT"), "clojure.lang.RT",
+//                                                  Symbol.intern("Num"), "clojure.lang.Num",
+//                                                  Symbol.intern("Symbol"), "clojure.lang.Symbol",
+//                                                  Symbol.intern("Keyword"), "clojure.lang.Keyword",
+//                                                  Symbol.intern("Var"), "clojure.lang.Var",
+//                                                  Symbol.intern("Ref"), "clojure.lang.Ref",
+//                                                  Symbol.intern("IFn"), "clojure.lang.IFn",
+//                                                  Symbol.intern("IObj"), "clojure.lang.IObj",
+//                                                  Symbol.intern("ISeq"), "clojure.lang.ISeq",
+//                                                  Symbol.intern("IPersistentCollection"),
 //                                                  "clojure.lang.IPersistentCollection",
-//                                                  Symbol.create("IPersistentMap"), "clojure.lang.IPersistentMap",
-//                                                  Symbol.create("IPersistentList"), "clojure.lang.IPersistentList",
-//                                                  Symbol.create("IPersistentVector"), "clojure.lang.IPersistentVector",
-Symbol.create("Boolean"), Boolean.class,
-Symbol.create("Byte"), Byte.class,
-Symbol.create("Character"), Character.class,
-Symbol.create("Class"), Class.class,
-Symbol.create("ClassLoader"), ClassLoader.class,
-Symbol.create("Compiler"), Compiler.class,
-Symbol.create("Double"), Double.class,
-Symbol.create("Enum"), Enum.class,
-Symbol.create("Float"), Float.class,
-Symbol.create("InheritableThreadLocal"), InheritableThreadLocal.class,
-Symbol.create("Integer"), Integer.class,
-Symbol.create("Long"), Long.class,
-Symbol.create("Math"), Math.class,
-Symbol.create("Number"), Number.class,
-Symbol.create("Object"), Object.class,
-Symbol.create("Package"), Package.class,
-Symbol.create("Process"), Process.class,
-Symbol.create("ProcessBuilder"), ProcessBuilder.class,
-Symbol.create("Runtime"), Runtime.class,
-Symbol.create("RuntimePermission"), RuntimePermission.class,
-Symbol.create("SecurityManager"), SecurityManager.class,
-Symbol.create("Short"), Short.class,
-Symbol.create("StackTraceElement"), StackTraceElement.class,
-Symbol.create("StrictMath"), StrictMath.class,
-Symbol.create("String"), String.class,
-Symbol.create("StringBuffer"), StringBuffer.class,
-Symbol.create("StringBuilder"), StringBuilder.class,
-Symbol.create("System"), System.class,
-Symbol.create("Thread"), Thread.class,
-Symbol.create("ThreadGroup"), ThreadGroup.class,
-Symbol.create("ThreadLocal"), ThreadLocal.class,
-Symbol.create("Throwable"), Throwable.class,
-Symbol.create("Void"), Void.class,
-Symbol.create("Appendable"), Appendable.class,
-Symbol.create("CharSequence"), CharSequence.class,
-Symbol.create("Cloneable"), Cloneable.class,
-Symbol.create("Comparable"), Comparable.class,
-Symbol.create("Iterable"), Iterable.class,
-Symbol.create("Readable"), Readable.class,
-Symbol.create("Runnable"), Runnable.class,
-Symbol.create("Callable"), Callable.class,
-Symbol.create("BigInteger"), BigInteger.class,
-Symbol.create("BigDecimal"), BigDecimal.class,
-Symbol.create("ArithmeticException"), ArithmeticException.class,
-Symbol.create("ArrayIndexOutOfBoundsException"), ArrayIndexOutOfBoundsException.class,
-Symbol.create("ArrayStoreException"), ArrayStoreException.class,
-Symbol.create("ClassCastException"), ClassCastException.class,
-Symbol.create("ClassNotFoundException"), ClassNotFoundException.class,
-Symbol.create("CloneNotSupportedException"), CloneNotSupportedException.class,
-Symbol.create("EnumConstantNotPresentException"), EnumConstantNotPresentException.class,
-Symbol.create("Exception"), Exception.class,
-Symbol.create("IllegalAccessException"), IllegalAccessException.class,
-Symbol.create("IllegalArgumentException"), IllegalArgumentException.class,
-Symbol.create("IllegalMonitorStateException"), IllegalMonitorStateException.class,
-Symbol.create("IllegalStateException"), IllegalStateException.class,
-Symbol.create("IllegalThreadStateException"), IllegalThreadStateException.class,
-Symbol.create("IndexOutOfBoundsException"), IndexOutOfBoundsException.class,
-Symbol.create("InstantiationException"), InstantiationException.class,
-Symbol.create("InterruptedException"), InterruptedException.class,
-Symbol.create("NegativeArraySizeException"), NegativeArraySizeException.class,
-Symbol.create("NoSuchFieldException"), NoSuchFieldException.class,
-Symbol.create("NoSuchMethodException"), NoSuchMethodException.class,
-Symbol.create("NullPointerException"), NullPointerException.class,
-Symbol.create("NumberFormatException"), NumberFormatException.class,
-Symbol.create("RuntimeException"), RuntimeException.class,
-Symbol.create("SecurityException"), SecurityException.class,
-Symbol.create("StringIndexOutOfBoundsException"), StringIndexOutOfBoundsException.class,
-Symbol.create("TypeNotPresentException"), TypeNotPresentException.class,
-Symbol.create("UnsupportedOperationException"), UnsupportedOperationException.class,
-Symbol.create("AbstractMethodError"), AbstractMethodError.class,
-Symbol.create("AssertionError"), AssertionError.class,
-Symbol.create("ClassCircularityError"), ClassCircularityError.class,
-Symbol.create("ClassFormatError"), ClassFormatError.class,
-Symbol.create("Error"), Error.class,
-Symbol.create("ExceptionInInitializerError"), ExceptionInInitializerError.class,
-Symbol.create("IllegalAccessError"), IllegalAccessError.class,
-Symbol.create("IncompatibleClassChangeError"), IncompatibleClassChangeError.class,
-Symbol.create("InstantiationError"), InstantiationError.class,
-Symbol.create("InternalError"), InternalError.class,
-Symbol.create("LinkageError"), LinkageError.class,
-Symbol.create("NoClassDefFoundError"), NoClassDefFoundError.class,
-Symbol.create("NoSuchFieldError"), NoSuchFieldError.class,
-Symbol.create("NoSuchMethodError"), NoSuchMethodError.class,
-Symbol.create("OutOfMemoryError"), OutOfMemoryError.class,
-Symbol.create("StackOverflowError"), StackOverflowError.class,
-Symbol.create("ThreadDeath"), ThreadDeath.class,
-Symbol.create("UnknownError"), UnknownError.class,
-Symbol.create("UnsatisfiedLinkError"), UnsatisfiedLinkError.class,
-Symbol.create("UnsupportedClassVersionError"), UnsupportedClassVersionError.class,
-Symbol.create("VerifyError"), VerifyError.class,
-Symbol.create("VirtualMachineError"), VirtualMachineError.class,
-Symbol.create("Thread$UncaughtExceptionHandler"), Thread.UncaughtExceptionHandler.class,
-Symbol.create("Thread$State"), Thread.State.class,
-Symbol.create("Deprecated"), Deprecated.class,
-Symbol.create("Override"), Override.class,
-Symbol.create("SuppressWarnings"), SuppressWarnings.class
-
-//                                                  Symbol.create("Collection"), "java.util.Collection",
-//                                                  Symbol.create("Comparator"), "java.util.Comparator",
-//                                                  Symbol.create("Enumeration"), "java.util.Enumeration",
-//                                                  Symbol.create("EventListener"), "java.util.EventListener",
-//                                                  Symbol.create("Formattable"), "java.util.Formattable",
-//                                                  Symbol.create("Iterator"), "java.util.Iterator",
-//                                                  Symbol.create("List"), "java.util.List",
-//                                                  Symbol.create("ListIterator"), "java.util.ListIterator",
-//                                                  Symbol.create("Map"), "java.util.Map",
-//                                                  Symbol.create("Map$Entry"), "java.util.Map$Entry",
-//                                                  Symbol.create("Observer"), "java.util.Observer",
-//                                                  Symbol.create("Queue"), "java.util.Queue",
-//                                                  Symbol.create("RandomAccess"), "java.util.RandomAccess",
-//                                                  Symbol.create("Set"), "java.util.Set",
-//                                                  Symbol.create("SortedMap"), "java.util.SortedMap",
-//                                                  Symbol.create("SortedSet"), "java.util.SortedSet"
+//                                                  Symbol.intern("IPersistentMap"), "clojure.lang.IPersistentMap",
+//                                                  Symbol.intern("IPersistentList"), "clojure.lang.IPersistentList",
+//                                                  Symbol.intern("IPersistentVector"), "clojure.lang.IPersistentVector",
+Symbol.intern("Boolean"), Boolean.class,
+Symbol.intern("Byte"), Byte.class,
+Symbol.intern("Character"), Character.class,
+Symbol.intern("Class"), Class.class,
+Symbol.intern("ClassLoader"), ClassLoader.class,
+Symbol.intern("Compiler"), Compiler.class,
+Symbol.intern("Double"), Double.class,
+Symbol.intern("Enum"), Enum.class,
+Symbol.intern("Float"), Float.class,
+Symbol.intern("InheritableThreadLocal"), InheritableThreadLocal.class,
+Symbol.intern("Integer"), Integer.class,
+Symbol.intern("Long"), Long.class,
+Symbol.intern("Math"), Math.class,
+Symbol.intern("Number"), Number.class,
+Symbol.intern("Object"), Object.class,
+Symbol.intern("Package"), Package.class,
+Symbol.intern("Process"), Process.class,
+Symbol.intern("ProcessBuilder"), ProcessBuilder.class,
+Symbol.intern("Runtime"), Runtime.class,
+Symbol.intern("RuntimePermission"), RuntimePermission.class,
+Symbol.intern("SecurityManager"), SecurityManager.class,
+Symbol.intern("Short"), Short.class,
+Symbol.intern("StackTraceElement"), StackTraceElement.class,
+Symbol.intern("StrictMath"), StrictMath.class,
+Symbol.intern("String"), String.class,
+Symbol.intern("StringBuffer"), StringBuffer.class,
+Symbol.intern("StringBuilder"), StringBuilder.class,
+Symbol.intern("System"), System.class,
+Symbol.intern("Thread"), Thread.class,
+Symbol.intern("ThreadGroup"), ThreadGroup.class,
+Symbol.intern("ThreadLocal"), ThreadLocal.class,
+Symbol.intern("Throwable"), Throwable.class,
+Symbol.intern("Void"), Void.class,
+Symbol.intern("Appendable"), Appendable.class,
+Symbol.intern("CharSequence"), CharSequence.class,
+Symbol.intern("Cloneable"), Cloneable.class,
+Symbol.intern("Comparable"), Comparable.class,
+Symbol.intern("Iterable"), Iterable.class,
+Symbol.intern("Readable"), Readable.class,
+Symbol.intern("Runnable"), Runnable.class,
+Symbol.intern("Callable"), Callable.class,
+Symbol.intern("BigInteger"), BigInteger.class,
+Symbol.intern("BigDecimal"), BigDecimal.class,
+Symbol.intern("ArithmeticException"), ArithmeticException.class,
+Symbol.intern("ArrayIndexOutOfBoundsException"), ArrayIndexOutOfBoundsException.class,
+Symbol.intern("ArrayStoreException"), ArrayStoreException.class,
+Symbol.intern("ClassCastException"), ClassCastException.class,
+Symbol.intern("ClassNotFoundException"), ClassNotFoundException.class,
+Symbol.intern("CloneNotSupportedException"), CloneNotSupportedException.class,
+Symbol.intern("EnumConstantNotPresentException"), EnumConstantNotPresentException.class,
+Symbol.intern("Exception"), Exception.class,
+Symbol.intern("IllegalAccessException"), IllegalAccessException.class,
+Symbol.intern("IllegalArgumentException"), IllegalArgumentException.class,
+Symbol.intern("IllegalMonitorStateException"), IllegalMonitorStateException.class,
+Symbol.intern("IllegalStateException"), IllegalStateException.class,
+Symbol.intern("IllegalThreadStateException"), IllegalThreadStateException.class,
+Symbol.intern("IndexOutOfBoundsException"), IndexOutOfBoundsException.class,
+Symbol.intern("InstantiationException"), InstantiationException.class,
+Symbol.intern("InterruptedException"), InterruptedException.class,
+Symbol.intern("NegativeArraySizeException"), NegativeArraySizeException.class,
+Symbol.intern("NoSuchFieldException"), NoSuchFieldException.class,
+Symbol.intern("NoSuchMethodException"), NoSuchMethodException.class,
+Symbol.intern("NullPointerException"), NullPointerException.class,
+Symbol.intern("NumberFormatException"), NumberFormatException.class,
+Symbol.intern("RuntimeException"), RuntimeException.class,
+Symbol.intern("SecurityException"), SecurityException.class,
+Symbol.intern("StringIndexOutOfBoundsException"), StringIndexOutOfBoundsException.class,
+Symbol.intern("TypeNotPresentException"), TypeNotPresentException.class,
+Symbol.intern("UnsupportedOperationException"), UnsupportedOperationException.class,
+Symbol.intern("AbstractMethodError"), AbstractMethodError.class,
+Symbol.intern("AssertionError"), AssertionError.class,
+Symbol.intern("ClassCircularityError"), ClassCircularityError.class,
+Symbol.intern("ClassFormatError"), ClassFormatError.class,
+Symbol.intern("Error"), Error.class,
+Symbol.intern("ExceptionInInitializerError"), ExceptionInInitializerError.class,
+Symbol.intern("IllegalAccessError"), IllegalAccessError.class,
+Symbol.intern("IncompatibleClassChangeError"), IncompatibleClassChangeError.class,
+Symbol.intern("InstantiationError"), InstantiationError.class,
+Symbol.intern("InternalError"), InternalError.class,
+Symbol.intern("LinkageError"), LinkageError.class,
+Symbol.intern("NoClassDefFoundError"), NoClassDefFoundError.class,
+Symbol.intern("NoSuchFieldError"), NoSuchFieldError.class,
+Symbol.intern("NoSuchMethodError"), NoSuchMethodError.class,
+Symbol.intern("OutOfMemoryError"), OutOfMemoryError.class,
+Symbol.intern("StackOverflowError"), StackOverflowError.class,
+Symbol.intern("ThreadDeath"), ThreadDeath.class,
+Symbol.intern("UnknownError"), UnknownError.class,
+Symbol.intern("UnsatisfiedLinkError"), UnsatisfiedLinkError.class,
+Symbol.intern("UnsupportedClassVersionError"), UnsupportedClassVersionError.class,
+Symbol.intern("VerifyError"), VerifyError.class,
+Symbol.intern("VirtualMachineError"), VirtualMachineError.class,
+Symbol.intern("Thread$UncaughtExceptionHandler"), Thread.UncaughtExceptionHandler.class,
+Symbol.intern("Thread$State"), Thread.State.class,
+Symbol.intern("Deprecated"), Deprecated.class,
+Symbol.intern("Override"), Override.class,
+Symbol.intern("SuppressWarnings"), SuppressWarnings.class
+
+//                                                  Symbol.intern("Collection"), "java.util.Collection",
+//                                                  Symbol.intern("Comparator"), "java.util.Comparator",
+//                                                  Symbol.intern("Enumeration"), "java.util.Enumeration",
+//                                                  Symbol.intern("EventListener"), "java.util.EventListener",
+//                                                  Symbol.intern("Formattable"), "java.util.Formattable",
+//                                                  Symbol.intern("Iterator"), "java.util.Iterator",
+//                                                  Symbol.intern("List"), "java.util.List",
+//                                                  Symbol.intern("ListIterator"), "java.util.ListIterator",
+//                                                  Symbol.intern("Map"), "java.util.Map",
+//                                                  Symbol.intern("Map$Entry"), "java.util.Map$Entry",
+//                                                  Symbol.intern("Observer"), "java.util.Observer",
+//                                                  Symbol.intern("Queue"), "java.util.Queue",
+//                                                  Symbol.intern("RandomAccess"), "java.util.RandomAccess",
+//                                                  Symbol.intern("Set"), "java.util.Set",
+//                                                  Symbol.intern("SortedMap"), "java.util.SortedMap",
+//                                                  Symbol.intern("SortedSet"), "java.util.SortedSet"
 );
 
 // single instance of UTF-8 Charset, so as to avoid catching UnsupportedCharsetExceptions everywhere
 static public Charset UTF8 = Charset.forName("UTF-8");
 
-static public final Namespace CLOJURE_NS = Namespace.findOrCreate(Symbol.create("clojure.core"));
-//static final Namespace USER_NS = Namespace.findOrCreate(Symbol.create("user"));
+static public final Namespace CLOJURE_NS = Namespace.findOrCreate(Symbol.intern("clojure.core"));
+//static final Namespace USER_NS = Namespace.findOrCreate(Symbol.intern("user"));
 final static public Var OUT =
-		Var.intern(CLOJURE_NS, Symbol.create("*out*"), new OutputStreamWriter(System.out));
+		Var.intern(CLOJURE_NS, Symbol.intern("*out*"), new OutputStreamWriter(System.out));
 final static public Var IN =
-		Var.intern(CLOJURE_NS, Symbol.create("*in*"),
+		Var.intern(CLOJURE_NS, Symbol.intern("*in*"),
 		           new LineNumberingPushbackReader(new InputStreamReader(System.in)));
 final static public Var ERR =
-		Var.intern(CLOJURE_NS, Symbol.create("*err*"),
+		Var.intern(CLOJURE_NS, Symbol.intern("*err*"),
 		           new PrintWriter(new OutputStreamWriter(System.err), true));
 final static Keyword TAG_KEY = Keyword.intern(null, "tag");
-final static public Var AGENT = Var.intern(CLOJURE_NS, Symbol.create("*agent*"), null);
-final static public Var READEVAL = Var.intern(CLOJURE_NS, Symbol.create("*read-eval*"), T);
-final static public Var ASSERT = Var.intern(CLOJURE_NS, Symbol.create("*assert*"), T);
-final static public Var MATH_CONTEXT = Var.intern(CLOJURE_NS, Symbol.create("*math-context*"), null);
+final static public Var AGENT = Var.intern(CLOJURE_NS, Symbol.intern("*agent*"), null);
+final static public Var READEVAL = Var.intern(CLOJURE_NS, Symbol.intern("*read-eval*"), T);
+final static public Var ASSERT = Var.intern(CLOJURE_NS, Symbol.intern("*assert*"), T);
+final static public Var MATH_CONTEXT = Var.intern(CLOJURE_NS, Symbol.intern("*math-context*"), null);
 static Keyword LINE_KEY = Keyword.intern(null, "line");
 static Keyword FILE_KEY = Keyword.intern(null, "file");
 static Keyword DECLARED_KEY = Keyword.intern(null, "declared");
 static Keyword DOC_KEY = Keyword.intern(null, "doc");
 final static public Var USE_CONTEXT_CLASSLOADER =
-		Var.intern(CLOJURE_NS, Symbol.create("*use-context-classloader*"), T);
-//final static public Var CURRENT_MODULE = Var.intern(Symbol.create("clojure.core", "current-module"),
+		Var.intern(CLOJURE_NS, Symbol.intern("*use-context-classloader*"), T);
+//final static public Var CURRENT_MODULE = Var.intern(Symbol.intern("clojure.core", "current-module"),
 //                                                    Module.findOrCreateModule("clojure/user"));
 
-final static Symbol LOAD_FILE = Symbol.create("load-file");
-final static Symbol IN_NAMESPACE = Symbol.create("in-ns");
-final static Symbol NAMESPACE = Symbol.create("ns");
-static final Symbol IDENTICAL = Symbol.create("identical?");
-final static Var CMD_LINE_ARGS = Var.intern(CLOJURE_NS, Symbol.create("*command-line-args*"), null);
+final static Symbol LOAD_FILE = Symbol.intern("load-file");
+final static Symbol IN_NAMESPACE = Symbol.intern("in-ns");
+final static Symbol NAMESPACE = Symbol.intern("ns");
+static final Symbol IDENTICAL = Symbol.intern("identical?");
+final static Var CMD_LINE_ARGS = Var.intern(CLOJURE_NS, Symbol.intern("*command-line-args*"), null);
 //symbol
-final public static Var CURRENT_NS = Var.intern(CLOJURE_NS, Symbol.create("*ns*"),
+final public static Var CURRENT_NS = Var.intern(CLOJURE_NS, Symbol.intern("*ns*"),
                                                 CLOJURE_NS);
 
-final static Var FLUSH_ON_NEWLINE = Var.intern(CLOJURE_NS, Symbol.create("*flush-on-newline*"), T);
-final static Var PRINT_META = Var.intern(CLOJURE_NS, Symbol.create("*print-meta*"), F);
-final static Var PRINT_READABLY = Var.intern(CLOJURE_NS, Symbol.create("*print-readably*"), T);
-final static Var PRINT_DUP = Var.intern(CLOJURE_NS, Symbol.create("*print-dup*"), F);
-final static Var WARN_ON_REFLECTION = Var.intern(CLOJURE_NS, Symbol.create("*warn-on-reflection*"), F);
-final static Var ALLOW_UNRESOLVED_VARS = Var.intern(CLOJURE_NS, Symbol.create("*allow-unresolved-vars*"), F);
-
-final static Var IN_NS_VAR = Var.intern(CLOJURE_NS, Symbol.create("in-ns"), F);
-final static Var NS_VAR = Var.intern(CLOJURE_NS, Symbol.create("ns"), F);
-static final Var PRINT_INITIALIZED = Var.intern(CLOJURE_NS, Symbol.create("print-initialized"));
-static final Var PR_ON = Var.intern(CLOJURE_NS, Symbol.create("pr-on"));
-//final static Var IMPORTS = Var.intern(CLOJURE_NS, Symbol.create("*imports*"), DEFAULT_IMPORTS);
+final static Var FLUSH_ON_NEWLINE = Var.intern(CLOJURE_NS, Symbol.intern("*flush-on-newline*"), T);
+final static Var PRINT_META = Var.intern(CLOJURE_NS, Symbol.intern("*print-meta*"), F);
+final static Var PRINT_READABLY = Var.intern(CLOJURE_NS, Symbol.intern("*print-readably*"), T);
+final static Var PRINT_DUP = Var.intern(CLOJURE_NS, Symbol.intern("*print-dup*"), F);
+final static Var WARN_ON_REFLECTION = Var.intern(CLOJURE_NS, Symbol.intern("*warn-on-reflection*"), F);
+final static Var ALLOW_UNRESOLVED_VARS = Var.intern(CLOJURE_NS, Symbol.intern("*allow-unresolved-vars*"), F);
+
+final static Var IN_NS_VAR = Var.intern(CLOJURE_NS, Symbol.intern("in-ns"), F);
+final static Var NS_VAR = Var.intern(CLOJURE_NS, Symbol.intern("ns"), F);
+static final Var PRINT_INITIALIZED = Var.intern(CLOJURE_NS, Symbol.intern("print-initialized"));
+static final Var PR_ON = Var.intern(CLOJURE_NS, Symbol.intern("pr-on"));
+//final static Var IMPORTS = Var.intern(CLOJURE_NS, Symbol.intern("*imports*"), DEFAULT_IMPORTS);
 final static IFn inNamespace = new AFn(){
 	public Object invoke(Object arg1) throws Exception{
 		Symbol nsname = (Symbol) arg1;
@@ -278,12 +278,12 @@ static public void addURL(Object url) throws Exception{
 
 static{
 	Keyword arglistskw = Keyword.intern(null, "arglists");
-	Symbol namesym = Symbol.create("name");
-	OUT.setTag(Symbol.create("java.io.Writer"));
-	CURRENT_NS.setTag(Symbol.create("clojure.lang.Namespace"));
+	Symbol namesym = Symbol.intern("name");
+	OUT.setTag(Symbol.intern("java.io.Writer"));
+	CURRENT_NS.setTag(Symbol.intern("clojure.lang.Namespace"));
 	AGENT.setMeta(map(DOC_KEY, "The agent currently running an action on this thread, else nil"));
-	AGENT.setTag(Symbol.create("clojure.lang.Agent"));
-	MATH_CONTEXT.setTag(Symbol.create("java.math.MathContext"));
+	AGENT.setTag(Symbol.intern("clojure.lang.Agent"));
+	MATH_CONTEXT.setTag(Symbol.intern("java.math.MathContext"));
 	Var nv = Var.intern(CLOJURE_NS, NAMESPACE, bootNamespace);
 	nv.