Got rid of peculiar null literal in parsing an incomplete new expression.

compiler/java/com/google/dart/compiler/parser/DartParser.java

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 package com.google.dart.compiler.parser;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.io.CharStreams;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.DartCompilerListener;
@@ skipping 1769 matching lines @@
    * </pre>
    *
    * @return an expression matching the {@code expression} production above
    */
   @VisibleForTesting
   public DartExpression parseExpression() {
     beginExpression();
     if (looksLikeTopLevelKeyword() || peek(0).equals(Token.RBRACE)) {
       // Allow recovery back to the top level.
       reportErrorWithoutAdvancing(ParserErrorCode.UNEXPECTED_TOKEN);
-      return done(DartNullLiteral.get());
+      return done(null);
     }
     DartExpression result = parseConditionalExpression();
     Token token = peek(0);
     if (token.isAssignmentOperator()) {
       ensureAssignable(result);
       consume(token);
       result = done(new DartBinaryExpression(token, result, parseExpression()));
     } else {
       done(null);
     }
@@ skipping 150 matching lines @@
         DartIdentifier name = parseIdentifier();
         expect(Token.COLON);
         expression = new DartNamedExpression(name, parseExpression());
         namedArgumentParsed = true;
       } else {
         expression = parseExpression();
         if (namedArgumentParsed) {
           reportError(expression, ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT);
         }
       }
-      arguments.add(done(expression));
+      if (expression != null) {
+        arguments.add(done(expression));
+      }
       switch(peek(0)) {
         // Must keep in sync with @Terminals above
         case COMMA:
           consume(Token.COMMA);
           break;
           // Must keep in sync with @Terminals above
         case RPAREN:
           break;
         default:
           Token actual = peek(0);
@@ skipping 267 matching lines @@
     // Parse the key.
     DartExpression keyExpr = parseStringWithPasting();
     if (keyExpr == null) {
       return done(null);
     }
     // Parse the value.
     DartExpression value;
     if (expect(Token.COLON)) {
       value = parseExpression();
     } else {
-      value = doneWithoutConsuming(DartNullLiteral.get());
+      value = doneWithoutConsuming(new DartSyntheticErrorExpression());
     }
     return done(new DartMapLiteralEntry(keyExpr, value));
   }
   private boolean looksLikeString() {
     switch(peek(0)) {
       case STRING:
       case STRING_SEGMENT:
       case STRING_EMBED_EXP_START:
         return true;
     }
@@ skipping 823 matching lines @@
               return emptyBlock;
           }
         }
       }
       // Return an empty block so we don't generate unparseable code.
       return emptyBlock;
     } else {
       beginFunctionStatementBody();
       if (optional(Token.ARROW)) {
         DartExpression expr = parseExpression();
+        if (expr == null) {
+          expr = new DartSyntheticErrorExpression();
+        }
         if (requireSemicolonForArrow) {
           expect(Token.SEMICOLON);
         }
         return done(makeReturnBlock(expr));
       } else {
         return done(parseBlock());
       }
     }
   }
 
@@ skipping 328 matching lines @@
     beginExpressionStatement();
     if (peek(1) == Token.LPAREN && optionalPseudoKeyword(ASSERT_KEYWORD)) {
       consume(Token.LPAREN);
       DartExpression expression = parseConditionalExpression();
       expectCloseParen();
       expectStatmentTerminator();
       return done(new DartAssertion(expression));
     }
     DartExpression expression = parseExpression();
     expectStatmentTerminator();
+
     return done(new DartExprStmt(expression));
   }
 
   /**
    * Expect a close paren, reporting an error and consuming tokens until a
    * plausible continuation is found if it isn't present.
    */
   private void expectCloseParen() {
     int parenCount = 1;
     Token nextToken = peek(0);
@@ skipping 739 matching lines @@
   }
 
   private void reportError(DartNode node, ErrorCode errorCode, Object... arguments) {
     reportError(new DartCompilationError(node, errorCode, arguments));
   }
 
   private boolean currentlyParsingToplevel() {
     return   !(isParsingInterface || isTopLevelAbstract || isParsingClass);
   }
 }