Handle NewExpression in SemanticSendVisitor.

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.constants.expressions;
 
 import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     Element,
@@ skipping 79 matching lines @@
   final List<ConstantExpression> values;
 
   MapConstantExpression(this.value, this.type, this.keys, this.values);
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
 }
 
 /// Invocation of a const constructor.
-class ConstructedConstantExpresssion extends ConstantExpression {
+class ConstructedConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final InterfaceType type;
   final FunctionElement target;
   final Selector selector;
   final List<ConstantExpression> arguments;
 
-  ConstructedConstantExpresssion(this.value,
+  ConstructedConstantExpression(this.value,
                       this.type,
                       this.target,
                       this.selector,
                       this.arguments) {
     assert(type.element == target.enclosingClass);
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
@@ skipping 149 matching lines @@
 abstract class ConstantExpressionVisitor<C, R> {
   const ConstantExpressionVisitor();
 
   R visit(ConstantExpression constant, C context) {
     return constant.accept(this, context);
   }
 
   R visitPrimitive(PrimitiveConstantExpression exp, C context);
   R visitList(ListConstantExpression exp, C context);
   R visitMap(MapConstantExpression exp, C context);
-  R visitConstructed(ConstructedConstantExpresssion exp, C context);
+  R visitConstructed(ConstructedConstantExpression exp, C context);
   R visitConcatenate(ConcatenateConstantExpression exp, C context);
   R visitSymbol(SymbolConstantExpression exp, C context);
   R visitType(TypeConstantExpression exp, C context);
   R visitVariable(VariableConstantExpression exp, C context);
   R visitFunction(FunctionConstantExpression exp, C context);
   R visitBinary(BinaryConstantExpression exp, C context);
   R visitUnary(UnaryConstantExpression exp, C context);
   R visitConditional(ConditionalConstantExpression exp, C context);
 }
 
@@ skipping 72 matching lines @@
         sb.write(', ');
       }
       visit(exp.keys[index]);
       sb.write(': ');
       visit(exp.values[index]);
     }
     sb.write('}');
   }
 
   @override
-  void visitConstructed(ConstructedConstantExpresssion exp, [_]) {
+  void visitConstructed(ConstructedConstantExpression exp, [_]) {
     sb.write('const ');
     sb.write(exp.target.enclosingClass.name);
     if (exp.target.name != '') {
       sb.write('.');
       sb.write(exp.target.name);
     }
     writeTypeArguments(exp.type);
     sb.write('(');
     bool needsComma = false;
 
@@ skipping 78 matching lines @@
   void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
   String toString() => sb.toString();
 }