[lookupGen] - New example2 lookup definition

7 files changed, 509 insertions, 508 deletions

diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.ecore b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.ecore
index 5130124bb..946f0ea0a 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.ecore
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.ecore
@@ -10,18 +10,20 @@
     <details key="validationDelegates" value="http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot"/>
   </eAnnotations>
   <eClassifiers xsi:type="ecore:EClass" name="LookupEnvironment" eSuperTypes="#//Env4CG">
-    <eOperations name="addElements" eType="#//LookupEnvironment">
+    <eOperations name="addElements" lowerBound="1" eType="#//LookupEnvironment">
       <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot">
         <details key="body" value="LookupEnvironment{&#xA;&#x9;&#x9;&#x9;&#x9;&#x9;&#x9;namedElements = namedElements->includingAll(elements),&#xA;&#x9;&#x9;&#x9;&#x9;&#x9;&#x9;parentEnv = parentEnv&#x9;&#xA;&#x9;&#x9;&#x9;&#x9;}"/>
       </eAnnotations>
       <eTypeParameters name="NE">
         <eBounds eClassifier="ecore:EClass Classes.ecore#//NamedElement"/>
       </eTypeParameters>
-      <eParameters name="elements" upperBound="-1">
-        <eGenericType eTypeParameter="#//LookupEnvironment/addElements/NE"/>
+      <eParameters name="elements" lowerBound="1">
+        <eGenericType eClassifier="ecore:EClass platform:/plugin/org.eclipse.ocl.pivot/model-gen/oclstdlib.ecore#//Collection">
+          <eTypeArguments eTypeParameter="#//LookupEnvironment/addElements/NE"/>
+        </eGenericType>
       </eParameters>
     </eOperations>
-    <eOperations name="addElement" eType="#//LookupEnvironment">
+    <eOperations name="addElement" lowerBound="1" eType="#//LookupEnvironment">
       <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore/OCL/Pivot">
         <details key="body" value="LookupEnvironment{&#xA;&#x9;&#x9;&#x9;&#x9;&#x9;&#x9;namedElements = namedElements->including(element),&#xA;&#x9;&#x9;&#x9;&#x9;&#x9;&#x9;parentEnv = parentEnv&#xA;&#x9;&#x9;&#x9;&#x9;&#x9;}"/>
       </eAnnotations>
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.genmodel b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.genmodel
index 6faca7ba0..b8229c623 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.genmodel
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/EnvExample2.genmodel
@@ -4,8 +4,8 @@
     modelPluginID="org.eclipse.qvtd.cs2as.compiler.tests" templateDirectory="" modelName="Example2Environment"
     updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     importerID="org.eclipse.emf.importer.ecore" bundleManifest="false" complianceLevel="8.0"
-    copyrightFields="false" usedGenPackages="Classes.genmodel#//classes" operationReflection="true"
-    importOrganizing="true" pluginKey="">
+    copyrightFields="false" usedGenPackages="Classes.genmodel#//classes platform:/plugin/org.eclipse.ocl.pivot/model/oclstdlib.genmodel#//oclstdlib"
+    operationReflection="true" importOrganizing="true" pluginKey="">
   <genAnnotations source="http://www.eclipse.org/OCL/GenModel">
     <details key="Use Delegates" value="false"/>
     <details key="Use Null Annotations" value="true"/>
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.cs2as b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.cs2as
index e0057d62b..dba892feb 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.cs2as
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.cs2as
@@ -1,114 +1,114 @@
-source cs : 'ClassesCS.ecore#/'

-target as : 'Classes.ecore#/'

-

-mappings {

-	map as::Root from RootCS {

-		ownedPackages := ownedPackages.resolve;

-	}

-

-	map as::Package from PackageCS {

-		name := name;

-		ownedClasses := ownedClasses.resolve;

-		ownedPackages := ownedPackages.resolve;

-	}

-

-	map as::Class from ClassCS {

-		name := name;

-		ownedOperations := operations.resolve;

-		ownedProperties := properties.resolve;

-		superClass := if _extends = null then null else resolve.lookup(Class,_extends) endif; 

-	}

-	

-	map as::Property from PropertyCS {

-		name := name;

-		type := resolve.lookup(Class, typeRef); 

-	}

-	

-	map as::Operation from OperationCS {

-		name := name;

-		type := resolve.lookup(Class, resultRef);

-		ownedParameters := params->collect(x | classes::Parameter{ /*FIXME*/ });

-		ownedExpressions := bodyExps.resolve; 

-	}

-	

-	map as::PropertyCallExp from NameExpCS {

-		when isPropCallExp;

-		

-		ownedCallExp := ownedNameExp?.resolve;

-		referredProperty := if oclContainer().oclIsKindOf(NameExpCS) 

-							then resolve.lookupFrom(Property, resolve.owningSource.type, name)

-							else resolve.lookup(Property, name)

-							endif;

-		type := resolve.oclAsType(as::PropertyCallExp).referredProperty.type;

-	}

-	

-	map as::OperationCallExp from NameExpCS {

-		when isOpCallExp;

-	

-		ownedCallExp := ownedNameExp?.resolve;

-		ownedArguments := roundedBrackets.args.resolve;

-		referredOperation := if oclContainer().oclIsKindOf(NameExpCS) 

-							then resolve.lookupFrom(Operation, resolve.owningSource.type, name, resolve.oclAsType(as::OperationCallExp).ownedArguments) /*FIXME cast */

-							else resolve.lookup(Operation, name, resolve.oclAsType(as::OperationCallExp).ownedArguments) /*FIXME cast */

-							endif;

-		type := resolve.oclAsType(as::OperationCallExp).referredOperation.type;	

-	}

-	

-	map as::Argument from ArgumentCS {

-		name := name;

-	}	

-}

-

-

-

-disambiguation {

-	 NameExpCS {

-	 	isOpCallExp := roundedBrackets <> null;

-	 	isPropCallExp := roundedBrackets = null;

-	 }

-}

-

-nameresolution {

-		

-	named-element NamedElement name-property name; 	  /*from target */

-	name-referencer PathElementCS name-property name; /*from source */

-	name-qualifier PathNameCS name-segments-property path; /*from source */

-	

-	Root {

-		same-scope ownedPackages;

-	}

-	

-	Package {

-		named-element 

-			qualifying Package using ownedPackages,

-					   Class using ownedClasses;

-		

-		nested-scope ownedPackages, ownedClasses;

-	}

-	

-	Class {

-		named-element

-			qualifying Operation using ownedOperations,

-					   Property using ownedProperties;

-					   

-		nested-scope ownedOperations, ownedProperties;

-		

-		exports Operation using ownedOperations; 

-	    exports Property using ownedProperties; /* FIXME */

-	}

-	

-	Operation {

-		named-element

-			filtered by args : OrderedSet(Argument)

-				when args->size() = ownedParameters->size() and

-						args->forAll(x | x.name = ownedParameters->at(args->indexOf(x)).name);

-	}

-	

-	Property {

-		named-element;

-	}

-}

-

-helpers {

-	

+source cs : 'ClassesCS.ecore#/'
+target as : 'Classes.ecore#/'
+
+mappings {
+	map as::Root from RootCS {
+		ownedPackages := ownedPackages.resolve;
+	}
+
+	map as::Package from PackageCS {
+		name := name;
+		ownedClasses := ownedClasses.resolve;
+		ownedPackages := ownedPackages.resolve;
+	}
+
+	map as::Class from ClassCS {
+		name := name;
+		ownedOperations := operations.resolve;
+		ownedProperties := properties.resolve;
+		superClass := if _extends = null then null else resolve.lookup(Class,_extends) endif; 
+	}
+	
+	map as::Property from PropertyCS {
+		name := name;
+		type := resolve.lookup(Class, typeRef); 
+	}
+	
+	map as::Operation from OperationCS {
+		name := name;
+		type := resolve.lookup(Class, resultRef);
+		ownedParameters := params->collect(x | classes::Parameter{ /*FIXME*/ });
+		ownedExpressions := bodyExps.resolve; 
+	}
+	
+	map as::PropertyCallExp from NameExpCS {
+		when isPropCallExp;
+		
+		ownedCallExp := ownedNameExp?.resolve;
+		referredProperty := if oclContainer().oclIsKindOf(NameExpCS) 
+							then resolve.lookupFrom(Property, resolve.owningSource.type, name)
+							else resolve.lookup(Property, name)
+							endif;
+		type := resolve.oclAsType(as::PropertyCallExp).referredProperty.type;
+	}
+	
+	map as::OperationCallExp from NameExpCS {
+		when isOpCallExp;
+	
+		ownedCallExp := ownedNameExp?.resolve;
+		ownedArguments := roundedBrackets.args.resolve;
+		referredOperation := if oclContainer().oclIsKindOf(NameExpCS) 
+							then resolve.lookupFrom(Operation, resolve.owningSource.type, name, resolve.oclAsType(as::OperationCallExp).ownedArguments) /*FIXME cast */
+							else resolve.lookup(Operation, name, resolve.oclAsType(as::OperationCallExp).ownedArguments) /*FIXME cast */
+							endif;
+		type := resolve.oclAsType(as::OperationCallExp).referredOperation.type;	
+	}
+	
+	map as::Argument from ArgumentCS {
+		name := name;
+	}	
+}
+
+
+
+disambiguation {
+	 NameExpCS {
+	 	isOpCallExp := roundedBrackets <> null;
+	 	isPropCallExp := roundedBrackets = null;
+	 }
+}
+
+nameresolution {
+		
+	named-element NamedElement name-property name; 	  /*from target */
+	name-referencer PathElementCS name-property name; /*from source */
+	name-qualifier PathNameCS name-segments-property path; /*from source */
+	
+	Root {
+		same-scope ownedPackages;
+	}
+	
+	Package {
+		named-element 
+			qualifying Package using ownedPackages,
+					   Class using ownedClasses;
+		
+		nested-scope ownedPackages, ownedClasses;
+	}
+	
+	Class {
+		named-element
+			qualifying Operation using ownedOperations,
+					   Property using ownedProperties;
+					   
+		nested-scope ownedOperations, ownedProperties;
+		
+		exports Operation using ownedOperations; 
+	    exports Property using ownedProperties; /* FIXME */
+	}
+	
+	Operation {
+		named-element
+			filtered by args : OrderedSet(Argument)
+				when args->size() = ownedParameters->size() and
+						args->forAll(x | x.name = ownedParameters->at(args->indexOf(x)).name);
+	}
+	
+	Property {
+		named-element;
+	}
+}
+
+helpers {
+	
 }
\ No newline at end of file
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.ocl b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.ocl
index 58d1c9c15..561002fec 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.ocl
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2.ocl
@@ -1,69 +1,69 @@
-import  cs : 'ClassesCS.ecore#/'

-import  as : 'Classes.ecore#/'

-import 'classescs2asV2Helpers.ocl'

-import 'classescs2asV2Lookup.ocl'

-import 'classescs2asV2Disambiguation.ocl'

-package cs

-

-context RootCS

-def : ast() : as::Root =

-	as::Root {

-		ownedPackages = ownedPackages.ast() 

-	}

-context PackageCS

-def : ast() : as::Package =

-	as::Package {

-		name = name, 

-	ownedClasses = ownedClasses.ast(), 

-	ownedPackages = ownedPackages.ast() 

-	}

-context ClassCS

-def : ast() : as::Class =

-	as::Class {

-		name = name, 

-	ownedOperations = operations.ast(), 

-	ownedProperties = properties.ast(), 

-	superClass = if _extends = null then null else ast().lookupClass(_extends) endif 

-	}

-context PropertyCS

-def : ast() : as::Property =

-	as::Property {

-		name = name, 

-	type = ast().lookupClass(typeRef) 

-	}

-context OperationCS

-def : ast() : as::Operation =

-	as::Operation {

-		name = name, 

-	type = ast().lookupClass(resultRef), 

-	ownedParameters = params->collect(x | classes::Parameter{

-					name = x

-				}), 

-	ownedExpressions = bodyExps.ast() 

-	}

-context NameExpCS

-def : ast() : as::CallExp =

-	if isOpCallExp()

-	then as::OperationCallExp {

-		ownedCallExp = ownedNameExp?.ast(),

-		ownedArguments = roundedBrackets.args.ast(), 

-	referredOperation = if oclContainer().oclIsKindOf(NameExpCS) then ast().lookupOperationFrom(ast().owningSource.type, name, ast().oclAsType(as::OperationCallExp).ownedArguments) else ast().lookupOperation(name, ast().oclAsType(as::OperationCallExp).ownedArguments) endif, 

-	type = ast().oclAsType(as::OperationCallExp).referredOperation?.type

-	}

-	else

-		if isPropCallExp()

-		then as::PropertyCallExp {

-			ownedCallExp = ownedNameExp?.ast(), 

-		referredProperty = if oclContainer().oclIsKindOf(NameExpCS) then ast().lookupPropertyFrom(ast().owningSource.type, name) else ast().lookupProperty(name) endif, 

-		type = ast().oclAsType(as::PropertyCallExp).referredProperty?.type

-		}

-		else

-			invalid

-		endif

-	endif

-context ArgumentCS

-def : ast() : as::Argument =

-	as::Argument {

-		name = name 

-	}

-endpackage

+import  cs : 'ClassesCS.ecore#/'
+import  as : 'Classes.ecore#/'
+import 'classescs2asV2Helpers.ocl'
+import 'classescs2asV2Lookup.ocl'
+import 'classescs2asV2Disambiguation.ocl'
+package cs
+
+context RootCS
+def : ast() : as::Root =
+	as::Root {
+		ownedPackages = ownedPackages.ast() 
+	}
+context PackageCS
+def : ast() : as::Package =
+	as::Package {
+		name = name, 
+	ownedClasses = ownedClasses.ast(), 
+	ownedPackages = ownedPackages.ast() 
+	}
+context ClassCS
+def : ast() : as::Class =
+	as::Class {
+		name = name, 
+	ownedOperations = operations.ast(), 
+	ownedProperties = properties.ast(), 
+	superClass = if _extends = null then null else ast().lookupClass(_extends) endif 
+	}
+context PropertyCS
+def : ast() : as::Property =
+	as::Property {
+		name = name, 
+	type = ast().lookupClass(typeRef) 
+	}
+context OperationCS
+def : ast() : as::Operation =
+	as::Operation {
+		name = name, 
+	type = ast().lookupClass(resultRef), 
+	ownedParameters = params->collect(x | classes::Parameter{
+					name = x
+				}), 
+	ownedExpressions = bodyExps.ast() 
+	}
+context NameExpCS
+def : ast() : as::CallExp =
+	if isOpCallExp()
+	then as::OperationCallExp {
+		ownedCallExp = ownedNameExp?.ast(),
+		ownedArguments = roundedBrackets.args.ast(), 
+	referredOperation = if oclContainer().oclIsKindOf(NameExpCS) then ast().lookupOperationFrom(ast().owningSource.type, name, ast().oclAsType(as::OperationCallExp).ownedArguments) else ast().lookupOperation(name, ast().oclAsType(as::OperationCallExp).ownedArguments) endif, 
+	type = ast().oclAsType(as::OperationCallExp).referredOperation?.type
+	}
+	else
+		if isPropCallExp()
+		then as::PropertyCallExp {
+			ownedCallExp = ownedNameExp?.ast(), 
+		referredProperty = if oclContainer().oclIsKindOf(NameExpCS) then ast().lookupPropertyFrom(ast().owningSource.type, name) else ast().lookupProperty(name) endif, 
+		type = ast().oclAsType(as::PropertyCallExp).referredProperty?.type
+		}
+		else
+			invalid
+		endif
+	endif
+context ArgumentCS
+def : ast() : as::Argument =
+	as::Argument {
+		name = name 
+	}
+endpackage
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Disambiguation.ocl b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Disambiguation.ocl
index b015afc2e..fa07f72c7 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Disambiguation.ocl
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Disambiguation.ocl
@@ -1,12 +1,12 @@
-import  cs : 'ClassesCS.ecore#/'

-import  as : 'Classes.ecore#/'

-import 'classescs2asV2Helpers.ocl'

-import 'classescs2asV2Lookup.ocl'

-package cs

-

-context NameExpCS

-def : isOpCallExp() : Boolean =

-	roundedBrackets <> null

-def : isPropCallExp() : Boolean =

-	roundedBrackets = null

-endpackage

+import  cs : 'ClassesCS.ecore#/'
+import  as : 'Classes.ecore#/'
+import 'classescs2asV2Helpers.ocl'
+import 'classescs2asV2Lookup.ocl'
+package cs
+
+context NameExpCS
+def : isOpCallExp() : Boolean =
+	roundedBrackets <> null
+def : isPropCallExp() : Boolean =
+	roundedBrackets = null
+endpackage
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Helpers.ocl b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Helpers.ocl
index da9463027..5ea5ba34d 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Helpers.ocl
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Helpers.ocl
@@ -1,2 +1,2 @@
-import  cs : 'ClassesCS.ecore#/'

-import  as : 'Classes.ecore#/'

+import  cs : 'ClassesCS.ecore#/'
+import  as : 'Classes.ecore#/'
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Lookup.ocl b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Lookup.ocl
index 05415f1d5..ab192f5a3 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Lookup.ocl
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/models/example2/classescs2asV2Lookup.ocl
@@ -1,306 +1,305 @@
-import  cs : 'ClassesCS.ecore#/'

-import  as : 'Classes.ecore#/'

-import 'EnvExample2.ecore'

-import 'classescs2asV2Helpers.ocl'

-

-package ocl

----- Default Environment related functionality

-context OclElement

---	

-def : env() : lookup::LookupEnvironment[1] =

-	_env(null)

-

-def : _env(child : OclElement) : lookup::LookupEnvironment[1] =

-	parentEnv()

-	

-def : _exported_env(importer : OclElement) : lookup::LookupEnvironment[1] =

-	lookup::LookupEnvironment { }

-	

-def : parentEnv() : lookup::LookupEnvironment[1] =

-	let parent = oclContainer() in if parent = null then lookup::LookupEnvironment { } else parent._env(self) endif

-endpackage 

-

-package lookup

-context LookupEnvironment

-def : nestedEnv() : LookupEnvironment[1] = 

-	LookupEnvironment {

-		parentEnv = self

-	}

-endpackage

-

-package as

-

-	

-context Root

-def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =

-	parentEnv()

-		.addElements(ownedPackages)

-	

-context Package

-	

-def : _lookupQualifiedPackage(pName : String) : Package[?] =

-	let foundPackage = _lookupPackage(_qualified_env(), pName)

-	in  if foundPackage->isEmpty()

-		then null

-		else foundPackage->first()

-		endif

-def : lookupQualifiedPackage(aPathElementCS : cs::PathElementCS) : Package[?] =

-   _lookupQualifiedPackage(aPathElementCS.name)

-   

-	

-def : _lookupQualifiedClass(cName : String) : Class[?] =

-	let foundClass = _lookupClass(_qualified_env(), cName)

-	in  if foundClass->isEmpty()

-		then null

-		else foundClass->first()

-		endif

-def : lookupQualifiedClass(aPathElementCS : cs::PathElementCS) : Class[?] =

-   _lookupQualifiedClass(aPathElementCS.name)

-   

-	

-def : _qualified_env() : lookup::LookupEnvironment =

-	let env = lookup::LookupEnvironment{}

-	in env

-		.addElements(ownedPackages)

-.addElements(ownedClasses)

-def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =

-	parentEnv().nestedEnv()

-		.addElements(ownedPackages)

-		.addElements(ownedClasses)

-	

-context Class

-	

-def : _lookupQualifiedOperation(oName : String, args : OrderedSet(Argument)) : Operation[?] =

-	let foundOperation = _lookupOperation(_qualified_env(), oName, args)

-	in  if foundOperation->isEmpty()

-		then null

-		else foundOperation->first()

-		endif

-def : lookupQualifiedOperation(aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =

-   _lookupQualifiedOperation(aPathElementCS.name, args)

-   

-	

-def : _lookupQualifiedProperty(pName : String) : Property[?] =

-	let foundProperty = _lookupProperty(_qualified_env(), pName)

-	in  if foundProperty->isEmpty()

-		then null

-		else foundProperty->first()

-		endif

-def : lookupQualifiedProperty(aPathElementCS : cs::PathElementCS) : Property[?] =

-   _lookupQualifiedProperty(aPathElementCS.name)

-   

-	

-def : _qualified_env() : lookup::LookupEnvironment =

-	let env = lookup::LookupEnvironment{}

-	in env

-		.addElements(ownedOperations)

-.addElements(ownedProperties)

-def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =

-	parentEnv().nestedEnv()

-		.addElements(let allSuperClasses = self->closure(superClass)

-					in let properties : Bag(NamedElement) = allSuperClasses->collect(ownedProperties)

-					in properties->includingAll(allSuperClasses.ownedOperations)

-					->asOrderedSet() -- FIXME

-		)

-		.nestedEnv()

-		.addElements(ownedOperations)

-		.addElements(ownedProperties)

-def : _exported_env(importer : ocl::OclElement) : lookup::LookupEnvironment =

-	let env = lookup::LookupEnvironment {}

-	in env

-		.addElements(ownedProperties)

-	

-def : _lookupExportedOperation(importer : ocl::OclElement, oName : String, args : OrderedSet(Argument)) : Operation[?] =

-	let foundOperation = _lookupOperation(_exported_env(importer), oName, args)

-	in  if foundOperation->isEmpty()

-		then null

-		else foundOperation->first()

-		endif

-		

-def : lookupExportedOperation(importer : ocl::OclElement, aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =

-	_lookupExportedOperation(importer, aPathElementCS.name, args)

-	

-def : _lookupExportedProperty(importer : ocl::OclElement, pName : String) : Property[?] =

-	let foundProperty = _lookupProperty(_exported_env(importer), pName)

-	in  if foundProperty->isEmpty()

-		then null

-		else foundProperty->first()

-		endif

-		

-def : lookupExportedProperty(importer : ocl::OclElement, aPathElementCS : cs::PathElementCS) : Property[?] =

-	_lookupExportedProperty(importer, aPathElementCS.name)

-	

-context Operation

-	

-def : _appliesFilter_Operation(args : OrderedSet(Argument)) : Boolean =

-	args->size() = ownedParameters->size() and args->forAll(x | x.name = ownedParameters->at(args->indexOf(x)).name)

-def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =

-	parentEnv()

-	

-context Property

-def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =

-	parentEnv()

-

-context Visitable

--- Package lookup

-def : _lookupPackage(env : lookup::LookupEnvironment, pName : String) : OrderedSet(Package) =

-let foundPackage = env.namedElements->selectByKind(Package)->select(name = pName)

-in  if foundPackage->isEmpty() and not (env.parentEnv = null)

-	then _lookupPackage(env.parentEnv, pName)

-	else foundPackage

-	endif

-	

--- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 

--- object on which error reports will be handled

-def : _lookupPackage(pName : String) : Package[?] =

-let foundPackage = _lookupPackage(env(), pName)

-in  if foundPackage->isEmpty()

-	then null

-	else foundPackage->first() -- LookupVisitor will report ambiguous result

-	endif

-def : lookupPackage(aPathElementCS : cs::PathElementCS) : Package[?] =

-   _lookupPackage(aPathElementCS.name)

-   

-

--- QN Package lookup

-def : lookupPackage(aPathNameCS : cs::PathNameCS) : Package[?] =

-   lookupPackage(aPathNameCS .path)

-

-def : lookupPackage(segments : OrderedSet(cs::PathElementCS)) : Package[?] =

-   if segments->size() = 1

-   then lookupPackage(segments->first())

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupPackage(qualifierSegments)

-        in qualifier?.lookupQualifiedPackage(segments->last())

-   endif

-

--- Class lookup

-def : _lookupClass(env : lookup::LookupEnvironment, cName : String) : OrderedSet(Class) =

-let foundClass = env.namedElements->selectByKind(Class)->select(name = cName)

-in  if foundClass->isEmpty() and not (env.parentEnv = null)

-	then _lookupClass(env.parentEnv, cName)

-	else foundClass

-	endif

-	

--- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 

--- object on which error reports will be handled

-def : _lookupClass(cName : String) : Class[?] =

-let foundClass = _lookupClass(env(), cName)

-in  if foundClass->isEmpty()

-	then null

-	else foundClass->first() -- LookupVisitor will report ambiguous result

-	endif

-def : lookupClass(aPathElementCS : cs::PathElementCS) : Class[?] =

-   _lookupClass(aPathElementCS.name)

-   

-

--- QN Class lookup

-def : lookupClass(aPathNameCS : cs::PathNameCS) : Class[?] =

-   lookupClass(aPathNameCS .path)

-

-def : lookupClass(segments : OrderedSet(cs::PathElementCS)) : Class[?] =

-   if segments->size() = 1

-   then lookupClass(segments->first())

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupPackage(qualifierSegments)

-        in qualifier?.lookupQualifiedClass(segments->last())

-   endif

-

--- Class exports Operation

-	

-def : lookupOperationFrom(exporter : Class, aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =

-	exporter.lookupExportedOperation(self, aPathElementCS, args)

-

-def : lookupOperationFrom(exporter : Class, aPathNameCS : cs::PathNameCS, args : OrderedSet(Argument)) : Operation[?] =

-   lookupOperationFrom(exporter, aPathNameCS.path, args)

-

-def : lookupOperationFrom(exporter : Class, segments : OrderedSet(cs::PathElementCS), args : OrderedSet(Argument)) : Operation[?] =

-   if segments->size() = 1

-   then lookupOperationFrom(exporter, segments->first(), args)

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupClass(qualifierSegments)

-        in qualifier?.lookupQualifiedOperation(segments->last(), args)

-   endif

--- Class exports Property

-	

-def : lookupPropertyFrom(exporter : Class, aPathElementCS : cs::PathElementCS) : Property[?] =

-	exporter.lookupExportedProperty(self, aPathElementCS)

-

-def : lookupPropertyFrom(exporter : Class, aPathNameCS : cs::PathNameCS) : Property[?] =

-   lookupPropertyFrom(exporter, aPathNameCS.path)

-

-def : lookupPropertyFrom(exporter : Class, segments : OrderedSet(cs::PathElementCS)) : Property[?] =

-   if segments->size() = 1

-   then lookupPropertyFrom(exporter, segments->first())

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupClass(qualifierSegments)

-        in qualifier?.lookupQualifiedProperty(segments->last())

-   endif

--- Operation lookup

-def : _lookupOperation(env : lookup::LookupEnvironment, oName : String, args : OrderedSet(Argument)) : OrderedSet(Operation) =

-let foundOperation = env.namedElements->selectByKind(Operation)->select(name = oName)

-                                         ->select(_appliesFilter_Operation(args))

-in  if foundOperation->isEmpty() and not (env.parentEnv = null)

-	then _lookupOperation(env.parentEnv, oName, args)

-	else foundOperation

-	endif

-	

--- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 

--- object on which error reports will be handled

-def : _lookupOperation(oName : String, args : OrderedSet(Argument)) : Operation[?] =

-let foundOperation = _lookupOperation(env(), oName, args)

-in  if foundOperation->isEmpty()

-	then null

-	else foundOperation->first() -- LookupVisitor will report ambiguous result

-	endif

-def : lookupOperation(aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =

-   _lookupOperation(aPathElementCS.name, args)

-   

-

--- QN Operation lookup

-def : lookupOperation(aPathNameCS : cs::PathNameCS, args : OrderedSet(Argument)) : Operation[?] =

-   lookupOperation(aPathNameCS .path, args)

-

-def : lookupOperation(segments : OrderedSet(cs::PathElementCS), args : OrderedSet(Argument)) : Operation[?] =

-   if segments->size() = 1

-   then lookupOperation(segments->first(), args)

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupClass(qualifierSegments)

-        in qualifier?.lookupQualifiedOperation(segments->last(), args)

-   endif

-

--- Property lookup

-def : _lookupProperty(env : lookup::LookupEnvironment, pName : String) : OrderedSet(Property) =

-let foundProperty = env.namedElements->selectByKind(Property)->select(name = pName)

-in  if foundProperty->isEmpty() and not (env.parentEnv = null)

-	then _lookupProperty(env.parentEnv, pName)

-	else foundProperty

-	endif

-	

--- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 

--- object on which error reports will be handled

-def : _lookupProperty(pName : String) : Property[?] =

-let foundProperty = _lookupProperty(env(), pName)

-in  if foundProperty->isEmpty()

-	then null

-	else foundProperty->first() -- LookupVisitor will report ambiguous result

-	endif

-def : lookupProperty(aPathElementCS : cs::PathElementCS) : Property[?] =

-   _lookupProperty(aPathElementCS.name)

-   

-

--- QN Property lookup

-def : lookupProperty(aPathNameCS : cs::PathNameCS) : Property[?] =

-   lookupProperty(aPathNameCS .path)

-

-def : lookupProperty(segments : OrderedSet(cs::PathElementCS)) : Property[?] =

-   if segments->size() = 1

-   then lookupProperty(segments->first())

-   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),

-            qualifier = lookupClass(qualifierSegments)

-        in qualifier?.lookupQualifiedProperty(segments->last())

-   endif

-

-

-

-endpackage

+import  cs : 'ClassesCS.ecore#/'
+import  as : 'Classes.ecore#/'
+import 'EnvExample2.ecore'
+import 'classescs2asV2Helpers.ocl'
+
+package ocl
+---- Default Environment related functionality
+context OclElement
+--	
+def : env() : lookup::LookupEnvironment[1] =
+	_env(null)
+
+def : _env(child : OclElement) : lookup::LookupEnvironment[1] =
+	parentEnv()
+	
+def : _exported_env(importer : OclElement) : lookup::LookupEnvironment[1] =
+	lookup::LookupEnvironment { }
+	
+def : parentEnv() : lookup::LookupEnvironment[1] =
+	let parent = oclContainer() in if parent = null then lookup::LookupEnvironment { } else parent._env(self) endif
+endpackage 
+
+package lookup
+context LookupEnvironment
+def : nestedEnv() : LookupEnvironment[1] = 
+	LookupEnvironment {
+		parentEnv = self
+	}
+endpackage
+
+package as
+
+	
+context Root
+def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =
+	parentEnv()
+		.addElements(ownedPackages)
+	
+context Package
+	
+def : _lookupQualifiedPackage(pName : String) : Package[?] =
+	let foundPackage = _lookupPackage(_qualified_env(), pName)
+	in  if foundPackage->isEmpty()
+		then null
+		else foundPackage->first()
+		endif
+def : lookupQualifiedPackage(aPathElementCS : cs::PathElementCS) : Package[?] =
+   _lookupQualifiedPackage(aPathElementCS.name)
+   
+	
+def : _lookupQualifiedClass(cName : String) : Class[?] =
+	let foundClass = _lookupClass(_qualified_env(), cName)
+	in  if foundClass->isEmpty()
+		then null
+		else foundClass->first()
+		endif
+def : lookupQualifiedClass(aPathElementCS : cs::PathElementCS) : Class[?] =
+   _lookupQualifiedClass(aPathElementCS.name)
+   
+	
+def : _qualified_env() : lookup::LookupEnvironment =
+	let env = lookup::LookupEnvironment{}
+	in env
+		.addElements(ownedPackages)
+.addElements(ownedClasses)
+def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =
+	parentEnv().nestedEnv()
+		.addElements(ownedPackages)
+		.addElements(ownedClasses)
+	
+context Class
+	
+def : _lookupQualifiedOperation(oName : String, args : OrderedSet(Argument)) : Operation[?] =
+	let foundOperation = _lookupOperation(_qualified_env(), oName, args)
+	in  if foundOperation->isEmpty()
+		then null
+		else foundOperation->first()
+		endif
+def : lookupQualifiedOperation(aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =
+   _lookupQualifiedOperation(aPathElementCS.name, args)
+   
+	
+def : _lookupQualifiedProperty(pName : String) : Property[?] =
+	let foundProperty = _lookupProperty(_qualified_env(), pName)
+	in  if foundProperty->isEmpty()
+		then null
+		else foundProperty->first()
+		endif
+def : lookupQualifiedProperty(aPathElementCS : cs::PathElementCS) : Property[?] =
+   _lookupQualifiedProperty(aPathElementCS.name)
+   
+	
+def : _qualified_env() : lookup::LookupEnvironment =
+	let env = lookup::LookupEnvironment{}
+	in env
+		.addElements(ownedOperations)
+.addElements(ownedProperties)
+def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =
+	parentEnv().nestedEnv()
+		.addElements(let allSuperClasses = self->closure(superClass)
+					in let properties : Bag(NamedElement) = allSuperClasses->collect(ownedProperties)
+					in properties->includingAll(allSuperClasses.ownedOperations)
+		)
+		.nestedEnv()
+		.addElements(ownedOperations)
+		.addElements(ownedProperties)
+def : _exported_env(importer : ocl::OclElement) : lookup::LookupEnvironment =
+	let env = lookup::LookupEnvironment {}
+	in env
+		.addElements(ownedProperties)
+	
+def : _lookupExportedOperation(importer : ocl::OclElement, oName : String, args : OrderedSet(Argument)) : Operation[?] =
+	let foundOperation = _lookupOperation(_exported_env(importer), oName, args)
+	in  if foundOperation->isEmpty()
+		then null
+		else foundOperation->first()
+		endif
+		
+def : lookupExportedOperation(importer : ocl::OclElement, aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =
+	_lookupExportedOperation(importer, aPathElementCS.name, args)
+	
+def : _lookupExportedProperty(importer : ocl::OclElement, pName : String) : Property[?] =
+	let foundProperty = _lookupProperty(_exported_env(importer), pName)
+	in  if foundProperty->isEmpty()
+		then null
+		else foundProperty->first()
+		endif
+		
+def : lookupExportedProperty(importer : ocl::OclElement, aPathElementCS : cs::PathElementCS) : Property[?] =
+	_lookupExportedProperty(importer, aPathElementCS.name)
+	
+context Operation
+	
+def : _appliesFilter_Operation(args : OrderedSet(Argument)) : Boolean =
+	args->size() = ownedParameters->size() and args->forAll(x | x.name = ownedParameters->at(args->indexOf(x)).name)
+def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =
+	parentEnv()
+	
+context Property
+def : _env(child : ocl::OclElement) : lookup::LookupEnvironment =
+	parentEnv()
+
+context Visitable
+-- Package lookup
+def : _lookupPackage(env : lookup::LookupEnvironment, pName : String) : OrderedSet(Package) =
+let foundPackage = env.namedElements->selectByKind(Package)->select(name = pName)
+in  if foundPackage->isEmpty() and not (env.parentEnv = null)
+	then _lookupPackage(env.parentEnv, pName)
+	else foundPackage
+	endif
+	
+-- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 
+-- object on which error reports will be handled
+def : _lookupPackage(pName : String) : Package[?] =
+let foundPackage = _lookupPackage(env(), pName)
+in  if foundPackage->isEmpty()
+	then null
+	else foundPackage->first() -- LookupVisitor will report ambiguous result
+	endif
+def : lookupPackage(aPathElementCS : cs::PathElementCS) : Package[?] =
+   _lookupPackage(aPathElementCS.name)
+   
+
+-- QN Package lookup
+def : lookupPackage(aPathNameCS : cs::PathNameCS) : Package[?] =
+   lookupPackage(aPathNameCS .path)
+
+def : lookupPackage(segments : OrderedSet(cs::PathElementCS)) : Package[?] =
+   if segments->size() = 1
+   then lookupPackage(segments->first())
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupPackage(qualifierSegments)
+        in qualifier?.lookupQualifiedPackage(segments->last())
+   endif
+
+-- Class lookup
+def : _lookupClass(env : lookup::LookupEnvironment, cName : String) : OrderedSet(Class) =
+let foundClass = env.namedElements->selectByKind(Class)->select(name = cName)
+in  if foundClass->isEmpty() and not (env.parentEnv = null)
+	then _lookupClass(env.parentEnv, cName)
+	else foundClass
+	endif
+	
+-- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 
+-- object on which error reports will be handled
+def : _lookupClass(cName : String) : Class[?] =
+let foundClass = _lookupClass(env(), cName)
+in  if foundClass->isEmpty()
+	then null
+	else foundClass->first() -- LookupVisitor will report ambiguous result
+	endif
+def : lookupClass(aPathElementCS : cs::PathElementCS) : Class[?] =
+   _lookupClass(aPathElementCS.name)
+   
+
+-- QN Class lookup
+def : lookupClass(aPathNameCS : cs::PathNameCS) : Class[?] =
+   lookupClass(aPathNameCS .path)
+
+def : lookupClass(segments : OrderedSet(cs::PathElementCS)) : Class[?] =
+   if segments->size() = 1
+   then lookupClass(segments->first())
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupPackage(qualifierSegments)
+        in qualifier?.lookupQualifiedClass(segments->last())
+   endif
+
+-- Class exports Operation
+	
+def : lookupOperationFrom(exporter : Class, aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =
+	exporter.lookupExportedOperation(self, aPathElementCS, args)
+
+def : lookupOperationFrom(exporter : Class, aPathNameCS : cs::PathNameCS, args : OrderedSet(Argument)) : Operation[?] =
+   lookupOperationFrom(exporter, aPathNameCS.path, args)
+
+def : lookupOperationFrom(exporter : Class, segments : OrderedSet(cs::PathElementCS), args : OrderedSet(Argument)) : Operation[?] =
+   if segments->size() = 1
+   then lookupOperationFrom(exporter, segments->first(), args)
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupClass(qualifierSegments)
+        in qualifier?.lookupQualifiedOperation(segments->last(), args)
+   endif
+-- Class exports Property
+	
+def : lookupPropertyFrom(exporter : Class, aPathElementCS : cs::PathElementCS) : Property[?] =
+	exporter.lookupExportedProperty(self, aPathElementCS)
+
+def : lookupPropertyFrom(exporter : Class, aPathNameCS : cs::PathNameCS) : Property[?] =
+   lookupPropertyFrom(exporter, aPathNameCS.path)
+
+def : lookupPropertyFrom(exporter : Class, segments : OrderedSet(cs::PathElementCS)) : Property[?] =
+   if segments->size() = 1
+   then lookupPropertyFrom(exporter, segments->first())
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupClass(qualifierSegments)
+        in qualifier?.lookupQualifiedProperty(segments->last())
+   endif
+-- Operation lookup
+def : _lookupOperation(env : lookup::LookupEnvironment, oName : String, args : OrderedSet(Argument)) : OrderedSet(Operation) =
+let foundOperation = env.namedElements->selectByKind(Operation)->select(name = oName)
+                                         ->select(_appliesFilter_Operation(args))
+in  if foundOperation->isEmpty() and not (env.parentEnv = null)
+	then _lookupOperation(env.parentEnv, oName, args)
+	else foundOperation
+	endif
+	
+-- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 
+-- object on which error reports will be handled
+def : _lookupOperation(oName : String, args : OrderedSet(Argument)) : Operation[?] =
+let foundOperation = _lookupOperation(env(), oName, args)
+in  if foundOperation->isEmpty()
+	then null
+	else foundOperation->first() -- LookupVisitor will report ambiguous result
+	endif
+def : lookupOperation(aPathElementCS : cs::PathElementCS, args : OrderedSet(Argument)) : Operation[?] =
+   _lookupOperation(aPathElementCS.name, args)
+   
+
+-- QN Operation lookup
+def : lookupOperation(aPathNameCS : cs::PathNameCS, args : OrderedSet(Argument)) : Operation[?] =
+   lookupOperation(aPathNameCS .path, args)
+
+def : lookupOperation(segments : OrderedSet(cs::PathElementCS), args : OrderedSet(Argument)) : Operation[?] =
+   if segments->size() = 1
+   then lookupOperation(segments->first(), args)
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupClass(qualifierSegments)
+        in qualifier?.lookupQualifiedOperation(segments->last(), args)
+   endif
+
+-- Property lookup
+def : _lookupProperty(env : lookup::LookupEnvironment, pName : String) : OrderedSet(Property) =
+let foundProperty = env.namedElements->selectByKind(Property)->select(name = pName)
+in  if foundProperty->isEmpty() and not (env.parentEnv = null)
+	then _lookupProperty(env.parentEnv, pName)
+	else foundProperty
+	endif
+	
+-- Note: when calling this method, the source element of the argument passed to this method, will be the contextual 
+-- object on which error reports will be handled
+def : _lookupProperty(pName : String) : Property[?] =
+let foundProperty = _lookupProperty(env(), pName)
+in  if foundProperty->isEmpty()
+	then null
+	else foundProperty->first() -- LookupVisitor will report ambiguous result
+	endif
+def : lookupProperty(aPathElementCS : cs::PathElementCS) : Property[?] =
+   _lookupProperty(aPathElementCS.name)
+   
+
+-- QN Property lookup
+def : lookupProperty(aPathNameCS : cs::PathNameCS) : Property[?] =
+   lookupProperty(aPathNameCS .path)
+
+def : lookupProperty(segments : OrderedSet(cs::PathElementCS)) : Property[?] =
+   if segments->size() = 1
+   then lookupProperty(segments->first())
+   else let qualifierSegments = segments->subOrderedSet(1,segments->size()-1),
+            qualifier = lookupClass(qualifierSegments)
+        in qualifier?.lookupQualifiedProperty(segments->last())
+   endif
+
+
+
+endpackage