org.eclipse.m2m.atl.emftvm.util.VMException: java.lang.IllegalArgumentException: Cannot read properties of org.dews_online.ccui.core.view.viewparts.PhenomenonTreeView.viewerContribution:profile!Class, as it is contained in an output model

helper def: xmlElements: Sequence(XML!Element) = XML!Element.allInstancesFrom('Plugin');

rule Model {
	from
		s: UML2!Model in IN (
			not s.oclIsUndefined() and not (s.name = 'root model') and not (s.name =
					'externals') and not (s.name = 'source references')
		)
	to
[...],
vac: UML2!Package (
			name <- 'viewActions',
			packagedElement <- thisModule.xmlElements -> select(e | e.name =
					'viewContribution') -> collect(e | [color=red]thisModule.ActionSetClass(e)[/color])
		)
}

lazy rule ActionSetClass {
	from
		s: XML!Element
	to
		r: UML2!Class (
			name <- s.children -> select(e | e.oclIsTypeOf(XML!Attribute) and not e.
					oclIsUndefined() and e.name = 'id').first().value 
		) 
		--- The stereotype can't be applied since the element is generated outside
		--- the model.
	
	do {
		thisModule.wbactions <-thisModule.wbactions.union([color=red]r.setGroup()[/color]);
	}
}

helper context UML2!Class def: setGroup(): Sequence(UML2!Class) =
	if (thisModule.classes -> select(e | e.value.toUpper().
			endsWith(self.name.toUpper() )).
			notEmpty()) then
		if (thisModule.classes -> select(e | e.value.toUpper().endsWith(self.name.
				toUpper())).first().parent.name = 'actionSet')
				then
			Sequence{self}
		else
			Sequence{}
		endif
	else
		Sequence{}
	endif;

lazy rule ActionSetClass {
	from
		s: XML!Element
	using {
		nameValue : String = s.children -> any(e | e.oclIsTypeOf(XML!Attribute) and
				e.name = 'id').value;
	}
	to
		r: UML2!Class (
			name <- nameValue 
		) 
		--- The stereotype can't be applied since the element is generated outside
		--- the model.
	
	do {
		thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue));
	}
}

helper context UML2!Class def: setGroup(name : String): Sequence(UML2!Class) =
	let nameUpper : String = name.toUpper() in
	if (thisModule.classes -> select(e | e.value.toUpper().
			endsWith(nameUpper)).notEmpty()) then
		if (thisModule.classes -> select(e | e.value.toUpper().endsWith(nameUpper))
				.first().parent.name = 'actionSet') then
			Sequence{self}
		else
			Sequence{}
		endif
	else
		Sequence{}
	endif;

lazy rule ActionSetClass {
	from
		s: XML!Element (s.name =
					'viewContribution')
	using {
		nameValue : String = s.children -> any(e | e.oclIsTypeOf(XML!Attribute) and
				e.name = 'id').value;
	}
	to
		r: UML2!Class (
			name <- nameValue ->debug('name')
		) 
		--- The stereotype can't be applied since the element is generated outside
		--- the model.
	
	do {
		r->debug('class');
		thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue))->debug('wbactions');
	}
}

thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue))->debug('wbactions');

	do {
		thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue))->debug('wbactions');
		r->debug('class');
	}

rule Model {
	from
		s: UML2!Model in IN (
			not s.oclIsUndefined() and not (s.name = 'root model') and not (s.name =
					'externals') and not (s.name = 'source references')
		)
	to
		t: UML2!Model (
			[...]
		),
		[...]
		),
		[...]	

		),
		wac: UML2!Package (
			name <- 'workbenchActions'
			,
--			packagedElement <- thisModule.xmlElements -> select(e | e.name = 'actionSet')->debug('ActionSets!')
--					-> collect(e | thisModule.WorkbenchActions(e))
			packagedElement<- Sequence{thisModule.resolveTemp(XML!Element.allInstances()->select(e|e.name='actionSet').first(), 'wAction')}
		),
		[...]
		)

thisModule.resolveTemp(thisModule.mainModel,'wac')

rule Model {
	from
		s: UML2!Model in IN (
			not s.oclIsUndefined() and not (s.name = 'root model') and not (s.name =
					'externals') and not (s.name = 'source references')
		)
	to
		t: UML2!Model (
			name <- s.name ,
			visibility <- s.visibility,
			viewpoint <- s.viewpoint,
			eAnnotations <- s.eAnnotations,
			ownedComment <- s.ownedComment,
			clientDependency <- s.clientDependency,
			nameExpression <- s.nameExpression,
			elementImport <- s.elementImport,
			packageImport <- s.packageImport,
			ownedRule <- s.ownedRule,
			templateParameter <- s.templateParameter,
			templateBinding <- s.templateBinding,
			ownedTemplateSignature <- s.ownedTemplateSignature,
			packageMerge <- s.packageMerge,
			packagedElement <- s.packagedElement.union(Sequence {pck})
		),
		[...]
		),
		tool: UML2!Package (
			name <- 'Toolbars'
			,
			packagedElement <- thisModule.toolbarsHelper->select(e|e.isClass() and not e.isInterface()) ->collect(e|thisModule.lazyToolbarClass(e)).union(
				thisModule.toolbarsHelper->select(e|not e.isClass() and not e.isInterface()) ->collect(e|thisModule.lazyToolbarClass(e))).union(
			thisModule.toolbarsHelper->select(e|e.isInterface()) ->collect(e|thisModule.lazyToolbarInterface(e)))
		)

	do {
		thisModule.mainModel<-s;
		--- We apply the profile and the Workbench stereotype.
		t.applyProfile(profile!Profile.allInstances().asSequence().first())->debug('profile'); 
		t.applyStereotype(profile!Stereotype.allInstances().asSequence() -> select(i | i.
				qualifiedName = 'RCP::Workbench').last()); 
		[...]
		}

lazy rule lazyToolbarClass {
	from
		s: XML!Element in Plugin
		using {
		nameValue : String = s.getElementName();
	}
	to
		r: UML2!Class (
			name <- nameValue
		) 
	do {
		
		thisModule.transformedToolbars <-thisModule.transformedToolbars.union(Sequence{r});
		thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue));
		r;
	}
}
lazy rule lazyToolbarInterface {
	from
		s: XML!Element in Plugin
	to
		r: UML2!Interface (
			name <- s.getElementName()
		) 
		--- The stereotype can't be applied since the element is generated outside
		--- the model.
	
	do {
		
		thisModule.transformedToolbars <-thisModule.transformedToolbars.union(Sequence{r});
		r;
	}
}

r.applyStereotype(profile!Stereotype.allInstances().asSequence() -> select(i | i.
				qualifiedName = 'RCP::Toolbar').last()); 

helper def toolbarStereotype : profile!Stereotype =
	profile!Stereotype.allInstances().asSequence() -> select(i | i.
				qualifiedName = 'RCP::Toolbar').last();

rule Model {
	from
		s: UML2!Model in IN (
			not s.oclIsUndefined() and not (s.name = 'root model') and not (s.name =
					'externals') and not (s.name = 'source references')
		)
	to
		t: UML2!Model (
		[...]
		),
		tool: UML2!Package (
			name <- 'Toolbars'
			,
			packagedElement <- thisModule.toolbarsHelper->select(e|e.isClass() and not e.isInterface()) ->union(
				thisModule.toolbarsHelper->select(e|not e.isClass() and not e.isInterface()) ->union(
			thisModule.toolbarsHelper->select(e|e.isInterface()))
		)

	do {
		thisModule.mainModel<-s;
		--- We apply the profile and the Workbench stereotype.
		t.applyProfile(profile!Profile.allInstances().asSequence().first())->debug('profile'); 
		t.applyStereotype(profile!Stereotype.allInstances().asSequence() -> select(i | i.
				qualifiedName = 'RCP::Workbench').last()); 
		[...]
		}

rule ToolbarClass {
	from
		s: XML!Element in Plugin (thisModule.toolbarsHelper->includes(s) and not s.isInterface())
		using {
		nameValue : String = s.getElementName();
	}
	to
		r: UML2!Class (
			name <- nameValue
		) 
	do {
		thisModule.transformedToolbars <-thisModule.transformedToolbars.union(Sequence{r});
		thisModule.wbactions <-thisModule.wbactions.union(r.setGroup(nameValue));
		r.applyStereotype(thisModule.toolbarStereotype);
	}
}

rule ToolbarInterface {
	from
		s: XML!Element in Plugin (thisModule.toolbarsHelper->includes(s) and s.isInterface())
	to
		r: UML2!Interface (
			name <- s.getElementName()
		) 
		--- The stereotype can't be applied since the element is generated outside
		--- the model.
	
	do {
		thisModule.transformedToolbars <-thisModule.transformedToolbars.union(Sequence{r});
		r.applyStereotype(thisModule.toolbarStereotype);
	}
}

helper def: toolbarsHelper: Sequence (XML!Element) = thisModule.xmlElements 
	-> select(e | e.name ='viewContribution' or e.name='actionSet' or e.name='objectContribution');

create OUT: UML2 from IN: UML2, Initial: UML2, Plugin: XML, Profile: profile;

helper def: initialClasses: Sequence(UML2!Class) =
	UML2!Class.allInstancesFrom('Initial'); 

helper context UML2!Class def: getOwnedAttributes(): Sequence(UML2!Property) =
	if thisModule.initialClasses -> select(e | e.name = self.name).isEmpty() then
		Sequence{}
	else
		if not (thisModule.initialClasses -> select(e | e.name = self.name).first().
				getAllAttributes().isEmpty()) then
			thisModule.initialClasses -> select(e | e.name = self.name).first().
					getAllAttributes()
		else
			Sequence{}
		endif
	endif;
[...]


rule ClassFromIN {
	from
		s: UML2!Class in IN (
			s.oclIsTypeOf(UML2!"uml::Class")
			and not s.oclIsUndefined()
		)
	to
		t: UML2!"uml::Class" (
			name <- s.name,
			visibility <- s.visibility,
			isLeaf <- s.isLeaf,
			isAbstract <- s.isAbstract,
			isActive <- s.isActive,
			eAnnotations <- s.eAnnotations,
			ownedComment <- s.ownedComment,
			clientDependency <- s.clientDependency,
			nameExpression <- s.nameExpression,
			elementImport <- s.elementImport,
			packageImport <- s.packageImport,
			ownedRule <- s.ownedRule,
			templateParameter <- s.templateParameter,
			templateBinding <- s.templateBinding,
			ownedTemplateSignature <- s.ownedTemplateSignature,
			generalization <- s.generalization,
			powertypeExtent <- s.powertypeExtent,
			redefinedClassifier <- s.redefinedClassifier,
			substitution <- s.substitution,
			representation <- s.representation,
			collaborationUse <- s.collaborationUse,
			ownedUseCase <- s.ownedUseCase,
			useCase <- s.useCase,
			ownedAttribute <- s.ownedAttribute,
			ownedConnector <- s.ownedConnector,
			ownedBehavior <- s.ownedBehavior,
			classifierBehavior <- s.classifierBehavior,
			interfaceRealization <- s.interfaceRealization,
			nestedClassifier <- s.nestedClassifier
			ownedReception <- s.ownedReception
		)
		---Keeps the applied stereotypes and values(CURRENTLY NOT WORKING)
	do {		
		t.ownedOperation <- s.getOwnedOperations()->debug('OwnedOperations') -> collect(e | thisModule.
					resolveTemp(e, 't'));
		t.ownedAttribute <- s.getOwnedAttributes()->debug('OwnedAttributtes') 
			-> collect(e | thisModule.
					resolveTemp(e->debug('e'), 'tgt'));
	}

rule PropertyFromInitial {
	from
		src: UML2!Property in Initial (
			---We need to make sure that the property is not empty,and also
			---that it doesn't belong to a type that is not transformed.
		if src.refImmediateComposite().oclIsTypeOf(UML2!Class) then
			src.refImmediateComposite().existsInIN() and not thisModule.inClasses ->
					select(e | e.name = src.refImmediateComposite().name).first().
					belongsToPackage('google') and if src.type.oclIsUndefined() then
				false
			else
				if src.type.getModel().oclIsUndefined() then
					true
				else
					not (src.type.getModel().name = UML2!Model.
							allInstancesFrom('IN').first().name)
				endif
			endif
		else
			false
		endif
		)
	to
		tgt: UML2!Property (
			name <- src.name,
			visibility <- src.visibility,
			lower <- src.lower,
			upper <- src.upper,
			type <- src.setType(),
			aggregation <- src.aggregation,
			association <- src.association,
			isStatic <- src.isStatic,
			ownedComment <- src.ownedComment
		)
}

lazy rule createAssociation {
	from
		s: String,  s2: String
	to
		tgt: UML2!Association (
			ownedEnd <- Sequence{thisModule.createProperty(tgt,s,true)},
			memberEnd<-Sequence{thisModule.createProperty(tgt,s2,false)}
		)
	do{
		tgt;	
	}
}

lazy rule createAssociation {
	from
		s: String,  s2: String
	to
		tgt: UML2!Association (
			ownedEnd <- Sequence{thisModule.createProperty(tgt,s,true),thisModule.createProperty(tgt,s2,false)}
		)
	do{
		tgt;	
	}
}