25 files changed, 234 insertions, 216 deletions

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
index b0ce2497..1c86e38f 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
index b69f4fca..57c8ab25 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ui/META-INF/MANIFEST.MF b/Application/hu.bme.mit.inf.dslreasoner.application.ui/META-INF/MANIFEST.MF
index 38bb7dbd..2f2c83ef 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ui/META-INF/MANIFEST.MF
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ui/META-INF/MANIFEST.MF
@@ -22,7 +22,8 @@ Require-Bundle: hu.bme.mit.inf.dslreasoner.application,
  org.eclipse.xtext.builder,
  org.eclipse.xtend.lib;bundle-version="2.14.0";resolution:=optional,
  org.eclipse.xtext.xbase.lib;bundle-version="2.14.0",
- org.eclipse.viatra.addon.validation.runtime.ui;bundle-version="1.7.0"
+ org.eclipse.viatra.addon.validation.runtime.ui;bundle-version="1.7.0",
+ org.eclipse.viatra.query.patternlanguage.emf.ui;bundle-version="2.4.1"
 Import-Package: org.apache.log4j
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: hu.bme.mit.inf.dslreasoner.application.ui.quickfix,
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ui/plugin.xml b/Application/hu.bme.mit.inf.dslreasoner.application.ui/plugin.xml
index 304df098..2895983e 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ui/plugin.xml
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ui/plugin.xml
@@ -410,7 +410,7 @@
  <extension

        point="org.eclipse.ui.commands">

     <command

-          defaultHandler="hu.bme.mit.inf.dslreasoner.application.ui.execute.ExecuteScriptHandler"

+          defaultHandler="org.eclipse.viatra.query.patternlanguage.emf.ui.ReusablePatternLanguageExecutableExtensionFactory:hu.bme.mit.inf.dslreasoner.application.ui.execute.ExecuteScriptHandler"

           id="hu.bme.mit.inf.dslreasoner.application.ui.executescript"

           name="ExecuteScript">

     </command>

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ui/src/hu/bme/mit/inf/dslreasoner/application/ui/execute/ExecuteScriptHandler.java b/Application/hu.bme.mit.inf.dslreasoner.application.ui/src/hu/bme/mit/inf/dslreasoner/application/ui/execute/ExecuteScriptHandler.java
index 380410d0..8d9d07a6 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ui/src/hu/bme/mit/inf/dslreasoner/application/ui/execute/ExecuteScriptHandler.java
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ui/src/hu/bme/mit/inf/dslreasoner/application/ui/execute/ExecuteScriptHandler.java
@@ -12,14 +12,23 @@ import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.StructuredSelection;

 import org.eclipse.ui.handlers.HandlerUtil;

 

+import com.google.inject.Inject;

+import com.google.inject.Injector;

+

 import hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor;

 

 public class ExecuteScriptHandler extends AbstractHandler implements IHandler {

-

-        ScriptExecutor scriptExecutor = new ScriptExecutor(RuntimeConsoleBasedScriptConsole.FACTORY);

+        

+        ScriptExecutor scriptExecutor;

+        

+        @Inject

+        public void setInjector(Injector injector) {

+                scriptExecutor = new ScriptExecutor(RuntimeConsoleBasedScriptConsole.FACTORY, injector);

+        }

         

         @Override

         public Object execute(ExecutionEvent event) throws ExecutionException {

+                assert scriptExecutor != null : "Injector must be set";

                 ISelection selection = HandlerUtil.getCurrentSelection(event);

                 if(selection instanceof StructuredSelection) {

                         StructuredSelection structuredSelection = (StructuredSelection) selection;

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
index c3ba9f81..d718bb91 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.application.execution

 

+import com.google.inject.Injector

 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript

 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

@@ -24,7 +25,9 @@ import java.util.LinkedList
 import java.util.Optional

 import org.eclipse.core.runtime.IProgressMonitor

 import org.eclipse.emf.common.util.URI

+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor

 

+@FinalFieldsConstructor

 class GenerationTaskExecutor {

         val metamodelLoader = new MetamodelLoader

         val modelLoader = new ModelLoader

@@ -32,6 +35,7 @@ class GenerationTaskExecutor {
         val solverLoader = new SolverLoader

         val scopeLoader = new ScopeLoader

         val statisticsUtil = new StatisticSections2CSV

+        val Injector injector

         

         def executeGenerationTask(

                 GenerationTask task,

@@ -102,7 +106,7 @@ class GenerationTaskExecutor {
                         var domain2LogicTransformationTime = System.nanoTime

                         val Ecore2Logic ecore2Logic = new Ecore2Logic

                         val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)

-                        val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)

+                        val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic, injector)

                         val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic

                         

                         var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/PatternLanguageWithRSSetup.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/PatternLanguageWithRSSetup.xtend
index c209cde5..371f6f8c 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/PatternLanguageWithRSSetup.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/PatternLanguageWithRSSetup.xtend
@@ -1,11 +1,7 @@
 package hu.bme.mit.inf.dslreasoner.application.execution

 

-import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetupGenerated

-import com.google.inject.Injector

 import com.google.inject.Guice

-import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageRuntimeModule

-import com.google.inject.Guice;

-import com.google.inject.Injector;

+import com.google.inject.Injector

 import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup

 

 class PatternLanguageWithRSSetup extends EMFPatternLanguageStandaloneSetup{

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend
index 3dea677f..9d0985d2 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/ScriptExecutor.xtend
@@ -1,5 +1,7 @@
 package hu.bme.mit.inf.dslreasoner.application.execution

 

+import com.google.inject.Inject

+import com.google.inject.Injector

 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigReference

 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigSpecification

 import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript

@@ -33,11 +35,19 @@ import org.eclipse.core.runtime.jobs.Job
 import org.eclipse.emf.common.util.URI

 import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor

 

-@FinalFieldsConstructor

 class ScriptExecutor {

         val parser = new ApplicationConfigurationParser

         

         val ScriptConsole.Factory scriptConsoleFactory

+        val Injector injector

+        

+        @FinalFieldsConstructor

+        new() {

+        }

+        

+        new(ScriptConsole.Factory scriptConsoleFactory) {

+                this(scriptConsoleFactory, null)

+        }

         

         /**

          * Executes a script

@@ -101,7 +111,7 @@ class ScriptExecutor {
         }

         

         def dispatch void execute(GenerationTask task, IProgressMonitor monitor) {

-                val generationTaskExecutor = new GenerationTaskExecutor

+                val generationTaskExecutor = new GenerationTaskExecutor(injector)

                 generationTaskExecutor.executeGenerationTask(task,this,scriptConsoleFactory,monitor)

         }

         

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/start-standalone.launch b/Application/hu.bme.mit.inf.dslreasoner.application/start-standalone.launch
index 1f3744a7..437bc6e2 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/start-standalone.launch
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/start-standalone.launch
@@ -1,12 +1,15 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-<listEntry value="/hu.bme.mit.inf.dslreasoner.application/xtend-gen/hu/bme/mit/inf/dslreasoner/application/execution/StandaloneScriptExecutor.java"/>
-</listAttribute>
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
-<listEntry value="1"/>
-</listAttribute>
-<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="hu.bme.mit.inf.dslreasoner.application.execution.StandaloneScriptExecutor"/>
-<stringAttribute key="org.eclipse.jdt.launching.MODULE_NAME" value="hu.bme.mit.inf.dslreasoner.application"/>
-<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="hu.bme.mit.inf.dslreasoner.application"/>
+    <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+        <listEntry value="/hu.bme.mit.inf.dslreasoner.application/xtend-gen/hu/bme/mit/inf/dslreasoner/application/execution/StandaloneScriptExecutor.java"/>
+    </listAttribute>
+    <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+        <listEntry value="1"/>
+    </listAttribute>
+    <booleanAttribute key="org.eclipse.jdt.launching.ATTR_USE_CLASSPATH_ONLY_JAR" value="false"/>
+    <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="hu.bme.mit.inf.dslreasoner.application.execution.StandaloneScriptExecutor"/>
+    <stringAttribute key="org.eclipse.jdt.launching.MODULE_NAME" value="hu.bme.mit.inf.dslreasoner.application"/>
+    <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="EcoreGeneration.vsconfig"/>
+    <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="hu.bme.mit.inf.dslreasoner.application"/>
+    <stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${workspace_loc:Ecore-Plugin}"/>
 </launchConfiguration>
diff --git a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticHighlightCalculator.xtendbin b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticHighlightCalculator.xtendbin
index 0ccad2d7..a107bf27 100644
--- a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticHighlightCalculator.xtendbin
+++ b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticHighlightCalculator.xtendbin
diff --git a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticTextAttributeProvider.xtendbin b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticTextAttributeProvider.xtendbin
index 55a1bdd4..994dbd52 100644
--- a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticTextAttributeProvider.xtendbin
+++ b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/ui/syntaxcoloring/.SolverSemanticTextAttributeProvider.xtendbin
diff --git a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/validation/.SolverLanguageValidator.xtendbin b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/validation/.SolverLanguageValidator.xtendbin
index 1d870094..9839769e 100644
--- a/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/validation/.SolverLanguageValidator.xtendbin
+++ b/Application/org.eclipse.viatra.solver.language.ui/xtend-gen/org/eclipse/viatra/solver/language/validation/.SolverLanguageValidator.xtendbin
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin
index 1147f2ef..d2fd056e 100644
--- a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin
+++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin
index 8bb907a2..30cf1dbd 100644
--- a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin
+++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin
index 47306d9c..ddc8ea74 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin
index 809f268d..e89ea81c 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin
index 90f98dd6..e006abd7 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
index c9418b49..11227a1c 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin
index 437a84cc..90728c00 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
index 34c9b033..4625dcf2 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin
index 993f0f78..d74342ba 100644
--- a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Constraint2Logic.xtend b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Constraint2Logic.xtend
index b8c52af4..37fb81ae 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Constraint2Logic.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Constraint2Logic.xtend
@@ -1,5 +1,4 @@
 package hu.bme.mit.inf.dslreasoner.viatra2logic

-

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

@@ -17,27 +16,27 @@ import org.eclipse.emf.ecore.EStructuralFeature
 import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey

 import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey

 import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey

+import org.eclipse.viatra.query.runtime.matchers.aggregators.DoubleSumOperator

+import org.eclipse.viatra.query.runtime.matchers.aggregators.ExtremumOperator

+import org.eclipse.viatra.query.runtime.matchers.aggregators.ExtremumOperator.Extreme

+import org.eclipse.viatra.query.runtime.matchers.aggregators.IntegerSumOperator

+import org.eclipse.viatra.query.runtime.matchers.aggregators.LongSumOperator

 import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.AggregatorConstraint

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.AggregatorConstraint

-import org.eclipse.viatra.query.runtime.matchers.aggregators.DoubleSumOperator

-import org.eclipse.viatra.query.runtime.matchers.aggregators.IntegerSumOperator

-import org.eclipse.viatra.query.runtime.matchers.aggregators.LongSumOperator

-import org.eclipse.viatra.query.runtime.matchers.aggregators.ExtremumOperator

-import org.eclipse.viatra.query.runtime.matchers.aggregators.ExtremumOperator.Extreme

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation

 

 class Constraint2Logic {

         val extension LogicProblemBuilder builder = new LogicProblemBuilder

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2Logic.xtend b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2Logic.xtend
index 74e03f71..2f7febd0 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2Logic.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2Logic.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatra2logic

 

+import com.google.inject.Injector

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

@@ -50,7 +51,7 @@ class Viatra2LogicConfiguration {
         public var normalize = true

 }

 

-class  Viatra2Logic {

+class Viatra2Logic {

         val extension LogicProblemBuilder builder = new LogicProblemBuilder

         val extension Viatra2LogicAnnotationsFactory factory = Viatra2LogicAnnotationsFactory.eINSTANCE

         val normalizer = new PBodyNormalizer(EMFQueryMetaContext.DEFAULT)

@@ -59,12 +60,16 @@ class  Viatra2Logic {
         val Ecore2Logic ecore2Logic

         Constraint2Logic constraint2Logic

         

-        new(Ecore2Logic ecore2Logic) {

+        new(Ecore2Logic ecore2Logic, Injector injector) {

                 this.ecore2Logic = ecore2Logic

-                this.typeInferer = new Viatra2LogicTypeInferer(ecore2Logic)

+                this.typeInferer = new Viatra2LogicTypeInferer(ecore2Logic, injector)

                 this.constraint2Logic = new Constraint2Logic(ecore2Logic)

         }

         

+        new(Ecore2Logic ecore2Logic) {

+                this(ecore2Logic, null)

+        }

+        

         def TracedOutput<LogicProblem,Viatra2LogicTrace> transformQueries(

                 ViatraQuerySetDescriptor queries,

                 TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace,

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2LogicTypeInferer.xtend b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2LogicTypeInferer.xtend
index b8a6b9c1..1a96bf07 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2LogicTypeInferer.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.viatra2logic/src/hu/bme/mit/inf/dslreasoner/viatra2logic/Viatra2LogicTypeInferer.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatra2logic

 

+import com.google.inject.Injector

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

@@ -18,7 +19,6 @@ import java.util.Set
 import org.eclipse.emf.ecore.EEnum

 import org.eclipse.emf.ecore.EcorePackage

 import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup

-import org.eclipse.viatra.query.patternlanguage.emf.specification.XBaseEvaluator

 import org.eclipse.viatra.query.runtime.emf.EMFQueryMetaContext

 import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey

 import org.eclipse.viatra.query.runtime.emf.types.EClassUnscopedTransitiveInstancesKey

@@ -26,7 +26,6 @@ import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey
 import org.eclipse.viatra.query.runtime.matchers.context.IInputKey

 import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey

 import org.eclipse.viatra.query.runtime.matchers.planning.helpers.TypeHelper

-import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator

 import org.eclipse.viatra.query.runtime.matchers.psystem.PBody

 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.AggregatorConstraint

@@ -40,285 +39,275 @@ import org.eclipse.xtext.xbase.typesystem.IBatchTypeResolver
 import org.eclipse.xtext.xbase.typesystem.references.UnknownTypeReference

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import org.eclipse.xtext.xbase.typesystem.references.InnerTypeReference

 

-class Viatra2LogicTypeInferer{

+class Viatra2LogicTypeInferer {

         val Ecore2Logic ecore2Logic

         val extension LogicProblemBuilder builder = new LogicProblemBuilder

         /**Typeresolver uses the same resolver as EMFPatternLanguageStandaloneSetup.*/

-        val IBatchTypeResolver typeResolver = 

-                (new EMFPatternLanguageStandaloneSetup).createInjector.getInstance(IBatchTypeResolver)

+        val IBatchTypeResolver typeResolver

         val expressionExtractor = new XExpressionExtractor

-        

-        new(Ecore2Logic ecore2Logic) {

+

+        new(Ecore2Logic ecore2Logic, Injector injector) {

                 this.ecore2Logic = ecore2Logic

+                val selectedInjector = injector ?:

+                        new EMFPatternLanguageStandaloneSetup().createStandaloneInjectorWithSeparateModules

+                this.typeResolver = selectedInjector.getInstance(IBatchTypeResolver)

+        }

+

+        new(Ecore2Logic ecore2Logic) {

+                this(ecore2Logic, null)

         }

-        

-        def Viatra2LogicTypeResult inferTypes(List<PQuery> pQueries, TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace, Viatra2LogicTrace viatra2LogicTrace) {

-                val Viatra2LogicTypeResult result = new Viatra2LogicTypeResult(new HashMap,new HashMap);

-                for(query : pQueries) {

-                        for(body: query.lookup(viatra2LogicTrace.query2Disjunction).bodies) {

-                                for(variable : body.uniqueVariables) {

-                                        getOrMakeTypeDecision(result,variable,body,ecore2LogicTrace,viatra2LogicTrace,emptySet)

+

+        def Viatra2LogicTypeResult inferTypes(List<PQuery> pQueries,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace, Viatra2LogicTrace viatra2LogicTrace) {

+                val Viatra2LogicTypeResult result = new Viatra2LogicTypeResult(new HashMap, new HashMap);

+                for (query : pQueries) {

+                        for (body : query.lookup(viatra2LogicTrace.query2Disjunction).bodies) {

+                                for (variable : body.uniqueVariables) {

+                                        getOrMakeTypeDecision(result, variable, body, ecore2LogicTrace, viatra2LogicTrace, emptySet)

                                 }

                         }

-                        for(parameter: query.parameters) {

-                                getOrMakeTypeDecision(result,query,parameter,ecore2LogicTrace,viatra2LogicTrace,emptySet)

+                        for (parameter : query.parameters) {

+                                getOrMakeTypeDecision(result, query, parameter, ecore2LogicTrace, viatra2LogicTrace, emptySet)

                         }

                 }

                 return result

         }

-        

-        private def TypeReference getOrMakeTypeDecision(

-                Viatra2LogicTypeResult result,

-                PVariable variable, PBody body,

-                TracedOutput<LogicProblem,  Ecore2Logic_Trace> ecore2LogicTrace,

-                Viatra2LogicTrace viatra2LogicTrace,

-                Set<? extends PParameter> checkedInDecisionMaking)

-        {

-                if(result.containsSolution(body,variable)) {

-                        return result.getType(body,variable)

+

+        private def TypeReference getOrMakeTypeDecision(Viatra2LogicTypeResult result, PVariable variable, PBody body,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace, Viatra2LogicTrace viatra2LogicTrace,

+                Set<? extends PParameter> checkedInDecisionMaking) {

+                if (result.containsSolution(body, variable)) {

+                        return result.getType(body, variable)

                 } else {

-                        val inferredTypesByViatra = TypeHelper::inferUnaryTypesFor(body.uniqueVariables, body.constraints, EMFQueryMetaContext.DEFAULT)

+                        val inferredTypesByViatra = TypeHelper::inferUnaryTypesFor(body.uniqueVariables, body.constraints,

+                                EMFQueryMetaContext.DEFAULT)

                         val constraintsForVariable = variable.lookup(inferredTypesByViatra)

-                        

-                        val typeConstraintsDerivedByTypeHelper = constraintsForVariable.map[transformTypeReference(ecore2LogicTrace)]

+

+                        val typeConstraintsDerivedByTypeHelper = constraintsForVariable.map [

+                                transformTypeReference(ecore2LogicTrace)

+                        ]

                         val typesFromEval = variable.getTypesFromEval(typeResolver)

-                        val typesFromAggregatorResult = variable.getTypeFromPassivePatternCallConstraintResult(

-                                result,

-                                ecore2LogicTrace,

-                                viatra2LogicTrace,

-                                checkedInDecisionMaking)

-                                 

-                        val typesFromPositiveReasoning = (typeConstraintsDerivedByTypeHelper + typesFromEval + typesFromAggregatorResult).filterNull

-                        

-                        val types = if(!typesFromPositiveReasoning.empty) {

-                                typesFromPositiveReasoning

-                        } else {

-                                variable.getTypeFromPassivePatternCallConstraints(

-                                        result,

-                                        ecore2LogicTrace,

-                                        viatra2LogicTrace,

+                        val typesFromAggregatorResult = variable.

+                                getTypeFromPassivePatternCallConstraintResult(result, ecore2LogicTrace, viatra2LogicTrace,

                                         checkedInDecisionMaking)

-                        }

-                        

+

+                        val typesFromPositiveReasoning = (typeConstraintsDerivedByTypeHelper + typesFromEval +

+                                typesFromAggregatorResult).filterNull

+

+                        val types = if (!typesFromPositiveReasoning.empty) {

+                                        typesFromPositiveReasoning

+                                } else {

+                                        variable.getTypeFromPassivePatternCallConstraints(result, ecore2LogicTrace, viatra2LogicTrace,

+                                                checkedInDecisionMaking)

+                                }

+

                         val commonSubtype = this.calculateCommonSubtype(types)

-                        

-                        result.addType(body,variable,commonSubtype)

+

+                        result.addType(body, variable, commonSubtype)

                         return commonSubtype

                 }

         }

 

-        private def TypeReference getOrMakeTypeDecision(

-                Viatra2LogicTypeResult result,

-                PQuery query,

-                PParameter parameter,

-                TracedOutput<LogicProblem,  Ecore2Logic_Trace> ecore2LogicTrace,

-                Viatra2LogicTrace viatra2LogicTrace,

-                Set<? extends PParameter> checkedInDecisionMaking)

-        {

-                if(checkedInDecisionMaking.contains(parameter)) {

+        private def TypeReference getOrMakeTypeDecision(Viatra2LogicTypeResult result, PQuery query, PParameter parameter,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace, Viatra2LogicTrace viatra2LogicTrace,

+                Set<? extends PParameter> checkedInDecisionMaking) {

+                if (checkedInDecisionMaking.contains(parameter)) {

                         return null

                 }

-                if(result.containsSolution(parameter)) {

+                if (result.containsSolution(parameter)) {

                         return result.getType(query, parameter)

                 }

-                

+

                 var TypeReference typeReference;

-                

-                if(parameter.declaredUnaryType !== null) {

-                         val key = parameter.declaredUnaryType

-                         typeReference = key.transformTypeReference(ecore2LogicTrace)

+

+                if (parameter.declaredUnaryType !== null) {

+                        val key = parameter.declaredUnaryType

+                        typeReference = key.transformTypeReference(ecore2LogicTrace)

                 } else {

                         val bodies = query.lookup(viatra2LogicTrace.query2Disjunction).bodies

                         val newChecked = new HashSet(checkedInDecisionMaking) => [add(parameter)]

-                        val Iterable<TypeReference> variableTypes = bodies.map[body|

+                        val Iterable<TypeReference> variableTypes = bodies.map [ body |

                                 val symbolicParameter = body.symbolicParameters.filter[patternParameter === parameter].head

                                 val variable = symbolicParameter.parameterVariable

-                                getOrMakeTypeDecision(result,variable,body,ecore2LogicTrace,viatra2LogicTrace,newChecked)

+                                getOrMakeTypeDecision(result, variable, body, ecore2LogicTrace, viatra2LogicTrace, newChecked)

                         ]

                         typeReference = calculateCommonSupertype(variableTypes)

                 }

-                result.addType(query,parameter,typeReference)

+                result.addType(query, parameter, typeReference)

                 return typeReference

         }

-        

+

         private def Iterable<? extends TypeReference> getTypesFromEval(PVariable v, IBatchTypeResolver typeResolver) {

                 val constraints = v.getReferringConstraintsOfType(

                         typeof(ExpressionEvaluation)

-                ).filter[

+                ).filter [

                         it.outputVariable === v

                 ]

                 val res = constraints.map[getTypeFromEval]

                 return res

         }

-        

+

         def TypeReference getTypeFromEval(ExpressionEvaluation evaluation) {

                 val XExpression expression = expressionExtractor.extractExpression(evaluation.evaluator)

                 val returnType = typeResolver.resolveTypes(expression).getReturnType(expression);

-                if(returnType === null || returnType instanceof UnknownTypeReference) {

+                if (returnType === null || returnType instanceof UnknownTypeReference) {

                         return null

                 } else {

                         val javaIdentifier = returnType.wrapperTypeIfPrimitive.javaIdentifier

-                        if(javaIdentifier == Boolean.name) {

+                        if (javaIdentifier == Boolean.name) {

                                 return LogicBool

-                        } else if(javaIdentifier == Integer.name || javaIdentifier == Short.name) {

+                        } else if (javaIdentifier == Integer.name || javaIdentifier == Short.name) {

                                 return LogicInt

-                        } else if(javaIdentifier == Double.name || javaIdentifier == Float.name){

+                        } else if (javaIdentifier == Double.name || javaIdentifier == Float.name) {

                                 return LogicReal

-                        } else if(javaIdentifier == String.name) {

+                        } else if (javaIdentifier == String.name) {

                                 return LogicString

                         } else {

                                 throw new UnsupportedOperationException('''Unsupported eval type: "«javaIdentifier»"!''')

                         }

                 }

         }

-        

+

         private def getTypeFromPassivePatternCallConstraintResult(

                 PVariable v,

                 Viatra2LogicTypeResult result,

-                TracedOutput<LogicProblem,  Ecore2Logic_Trace> ecore2LogicTrace,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace,

                 Viatra2LogicTrace viatra2LogicTrace,

                 Set<? extends PParameter> checkedInDecisionMaking

         ) {

                 val referringConstraints = v.referringConstraints

-                

-                val referringCountMatcherTargeting = referringConstraints

-                        .filter(PatternMatchCounter)

-                        .filter[it.resultVariable === v]

-                        .map[builder.LogicInt]

-                val referringAggregatorConstraintsTargeting = referringConstraints

-                        .filter(AggregatorConstraint)

-                        .filter[it.resultVariable === v]

-                        .map[ // get the type of the referred column

-                                getOrMakeTypeDecision(

-                                        result,

-                                        it.referredQuery,

-                                        it.referredQuery.parameters.get(aggregatedColumn),

-                                        ecore2LogicTrace,

-                                        viatra2LogicTrace,

-                                        checkedInDecisionMaking)]

-                                        

+

+                val referringCountMatcherTargeting = referringConstraints.filter(PatternMatchCounter).filter [

+                        it.resultVariable === v

+                ].map[builder.LogicInt]

+                val referringAggregatorConstraintsTargeting = referringConstraints.filter(AggregatorConstraint).filter [

+                        it.resultVariable === v

+                ].map [ // get the type of the referred column

+                        getOrMakeTypeDecision(result, it.referredQuery, it.referredQuery.parameters.get(aggregatedColumn),

+                                ecore2LogicTrace, viatra2LogicTrace, checkedInDecisionMaking)

+                ]

+

                 return referringCountMatcherTargeting + referringAggregatorConstraintsTargeting

         }

-        

+

         private def getTypeFromPassivePatternCallConstraints(

                 PVariable v,

                 Viatra2LogicTypeResult result,

-                TracedOutput<LogicProblem,  Ecore2Logic_Trace> ecore2LogicTrace,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace,

                 Viatra2LogicTrace viatra2LogicTrace,

                 Set<? extends PParameter> checkedInDecisionMaking

         ) {

                 val referringConstraints = v.referringConstraints

-                if(referringConstraints.size === 1) {

+                if (referringConstraints.size === 1) {

                         val onlyConstraint = referringConstraints.head

-                        

-                        if(onlyConstraint instanceof PatternCallBasedDeferred) {

+

+                        if (onlyConstraint instanceof PatternCallBasedDeferred) {

                                 val indexOfVariable = v.lookup(onlyConstraint.actualParametersTuple.invertIndex)

                                 val parameter = onlyConstraint.referredQuery.parameters.get(indexOfVariable)

-                                val res = getOrMakeTypeDecision(result, onlyConstraint.referredQuery, parameter, ecore2LogicTrace,viatra2LogicTrace,checkedInDecisionMaking)

+                                val res = getOrMakeTypeDecision(result, onlyConstraint.referredQuery, parameter, ecore2LogicTrace,

+                                        viatra2LogicTrace, checkedInDecisionMaking)

                                 return #[res]

                         } else {

                                 throw new IllegalArgumentException('''A non-PatternCallBasedDeferred type constraint is referring to the variable "«v.name»"!''')

                         }

                 } else {

-                        throw new IllegalArgumentException('''Multiple («referringConstraints.size», «FOR c:referringConstraints SEPARATOR ", "»«c»«ENDFOR») constraints are referring to variable "«v.name»", but no type is inferred!''')

+                        throw new IllegalArgumentException('''Multiple («referringConstraints.size», «FOR c : referringConstraints SEPARATOR ", "»«c»«ENDFOR») constraints are referring to variable "«v.name»", but no type is inferred!''')

                 }

         }

-        

+

         def TypeReference calculateCommonSubtype(Iterable<TypeReference> types) {

                 val primitiveTypeReferences = types.filter(PrimitiveTypeReference)

                 val complexTypeReferences = types.filter(ComplexTypeReference)

-                if(complexTypeReferences.isEmpty) {

+                if (complexTypeReferences.isEmpty) {

                         // If there is an int type, ...

-                        if(primitiveTypeReferences.exists[it instanceof IntTypeReference]) {

+                        if (primitiveTypeReferences.exists[it instanceof IntTypeReference]) {

                                 // ... and all types are either real or int, then return int!

-                                if(primitiveTypeReferences.forall[it instanceof RealTypeReference || it instanceof IntTypeReference]) {

+                                if (primitiveTypeReferences.forall[it instanceof RealTypeReference || it instanceof IntTypeReference]) {

                                         return primitiveTypeReferences.filter(IntTypeReference).head

-                                }

-                                // Otherwise, the types are inconsistent, because they mixing numeric and non-numeric types.

-                                else throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

+                                } // Otherwise, the types are inconsistent, because they mixing numeric and non-numeric types.

+                                else

+                                        throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

                         }

                         // If there is no Real, then the types should be homogenious

                         val head = primitiveTypeReferences.head

-                        if(primitiveTypeReferences.exists[it.eClass !== head.eClass]) {

+                        if (primitiveTypeReferences.exists[it.eClass !== head.eClass]) {

                                 throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

                         }

                         return head

-                } else if(primitiveTypeReferences.isEmpty) {

+                } else if (primitiveTypeReferences.isEmpty) {

                         val complexTypes = complexTypeReferences.map[it.referred].toSet

-                        if(complexTypes.size === 1) {

+                        if (complexTypes.size === 1) {

                                 return builder.toTypeReference(complexTypes.head)

                         }

                         // Collect possible subtypes

                         val subtypeSets = complexTypes.map[it.transitiveClosureStar[it.subtypes].toSet]

                         val commonTypeSet = new HashSet(subtypeSets.head)

                         val otherSets = subtypeSets.tail

-                        for(otherSet : otherSets) {

+                        for (otherSet : otherSets) {

                                 commonTypeSet.retainAll(otherSet)

                         }

-                        if(commonTypeSet.empty) {

+                        if (commonTypeSet.empty) {

                                 throw new IllegalArgumentException('''Inconsistent types: «complexTypes.map[name].toList»''')

                         }

-                        

-                        

+

                         return calculateCommonComplexSupertype(commonTypeSet)

-                        

+

                 } else {

                         throw new IllegalArgumentException('''

                         Inconsistent types, mixing primitive and complex types:

                                 «primitiveTypeReferences.map[eClass.name].toSet.toList»

                                         and

                                 «complexTypeReferences.map[it.referred].toSet.map[name].toList»''')

-                        

+

                 }

         }

-        

-        

+

         def TypeReference calculateCommonSupertype(Iterable<TypeReference> types) {

                 val primitiveTypeReferences = types.filter(PrimitiveTypeReference)

                 val complexTypeReferences = types.filter(ComplexTypeReference)

-                if(complexTypeReferences.isEmpty) {

+                if (complexTypeReferences.isEmpty) {

                         // If there is a real type, ...

-                        if(primitiveTypeReferences.exists[it instanceof RealTypeReference]) {

+                        if (primitiveTypeReferences.exists[it instanceof RealTypeReference]) {

                                 // ... and all types are either real or int, then return real!

-                                if(primitiveTypeReferences.forall[it instanceof RealTypeReference || it instanceof IntTypeReference]) {

+                                if (primitiveTypeReferences.forall[it instanceof RealTypeReference || it instanceof IntTypeReference]) {

                                         return primitiveTypeReferences.filter(RealTypeReference).head

-                                }

-                                // Otherwise, the types are inconsistent, because they mixing numeric and non-numeric types.

-                                else throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

+                                } // Otherwise, the types are inconsistent, because they mixing numeric and non-numeric types.

+                                else

+                                        throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

                         }

                         // If there is no Real, then the types should be homogenious

                         val head = primitiveTypeReferences.head

-                        if(primitiveTypeReferences.exists[it.eClass !== head.eClass]) {

+                        if (primitiveTypeReferences.exists[it.eClass !== head.eClass]) {

                                 throw new IllegalArgumentException('''Inconsistent types: «primitiveTypeReferences.map[eClass.name].toSet.toList»''')

                         }

                         return head

-                } else if(primitiveTypeReferences.isEmpty) {

+                } else if (primitiveTypeReferences.isEmpty) {

                         val complexTypes = complexTypeReferences.map[it.referred].toSet

                         return calculateCommonComplexSupertype(complexTypes)

-                        

+

                 } else {

                         throw new IllegalArgumentException('''

                         Inconsistent types, mixing primitive and complex types:

                                 «primitiveTypeReferences.map[eClass.name].toSet.toList»

                                         and

                                 «complexTypeReferences.map[it.referred].toSet.map[name].toList»''')

-                        

+

                 }

         }

+

         def TypeReference calculateCommonComplexSupertype(Set<Type> complexTypes) {

-                if(complexTypes.size === 1) {

+                if (complexTypes.size === 1) {

                         return builder.toTypeReference(complexTypes.head)

                 }

                 // Collect possible supertypes

                 val supertypeSets = complexTypes.map[it.transitiveClosureStar[it.supertypes].toSet]

                 val commonTypeSet = new HashSet(supertypeSets.head)

                 val otherSets = supertypeSets.tail

-                for(otherSet : otherSets) {

+                for (otherSet : otherSets) {

                         commonTypeSet.retainAll(otherSet)

                 }

-                if(commonTypeSet.empty) {

+                if (commonTypeSet.empty) {

                         throw new IllegalArgumentException('''Inconsistent types: «complexTypes.map[name].toList»''')

                 }

                 // Remove type that already have covered

@@ -326,40 +315,44 @@ class Viatra2LogicTypeInferer{
                 commonTypeSet.removeAll(coveredTypes)

                 return builder.toTypeReference(commonTypeSet.head)

         }

-        

+

         /**

          * Transforms a Viatra type reference to a logic type.

          */

-        def dispatch TypeReference transformTypeReference(EDataTypeInSlotsKey k,TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

-                val w = k.wrappedKey 

-                if(w == EcorePackage.Literals.EINT || w == EcorePackage.Literals.ESHORT || w == EcorePackage.Literals.ELONG) {

+        def dispatch TypeReference transformTypeReference(EDataTypeInSlotsKey k,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

+                val w = k.wrappedKey

+                if (w == EcorePackage.Literals.EINT || w == EcorePackage.Literals.ESHORT || w == EcorePackage.Literals.ELONG) {

                         return builder.LogicInt

-                } else if(w == EcorePackage.Literals.EDOUBLE || w == EcorePackage.Literals.EFLOAT) {

+                } else if (w == EcorePackage.Literals.EDOUBLE || w == EcorePackage.Literals.EFLOAT) {

                         return builder.LogicReal

-                } else if(w == EcorePackage.Literals.EBOOLEAN) {

+                } else if (w == EcorePackage.Literals.EBOOLEAN) {

                         return builder.LogicBool

-                } else if(w == EcorePackage.Literals.ESTRING) {

+                } else if (w == EcorePackage.Literals.ESTRING) {

                         return builder.LogicString

-                } else if(w instanceof EEnum) {

-                        val c = this.ecore2Logic.TypeofEEnum(ecore2LogicTrace.trace,w)

+                } else if (w instanceof EEnum) {

+                        val c = this.ecore2Logic.TypeofEEnum(ecore2LogicTrace.trace, w)

                         return builder.toTypeReference(c);

-                } else throw new UnsupportedOperationException('''Unknown reference type «w.class.name»''')

+                } else

+                        throw new UnsupportedOperationException('''Unknown reference type «w.class.name»''')

         }

-        def dispatch TypeReference transformTypeReference(JavaTransitiveInstancesKey k,TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

+

+        def dispatch TypeReference transformTypeReference(JavaTransitiveInstancesKey k,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

                 val c = k.wrapperInstanceClass

-                if(c == Integer || c == Long || c == Short) {

+                if (c == Integer || c == Long || c == Short) {

                         return LogicInt

-                } else if(c == Float || c == Double) {

+                } else if (c == Float || c == Double) {

                         return LogicReal

-                } else if(c == Boolean) {

+                } else if (c == Boolean) {

                         return LogicBool

-                } else if(c == String) {

+                } else if (c == String) {

                         return LogicString

-                } else if(c.superclass == Enum){

+                } else if (c.superclass == Enum) {

                         val enums = ecore2Logic.allEnumsInScope(ecore2LogicTrace.trace)

-                        for(enum : enums) {

-                                if(c == enum.instanceClass) {

-                                        return builder.toTypeReference(ecore2Logic.TypeofEEnum(ecore2LogicTrace.trace,enum))

+                        for (enum : enums) {

+                                if (c == enum.instanceClass) {

+                                        return builder.toTypeReference(ecore2Logic.TypeofEEnum(ecore2LogicTrace.trace, enum))

                                 }

                         }

                         throw new IllegalArgumentException('''Enum type «c.simpleName» is not mapped to logic!''')

@@ -367,26 +360,31 @@ class Viatra2LogicTypeInferer{
                         return null

                 }

         }

-        def dispatch TypeReference transformTypeReference(EClassTransitiveInstancesKey k,TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

+

+        def dispatch TypeReference transformTypeReference(EClassTransitiveInstancesKey k,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

                 val c = k.wrappedKey

-                                

-                if(this.ecore2Logic.allClassesInScope(ecore2LogicTrace.trace).toList.contains(c)) {

-                        return builder.toTypeReference(this.ecore2Logic.TypeofEClass(ecore2LogicTrace.trace,k.wrappedKey))

+

+                if (this.ecore2Logic.allClassesInScope(ecore2LogicTrace.trace).toList.contains(c)) {

+                        return builder.toTypeReference(this.ecore2Logic.TypeofEClass(ecore2LogicTrace.trace, k.wrappedKey))

                 } else {

                         return null

                 }

         }

-        def dispatch TypeReference transformTypeReference(EClassUnscopedTransitiveInstancesKey k, TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

+

+        def dispatch TypeReference transformTypeReference(EClassUnscopedTransitiveInstancesKey k,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

                 val c = k.wrappedKey

-                

-                if(this.ecore2Logic.allClassesInScope(ecore2LogicTrace.trace).toList.contains(c)) {

-                        return builder.toTypeReference(this.ecore2Logic.TypeofEClass(ecore2LogicTrace.trace,k.wrappedKey))

+

+                if (this.ecore2Logic.allClassesInScope(ecore2LogicTrace.trace).toList.contains(c)) {

+                        return builder.toTypeReference(this.ecore2Logic.TypeofEClass(ecore2LogicTrace.trace, k.wrappedKey))

                 } else {

                         return null

                 }

         }

-        

-        def dispatch TypeReference transformTypeReference(IInputKey k,TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

+

+        def dispatch TypeReference transformTypeReference(IInputKey k,

+                TracedOutput<LogicProblem, Ecore2Logic_Trace> ecore2LogicTrace) {

                 throw new IllegalArgumentException('''Unsupported type: «k.class.simpleName»''')

         }

-}
\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
index 26ec7091..69b54b8a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
@@ -6,7 +6,6 @@ import com.google.inject.Inject
 import com.google.inject.Injector

 import com.google.inject.multibindings.Multibinder

 import com.google.inject.name.Names

-import com.google.inject.util.Modules

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage

@@ -46,7 +45,6 @@ import org.eclipse.xtext.scoping.IScope
 import org.eclipse.xtext.scoping.IScopeProvider

 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider

 import org.eclipse.xtext.scoping.impl.SimpleScope

-import org.eclipse.xtext.service.AbstractGenericModule

 import org.eclipse.xtext.service.SingletonBinding

 import org.eclipse.xtext.workspace.IProjectConfigProvider

 

@@ -65,35 +63,32 @@ package class StandaloneParserWithFixedMetamodelProviderModule extends Standalon
                 Multibinder::newSetBinder(binder, IMetamodelProviderInstance);

         }

 

-}

-

-package class StandaloneParserOverridesModule extends AbstractGenericModule {

-

-        def Class<? extends IMetamodelProvider> bindIMetamodelProvider() {

+        @SingletonBinding

+        override IResourceServiceProvider.Registry bindIResourceServiceProvider$Registry() {

+                new VqlDeactivatedServiceProviderRegistry

+        }

+        

+        override Class<? extends IMetamodelProvider> bindIMetamodelProvider() {

                 FixedMetamodelProvider

         }

 

-        def Class<? extends IProjectConfigProvider> bindProjectConfigProvider() {

+        override Class<? extends IProjectConfigProvider> bindProjectConfigProvider() {

                 NullProjectConfigProvider

         }

 

         @SingletonBinding

-        def Class<? extends IResourceServiceProvider.Registry> bindIResourceServiceProvider$Registry() {

-                VqlDeactivatedServiceProviderRegistry

-        }

-

-        def EValidator.Registry bindEValidator$Registry() {

+        override EValidator.Registry bindEValidatorRegistry() {

                 // org.eclipse.xtext.validation.EValidatorRegistrar modifies EValidators already in the registry,

                 // so it is not safe to populate the registry from the EValidator.Registry.INSTANCE singleton.

                 // There is no need to execute any EValiator other than EMFPatternLanguageValidator,

                 // so we can start with a blank registry instead.

-                new EValidatorRegistryImpl()

+                new EValidatorRegistryImpl

         }

 

-        def EPackage.Registry bindEPackage$Registry() {

+        @SingletonBinding

+        override EPackage.Registry bindEPackageRegistry() {

                 new EPackageRegistryImpl(EPackage.Registry.INSTANCE)

         }

-

 }

 

 package class NullProjectConfigProvider implements IProjectConfigProvider {

@@ -136,10 +131,8 @@ class ParseUtil {
 

         def protected Injector internalCreateInjector() {

                 ensureViatraInitialized();

-                val runtimeModulemodule = new StandaloneParserWithFixedMetamodelProviderModule

-                val overridesModule = new StandaloneParserOverridesModule

-                val module = Modules.override(runtimeModulemodule).with(overridesModule)

-                val newInjector = Guice.createInjector(module)

+                val runtimeModule = new StandaloneParserWithFixedMetamodelProviderModule

+                val newInjector = Guice.createInjector(runtimeModule)

                 return newInjector

         }