--- a/trunk/src/Expressions.d	Wed Jul 11 21:38:05 2007 +0000
+++ b/trunk/src/Expressions.d	Thu Jul 12 10:24:02 2007 +0000
@@ -318,8 +318,32 @@
 
 class NewExpression : UnaryExpression
 {
-  this(Expression e)
-  { super(e); }
+  Expression[] newArgs;
+  Type type;
+  Expression[] ctorArgs;
+  this(Expression e, Expression[] newArgs, Type type, Expression[] ctorArgs)
+  {
+    super(e);
+    this.newArgs = newArgs;
+    this.type = type;
+    this.ctorArgs = ctorArgs;
+  }
+}
+
+class NewAnonClassExpression : UnaryExpression
+{
+  Expression[] newArgs;
+  BaseClass[] bases;
+  Expression[] ctorArgs;
+  Declaration[] decls;
+  this(Expression e, Expression[] newArgs, BaseClass[] bases, Expression[] ctorArgs, Declaration[] decls)
+  {
+    super(e);
+    this.newArgs = newArgs;
+    this.bases = bases;
+    this.ctorArgs = ctorArgs;
+    this.decls = decls;
+  }
 }
 
 class DeleteExpression : UnaryExpression
@@ -338,12 +362,6 @@
   }
 }
 
-class AnonClassExpression : UnaryExpression
-{
-  this(Expression e)
-  { super(e); }
-}
-
 class IndexExpression : UnaryExpression
 {
   Expression[] args;

--- a/trunk/src/Parser.d	Wed Jul 11 21:38:05 2007 +0000
+++ b/trunk/src/Parser.d	Thu Jul 12 10:24:02 2007 +0000
@@ -414,14 +414,16 @@
     return new ClassDeclaration(className, bases, decls, hasBody);
   }
 
-  BaseClass[] parseBaseClasses()
+  BaseClass[] parseBaseClasses(bool colonLeadsOff = true)
   {
-    assert(token.type == T.Colon);
+    if (colonLeadsOff)
+    {
+      assert(token.type == T.Colon);
+      nT(); // Skip colon
+    }
 
     BaseClass[] bases;
 
-    nT(); // Skip colon
-
     while (1)
     {
       Protection prot = Protection.Public;
@@ -1438,8 +1440,42 @@
 
   Expression parseNewExpression(Expression e)
   {
-    // TODO: implement this method.
-    return null;
+    assert(token.type == T.New);
+    nT(); // Skip new keyword.
+
+    Expression[] newArguments;
+    Expression[] ctorArguments;
+
+    if (token.type == T.LParen)
+      newArguments = parseArguments(T.RParen);
+
+    // NewAnonClassExpression:
+    //         new (ArgumentList)opt class (ArgumentList)opt SuperClassopt InterfaceClassesopt ClassBody
+    if (token.type == T.Class)
+    {
+      nT();
+      if (token.type == T.LParen)
+        ctorArguments = parseArguments(T.RParen);
+
+      BaseClass[] bases = token.type != T.LBrace ? parseBaseClasses(false) : null ;
+
+      require(T.LBrace);
+      auto decls = parseDeclarationDefinitions();
+      require(T.RBrace);
+      return new NewAnonClassExpression(e, newArguments, bases, ctorArguments, decls);
+    }
+
+    // NewExpression:
+    //         NewArguments Type [ AssignExpression ]
+    //         NewArguments Type ( ArgumentList )
+    //         NewArguments Type
+    auto type = parseType();
+    // TODO: consider "new Foo!(int)(1,2,3)"
+    if (type.tid == TID.Identifier)
+    {
+      ctorArguments = parseArguments(T.RParen);
+    }
+    return new NewExpression(e, newArguments, type, ctorArguments);
   }
 
   Type parseType()