New analyzer 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 'dart:collection';
@@ skipping 269 matching lines @@
 /**
  * Instances of the class `ConstantValueComputer` compute the values of constant variables and
  * constant constructor invocations in one or more compilation units. The expected usage pattern is
  * for the compilation units to be added to this computer using the method
  * [add] and then for the method [computeValues] to be invoked
  * exactly once. Any use of an instance after invoking the method [computeValues] will
  * result in unpredictable behavior.
  */
 class ConstantValueComputer {
   /**
+   * Parameter to "fromEnvironment" methods that denotes the default value.
+   */
+  static String _DEFAULT_VALUE_PARAM = "defaultValue";
+
+  /**
    * The type provider used to access the known types.
    */
   TypeProvider typeProvider;
 
   /**
    * The object used to find constant variables and constant constructor invocations in the
    * compilation units that were added.
    */
   ConstantFinder _constantFinder = new ConstantFinder();
 
@@ skipping 12 matching lines @@
    * A table mapping constant constructors to the declarations of those constructors.
    */
   HashMap<ConstructorElement, ConstructorDeclaration> constructorDeclarationMap;
 
   /**
    * A collection of constant constructor invocations.
    */
   List<InstanceCreationExpression> _constructorInvocations;
 
   /**
+   * The set of variables declared on the command line using '-D'.
+   */
+  final DeclaredVariables _declaredVariables;
+
+  /**
    * Initialize a newly created constant value computer.
    *
    * @param typeProvider the type provider used to access known types
+   * @param declaredVariables the set of variables declared on the command line using '-D'
    */
-  ConstantValueComputer(TypeProvider typeProvider) {
+  ConstantValueComputer(TypeProvider typeProvider, this._declaredVariables) {
     this.typeProvider = typeProvider;
   }
 
   /**
    * Add the constants in the given compilation unit to the list of constants whose value needs to
    * be computed.
    *
    * @param unit the compilation unit defining the constants to be added
    */
   void add(CompilationUnit unit) {
@@ skipping 101 matching lines @@
 
   /**
    * Create the ConstantVisitor used to evaluate constants. Unit tests will override this method to
    * introduce additional error checking.
    */
   ConstantVisitor createConstantVisitor() => new ConstantVisitor.con1(typeProvider);
 
   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) {
+    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;
+    }
+    if (argumentCount == 2) {
+      if (arguments[1] is! NamedExpression) {
+        return false;
+      }
+      if (!((arguments[1] as NamedExpression).name.label.name == _DEFAULT_VALUE_PARAM)) {
+        return false;
+      }
+      InterfaceType defaultValueType = namedArgumentValues[_DEFAULT_VALUE_PARAM].type;
+      if (!(identical(defaultValueType, expectedDefaultValueType) || identical(defaultValueType, typeProvider.nullType))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
    * Compute a value for the given constant.
    *
    * @param constNode the constant for which a value is to be computed
    */
   void _computeValueFor(AstNode constNode) {
     beforeComputeValue(constNode);
     if (constNode is VariableDeclaration) {
       VariableDeclaration declaration = constNode;
       Element element = declaration.element;
       EvaluationResultImpl result = declaration.initializer.accept(createConstantVisitor());
       (element as VariableElementImpl).evaluationResult = result;
     } 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.
         return;
       }
       ConstantVisitor constantVisitor = createConstantVisitor();
-      ValidResult result = _evaluateConstructorCall(expression.argumentList.arguments, constructor, constantVisitor);
+      EvaluationResultImpl result = _evaluateConstructorCall(constNode, expression.argumentList.arguments, constructor, constantVisitor);
       expression.evaluationResult = result;
     } 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);
     } else if (constNode is FormalParameter) {
       if (constNode is DefaultFormalParameter) {
         DefaultFormalParameter parameter = constNode;
         ParameterElement element = parameter.element;
         Expression defaultValue = parameter.defaultValue;
         if (defaultValue != null) {
           EvaluationResultImpl result = defaultValue.accept(createConstantVisitor());
           (element as ParameterElementImpl).evaluationResult = result;
         }
       }
     } 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;
     }
   }
 
-  ValidResult _evaluateConstructorCall(NodeList<Expression> arguments, ConstructorElement constructor, ConstantVisitor constantVisitor) {
+  /**
+   * 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 [ValidResult] object corresponding to the evaluated result
+   */
+  ValidResult _computeValueFromEnvironment(DartObject environmentValue, 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 corresponding value.  So use the built-in default value, because
+        // this is what the VM does.
+        value = builtInDefaultValue;
+      } else {
+      }
+    }
+    return new ValidResult(value);
+  }
+
+  EvaluationResultImpl _evaluateConstructorCall(AstNode node, NodeList<Expression> arguments, ConstructorElement constructor, ConstantVisitor constantVisitor) {
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues = new List<DartObjectImpl>(argumentCount);
     HashMap<String, DartObjectImpl> namedArgumentValues = new HashMap<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] = constantVisitor._valueOf(namedExpression.expression);
         argumentValues[i] = constantVisitor.null2;
       } else {
         argumentValues[i] = constantVisitor._valueOf(argument);
       }
     }
     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.
-      // TODO(paulberry): if the constructor is one of {bool,int,String}.fromEnvironment(),
-      // we may be able to infer the value based on -D flags provided to the analyzer (see
-      // dartbug.com/17234).
-      if (identical(definingClass, typeProvider.symbolType) && argumentCount == 1) {
+      if (constructor.name == "fromEnvironment") {
+        if (!_checkFromEnvironmentArguments(arguments, argumentValues, namedArgumentValues, definingClass)) {
+          return new ErrorResult.con1(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
+        }
+        String variableName = argumentCount < 1 ? null : argumentValues[0].stringValue;
+        if (identical(definingClass, typeProvider.boolType)) {
+          DartObject valueFromEnvironment;
+          valueFromEnvironment = _declaredVariables.getBool(typeProvider, variableName);
+          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, new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE), namedArgumentValues);
+        } else if (identical(definingClass, typeProvider.stringType)) {
+          DartObject valueFromEnvironment;
+          valueFromEnvironment = _declaredVariables.getString(typeProvider, variableName);
+          return _computeValueFromEnvironment(valueFromEnvironment, new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE), namedArgumentValues);
+        }
+      } else if (constructor.name == "" && identical(definingClass, typeProvider.symbolType) && argumentCount == 1) {
         String argumentValue = argumentValues[0].stringValue;
         if (argumentValue != null) {
           return constantVisitor._valid(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.
@@ skipping 72 matching lines @@
       }
     }
     // 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(fieldMap, superConstructor, superArguments, initializerVisitor);
+        _evaluateSuperConstructorCall(node, fieldMap, superConstructor, superArguments, initializerVisitor);
       }
     }
     return constantVisitor._valid(definingClass, new GenericState(fieldMap));
   }
 
-  void _evaluateSuperConstructorCall(HashMap<String, DartObjectImpl> fieldMap, ConstructorElement superConstructor, NodeList<Expression> superArguments, ConstantVisitor initializerVisitor) {
+  void _evaluateSuperConstructorCall(AstNode node, HashMap<String, DartObjectImpl> fieldMap, ConstructorElement superConstructor, NodeList<Expression> superArguments, ConstantVisitor initializerVisitor) {
     if (superConstructor != null && superConstructor.isConst) {
-      ValidResult evaluationResult = _evaluateConstructorCall(superArguments, superConstructor, initializerVisitor);
-      fieldMap[GenericState.SUPERCLASS_FIELD] = evaluationResult.value;
+      EvaluationResultImpl evaluationResult = _evaluateConstructorCall(node, superArguments, superConstructor, initializerVisitor);
+      if (evaluationResult is ValidResult) {
+        ValidResult validResult = evaluationResult;
+        fieldMap[GenericState.SUPERCLASS_FIELD] = validResult.value;
+      }
     }
   }
 
   /**
    * 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
@@ skipping 1108 matching lines @@
    * Define a variable with the given name to have the given value.
    *
    * @param variableName the name of the variable being defined
    * @param value the value of the variable
    */
   void define(String variableName, String value) {
     _declaredVariables[variableName] = value;
   }
 
   /**
-   * Return the value of the variable with the given name interpreted as a boolean value, or
-   * `null` if the variable is not defined.
+   * Return the value of the variable with the given name interpreted as a boolean value. If the
+   * variable is not defined (or [variableName] is null), a DartObject representing "unknown"
+   * is returned. If the value can't be parsed as a boolean, a DartObject representing null is
+   * returned.
    *
    * @param typeProvider the type provider used to find the type 'bool'
    * @param variableName the name of the variable whose value is to be returned
    */
   DartObject getBool(TypeProvider typeProvider, String variableName) {
     String value = _declaredVariables[variableName];
     if (value == null) {
-      return null;
+      return new DartObjectImpl(typeProvider.boolType, BoolState.UNKNOWN_VALUE);
     }
     if (value == "true") {
-      return new DartObjectImpl(typeProvider.boolType, BoolState.from(true));
+      return new DartObjectImpl(typeProvider.boolType, BoolState.TRUE_STATE);
     } else if (value == "false") {
-      return new DartObjectImpl(typeProvider.boolType, BoolState.from(false));
+      return new DartObjectImpl(typeProvider.boolType, BoolState.FALSE_STATE);
     }
-    return null;
+    return new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE);
   }
 
   /**
-   * Return the value of the variable with the given name interpreted as an integer value, or
-   * `null` if the variable is not defined.
+   * Return the value of the variable with the given name interpreted as an integer value. If the
+   * variable is not defined (or [variableName] is null), a DartObject representing "unknown"
+   * is returned. If the value can't be parsed as an integer, a DartObject representing null is
+   * returned.
    *
    * @param typeProvider the type provider used to find the type 'int'
    * @param variableName the name of the variable whose value is to be returned
-   * @throws NumberFormatException if the value of the variable is not a valid integer value
    */
   DartObject getInt(TypeProvider typeProvider, String variableName) {
     String value = _declaredVariables[variableName];
     if (value == null) {
-      return null;
+      return new DartObjectImpl(typeProvider.intType, IntState.UNKNOWN_VALUE);
     }
-    return new DartObjectImpl(typeProvider.intType, new IntState(int.parse(value)));
+    int bigInteger;
+    try {
+      bigInteger = int.parse(value);
+    } on FormatException catch (exception) {
+      return new DartObjectImpl(typeProvider.nullType, NullState.NULL_STATE);
+    }
+    return new DartObjectImpl(typeProvider.intType, new IntState(bigInteger));
   }
 
   /**
    * Return the value of the variable with the given name interpreted as a String value, or
-   * `null` if the variable is not defined.
+   * `null` if the variable is not defined. Return the value of the variable with the given
+   * 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 null;
+      return new DartObjectImpl(typeProvider.intType, IntState.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 177 matching lines @@
     } else if (rightOperand is DynamicState || rightOperand is NumState) {
       return IntState.UNKNOWN_VALUE;
     }
     throw new EvaluationException(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
   }
 
   @override
   bool get isBoolNumStringOrNull => true;
 
   @override
+  bool get isUnknown => value == null;
+
+  @override
   BoolState lessThan(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is IntState) {
       int rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
@@ skipping 1559 matching lines @@
     } else if (rightOperand is DynamicState || rightOperand is NumState) {
       return UNKNOWN_VALUE;
     }
     throw new EvaluationException(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
   }
 
   @override
   bool get isBoolNumStringOrNull => true;
 
   @override
+  bool get isUnknown => value == null;
+
+  @override
   BoolState lessThan(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is IntState) {
       int rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
@@ skipping 1228 matching lines @@
   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);
 }