Hi,

I have been hit by a changed behaviour of mappings in chained in-place transformations from QVTO 3.2.2 to 3.3.0.

...

In QVTO 3.2.2 (Juno) this also works fine, the result is an EAnnotation with the single detail with value "test2". In QVTO 3.3.0 (in Kepler) and 3.4.0 (in Luna) the same transformation results in an EAnnotation with two details with values "test1" and "test2". It seems that the "test1" detail which has been added by the first transformation could not be removed by the second transformation.

When I replace the mapping "removeAnno" by a handler "hremoveAnno" with the same body it works fine also in 3.3.0 and 3.4.0.

My questions are:
- is this a desired behaviour which has been corrected from 3.2.2 to 3.3.0 or is it a bug?
- I found other cases where a similar problem occurs for nested mappings which add model objects. Again the problem disappears when using helpers instead. However, the QVT 1.1 specification says in 8.2.1.12: "However it is illegal to create or update object instances within a helper operation except for pre-defined types like sets, tuples, and for intermediate properties." I create EStringToStringMapEntry objects, so this should not work at all!?
- what are the exact differences between mappings and helpers and when should I use which one?
- In the specification I found the concept of intermediate data in QVTO, but that seems not to be supported in the implementation (at least not in 3.2.2). Are there other means to remove in a single transformation data which has been created in the same transformation?

helper ENamedElement :: setAnno(aname: String, k : String, v: String) {
	self.removeAnno(aname, k);
	self.eAnnotations->select(source = aname)->first().details += object EStringToStringMapEntry { key := k; value := v; };
	return
}

helper ENamedElement :: removeAnno(aname: String, k : String) {
	self.eAnnotations->select(source = aname)->forEach(a) {
		a.details := a.details->select(key != k);
	}
}

helper ENamedElement :: removeAnno(aname: String, k : String) {
	self.eAnnotations->select(source = aname)->forEach(a) {
		a.details := Set{}
	}
}

About mappings and helpers.

Execution semantics of mappings is described in QVTO specification in section "8.2.1.15 MappingOperation" part "Execution Semantics". In short during invocation of mapping operation the trace pool is checked and mapping is not executed in case it's invoked on the same object with the same parameters. So in your case the invocation of 'removeAnno()' mapping which is initiated in Test2Trans was skipped.

Helpers are different in that they don't use traces. Also QVTo relaxes restriction on helpers so it's possible to create and update any objects by means of them.

Btw, I didn't quite understand logic in 'removeAnno()'. To me it should looks like:

helper ENamedElement :: removeAnno(aname: String, k : String) {
	self.eAnnotations->select(source = aname)->forEach(a) {
		a.details := Set{}
	}
}

Is this the only reason which can cause object removals to be ignored? What happens if a created object in a mapping which has been added to the trace is removed afterwards? Is that possible? What is the correct way to remove objects? I found the unlink expression in the QVT 1.1 spec in section 8.2.2.12 but it seems not to be implemented in QVTo (?)

QVTo provides a notion of model extent. Without going into details the model extent can be thought as EMF Resource associated with each of model parameter (which are transformation parameters).
Removing of element means moving it out of model extent. This is done with 'Model::removeElement(Element)' call. Removing of object does not lead to destroying it (object itself still exists and valid). Thus trace record is still valid even for removed objects.

Unlink expression is used to remove a value from a multivalued property. It can be a collection of datatypes like p1:String[*] or collection of object instances like p2:Class[*].
You're right that this is not implemented. However it's easily realized by assigning the feature new collection which is obtained from an original one by filtering unneeded elements.