Translate private Java members to private Dart members.

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 'java_core.dart';
@@ skipping 308 matching lines @@
     _declarationMap = _constantFinder.variableMap;
     for (MapEntry<VariableElement, VariableDeclaration> entry in getMapEntrySet(_declarationMap)) {
       VariableElement element = entry.getKey();
       ReferenceFinder referenceFinder = new ReferenceFinder(element, _referenceGraph);
       _referenceGraph.addNode(element);
       entry.getValue().initializer.accept(referenceFinder);
     }
     while (!_referenceGraph.isEmpty) {
       VariableElement element = _referenceGraph.removeSink();
       while (element != null) {
-        computeValueFor(element);
+        _computeValueFor(element);
         element = _referenceGraph.removeSink();
       }
       if (!_referenceGraph.isEmpty) {
         List<VariableElement> variablesInCycle = _referenceGraph.findCycle();
         if (variablesInCycle == null) {
           //
           // This should not happen. Either the graph should be empty, or there should be at least
           // one sink, or there should be a cycle. If this does happen we exit to prevent an
           // infinite loop.
           //
           AnalysisEngine.instance.logger.logError("Exiting constant value computer with ${_referenceGraph.nodeCount} variables that are neither sinks nor in a cycle");
           return;
         }
         for (VariableElement variable in variablesInCycle) {
-          generateCycleError(variablesInCycle, variable);
+          _generateCycleError(variablesInCycle, variable);
         }
         _referenceGraph.removeAllNodes(variablesInCycle);
       }
     }
   }
 
   /**
    * Compute a value for the given variable.
    *
    * @param variable the variable for which a value is to be computed
    */
-  void computeValueFor(VariableElement variable) {
+  void _computeValueFor(VariableElement variable) {
     VariableDeclaration declaration = _declarationMap[variable];
     if (declaration == null) {
       //
       // The declaration will be null when the variable was added to the graph as a result of being
       // referenced by another variable but is not defined in the compilation units that were added
       // to this computer. In such cases, the variable should already have a value associated with
       // it, but we don't bother to check because there's nothing we can do about it at this point.
       //
       return;
     }
@@ skipping 10 matching lines @@
   }
 
   /**
    * Generate an error indicating that the given variable is not a valid compile-time constant
    * because it references at least one of the variables in the given cycle, each of which directly
    * or indirectly references the variable.
    *
    * @param variablesInCycle the variables in the cycle that includes the given variable
    * @param variable the variable that is not a valid compile-time constant
    */
-  void generateCycleError(List<VariableElement> variablesInCycle, VariableElement variable) {
+  void _generateCycleError(List<VariableElement> variablesInCycle, VariableElement variable) {
   }
 }
 
 /**
  * Instances of the class `ConstantVisitor` 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
@@ skipping 65 matching lines @@
     return result;
   }
 
   EvaluationResultImpl visitBinaryExpression(BinaryExpression node) {
     EvaluationResultImpl leftResult = node.leftOperand.accept(this);
     EvaluationResultImpl rightResult = node.rightOperand.accept(this);
     TokenType operatorType = node.operator.type;
     // 'null' is almost never good operand
     if (operatorType != TokenType.BANG_EQ && operatorType != TokenType.EQ_EQ) {
       if (leftResult is ValidResult && leftResult.isNull || rightResult is ValidResult && rightResult.isNull) {
-        return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
+        return _error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
       }
     }
     // evaluate operator
     while (true) {
       if (operatorType == TokenType.AMPERSAND) {
         return leftResult.bitAnd(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
         return leftResult.logicalAnd(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.BANG_EQ) {
         return leftResult.notEqual(_typeProvider, node, rightResult);
@@ skipping 24 matching lines @@
       } else if (operatorType == TokenType.PLUS) {
         return leftResult.add(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.STAR) {
         return leftResult.times(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.SLASH) {
         return leftResult.divide(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.TILDE_SLASH) {
         return leftResult.integerDivide(_typeProvider, node, rightResult);
       } else {
         // TODO(brianwilkerson) Figure out which error to report.
-        return error(node, null);
+        return _error(node, null);
       }
       break;
     }
   }
 
-  EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => valid(_typeProvider.boolType, BoolState.from(node.value));
+  EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => _valid(_typeProvider.boolType, BoolState.from(node.value));
 
   EvaluationResultImpl visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     EvaluationResultImpl conditionResult = condition.accept(this);
     EvaluationResultImpl thenResult = node.thenExpression.accept(this);
     EvaluationResultImpl elseResult = node.elseExpression.accept(this);
     if (conditionResult is ErrorResult) {
-      return union(union(conditionResult as ErrorResult, thenResult), elseResult);
+      return _union(_union(conditionResult as ErrorResult, thenResult), elseResult);
     } else if (!(conditionResult as ValidResult).isBool) {
       return new ErrorResult.con1(condition, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL);
     } else if (thenResult is ErrorResult) {
-      return union(thenResult, elseResult);
+      return _union(thenResult, elseResult);
     } else if (elseResult is ErrorResult) {
       return elseResult;
     }
     conditionResult = conditionResult.applyBooleanConversion(_typeProvider, condition);
     if (conditionResult is ErrorResult) {
       return conditionResult;
     }
     ValidResult validResult = conditionResult as ValidResult;
     if (validResult.isTrue) {
       return thenResult;
     } else if (validResult.isFalse) {
       return elseResult;
     }
     InterfaceType thenType = (thenResult as ValidResult).value.type;
     InterfaceType elseType = (elseResult as ValidResult).value.type;
-    return validWithUnknownValue(thenType.getLeastUpperBound(elseType) as InterfaceType);
+    return _validWithUnknownValue(thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
-  EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => valid(_typeProvider.doubleType, new DoubleState(node.value));
+  EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => _valid(_typeProvider.doubleType, new DoubleState(node.value));
 
   EvaluationResultImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (!node.isConst) {
       // TODO(brianwilkerson) Figure out which error to report.
-      return error(node, null);
+      return _error(node, null);
     }
     ConstructorElement constructor = node.staticElement;
     if (constructor != null && constructor.isConst) {
       NodeList<Expression> arguments = node.argumentList.arguments;
       int argumentCount = arguments.length;
       List<DartObjectImpl> argumentValues = new List<DartObjectImpl>(argumentCount);
       Map<String, DartObjectImpl> namedArgumentValues = new Map<String, DartObjectImpl>();
       for (int i = 0; i < argumentCount; i++) {
         Expression argument = arguments[i];
         if (argument is NamedExpression) {
           NamedExpression namedExpression = argument;
           String name = namedExpression.name.label.name;
-          namedArgumentValues[name] = valueOf(namedExpression.expression);
+          namedArgumentValues[name] = _valueOf(namedExpression.expression);
           argumentValues[i] = null2;
         } else {
-          argumentValues[i] = valueOf(argument);
+          argumentValues[i] = _valueOf(argument);
         }
       }
       InterfaceType definingClass = constructor.returnType as InterfaceType;
       if (definingClass.element.library.isDartCore) {
         String className = definingClass.name;
         if (className == "Symbol" && argumentCount == 1) {
           String argumentValue = argumentValues[0].stringValue;
           if (argumentValue != null) {
-            return valid(definingClass, new SymbolState(argumentValue));
+            return _valid(definingClass, new SymbolState(argumentValue));
           }
         }
       }
       Map<String, DartObjectImpl> fieldMap = new Map<String, DartObjectImpl>();
       List<ParameterElement> parameters = constructor.parameters;
       int parameterCount = parameters.length;
       for (int i = 0; i < parameterCount; i++) {
         ParameterElement parameter = parameters[i];
         if (parameter.isInitializingFormal) {
           String fieldName = (parameter as FieldFormalParameterElement).field.name;
           if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
             DartObjectImpl argumentValue = namedArgumentValues[parameter.name];
             if (argumentValue != null) {
               fieldMap[fieldName] = argumentValue;
             }
           } else if (i < argumentCount) {
             fieldMap[fieldName] = argumentValues[i];
           }
         }
       }
       // TODO(brianwilkerson) This doesn't handle fields initialized in an initializer. We should be
       // able to handle fields initialized by the superclass' constructor fairly easily, but other
       // initializers will be harder.
-      return valid(definingClass, new GenericState(fieldMap));
+      return _valid(definingClass, new GenericState(fieldMap));
     }
     // TODO(brianwilkerson) Figure out which error to report.
-    return error(node, null);
+    return _error(node, null);
   }
 
-  EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => valid(_typeProvider.intType, new IntState(node.value));
+  EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => _valid(_typeProvider.intType, new IntState(node.value));
 
   EvaluationResultImpl visitInterpolationExpression(InterpolationExpression node) {
     EvaluationResultImpl result = node.expression.accept(this);
     if (result is ValidResult && !result.isBoolNumStringOrNull) {
-      return error(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
+      return _error(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
     }
     return result.performToString(_typeProvider, node);
   }
 
-  EvaluationResultImpl visitInterpolationString(InterpolationString node) => valid(_typeProvider.stringType, new StringState(node.value));
+  EvaluationResultImpl visitInterpolationString(InterpolationString node) => _valid(_typeProvider.stringType, new StringState(node.value));
 
   EvaluationResultImpl visitListLiteral(ListLiteral node) {
     if (node.constKeyword == null) {
       return new ErrorResult.con1(node, CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL);
     }
     ErrorResult result = null;
     List<DartObjectImpl> elements = new List<DartObjectImpl>();
     for (Expression element in node.elements) {
       EvaluationResultImpl elementResult = element.accept(this);
-      result = union(result, elementResult);
+      result = _union(result, elementResult);
       if (elementResult is ValidResult) {
         elements.add(elementResult.value);
       }
     }
     if (result != null) {
       return result;
     }
-    return valid(_typeProvider.listType, new ListState(new List.from(elements)));
+    return _valid(_typeProvider.listType, new ListState(new List.from(elements)));
   }
 
   EvaluationResultImpl visitMapLiteral(MapLiteral node) {
     if (node.constKeyword == null) {
       return new ErrorResult.con1(node, CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL);
     }
     ErrorResult result = null;
     Map<DartObjectImpl, DartObjectImpl> map = new Map<DartObjectImpl, DartObjectImpl>();
     for (MapLiteralEntry entry in node.entries) {
       EvaluationResultImpl keyResult = entry.key.accept(this);
       EvaluationResultImpl valueResult = entry.value.accept(this);
-      result = union(result, keyResult);
-      result = union(result, valueResult);
+      result = _union(result, keyResult);
+      result = _union(result, valueResult);
       if (keyResult is ValidResult && valueResult is ValidResult) {
         map[keyResult.value] = valueResult.value;
       }
     }
     if (result != null) {
       return result;
     }
-    return valid(_typeProvider.mapType, new MapState(map));
+    return _valid(_typeProvider.mapType, new MapState(map));
   }
 
   EvaluationResultImpl visitMethodInvocation(MethodInvocation node) {
     Element element = node.methodName.staticElement;
     if (element is FunctionElement) {
       FunctionElement function = element;
       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) {
               EvaluationResultImpl leftArgument = arguments[0].accept(this);
               EvaluationResultImpl rightArgument = arguments[1].accept(this);
               return leftArgument.equalEqual(_typeProvider, node, rightArgument);
             }
           }
         }
       }
     }
     // TODO(brianwilkerson) Figure out which error to report.
-    return error(node, null);
+    return _error(node, null);
   }
 
   EvaluationResultImpl visitNamedExpression(NamedExpression node) => node.expression.accept(this);
 
-  EvaluationResultImpl visitNode(AstNode node) => error(node, null);
+  EvaluationResultImpl visitNode(AstNode node) => _error(node, null);
 
   EvaluationResultImpl visitNullLiteral(NullLiteral node) => new ValidResult(null2);
 
   EvaluationResultImpl visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
 
   EvaluationResultImpl visitPrefixedIdentifier(PrefixedIdentifier node) {
     // validate prefix
     SimpleIdentifier prefixNode = node.prefix;
     Element prefixElement = prefixNode.staticElement;
     if (prefixElement is! PrefixElement) {
       EvaluationResultImpl prefixResult = prefixNode.accept(this);
       if (prefixResult is! ValidResult) {
-        return error(node, null);
+        return _error(node, null);
       }
     }
     // validate prefixed identifier
-    return getConstantValue(node, node.staticElement);
+    return _getConstantValue(node, node.staticElement);
   }
 
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
     EvaluationResultImpl operand = node.operand.accept(this);
     if (operand is ValidResult && operand.isNull) {
-      return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
+      return _error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         return operand.logicalNot(_typeProvider, node);
       } else if (node.operator.type == TokenType.TILDE) {
         return operand.bitNot(_typeProvider, node);
       } else if (node.operator.type == TokenType.MINUS) {
         return operand.negated(_typeProvider, node);
       } else {
         // TODO(brianwilkerson) Figure out which error to report.
-        return error(node, null);
+        return _error(node, null);
       }
       break;
     }
   }
 
-  EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => getConstantValue(node, node.propertyName.staticElement);
+  EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => _getConstantValue(node, node.propertyName.staticElement);
 
-  EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(node, node.staticElement);
+  EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => _getConstantValue(node, node.staticElement);
 
-  EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => valid(_typeProvider.stringType, new StringState(node.value));
+  EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => _valid(_typeProvider.stringType, new StringState(node.value));
 
   EvaluationResultImpl visitStringInterpolation(StringInterpolation node) {
     EvaluationResultImpl result = null;
     for (InterpolationElement element in node.elements) {
       if (result == null) {
         result = element.accept(this);
       } else {
         result = result.concatenate(_typeProvider, node, element.accept(this));
       }
     }
     return result;
   }
 
   EvaluationResultImpl visitSymbolLiteral(SymbolLiteral node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     List<Token> components = node.components;
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
         builder.appendChar(0x2E);
       }
       builder.append(components[i].lexeme);
     }
-    return valid(_typeProvider.symbolType, new SymbolState(builder.toString()));
+    return _valid(_typeProvider.symbolType, new SymbolState(builder.toString()));
   }
 
   /**
    * Return a result object representing 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
    * @return a result object representing an error associated with the given node
    */
-  ErrorResult error(AstNode node, ErrorCode code) => new ErrorResult.con1(node, code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code);
+  ErrorResult _error(AstNode node, ErrorCode code) => new ErrorResult.con1(node, code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code);
 
   /**
    * 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
    */
-  EvaluationResultImpl getConstantValue(AstNode node, Element element) {
+  EvaluationResultImpl _getConstantValue(AstNode node, Element element) {
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElementImpl) {
       VariableElementImpl variableElementImpl = element;
       EvaluationResultImpl value = variableElementImpl.evaluationResult;
       if (variableElementImpl.isConst && value != null) {
         return value;
       }
     } else if (element is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
-        return valid(_typeProvider.functionType, new FunctionState(function));
+        return _valid(_typeProvider.functionType, new FunctionState(function));
       }
     } else if (element is ClassElement || element is FunctionTypeAliasElement) {
-      return valid(_typeProvider.typeType, new TypeState(element));
+      return _valid(_typeProvider.typeType, new TypeState(element));
     }
     // TODO(brianwilkerson) Figure out which error to report.
-    return error(node, null);
+    return _error(node, null);
   }
 
   /**
    * 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;
   }
 
   /**
    * Return the union of the errors encoded in the given results.
    *
    * @param leftResult the first set of errors, or `null` if there was no previous collection
    *          of errors
    * @param rightResult the errors to be added to the collection, or a valid result if there are no
    *          errors to be added
    * @return the union of the errors encoded in the given results
    */
-  ErrorResult union(ErrorResult leftResult, EvaluationResultImpl rightResult) {
+  ErrorResult _union(ErrorResult leftResult, EvaluationResultImpl rightResult) {
     if (rightResult is ErrorResult) {
       if (leftResult != null) {
         return new ErrorResult.con2(leftResult, rightResult);
       } else {
         return rightResult;
       }
     }
     return leftResult;
   }
 
-  ValidResult valid(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
+  ValidResult _valid(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
 
-  ValidResult validWithUnknownValue(InterfaceType type) {
+  ValidResult _validWithUnknownValue(InterfaceType type) {
     if (type.element.library.isDartCore) {
       String typeName = type.name;
       if (typeName == "bool") {
-        return valid(type, BoolState.UNKNOWN_VALUE);
+        return _valid(type, BoolState.UNKNOWN_VALUE);
       } else if (typeName == "double") {
-        return valid(type, DoubleState.UNKNOWN_VALUE);
+        return _valid(type, DoubleState.UNKNOWN_VALUE);
       } else if (typeName == "int") {
-        return valid(type, IntState.UNKNOWN_VALUE);
+        return _valid(type, IntState.UNKNOWN_VALUE);
       } else if (typeName == "String") {
-        return valid(type, StringState.UNKNOWN_VALUE);
+        return _valid(type, StringState.UNKNOWN_VALUE);
       }
     }
-    return valid(type, GenericState.UNKNOWN_VALUE);
+    return _valid(type, GenericState.UNKNOWN_VALUE);
   }
 
   /**
    * Return the value of the given expression, or a representation of 'null' if the expression
    * cannot be evaluated.
    *
    * @param expression the expression whose value is to be returned
    * @return the value of the given expression
    */
-  DartObjectImpl valueOf(Expression expression) {
+  DartObjectImpl _valueOf(Expression expression) {
     EvaluationResultImpl expressionValue = expression.accept(this);
     if (expressionValue is ValidResult) {
       return expressionValue.value;
     }
     return null2;
   }
 }
 
 /**
  * Instances of the class `DirectedGraph` implement a directed graph in which the nodes are
@@ skipping 130 matching lines @@
   /**
    * Find one node (referred to as a sink node) that has no outgoing edges (that is, for which there
    * are no edges that have that node as the head of the edge) and remove it from this graph. Return
    * the node that was removed, or `null` if there are no such nodes either because the graph
    * is empty or because every node in the graph has at least one outgoing edge. As a consequence of
    * removing the node from the graph any edges for which that node was a tail will also be removed.
    *
    * @return the sink node that was removed
    */
   N removeSink() {
-    N sink = findSink();
+    N sink = _findSink();
     if (sink == null) {
       return null;
     }
     removeNode(sink);
     return sink;
   }
 
   /**
    * Return one node that has no outgoing edges (that is, for which there are no edges that have
    * that node as the head of the edge), or `null` if there are no such nodes.
    *
    * @return a sink node
    */
-  N findSink() {
+  N _findSink() {
     for (N key in _edges.keys) {
       if (_edges[key].isEmpty) return key;
     }
     return null;
   }
 }
 
 /**
  * Instances of the class `ErrorResult` represent the result of evaluating an expression that
  * is not a valid compile time constant.
@@ skipping 392 matching lines @@
   EvaluationResultImpl add(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToValid(typeProvider, node, this);
 
   /**
    * 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
    */
   EvaluationResultImpl applyBooleanConversion(TypeProvider typeProvider, AstNode node) {
     try {
-      return valueOf(value.convertToBool(typeProvider));
+      return _valueOf(value.convertToBool(typeProvider));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl bitAnd(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndValid(typeProvider, node, this);
 
   EvaluationResultImpl bitNot(TypeProvider typeProvider, Expression node) {
     try {
-      return valueOf(value.bitNot(typeProvider));
+      return _valueOf(value.bitNot(typeProvider));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl bitOr(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitOrValid(typeProvider, node, this);
 
   EvaluationResultImpl bitXor(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitXorValid(typeProvider, node, this);
 
   EvaluationResultImpl concatenate(TypeProvider typeProvider, Expression node, EvaluationResultImpl rightOperand) => rightOperand.concatenateValid(typeProvider, node, this);
 
   EvaluationResultImpl divide(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.divideValid(typeProvider, node, this);
@@ skipping 57 matching lines @@
   bool get isUserDefinedObject => value.isUserDefinedObject;
 
   EvaluationResultImpl lessThan(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanValid(typeProvider, node, this);
 
   EvaluationResultImpl lessThanOrEqual(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanOrEqualValid(typeProvider, node, this);
 
   EvaluationResultImpl logicalAnd(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalAndValid(typeProvider, node, this);
 
   EvaluationResultImpl logicalNot(TypeProvider typeProvider, Expression node) {
     try {
-      return valueOf(value.logicalNot(typeProvider));
+      return _valueOf(value.logicalNot(typeProvider));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl logicalOr(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalOrValid(typeProvider, node, this);
 
   EvaluationResultImpl minus(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.minusValid(typeProvider, node, this);
 
   EvaluationResultImpl negated(TypeProvider typeProvider, Expression node) {
     try {
-      return valueOf(value.negated(typeProvider));
+      return _valueOf(value.negated(typeProvider));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl notEqual(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.notEqualValid(typeProvider, node, this);
 
   EvaluationResultImpl performToString(TypeProvider typeProvider, AstNode node) {
     try {
-      return valueOf(value.performToString(typeProvider));
+      return _valueOf(value.performToString(typeProvider));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl remainder(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.remainderValid(typeProvider, node, this);
 
   EvaluationResultImpl shiftLeft(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftLeftValid(typeProvider, node, this);
 
   EvaluationResultImpl shiftRight(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftRightValid(typeProvider, node, this);
 
   EvaluationResultImpl times(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.timesValid(typeProvider, node, this);
 
   String toString() {
     if (value == null) {
       return "null";
     }
     return value.toString();
   }
 
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl addToValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.add(typeProvider, value));
+      return _valueOf(leftOperand.value.add(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl bitAndValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.bitAnd(typeProvider, value));
+      return _valueOf(leftOperand.value.bitAnd(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl bitOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl bitOrValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.bitOr(typeProvider, value));
+      return _valueOf(leftOperand.value.bitOr(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl bitXorError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl bitXorValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.bitXor(typeProvider, value));
+      return _valueOf(leftOperand.value.bitXor(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl concatenateError(Expression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl concatenateValid(TypeProvider typeProvider, Expression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.concatenate(typeProvider, value));
+      return _valueOf(leftOperand.value.concatenate(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl divideValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.divide(typeProvider, value));
+      return _valueOf(leftOperand.value.divide(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl equalEqualError(Expression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl equalEqualValid(TypeProvider typeProvider, Expression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.equalEqual(typeProvider, value));
+      return _valueOf(leftOperand.value.equalEqual(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl greaterThanOrEqualValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.greaterThanOrEqual(typeProvider, value));
+      return _valueOf(leftOperand.value.greaterThanOrEqual(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl greaterThanValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.greaterThan(typeProvider, value));
+      return _valueOf(leftOperand.value.greaterThan(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl integerDivideValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.integerDivide(typeProvider, value));
+      return _valueOf(leftOperand.value.integerDivide(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl lessThanOrEqualValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.lessThanOrEqual(typeProvider, value));
+      return _valueOf(leftOperand.value.lessThanOrEqual(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl lessThanValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.lessThan(typeProvider, value));
+      return _valueOf(leftOperand.value.lessThan(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl logicalAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl logicalAndValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.logicalAnd(typeProvider, value));
+      return _valueOf(leftOperand.value.logicalAnd(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl logicalOrValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.logicalOr(typeProvider, value));
+      return _valueOf(leftOperand.value.logicalOr(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl minusValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.minus(typeProvider, value));
+      return _valueOf(leftOperand.value.minus(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl notEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl notEqualValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.notEqual(typeProvider, value));
+      return _valueOf(leftOperand.value.notEqual(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl remainderValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.remainder(typeProvider, value));
+      return _valueOf(leftOperand.value.remainder(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl shiftLeftValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.shiftLeft(typeProvider, value));
+      return _valueOf(leftOperand.value.shiftLeft(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl shiftRightError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl shiftRightValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.shiftRight(typeProvider, value));
+      return _valueOf(leftOperand.value.shiftRight(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
 
   EvaluationResultImpl timesValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) {
     try {
-      return valueOf(leftOperand.value.times(typeProvider, value));
+      return _valueOf(leftOperand.value.times(typeProvider, value));
     } on EvaluationException catch (exception) {
-      return error(node, exception.errorCode);
+      return _error(node, exception.errorCode);
     }
   }
 
   /**
    * Return a result object representing 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
    * @return a result object representing an error associated with the given node
    */
-  ErrorResult error(AstNode node, ErrorCode code) => new ErrorResult.con1(node, code);
+  ErrorResult _error(AstNode node, ErrorCode code) => new ErrorResult.con1(node, code);
 
   /**
    * Return a result object representing the given value.
    *
    * @param value the value to be represented as a result object
    * @return a result object representing the given value
    */
-  ValidResult valueOf(DartObjectImpl value) => new ValidResult(value);
+  ValidResult _valueOf(DartObjectImpl value) => new ValidResult(value);
 }
 
 /**
  * Instances of the class `BoolState` represent the state of an object representing a boolean
  * value.
  */
 class BoolState extends InstanceState {
   /**
    * The value of this instance.
    */
@@ skipping 843 matching lines @@
  * object for which there is no type information.
  */
 class DynamicState extends InstanceState {
   /**
    * The unique instance of this class.
    */
   static DynamicState DYNAMIC_STATE = new DynamicState();
 
   NumState add(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
-    return unknownNum(rightOperand);
+    return _unknownNum(rightOperand);
   }
 
   IntState bitAnd(InstanceState rightOperand) {
     assertIntOrNull(rightOperand);
     return IntState.UNKNOWN_VALUE;
   }
 
   IntState bitNot() => IntState.UNKNOWN_VALUE;
 
   IntState bitOr(InstanceState rightOperand) {
@@ skipping 10 matching lines @@
     assertString(rightOperand);
     return StringState.UNKNOWN_VALUE;
   }
 
   BoolState convertToBool() => BoolState.UNKNOWN_VALUE;
 
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   NumState divide(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
-    return unknownNum(rightOperand);
+    return _unknownNum(rightOperand);
   }
 
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     return BoolState.UNKNOWN_VALUE;
   }
 
   String get typeName => "dynamic";
 
   BoolState greaterThan(InstanceState rightOperand) {
@@ skipping 32 matching lines @@
 
   BoolState logicalNot() => BoolState.UNKNOWN_VALUE;
 
   BoolState logicalOr(InstanceState rightOperand) {
     assertBool(rightOperand);
     return rightOperand.convertToBool();
   }
 
   NumState minus(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
-    return unknownNum(rightOperand);
+    return _unknownNum(rightOperand);
   }
 
   NumState negated() => NumState.UNKNOWN_VALUE;
 
   NumState remainder(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
-    return unknownNum(rightOperand);
+    return _unknownNum(rightOperand);
   }
 
   IntState shiftLeft(InstanceState rightOperand) {
     assertIntOrNull(rightOperand);
     return IntState.UNKNOWN_VALUE;
   }
 
   IntState shiftRight(InstanceState rightOperand) {
     assertIntOrNull(rightOperand);
     return IntState.UNKNOWN_VALUE;
   }
 
   NumState times(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
-    return unknownNum(rightOperand);
+    return _unknownNum(rightOperand);
   }
 
   /**
    * Return an object representing an unknown numeric value whose type is based on the type of the
    * right-hand operand.
    *
    * @param rightOperand the operand whose type will determine the type of the result
    * @return an object representing an unknown numeric value
    */
-  NumState unknownNum(InstanceState rightOperand) {
+  NumState _unknownNum(InstanceState rightOperand) {
     if (rightOperand is IntState) {
       return IntState.UNKNOWN_VALUE;
     } else if (rightOperand is DoubleState) {
       return DoubleState.UNKNOWN_VALUE;
     }
     return NumState.UNKNOWN_VALUE;
   }
 }
 
 /**
@@ skipping 1410 matching lines @@
     }
     return BoolState.FALSE_STATE;
   }
 
   String get typeName => "Type";
 
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   String toString() => _element == null ? "-unknown-" : _element.name;
 }