plugins/org.eclipse.ocl.pivot/model/PivotCS2AS.cs2as

source  cs : '/resource/org.eclipse.ocl.xtext.base/model/BaseCS.ecore#/'
target  as : 'Pivot.ecore#/'

mappings {
	
}

disambiguation {
	
}

nameresolution {
		
	named-element NamedElement name-property name; 	  /*from target */
	name-referencer PathElementCS name-property name; /*from source */
	name-qualifier PathNameCS name-segments-property ownedPathElements; /*from source */
		
	Variable {
		named-element /*name-property name*/;
	}
	
	Namespace {
		named-element
			/*qualifying Namespace using invalid,
					Class using invalid,
					Package using invalid,
					Operation using invalid,
					Property using invalid*/;
	}
	
	/*FIXME Element {
		same-scope	
	}*/
	
	
	
	
	Class {
		named-element 
			qualifying Property using ownedProperties,
						Operation using ownedOperations;
						
		nested-scope ownedProperties->select(not isStatic), 
				  ownedOperations->select(not isStatic),
				  ownedBehaviors 
			occluding let allSuperClasses = self->closure(superClass) -- FIXME
					in allSuperClasses->collect(ownedProperties->select(not isStatic))
					->includingAll(allSuperClasses->collect(ownedOperations->select(not isStatic)))
					->includingAll(allSuperClasses->collection(ownedBehaviors));
	}
	
	DataType {
		nested-scope ownedProperties->select(not isStatic), 
				  ownedOperations->select(not isStatic)
			occluding let allSuperClasses = self->closure(superClass)
					in allSuperClasses->collect(ownedProperties->select(not isStatic))
					->includingAll(allSuperClasses->collect(ownedOperations->select(not isStatic)));
	}
	
	Enumeration {
		nested-scope ownedLiterals,
				  ownedProperties->select(not isStatic),
				  ownedOperations->select(not isStatic),
				  ownedBehaviors;
		
	}
	
	ExpressionInOCL{
		nested-scope ownedContext->asSequence() /*FIXME*/,
				ownedParameters,
				ownedResult->asSequence() /*FIXME*/;
		
	}
	
	IterateExp{
		for ownedIterators
			nested-scope ownedResult->asSequence() /*FIXME*/, following ownedIterators;
		for all
			nested-scope ownedIterators;
	}
	
	IteratorExp {
		for ownedIterators
			nested-scope following ownedIterators;
		for all
			nested-scope ownedIterators;
	}
	
	
	LetExp {
		for ownedIn
			nested-scope ownedVariable->asSequence() /*FIXME*/;
	}
	
	Library {
		nested-scope ownedPackages,
				ownedClasses,
				ownedPrecedences;
	}
	
	Model {
		same-scope ownedPackages, ownedImports.importedNamespace,
			imported ownedImports.importedNamespace;
		
		exports Package using ownedPackages;
	}
	
	Operation {
		named-element
			filtered by argTypes : OrderedSet(Type) 
				when matchesArgs(argTypes);
		for all excepting ownedParameters
			nested-scope ownedParameters;
	}
	
	
	Package {
		named-element 
			qualifying Class using ownedClasses, 
					   Package using ownedPackages;
		/*for all*/
		nested-scope ownedClasses;
		exports Class using ownedClasses;
	}
	
	Property {
		named-element;
	}
}

helpers {
	as::Operation {
		matchesArgs(argTypes : OrderedSet(Type)) : Boolean :=
			argTypes->size() = ownedParameters->size() 
			and argTypes->forAll(x | x.conformsTo(ownedParameters->at(argTypes->indexOf(x)).type));
	}
	
	as::Class {
		conformsTo(anotherType : Class) : Boolean :=
			_conformsTo(anotherType) or 
			superClasses->exists(conformsTo(anotherType));

		_conformsTo(anotherType : Class) : Boolean :=
			self = anotherType;
	}
	
}