diff --git a/src/main/java/com/mysema/query/ExtQuery.java b/src/main/java/com/mysema/query/ExtQuery.java
index 85a13363e..8bbca39af 100644
--- a/src/main/java/com/mysema/query/ExtQuery.java
+++ b/src/main/java/com/mysema/query/ExtQuery.java
@@ -5,8 +5,8 @@
  */
 package com.mysema.query;
 
-import com.mysema.query.grammar.Types.ExprForBoolean;
-import com.mysema.query.grammar.Types.ExprForEntity;
+import com.mysema.query.grammar.Types.ExprBoolean;
+import com.mysema.query.grammar.Types.ExprEntity;
 
 /**
  * ExtQuery externds the Query interface to provide innerJoin, leftJoin and with methods
@@ -15,8 +15,8 @@ import com.mysema.query.grammar.Types.ExprForEntity;
  * @version $Id$
  */
 public interface ExtQuery<A extends ExtQuery<A>> extends Query<A> {
-    A innerJoin(ExprForEntity<?> object);
-    A join(ExprForEntity<?> object);
-    A leftJoin(ExprForEntity<?> object); 
-    A with(ExprForBoolean... objects);
+    A innerJoin(ExprEntity<?> o);
+    A join(ExprEntity<?> o);
+    A leftJoin(ExprEntity<?> o); 
+    A with(ExprBoolean... o);
 }
diff --git a/src/main/java/com/mysema/query/ExtQueryBase.java b/src/main/java/com/mysema/query/ExtQueryBase.java
index b06f3ba88..006f3e77d 100644
--- a/src/main/java/com/mysema/query/ExtQueryBase.java
+++ b/src/main/java/com/mysema/query/ExtQueryBase.java
@@ -5,8 +5,8 @@
  */
 package com.mysema.query;
 
-import com.mysema.query.grammar.Types.ExprForBoolean;
-import com.mysema.query.grammar.Types.ExprForEntity;
+import com.mysema.query.grammar.Types.ExprBoolean;
+import com.mysema.query.grammar.Types.ExprEntity;
 
 /**
  * ExtQueryBased provides a basic implementation of the ExtQuery interface
@@ -17,24 +17,24 @@ import com.mysema.query.grammar.Types.ExprForEntity;
 @SuppressWarnings("unchecked")
 public class ExtQueryBase<A extends ExtQueryBase<A>> extends QueryBase<A> implements ExtQuery<A> { 
 
-    public A innerJoin(ExprForEntity<?> object) {
-        joins.add(new JoinExpression(JoinType.IJ,object));
+    public A innerJoin(ExprEntity<?> o) {
+        joins.add(new JoinExpression(JoinType.IJ,o));
         return (A) this;
     }
     
-    public A join(ExprForEntity<?> object) {
-        joins.add(new JoinExpression(JoinType.J,object));
+    public A join(ExprEntity<?> o) {
+        joins.add(new JoinExpression(JoinType.J,o));
         return (A) this;
     }
 
-    public A leftJoin(ExprForEntity<?> object) {
-        joins.add(new JoinExpression(JoinType.LJ,object));
+    public A leftJoin(ExprEntity<?> o) {
+        joins.add(new JoinExpression(JoinType.LJ,o));
         return (A) this;
     }
     
-    public A with(ExprForBoolean... objects) {
+    public A with(ExprBoolean... o) {
         if (!joins.isEmpty()){
-            joins.get(joins.size()-1).conditions = objects;
+            joins.get(joins.size()-1).conditions = o;
         }
         return (A) this;
     }
diff --git a/src/main/java/com/mysema/query/Query.java b/src/main/java/com/mysema/query/Query.java
index 2a7eea3c9..7e87ee707 100644
--- a/src/main/java/com/mysema/query/Query.java
+++ b/src/main/java/com/mysema/query/Query.java
@@ -5,8 +5,8 @@
  */
 package com.mysema.query;
 
-import com.mysema.query.grammar.Types.ExprForBoolean;
-import com.mysema.query.grammar.Types.ExprForEntity;
+import com.mysema.query.grammar.Types.ExprBoolean;
+import com.mysema.query.grammar.Types.ExprEntity;
 import com.mysema.query.grammar.Types.Expr;
 import com.mysema.query.grammar.Types.OrderSpecifier;
 
@@ -17,10 +17,10 @@ import com.mysema.query.grammar.Types.OrderSpecifier;
  * @version $Id$
  */
 public interface Query<A extends Query<A>>{
-    A select(Expr<?>... objects);
-    A from(ExprForEntity<?>... objects);    
-    A where(ExprForBoolean... objects);
-    A groupBy(Expr<?>... objects);
-    A having(ExprForBoolean... objects);
-    A orderBy(OrderSpecifier<?>... objects);
+    A select(Expr<?>... o);
+    A from(ExprEntity<?>... o);    
+    A where(ExprBoolean... o);
+    A groupBy(Expr<?>... o);
+    A having(ExprBoolean... o);
+    A orderBy(OrderSpecifier<?>... o);
 }
\ No newline at end of file
diff --git a/src/main/java/com/mysema/query/QueryBase.java b/src/main/java/com/mysema/query/QueryBase.java
index c7853ef15..c16b0e564 100644
--- a/src/main/java/com/mysema/query/QueryBase.java
+++ b/src/main/java/com/mysema/query/QueryBase.java
@@ -8,8 +8,8 @@ package com.mysema.query;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.mysema.query.grammar.Types.ExprForBoolean;
-import com.mysema.query.grammar.Types.ExprForEntity;
+import com.mysema.query.grammar.Types.ExprBoolean;
+import com.mysema.query.grammar.Types.ExprEntity;
 import com.mysema.query.grammar.Types.Expr;
 import com.mysema.query.grammar.Types.OrderSpecifier;
 /**
@@ -26,20 +26,20 @@ public class QueryBase<A extends QueryBase<A>> implements Query<A> {
     
     public class JoinExpression{
         public final JoinType type;
-        public final ExprForEntity<?> target;
-        JoinExpression(JoinType type, ExprForEntity<?> target){
+        public final ExprEntity<?> target;
+        JoinExpression(JoinType type, ExprEntity<?> target){
             this.type = type;
             this.target = target;
         }
-        public ExprForBoolean[] conditions;
+        public ExprBoolean[] conditions;
     }
     
     protected List<JoinExpression> joins = new ArrayList<JoinExpression>();
     protected Expr<?>[] groupBy;
-    protected ExprForBoolean[] having;
+    protected ExprBoolean[] having;
     protected OrderSpecifier<?>[] orderBy;
     protected Expr<?>[] select;
-    protected ExprForBoolean[] where;
+    protected ExprBoolean[] where;
     
     protected void clear(){
         joins.clear();
@@ -50,36 +50,36 @@ public class QueryBase<A extends QueryBase<A>> implements Query<A> {
         where = null;
     }
     
-    public A from(ExprForEntity<?>... objects) {
-        for (ExprForEntity<?> expr : objects){
+    public A from(ExprEntity<?>... o) {
+        for (ExprEntity<?> expr : o){
             joins.add(new JoinExpression(JoinType.DEFAULT,expr));
         }
         return (A) this;
     }
 
-    public A groupBy(Expr<?>... objects) {
-        groupBy = objects;
+    public A groupBy(Expr<?>... o) {
+        groupBy = o;
         return (A) this;
     }
 
-    public A having(ExprForBoolean... objects) {
-        having = objects;
+    public A having(ExprBoolean... o) {
+        having = o;
         return (A) this;
     }
 
 
-    public A orderBy(OrderSpecifier<?>... objects) {
-        orderBy = objects;
+    public A orderBy(OrderSpecifier<?>... o) {
+        orderBy = o;
         return (A) this;
     }
 
-    public A select(Expr<?>... objects) {
-        select = objects;
+    public A select(Expr<?>... o) {
+        select = o;
         return (A) this;
     }
     
-    public A where(ExprForBoolean... objects) {
-        where = objects;
+    public A where(ExprBoolean... o) {
+        where = o;
         return (A) this;
     }
     
diff --git a/src/main/java/com/mysema/query/grammar/Grammar.java b/src/main/java/com/mysema/query/grammar/Grammar.java
index f5b6eede8..462980986 100644
--- a/src/main/java/com/mysema/query/grammar/Grammar.java
+++ b/src/main/java/com/mysema/query/grammar/Grammar.java
@@ -5,8 +5,10 @@
  */
 package com.mysema.query.grammar;
 
-import com.mysema.query.grammar.Types.*;
+import java.util.Collection;
+
 import com.mysema.query.grammar.Ops.*;
+import com.mysema.query.grammar.Types.*;
 
 /**
  * Grammar provides the factory methods for the fluent grammar
@@ -16,7 +18,7 @@ import com.mysema.query.grammar.Ops.*;
  */
 public class Grammar {
 
-    static <L, R> ExprForBoolean _binOp(Op<Boolean> operator, Expr<L> left,
+    static <L, R> ExprBoolean _binOp(Op<Boolean> operator, Expr<L> left,
             Expr<R> right) {
         OperationBinaryBoolean<L, R> op = new OperationBinaryBoolean<L, R>();
         op.operator = operator;
@@ -57,7 +59,7 @@ public class Grammar {
         return os;
     }
 
-    static <F, S, T> ExprForBoolean _terOp(Op<Boolean> type, Expr<F> fst,
+    static <F, S, T> ExprBoolean _terOp(Op<Boolean> type, Expr<F> fst,
             Expr<S> snd, Expr<T> trd) {
         OperationTertiaryBoolean<F, S, T> op = new OperationTertiaryBoolean<F, S, T>();
         op.operator = type;
@@ -77,7 +79,7 @@ public class Grammar {
         return op;
     }
 
-    static <A> ExprForBoolean _unOp(Op<Boolean> type, Expr<A> left) {
+    static <A> ExprBoolean _unOp(Op<Boolean> type, Expr<A> left) {
         OperationUnaryBoolean<A> op = new OperationUnaryBoolean<A>();
         op.operator = type;
         op.left = left;
@@ -91,15 +93,15 @@ public class Grammar {
         return op;
     }
 
-    public static <A extends Number> ExprForNoEntity<A> add(Expr<A> left, A right) {
+    public static <A extends Number> ExprNoEntity<A> add(Expr<A> left, A right) {
         return _binOp(OpNumber.ADD, left, _const(right));
     }
 
-    public static <A extends Number> ExprForNoEntity<A> add(Expr<A> left, Expr<A> right) {
+    public static <A extends Number> ExprNoEntity<A> add(Expr<A> left, Expr<A> right) {
         return _binOp(OpNumber.ADD, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean after(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean after(Expr<A> left,
             A right) {
         // NOTE : signature is for Comparables to support other than Java's date
         // types
@@ -107,7 +109,7 @@ public class Grammar {
         return _binOp(OpDate.AFTER, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean after(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean after(Expr<A> left,
             Expr<A> right) {
         // NOTE : signature is for Comparables to support other than Java's date
         // types
@@ -115,28 +117,28 @@ public class Grammar {
         return _binOp(OpDate.AFTER, left, right);
     }
 
-    public static ExprForBoolean and(ExprForBoolean left, ExprForBoolean right) {
+    public static ExprBoolean and(ExprBoolean left, ExprBoolean right) {
         return _binOp(OpBoolean.AND, left, right);
     }
 
-    public static <D> AliasForCollection<D> as(PathForEntityCollection<D> from, PathForEntity<D> to) {
-        return new AliasForCollection<D>(from, to);
-    }
-    
-    public static <D> AliasForEntity<D> as(PathForEntity<D> from, PathForEntity<D> to) {
-        return new AliasForEntity<D>(from, to);
-    }
-    
-    public static <D> AliasForNoEntity<D> as(ExprForNoEntity<D> from, String to) {
+    public static <D> AliasNoEntity<D> as(ExprNoEntity<D> from, String to) {
         // NOTE : maybe this needs to be possible for all expressions
-        return new AliasForNoEntity<D>(from, to);
+        return new AliasNoEntity<D>(from, to);
+    }
+    
+    public static <D> AliasEntity<D> as(PathEntity<D> from, PathEntity<D> to) {
+        return new AliasEntity<D>(from, to);
+    }
+    
+    public static <D> AliasCollection<D> as(PathEntityCollection<D> from, PathEntity<D> to) {
+        return new AliasCollection<D>(from, to);
     }
 
     public static <A extends Comparable<A>> OrderSpecifier<A> asc(Expr<A> target) {
         return _orderAsc(target);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean before(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean before(Expr<A> left,
             A right) {
         // NOTE : signature is for Comparables to support other than Java's date
         // types
@@ -144,7 +146,7 @@ public class Grammar {
         return _binOp(OpDate.BEFORE, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean before(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean before(Expr<A> left,
             Expr<A> right) {
         // NOTE : signature is for Comparables to support other than Java's date
         // types
@@ -152,150 +154,154 @@ public class Grammar {
         return _binOp(OpDate.BEFORE, left, right);
     }
     
-    public static <A extends Comparable<A>> ExprForBoolean between(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean between(Expr<A> left,
             A start, A end) {
         return _terOp(OpComparable.BETWEEN, left, _const(start), _const(end));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean between(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean between(Expr<A> left,
             Expr<A> start, Expr<A> end) {
         return _terOp(OpComparable.BETWEEN, left, start, end);
     }
 
-    public static ExprForNoEntity<String> concat(Expr<String> left, Expr<String> right) {
+    public static ExprNoEntity<String> concat(Expr<String> left, Expr<String> right) {
         return _binOp(OpString.CONCAT, left, right);
     }
-
-    public static ExprForNoEntity<Long> count(){
-        return new CountExpr<Long>();
-    }
     
     public static <A extends Comparable<A>> OrderSpecifier<A> desc(
             Expr<A> target) {
         return _orderDesc(target);
     }
 
-    public static <A extends Number> ExprForNoEntity<A> div(Expr<A> left, A right) {
+    public static <A extends Number> ExprNoEntity<A> div(Expr<A> left, A right) {
         return _binOp(OpNumber.DIV, left, _const(right));
     }
     
-    public static <A extends Number> ExprForNoEntity<A> div(Expr<A> left, Expr<A> right) {
+    public static <A extends Number> ExprNoEntity<A> div(Expr<A> left, Expr<A> right) {
         return _binOp(OpNumber.DIV, left, right);
     }
 
-    public static <A, B extends A> ExprForBoolean eq(Expr<A> left, B right) {
+    public static <A, B extends A> ExprBoolean eq(Expr<A> left, B right) {
         return _binOp(Op.EQ, left, _const(right));
     }
 
-    public static <A, B extends A> ExprForBoolean eq(Expr<A> left, Expr<B> right) {
+    public static <A, B extends A> ExprBoolean eq(Expr<A> left, Expr<B> right) {
         return _binOp(Op.EQ, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean goe(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
             A right) {
         return _binOp(OpNumber.GOE, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean goe(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean goe(Expr<A> left,
             Expr<A> right) {
         return _binOp(OpNumber.GOE, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean gt(Expr<A> left, A right) {
+    public static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left, A right) {
         return _binOp(OpNumber.GT, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean gt(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean gt(Expr<A> left,
             Expr<A> right) {
         return _binOp(OpNumber.GT, left, right);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean in(Expr<A> left,
+    public static <A> ExprBoolean in(A left, ExprEntity<Collection<A>> right){
+        return _binOp(Op.INELEMENTS, _const(left), right);
+    }
+    
+    public static <A extends Comparable<A>> ExprBoolean in(Expr<A> left,
             A... rest) {
-        return _binOp(Op.IN, left, _const(rest));
+        return _binOp(Op.INARRAY, left, _const(rest));
+    }
+    
+    public static <A> ExprBoolean in(ExprEntity<A> left, ExprEntity<Collection<A>> right){
+        return _binOp(Op.INELEMENTS, left, right);
     }
 
-    public static <A> ExprForBoolean isnotnull(Expr<A> left) {
+    public static <A> ExprBoolean isnotnull(Expr<A> left) {
         return _unOp(Op.ISNOTNULL, left);
     }
 
-    public static <A> ExprForBoolean isnull(Expr<A> left) {
+    public static <A> ExprBoolean isnull(Expr<A> left) {
         return _unOp(Op.ISNULL, left);
     }
 
-    public static ExprForBoolean like(Expr<String> left, String right) {
+    public static ExprBoolean like(Expr<String> left, String right) {
         return _binOp(OpString.LIKE, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean loe(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean loe(Expr<A> left,
             A right) {
         return _binOp(OpNumber.LOE, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean loe(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean loe(Expr<A> left,
             Expr<A> right) {
         return _binOp(OpNumber.LOE, left, right);
     }
 
-    public static ExprForNoEntity<String> lower(Expr<String> left) {
+    public static ExprNoEntity<String> lower(Expr<String> left) {
         return _unOp(OpString.LOWER, left);
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean lt(Expr<A> left, A right) {
+    public static <A extends Comparable<A>> ExprBoolean lt(Expr<A> left, A right) {
         return _binOp(OpNumber.LT, left, _const(right));
     }
 
-    public static <A extends Comparable<A>> ExprForBoolean lt(Expr<A> left,
+    public static <A extends Comparable<A>> ExprBoolean lt(Expr<A> left,
             Expr<A> right) {
         return _binOp(OpNumber.LT, left, right);
     }
 
-    public static <A extends Number> ExprForNoEntity<A> mult(Expr<A> left, A right) {
+    public static <A extends Number> ExprNoEntity<A> mult(Expr<A> left, A right) {
         return _binOp(OpNumber.MULT, left, _const(right));
     }
 
-    public static <A extends Number> ExprForNoEntity<A> mult(Expr<A> left, Expr<A> right) {
+    public static <A extends Number> ExprNoEntity<A> mult(Expr<A> left, Expr<A> right) {
         return _binOp(OpNumber.MULT, left, right);
     }
 
-    public static <A, B extends A> ExprForBoolean ne(Expr<A> left, B right) {
+    public static <A, B extends A> ExprBoolean ne(Expr<A> left, B right) {
         return _binOp(Op.NE, left, _const(right));
     }
 
-    public static <A, B extends A> ExprForBoolean ne(Expr<A> left, Expr<B> right) {
+    public static <A, B extends A> ExprBoolean ne(Expr<A> left, Expr<B> right) {
         return _binOp(Op.NE, left, right);
     }
 
-    public static ExprForBoolean not(ExprForBoolean left) {
+    public static ExprBoolean not(ExprBoolean left) {
         return _unOp(OpBoolean.NOT, left);
     }
 
-    public static ExprForBoolean or(ExprForBoolean left, ExprForBoolean right) {
+    public static ExprBoolean or(ExprBoolean left, ExprBoolean right) {
         return _binOp(OpBoolean.OR, left, right);
     }
 
-    public static <A extends Number> ExprForNoEntity<A> sub(Expr<A> left, A right) {
+    public static <A extends Number> ExprNoEntity<A> sub(Expr<A> left, A right) {
         return _binOp(OpNumber.SUB, left, _const(right));
     }
 
-    public static <A extends Number> ExprForNoEntity<A> sub(Expr<A> left, Expr<A> right) {
+    public static <A extends Number> ExprNoEntity<A> sub(Expr<A> left, Expr<A> right) {
         return _binOp(OpNumber.SUB, left, right);
     }
 
-    public static ExprForNoEntity<String> substr(Expr<String> left, int start) {
+    public static ExprNoEntity<String> substr(Expr<String> left, int start) {
         return _binOp(OpString.SUBSTR, left, _const(start));
     }
 
-    public static ExprForNoEntity<String> substr(Expr<String> left, int start, int offset) {
+    public static ExprNoEntity<String> substr(Expr<String> left, int start, int offset) {
         return _terOp(OpString.SUBSTR, left, _const(start), _const(offset));
     }
 
-    public static <A, B extends A> ExprForBoolean typeOf(Expr<A> left,
+    public static <A, B extends A> ExprBoolean typeOf(Expr<A> left,
             Class<B> right) {
         return _binOp(Op.ISTYPEOF, left, _const(right));
     }
 
-    public static ExprForNoEntity<String> upper(Expr<String> left) {
+    public static ExprNoEntity<String> upper(Expr<String> left) {
         return _unOp(OpString.UPPER, left);
     }
 }
diff --git a/src/main/java/com/mysema/query/grammar/Ops.java b/src/main/java/com/mysema/query/grammar/Ops.java
index 8d5fe8aff..05be2ea75 100644
--- a/src/main/java/com/mysema/query/grammar/Ops.java
+++ b/src/main/java/com/mysema/query/grammar/Ops.java
@@ -18,7 +18,8 @@ public class Ops {
      */
     public interface Op<RT> {
         Op<Boolean> EQ = new OpImpl<Boolean>();
-        Op<Boolean> IN = new OpImpl<Boolean>();
+        Op<Boolean> INARRAY = new OpImpl<Boolean>();
+        Op<Boolean> INELEMENTS = new OpImpl<Boolean>();
         Op<Boolean> ISNOTNULL = new OpImpl<Boolean>();
         Op<Boolean> ISNULL = new OpImpl<Boolean>();
         Op<Boolean> ISTYPEOF = new OpImpl<Boolean>();
diff --git a/src/main/java/com/mysema/query/grammar/Types.java b/src/main/java/com/mysema/query/grammar/Types.java
index 731bb796b..6ff71c0d9 100644
--- a/src/main/java/com/mysema/query/grammar/Types.java
+++ b/src/main/java/com/mysema/query/grammar/Types.java
@@ -18,7 +18,7 @@ import com.mysema.query.grammar.Ops.Op;
  */
 public class Types {
     
-    public abstract static class Alias<D> extends ExprImpl<D>{ 
+    public abstract static class Alias<D> extends ExprNonFinalImpl<D>{ 
         public final Expr<?> from;
         public final String to;
         Alias(Expr<?> from, String to) {
@@ -27,23 +27,23 @@ public class Types {
         }
     }
         
-    public static class AliasForCollection<D> extends Alias<D> implements ExprForEntity<D>{
-        AliasForCollection(PathForEntityCollection<D> from, Path<D> to) {
+    public static class AliasCollection<D> extends Alias<D> implements ExprEntity<D>{
+        AliasCollection(PathEntityCollection<D> from, Path<D> to) {
             super(from,to.toString());
         }        
     }
     
-    public static class AliasForEntity<D> extends Alias<D> implements ExprForEntity<D>{
-        AliasForEntity(PathForEntity<D> from, PathForEntity<D> to) {
+    public static class AliasEntity<D> extends Alias<D> implements ExprEntity<D>{
+        AliasEntity(PathEntity<D> from, PathEntity<D> to) {
             super(from,to.toString());
         }
-        AliasForEntity(PathForEntity<D> from, String to) {
+        AliasEntity(PathEntity<D> from, String to) {
             super(from,to);
         }
     }
     
-    public static class AliasForNoEntity<D> extends Alias<D> implements ExprForNoEntity<D>{       
-        AliasForNoEntity(Expr<D> from, String to) {
+    public static class AliasNoEntity<D> extends Alias<D> implements ExprNoEntity<D>{       
+        AliasNoEntity(Expr<D> from, String to) {
             super(from,to);
         }
         public Expr<D> as(String to) {
@@ -51,44 +51,44 @@ public class Types {
         }        
     }
     
-    public static class ConstantExpr<D> extends ExprImpl<D>{
+    public static class ConstantExpr<D> extends ExprNonFinalImpl<D>{
         public D constant;
     }
     
-    public static class CountExpr<D> extends ExprForNoEntityImpl<D>{
-        // TODO : move to querydsl-hibernate
+    public interface Expr<D> {
+                
     }
     
-    public interface Expr<D> { 
-        public <B extends D> ExprForBoolean eq(B right);        
-        public <B extends D> ExprForBoolean eq(Expr<B> right);
-        public <B extends D> ExprForBoolean ne(B right);
-        public <B extends D> ExprForBoolean ne(Expr<B> right);        
+    public interface ExprNonFinal<D> extends Expr<D> {
+        public <B extends D> ExprBoolean eq(B right);        
+        public <B extends D> ExprBoolean eq(Expr<B> right);
+        public <B extends D> ExprBoolean ne(B right);
+        public <B extends D> ExprBoolean ne(Expr<B> right);
     }
     
-    static abstract class ExprImpl<D> implements Expr<D>{
-        public <B extends D> ExprForBoolean eq(B right){return Grammar.eq(this, right);}        
-        public <B extends D> ExprForBoolean eq(Expr<B> right){return Grammar.eq(this, right);}
-        public <B extends D> ExprForBoolean ne(B right){return Grammar.ne(this, right);}
-        public <B extends D> ExprForBoolean ne(Expr<B> right){return Grammar.ne(this, right);}
-    }
-    
-    public interface ExprForBoolean extends ExprForNoEntity<Boolean>{ }  
+    public interface ExprBoolean extends ExprNoEntity<Boolean>{ }
     
     /**
      * Reference to an entity
      */
-    public interface ExprForEntity<D> extends Expr<D>{}
+    public interface ExprEntity<D> extends Expr<D>{}  
+    
+    static abstract class ExprNonFinalImpl<D> implements ExprNonFinal<D>{
+        public <B extends D> ExprBoolean eq(B right){return Grammar.eq(this, right);}        
+        public <B extends D> ExprBoolean eq(Expr<B> right){return Grammar.eq(this, right);}
+        public <B extends D> ExprBoolean ne(B right){return Grammar.ne(this, right);}
+        public <B extends D> ExprBoolean ne(Expr<B> right){return Grammar.ne(this, right);}
+    }
             
-    public interface ExprForNoEntity<D> extends Expr<D>{
+    public interface ExprNoEntity<D> extends ExprNonFinal<D>{
         public Expr<D> as(String to);
     }
     
-    static abstract class ExprForNoEntityImpl<D> extends ExprImpl<D> implements ExprForNoEntity<D>{
+    public static abstract class ExprNoEntityImpl<D> extends ExprNonFinalImpl<D> implements ExprNoEntity<D>{
         public Expr<D> as(String to){return Grammar.as(this, to);}
     }  
     
-    public abstract static class Operation<RT> extends ExprForNoEntityImpl<RT> {
+    public abstract static class Operation<RT> extends ExprNoEntityImpl<RT> {
         public Expr<RT> as(String to) {
             return Grammar.as(this, to);
         }  
@@ -104,7 +104,7 @@ public class Types {
     }
     
     public static class OperationBinaryBoolean<L,R> extends OperationBinary<Boolean,Boolean,L,R> 
-        implements ExprForBoolean {
+        implements ExprBoolean {
         public Expr<Boolean> as(String to) {
             return Grammar.as(this, to);
         }        
@@ -121,7 +121,7 @@ public class Types {
     }
            
     public static class OperationTertiaryBoolean<F,S,T> extends OperationTertiary<Boolean,Boolean,F,S,T>
-        implements ExprForBoolean{  
+        implements ExprBoolean{  
     }
     
     public static class OperationUnary<OP,RT extends OP,A> extends Operation<RT>{
@@ -133,7 +133,7 @@ public class Types {
     }
     
     public static class OperationUnaryBoolean<A> extends OperationUnary<Boolean,Boolean,A>
-        implements ExprForBoolean{
+        implements ExprBoolean{
     }
     
     public enum Order{ ASC,DESC }
@@ -143,7 +143,7 @@ public class Types {
         public Expr<A> target;       
     }
     
-    public abstract static class Path<D> extends ExprImpl<D>{
+    public abstract static class Path<D> extends ExprNonFinalImpl<D>{
         // path is hidden to not pollute the namespace of the domain types
         private final String path;
         public Path(String p) {
@@ -153,40 +153,40 @@ public class Types {
         public final String toString(){ return path; }
     }
     
-    public static class PathForBoolean extends PathForNoEntity<Boolean> implements ExprForBoolean{
-        PathForBoolean(String path) {super(path);}
+    public static class PathBoolean extends PathNoEntity<Boolean> implements ExprBoolean{
+        PathBoolean(String path) {super(path);}
     }
     
-    public static class PathForEntity<D> extends Path<D> implements ExprForEntity<D>{
-        protected PathForEntity(PathForEntity<?> type, String path) {
+    public static class PathEntity<D> extends Path<D> implements ExprEntity<D>{
+        protected PathEntity(PathEntity<?> type, String path) {
             super(type+"."+path);
         } 
-        protected PathForEntity(String path) {super(path);}
-        protected PathForBoolean _boolean(String path){
-            return new PathForBoolean(this+"."+path);
+        protected PathEntity(String path) {super(path);}
+        protected PathBoolean _boolean(String path){
+            return new PathBoolean(this+"."+path);
         }
-        protected <A>PathForEntityCollection<A> _collection(String path,Class<A> type) {
-            return new PathForEntityCollection<A>(this+"."+path);
+        protected <A>PathEntityCollection<A> _collection(String path,Class<A> type) {
+            return new PathEntityCollection<A>(this+"."+path);
         }
-        protected <A> PathForNoEntity<A> _prop(String path,Class<A> type) {
-            return new PathForNoEntity<A>(this+"."+path);
+        protected <A> PathNoEntity<A> _prop(String path,Class<A> type) {
+            return new PathNoEntity<A>(this+"."+path);
         }
         
-        public AliasForEntity<D> as(PathForEntity<D> to) {return Grammar.as(this, to);}
+        public AliasEntity<D> as(PathEntity<D> to) {return Grammar.as(this, to);}
     }
     
-    public static class PathForEntityCollection<D> extends Path<Collection<D>> implements 
-        ExprForEntity<Collection<D>>{
-        PathForEntityCollection(String p) {
+    public static class PathEntityCollection<D> extends Path<Collection<D>> implements 
+        ExprEntity<Collection<D>>{
+        PathEntityCollection(String p) {
             super(p);
         }        
-        public AliasForCollection<D> as(PathForEntity<D> to) {
+        public AliasCollection<D> as(PathEntity<D> to) {
             return Grammar.as(this, to);
         }
     }
     
-    public static class PathForNoEntity<D> extends Path<D> implements ExprForNoEntity<D>{
-        public PathForNoEntity(String p) {
+    public static class PathNoEntity<D> extends Path<D> implements ExprNoEntity<D>{
+        public PathNoEntity(String p) {
             super(p);
         }
         public Expr<D> as(String to) {
diff --git a/src/main/java/com/mysema/query/grammar/Visitor.java b/src/main/java/com/mysema/query/grammar/Visitor.java
index d5c6846c8..4ca073aed 100644
--- a/src/main/java/com/mysema/query/grammar/Visitor.java
+++ b/src/main/java/com/mysema/query/grammar/Visitor.java
@@ -22,10 +22,10 @@ public abstract class Visitor<T extends Visitor<T>> {
 
         @Override
         protected Method create(Class<?> cl) {
-            while (!Types.class.equals(cl.getEnclosingClass())){
-                cl = cl.getSuperclass();
-            }
             try {
+                if (PathEntity.class.isAssignableFrom(cl)){
+                    cl = PathEntity.class;
+                }
                 Method method = null;
                 Class<?> sigClass = Visitor.this.getClass();
                 while (method == null && !sigClass.equals(Visitor.class)){
@@ -60,16 +60,14 @@ public abstract class Visitor<T extends Visitor<T>> {
     
     protected abstract void visit(Alias<?> expr);
     
-    protected abstract void visit(AliasForNoEntity<?> expr);
+    protected abstract void visit(AliasNoEntity<?> expr);
     
-    protected abstract void visit(AliasForCollection<?> expr);
+    protected abstract void visit(AliasCollection<?> expr);
     
-    protected abstract void visit(AliasForEntity<?> expr);
+    protected abstract void visit(AliasEntity<?> expr);
     
     protected abstract void visit(ConstantExpr<?> expr);
     
-    protected abstract void visit(CountExpr<?> expr);
-    
     protected abstract void visit(OperationBinary<?,?,?,?> expr);
     
     protected abstract void visit(OperationBinaryBoolean<?,?> expr);
@@ -84,12 +82,12 @@ public abstract class Visitor<T extends Visitor<T>> {
     
     protected abstract void visit(Path<?> expr);
     
-    protected abstract void visit(PathForBoolean expr);
+    protected abstract void visit(PathBoolean expr);
     
-    protected abstract void visit(PathForEntityCollection<?> expr);
+    protected abstract void visit(PathEntityCollection<?> expr);
     
-    protected abstract void visit(PathForEntity<?> expr);
+    protected abstract void visit(PathEntity<?> expr);
     
-    protected abstract void visit(PathForNoEntity<?> expr);
+    protected abstract void visit(PathNoEntity<?> expr);
     
 }
diff --git a/src/main/java/com/mysema/query/grammar/VisitorAdapter.java b/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
index 66b9d8417..206958101 100644
--- a/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
+++ b/src/main/java/com/mysema/query/grammar/VisitorAdapter.java
@@ -17,17 +17,17 @@ import com.mysema.query.grammar.Types.*;
 public abstract class VisitorAdapter<V extends VisitorAdapter<V>> extends Visitor<V>{
     
     @Override
-    protected void visit(AliasForNoEntity<?> expr) {
+    protected void visit(AliasNoEntity<?> expr) {
         visit((Alias<?>)expr);        
     }
     
     @Override
-    protected void visit(AliasForCollection<?> expr){
+    protected void visit(AliasCollection<?> expr){
         visit((Alias<?>)expr);
     }
     
     @Override
-    protected void visit(AliasForEntity<?> expr) {
+    protected void visit(AliasEntity<?> expr) {
         visit((Alias<?>)expr);        
     }
     
@@ -37,22 +37,22 @@ public abstract class VisitorAdapter<V extends VisitorAdapter<V>> extends Visito
     }
     
     @Override
-    protected void visit(PathForBoolean expr) {
+    protected void visit(PathBoolean expr) {
         visit((Path<?>)expr);     
     }
     
     @Override
-    protected void visit(PathForEntityCollection<?> expr){
+    protected void visit(PathEntityCollection<?> expr){
         visit((Path<?>)expr);
     }
     
     @Override
-    protected void visit(PathForEntity<?> expr) {
+    protected void visit(PathEntity<?> expr) {
         visit((Path<?>)expr);        
     }
     
     @Override
-    protected void visit(PathForNoEntity<?> expr) {
+    protected void visit(PathNoEntity<?> expr) {
         visit((Path<?>)expr);        
     }