anchor.diff:    }
   
     visitConditionalExpression(ConditionalExpression node) {
  -    final Constant constant = _evaluateSubexpression(node.condition);
  -    if (constant == trueConstant) {
  +    final Constant condition = _evaluateSubexpression(node.condition);
  +    if (condition == trueConstant) {
         return _evaluateSubexpression(node.then);
  -    } else if (constant == falseConstant) {
  +    } else if (condition == falseConstant) {
         return _evaluateSubexpression(node.otherwise);
  +    } else if (condition is UnevaluatedConstant) {
  +      return unevaluated(
  +          node,
  +          new ConditionalExpression(unique(condition.expression), node.then,
  +              node.otherwise, node.staticType));
       } else {
         throw new _AbortCurrentEvaluation(errorReporter.invalidDartType(
  -          contextChain, node, constant, typeEnvironment.boolType));
  +          contextChain, node, condition, typeEnvironment.boolType));
       }
     }
   
  
positive.code:           return receiver.fieldValues[fieldRef];
          }
        }
      }
      throw 'Could not evaluate property get on $receiver.';
    }
  
negative.code:       }
        entries[i] = new ConstantMapEntry(key, value);
      }
      if (hasUnevaluatedChild(node)) {
        final mapEntries = new List<MapEntry>(node.entries.length);
        for (int i = 0; i < node.entries.length; ++i) {
          mapEntries[i] = new MapEntry(unique(entries[i].key.asExpression()),
              unique(entries[i].value.asExpression()));
        }
        return unevaluated(
            node,
            new MapLiteral(mapEntries,
                keyType: node.keyType, valueType: node.valueType, isConst: true));
      }
      final DartType keyType = evaluateDartType(node, node.keyType);
      final DartType valueType = evaluateDartType(node, node.valueType);
      return canonicalize(new MapConstant(keyType, valueType, entries));
  