anchor.diff:      if (type == this) 
         return this;
       else if (type is ObjectType){
  -      type.properties.forEach((Name ident, AbstractType type) {
  +      type.properties.forEach((Name ident, NonStructuralType type) {
           if (properties.containsKey(ident))
             properties[ident] = properties[ident].union(type);
           else
  
positive.code: class MethodConstraint extends Constraint {
    Name method;
    AbstractType object;
    List<AbstractType> normalParameterTypes;
    List<AbstractType> optionalParameterTypes;
    Map<Name, AbstractType> namedParameterTypes;
    AbstractType returnType;
    
    MethodConstraint(AbstractType this.object, this.method, List<SimpleType> this.normalParameterTypes, this.returnType, [List<SimpleType> optionalParameterTypes = null, Map<Name, SimpleType> namedParameterTypes = null ] ) :
      this.optionalParameterTypes = (optionalParameterTypes == null ? <AbstractType>[] : optionalParameterTypes),
      this.namedParameterTypes = (namedParameterTypes == null ? <Name, AbstractType>{} : namedParameterTypes);
    
    String toString() => "${object} contains method: '${method}', with return '${returnType}', normalParameters: ${normalParameterTypes}, optionalParameters: ${optionalParameterTypes}, namedParameters: ${namedParameterTypes}.";
    
  
negative.code:     });
    }
    
    void addProperty(TypeVariable key, Name property, NonStructuralType type) {
      if (!substitutions.containsKey(key))
        substitutions[key] = new ObjectType(key);
      substitutions[key] = substitutions[key].addProperty(property, type);
    }
    
    String toString(){
      StringBuffer sb = new StringBuffer();
      substitutions.forEach((TypeVariable key, ObjectType type) => sb.writeln("${key}: $type"));
      return sb.toString();  
    }
  }
  