Convert isX() methods to isX getter.

pkg/analyzer_experimental/lib/src/generated/constant.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.constant;
 import 'java_core.dart';
 import 'source.dart' show Source;
 import 'error.dart' show AnalysisError, ErrorCode, CompileTimeErrorCode;
 import 'scanner.dart' show TokenType;
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 111 matching lines @@
    * expression or because it would throw an exception when evaluated.
    * @return the value of the expression
    */
   Object get value => _value;
 
   /**
    * Return `true` if the expression is a compile-time constant expression that would not
    * throw an exception when evaluated.
    * @return `true` if the expression is a valid compile-time constant expression
    */
-  bool isValid() => _errors == null;
+  bool get isValid => _errors == null;
 }
 /**
  * Instances of the class `ConstantFinder` are used to traverse the AST structures of all of
  * the compilation units being resolved and build a table mapping constant variable elements to the
  * declarations of those variables.
  */
 class ConstantFinder extends RecursiveASTVisitor<Object> {
 
   /**
    * A table mapping constant variable elements to the declarations of those variables.
    */
   Map<VariableElement, VariableDeclaration> _variableMap = new Map<VariableElement, VariableDeclaration>();
 
   /**
    * Return a table mapping constant variable elements to the declarations of those variables.
    * @return a table mapping constant variable elements to the declarations of those variables
    */
   Map<VariableElement, VariableDeclaration> get variableMap => _variableMap;
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
-    if (initializer != null && node.isConst()) {
+    if (initializer != null && node.isConst) {
       VariableElement element = node.element;
       if (element != null) {
         _variableMap[element] = node;
       }
     }
     return null;
   }
 }
 /**
  * Instances of the class `ConstantValueComputer` compute the values of constant variables in
@@ skipping 32 matching lines @@
    * Compute values for all of the constant variables in the compilation units that were added.
    */
   void computeValues() {
     _declarationMap = _constantFinder.variableMap;
     for (MapEntry<VariableElement, VariableDeclaration> entry in getMapEntrySet(_declarationMap)) {
       VariableElement element = entry.getKey();
       ReferenceFinder referenceFinder = new ReferenceFinder(element, _referenceGraph);
       _referenceGraph.addNode(element);
       entry.getValue().initializer.accept(referenceFinder);
     }
-    while (!_referenceGraph.isEmpty()) {
+    while (!_referenceGraph.isEmpty) {
       VariableElement element = _referenceGraph.removeSink();
       while (element != null) {
         computeValueFor(element);
         element = _referenceGraph.removeSink();
       }
-      if (!_referenceGraph.isEmpty()) {
+      if (!_referenceGraph.isEmpty) {
         List<VariableElement> variablesInCycle = _referenceGraph.findCycle();
         if (variablesInCycle == null) {
           AnalysisEngine.instance.logger.logError("Exiting constant value computer with ${_referenceGraph.nodeCount} variables that are neither sinks no in a cycle");
           return;
         }
         for (VariableElement variable in variablesInCycle) {
           generateCycleError(variablesInCycle, variable);
         }
         _referenceGraph.removeAllNodes(variablesInCycle);
       }
@@ skipping 67 matching lines @@
         result = result.concatenate(node, string.accept(this));
       }
     }
     return result;
   }
   EvaluationResultImpl visitBinaryExpression(BinaryExpression node) {
     EvaluationResultImpl leftResult = node.leftOperand.accept(this);
     EvaluationResultImpl rightResult = node.rightOperand.accept(this);
     TokenType operatorType = node.operator.type;
     if (operatorType != TokenType.BANG_EQ && operatorType != TokenType.EQ_EQ) {
-      if (leftResult is ValidResult && ((leftResult as ValidResult)).isNull() || rightResult is ValidResult && ((rightResult as ValidResult)).isNull()) {
+      if (leftResult is ValidResult && ((leftResult as ValidResult)).isNull || rightResult is ValidResult && ((rightResult as ValidResult)).isNull) {
         return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
       }
     }
     while (true) {
       if (operatorType == TokenType.AMPERSAND) {
         return leftResult.bitAnd(node, rightResult);
       } else if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
         return leftResult.logicalAnd(node, rightResult);
       } else if (operatorType == TokenType.BANG_EQ) {
         return leftResult.notEqual(node, rightResult);
@@ skipping 31 matching lines @@
         return leftResult.integerDivide(node, rightResult);
       }
       break;
     }
     return error(node, null);
   }
   EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => node.value ? ValidResult.RESULT_TRUE : ValidResult.RESULT_FALSE;
   EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => new ValidResult(node.value);
   EvaluationResultImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement constructor = node.element;
-    if (constructor != null && constructor.isConst()) {
+    if (constructor != null && constructor.isConst) {
       node.argumentList.accept(this);
       return ValidResult.RESULT_OBJECT;
     }
     return error(node, null);
   }
   EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => new ValidResult(node.value);
   EvaluationResultImpl visitInterpolationExpression(InterpolationExpression node) {
     EvaluationResultImpl result = node.expression.accept(this);
     return result.performToString(node);
   }
@@ skipping 28 matching lines @@
   EvaluationResultImpl visitMethodInvocation(MethodInvocation node) {
     Element element = node.methodName.element;
     if (element is FunctionElement) {
       FunctionElement function = element as FunctionElement;
       if (function.name == "identical") {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 2) {
           Element enclosingElement = function.enclosingElement;
           if (enclosingElement is CompilationUnitElement) {
             LibraryElement library = ((enclosingElement as CompilationUnitElement)).library;
-            if (library.isDartCore()) {
+            if (library.isDartCore) {
               EvaluationResultImpl leftArgument = arguments[0].accept(this);
               EvaluationResultImpl rightArgument = arguments[1].accept(this);
               return leftArgument.equalEqual(node, rightArgument);
             }
           }
         }
       }
     }
     return error(node, null);
   }
   EvaluationResultImpl visitNode(ASTNode node) => error(node, null);
   EvaluationResultImpl visitNullLiteral(NullLiteral node) => ValidResult.RESULT_NULL;
   EvaluationResultImpl visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
   EvaluationResultImpl visitPrefixedIdentifier(PrefixedIdentifier node) => getConstantValue(node, node.element);
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
     EvaluationResultImpl operand = node.operand.accept(this);
-    if (operand is ValidResult && ((operand as ValidResult)).isNull()) {
+    if (operand is ValidResult && ((operand as ValidResult)).isNull) {
       return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         return operand.logicalNot(node);
       } else if (node.operator.type == TokenType.TILDE) {
         return operand.bitNot(node);
       } else if (node.operator.type == TokenType.MINUS) {
         return operand.negated(node);
       }
@@ skipping 136 matching lines @@
     if (tails == null) {
       return new Set<N>();
     }
     return tails;
   }
 
   /**
    * Return `true` if this graph is empty.
    * @return `true` if this graph is empty
    */
-  bool isEmpty() => _edges.isEmpty;
+  bool get isEmpty => _edges.isEmpty;
 
   /**
    * Remove all of the given nodes from this graph. As a consequence, any edges for which those
    * nodes were either a head or a tail will also be removed.
    * @param nodes the nodes to be removed
    */
   void removeAllNodes(List<N> nodes) {
     for (N node in nodes) {
       removeNode(node);
     }
@@ skipping 293 matching lines @@
     this._source = source;
     this._referenceGraph = referenceGraph;
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.element;
     if (element is PropertyAccessorElement) {
       element = ((element as PropertyAccessorElement)).variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
-      if (variable.isConst()) {
+      if (variable.isConst) {
         _referenceGraph.addEdge(_source, variable);
       }
     }
     return null;
   }
 }
 /**
  * Instances of the class `ValidResult` represent the result of attempting to evaluate a valid
  * compile time constant expression.
  */
@@ skipping 58 matching lines @@
   /**
    * Initialize a newly created result to represent the given value.
    * @param value the value of the expression
    */
   ValidResult(Object value) {
     this._value = value;
   }
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToValid(node, this);
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndValid(node, this);
   EvaluationResultImpl bitNot(Expression node) {
-    if (isSomeInt()) {
+    if (isSomeInt) {
       return RESULT_INT;
     }
     if (_value == null) {
       return error(node);
     } else if (_value is int) {
       return valueOf(~((_value as int)));
     }
     return error(node);
   }
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitOrValid(node, this);
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitXorValid(node, this);
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand) => rightOperand.concatenateValid(node, this);
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.divideValid(node, this);
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand) => rightOperand.equalEqualValid(node, this);
   bool equalValues(EvaluationResultImpl result) => identical(equalEqual(null, result), RESULT_TRUE);
   Object get value => _value;
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanValid(node, this);
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanOrEqualValid(node, this);
   EvaluationResultImpl integerDivide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.integerDivideValid(node, this);
   EvaluationResultImpl lessThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanValid(node, this);
   EvaluationResultImpl lessThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanOrEqualValid(node, this);
   EvaluationResultImpl logicalAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalAndValid(node, this);
   EvaluationResultImpl logicalNot(Expression node) {
-    if (isSomeBool()) {
+    if (isSomeBool) {
       return RESULT_BOOL;
     }
     if (_value == null) {
       return RESULT_TRUE;
     } else if (_value is bool) {
       return ((_value as bool)) ? RESULT_FALSE : RESULT_TRUE;
     }
     return error(node);
   }
   EvaluationResultImpl logicalOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalOrValid(node, this);
   EvaluationResultImpl minus(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.minusValid(node, this);
   EvaluationResultImpl negated(Expression node) {
-    if (isSomeNum()) {
+    if (isSomeNum) {
       return RESULT_INT;
     }
     if (_value == null) {
       return error(node);
     } else if (_value is int) {
       return valueOf(-((_value as int)));
     } else if (_value is double) {
       return valueOf3(-((_value as double)));
     }
     return error(node);
@@ skipping 18 matching lines @@
   EvaluationResultImpl shiftRight(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftRightValid(node, this);
   EvaluationResultImpl times(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.timesValid(node, this);
   String toString() {
     if (_value == null) {
       return "null";
     }
     return _value.toString();
   }
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_NUM;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
@@ skipping 10 matching lines @@
       }
     } else if (leftValue is String) {
       if (_value is String) {
         return valueOf4("${((leftValue as String))}${((_value as String))}");
       }
     }
     return error(node);
   }
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeInt() || leftOperand2.isSomeInt()) {
-      if (isAnyInt() && leftOperand2.isAnyInt()) {
+    if (isSomeInt || leftOperand2.isSomeInt) {
+      if (isAnyInt && leftOperand2.isAnyInt) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) & (_value as int));
       }
       return error(node.leftOperand);
     }
     if (_value is int) {
       return error(node.rightOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl bitOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeInt() || leftOperand2.isSomeInt()) {
-      if (isAnyInt() && leftOperand2.isAnyInt()) {
+    if (isSomeInt || leftOperand2.isSomeInt) {
+      if (isAnyInt && leftOperand2.isAnyInt) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) | (_value as int));
       }
       return error(node.leftOperand);
     }
     if (_value is int) {
       return error(node.rightOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl bitXorError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeInt() || leftOperand2.isSomeInt()) {
-      if (isAnyInt() && leftOperand2.isAnyInt()) {
+    if (isSomeInt || leftOperand2.isSomeInt) {
+      if (isAnyInt && leftOperand2.isAnyInt) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
@@ skipping 10 matching lines @@
   EvaluationResultImpl concatenateError(Expression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl concatenateValid(Expression node, ValidResult leftOperand) {
     Object leftValue = leftOperand.value;
     if (leftValue is String && _value is String) {
       return valueOf4("${((leftValue as String))}${((_value as String))}");
     }
     return error(node);
   }
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_NUM;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
@@ skipping 10 matching lines @@
         return valueOf3(((leftValue as double)) / ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf3(((leftValue as double)) / ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl equalEqualError(Expression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl equalEqualValid(Expression node, ValidResult leftOperand) {
     if (node is BinaryExpression) {
-      if (!isAnyNullBoolNumString() || !leftOperand.isAnyNullBoolNumString()) {
+      if (!isAnyNullBoolNumString || !leftOperand.isAnyNullBoolNumString) {
         return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
       }
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return valueOf2(_value == null);
     } else if (leftValue is bool) {
       if (_value is bool) {
         return valueOf2(identical(((leftValue as bool)), ((_value as bool))));
       }
@@ skipping 16 matching lines @@
       if (_value is String) {
         return valueOf2(((leftValue as String)) == _value);
       }
       return RESULT_FALSE;
     }
     return RESULT_FALSE;
   }
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf2(((leftValue as int)).compareTo((_value as int)) >= 0);
       } else if (_value is double) {
         return valueOf2(((leftValue as int)).toDouble() >= ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf2(((leftValue as double)) >= ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf2(((leftValue as double)) >= ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf2(((leftValue as int)).compareTo((_value as int)) > 0);
       } else if (_value is double) {
         return valueOf2(((leftValue as int)).toDouble() > ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf2(((leftValue as double)) > ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf2(((leftValue as double)) > ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
@@ skipping 13 matching lines @@
       } else if (_value is double) {
         double result = ((leftValue as double)) / ((_value as double));
         return valueOf(result.toInt());
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf2(((leftValue as int)).compareTo((_value as int)) <= 0);
       } else if (_value is double) {
         return valueOf2(((leftValue as int)).toDouble() <= ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf2(((leftValue as double)) <= ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf2(((leftValue as double)) <= ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf2(((leftValue as int)).compareTo((_value as int)) < 0);
       } else if (_value is double) {
         return valueOf2(((leftValue as int)).toDouble() < ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf2(((leftValue as double)) < ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf2(((leftValue as double)) < ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl logicalAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl logicalAndValid(BinaryExpression node, ValidResult leftOperand) {
-    if (isSomeBool() || leftOperand.isSomeBool()) {
-      if (isAnyBool() && leftOperand.isAnyBool()) {
+    if (isSomeBool || leftOperand.isSomeBool) {
+      if (isAnyBool && leftOperand.isAnyBool) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL);
     }
     Object leftValue = leftOperand.value;
     if (leftValue is bool) {
       if (((leftValue as bool))) {
         return booleanConversion(node.rightOperand, _value);
       }
       return RESULT_FALSE;
     }
     return error(node);
   }
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl logicalOrValid(BinaryExpression node, ValidResult leftOperand) {
-    if (isSomeBool() || leftOperand.isSomeBool()) {
-      if (isAnyBool() && leftOperand.isAnyBool()) {
+    if (isSomeBool || leftOperand.isSomeBool) {
+      if (isAnyBool && leftOperand.isAnyBool) {
         return RESULT_BOOL;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL);
     }
     Object leftValue = leftOperand.value;
     if (leftValue is bool && ((leftValue as bool))) {
       return RESULT_TRUE;
     }
     return booleanConversion(node.rightOperand, _value);
   }
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_NUM;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) - (_value as int));
       } else if (_value is double) {
         return valueOf3(((leftValue as int)).toDouble() - ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf3(((leftValue as double)) - ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf3(((leftValue as double)) - ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl notEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl notEqualValid(BinaryExpression node, ValidResult leftOperand) {
-    if (!isAnyNullBoolNumString() || !leftOperand.isAnyNullBoolNumString()) {
+    if (!isAnyNullBoolNumString || !leftOperand.isAnyNullBoolNumString) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return valueOf2(_value != null);
     } else if (leftValue is bool) {
       if (_value is bool) {
         return valueOf2(((leftValue as bool)) != ((_value as bool)));
       }
       return RESULT_TRUE;
@@ skipping 14 matching lines @@
     } else if (leftValue is String) {
       if (_value is String) {
         return valueOf2(((leftValue as String)) != _value);
       }
       return RESULT_TRUE;
     }
     return RESULT_TRUE;
   }
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_NUM;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         if (((_value as int)) == 0) {
           return valueOf3(((leftValue as int)).toDouble() % ((_value as int)).toDouble());
         }
         return valueOf(((leftValue as int)).remainder((_value as int)));
       } else if (_value is double) {
         return valueOf3(((leftValue as int)).toDouble() % ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf3(((leftValue as double)) % ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf3(((leftValue as double)) % ((_value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeInt() || leftOperand2.isSomeInt()) {
-      if (isAnyInt() && leftOperand2.isAnyInt()) {
+    if (isSomeInt || leftOperand2.isSomeInt) {
+      if (isAnyInt && leftOperand2.isAnyInt) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) << ((_value as int)));
       }
       return error(node.rightOperand);
     }
     if (_value is int) {
       return error(node.leftOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl shiftRightError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeInt() || leftOperand2.isSomeInt()) {
-      if (isAnyInt() && leftOperand2.isAnyInt()) {
+    if (isSomeInt || leftOperand2.isSomeInt) {
+      if (isAnyInt && leftOperand2.isAnyInt) {
         return RESULT_INT;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) >> ((_value as int)));
       }
       return error(node.rightOperand);
     }
     if (_value is int) {
       return error(node.leftOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl timesValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (isSomeNum() || leftOperand2.isSomeNum()) {
-      if (isAnyNum() && leftOperand2.isAnyNum()) {
+    if (isSomeNum || leftOperand2.isSomeNum) {
+      if (isAnyNum && leftOperand2.isAnyNum) {
         return RESULT_NUM;
       }
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (_value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (_value is int) {
         return valueOf(((leftValue as int)) * (_value as int));
       } else if (_value is double) {
         return valueOf3(((leftValue as int)).toDouble() * ((_value as double)));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         return valueOf3(((leftValue as double)) * ((_value as int)).toDouble());
       } else if (_value is double) {
         return valueOf3(((leftValue as double)) * ((_value as double)));
       }
     }
     return error(node);
   }
-  bool isNull() => identical(this, RESULT_NULL);
+  bool get isNull => identical(this, RESULT_NULL);
 
   /**
    * Return the result of applying boolean conversion to the given value.
    * @param node the node against which errors should be reported
    * @param value the value to be converted to a boolean
    * @return the result of applying boolean conversion to the given value
    */
   EvaluationResultImpl booleanConversion(ASTNode node, Object value) {
     if (value is bool) {
       if (((value as bool))) {
@@ skipping 10 matching lines @@
    * Return a result object representing an error associated with the given node.
    * @param node the AST node associated with the error
    * @param code the error code indicating the nature of the error
    * @return a result object representing an error associated with the given node
    */
   ErrorResult error2(ASTNode node, ErrorCode code) => new ErrorResult.con1(node, code);
 
   /**
    * Checks if this result has type "bool", with known or unknown value.
    */
-  bool isAnyBool() => isSomeBool() || identical(this, RESULT_TRUE) || identical(this, RESULT_FALSE);
+  bool get isAnyBool => isSomeBool || identical(this, RESULT_TRUE) || identical(this, RESULT_FALSE);
 
   /**
    * Checks if this result has type "int", with known or unknown value.
    */
-  bool isAnyInt() => identical(this, RESULT_INT) || _value is int;
+  bool get isAnyInt => identical(this, RESULT_INT) || _value is int;
 
   /**
    * Checks if this result has one of the types - "bool", "num" or "string"; or may be `null`.
    */
-  bool isAnyNullBoolNumString() => isNull() || isAnyBool() || isAnyNum() || _value is String;
+  bool get isAnyNullBoolNumString => isNull || isAnyBool || isAnyNum || _value is String;
 
   /**
    * Checks if this result has type "num", with known or unknown value.
    */
-  bool isAnyNum() => isSomeNum() || _value is num;
+  bool get isAnyNum => isSomeNum || _value is num;
 
   /**
    * Checks if this result has type "bool", exact value of which we don't know.
    */
-  bool isSomeBool() => identical(this, RESULT_BOOL);
+  bool get isSomeBool => identical(this, RESULT_BOOL);
 
   /**
    * Checks if this result has type "int", exact value of which we don't know.
    */
-  bool isSomeInt() => identical(this, RESULT_INT);
+  bool get isSomeInt => identical(this, RESULT_INT);
 
   /**
    * Checks if this result has type "num" (or "int"), exact value of which we don't know.
    */
-  bool isSomeNum() => identical(this, RESULT_DYNAMIC) || identical(this, RESULT_INT) || identical(this, RESULT_NUM);
+  bool get isSomeNum => identical(this, RESULT_DYNAMIC) || identical(this, RESULT_INT) || identical(this, RESULT_NUM);
   double toDouble(int value) => value.toDouble();
 
   /**
    * Return an error result that is the union of the two given error results.
    * @param firstError the first error to be combined
    * @param secondError the second error to be combined
    * @return an error result that is the union of the two given error results
    */
   ErrorResult union(ErrorResult firstError, ErrorResult secondError) => new ErrorResult.con2(firstError, secondError);
 
@@ skipping 18 matching lines @@
    */
   ValidResult valueOf3(double value) => new ValidResult(value);
 
   /**
    * Return a result object representing the given value.
    * @param value the value to be represented as a result object
    * @return a result object representing the given value
    */
   ValidResult valueOf4(String value) => new ValidResult(value);
 }