anchor.diff:  
       if (node.initializer != null) {
         if (node.isConst) {
  -        final Constant constant =
  -            tryEvaluateWithContext(node, node.initializer);
  -
  -        // If there was a constant evaluation error we will not continue and
  -        // simply keep the old [node].
  -        if (constant != null) {
  -          constantEvaluator.env.addVariableValue(node, constant);
  -
  -          if (keepVariables) {
  -            // So the value of the variable is still available for debugging
  -            // purposes we convert the constant variable to be a final variable
  -            // initialized to the evaluated constant expression.
  -            node.initializer = makeConstantExpression(constant)..parent = node;
  -            node.isFinal = true;
  -            node.isConst = false;
  -          } else {
  -            // Since we convert all use-sites of constants, the constant
  -            // [VariableDeclaration] is unused and we'll therefore remove it.
  -            return null;
  -          }
  +        final Constant constant = evaluateWithContext(node, node.initializer);
  +        constantEvaluator.env.addVariableValue(node, constant);
  +
  +        if (keepVariables) {
  +          // So the value of the variable is still available for debugging
  +          // purposes we convert the constant variable to be a final variable
  +          // initialized to the evaluated constant expression.
  +          node.initializer = makeConstantExpression(constant)..parent = node;
  +          node.isFinal = true;
  +          node.isConst = false;
  +        } else {
  +          // Since we convert all use-sites of constants, the constant
  +          // [VariableDeclaration] is unused and we'll therefore remove it.
  +          return null;
           }
         } else {
           node.initializer = node.initializer.accept(this)..parent = node;
  
positive.code:   void transformExpressions(List<Expression> nodes, TreeNode parent) {
      constantEvaluator.withNewEnvironment(() {
        for (int i = 0; i < nodes.length; ++i) {
          nodes[i] = tryEvaluateAndTransformWithContext(parent, nodes[i])
            ..parent = parent;
        }
      });
  
negative.code:     Constant constant = node.constant;
      if (constant is UnevaluatedConstant) {
        Expression expression = constant.expression;
        return evaluateAndTransformWithContext(expression, expression);
      } else {
        node.constant = constantEvaluator.canonicalize(constant);
        return node;
      }
    }
  
    evaluateAndTransformWithContext(TreeNode treeContext, Expression node) {
      return makeConstantExpression(evaluateWithContext(treeContext, node));
    }
  
    evaluateWithContext(TreeNode treeContext, Expression node) {
      if (treeContext == node) {
        return constantEvaluator.evaluate(node);
      }
  