Reorganize constants/* libraries.

pkg/compiler/lib/src/constants/expressions.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.
 
 library dart2js.constants.expressions;
 
 import '../constants/constant_system.dart';
 import '../core_types.dart';
-import '../dart2jslib.dart' show assertDebugMode, Compiler;
+import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     ConstructorElement,
     Element,
     FieldElement,
     FunctionElement,
     PrefixElement,
     VariableElement;
 import '../resolution/operators.dart';
 import '../tree/tree.dart' show DartString;
 import '../universe/universe.dart' show CallStructure;
-import '../util/util.dart';
+import 'evaluation.dart';
 import 'values.dart';
 
 enum ConstantExpressionKind {
   BINARY,
   BOOL,
   BOOL_FROM_ENVIRONMENT,
   CONCATENATE,
   CONDITIONAL,
   CONSTRUCTED,
   DEFERRED,
@@ skipping 12 matching lines @@
   SYMBOL,
   SYNTHETIC,
   TYPE,
   UNARY,
   VARIABLE,
 
   POSITIONAL_REFERENCE,
   NAMED_REFERENCE,
 }
 
-/// Environment used for evaluating constant expressions.
-abstract class Environment {
-  // TODO(johnniwinther): Replace this with [CoreTypes] and maybe [Backend].
-  Compiler get compiler;
-
-  /// Read environments string passed in using the '-Dname=value' option.
-  String readFromEnvironment(String name);
-}
-
-/// The normalized arguments passed to a const constructor computed from the
-/// actual [arguments] and the [defaultValues] of the called construrctor.
-class NormalizedArguments {
-  final Map<dynamic/*int|String*/, ConstantExpression> defaultValues;
-  final CallStructure callStructure;
-  final List<ConstantExpression> arguments;
-
-  NormalizedArguments(this.defaultValues, this.callStructure, this.arguments);
-
-  /// Returns the normalized named argument [name].
-  ConstantExpression getNamedArgument(String name) {
-    int index = callStructure.namedArguments.indexOf(name);
-    if (index == -1) {
-      // The named argument is not provided.
-      return defaultValues[name];
-    }
-    return arguments[index + callStructure.positionalArgumentCount];
-  }
-
-  /// Returns the normalized [index]th positional argument.
-  ConstantExpression getPositionalArgument(int index) {
-    if (index >= callStructure.positionalArgumentCount) {
-      // The positional argument is not provided.
-      return defaultValues[index];
-    }
-    return arguments[index];
-  }
-}
-
-enum ConstantConstructorKind {
-  GENERATIVE,
-  REDIRECTING_GENERATIVE,
-  REDIRECTING_FACTORY,
-}
-
-/// Definition of a constant constructor.
-abstract class ConstantConstructor {
-  ConstantConstructorKind get kind;
-
-  /// Computes the type of the instance created in a const constructor
-  /// invocation with type [newType].
-  InterfaceType computeInstanceType(InterfaceType newType);
-
-  /// Computes the constant expressions of the fields of the created instance
-  /// in a const constructor invocation with [arguments].
-  Map<FieldElement, ConstantExpression> computeInstanceFields(
-      List<ConstantExpression> arguments,
-      CallStructure callStructure);
-
-  accept(ConstantConstructorVisitor visitor, arg);
-}
-
-abstract class ConstantConstructorVisitor<R, A> {
-  const ConstantConstructorVisitor();
-
-  R visit(ConstantConstructor constantConstructor, A context) {
-    return constantConstructor.accept(this, context);
-  }
-
-  R visitGenerative(GenerativeConstantConstructor constructor, A arg);
-  R visitRedirectingGenerative(
-      RedirectingGenerativeConstantConstructor constructor, A arg);
-  R visitRedirectingFactory(
-      RedirectingFactoryConstantConstructor constructor, A arg);
-}
-
-/// A generative constant constructor.
-class GenerativeConstantConstructor implements ConstantConstructor{
-  final InterfaceType type;
-  final Map<dynamic/*int|String*/, ConstantExpression> defaultValues;
-  final Map<FieldElement, ConstantExpression> fieldMap;
-  final ConstructedConstantExpression superConstructorInvocation;
-
-  GenerativeConstantConstructor(
-      this.type,
-      this.defaultValues,
-      this.fieldMap,
-      this.superConstructorInvocation);
-
-  ConstantConstructorKind get kind => ConstantConstructorKind.GENERATIVE;
-
-  InterfaceType computeInstanceType(InterfaceType newType) {
-    return type.substByContext(newType);
-  }
-
-  Map<FieldElement, ConstantExpression> computeInstanceFields(
-      List<ConstantExpression> arguments,
-      CallStructure callStructure) {
-    NormalizedArguments args = new NormalizedArguments(
-        defaultValues, callStructure, arguments);
-    Map<FieldElement, ConstantExpression> appliedFieldMap =
-        applyFields(args, superConstructorInvocation);
-    fieldMap.forEach((FieldElement field, ConstantExpression constant) {
-     appliedFieldMap[field] = constant.apply(args);
-    });
-    return appliedFieldMap;
-  }
-
-  accept(ConstantConstructorVisitor visitor, arg) {
-    return visitor.visitGenerative(this, arg);
-  }
-
-  int get hashCode {
-    int hash = Hashing.objectHash(type);
-    hash = Hashing.mapHash(defaultValues, hash);
-    hash = Hashing.mapHash(fieldMap, hash);
-    return Hashing.objectHash(superConstructorInvocation, hash);
-  }
-
-  bool operator ==(other) {
-    if (identical(this, other)) return true;
-    if (other is! GenerativeConstantConstructor) return false;
-    return
-        type == other.type &&
-        superConstructorInvocation == other.superConstructorInvocation &&
-        mapEquals(defaultValues, other.defaultValues) &&
-        mapEquals(fieldMap, other.fieldMap);
-  }
-
-  String toString() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("{'type': $type");
-    defaultValues.forEach((key, ConstantExpression expression) {
-      sb.write(",\n 'default:${key}': ${expression.getText()}");
-    });
-    fieldMap.forEach((FieldElement field, ConstantExpression expression) {
-      sb.write(",\n 'field:${field}': ${expression.getText()}");
-    });
-    if (superConstructorInvocation != null) {
-      sb.write(",\n 'constructor: ${superConstructorInvocation.getText()}");
-    }
-    sb.write("}");
-    return sb.toString();
-  }
-
-  static bool mapEquals(Map map1, Map map2) {
-    if (map1.length != map1.length) return false;
-    for (var key in map1.keys) {
-      if (map1[key] != map2[key]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /// Creates the field-to-constant map from applying [args] to
-  /// [constructorInvocation]. If [constructorInvocation] is `null`, an empty
-  /// map is created.
-  static Map<FieldElement, ConstantExpression> applyFields(
-      NormalizedArguments args,
-      ConstructedConstantExpression constructorInvocation) {
-    Map<FieldElement, ConstantExpression> appliedFieldMap =
-        <FieldElement, ConstantExpression>{};
-    if (constructorInvocation != null) {
-      Map<FieldElement, ConstantExpression> fieldMap =
-          constructorInvocation.computeInstanceFields();
-      fieldMap.forEach((FieldElement field, ConstantExpression constant) {
-        appliedFieldMap[field] = constant.apply(args);
-      });
-    }
-    return appliedFieldMap;
-  }
-}
-
-/// A redirecting generative constant constructor.
-class RedirectingGenerativeConstantConstructor implements ConstantConstructor {
-  final Map<dynamic/*int|String*/, ConstantExpression> defaultValues;
-  final ConstructedConstantExpression thisConstructorInvocation;
-
-  RedirectingGenerativeConstantConstructor(
-      this.defaultValues,
-      this.thisConstructorInvocation);
-
-  ConstantConstructorKind get kind {
-    return ConstantConstructorKind.REDIRECTING_GENERATIVE;
-  }
-
-  InterfaceType computeInstanceType(InterfaceType newType) {
-    return thisConstructorInvocation.computeInstanceType()
-        .substByContext(newType);
-  }
-
-  Map<FieldElement, ConstantExpression> computeInstanceFields(
-      List<ConstantExpression> arguments,
-      CallStructure callStructure) {
-    NormalizedArguments args =
-        new NormalizedArguments(defaultValues, callStructure, arguments);
-    Map<FieldElement, ConstantExpression> appliedFieldMap =
-        GenerativeConstantConstructor.applyFields(
-            args, thisConstructorInvocation);
-    return appliedFieldMap;
-  }
-
-  accept(ConstantConstructorVisitor visitor, arg) {
-    return visitor.visitRedirectingGenerative(this, arg);
-  }
-
-  int get hashCode {
-    int hash = Hashing.objectHash(thisConstructorInvocation);
-    return Hashing.mapHash(defaultValues, hash);
-  }
-
-  bool operator ==(other) {
-    if (identical(this, other)) return true;
-    if (other is! RedirectingGenerativeConstantConstructor) return false;
-    return
-        thisConstructorInvocation == other.thisConstructorInvocation &&
-        GenerativeConstantConstructor.mapEquals(
-            defaultValues, other.defaultValues);
-  }
-
-  String toString() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("{'type': ${thisConstructorInvocation.type}");
-    defaultValues.forEach((key, ConstantExpression expression) {
-      sb.write(",\n 'default:${key}': ${expression.getText()}");
-    });
-    sb.write(",\n 'constructor': ${thisConstructorInvocation.getText()}");
-    sb.write("}");
-    return sb.toString();
-  }
-}
-
-/// A redirecting factory constant constructor.
-class RedirectingFactoryConstantConstructor implements ConstantConstructor {
-  final ConstructedConstantExpression targetConstructorInvocation;
-
-  RedirectingFactoryConstantConstructor(this.targetConstructorInvocation);
-
-  ConstantConstructorKind get kind {
-    return ConstantConstructorKind.REDIRECTING_FACTORY;
-  }
-
-  InterfaceType computeInstanceType(InterfaceType newType) {
-    return targetConstructorInvocation.computeInstanceType()
-        .substByContext(newType);
-  }
-
-  Map<FieldElement, ConstantExpression> computeInstanceFields(
-      List<ConstantExpression> arguments,
-      CallStructure callStructure) {
-    ConstantConstructor constantConstructor =
-        targetConstructorInvocation.target.constantConstructor;
-    return constantConstructor.computeInstanceFields(arguments, callStructure);
-  }
-
-  accept(ConstantConstructorVisitor visitor, arg) {
-    return visitor.visitRedirectingFactory(this, arg);
-  }
-
-  int get hashCode {
-    return Hashing.objectHash(targetConstructorInvocation);
-  }
-
-  bool operator ==(other) {
-    if (identical(this, other)) return true;
-    if (other is! RedirectingFactoryConstantConstructor) return false;
-    return targetConstructorInvocation == other.targetConstructorInvocation;
-  }
-
-  String toString() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("{");
-    sb.write("'constructor': ${targetConstructorInvocation.getText()}");
-    sb.write("}");
-    return sb.toString();
-  }
-}
-
 /// An expression that is a compile-time constant.
 ///
 /// Whereas [ConstantValue] represent a compile-time value, a
 /// [ConstantExpression] represents an expression for creating a constant.
 ///
 /// There is no one-to-one mapping between [ConstantExpression] and
 /// [ConstantValue], because different expressions can denote the same constant.
 /// For instance, multiple `const` constructors may be used to create the same
 /// object, and different `const` variables may hold the same value.
 abstract class ConstantExpression {
@@ skipping 1533 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }