New analzyer snapshot.

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 352 matching lines @@
       // it, but we don't bother to check because there's nothing we can do about it at this point.
       //
       return;
     }
     EvaluationResultImpl result = declaration.initializer.accept(new ConstantVisitor(_typeProvider));
     (variable as VariableElementImpl).evaluationResult = result;
     if (result is ErrorResult) {
       List<AnalysisError> errors = new List<AnalysisError>();
       for (ErrorResult_ErrorData data in result.errorData) {
         AstNode node = data.node;
-        Source source = variable.getAncestor(CompilationUnitElement).source;
+        Source source = variable.getAncestor((element) => element is CompilationUnitElement).source;
         errors.add(new AnalysisError.con2(source, node.offset, node.length, data.errorCode, []));
       }
     }
   }
 
   /**
    * 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.
    *
@@ skipping 130 matching lines @@
       } 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);
       }
       break;
     }
   }
 
-  EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => valid2(_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);
     } 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);
     } 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 valid(thenType.getLeastUpperBound(elseType) as InterfaceType);
+    return validWithUnknownValue(thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
-  EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => valid2(_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);
     }
     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);
           argumentValues[i] = null2;
         } else {
           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 valid2(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 valid2(definingClass, new GenericState(fieldMap));
+      return valid(definingClass, new GenericState(fieldMap));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
-  EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => valid2(_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 result.performToString(_typeProvider, node);
   }
 
-  EvaluationResultImpl visitInterpolationString(InterpolationString node) => valid2(_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);
       if (elementResult is ValidResult) {
         elements.add(elementResult.value);
       }
     }
     if (result != null) {
       return result;
     }
-    return valid2(_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);
       if (keyResult is ValidResult && valueResult is ValidResult) {
         map[keyResult.value] = valueResult.value;
       }
     }
     if (result != null) {
       return result;
     }
-    return valid2(_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;
@@ skipping 51 matching lines @@
         return error(node, null);
       }
       break;
     }
   }
 
   EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => getConstantValue(node, node.propertyName.staticElement);
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(node, node.staticElement);
 
-  EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => valid2(_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 valid2(_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);
@@ skipping 11 matching lines @@
     }
     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 valid2(_typeProvider.functionType, new FunctionState(function));
+        return valid(_typeProvider.functionType, new FunctionState(function));
       }
     } else if (element is ClassElement || element is FunctionTypeAliasElement) {
-      return valid2(_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 an object representing the value 'null'.
    *
    * @return an object representing the value 'null'
    */
@@ skipping 17 matching lines @@
     if (rightResult is ErrorResult) {
       if (leftResult != null) {
         return new ErrorResult.con2(leftResult, rightResult);
       } else {
         return rightResult;
       }
     }
     return leftResult;
   }
 
-  ValidResult valid(InterfaceType type) {
+  ValidResult valid(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
+
+  ValidResult validWithUnknownValue(InterfaceType type) {
     if (type.element.library.isDartCore) {
       String typeName = type.name;
       if (typeName == "bool") {
-        return valid2(type, BoolState.UNKNOWN_VALUE);
+        return valid(type, BoolState.UNKNOWN_VALUE);
       } else if (typeName == "double") {
-        return valid2(type, DoubleState.UNKNOWN_VALUE);
+        return valid(type, DoubleState.UNKNOWN_VALUE);
       } else if (typeName == "int") {
-        return valid2(type, IntState.UNKNOWN_VALUE);
+        return valid(type, IntState.UNKNOWN_VALUE);
       } else if (typeName == "String") {
-        return valid2(type, StringState.UNKNOWN_VALUE);
+        return valid(type, StringState.UNKNOWN_VALUE);
       }
     }
-    return valid2(type, GenericState.UNKNOWN_VALUE);
+    return valid(type, GenericState.UNKNOWN_VALUE);
   }
 
-  ValidResult valid2(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
-
   /**
    * 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) {
     EvaluationResultImpl expressionValue = expression.accept(this);
     if (expressionValue is ValidResult) {
@@ skipping 3324 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;
 }