Reformat

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';
@@ skipping 201 matching lines @@
    * Initialize a newly created evaluator to evaluate expressions in the given source.
    *
    * @param source the source containing the expression(s) that will be evaluated
    * @param typeProvider the type provider used to access known types
    */
   ConstantEvaluator(this._source, this._typeProvider);
 
   EvaluationResult evaluate(Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
-    DartObjectImpl result =
-        expression.accept(new ConstantVisitor.con1(_typeProvider, errorReporter));
+    DartObjectImpl result = expression
+        .accept(new ConstantVisitor.con1(_typeProvider, errorReporter));
     if (result != null) {
       return EvaluationResult.forValue(result);
     }
     return EvaluationResult.forErrors(errorListener.errors);
   }
 }
 
 /**
  * Instances of the class `ConstantFinder` are used to traverse the AST
  * structures of all of the compilation units being resolved and build tables
@@ skipping 163 matching lines @@
    * @param unit the compilation unit defining the constants to be added
    */
   void add(CompilationUnit unit) {
     unit.accept(_constantFinder);
   }
 
   /**
    * This method is called just before computing the constant value associated with an AST node.
    * Unit tests will override this method to introduce additional error checking.
    */
-  void beforeComputeValue(AstNode constNode) {
-  }
+  void beforeComputeValue(AstNode constNode) {}
 
   /**
    * This method is called just before getting the constant initializers associated with a
    * constructor AST node. Unit tests will override this method to introduce additional error
    * checking.
    */
-  void beforeGetConstantInitializers(ConstructorElement constructor) {
-  }
+  void beforeGetConstantInitializers(ConstructorElement constructor) {}
 
   /**
    * This method is called just before getting a parameter's default value. Unit tests will override
    * this method to introduce additional error checking.
    */
-  void beforeGetParameterDefault(ParameterElement parameter) {
-  }
+  void beforeGetParameterDefault(ParameterElement parameter) {}
 
   /**
    * Compute values for all of the constants in the compilation units that were added.
    */
   void computeValues() {
     _variableDeclarationMap = _constantFinder.variableMap;
     constructorDeclarationMap = _constantFinder.constructorMap;
     _constructorInvocations = _constantFinder.constructorInvocations;
     _annotations = _constantFinder.annotations;
     _variableDeclarationMap.values.forEach((VariableDeclaration declaration) {
-      ReferenceFinder referenceFinder = new ReferenceFinder(
-          declaration,
-          referenceGraph,
-          _variableDeclarationMap,
-          constructorDeclarationMap);
+      ReferenceFinder referenceFinder = new ReferenceFinder(declaration,
+          referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       referenceGraph.addNode(declaration);
       declaration.initializer.accept(referenceFinder);
     });
     constructorDeclarationMap.forEach(
         (ConstructorElement element, ConstructorDeclaration declaration) {
-      ReferenceFinder referenceFinder = new ReferenceFinder(
-          declaration,
-          referenceGraph,
-          _variableDeclarationMap,
-          constructorDeclarationMap);
+      ReferenceFinder referenceFinder = new ReferenceFinder(declaration,
+          referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       referenceGraph.addNode(declaration);
       bool superInvocationFound = false;
       NodeList<ConstructorInitializer> initializers = declaration.initializers;
       for (ConstructorInitializer initializer in initializers) {
         if (initializer is SuperConstructorInvocation) {
           superInvocationFound = true;
         }
         initializer.accept(referenceFinder);
       }
       if (!superInvocationFound) {
@@ skipping 11 matching lines @@
           }
         }
       }
       for (FormalParameter parameter in declaration.parameters.parameters) {
         referenceGraph.addNode(parameter);
         referenceGraph.addEdge(declaration, parameter);
         if (parameter is DefaultFormalParameter) {
           Expression defaultValue = parameter.defaultValue;
           if (defaultValue != null) {
             ReferenceFinder parameterReferenceFinder = new ReferenceFinder(
-                parameter,
-                referenceGraph,
-                _variableDeclarationMap,
+                parameter, referenceGraph, _variableDeclarationMap,
                 constructorDeclarationMap);
             defaultValue.accept(parameterReferenceFinder);
           }
         }
       }
     });
     for (InstanceCreationExpression expression in _constructorInvocations) {
       referenceGraph.addNode(expression);
       ConstructorElement constructor = expression.staticElement;
       if (constructor == null) {
         continue;
       }
       constructor = _followConstantRedirectionChain(constructor);
       ConstructorDeclaration declaration =
           findConstructorDeclaration(constructor);
       // An instance creation expression depends both on the constructor and
       // the arguments passed to it.
-      ReferenceFinder referenceFinder = new ReferenceFinder(
-          expression,
-          referenceGraph,
-          _variableDeclarationMap,
-          constructorDeclarationMap);
+      ReferenceFinder referenceFinder = new ReferenceFinder(expression,
+          referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       if (declaration != null) {
         referenceGraph.addEdge(expression, declaration);
       }
       expression.argumentList.accept(referenceFinder);
     }
     List<List<AstNode>> topologicalSort =
         referenceGraph.computeTopologicalSort();
     for (List<AstNode> constantsInCycle in topologicalSort) {
       if (constantsInCycle.length == 1) {
         _computeValueFor(constantsInCycle[0]);
@@ skipping 11 matching lines @@
     }
   }
 
   /**
    * Create the ConstantVisitor used to evaluate constants. Unit tests will override this method to
    * introduce additional error checking.
    */
   ConstantVisitor createConstantVisitor(ErrorReporter errorReporter) =>
       new ConstantVisitor.con1(typeProvider, errorReporter);
 
-  ConstructorDeclaration
-      findConstructorDeclaration(ConstructorElement constructor) =>
+  ConstructorDeclaration findConstructorDeclaration(
+          ConstructorElement constructor) =>
       constructorDeclarationMap[_getConstructorBase(constructor)];
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct.
    *
    * @param arguments the AST nodes of the arguments.
    * @param argumentValues the values of the unnamed arguments.
    * @param namedArgumentValues the values of the named arguments.
    * @param expectedDefaultValueType 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,
-      List<DartObjectImpl> argumentValues, HashMap<String,
-      DartObjectImpl> namedArgumentValues, InterfaceType expectedDefaultValueType) {
+      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;
     }
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
     }
@@ skipping 17 matching lines @@
 
   /**
    * Check that the arguments to a call to Symbol() are correct.
    *
    * @param arguments the AST nodes of the arguments.
    * @param argumentValues the values of the unnamed arguments.
    * @param namedArgumentValues the values of the named arguments.
    * @return true if the arguments are correct, false if there is an error.
    */
   bool _checkSymbolArguments(NodeList<Expression> arguments,
-      List<DartObjectImpl> argumentValues, HashMap<String,
-      DartObjectImpl> namedArgumentValues) {
+      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;
     }
     String name = argumentValues[0].stringValue;
@@ skipping 12 matching lines @@
       VariableElement element = declaration.element;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter =
           new ErrorReporter(errorListener, element.source);
       DartObjectImpl dartObject =
           declaration.initializer.accept(createConstantVisitor(errorReporter));
       if (dartObject != null) {
         if (!_runtimeTypeMatch(dartObject, element.type)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
-              declaration,
-              [dartObject.type, element.type]);
+              declaration, [dartObject.type, element.type]);
         }
       }
       (element as VariableElementImpl).evaluationResult =
           new EvaluationResultImpl.con2(dartObject, errorListener.errors);
     } else if (constNode is InstanceCreationExpression) {
       InstanceCreationExpression expression = constNode;
       ConstructorElement constructor = expression.staticElement;
       if (constructor == null) {
         // Couldn't resolve the constructor so we can't compute a value.
         // No problem - the error has already been reported.
         // But we still need to store an evaluation result.
         expression.evaluationResult = new EvaluationResultImpl.con1(null);
         return;
       }
       RecordingErrorListener errorListener = new RecordingErrorListener();
       CompilationUnit sourceCompilationUnit =
           expression.getAncestor((node) => node is CompilationUnit);
-      ErrorReporter errorReporter =
-          new ErrorReporter(errorListener, sourceCompilationUnit.element.source);
+      ErrorReporter errorReporter = new ErrorReporter(
+          errorListener, sourceCompilationUnit.element.source);
       ConstantVisitor constantVisitor = createConstantVisitor(errorReporter);
-      DartObjectImpl result = _evaluateConstructorCall(
-          constNode,
-          expression.argumentList.arguments,
-          constructor,
-          constantVisitor,
+      DartObjectImpl result = _evaluateConstructorCall(constNode,
+          expression.argumentList.arguments, constructor, constantVisitor,
           errorReporter);
       expression.evaluationResult =
           new EvaluationResultImpl.con2(result, errorListener.errors);
     } else if (constNode is ConstructorDeclaration) {
       ConstructorDeclaration declaration = constNode;
       NodeList<ConstructorInitializer> initializers = declaration.initializers;
       ConstructorElementImpl constructor =
           declaration.element as ConstructorElementImpl;
       constructor.constantInitializers =
-          new ConstantValueComputer_InitializerCloner().cloneNodeList(initializers);
+          new ConstantValueComputer_InitializerCloner()
+              .cloneNodeList(initializers);
     } else if (constNode is FormalParameter) {
       if (constNode is DefaultFormalParameter) {
         DefaultFormalParameter parameter = constNode;
         ParameterElement element = parameter.element;
         Expression defaultValue = parameter.defaultValue;
         if (defaultValue != null) {
           RecordingErrorListener errorListener = new RecordingErrorListener();
           ErrorReporter errorReporter =
               new ErrorReporter(errorListener, element.source);
           DartObjectImpl dartObject =
@@ skipping 13 matching lines @@
           // The annotation is a reference to a compile-time constant variable.
           // Just copy the evaluation result.
           VariableElementImpl variableElement =
               element.variable as VariableElementImpl;
           elementAnnotation.evaluationResult = variableElement.evaluationResult;
         } else if (element is ConstructorElementImpl &&
             constNode.arguments != null) {
           RecordingErrorListener errorListener = new RecordingErrorListener();
           CompilationUnit sourceCompilationUnit =
               constNode.getAncestor((node) => node is CompilationUnit);
-          ErrorReporter errorReporter =
-              new ErrorReporter(errorListener, sourceCompilationUnit.element.source);
+          ErrorReporter errorReporter = new ErrorReporter(
+              errorListener, sourceCompilationUnit.element.source);
           ConstantVisitor constantVisitor =
               createConstantVisitor(errorReporter);
-          DartObjectImpl result = _evaluateConstructorCall(
-              constNode,
-              constNode.arguments.arguments,
-              element,
-              constantVisitor,
+          DartObjectImpl result = _evaluateConstructorCall(constNode,
+              constNode.arguments.arguments, element, constantVisitor,
               errorReporter);
           elementAnnotation.evaluationResult =
               new EvaluationResultImpl.con2(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.con1(null);
         }
       }
     } else {
       // Should not happen.
       AnalysisEngine.instance.logger.logError(
           "Constant value computer trying to compute the value of a node which is not a VariableDeclaration, InstanceCreationExpression, FormalParameter, or ConstructorDeclaration");
       return;
     }
   }
 
   /**
    * Evaluate a call to fromEnvironment() on the bool, int, or String class.
    *
    * @param environmentValue Value fetched from the environment
    * @param builtInDefaultValue Value that should be used as the default if no "defaultValue"
    *          argument appears in [namedArgumentValues].
    * @param namedArgumentValues Named parameters passed to fromEnvironment()
    * @return A [DartObjectImpl] object corresponding to the evaluated result
    */
   DartObjectImpl _computeValueFromEnvironment(DartObject environmentValue,
-      DartObjectImpl builtInDefaultValue, HashMap<String,
-      DartObjectImpl> namedArgumentValues) {
+      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
@@ skipping 36 matching lines @@
       }
     }
     constructor = _followConstantRedirectionChain(constructor);
     InterfaceType definingClass = constructor.returnType as InterfaceType;
     if (constructor.isFactory) {
       // We couldn't find a non-factory constructor.
       // See if it's because we reached an external const factory constructor
       // that we can emulate.
       if (constructor.name == "fromEnvironment") {
         if (!_checkFromEnvironmentArguments(
-            arguments,
-            argumentValues,
-            namedArgumentValues,
-            definingClass)) {
+            arguments, argumentValues, namedArgumentValues, definingClass)) {
           errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
-              node);
+              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)) {
+            arguments, argumentValues, namedArgumentValues)) {
           errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
-              node);
+              CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           return null;
         }
         String argumentValue = argumentValues[0].stringValue;
         return new DartObjectImpl(
-            definingClass,
-            new SymbolState(argumentValue));
+            definingClass, new SymbolState(argumentValue));
       }
       // Either it's an external const factory constructor that we can't
       // emulate, or an error occurred (a cycle, or a const constructor trying
       // to delegate to a non-const constructor).
       // In the former case, the best we can do is consider it an unknown value.
       // In the latter case, the error has already been reported, so considering
       // it an unknown value will suppress further errors.
       return constantVisitor._validWithUnknownValue(definingClass);
     }
     beforeGetConstantInitializers(constructor);
@@ skipping 46 matching lines @@
           // No default was provided, so the default value is null.
           argumentValue = constantVisitor.null2;
         } 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;
             fieldMap[fieldName] = argumentValue;
           }
         } else {
           String name = baseParameter.name;
           parameterMap[name] = argumentValue;
         }
       }
@@ skipping 11 matching lines @@
             initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
           String fieldName = constructorFieldInitializer.fieldName.name;
           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);
+        _evaluateSuperConstructorCall(node, fieldMap, superConstructor,
+            superArguments, initializerVisitor, errorReporter);
       }
     }
     return new DartObjectImpl(definingClass, new GenericState(fieldMap));
   }
 
-  void _evaluateSuperConstructorCall(AstNode node, HashMap<String,
-      DartObjectImpl> fieldMap, ConstructorElement superConstructor,
-      NodeList<Expression> superArguments, ConstantVisitor initializerVisitor,
-      ErrorReporter errorReporter) {
+  void _evaluateSuperConstructorCall(AstNode node,
+      HashMap<String, DartObjectImpl> fieldMap,
+      ConstructorElement superConstructor, NodeList<Expression> superArguments,
+      ConstantVisitor initializerVisitor, ErrorReporter errorReporter) {
     if (superConstructor != null && superConstructor.isConst) {
-      DartObjectImpl evaluationResult = _evaluateConstructorCall(
-          node,
-          superArguments,
-          superConstructor,
-          initializerVisitor,
-          errorReporter);
+      DartObjectImpl evaluationResult = _evaluateConstructorCall(node,
+          superArguments, superConstructor, initializerVisitor, errorReporter);
       if (evaluationResult != null) {
         fieldMap[GenericState.SUPERCLASS_FIELD] = evaluationResult;
       }
     }
   }
 
   /**
    * Attempt to follow the chain of factory redirections until a constructor is reached which is not
    * a const factory constructor.
    *
    * @return the constant constructor which terminates the chain of factory redirections, if the
    *         chain terminates. If there is a problem (e.g. a redirection can't be found, or a cycle
    *         is encountered), the chain will be followed as far as possible and then a const factory
    *         constructor will be returned.
    */
-  ConstructorElement
-      _followConstantRedirectionChain(ConstructorElement constructor) {
+  ConstructorElement _followConstantRedirectionChain(
+      ConstructorElement constructor) {
     HashSet<ConstructorElement> constructorsVisited =
         new HashSet<ConstructorElement>();
     while (constructor.isFactory) {
       if (identical(
-          constructor.enclosingElement.type,
-          typeProvider.symbolType)) {
+          constructor.enclosingElement.type, typeProvider.symbolType)) {
         // The dart:core.Symbol has a const factory constructor that redirects
         // to dart:_internal.Symbol.  That in turn redirects to an external
         // const constructor, which we won't be able to evaluate.
         // So stop following the chain of redirections at dart:core.Symbol, and
         // let [evaluateInstanceCreationExpression] handle it specially.
         break;
       }
       constructorsVisited.add(constructor);
       ConstructorElement redirectedConstructor =
           constructor.redirectedConstructor;
@@ skipping 48 matching lines @@
     if (type.isUndefined) {
       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" ||
-          new JavaPatternMatcher(_PUBLIC_SYMBOL_PATTERN, name).matches();
+  static bool isValidPublicSymbol(String name) => name.isEmpty ||
+      name == "void" ||
+      new JavaPatternMatcher(_PUBLIC_SYMBOL_PATTERN, name).matches();
 }
 
 /**
  * A `ConstantValueComputer_InitializerCloner` is an [AstCloner] that copies the
  * necessary information from the AST to allow const constructor initializers to
  * be evaluated.
  */
 class ConstantValueComputer_InitializerCloner extends AstCloner {
   // TODO(brianwilkerson) Investigate replacing uses of this class with uses of
   // AstCloner and ResolutionCopier.
 
   ConstantValueComputer_InitializerCloner() : super(true);
 
   @override
-  InstanceCreationExpression
-      visitInstanceCreationExpression(InstanceCreationExpression node) {
+  InstanceCreationExpression visitInstanceCreationExpression(
+      InstanceCreationExpression node) {
     InstanceCreationExpression expression =
         super.visitInstanceCreationExpression(node);
     expression.evaluationResult = node.evaluationResult;
     return expression;
   }
 
   @override
-  RedirectingConstructorInvocation
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation invocation =
         super.visitRedirectingConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
   }
 
   @override
   SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) {
     SimpleIdentifier identifier = super.visitSimpleIdentifier(node);
     identifier.staticElement = node.staticElement;
     return identifier;
   }
 
   @override
-  SuperConstructorInvocation
-      visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+  SuperConstructorInvocation visitSuperConstructorInvocation(
+      SuperConstructorInvocation node) {
     SuperConstructorInvocation invocation =
         super.visitSuperConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
   }
 }
 
 /**
  * Instances of the class `ConstantVisitor` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
@@ skipping 73 matching lines @@
         new DartObjectComputer(_errorReporter, _typeProvider);
   }
 
   /**
    * Initialize a newly created constant visitor.
    *
    * @param typeProvider the type provider used to access known types
    * @param lexicalEnvironment values which should override simpleIdentifiers, or null if no
    *          overriding is necessary.
    */
-  ConstantVisitor.con2(this._typeProvider, HashMap<String,
-      DartObjectImpl> lexicalEnvironment, this._errorReporter) {
+  ConstantVisitor.con2(this._typeProvider,
+      HashMap<String, DartObjectImpl> lexicalEnvironment, this._errorReporter) {
     this._lexicalEnvironment = lexicalEnvironment;
     this._dartObjectComputer =
         new DartObjectComputer(_errorReporter, _typeProvider);
   }
 
   /**
    * Return an object representing the value 'null'.
    *
    * @return an object representing the value 'null'
    */
   DartObjectImpl get null2 {
     if (_nullObject == null) {
       _nullObject =
           new DartObjectImpl(_typeProvider.nullType, NullState.NULL_STATE);
     }
     return _nullObject;
   }
 
   /**
    * This method is called just before retrieving an evaluation result from an AST node. Unit tests
    * will override it to introduce additional error checking.
    */
-  void beforeGetEvaluationResult(AstNode node) {
-  }
+  void beforeGetEvaluationResult(AstNode node) {}
 
   /**
    * Return `true` if the given [element] represents the `length` getter in
    * class [String].
    */
   bool isStringLength(Element element) {
     if (element is PropertyAccessorElement) {
       if (element.isGetter && element.name == 'length') {
         return element.enclosingElement == _typeProvider.stringType.element;
       }
@@ skipping 41 matching lines @@
       } else if (operatorType == TokenType.BAR_BAR) {
         return _dartObjectComputer.logicalOr(node, leftResult, rightResult);
       } else if (operatorType == TokenType.CARET) {
         return _dartObjectComputer.bitXor(node, leftResult, rightResult);
       } else if (operatorType == TokenType.EQ_EQ) {
         return _dartObjectComputer.equalEqual(node, leftResult, rightResult);
       } else if (operatorType == TokenType.GT) {
         return _dartObjectComputer.greaterThan(node, leftResult, rightResult);
       } else if (operatorType == TokenType.GT_EQ) {
         return _dartObjectComputer.greaterThanOrEqual(
-            node,
-            leftResult,
-            rightResult);
+            node, leftResult, rightResult);
       } else if (operatorType == TokenType.GT_GT) {
         return _dartObjectComputer.shiftRight(node, leftResult, rightResult);
       } else if (operatorType == TokenType.LT) {
         return _dartObjectComputer.lessThan(node, leftResult, rightResult);
       } else if (operatorType == TokenType.LT_EQ) {
         return _dartObjectComputer.lessThanOrEqual(
-            node,
-            leftResult,
-            rightResult);
+            node, leftResult, rightResult);
       } else if (operatorType == TokenType.LT_LT) {
         return _dartObjectComputer.shiftLeft(node, leftResult, rightResult);
       } else if (operatorType == TokenType.MINUS) {
         return _dartObjectComputer.minus(node, leftResult, rightResult);
       } else if (operatorType == TokenType.PERCENT) {
         return _dartObjectComputer.remainder(node, leftResult, rightResult);
       } else if (operatorType == TokenType.PLUS) {
         return _dartObjectComputer.add(node, leftResult, rightResult);
       } else if (operatorType == TokenType.STAR) {
         return _dartObjectComputer.times(node, leftResult, rightResult);
@@ skipping 17 matching lines @@
   @override
   DartObjectImpl visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     DartObjectImpl conditionResult = condition.accept(this);
     DartObjectImpl thenResult = node.thenExpression.accept(this);
     DartObjectImpl elseResult = node.elseExpression.accept(this);
     if (conditionResult == null) {
       return conditionResult;
     } else if (!conditionResult.isBool) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL,
-          condition);
+          CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, condition);
       return null;
     } else if (thenResult == null) {
       return thenResult;
     } else if (elseResult == null) {
       return elseResult;
     }
     conditionResult =
         _dartObjectComputer.applyBooleanConversion(condition, conditionResult);
     if (conditionResult == null) {
       return conditionResult;
     }
     if (conditionResult.isTrue) {
       return thenResult;
     } else if (conditionResult.isFalse) {
       return elseResult;
     }
     ParameterizedType thenType = thenResult.type;
     ParameterizedType elseType = elseResult.type;
     return _validWithUnknownValue(
         thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
   @override
   DartObjectImpl visitDoubleLiteral(DoubleLiteral node) =>
       new DartObjectImpl(_typeProvider.doubleType, new DoubleState(node.value));
 
   @override
-  DartObjectImpl
-      visitInstanceCreationExpression(InstanceCreationExpression node) {
+  DartObjectImpl visitInstanceCreationExpression(
+      InstanceCreationExpression node) {
     if (!node.isConst) {
       // TODO(brianwilkerson) Figure out which error to report.
       _error(node, null);
       return null;
     }
     beforeGetEvaluationResult(node);
     EvaluationResultImpl result = node.evaluationResult;
     if (result != null) {
       return result.value;
     }
@@ skipping 17 matching lines @@
   }
 
   @override
   DartObjectImpl visitInterpolationString(InterpolationString node) =>
       new DartObjectImpl(_typeProvider.stringType, new StringState(node.value));
 
   @override
   DartObjectImpl visitListLiteral(ListLiteral node) {
     if (node.constKeyword == null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL,
-          node);
+          CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL, node);
       return null;
     }
     bool errorOccurred = false;
     List<DartObjectImpl> elements = new List<DartObjectImpl>();
     for (Expression element in node.elements) {
       DartObjectImpl elementResult = element.accept(this);
       if (elementResult == null) {
         errorOccurred = true;
       } else {
         elements.add(elementResult);
@@ skipping 11 matching lines @@
       }
     }
     InterfaceType listType = _typeProvider.listType.substitute4([elementType]);
     return new DartObjectImpl(listType, new ListState(elements));
   }
 
   @override
   DartObjectImpl visitMapLiteral(MapLiteral node) {
     if (node.constKeyword == null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL,
-          node);
+          CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL, node);
       return null;
     }
     bool errorOccurred = false;
     HashMap<DartObjectImpl, DartObjectImpl> map =
         new HashMap<DartObjectImpl, DartObjectImpl>();
     for (MapLiteralEntry entry in node.entries) {
       DartObjectImpl keyResult = entry.key.accept(this);
       DartObjectImpl valueResult = entry.value.accept(this);
       if (keyResult == null || valueResult == null) {
         errorOccurred = true;
@@ skipping 30 matching lines @@
       if (function.name == "identical") {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 2) {
           Element enclosingElement = function.enclosingElement;
           if (enclosingElement is CompilationUnitElement) {
             LibraryElement library = enclosingElement.library;
             if (library.isDartCore) {
               DartObjectImpl leftArgument = arguments[0].accept(this);
               DartObjectImpl rightArgument = arguments[1].accept(this);
               return _dartObjectComputer.isIdentical(
-                  node,
-                  leftArgument,
-                  rightArgument);
+                  node, leftArgument, rightArgument);
             }
           }
         }
       }
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
@@ skipping 105 matching lines @@
   DartObjectImpl visitSymbolLiteral(SymbolLiteral node) {
     StringBuffer buffer = new StringBuffer();
     List<Token> components = node.components;
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
         buffer.writeCharCode(0x2E);
       }
       buffer.write(components[i].lexeme);
     }
     return new DartObjectImpl(
-        _typeProvider.symbolType,
-        new SymbolState(buffer.toString()));
+        _typeProvider.symbolType, new SymbolState(buffer.toString()));
   }
 
   /**
    * Create an error associated with the given node.
    *
    * @param node the AST node associated with the error
    * @param code the error code indicating the nature of the error
    */
   void _error(AstNode node, ErrorCode code) {
     _errorReporter.reportErrorForNode(
-        code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code,
-        node);
+        code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code, node);
   }
 
   /**
    * Return the constant value of the static constant represented by the given element.
    *
    * @param node the node to be used if an error needs to be reported
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   DartObjectImpl _getConstantValue(AstNode node, Element element) {
@@ skipping 168 matching lines @@
     }
     return null;
   }
 
   /**
    * 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
    */
-  DartObjectImpl applyBooleanConversion(AstNode node,
-      DartObjectImpl evaluationResult) {
+  DartObjectImpl applyBooleanConversion(
+      AstNode node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.convertToBool(_typeProvider);
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
@@ skipping 215 matching lines @@
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.notEqual(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
-  DartObjectImpl performToString(AstNode node,
-      DartObjectImpl evaluationResult) {
+  DartObjectImpl performToString(
+      AstNode node, DartObjectImpl evaluationResult) {
     if (evaluationResult != null) {
       try {
         return evaluationResult.performToString(_typeProvider);
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return null;
   }
 
@@ skipping 32 matching lines @@
     }
     return null;
   }
 
   /**
    * Return the result of invoking the 'length' getter on this result.
    *
    * @param node the node against which errors should be reported
    * @return the result of invoking the 'length' getter on this result
    */
-  EvaluationResultImpl stringLength(Expression node,
-      EvaluationResultImpl evaluationResult) {
+  EvaluationResultImpl stringLength(
+      Expression node, EvaluationResultImpl evaluationResult) {
     if (evaluationResult.value != null) {
       try {
         return new EvaluationResultImpl.con1(
             evaluationResult.value.stringLength(_typeProvider));
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node);
       }
     }
     return new EvaluationResultImpl.con1(null);
   }
@@ skipping 152 matching lines @@
   }
 
   /**
    * Return the result of invoking the '&' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl bitAnd(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
-      new DartObjectImpl(typeProvider.intType, _state.bitAnd(rightOperand._state));
+  DartObjectImpl bitAnd(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(
+          typeProvider.intType, _state.bitAnd(rightOperand._state));
 
   /**
    * Return the result of invoking the '~' operator on this object.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of invoking the '~' operator on this object
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl bitNot(TypeProvider typeProvider) =>
       new DartObjectImpl(typeProvider.intType, _state.bitNot());
 
   /**
    * Return the result of invoking the '|' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '|' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl bitOr(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
-      new DartObjectImpl(typeProvider.intType, _state.bitOr(rightOperand._state));
+  DartObjectImpl bitOr(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(
+          typeProvider.intType, _state.bitOr(rightOperand._state));
 
   /**
    * Return the result of invoking the '^' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '^' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl bitXor(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
-      new DartObjectImpl(typeProvider.intType, _state.bitXor(rightOperand._state));
+  DartObjectImpl bitXor(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(
+          typeProvider.intType, _state.bitXor(rightOperand._state));
 
   /**
    * Return the result of invoking the ' ' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the ' ' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl concatenate(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl concatenate(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.stringType,
-          _state.concatenate(rightOperand._state));
+          typeProvider.stringType, _state.concatenate(rightOperand._state));
 
   /**
    * Return the result of applying boolean conversion to this object.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of applying boolean conversion to this object
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl convertToBool(TypeProvider typeProvider) {
     InterfaceType boolType = typeProvider.boolType;
     if (identical(type, boolType)) {
       return this;
     }
     return new DartObjectImpl(boolType, _state.convertToBool());
   }
 
   /**
    * Return the result of invoking the '/' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '/' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl divide(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) {
+  DartObjectImpl divide(
+      TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.divide(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
     throw new IllegalStateException("divide returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '==' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '==' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl equalEqual(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) {
+  DartObjectImpl equalEqual(
+      TypeProvider typeProvider, DartObjectImpl rightOperand) {
     if (type != rightOperand.type) {
       String typeName = type.name;
       if (!(typeName == "bool" ||
           typeName == "double" ||
           typeName == "int" ||
           typeName == "num" ||
           typeName == "String" ||
           typeName == "Null" ||
           type.isDynamic)) {
         throw new EvaluationException(
             CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
       }
     }
     return new DartObjectImpl(
-        typeProvider.boolType,
-        _state.equalEqual(rightOperand._state));
+        typeProvider.boolType, _state.equalEqual(rightOperand._state));
   }
 
   /**
    * Return the result of invoking the '&gt;' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&gt;' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl greaterThan(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl greaterThan(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.boolType,
-          _state.greaterThan(rightOperand._state));
+          typeProvider.boolType, _state.greaterThan(rightOperand._state));
 
   /**
    * Return the result of invoking the '&gt;=' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&gt;=' operator on this object with the given argument
    * @throws 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 rightOperand) => new DartObjectImpl(
+      typeProvider.boolType, _state.greaterThanOrEqual(rightOperand._state));
 
   /**
    * Return the result of invoking the '~/' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '~/' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl integerDivide(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl integerDivide(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.intType,
-          _state.integerDivide(rightOperand._state));
+          typeProvider.intType, _state.integerDivide(rightOperand._state));
 
   /**
    * Return the result of invoking the identical function on this object with
    * the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the identical function on this object with
    *         the given argument
    */
-  DartObjectImpl isIdentical(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) {
+  DartObjectImpl isIdentical(
+      TypeProvider typeProvider, DartObjectImpl rightOperand) {
     return new DartObjectImpl(
-        typeProvider.boolType,
-        _state.isIdentical(rightOperand._state));
+        typeProvider.boolType, _state.isIdentical(rightOperand._state));
   }
 
   /**
    * Return the result of invoking the '&lt;' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&lt;' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl lessThan(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
-      new DartObjectImpl(typeProvider.boolType, _state.lessThan(rightOperand._state));
+  DartObjectImpl lessThan(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(
+          typeProvider.boolType, _state.lessThan(rightOperand._state));
 
   /**
    * Return the result of invoking the '&lt;=' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&lt;=' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl lessThanOrEqual(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl lessThanOrEqual(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.boolType,
-          _state.lessThanOrEqual(rightOperand._state));
+          typeProvider.boolType, _state.lessThanOrEqual(rightOperand._state));
 
   /**
    * Return the result of invoking the '&&' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&&' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl logicalAnd(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl logicalAnd(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.boolType,
-          _state.logicalAnd(rightOperand._state));
+          typeProvider.boolType, _state.logicalAnd(rightOperand._state));
 
   /**
    * Return the result of invoking the '!' operator on this object.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of invoking the '!' operator on this object
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl logicalNot(TypeProvider typeProvider) =>
       new DartObjectImpl(typeProvider.boolType, _state.logicalNot());
 
   /**
    * Return the result of invoking the '||' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '||' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl logicalOr(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl logicalOr(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.boolType,
-          _state.logicalOr(rightOperand._state));
+          typeProvider.boolType, _state.logicalOr(rightOperand._state));
 
   /**
    * Return the result of invoking the '-' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '-' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl minus(TypeProvider typeProvider, DartObjectImpl rightOperand) {
@@ skipping 30 matching lines @@
   }
 
   /**
    * Return the result of invoking the '!=' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '!=' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl notEqual(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) {
+  DartObjectImpl notEqual(
+      TypeProvider typeProvider, DartObjectImpl rightOperand) {
     if (type != rightOperand.type) {
       String typeName = type.name;
       if (typeName != "bool" &&
           typeName != "double" &&
           typeName != "int" &&
           typeName != "num" &&
           typeName != "String") {
         return new DartObjectImpl(typeProvider.boolType, BoolState.TRUE_STATE);
       }
     }
-    return new DartObjectImpl(
-        typeProvider.boolType,
+    return new DartObjectImpl(typeProvider.boolType,
         _state.equalEqual(rightOperand._state).logicalNot());
   }
 
   /**
    * Return the result of converting this object to a String.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of converting this object to a String
    * @throws EvaluationException if the object cannot be converted to a String
    */
   DartObjectImpl performToString(TypeProvider typeProvider) {
     InterfaceType stringType = typeProvider.stringType;
     if (identical(type, stringType)) {
       return this;
     }
     return new DartObjectImpl(stringType, _state.convertToString());
   }
 
   /**
    * Return the result of invoking the '%' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '%' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl remainder(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) {
+  DartObjectImpl remainder(
+      TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.remainder(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
     throw new IllegalStateException(
         "remainder returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '&lt;&lt;' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&lt;&lt;' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl shiftLeft(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
-      new DartObjectImpl(typeProvider.intType, _state.shiftLeft(rightOperand._state));
+  DartObjectImpl shiftLeft(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
+      new DartObjectImpl(
+          typeProvider.intType, _state.shiftLeft(rightOperand._state));
 
   /**
    * Return the result of invoking the '&gt;&gt;' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&gt;&gt;' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
-  DartObjectImpl shiftRight(TypeProvider typeProvider,
-      DartObjectImpl rightOperand) =>
+  DartObjectImpl shiftRight(
+          TypeProvider typeProvider, DartObjectImpl rightOperand) =>
       new DartObjectImpl(
-          typeProvider.intType,
-          _state.shiftRight(rightOperand._state));
+          typeProvider.intType, _state.shiftRight(rightOperand._state));
 
   /**
    * Return the result of invoking the 'length' getter on this object.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of invoking the 'length' getter on this object
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl stringLength(TypeProvider typeProvider) =>
       new DartObjectImpl(typeProvider.intType, _state.stringLength());
@@ skipping 94 matching lines @@
    * name interpreted as a String value. If the variable is not defined (or [variableName] is
    * null), a DartObject representing "unknown" is returned.
    *
    * @param typeProvider the type provider used to find the type 'String'
    * @param variableName the name of the variable whose value is to be returned
    */
   DartObject getString(TypeProvider typeProvider, String variableName) {
     String value = _declaredVariables[variableName];
     if (value == null) {
       return new DartObjectImpl(
-          typeProvider.stringType,
-          StringState.UNKNOWN_VALUE);
+          typeProvider.stringType, StringState.UNKNOWN_VALUE);
     }
     return new DartObjectImpl(typeProvider.stringType, new StringState(value));
   }
 }
 
 /**
  * Instances of the class `DoubleState` represent the state of an object representing a
  * double.
  */
 class DoubleState extends NumState {
@@ skipping 2127 matching lines @@
   final DirectedGraph<AstNode> _referenceGraph;
 
   /**
    * A table mapping constant variables to the declarations of those variables.
    */
   final HashMap<VariableElement, VariableDeclaration> _variableDeclarationMap;
 
   /**
    * A table mapping constant constructors to the declarations of those constructors.
    */
-  final HashMap<ConstructorElement, ConstructorDeclaration>
-      _constructorDeclarationMap;
+  final HashMap<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
 
   /**
    * Initialize a newly created reference finder to find references from the given variable to other
    * variables and to add those references to the given graph.
    *
    * @param source the element representing the variable whose initializer will be visited
    * @param referenceGraph a graph recording which variables (heads) reference which other variables
    *          (tails) in their initializers
    * @param variableDeclarationMap A table mapping constant variables to the declarations of those
    *          variables.
    * @param constructorDeclarationMap A table mapping constant constructors to the declarations of
    *          those constructors.
    */
   ReferenceFinder(this._source, this._referenceGraph,
       this._variableDeclarationMap, this._constructorDeclarationMap);
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
       _referenceGraph.addEdge(_source, node);
     }
     return null;
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     super.visitRedirectingConstructorInvocation(node);
     ConstructorElement target = node.staticElement;
     if (target != null && target.isConst) {
       ConstructorDeclaration targetDeclaration =
           _constructorDeclarationMap[target];
       if (targetDeclaration != null) {
         _referenceGraph.addEdge(_source, targetDeclaration);
       }
     }
     return null;
@@ skipping 257 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;
 }