diff --git a/src/main/java/com/mysema/codegen/AbstractCodeWriter.java b/src/main/java/com/mysema/codegen/AbstractCodeWriter.java
index cdaa9eb20..1cc68fc17 100644
--- a/src/main/java/com/mysema/codegen/AbstractCodeWriter.java
+++ b/src/main/java/com/mysema/codegen/AbstractCodeWriter.java
@@ -6,7 +6,6 @@
 package com.mysema.codegen;
 
 import static com.mysema.codegen.Symbols.NEWLINE;
-import static com.mysema.codegen.Symbols.SEMICOLON;
 
 import java.io.IOException;
 
diff --git a/src/main/java/com/mysema/codegen/CodeWriter.java b/src/main/java/com/mysema/codegen/CodeWriter.java
index 43da48775..2e6422f64 100644
--- a/src/main/java/com/mysema/codegen/CodeWriter.java
+++ b/src/main/java/com/mysema/codegen/CodeWriter.java
@@ -13,6 +13,7 @@ import javax.annotation.Nullable;
 
 import org.apache.commons.collections15.Transformer;
 
+import com.mysema.codegen.model.Parameter;
 import com.mysema.codegen.model.Type;
 
 /**
@@ -31,21 +32,21 @@ public interface CodeWriter extends Appendable{
 
     CodeWriter beginClass(Type type, @Nullable Type superClass, Type... interfaces) throws IOException;
 
-    <T> CodeWriter beginConstructor(Collection<T> params, Transformer<T, String> transformer) throws IOException;
+    <T> CodeWriter beginConstructor(Collection<T> params, Transformer<T, Parameter> transformer) throws IOException;
 
-    CodeWriter beginConstructor(String... params) throws IOException;
+    CodeWriter beginConstructor(Parameter... params) throws IOException;
 
     CodeWriter beginInterface(Type type, Type... interfaces) throws IOException;
 
     CodeWriter beginLine(String... segments) throws IOException;
 
-    <T> CodeWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException;
+    <T> CodeWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException;
 
-    CodeWriter beginPublicMethod(Type returnType, String methodName, String... args) throws IOException;
+    CodeWriter beginPublicMethod(Type returnType, String methodName, Parameter... args) throws IOException;
 
-    <T> CodeWriter beginStaticMethod(Type type, String name, Collection<T> params, Transformer<T, String> transformer) throws IOException;
+    <T> CodeWriter beginStaticMethod(Type type, String name, Collection<T> params, Transformer<T, Parameter> transformer) throws IOException;
 
-    CodeWriter beginStaticMethod(Type returnType, String methodName, String... args) throws IOException;
+    CodeWriter beginStaticMethod(Type returnType, String methodName, Parameter... args) throws IOException;
 
     CodeWriter end() throws IOException;
 
diff --git a/src/main/java/com/mysema/codegen/EvaluatorFactory.java b/src/main/java/com/mysema/codegen/EvaluatorFactory.java
index dd5908373..70f0b67af 100644
--- a/src/main/java/com/mysema/codegen/EvaluatorFactory.java
+++ b/src/main/java/com/mysema/codegen/EvaluatorFactory.java
@@ -24,6 +24,7 @@ import javax.tools.ToolProvider;
 import javax.tools.JavaCompiler.CompilationTask;
 
 import com.mysema.codegen.model.ClassType;
+import com.mysema.codegen.model.Parameter;
 import com.mysema.codegen.model.SimpleType;
 import com.mysema.codegen.model.Type;
 import com.mysema.codegen.model.TypeCategory;
@@ -59,8 +60,7 @@ public class EvaluatorFactory {
         this.loader = fileManager.getClassLoader(StandardLocation.CLASS_OUTPUT);
         this.compilationOptions = Arrays.asList("-classpath", classpath, "-g:none");
     }
-
-    @SuppressWarnings("unchecked")
+    
     private void compile(String source, Type projectionType,
             String[] names, Type[] types, String id, Map<String,Object> constants) throws IOException {
         // create source
@@ -68,9 +68,9 @@ public class EvaluatorFactory {
         JavaWriter javaw = new JavaWriter(writer);
         SimpleType idType = new SimpleType(id, "", id);
         javaw.beginClass(idType, null);
-        String[] params = new String[names.length];
+        Parameter[] params = new Parameter[names.length];
         for (int i = 0; i < params.length; i++) {
-            params[i] = types[i].getGenericName(true) + " " + names[i];
+            params[i] = new Parameter(names[i], types[i]);
         }
         
         for (Map.Entry<String,Object> entry : constants.entrySet()){
@@ -105,7 +105,6 @@ public class EvaluatorFactory {
 
     }
     
-    @SuppressWarnings("unchecked")
     public <T> Evaluator<T> createEvaluator(
             String source,
             Class<? extends T> projectionType, 
@@ -132,7 +131,7 @@ public class EvaluatorFactory {
      */
     public <T> Evaluator<T> createEvaluator(
                 String source,
-                ClassType<? extends T> projection, 
+                ClassType projection, 
                 String[] names, 
                 Type[] types,  
                 Class<?>[] classes,
@@ -156,7 +155,7 @@ public class EvaluatorFactory {
             }
 
             Method method = clazz.getMethod("eval", classes);
-            return new MethodEvaluator<T>(method, object, projection.getJavaClass());
+            return new MethodEvaluator<T>(method, object, (Class)projection.getJavaClass());
         } catch (ClassNotFoundException e) {
             throw new CodegenException(e);
         } catch (SecurityException e) {
diff --git a/src/main/java/com/mysema/codegen/JavaWriter.java b/src/main/java/com/mysema/codegen/JavaWriter.java
index c1347f44f..70f37f661 100644
--- a/src/main/java/com/mysema/codegen/JavaWriter.java
+++ b/src/main/java/com/mysema/codegen/JavaWriter.java
@@ -22,8 +22,8 @@ import java.util.Set;
 
 import org.apache.commons.collections15.Transformer;
 import org.apache.commons.lang.StringEscapeUtils;
-import org.apache.commons.lang.StringUtils;
 
+import com.mysema.codegen.model.Parameter;
 import com.mysema.codegen.model.Type;
 
 
@@ -67,15 +67,15 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
 
     private static final String PUBLIC_STATIC_FINAL = "public static final ";
     
-    private final Set<String> importedClasses = new HashSet<String>();
+    private final Set<String> classes = new HashSet<String>();
     
-    private final Set<String> importedPackages = new HashSet<String>();
+    private final Set<String> packages = new HashSet<String>();
     
     private Type type;
     
     public JavaWriter(Appendable appendable){
         super(appendable);
-        this.importedPackages.add("java.lang");
+        this.packages.add("java.lang");
     }
     
     @Override
@@ -148,7 +148,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
      }
     
     private JavaWriter appendType(Class<?> type) throws IOException{
-        if (importedClasses.contains(type.getName()) || importedPackages.contains(type.getPackage().getName())){
+        if (classes.contains(type.getName()) || packages.contains(type.getPackage().getName())){
             append(type.getSimpleName());
         }else{
             append(type.getName());
@@ -163,10 +163,10 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
     
     @Override
     public JavaWriter beginClass(Type type, Type superClass, Type... interfaces) throws IOException{
-        importedPackages.add(type.getPackageName());
+        packages.add(type.getPackageName());
         beginLine(PUBLIC_CLASS + type.getSimpleName());
         if (superClass != null){
-            append(EXTENDS + superClass.getGenericName(false, importedPackages, importedClasses));
+            append(EXTENDS + superClass.getGenericName(false, packages, classes));
         }
         if (interfaces.length > 0){
             append(IMPLEMENTS);
@@ -174,7 +174,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
                 if (i > 0){
                     append(COMMA);
                 }
-                append(interfaces[i].getGenericName(false, importedPackages, importedClasses));
+                append(interfaces[i].getGenericName(false, packages, classes));
             }
         }
         append(" {").nl().nl();
@@ -184,28 +184,28 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
     }
  
     @Override
-    public <T> JavaWriter beginConstructor(Collection<T> parameters, Transformer<T,String> transformer) throws IOException {
+    public <T> JavaWriter beginConstructor(Collection<T> parameters, Transformer<T,Parameter> transformer) throws IOException {
         beginLine(PUBLIC + type.getSimpleName()).params(parameters, transformer).append(" {").nl();
         return goIn();        
     }
     
     @Override
-    public JavaWriter beginConstructor(String... parameters) throws IOException{
+    public JavaWriter beginConstructor(Parameter... parameters) throws IOException{
         beginLine(PUBLIC + type.getSimpleName()).params(parameters).append(" {").nl();
         return goIn();
     }
     
     @Override
     public JavaWriter beginInterface(Type type, Type... interfaces) throws IOException {
-        importedPackages.add(type.getPackageName());
-        beginLine(PUBLIC_INTERFACE + type.getGenericName(false, importedPackages, importedClasses));
+        packages.add(type.getPackageName());
+        beginLine(PUBLIC_INTERFACE + type.getGenericName(false, packages, classes));
         if (interfaces.length > 0){
             append(EXTENDS);
             for (int i = 0; i < interfaces.length; i++){
                 if (i > 0){
                     append(COMMA);
                 }
-                append(interfaces[i].getGenericName(false, importedPackages, importedClasses));
+                append(interfaces[i].getGenericName(false, packages, classes));
             }
         }
         append(" {").nl().nl();
@@ -214,28 +214,28 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
         return this;        
     }
     
-    private JavaWriter beginMethod(String modifiers, Type returnType, String methodName, String... args) throws IOException{
-        beginLine(modifiers + returnType + SPACE + methodName).params(args).append(" {").nl();
+    private JavaWriter beginMethod(String modifiers, Type returnType, String methodName, Parameter... args) throws IOException{
+        beginLine(modifiers + returnType.getGenericName(true, packages, classes) + SPACE + methodName).params(args).append(" {").nl();
         return goIn();
     }
     
     @Override
-    public <T> JavaWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException {
+    public <T> JavaWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException {
         return beginMethod(PUBLIC, returnType, methodName, transform(parameters, transformer));
     }
 
     @Override
-    public JavaWriter beginPublicMethod(Type returnType, String methodName, String... args) throws IOException{
+    public JavaWriter beginPublicMethod(Type returnType, String methodName, Parameter... args) throws IOException{
         return beginMethod(PUBLIC, returnType, methodName, args);
     }
     
     @Override
-    public <T> JavaWriter beginStaticMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException {
+    public <T> JavaWriter beginStaticMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException {
         return beginMethod(PUBLIC_STATIC, returnType, methodName, transform(parameters, transformer));
     }
 
     @Override
-    public JavaWriter beginStaticMethod(Type returnType, String methodName, String... args) throws IOException{
+    public JavaWriter beginStaticMethod(Type returnType, String methodName, Parameter... args) throws IOException{
         return beginMethod(PUBLIC_STATIC, returnType, methodName, args);
     }
     
@@ -247,21 +247,21 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
  
     @Override
     public JavaWriter field(Type type, String name) throws IOException {
-        return line(type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + SEMICOLON).nl();
+        return line(type.getGenericName(true, packages, classes) + SPACE + name + SEMICOLON).nl();
     }
 
     private JavaWriter field(String modifier, Type type, String name) throws IOException{
-        return line(modifier + type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + SEMICOLON).nl();
+        return line(modifier + type.getGenericName(true, packages, classes) + SPACE + name + SEMICOLON).nl();
     }
     
     private JavaWriter field(String modifier, Type type, String name, String value) throws IOException{
-        return line(modifier + type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + ASSIGN + value + SEMICOLON).nl();
+        return line(modifier + type.getGenericName(true, packages, classes) + SPACE + name + ASSIGN + value + SEMICOLON).nl();
     }
 
     @Override
     public JavaWriter imports(Class<?>... imports) throws IOException{
         for (Class<?> cl : imports){
-            importedClasses.add(cl.getName());
+            classes.add(cl.getName());
             line(IMPORT + cl.getName() + SEMICOLON);
         }
         nl();
@@ -271,7 +271,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
     @Override
     public JavaWriter imports(Package... imports) throws IOException {
         for (Package p : imports){
-            importedPackages.add(p.getName());
+            packages.add(p.getName());
             line(IMPORT + p.getName() + ".*;");
         }
         nl();
@@ -281,7 +281,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
     @Override
     public JavaWriter importClasses(String... imports) throws IOException{
         for (String cl : imports){
-            importedClasses.add(cl);
+            classes.add(cl);
             line(IMPORT + cl + SEMICOLON);
         }
         nl();
@@ -291,7 +291,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
     @Override
     public JavaWriter importPackages(String... imports) throws IOException {
         for (String p : imports){
-            importedPackages.add(p);
+            packages.add(p);
             line(IMPORT + p + ".*;");
         }
         nl();
@@ -309,31 +309,43 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
 
     @Override
     public JavaWriter packageDecl(String packageName) throws IOException{
-        importedPackages.add(packageName);
+        packages.add(packageName);
         return line(PACKAGE + packageName + SEMICOLON).nl();
     }
     
-    private <T> JavaWriter params(Collection<T> parameters, Transformer<T,String> transformer) throws IOException{
+    private <T> JavaWriter params(Collection<T> parameters, Transformer<T,Parameter> transformer) throws IOException{
         append("(");
         boolean first = true;
         for (T param : parameters){
             if (!first){
                 append(COMMA);
             }
-            append(transformer.transform(param));
+            param(transformer.transform(param));
             first = false;
         }
         append(")");
         return this;
     }
 
-    private JavaWriter params(String... params) throws IOException{
+    private JavaWriter params(Parameter... params) throws IOException{
         append("(");
-        append(StringUtils.join(params, COMMA));
+        for (int i = 0; i < params.length; i++){
+            if (i > 0){
+                append(COMMA);
+            }
+            param(params[i]);
+        }
         append(")");
         return this;
     }
     
+    private JavaWriter param(Parameter parameter) throws IOException{
+        append(parameter.getType().getGenericName(true, packages, classes));
+        append(" ");
+        append(parameter.getName());
+        return this;
+    }
+    
     @Override
     public JavaWriter privateField(Type type, String name) throws IOException {
         return field(PRIVATE, type, name);
@@ -402,8 +414,8 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
         return line("@SuppressWarnings(\"" + type +"\")");
     }
 
-    private <T> String[] transform(Collection<T> parameters, Transformer<T,String> transformer){
-        String[] rv = new String[parameters.size()];
+    private <T> Parameter[] transform(Collection<T> parameters, Transformer<T,Parameter> transformer){
+        Parameter[] rv = new Parameter[parameters.size()];
         int i = 0; 
         for (T value : parameters){
             rv[i++] = transformer.transform(value);
diff --git a/src/main/java/com/mysema/codegen/model/ClassType.java b/src/main/java/com/mysema/codegen/model/ClassType.java
index 6be8581ea..8be21f914 100644
--- a/src/main/java/com/mysema/codegen/model/ClassType.java
+++ b/src/main/java/com/mysema/codegen/model/ClassType.java
@@ -23,57 +23,60 @@ import com.mysema.codegen.support.ClassUtils;
  * @param <T>
  */
 @Immutable
-public class ClassType<T> implements Type {
+public class ClassType implements Type {
 
     private final TypeCategory category;
     
-    private final Class<T> javaClass;
+    private final Class<?> javaClass;
     
     private final List<Type> parameters;
     
     @Nullable
     private final Class<?> primitiveClass;
     
+    private Type arrayType, componentType;
 
-    public ClassType(Class<T> javaClass) {
-        this(TypeCategory.SIMPLE, javaClass, null, Collections.<Type>emptyList());
+    public ClassType(Class<?> javaClass, Type... parameters) {
+        this(TypeCategory.SIMPLE, javaClass, null, Arrays.asList(parameters));
     }
     
-    public ClassType(TypeCategory category, Class<T> javaClass, List<Type> parameters) {
-        this(category, javaClass, null, parameters);
+    public ClassType(TypeCategory category, Class<?> javaClass, Class<?> primitiveClass) {
+        this(category, javaClass, primitiveClass, Collections.<Type>emptyList());
     }    
     
-    public ClassType(TypeCategory category, Class<T> clazz, Type... parameters) {
-        this(category, clazz, null, Arrays.asList(parameters));
-    }
-    
-    public ClassType(TypeCategory category, Class<T> javaClass, Class<?> primitiveClass) {
-        this(category, javaClass, primitiveClass, Collections.<Type>emptyList());
-    }
-        
-    public ClassType(TypeCategory category, Class<T> javaClass, @Nullable Class<?> primitiveClass, List<Type> parameters) {
+    public ClassType(TypeCategory category, Class<?> javaClass, @Nullable Class<?> primitiveClass, List<Type> parameters) {
         this.category = category;
         this.javaClass = javaClass;
         this.primitiveClass = primitiveClass;
         this.parameters = parameters;
     }
+    
+    public ClassType(TypeCategory category, Class<?> javaClass, List<Type> parameters) {
+        this(category, javaClass, null, parameters);
+    }
+        
+    public ClassType(TypeCategory category, Class<?> clazz, Type... parameters) {
+        this(category, clazz, null, Arrays.asList(parameters));
+    }
         
     @Override
     public Type as(TypeCategory c) {
         if (category == c){
             return this;
         }else{
-            return new ClassType<T>(c, javaClass);
+            return new ClassType(c, javaClass);
         }
     }
 
     @Override
     public Type asArrayType() {
-        String fullName = javaClass.getName()+"[]";
-        String simpleName = javaClass.getSimpleName()+"[]";
-        return new SimpleType(TypeCategory.ARRAY, fullName, getPackageName(), simpleName, false, false);
+        if (arrayType == null){
+            String fullName = javaClass.getName()+"[]";
+            String simpleName = javaClass.getSimpleName()+"[]";
+            arrayType = new SimpleType(TypeCategory.ARRAY, fullName, getPackageName(), simpleName, false, false);    
+        }
+        return arrayType;
     }
-    
 
     @Override
     public boolean equals(Object o){
@@ -86,11 +89,20 @@ public class ClassType<T> implements Type {
             return false;
         }
     }
-    
+
     public TypeCategory getCategory() {
         return category;
     }
     
+    @Override
+    public Type getComponentType() {
+        Class<?> clazz = javaClass.getComponentType();
+        if (clazz != null && componentType == null){
+            componentType = new ClassType(TypeCategory.SIMPLE, clazz);
+        }
+        return componentType;
+    }
+    
     @Override
     public String getFullName() {
         return javaClass.getName();
@@ -112,7 +124,7 @@ public class ClassType<T> implements Type {
             boolean first = true;
             for (Type parameter : parameters){                
                 if (!first){
-                    builder.append(",");
+                    builder.append(", ");
                 }
                 if (parameter == null || parameter.getFullName().equals(getFullName())){
                     builder.append("?");
@@ -126,13 +138,17 @@ public class ClassType<T> implements Type {
         }
     }
 
-    public Class<T> getJavaClass() {
+    public Class<?> getJavaClass() {
         return javaClass;
     }
 
     @Override
     public String getPackageName() {
-        return javaClass.getPackage().getName();
+        if (javaClass.getPackage() != null){
+            return javaClass.getPackage().getName();
+        }else{
+            return "";
+        }
     }
 
     @Override
@@ -154,17 +170,17 @@ public class ClassType<T> implements Type {
     public String getSimpleName() {
         return javaClass.getSimpleName();
     }
-    
+
     @Override
     public int hashCode(){
         return javaClass.getName().hashCode();
     }
-
+    
     @Override
     public boolean isFinal() {
         return Modifier.isFinal(javaClass.getModifiers());
     }
-    
+
     @Override
     public boolean isPrimitive() {
 //        return javaClass.isPrimitive();
diff --git a/src/main/java/com/mysema/codegen/model/SimpleType.java b/src/main/java/com/mysema/codegen/model/SimpleType.java
index 6bf784786..e19de05ad 100644
--- a/src/main/java/com/mysema/codegen/model/SimpleType.java
+++ b/src/main/java/com/mysema/codegen/model/SimpleType.java
@@ -26,19 +26,21 @@ public class SimpleType implements Type {
     private final List<Type> parameters;
     
     private final boolean primitiveClass, finalClass;
-
-    public SimpleType(Type type, Type... parameters) {
-        this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(), 
-            type.isPrimitive(), type.isFinal(), Arrays.asList(parameters));
-    }
     
+    private Type arrayType, componentType;
+
     public SimpleType(String fullName, String packageName, String simpleName, Type... parameters) {
         this(TypeCategory.SIMPLE, fullName, packageName, simpleName, false, false, Arrays.asList(parameters));
     }
     
-    public SimpleType(TypeCategory typeCategory, String fullName, String packageName, String simpleName, boolean p, boolean f, Type... parameters) {
-        this(typeCategory, fullName, packageName, simpleName, p, f, Arrays
-                .asList(parameters));
+    public SimpleType(Type type, List<Type> parameters) {
+        this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(), 
+            type.isPrimitive(), type.isFinal(), parameters);
+    }
+    
+    public SimpleType(Type type, Type... parameters) {
+        this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(), 
+            type.isPrimitive(), type.isFinal(), Arrays.asList(parameters));
     }
     
     public SimpleType(TypeCategory category, String fullName, String packageName, String simpleName, 
@@ -56,6 +58,11 @@ public class SimpleType implements Type {
         this.finalClass = finalClass;
         this.parameters = parameters;
     }
+    
+    public SimpleType(TypeCategory typeCategory, String fullName, String packageName, String simpleName, boolean p, boolean f, Type... parameters) {
+        this(typeCategory, fullName, packageName, simpleName, p, f, Arrays
+                .asList(parameters));
+    }
 
     @Override
     public Type as(TypeCategory c) {
@@ -68,11 +75,13 @@ public class SimpleType implements Type {
     
     @Override
     public Type asArrayType() {
-        String newFullName = getFullName()+"[]";
-        String newSimpleName = getSimpleName()+"[]";
-        return new SimpleType(TypeCategory.ARRAY, newFullName, getPackageName(), newSimpleName, false, false);
+        if (arrayType == null){
+            String newFullName = getFullName()+"[]";
+            String newSimpleName = getSimpleName()+"[]";
+            arrayType = new SimpleType(TypeCategory.ARRAY, newFullName, getPackageName(), newSimpleName, false, false);    
+        }
+        return arrayType;
     }
-    
 
     @Override
     public boolean equals(Object o){
@@ -85,11 +94,25 @@ public class SimpleType implements Type {
             return false;
         }
     }
-    
+
     public TypeCategory getCategory() {
         return category;
     }
     
+    @Override
+    public Type getComponentType() {
+        if (fullName.endsWith("[]")){
+            if (componentType == null){
+                String newFullName = fullName.substring(0, fullName.length()-2);
+                String newSimpleName = simpleName.substring(0, simpleName.length()-2);
+                componentType = new SimpleType(TypeCategory.SIMPLE, newFullName, getPackageName(), newSimpleName, false, false);    
+            }
+            return componentType;
+        }else{
+            return null;
+        }        
+    }
+    
     @Override
     public String getFullName() {
         return fullName;
@@ -111,7 +134,7 @@ public class SimpleType implements Type {
             boolean first = true;
             for (Type parameter : parameters){                
                 if (!first){
-                    builder.append(",");
+                    builder.append(", ");
                 }
                 if (parameter == null || parameter.getFullName().equals(fullName)){
                     builder.append("?");
@@ -153,7 +176,7 @@ public class SimpleType implements Type {
     public String getSimpleName() {
         return simpleName;
     }
-
+    
     @Override
     public int hashCode(){
         return fullName.hashCode();
@@ -168,9 +191,10 @@ public class SimpleType implements Type {
     public boolean isPrimitive() {
         return primitiveClass;
     }
-    
+
     public String toString(){
         return getGenericName(true);
     }
+
     
 }
diff --git a/src/main/java/com/mysema/codegen/model/Type.java b/src/main/java/com/mysema/codegen/model/Type.java
index 72f6382bc..a3b211f72 100644
--- a/src/main/java/com/mysema/codegen/model/Type.java
+++ b/src/main/java/com/mysema/codegen/model/Type.java
@@ -19,6 +19,9 @@ public interface Type {
     
     Type asArrayType();
     
+    @Nullable
+    Type getComponentType();
+    
     TypeCategory getCategory();
     
     String getFullName();
diff --git a/src/main/java/com/mysema/codegen/model/TypeAdapter.java b/src/main/java/com/mysema/codegen/model/TypeAdapter.java
index 8888f121a..e06b6a33b 100644
--- a/src/main/java/com/mysema/codegen/model/TypeAdapter.java
+++ b/src/main/java/com/mysema/codegen/model/TypeAdapter.java
@@ -35,6 +35,11 @@ public class TypeAdapter implements Type{
         return type.asArrayType();
     }
 
+    @Override
+    public Type getComponentType() {
+        return type.getComponentType();
+    }
+
     @Override
     public boolean equals(Object o){
         return type.equals(o);
diff --git a/src/main/java/com/mysema/codegen/model/Types.java b/src/main/java/com/mysema/codegen/model/Types.java
index 2186ece5e..4fdc4aeb7 100644
--- a/src/main/java/com/mysema/codegen/model/Types.java
+++ b/src/main/java/com/mysema/codegen/model/Types.java
@@ -18,50 +18,63 @@ import java.util.Set;
  * @author tiwe
  *
  */
-@SuppressWarnings("unchecked")
 public final class Types {
     
-    public static final ClassType<Object> OBJECT = new ClassType<Object>(TypeCategory.SIMPLE,Object.class);
+    public static final ClassType OBJECT = new ClassType(TypeCategory.SIMPLE, Object.class);
     
-    public static final ClassType<Object[]> OBJECTS = new ClassType<Object[]>(TypeCategory.ARRAY,Object[].class);    
+    public static final ClassType OBJECTS = new ClassType(TypeCategory.ARRAY, Object[].class);    
     
-    public static final ClassType<BigDecimal> BIG_DECIMAL = new ClassType<BigDecimal>(TypeCategory.NUMERIC,BigDecimal.class);
+    public static final ClassType BIG_DECIMAL = new ClassType(TypeCategory.NUMERIC, BigDecimal.class);
     
-    public static final ClassType<BigInteger> BIG_INTEGER = new ClassType<BigInteger>(TypeCategory.NUMERIC,BigInteger.class);
+    public static final ClassType BIG_INTEGER = new ClassType(TypeCategory.NUMERIC, BigInteger.class);
         
-    public static final ClassType<Boolean> BOOLEAN = new ClassType<Boolean>(TypeCategory.BOOLEAN,Boolean.class, boolean.class);
+    public static final ClassType BOOLEAN = new ClassType(TypeCategory.BOOLEAN, Boolean.class, boolean.class);
     
-    public static final ClassType<Byte> BYTE = new ClassType<Byte>(TypeCategory.NUMERIC,Byte.class, byte.class);
+    public static final ClassType BOOLEAN_P = new ClassType(TypeCategory.BOOLEAN, boolean.class);
     
-    public static final ClassType<Character> CHAR = new ClassType<Character>(TypeCategory.COMPARABLE,Character.class, char.class);
-
-    public static final ClassType<Collection> COLLECTION = new ClassType<Collection>(TypeCategory.COLLECTION, Collection.class, OBJECT);
+    public static final ClassType BYTE = new ClassType(TypeCategory.NUMERIC, Byte.class, byte.class);
     
-    public static final ClassType<Double> DOUBLE = new ClassType<Double>(TypeCategory.NUMERIC,Double.class, double.class);
+    public static final ClassType BYTE_P = new ClassType(TypeCategory.NUMERIC, byte.class);
+    
+    public static final ClassType CHARACTER = new ClassType(TypeCategory.COMPARABLE, Character.class, char.class);
+    
+    public static final ClassType CHAR = new ClassType(TypeCategory.COMPARABLE, char.class);
 
-    public static final ClassType<Float> FLOAT = new ClassType<Float>(TypeCategory.NUMERIC,Float.class, float.class);
+    public static final ClassType COLLECTION = new ClassType(TypeCategory.COLLECTION, Collection.class, OBJECT);
+    
+    public static final ClassType DOUBLE = new ClassType(TypeCategory.NUMERIC, Double.class, double.class);
+    
+    public static final ClassType DOUBLE_P = new ClassType(TypeCategory.NUMERIC, double.class);
 
-    public static final ClassType<Integer> INT = new ClassType<Integer>(TypeCategory.NUMERIC,Integer.class, int.class);
+    public static final ClassType FLOAT = new ClassType(TypeCategory.NUMERIC, Float.class, float.class);
 
-    public static final ClassType<Iterable> ITERABLE = new ClassType<Iterable>(TypeCategory.SIMPLE, Iterable.class, OBJECT);
+    public static final ClassType INTEGER = new ClassType(TypeCategory.NUMERIC, Integer.class);
+    
+    public static final ClassType INT = new ClassType(TypeCategory.NUMERIC, int.class);
 
-    public static final ClassType<List> LIST = new ClassType<List>(TypeCategory.LIST, List.class, OBJECT);
+    public static final ClassType ITERABLE = new ClassType(TypeCategory.SIMPLE, Iterable.class, OBJECT);
 
-    public static final ClassType<Locale> LOCALE = new ClassType<Locale>(TypeCategory.SIMPLE, Locale.class);
+    public static final ClassType LIST = new ClassType(TypeCategory.LIST, List.class, OBJECT);
 
-    public static final ClassType<Long> LONG = new ClassType<Long>(TypeCategory.NUMERIC,Long.class, long.class);
+    public static final ClassType LOCALE = new ClassType(TypeCategory.SIMPLE, Locale.class);
+
+    public static final ClassType LONG = new ClassType(TypeCategory.NUMERIC, Long.class, long.class);
+    
+    public static final ClassType LONG_P = new ClassType(TypeCategory.NUMERIC, long.class);
             
-    public static final ClassType<Map> MAP = new ClassType<Map>(TypeCategory.MAP, Map.class, OBJECT, OBJECT);
+    public static final ClassType MAP = new ClassType(TypeCategory.MAP, Map.class, OBJECT, OBJECT);
         
-    public static final ClassType<Set> SET = new ClassType<Set>(TypeCategory.SET, Set.class, OBJECT);
+    public static final ClassType SET = new ClassType(TypeCategory.SET, Set.class, OBJECT);
     
-    public static final ClassType<Short> SHORT = new ClassType<Short>(TypeCategory.NUMERIC,Short.class, short.class);
+    public static final ClassType SHORT = new ClassType(TypeCategory.NUMERIC, Short.class, short.class);
     
-    public static final ClassType<String> STRING = new ClassType<String>(TypeCategory.STRING,String.class);
+    public static final ClassType SHORT_P = new ClassType(TypeCategory.NUMERIC, short.class);
     
-    public static final ClassType<URI> URI = new ClassType<URI>(TypeCategory.COMPARABLE,URI.class);
+    public static final ClassType STRING = new ClassType(TypeCategory.STRING, String.class);
     
-    public static final ClassType<Void> VOID = new ClassType<Void>(TypeCategory.SIMPLE, void.class);
+    public static final ClassType URI = new ClassType(TypeCategory.COMPARABLE, URI.class);
+    
+    public static final ClassType VOID = new ClassType(TypeCategory.SIMPLE, void.class);
     
     public static final SimpleType DATE_TIME = new SimpleType(TypeCategory.DATETIME, "org.joda.time.DateTime", "org.joda.time", "DateTime", false, false);
 
diff --git a/src/test/java/com/mysema/codegen/ComplexEvaluationTest.java b/src/test/java/com/mysema/codegen/ComplexEvaluationTest.java
index 2c05a7ecd..a112cd31d 100644
--- a/src/test/java/com/mysema/codegen/ComplexEvaluationTest.java
+++ b/src/test/java/com/mysema/codegen/ComplexEvaluationTest.java
@@ -17,6 +17,7 @@ import org.junit.Test;
 import com.mysema.codegen.model.ClassType;
 import com.mysema.codegen.model.Type;
 import com.mysema.codegen.model.TypeCategory;
+import com.mysema.codegen.model.Types;
 
 
 public class ComplexEvaluationTest {
@@ -25,8 +26,8 @@ public class ComplexEvaluationTest {
     
     @Test
     @SuppressWarnings("unchecked")
-    public void testComplex(){ClassType<String> stringType = new ClassType<String>(TypeCategory.STRING,String.class);
-        ClassType<List> resultType = new ClassType<List>(TypeCategory.LIST,List.class, stringType);
+    public void testComplex(){
+        ClassType resultType = new ClassType(TypeCategory.LIST,List.class, Types.STRING);
         StringBuilder source = new StringBuilder();
         source.append("java.util.List<String> rv = new java.util.ArrayList<String>();\n");
         source.append("for (String a : a_){\n");
diff --git a/src/test/java/com/mysema/codegen/JavaWriterTest.java b/src/test/java/com/mysema/codegen/JavaWriterTest.java
index ffeeca3f5..d24f659d7 100644
--- a/src/test/java/com/mysema/codegen/JavaWriterTest.java
+++ b/src/test/java/com/mysema/codegen/JavaWriterTest.java
@@ -18,16 +18,17 @@ import org.junit.Before;
 import org.junit.Test;
 
 import com.mysema.codegen.model.ClassType;
+import com.mysema.codegen.model.Parameter;
 import com.mysema.codegen.model.SimpleType;
 import com.mysema.codegen.model.Type;
 import com.mysema.codegen.model.Types;
 
 public class JavaWriterTest {
-    
-    private static final Transformer<String,String> transformer = new Transformer<String,String>(){
-	@Override
-        public String transform(String input) {
-	    return input;
+
+    private static final Transformer<Parameter,Parameter> transformer = new Transformer<Parameter,Parameter>(){
+        @Override
+        public Parameter transform(Parameter input) {
+            return input;
         }	
     };
     
@@ -48,7 +49,7 @@ public class JavaWriterTest {
     public void setUp(){
         w = new StringWriter();
         writer = new JavaWriter(w);
-        testType = new ClassType<JavaWriterTest>(JavaWriterTest.class);
+        testType = new ClassType(JavaWriterTest.class);
         testType2 = new SimpleType("com.mysema.codegen.Test","com.mysema.codegen","Test");
         testSuperType = new SimpleType("com.mysema.codegen.Superclass","com.mysema.codegen","Superclass");
         testInterface1 = new SimpleType("com.mysema.codegen.TestInterface1","com.mysema.codegen","TestInterface1");
@@ -189,11 +190,11 @@ public class JavaWriterTest {
         // method
         
         // public
-        writer.beginPublicMethod(Types.STRING, "publicMethod", Arrays.asList("String a"), transformer);
+        writer.beginPublicMethod(Types.STRING, "publicMethod", Arrays.asList(new Parameter("a", Types.STRING)), transformer);
         writer.line("return null;");
         writer.end();
         
-        writer.beginStaticMethod(Types.STRING, "staticMethod", Arrays.asList("String a"), transformer);
+        writer.beginStaticMethod(Types.STRING, "staticMethod", Arrays.asList(new Parameter("a", Types.STRING)), transformer);
         writer.line("return null;");
         writer.end();
         
@@ -206,10 +207,10 @@ public class JavaWriterTest {
     public void testConstructors() throws IOException{
 	writer.beginClass(testType);
 	
-	writer.beginConstructor(Arrays.asList("String a","String b"), transformer);
+	writer.beginConstructor(Arrays.asList(new Parameter("a", Types.STRING), new Parameter("b", Types.STRING)), transformer);
 	writer.end();
 	
-	writer.beginConstructor("String a");
+	writer.beginConstructor(new Parameter("a", Types.STRING));
 	writer.end();
 	
 	writer.end();
diff --git a/src/test/java/com/mysema/codegen/model/ClassTypeTest.java b/src/test/java/com/mysema/codegen/model/ClassTypeTest.java
index d075e3077..09743d286 100644
--- a/src/test/java/com/mysema/codegen/model/ClassTypeTest.java
+++ b/src/test/java/com/mysema/codegen/model/ClassTypeTest.java
@@ -15,7 +15,7 @@ import org.junit.Test;
 
 public class ClassTypeTest {
 
-    private ClassType<String> stringType = new ClassType<String>(TypeCategory.STRING, String.class);
+    private ClassType stringType = new ClassType(TypeCategory.STRING, String.class);
 
 //    @Test
 //    public void asArrayType(){
@@ -27,10 +27,9 @@ public class ClassTypeTest {
         assertEquals(TypeCategory.COMPARABLE, stringType.as(TypeCategory.COMPARABLE).getCategory());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void getParameters(){
-        ClassType<Map> mapType = new ClassType<Map>(TypeCategory.MAP, Map.class, stringType, stringType);
+        ClassType mapType = new ClassType(TypeCategory.MAP, Map.class, stringType, stringType);
         assertEquals(2, mapType.getParameters().size());
         assertEquals(stringType, mapType.getParameters().get(0));
         assertEquals(stringType, mapType.getParameters().get(1));
diff --git a/src/test/java/com/mysema/codegen/model/TypeTest.java b/src/test/java/com/mysema/codegen/model/TypeTest.java
index 8f067c39e..44ca93972 100644
--- a/src/test/java/com/mysema/codegen/model/TypeTest.java
+++ b/src/test/java/com/mysema/codegen/model/TypeTest.java
@@ -22,7 +22,7 @@ public class TypeTest {
 
     private Set<String> emptyStrings = Collections.<String>emptySet();
         
-    private ClassType<Locale> locale = new ClassType<Locale>(TypeCategory.SIMPLE,Locale.class);
+    private ClassType locale = new ClassType(TypeCategory.SIMPLE,Locale.class);
     
     private Type string = Types.STRING;
     
@@ -30,11 +30,11 @@ public class TypeTest {
     
     private Type locale2 = new SimpleType(locale);
     
-    private Type stringList = new ClassType<List>(TypeCategory.LIST, List.class, Types.STRING);
+    private Type stringList = new ClassType(TypeCategory.LIST, List.class, Types.STRING);
     
     private Type stringList2 = new SimpleType(Types.LIST, Types.STRING);
     
-    private Type stringMap = new ClassType<Map>(TypeCategory.MAP, Map.class, Types.STRING, Types.STRING);
+    private Type stringMap = new ClassType(TypeCategory.MAP, Map.class, Types.STRING, Types.STRING);
     
     private Type stringMap2 = new SimpleType(Types.MAP, Types.STRING, Types.STRING);
    
@@ -63,8 +63,8 @@ public class TypeTest {
         assertEquals("java.util.Locale",locale2.getGenericName(true));
         assertEquals("java.util.List<String>",stringList.getGenericName(true));
         assertEquals("java.util.List<String>",stringList2.getGenericName(true));
-        assertEquals("java.util.Map<String,String>", stringMap.getGenericName(true));
-        assertEquals("java.util.Map<String,String>", stringMap2.getGenericName(true));
+        assertEquals("java.util.Map<String, String>", stringMap.getGenericName(true));
+        assertEquals("java.util.Map<String, String>", stringMap2.getGenericName(true));
         
         assertEquals("String", string.getGenericName(true));
         assertEquals("String", string2.getGenericName(true));