New analyzer_experimental snapshot.

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;
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
  * * A reference to a static constant variable.
- * * An identifier expression that denotes a constant variable, a class or a type variable.
+ * * An identifier expression that denotes a constant variable, a class or a type parameter.
  * * A constant constructor invocation.
  * * A constant list literal.
  * * A constant map literal.
  * * A simple or qualified identifier denoting a top-level function or a static method.
  * * A parenthesized expression `(e)` where `e` is a constant expression.
  * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,
  * `e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
  * numeric, string or boolean value or to `null`.
  * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where
  * `e`, `e1` and `e2` are constant expressions that evaluate to a boolean value or
@@ skipping 230 matching lines @@
  * Instances of the class `ConstantVisitor` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
  * * A reference to a static constant variable.
- * * An identifier expression that denotes a constant variable, a class or a type variable.
+ * * An identifier expression that denotes a constant variable, a class or a type parameter.
  * * A constant constructor invocation.
  * * A constant list literal.
  * * A constant map literal.
  * * A simple or qualified identifier denoting a top-level function or a static method.
  * * A parenthesized expression `(e)` where `e` is a constant expression.
  * * An expression of one of the forms `identical(e1, e2)`, `e1 == e2`,
  * `e1 != e2` where `e1` and `e2` are constant expressions that evaluate to a
  * numeric, string or boolean value or to `null`.
  * * An expression of one of the forms `!e`, `e1 && e2` or `e1 || e2`, where
  * `e`, `e1` and `e2` are constant expressions that evaluate to a boolean value or
@@ skipping 67 matching lines @@
       } else if (operatorType == TokenType.SLASH) {
         return leftResult.divide(node, rightResult);
       } else if (operatorType == TokenType.TILDE_SLASH) {
         return leftResult.integerDivide(node, rightResult);
       }
       break;
     }
     return error(node, null);
   }
   EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => node.value ? ValidResult.RESULT_TRUE : ValidResult.RESULT_FALSE;
+  EvaluationResultImpl visitConditionalExpression(ConditionalExpression node) {
+    Expression condition = node.condition;
+    EvaluationResultImpl conditionResult = condition.accept(this);
+    conditionResult = conditionResult.applyBooleanConversion(condition);
+    if (conditionResult is ErrorResult) {
+      return conditionResult;
+    }
+    EvaluationResultImpl thenResult = node.thenExpression.accept(this);
+    if (thenResult is ErrorResult) {
+      return thenResult;
+    }
+    EvaluationResultImpl elseResult = node.elseExpression.accept(this);
+    if (elseResult is ErrorResult) {
+      return elseResult;
+    }
+    return (identical(conditionResult, ValidResult.RESULT_TRUE)) ? thenResult : elseResult;
+  }
   EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => new ValidResult(node.value);
   EvaluationResultImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (!node.isConst) {
       return error(node, null);
     }
     ConstructorElement constructor = node.staticElement;
     if (constructor != null && constructor.isConst) {
       node.argumentList.accept(this);
       return ValidResult.RESULT_OBJECT;
     }
@@ skipping 341 matching lines @@
    * objects.
    *
    * @param firstResult the first set of results being merged
    * @param secondResult the second set of results being merged
    */
   ErrorResult.con2(ErrorResult firstResult, ErrorResult secondResult) {
     errorData.addAll(firstResult.errorData);
     errorData.addAll(secondResult.errorData);
   }
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToError(node, this);
+  EvaluationResultImpl applyBooleanConversion(ASTNode node) => this;
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndError(node, this);
   EvaluationResultImpl bitNot(Expression node) => this;
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitOrError(node, this);
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitXorError(node, this);
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand) => rightOperand.concatenateError(node, this);
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.divideError(node, this);
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand) => rightOperand.equalEqualError(node, this);
   bool equalValues(EvaluationResultImpl result) => false;
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanError(node, this);
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanOrEqualError(node, this);
@@ skipping 75 matching lines @@
     this.node = node;
     this.errorCode = errorCode;
   }
 }
 /**
  * Instances of the class `InternalResult` represent the result of attempting to evaluate a
  * expression.
  */
 abstract class EvaluationResultImpl {
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand);
+
+  /**
+   * Return the result of applying boolean conversion to this result.
+   *
+   * @param node the node against which errors should be reported
+   * @return the result of applying boolean conversion to the given value
+   */
+  EvaluationResultImpl applyBooleanConversion(ASTNode node);
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl bitNot(Expression node);
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand);
   bool equalValues(EvaluationResultImpl result);
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand);
@@ skipping 159 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);
+
+  /**
+   * Return the result of applying boolean conversion to this result.
+   *
+   * @param node the node against which errors should be reported
+   * @return the result of applying boolean conversion to the given value
+   */
+  EvaluationResultImpl applyBooleanConversion(ASTNode node) => booleanConversion(node, value);
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndValid(node, this);
   EvaluationResultImpl bitNot(Expression node) {
     if (isSomeInt) {
       return RESULT_INT;
     }
     if (value == null) {
       return error(node);
     } else if (value is int) {
       return valueOf(~((value as int)));
     }
@@ skipping 697 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);
 }