anchor.diff:      if (node.target.kind != ProcedureKind.Factory) {
         node.arguments.types.clear();
       }
  +    if (node.isConst) pushConstantContext();
       node.transformChildren(this);
  +    if (node.isConst) popConstantContext();
       return node;
     }
   
  
positive.code:     node.transformChildren(this);
      return node;
    }
  }
  
negative.code: import '../ast.dart';
  import '../type_algebra.dart';
  
  /// This pass is a temporary measure to run strong mode code in the VM, which
  /// does not yet have the necessary runtime support.
  ///
  /// Function type parameter lists are cleared and all uses of a function type
  /// parameter are replaced by its upper bound.
  ///
  /// All uses of type parameters in constants are replaced by 'dynamic'.
  ///
  /// This does not preserve dynamic type safety.
  class Erasure extends Transformer {
    final Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
    final Map<TypeParameter, DartType> constantSubstitution =
        <TypeParameter, DartType>{};
  
    int constantContexts = 0;
  
    void transform(Program program) {
      program.accept(this);
    }
  
    void pushConstantContext() {
      ++constantContexts;
    }
  
    void popConstantContext() {
      --constantContexts;
    }
  
    bool get isInConstantContext => constantContexts > 0;
  
    @override
    visitDartType(DartType type) {
      type = substitute(type, substitution);
      if (isInConstantContext) {
        type = substitute(type, constantSubstitution);
      }
      return type;
    }
  
    @override
    visitClass(Class node) {
      for (var parameter in node.typeParameters) {
        constantSubstitution[parameter] = const DynamicType();
      }
      node.transformChildren(this);
      constantSubstitution.clear();
      return node;
    }
  
    @override
    visitProcedure(Procedure node) {
  