anchor.diff:    }
     
     void _subsetConstraint(TypeIdentifier a, TypeIdentifier b) {
  +
  +   
  +      if (a.toString() == '#_DoubleLinkedQueueEntrySentinel._next' &&
  +          b.toString() == '#{entry._next}') {
  +       print('foo'); 
  +       debugStop = true;
  +      }
  +      
       if (a != b)
         foreach(a).update((AbstractType type) => types.put(b, type));
  +    
  +    
  +    if (a.toString() == '#_DoubleLinkedQueueEntrySentinel._next' &&
  +        b.toString() == '#{entry._next}') {
  +      debugStop = false;
  +    }
  +
     }
     
     AbstractType _getAbstractType(Name className, LibraryElement library, SourceElement source){
  
positive.code:   
    void add(AbstractType t) {
      //TODO (jln) If the type added is a free-type check if there already exists a free type and merge them.
      if (_types.add(t)) {
        _changed = true;
        trigger(t);
        _changed = false;
      }
    }
    
    List<AbstractType> get types => new List.from(_types); 
  
negative.code:     _filters[func] = filter;
      
      bool reset;
      
      do {
        List current_types = types;
        reset = false;
              
        for(AbstractType type in current_types){
          
          if (filter == null || filter(type))
            func(type);
    
          if (_types.length != current_types.length){
            //Changes has been made, so make another notify loop.
            reset = true;
            break;
          }
        }
      } while(reset);
      return (() => this.remove(func));
    }
  