Move exception support to its own library

pkg/analyzer/lib/src/dart/constant/evaluation.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 analyzer.src.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/constant/utilities.dart';
 import 'package:analyzer/src/dart/constant/value.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, RecordingErrorListener;
 import 'package:analyzer/src/generated/error.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart'
     show TypeSystem, TypeSystemImpl;
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart' show ParameterKind;
 import 'package:analyzer/src/task/dart.dart';
 
 /**
  * Helper class encapsulating the methods for evaluating constants and
  * constant instance creation expressions.
@@ skipping 817 matching lines @@
       return false;
     }
     return obj.type.isSubtypeOf(type);
   }
 
   /**
    * Determine whether the given string is a valid name for a public symbol
    * (i.e. whether it is allowed for a call to the Symbol constructor).
    */
   static bool isValidPublicSymbol(String name) =>
-      name.isEmpty ||
-      name == "void" ||
-      _PUBLIC_SYMBOL_PATTERN.hasMatch(name);
+      name.isEmpty || name == "void" || _PUBLIC_SYMBOL_PATTERN.hasMatch(name);
 }
 
 /**
  * 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 257 matching lines @@
    * 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;
 
+  /**
+   * Given a [type] that may contain free type variables, evaluate them against
+   * the current lexical environment and return the substituted type.
+   */
+  DartType evaluateType(DartType type) {
+    if (type is TypeParameterType) {
+      // Constants may only refer to type parameters in strong mode.
+      if (!evaluationEngine.strongMode) {
+        return null;
+      }
+
+      String name = type.name;
+      if (_lexicalEnvironment != null) {
+        return _lexicalEnvironment[name]?.toTypeValue() ?? type;
+      }
+      return type;
+    }
+    if (type is ParameterizedType) {
+      List<DartType> typeArguments;
+      for (int i = 0; i < type.typeArguments.length; i++) {
+        DartType ta = type.typeArguments[i];
+        DartType t = evaluateType(ta);
+        if (!identical(t, ta)) {
+          if (typeArguments == null) {
+            typeArguments = type.typeArguments.toList(growable: false);
+          }
+          typeArguments[i] = t;
+        }
+      }
+      if (typeArguments == null) return type;
+      return type.substitute2(typeArguments, type.typeArguments);
+    }
+    return type;
+  }
+
+  /**
+   * Given a [type], returns the constant value that contains that type value.
+   */
+  DartObjectImpl typeConstant(DartType type) {
+    return new DartObjectImpl(_typeProvider.typeType, new TypeState(type));
+  }
+
   @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 360 matching lines @@
   @override
   DartObjectImpl visitTypeName(TypeName node) {
     DartType type = evaluateType(node.type);
     if (type == null) {
       return super.visitTypeName(node);
     }
     return typeConstant(type);
   }
 
   /**
-   * Given a [type], returns the constant value that contains that type value.
-   */
-  DartObjectImpl typeConstant(DartType type) {
-    return new DartObjectImpl(_typeProvider.typeType, new TypeState(type));
-  }
-
-  /**
-   * Given a [type] that may contain free type variables, evaluate them against
-   * the current lexical environment and return the substituted type.
-   */
-  DartType evaluateType(DartType type) {
-    if (type is TypeParameterType) {
-      // Constants may only refer to type parameters in strong mode.
-      if (!evaluationEngine.strongMode) {
-        return null;
-      }
-
-      String name = type.name;
-      if (_lexicalEnvironment != null) {
-        return _lexicalEnvironment[name]?.toTypeValue() ?? type;
-      }
-      return type;
-    }
-    if (type is ParameterizedType) {
-      List<DartType> typeArguments;
-      for (int i = 0; i < type.typeArguments.length; i++) {
-        DartType ta = type.typeArguments[i];
-        DartType t = evaluateType(ta);
-        if (!identical(t, ta)) {
-          if (typeArguments == null) {
-            typeArguments = type.typeArguments.toList(growable: false);
-          }
-          typeArguments[i] = t;
-        }
-      }
-      if (typeArguments == null) return type;
-      return type.substitute2(typeArguments, type.typeArguments);
-    }
-    return type;
-  }
-
-  /**
    * Create an error associated with the given [node]. The error will have the
    * given error [code].
    */
   void _error(AstNode node, ErrorCode code) {
     _errorReporter.reportErrorForNode(
         code ?? CompileTimeErrorCode.INVALID_CONSTANT, node);
   }
 
   /**
    * Return the constant value of the static constant represented by the given
@@ skipping 508 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }