Get rid of a lot of () for getters.

lib/compiler/implementation/js_backend/constant_system_javascript.dart

 // 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.
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
 
 class JavaScriptBitNotOperation extends BitNotOperation {
   const JavaScriptBitNotOperation();
 
   Constant fold(Constant constant) {
@@ skipping 11 matching lines @@
 /**
  * In JavaScript we truncate the result to an unsigned 32 bit integer. Also, -0
  * is treated as if it was the integer 0.
  */
 class JavaScriptBinaryBitOperation implements BinaryOperation {
   final BinaryBitOperation dartBitOperation;
 
   const JavaScriptBinaryBitOperation(this.dartBitOperation);
 
   bool isUserDefinable() => dartBitOperation.isUserDefinable();
-  SourceString get name() => dartBitOperation.name;
+  SourceString get name => dartBitOperation.name;
 
   Constant fold(Constant left, Constant right) {
     // In JavaScript we don't check for -0 and treat it as if it was zero.
     if (left.isMinusZero()) left = DART_CONSTANT_SYSTEM.createInt(0);
     if (right.isMinusZero()) right = DART_CONSTANT_SYSTEM.createInt(0);
     IntConstant result = dartBitOperation.fold(left, right);
     if (result != null) {
       // We convert the result of bit-operations to 32 bit unsigned integers.
       return JAVA_SCRIPT_CONSTANT_SYSTEM.createInt32(result.value);
     }
@@ skipping 26 matching lines @@
     return super.fold(left, right);
   }
 }
 
 class JavaScriptNegateOperation implements UnaryOperation {
   final NegateOperation dartNegateOperation = const NegateOperation();
 
   const JavaScriptNegateOperation();
 
   bool isUserDefinable() => dartNegateOperation.isUserDefinable();
-  SourceString get name() => dartNegateOperation.name;
+  SourceString get name => dartNegateOperation.name;
 
   Constant fold(Constant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       if (intConstant.value == 0) {
         return JAVA_SCRIPT_CONSTANT_SYSTEM.createDouble(-0.0);
       }
     }
     return dartNegateOperation.fold(constant);
   }
 }
 
 class JavaScriptBinaryArithmeticOperation implements BinaryOperation {
   final BinaryOperation dartArithmeticOperation;
 
   const JavaScriptBinaryArithmeticOperation(this.dartArithmeticOperation);
 
   bool isUserDefinable() => dartArithmeticOperation.isUserDefinable();
-  SourceString get name() => dartArithmeticOperation.name;
+  SourceString get name => dartArithmeticOperation.name;
 
   Constant fold(Constant left, Constant right) {
     Constant result = dartArithmeticOperation.fold(left, right);
     if (result == null) return result;
     return JAVA_SCRIPT_CONSTANT_SYSTEM.convertToJavaScriptConstant(result);
   }
 }
 
 class JavaScriptIdentityOperation implements BinaryOperation {
   final IdentityOperation dartIdentityOperation = const IdentityOperation();
 
   const JavaScriptIdentityOperation();
 
   bool isUserDefinable() => dartIdentityOperation.isUserDefinable();
-  SourceString get name() => dartIdentityOperation.name;
+  SourceString get name => dartIdentityOperation.name;
 
   BoolConstant fold(Constant left, Constant right) {
     BoolConstant result = dartIdentityOperation.fold(left, right);
     if (result == null || result.value) return result;
     // In JavaScript -0.0 === 0 and all doubles are equal to their integer
     // values. Furthermore NaN !== NaN.
     if (left.isNum() && right.isNum()) {
       NumConstant leftNum = left;
       NumConstant rightNum = right;
       double leftDouble = leftNum.value.toDouble();
@@ skipping 87 matching lines @@
   NullConstant createNull() => new NullConstant();
 
   // Integer checks don't verify that the number is not -0.0.
   bool isInt(Constant constant) => constant.isInt() || constant.isMinusZero();
   bool isDouble(Constant constant)
       => constant.isDouble() && !constant.isMinusZero();
   bool isString(Constant constant) => constant.isString();
   bool isBool(Constant constant) => constant.isBool();
   bool isNull(Constant constant) => constant.isNull();
 }