Roll Observatory packages and add a roll script

packages/analyzer/lib/src/generated/constant.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.
 
-// 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 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/dart.dart';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 192 matching lines @@
       "(?!${ConstantValueComputer._RESERVED_WORD_RE}\\b(?!\\\$))[a-zA-Z\$][\\w\$]*";
 
   /**
    * RegExp that validates a non-empty non-private symbol.
    * From sdk/lib/internal/symbol.dart.
    */
   static RegExp _PUBLIC_SYMBOL_PATTERN = new RegExp(
       "^(?:${ConstantValueComputer._OPERATOR_RE}\$|$_PUBLIC_IDENTIFIER_RE(?:=?\$|[.](?!\$)))+?\$");
 
   /**
+   * The type provider used to access the known types.
+   */
+  final TypeProvider typeProvider;
+
+  /**
    * The type system.  This is used to gues the types of constants when their
    * exact value is unknown.
    */
   final TypeSystem typeSystem;
 
   /**
    * The set of variables declared on the command line using '-D'.
    */
   final DeclaredVariables _declaredVariables;
 
   /**
    * Validator used to verify correct dependency analysis when running unit
    * tests.
    */
   final ConstantEvaluationValidator validator;
 
   /**
    * Initialize a newly created [ConstantEvaluationEngine].  The [typeProvider]
    * is used to access known types.  [_declaredVariables] is the set of
    * variables declared on the command line using '-D'.  The [validator], if
    * given, is used to verify correct dependency analysis when running unit
    * tests.
    */
-  ConstantEvaluationEngine(TypeProvider typeProvider, this._declaredVariables,
-      {ConstantEvaluationValidator validator})
+  ConstantEvaluationEngine(this.typeProvider, this._declaredVariables,
+      {ConstantEvaluationValidator validator, TypeSystem typeSystem})
       : validator = validator != null
-          ? validator
-          : new ConstantEvaluationValidator_ForProduction(),
-        typeSystem = new TypeSystemImpl(typeProvider);
-
-  /**
-   * The type provider used to access the known types.
-   */
-  TypeProvider get typeProvider => typeSystem.typeProvider;
+            ? validator
+            : new ConstantEvaluationValidator_ForProduction(),
+        typeSystem = typeSystem != null ? typeSystem : new TypeSystemImpl();
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct. The
    * [arguments] are the AST nodes of the arguments. The [argumentValues] are
    * the values of the unnamed arguments. The [namedArgumentValues] are the
    * values of the named arguments. The [expectedDefaultValueType] is the
    * allowed type of the "defaultValue" parameter (if present). Note:
    * "defaultValue" is always allowed to be null. Return `true` if the arguments
    * are correct, `false` if there is an error.
    */
-  bool checkFromEnvironmentArguments(NodeList<Expression> arguments,
+  bool checkFromEnvironmentArguments(
+      NodeList<Expression> arguments,
       List<DartObjectImpl> argumentValues,
       HashMap<String, DartObjectImpl> namedArgumentValues,
       InterfaceType expectedDefaultValueType) {
     int argumentCount = arguments.length;
     if (argumentCount < 1 || argumentCount > 2) {
       return false;
     }
     if (arguments[0] is NamedExpression) {
       return false;
     }
@@ skipping 18 matching lines @@
     return true;
   }
 
   /**
    * Check that the arguments to a call to Symbol() are correct. The [arguments]
    * are the AST nodes of the arguments. The [argumentValues] are the values of
    * the unnamed arguments. The [namedArgumentValues] are the values of the
    * named arguments. Return `true` if the arguments are correct, `false` if
    * there is an error.
    */
-  bool checkSymbolArguments(NodeList<Expression> arguments,
+  bool checkSymbolArguments(
+      NodeList<Expression> arguments,
       List<DartObjectImpl> argumentValues,
       HashMap<String, DartObjectImpl> namedArgumentValues) {
     if (arguments.length != 1) {
       return false;
     }
     if (arguments[0] is NamedExpression) {
       return false;
     }
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
@@ skipping 31 matching lines @@
         DartObjectImpl dartObject = constantInitializer
             .accept(new ConstantVisitor(this, errorReporter));
         // Only check the type for truly const declarations (don't check final
         // fields with initializers, since their types may be generic.  The type
         // of the final field will be checked later, when the constructor is
         // invoked).
         if (dartObject != null && constant.isConst) {
           if (!runtimeTypeMatch(dartObject, constant.type)) {
             errorReporter.reportErrorForElement(
                 CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
-                constant, [dartObject.type, constant.type]);
+                constant,
+                [dartObject.type, constant.type]);
           }
         }
         (constant as VariableElementImpl).evaluationResult =
             new EvaluationResultImpl(dartObject, errorListener.errors);
       }
     } else if (constant is ConstructorElement) {
       if (constant.isConst) {
         // No evaluation needs to be done; constructor declarations are only in
         // the dependency graph to ensure that any constants referred to in
         // initializer lists and parameter defaults are evaluated before
@@ skipping 27 matching lines @@
         } else if (element is ConstructorElementImpl &&
             element.isConst &&
             constNode.arguments != null) {
           RecordingErrorListener errorListener = new RecordingErrorListener();
           CompilationUnit sourceCompilationUnit =
               constNode.getAncestor((node) => node is CompilationUnit);
           ErrorReporter errorReporter = new ErrorReporter(
               errorListener, sourceCompilationUnit.element.source);
           ConstantVisitor constantVisitor =
               new ConstantVisitor(this, errorReporter);
-          DartObjectImpl result = evaluateConstructorCall(constNode,
-              constNode.arguments.arguments, element, constantVisitor,
+          DartObjectImpl result = evaluateConstructorCall(
+              constNode,
+              constNode.arguments.arguments,
+              element,
+              constantVisitor,
               errorReporter);
           elementAnnotation.evaluationResult =
               new EvaluationResultImpl(result, errorListener.errors);
         } else {
           // This may happen for invalid code (e.g. failing to pass arguments
           // to an annotation which references a const constructor).  The error
           // is detected elsewhere, so just silently ignore it here.
           elementAnnotation.evaluationResult = new EvaluationResultImpl(null);
         }
       }
@@ skipping 124 matching lines @@
 
   /**
    * Evaluate a call to fromEnvironment() on the bool, int, or String class. The
    * [environmentValue] is the value fetched from the environment. The
    * [builtInDefaultValue] is the value that should be used as the default if no
    * "defaultValue" argument appears in [namedArgumentValues]. The
    * [namedArgumentValues] are the values of the named parameters passed to
    * fromEnvironment(). Return a [DartObjectImpl] object corresponding to the
    * evaluated result.
    */
-  DartObjectImpl computeValueFromEnvironment(DartObject environmentValue,
+  DartObjectImpl computeValueFromEnvironment(
+      DartObject environmentValue,
       DartObjectImpl builtInDefaultValue,
       HashMap<String, DartObjectImpl> namedArgumentValues) {
     DartObjectImpl value = environmentValue as DartObjectImpl;
     if (value.isUnknown || value.isNull) {
       // The name either doesn't exist in the environment or we couldn't parse
       // the corresponding value.
       // If the code supplied an explicit default, use it.
       if (namedArgumentValues.containsKey(_DEFAULT_VALUE_PARAM)) {
         value = namedArgumentValues[_DEFAULT_VALUE_PARAM];
       } else if (value.isNull) {
         // The code didn't supply an explicit default.
         // The name exists in the environment but we couldn't parse the
         // corresponding value.
         // So use the built-in default value, because this is what the VM does.
         value = builtInDefaultValue;
       } else {
         // The code didn't supply an explicit default.
         // The name doesn't exist in the environment.
         // The VM would use the built-in default value, but we don't want to do
         // that for analysis because it's likely to lead to cascading errors.
         // So just leave [value] in the unknown state.
       }
     }
     return value;
   }
 
-  DartObjectImpl evaluateConstructorCall(AstNode node,
-      NodeList<Expression> arguments, ConstructorElement constructor,
-      ConstantVisitor constantVisitor, ErrorReporter errorReporter) {
+  DartObjectImpl evaluateConstructorCall(
+      AstNode node,
+      NodeList<Expression> arguments,
+      ConstructorElement constructor,
+      ConstantVisitor constantVisitor,
+      ErrorReporter errorReporter) {
     if (!_getConstructorBase(constructor).isCycleFree) {
       // It's not safe to evaluate this constructor, so bail out.
       // TODO(paulberry): ensure that a reasonable error message is produced
       // in this case, as well as other cases involving constant expression
       // circularities (e.g. "compile-time constant expression depends on
       // itself")
       return new DartObjectImpl.validWithUnknownValue(constructor.returnType);
     }
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues =
@@ skipping 28 matching lines @@
           errorReporter.reportErrorForNode(
               CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           return null;
         }
         String variableName =
             argumentCount < 1 ? null : argumentValues[0].stringValue;
         if (identical(definingClass, typeProvider.boolType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment =
               _declaredVariables.getBool(typeProvider, variableName);
-          return computeValueFromEnvironment(valueFromEnvironment,
+          return computeValueFromEnvironment(
+              valueFromEnvironment,
               new DartObjectImpl(typeProvider.boolType, BoolState.FALSE_STATE),
               namedArgumentValues);
         } else if (identical(definingClass, typeProvider.intType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment =
               _declaredVariables.getInt(typeProvider, variableName);
-          return computeValueFromEnvironment(valueFromEnvironment,
+          return computeValueFromEnvironment(
+              valueFromEnvironment,
               new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE),
               namedArgumentValues);
         } else if (identical(definingClass, typeProvider.stringType)) {
           DartObject valueFromEnvironment;
           valueFromEnvironment =
               _declaredVariables.getString(typeProvider, variableName);
-          return computeValueFromEnvironment(valueFromEnvironment,
+          return computeValueFromEnvironment(
+              valueFromEnvironment,
               new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE),
               namedArgumentValues);
         }
       } else if (constructor.name == "" &&
           identical(definingClass, typeProvider.symbolType) &&
           argumentCount == 1) {
         if (!checkSymbolArguments(
             arguments, argumentValues, namedArgumentValues)) {
           errorReporter.reportErrorForNode(
               CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
@@ skipping 31 matching lines @@
           !field.isStatic &&
           field is ConstFieldElementImpl) {
         validator.beforeGetFieldEvaluationResult(field);
         EvaluationResultImpl evaluationResult = field.evaluationResult;
         DartType fieldType =
             FieldMember.from(field, constructor.returnType).type;
         DartObjectImpl fieldValue = evaluationResult.value;
         if (fieldValue != null && !runtimeTypeMatch(fieldValue, fieldType)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
-              node, [fieldValue.type, field.name, fieldType]);
+              node,
+              [fieldValue.type, field.name, fieldType]);
         }
         fieldMap[field.name] = evaluationResult.value;
       }
     }
     // Now evaluate the constructor declaration.
     HashMap<String, DartObjectImpl> parameterMap =
         new HashMap<String, DartObjectImpl>();
     List<ParameterElement> parameters = constructor.parameters;
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
@@ skipping 26 matching lines @@
           // No default was provided, so the default value is null.
           argumentValue = typeProvider.nullObject;
         } else if (evaluationResult.value != null) {
           argumentValue = evaluationResult.value;
         }
       }
       if (argumentValue != null) {
         if (!runtimeTypeMatch(argumentValue, parameter.type)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
-              errorTarget, [argumentValue.type, parameter.type]);
+              errorTarget,
+              [argumentValue.type, parameter.type]);
         }
         if (baseParameter.isInitializingFormal) {
           FieldElement field = (parameter as FieldFormalParameterElement).field;
           if (field != null) {
             DartType fieldType = field.type;
             if (fieldType != parameter.type) {
               // We've already checked that the argument can be assigned to the
               // parameter; we also need to check that it can be assigned to
               // the field.
               if (!runtimeTypeMatch(argumentValue, fieldType)) {
                 errorReporter.reportErrorForNode(
                     CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
-                    errorTarget, [argumentValue.type, fieldType]);
+                    errorTarget,
+                    [argumentValue.type, fieldType]);
               }
             }
             String fieldName = field.name;
             if (fieldMap.containsKey(fieldName)) {
               errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
             }
             fieldMap[fieldName] = argumentValue;
           }
         } else {
           String name = baseParameter.name;
           parameterMap[name] = argumentValue;
         }
       }
     }
     ConstantVisitor initializerVisitor = new ConstantVisitor(
-        this, errorReporter, lexicalEnvironment: parameterMap);
+        this, errorReporter,
+        lexicalEnvironment: parameterMap);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = initializer;
         Expression initializerExpression =
             constructorFieldInitializer.expression;
         DartObjectImpl evaluationResult =
             initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
           String fieldName = constructorFieldInitializer.fieldName.name;
           if (fieldMap.containsKey(fieldName)) {
             errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           }
           fieldMap[fieldName] = evaluationResult;
           PropertyAccessorElement getter = definingClass.getGetter(fieldName);
           if (getter != null) {
             PropertyInducingElement field = getter.variable;
             if (!runtimeTypeMatch(evaluationResult, field.type)) {
               errorReporter.reportErrorForNode(
                   CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
-                  node, [evaluationResult.type, fieldName, field.type]);
+                  node,
+                  [evaluationResult.type, fieldName, field.type]);
             }
           }
         }
       } else if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superConstructorInvocation = initializer;
         SimpleIdentifier name = superConstructorInvocation.constructorName;
         if (name != null) {
           superName = name.name;
         }
         superArguments = superConstructorInvocation.argumentList.arguments;
       } else if (initializer is RedirectingConstructorInvocation) {
         // This is a redirecting constructor, so just evaluate the constructor
         // it redirects to.
         ConstructorElement constructor = initializer.staticElement;
         if (constructor != null && constructor.isConst) {
-          return evaluateConstructorCall(node,
-              initializer.argumentList.arguments, constructor,
-              initializerVisitor, errorReporter);
+          return evaluateConstructorCall(
+              node,
+              initializer.argumentList.arguments,
+              constructor,
+              initializerVisitor,
+              errorReporter);
         }
       }
     }
     // Evaluate explicit or implicit call to super().
     InterfaceType superclass = definingClass.superclass;
     if (superclass != null && !superclass.isObject) {
       ConstructorElement superConstructor =
           superclass.lookUpConstructor(superName, constructor.library);
       if (superConstructor != null) {
         if (superArguments == null) {
           superArguments = new NodeList<Expression>(null);
         }
         evaluateSuperConstructorCall(node, fieldMap, superConstructor,
             superArguments, initializerVisitor, errorReporter);
       }
     }
     return new DartObjectImpl(definingClass, new GenericState(fieldMap));
   }
 
-  void evaluateSuperConstructorCall(AstNode node,
+  void evaluateSuperConstructorCall(
+      AstNode node,
       HashMap<String, DartObjectImpl> fieldMap,
-      ConstructorElement superConstructor, NodeList<Expression> superArguments,
-      ConstantVisitor initializerVisitor, ErrorReporter errorReporter) {
+      ConstructorElement superConstructor,
+      NodeList<Expression> superArguments,
+      ConstantVisitor initializerVisitor,
+      ErrorReporter errorReporter) {
     if (superConstructor != null && superConstructor.isConst) {
       DartObjectImpl evaluationResult = evaluateConstructorCall(node,
           superArguments, superConstructor, initializerVisitor, errorReporter);
       if (evaluationResult != null) {
         fieldMap[GenericState.SUPERCLASS_FIELD] = evaluationResult;
       }
     }
   }
 
   /**
@@ skipping 145 matching lines @@
   bool operator ==(other) {
     if (other is ConstantEvaluationTarget_Annotation) {
       return this.context == other.context &&
           this.source == other.source &&
           this.librarySource == other.librarySource &&
           this.annotation == other.annotation;
     } else {
       return false;
     }
   }
+
+  @override
+  String toString() => 'Constant: $annotation';
 }
 
 /**
  * Interface used by unit tests to verify correct dependency analysis during
  * constant evaluation.
  */
 abstract class ConstantEvaluationValidator {
   /**
    * This method is called just before computing the constant value associated
    * with [constant]. Unit tests will override this method to introduce
@@ skipping 44 matching lines @@
   @override
   void beforeGetEvaluationResult(ConstantEvaluationTarget constant) {}
 
   @override
   void beforeGetFieldEvaluationResult(FieldElementImpl field) {}
 
   @override
   void beforeGetParameterDefault(ParameterElement parameter) {}
 }
 
-/**
- * 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
- *   <b>null</b>.
- * * A literal symbol.
- * * <b>null</b>.
- * * A qualified reference to a static constant variable.
- * * An identifier expression that denotes a constant variable, class or type
- *   alias.
- * * 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 <i>(e)</i> where <i>e</i> is a constant
- *   expression.
- * * An expression of the form <i>identical(e<sub>1</sub>, e<sub>2</sub>)</i>
- *   where <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> are constant
- *   expressions and <i>identical()</i> is statically bound to the predefined
- *   dart function <i>identical()</i> discussed above.
- * * An expression of one of the forms <i>e<sub>1</sub> == e<sub>2</sub></i> or
- *   <i>e<sub>1</sub> != e<sub>2</sub></i> where <i>e<sub>1</sub></i> and
- *   <i>e<sub>2</sub></i> are constant expressions that evaluate to a numeric,
- *   string or boolean value.
- * * An expression of one of the forms <i>!e</i>, <i>e<sub>1</sub> &amp;&amp;
- *   e<sub>2</sub></i> or <i>e<sub>1</sub> || e<sub>2</sub></i>, where <i>e</i>,
- *   <i>e1</sub></i> and <i>e2</sub></i> are constant expressions that evaluate
- *   to a boolean value.
- * * An expression of one of the forms <i>~e</i>, <i>e<sub>1</sub> ^
- *   e<sub>2</sub></i>, <i>e<sub>1</sub> &amp; e<sub>2</sub></i>,
- *   <i>e<sub>1</sub> | e<sub>2</sub></i>, <i>e<sub>1</sub> &gt;&gt;
- *   e<sub>2</sub></i> or <i>e<sub>1</sub> &lt;&lt; e<sub>2</sub></i>, where
- *   <i>e</i>, <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> are constant
- *   expressions that evaluate to an integer value or to <b>null</b>.
- * * An expression of one of the forms <i>-e</i>, <i>e<sub>1</sub> +
- *   e<sub>2</sub></i>, <i>e<sub>1</sub> -e<sub>2</sub></i>, <i>e<sub>1</sub> *
- *   e<sub>2</sub></i>, <i>e<sub>1</sub> / e<sub>2</sub></i>, <i>e<sub>1</sub>
- *   ~/ e<sub>2</sub></i>, <i>e<sub>1</sub> &gt; e<sub>2</sub></i>,
- *   <i>e<sub>1</sub> &lt; e<sub>2</sub></i>, <i>e<sub>1</sub> &gt;=
- *   e<sub>2</sub></i>, <i>e<sub>1</sub> &lt;= e<sub>2</sub></i> or
- *   <i>e<sub>1</sub> % e<sub>2</sub></i>, where <i>e</i>, <i>e<sub>1</sub></i>
- *   and <i>e<sub>2</sub></i> are constant expressions that evaluate to a
- *   numeric value or to <b>null</b>.
- * * An expression of the form <i>e<sub>1</sub> ? e<sub>2</sub> :
- *   e<sub>3</sub></i> where <i>e<sub>1</sub></i>, <i>e<sub>2</sub></i> and
- *   <i>e<sub>3</sub></i> are constant expressions, and <i>e<sub>1</sub></i>
- *   evaluates to a boolean value.
- * </blockquote>
- */
+/// Instances of the class [ConstantEvaluator] evaluate constant expressions to
+/// produce their compile-time value.
+///
+/// According to the Dart Language Specification:
+///
+/// > 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**.
+/// > * A literal symbol.
+/// > * **null**.
+/// > * A qualified reference to a static constant variable.
+/// > * An identifier expression that denotes a constant variable, class or type
+/// >   alias.
+/// > * 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.
+/// > * <span>
+/// >   An expression of the form <i>identical(e<sub>1</sub>, e<sub>2</sub>)</i>
+/// >   where <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> are constant
+/// >   expressions and <i>identical()</i> is statically bound to the predefined
+/// >   dart function <i>identical()</i> discussed above.
+/// >   </span>
+/// > * <span>
+/// >   An expression of one of the forms <i>e<sub>1</sub> == e<sub>2</sub></i>
+/// >   or <i>e<sub>1</sub> != e<sub>2</sub></i> where <i>e<sub>1</sub></i> and
+/// >   <i>e<sub>2</sub></i> are constant expressions that evaluate to a
+/// >   numeric, string or boolean value.
+/// >   </span>
+/// > * <span>
+/// >   An expression of one of the forms <i>!e</i>, <i>e<sub>1</sub> &amp;&amp;
+/// >   e<sub>2</sub></i> or <i>e<sub>1</sub> || e<sub>2</sub></i>, where
+/// >   <i>e</i>, <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> are constant
+/// >   expressions that evaluate to a boolean value.
+/// >   </span>
+/// > * <span>
+/// >   An expression of one of the forms <i>~e</i>, <i>e<sub>1</sub> ^
+/// >   e<sub>2</sub></i>, <i>e<sub>1</sub> &amp; e<sub>2</sub></i>,
+/// >   <i>e<sub>1</sub> | e<sub>2</sub></i>, <i>e<sub>1</sub> &gt;&gt;
+/// >   e<sub>2</sub></i> or <i>e<sub>1</sub> &lt;&lt; e<sub>2</sub></i>, where
+/// >   <i>e</i>, <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> are constant
+/// >   expressions that evaluate to an integer value or to <b>null</b>.
+/// >   </span>
+/// > * <span>
+/// >   An expression of one of the forms <i>-e</i>, <i>e<sub>1</sub> +
+/// >   e<sub>2</sub></i>, <i>e<sub>1</sub> -e<sub>2</sub></i>,
+/// >   <i>e<sub>1</sub> * e<sub>2</sub></i>, <i>e<sub>1</sub> /
+/// >   e<sub>2</sub></i>, <i>e<sub>1</sub> ~/ e<sub>2</sub></i>,
+/// >   <i>e<sub>1</sub> &gt; e<sub>2</sub></i>, <i>e<sub>1</sub> &lt;
+/// >   e<sub>2</sub></i>, <i>e<sub>1</sub> &gt;= e<sub>2</sub></i>,
+/// >   <i>e<sub>1</sub> &lt;= e<sub>2</sub></i> or <i>e<sub>1</sub> %
+/// >   e<sub>2</sub></i>, where <i>e</i>, <i>e<sub>1</sub></i> and
+/// >   <i>e<sub>2</sub></i> are constant expressions that evaluate to a numeric
+/// >   value or to <b>null</b>.
+/// >   </span>
+/// > * <span>
+/// >   An expression of the form <i>e<sub>1</sub> ? e<sub>2</sub> :
+/// >   e<sub>3</sub></i> where <i>e<sub>1</sub></i>, <i>e<sub>2</sub></i> and
+/// >   <i>e<sub>3</sub></i> are constant expressions, and <i>e<sub>1</sub></i>
+/// >   evaluates to a boolean value.
+/// >   </span>
+///
+/// The values returned by instances of this class are therefore `null` and
+/// instances of the classes `Boolean`, `BigInteger`, `Double`, `String`, and
+/// `DartObject`.
+///
+/// In addition, this class defines several values that can be returned to
+/// indicate various conditions encountered during evaluation. These are
+/// documented with the static fields that define those values.
 class ConstantEvaluator {
   /**
    * The source containing the expression(s) that will be evaluated.
    */
   final Source _source;
 
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider _typeProvider;
 
   /**
+   * The type system primitives.
+   */
+  final TypeSystem _typeSystem;
+
+  /**
    * Initialize a newly created evaluator to evaluate expressions in the given
    * [source]. The [typeProvider] is the type provider used to access known
    * types.
    */
-  ConstantEvaluator(this._source, this._typeProvider);
+  ConstantEvaluator(this._source, this._typeProvider, {TypeSystem typeSystem})
+      : _typeSystem = typeSystem != null ? typeSystem : new TypeSystemImpl();
 
   EvaluationResult evaluate(Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
     DartObjectImpl result = expression.accept(new ConstantVisitor(
-        new ConstantEvaluationEngine(_typeProvider, new DeclaredVariables()),
+        new ConstantEvaluationEngine(_typeProvider, new DeclaredVariables(),
+            typeSystem: _typeSystem),
         errorReporter));
     if (result != null) {
       return EvaluationResult.forValue(result);
     }
     return EvaluationResult.forErrors(errorListener.errors);
   }
 }
 
 /**
  * A visitor used to traverse the AST structures of all of the compilation units
@@ skipping 123 matching lines @@
 
   final AnalysisContext _context;
 
   /**
    * Initialize a newly created constant value computer. The [typeProvider] is
    * the type provider used to access known types. The [declaredVariables] is
    * the set of variables declared on the command line using '-D'.
    */
   ConstantValueComputer(this._context, TypeProvider typeProvider,
       DeclaredVariables declaredVariables,
-      [ConstantEvaluationValidator validator])
+      [ConstantEvaluationValidator validator, TypeSystem typeSystem])
       : evaluationEngine = new ConstantEvaluationEngine(
-          typeProvider, declaredVariables, validator: validator);
+            typeProvider, declaredVariables,
+            validator: validator, typeSystem: typeSystem);
 
   /**
    * Add the constants in the given compilation [unit] to the list of constants
    * whose value needs to be computed.
    */
   void add(CompilationUnit unit, Source source, Source librarySource) {
     ConstantFinder constantFinder =
         new ConstantFinder(_context, source, librarySource);
     unit.accept(constantFinder);
     _constantsToCompute.addAll(constantFinder.constantsToCompute);
@@ skipping 249 matching lines @@
       return conditionResult;
     }
     if (conditionResult.isTrue) {
       return thenResult;
     } else if (conditionResult.isFalse) {
       return elseResult;
     }
     ParameterizedType thenType = thenResult.type;
     ParameterizedType elseType = elseResult.type;
     return new DartObjectImpl.validWithUnknownValue(
-        _typeSystem.getLeastUpperBound(thenType, elseType) as InterfaceType);
+        _typeSystem.getLeastUpperBound(_typeProvider, thenType, elseType)
+        as InterfaceType);
   }
 
   @override
   DartObjectImpl visitDoubleLiteral(DoubleLiteral node) =>
       new DartObjectImpl(_typeProvider.doubleType, new DoubleState(node.value));
 
   @override
   DartObjectImpl visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     if (!node.isConst) {
@@ skipping 1017 matching lines @@
           typeProvider.boolType, _state.greaterThan(rightOperand._state));
 
   /**
    * Return the result of invoking the '&gt;=' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
-  DartObjectImpl greaterThanOrEqual(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) => new DartObjectImpl(
-      typeProvider.boolType, _state.greaterThanOrEqual(rightOperand._state));
+  DartObjectImpl greaterThanOrEqual(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(typeProvider.boolType,
+          _state.greaterThanOrEqual(rightOperand._state));
 
   /**
    * Return the result of invoking the '~/' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
   DartObjectImpl integerDivide(
@@ skipping 910 matching lines @@
   EvaluationResultImpl(this.value, [List<AnalysisError> errors]) {
     this._errors = errors == null ? <AnalysisError>[] : errors;
   }
 
   @deprecated // Use new EvaluationResultImpl(value)
   EvaluationResultImpl.con1(this.value) {
     this._errors = new List<AnalysisError>(0);
   }
 
   @deprecated // Use new EvaluationResultImpl(value, errors)
-  EvaluationResultImpl.con2(this.value, List<AnalysisError> errors) {
-    this._errors = errors;
-  }
+  EvaluationResultImpl.con2(this.value, List<AnalysisError> this._errors);
 
   List<AnalysisError> get errors => _errors;
 
   bool equalValues(TypeProvider typeProvider, EvaluationResultImpl result) {
     if (this.value != null) {
       if (result.value == null) {
         return false;
       }
       return value == result.value;
     } else {
@@ skipping 1730 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }