Refactor least upper bound computation; support bottom correctly.

pkg/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';
 import 'engine.dart' show AnalysisEngine, RecordingErrorListener;
 import 'error.dart';
 import 'java_core.dart';
-import 'resolver.dart' show TypeProvider;
+import 'resolver.dart' show TypeProvider, TypeSystem, TypeSystemImpl;
 import 'scanner.dart' show Token, TokenType;
 import 'source.dart' show Source;
 import 'utilities_collection.dart';
 import 'utilities_dart.dart' show ParameterKind;
 
 /**
  * Callback used by [ReferenceFinder] to report that a dependency was found.
  */
 typedef void ReferenceFinderCallback(ConstantEvaluationTarget dependency);
 
@@ skipping 178 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.
+   * The type system.  This is used to gues the types of constants when their

[Brian Wilkerson, 2015/06/16 21:35:19]

"gues" --> "guess"

+   * exact value is unknown.
    */
-  final TypeProvider typeProvider;
+  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(this.typeProvider, this._declaredVariables,
+  ConstantEvaluationEngine(TypeProvider typeProvider, this._declaredVariables,
       {ConstantEvaluationValidator validator})
       : validator = validator != null
           ? validator
-          : new ConstantEvaluationValidator_ForProduction();
+          : new ConstantEvaluationValidator_ForProduction(),
+        typeSystem = new TypeSystemImpl(typeProvider);
+
+  /**
+   * The type provider used to access the known types.
+   */
+  TypeProvider get typeProvider => typeSystem.typeProvider;
 
   /**
    * 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.
    */
@@ skipping 1167 matching lines @@
     this._dartObjectComputer =
         new DartObjectComputer(_errorReporter, evaluationEngine.typeProvider);
   }
 
   /**
    * Convenience getter to gain access to the [evalationEngine]'s type
    * provider.
    */
   TypeProvider get _typeProvider => evaluationEngine.typeProvider;
 
+  /**
+   * Convenience getter to gain access to the [evaluationEngine]'s type system.
+   */
+  TypeSystem get _typeSystem => evaluationEngine.typeSystem;
+
   @override
   DartObjectImpl visitAdjacentStrings(AdjacentStrings node) {
     DartObjectImpl result = null;
     for (StringLiteral string in node.strings) {
       if (result == null) {
         result = string.accept(this);
       } else {
         result =
             _dartObjectComputer.concatenate(node, result, string.accept(this));
       }
@@ skipping 92 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(
-        thenType.getLeastUpperBound(elseType) as InterfaceType);
+        _typeSystem.getLeastUpperBound(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 3703 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;
 }