-- @atlcompiler atl2006
-- $Id$
-- This transformation defines the semantics of superimposing SUPER on IN.
module Superimpose;

create OUT : ATL from IN : ATL, SUPER : ATL;

helper def : inElements : Set(ATL!"ATL::LocatedElement") = 
	ATL!"ATL::LocatedElement".allInstancesFrom('IN')
	->reject(o|o.isOverridden())->asSet()
	->union(
		ATL!"ATL::LocatedElement".allInstancesFrom('SUPER')
		->reject(s|
			if s.oclIsKindOf(ATL!"ATL::Rule")
			or s.oclIsKindOf(ATL!"ATL::Helper") then
				s.isOverriding()
			else
				false
			endif));

helper def : realInElements : Set(ATL!"ATL::LocatedElement") = 
	ATL!"ATL::LocatedElement".allInstancesFrom('IN');

-- ***************************** isOverridden ******************************** 

helper context ATL!"ATL::LocatedElement" def : isOverridden() : Boolean =
	let owner : ATL!"ATL::LocatedElement" = self.refImmediateComposite() in
	if owner.oclIsUndefined() then
		false
	else
		owner.isOverridden()
	endif;

helper context ATL!"ATL::Rule" def : isOverridden() : Boolean =
	ATL!"ATL::Rule".allInstancesFrom('SUPER')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

helper context ATL!"ATL::Helper" def : isOverridden() : Boolean =
	ATL!"ATL::Helper".allInstancesFrom('SUPER')
	->exists(r|r.definition.feature.name = self.definition.feature.name
		and r.definition.feature.oclType() = self.definition.feature.oclType()
		and if r.definition.context_.oclIsUndefined()
			or self.definition.context_.oclIsUndefined() then
				r.definition.context_ = self.definition.context_
			else
				r.definition.context_.context_.name = 
					self.definition.context_.context_.name
			endif);

helper context ATL!"OCL::VariableDeclaration" def : isOverridden() : Boolean =
	let owner : ATL!"ATL::LocatedElement" = self.refImmediateComposite() in
	let variableExpOverridden : Boolean =
		self.variableExp->exists(e|e.isOverridden()) in
	if owner.oclIsUndefined() then
		variableExpOverridden
	else
		owner.isOverridden() or variableExpOverridden
	endif;

helper context ATL!"OCL::OclModel" def : isOverridden() : Boolean =
	ATL!"OCL::OclModel".allInstancesFrom('SUPER')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

helper context ATL!"ATL::LibraryRef" def : isOverridden() : Boolean =
	ATL!"ATL::LibraryRef".allInstancesFrom('SUPER')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

-- ***************************** isOverriding ******************************** 

helper context ATL!"ATL::LocatedElement" def : isOverriding() : Boolean =
	let owner : ATL!"ATL::LocatedElement" = self.refImmediateComposite() in
	if owner.oclIsUndefined() then
		false
	else
		owner.isOverriding()
	endif;

helper context ATL!"ATL::Rule" def : isOverriding() : Boolean =
	ATL!"ATL::Rule".allInstancesFrom('IN')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

helper context ATL!"ATL::Helper" def : isOverriding() : Boolean =
	ATL!"ATL::Helper".allInstancesFrom('IN')
	->exists(r|r.definition.feature.name = self.definition.feature.name
		and r.definition.feature.oclType() = self.definition.feature.oclType()
		and if r.definition.context_.oclIsUndefined()
			or self.definition.context_.oclIsUndefined() then
				r.definition.context_ = self.definition.context_
			else
				r.definition.context_.context_.name = 
					self.definition.context_.context_.name
			endif);

helper context ATL!"OCL::OclModel" def : isOverriding() : Boolean =
	ATL!"OCL::OclModel".allInstancesFrom('IN')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

helper context ATL!"ATL::LibraryRef" def : isOverriding() : Boolean =
	ATL!"ATL::LibraryRef".allInstancesFrom('IN')
	->exists(r|r.name = self.name and r.oclType() = self.oclType());

-- ***************************** overriddenBy ******************************** 

helper context ATL!"ATL::Rule" def : overriddenBy() : ATL!"ATL::Rule" =
	let selfInSuper : Sequence(ATL!"ATL::Rule") = 
		ATL!"ATL::Rule".allInstancesFrom('SUPER')
		->select(r|r.name = self.name and r.oclType() = self.oclType())
	in
	if selfInSuper->isEmpty() then
		self
	else
		selfInSuper->first()
	endif;

helper context ATL!"ATL::Helper" def : overriddenBy() : ATL!"ATL::Helper" =
	let selfInSuper : Sequence(ATL!"ATL::Helper") = 
		ATL!"ATL::Helper".allInstancesFrom('SUPER')
		->select(r|r.definition.feature.name = self.definition.feature.name
			and r.definition.feature.oclType() = self.definition.feature.oclType()
			and if r.definition.context_.oclIsUndefined()
				or self.definition.context_.oclIsUndefined() then
					r.definition.context_ = self.definition.context_
				else
					r.definition.context_.context_.name = 
						self.definition.context_.context_.name
				endif)
	in
	if selfInSuper->isEmpty() then
		self
	else
		selfInSuper->first()
	endif;

helper context ATL!"OCL::OclModel" def : overriddenBy() : ATL!"OCL::OclModel" =
	let selfInSuper : Sequence(ATL!"OCL::OclModel") = 
		ATL!"OCL::OclModel".allInstancesFrom('SUPER')
		->select(r|r.name = self.name and r.oclType() = self.oclType())
	in
	if selfInSuper->isEmpty() then
		self
	else
		selfInSuper->first()
	endif;

-- ******************************** rules ************************************ 

rule Module {
    from s : ATL!"ATL::Module" (thisModule.realInElements->includes(s))
	using { 
    	superElements : Sequence(ATL!"ATL::ModuleElement") = 
    		ATL!"ATL::Module".allInstancesFrom('SUPER')
			->collect(m|m.elements
				->select(e|not e.isOverriding()))
			->flatten();
		superInModels : Sequence(ATL!"OCL::OclModel") =
			ATL!"ATL::Module".allInstancesFrom('SUPER')
			->collect(m|m.inModels)
			->flatten();
		superOutModels : Sequence(ATL!"OCL::OclModel") =
			ATL!"ATL::Module".allInstancesFrom('SUPER')
			->collect(m|m.outModels)
			->flatten();
		superLibraryRefs : Sequence(ATL!"ATL::LibraryRef") =
			ATL!"ATL::Module".allInstancesFrom('SUPER')
			->collect(m|m.libraries)
			->flatten();
    }
    to t : ATL!"ATL::Module" (
        location <- s.location,
        commentsBefore <- s.commentsBefore,
        commentsAfter <- s.commentsAfter,
        name <- s.name,
        isRefining <- s.isRefining,
        libraries <- s.libraries->union(superLibraryRefs),
        inModels <- s.inModels->union(superInModels),
        outModels <- s.outModels->union(superOutModels),
        elements <- s.elements->union(superElements))
}

rule OverriddenMatchedRule {
    from s : ATL!"ATL::MatchedRule" (
		if thisModule.realInElements->includes(s) then
			s.oclIsTypeOf(ATL!"ATL::MatchedRule") and
			s.isOverridden()
		else false endif)
	using { o : ATL!"ATL::MatchedRule" = s.overriddenBy(); }
    to t : ATL!"ATL::MatchedRule" (
        location <- o.location,
        commentsBefore <- o.commentsBefore,
        commentsAfter <- o.commentsAfter,
        name <- o.name,
        isAbstract <- o.isAbstract,
        isRefining <- o.isRefining,
        isNoDefault <- o.isNoDefault,
        outPattern <- o.outPattern,
        actionBlock <- o.actionBlock,
        variables <- o.variables,
        inPattern <- o.inPattern,
        children <- o.children,
        superRule <- o.superRule)
}

rule OverriddenLazyMatchedRule {
    from s : ATL!"ATL::LazyMatchedRule" (
    	if thisModule.realInElements->includes(s) then
			s.isOverridden()
		else false endif)
	using { o : ATL!"ATL::LazyMatchedRule" = s.overriddenBy(); }
	to t : ATL!"ATL::LazyMatchedRule" (
        location <- o.location,
        commentsBefore <- o.commentsBefore,
        commentsAfter <- o.commentsAfter,
        name <- o.name,
        isAbstract <- o.isAbstract,
        isRefining <- o.isRefining,
        isNoDefault <- o.isNoDefault,
        isUnique <- o.isUnique,
        outPattern <- o.outPattern,
        actionBlock <- o.actionBlock,
        variables <- o.variables,
        inPattern <- o.inPattern,
        children <- o.children,
        superRule <- o.superRule)
}

rule OverriddenCalledRule {
    from s : ATL!"ATL::CalledRule" (
    	if thisModule.realInElements->includes(s) then
			s.isOverridden()
		else false endif)
	using { o : ATL!"ATL::CalledRule" = s.overriddenBy(); }
	to t : ATL!"ATL::CalledRule" (
        location <- o.location,
        commentsBefore <- o.commentsBefore,
        commentsAfter <- o.commentsAfter,
        name <- o.name,
        isEntrypoint <- o.isEntrypoint,
        isEndpoint <- o.isEndpoint,
        outPattern <- o.outPattern,
        actionBlock <- o.actionBlock,
        variables <- o.variables,
        parameters <- o.parameters)
}

rule OverriddenHelper {
    from s : ATL!"ATL::Helper" (
		if thisModule.realInElements->includes(s) then
			s.isOverridden()
		else false endif)
	using { o : ATL!"ATL::MatchedRule" = s.overriddenBy(); }
	to t : ATL!"ATL::Helper" (
        location <- o.location,
        commentsBefore <- o.commentsBefore,
        commentsAfter <- o.commentsAfter,
        definition <- o.definition)
}

rule OclModelElement {
    from s : ATL!"OCL::OclModelElement" (thisModule.inElements->includes(s))
    to t : ATL!"OCL::OclModelElement" (
        location <- s.location,
        commentsBefore <- s.commentsBefore,
        commentsAfter <- s.commentsAfter,
        name <- s.name,
        type <- s.type,
        model <- s.model.overriddenBy())
}