anchor.diff:  
     InstanceBuilder instanceBuilder;
     EvaluationEnvironment env;
  +  Expression evaluationRoot;
  +  Set<TreeNode> unevaluatedNodes;
  +  Set<Expression> replacementNodes;
   
     ConstantEvaluator(this.backend, this.environmentDefines, this.typeEnvironment,
         this.enableAsserts, this.errorReporter)
  
positive.code:         if (target.isConst) {
            if (target.isInExternalLibrary && target.initializer == null) {
              // The variable is unavailable due to separate compilation.
              return unevaluated(node);
            }
            return runInsideContext(target, () {
              return _evaluateSubexpression(target.initializer);
  
negative.code:   }
  
    visitStringConcatenation(StringConcatenation node) {
      final List<Object> concatenated = <Object>[new StringBuffer()];
      for (int i = 0; i < node.expressions.length; i++) {
        Constant constant = _evaluateSubexpression(node.expressions[i]);
        if (constant is PrimitiveConstant) {
          String value = constant.value.toString();
          Object last = concatenated.last;
          if (last is StringBuffer) {
            last.write(value);
          } else {
            concatenated.add(new StringBuffer(value));
          }
        } else if (constant is UnevaluatedConstant) {
          concatenated.add(constant);
        } else {
          throw new _AbortCurrentEvaluation(errorReporter
              .invalidStringInterpolationOperand(contextChain, node, constant));
        }
      }
      if (concatenated.length > 1) {
        final expressions = new List<Expression>(concatenated.length);
        for (int i = 0; i < concatenated.length; i++) {
          Object value = concatenated[i];
          if (value is UnevaluatedConstant) {
            expressions[i] = unique(value.expression);
          } else {
            expressions[i] = new ConstantExpression(
                canonicalize(new StringConstant(value.toString())));
          }
        }
        return unevaluated(node, new StringConcatenation(expressions));
      }
      return canonicalize(new StringConstant(concatenated.single.toString()));
    }
  
    visitStaticInvocation(StaticInvocation node) {
  