Changeset 3c46939 in OpenModelica

Timestamp:

2020-10-21T14:46:11+02:00 (3 years ago)

Author:

Adrian Pop <adrian.pop@…>

Children:

8dbe6e6

Parents:

feadc57b

git-author:

Adrian Pop <adrian.pop@…> (10/09/20 15:08:54)

git-committer:

Adrian Pop <adrian.pop@…> (10/21/20 14:46:11)

Message:

remove unqualified import

File:

• OMCompiler/Compiler/FrontEnd/AbsynUtil.mo (modified) (351 diffs)

OMCompiler/Compiler/FrontEnd/AbsynUtil.mo

@@ -32 +32 @@
 encapsulated package AbsynUtil
 
-protected import Absyn.*;
+protected import Absyn;
 protected import Dump;
 protected import Error;
@@ -39 +39 @@
 protected import Util;
 
-public constant ClassDef dummyParts = PARTS({},{},{},{},NONE());
-public constant Info dummyInfo = SOURCEINFO("",false,0,0,0,0,0.0);
-public constant Program dummyProgram = PROGRAM({},TOP());
+public constant Absyn.ClassDef dummyParts = Absyn.PARTS({},{},{},{},NONE());
+public constant Absyn.Info dummyInfo = SOURCEINFO("",false,0,0,0,0,0.0);
+public constant Absyn.Program dummyProgram = Absyn.PROGRAM({},Absyn.TOP());
 
 replaceable type TypeA subtypeof Any;
@@ -52 +52 @@
   "Traverses all subequations of an equation.
    Takes a function and an extra argument passed through the traversal"
-  input Equation inEquation;
+  input Absyn.Equation inEquation;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<Equation, TypeA> outTpl;
+  output tuple<Absyn.Equation, TypeA> outTpl;
 
   partial function FuncTplToTpl
-    input tuple<Equation, TypeA> inTpl;
-    output tuple<Equation, TypeA> outTpl;
+    input tuple<Absyn.Equation, TypeA> inTpl;
+    output tuple<Absyn.Equation, TypeA> outTpl;
   end FuncTplToTpl;
 
@@ -66 +66 @@
     local
       TypeA arg,arg_1,arg_2,arg_3,arg_4;
-      Equation eq,eq_1;
+      Absyn.Equation eq,eq_1;
       FuncTplToTpl rel;
-      Exp e,e_1;
-      list<EquationItem> eqilst,eqilst1,eqilst2,eqilst_1,eqilst1_1,eqilst2_1;
-      list<tuple<Exp, list<EquationItem>>> eeqitlst,eeqitlst_1;
-      ForIterators fis,fis_1;
-      EquationItem ei,ei_1;
-    case(eq as EQ_IF(e,eqilst1,eeqitlst,eqilst2),rel,arg)
+      Absyn.Exp e,e_1;
+      list<Absyn.EquationItem> eqilst,eqilst1,eqilst2,eqilst_1,eqilst1_1,eqilst2_1;
+      list<tuple<Absyn.Exp, list<Absyn.EquationItem>>> eeqitlst,eeqitlst_1;
+      Absyn.ForIterators fis,fis_1;
+      Absyn.EquationItem ei,ei_1;
+    case(eq as Absyn.EQ_IF(e,eqilst1,eeqitlst,eqilst2),rel,arg)
       equation
         ((eqilst1_1,arg_1)) = traverseEquationItemList(eqilst1,rel,arg);
         ((eeqitlst_1,arg_2)) = traverseExpEqItemTupleList(eeqitlst,rel,arg_1);
         ((eqilst2_1,arg_3)) = traverseEquationItemList(eqilst2,rel,arg_2);
-        ((EQ_IF(),arg_4)) = rel((eq,arg_3));
-      then
-        ((EQ_IF(e,eqilst1_1,eeqitlst_1,eqilst2_1),arg_4));
-    case(eq as EQ_FOR(_,eqilst),rel,arg)
+        ((Absyn.EQ_IF(),arg_4)) = rel((eq,arg_3));
+      then
+        ((Absyn.EQ_IF(e,eqilst1_1,eeqitlst_1,eqilst2_1),arg_4));
+    case(eq as Absyn.EQ_FOR(_,eqilst),rel,arg)
       equation
         ((eqilst_1,arg_1)) = traverseEquationItemList(eqilst,rel,arg);
-        ((EQ_FOR(fis_1,_),arg_2)) = rel((eq,arg_1));
-      then
-        ((EQ_FOR(fis_1,eqilst_1),arg_2));
-    case(eq as EQ_WHEN_E(_,eqilst,eeqitlst),rel,arg)
+        ((Absyn.EQ_FOR(fis_1,_),arg_2)) = rel((eq,arg_1));
+      then
+        ((Absyn.EQ_FOR(fis_1,eqilst_1),arg_2));
+    case(eq as Absyn.EQ_WHEN_E(_,eqilst,eeqitlst),rel,arg)
       equation
         ((eqilst_1,arg_1)) = traverseEquationItemList(eqilst,rel,arg);
         ((eeqitlst_1,arg_2)) = traverseExpEqItemTupleList(eeqitlst,rel,arg_1);
-        ((EQ_WHEN_E(e_1,_,_),arg_3)) = rel((eq,arg_2));
-      then
-        ((EQ_WHEN_E(e_1,eqilst_1,eeqitlst_1),arg_3));
-    case(eq as EQ_FAILURE(ei),rel,arg)
+        ((Absyn.EQ_WHEN_E(e_1,_,_),arg_3)) = rel((eq,arg_2));
+      then
+        ((Absyn.EQ_WHEN_E(e_1,eqilst_1,eeqitlst_1),arg_3));
+    case(eq as Absyn.EQ_FAILURE(ei),rel,arg)
       equation
         ((ei_1,arg_1)) = traverseEquationItem(ei,rel,arg);
-        ((EQ_FAILURE(),arg_2)) = rel((eq,arg_1));
-      then
-        ((EQ_FAILURE(ei_1),arg_2));
+        ((Absyn.EQ_FAILURE(),arg_2)) = rel((eq,arg_1));
+      then
+        ((Absyn.EQ_FAILURE(ei_1),arg_2));
     case(eq,rel,arg)
       equation
@@ -111 +111 @@
 protected function traverseEquationItem
 "Traverses the equation inside an equationitem"
-  input EquationItem inEquationItem;
+  input Absyn.EquationItem inEquationItem;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<EquationItem, TypeA> outTpl;
+  output tuple<Absyn.EquationItem, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Equation, TypeA> inTpl;
-    output tuple<Equation, TypeA> outTpl;
+    input tuple<Absyn.Equation, TypeA> inTpl;
+    output tuple<Absyn.Equation, TypeA> outTpl;
   end FuncTplToTpl;
 algorithm
   outTpl := matchcontinue (inEquationItem,inFunc,inTypeA)
     local
-      EquationItem ei;
+      Absyn.EquationItem ei;
       FuncTplToTpl rel;
       TypeA arg,arg_1;
-      Equation eq,eq_1;
-      Option<Comment> oc;
-      Info info;
-    case(EQUATIONITEM(eq,oc,info),rel,arg)
+      Absyn.Equation eq,eq_1;
+      Option<Absyn.Comment> oc;
+      Absyn.Info info;
+    case(Absyn.EQUATIONITEM(eq,oc,info),rel,arg)
       equation
         ((eq_1,arg_1)) = traverseEquation(eq,rel,arg);
       then
-        ((EQUATIONITEM(eq_1,oc,info),arg_1));
+        ((Absyn.EQUATIONITEM(eq_1,oc,info),arg_1));
     case(ei,_,arg) then ((ei,arg));
   end matchcontinue;
@@ -140 +140 @@
 public function traverseEquationItemList
 "calls traverseEquationItem on every element of the given list"
-  input list<EquationItem> inEquationItemList;
+  input list<Absyn.EquationItem> inEquationItemList;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<list<EquationItem>, TypeA> outTpl;
+  output tuple<list<Absyn.EquationItem>, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Equation, TypeA> inTpl;
-    output tuple<Equation, TypeA> outTpl;
+    input tuple<Absyn.Equation, TypeA> inTpl;
+    output tuple<Absyn.Equation, TypeA> outTpl;
   end FuncTplToTpl;
 protected
@@ -153 +153 @@
   outTpl := (list(match el
       local
-        EquationItem ei,ei_1;
+        Absyn.EquationItem ei,ei_1;
       case (ei) equation
         ((ei_1,arg2)) = traverseEquationItem(ei,inFunc,arg2);
@@ -162 +162 @@
 // stefan
 public function traverseExpEqItemTupleList
-"traverses a list of Exp * EquationItem list tuples
+"traverses a list of Absyn.Exp * Absyn.EquationItem list tuples
   mostly used for else-if blocks"
-  input list<tuple<Exp, list<EquationItem>>> inList;
+  input list<tuple<Absyn.Exp, list<Absyn.EquationItem>>> inList;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<list<tuple<Exp, list<EquationItem>>>, TypeA> outTpl;
+  output tuple<list<tuple<Absyn.Exp, list<Absyn.EquationItem>>>, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Equation, TypeA> inTpl;
-    output tuple<Equation, TypeA> outTpl;
+    input tuple<Absyn.Equation, TypeA> inTpl;
+    output tuple<Absyn.Equation, TypeA> outTpl;
   end FuncTplToTpl;
 protected
@@ -177 +177 @@
   outTpl := (list(match el
       local
-        Exp e;
-        list<EquationItem> eilst,eilst_1;
+        Absyn.Exp e;
+        list<Absyn.EquationItem> eilst,eilst_1;
       case (e,eilst) equation
         ((eilst_1,arg2)) = traverseEquationItemList(eilst,inFunc,arg2);
@@ -189 +189 @@
 "Traverses all subalgorithms of an algorithm
   Takes a function and an extra argument passed through the traversal"
-  input Algorithm inAlgorithm;
+  input Absyn.Algorithm inAlgorithm;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<Algorithm, TypeA> outTpl;
+  output tuple<Absyn.Algorithm, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Algorithm, TypeA> inTpl;
-    output tuple<Algorithm, TypeA> outTpl;
+    input tuple<Absyn.Algorithm, TypeA> inTpl;
+    output tuple<Absyn.Algorithm, TypeA> outTpl;
   end FuncTplToTpl;
 algorithm
@@ -201 +201 @@
     local
       TypeA arg,arg_1,arg1_1,arg2_1,arg3_1;
-      Algorithm alg,alg_1,alg1_1,alg2_1,alg3_1;
-      list<AlgorithmItem> ailst,ailst1,ailst2,ailst_1,ailst1_1,ailst2_1;
-      list<tuple<Exp, list<AlgorithmItem>>> eaitlst,eaitlst_1;
+      Absyn.Algorithm alg,alg_1,alg1_1,alg2_1,alg3_1;
+      list<Absyn.AlgorithmItem> ailst,ailst1,ailst2,ailst_1,ailst1_1,ailst2_1;
+      list<tuple<Absyn.Exp, list<Absyn.AlgorithmItem>>> eaitlst,eaitlst_1;
       FuncTplToTpl rel;
-      AlgorithmItem ai,ai_1;
-      Exp e,e_1;
-      ForIterators fis,fis_1;
-    case(alg as ALG_IF(_,ailst1,eaitlst,ailst2),rel,arg)
+      Absyn.AlgorithmItem ai,ai_1;
+      Absyn.Exp e,e_1;
+      Absyn.ForIterators fis,fis_1;
+    case(alg as Absyn.ALG_IF(_,ailst1,eaitlst,ailst2),rel,arg)
       equation
         ((ailst1_1,arg1_1)) = traverseAlgorithmItemList(ailst1,rel,arg);
         ((eaitlst_1,arg2_1)) = traverseExpAlgItemTupleList(eaitlst,rel,arg1_1);
         ((ailst2_1,arg3_1)) = traverseAlgorithmItemList(ailst2,rel,arg2_1);
-        ((ALG_IF(e_1,_,_,_),arg_1)) = rel((alg,arg3_1));
-      then
-        ((ALG_IF(e_1,ailst1_1,eaitlst_1,ailst2_1),arg_1));
-    case(alg as ALG_FOR(_,ailst),rel,arg)
+        ((Absyn.ALG_IF(e_1,_,_,_),arg_1)) = rel((alg,arg3_1));
+      then
+        ((Absyn.ALG_IF(e_1,ailst1_1,eaitlst_1,ailst2_1),arg_1));
+    case(alg as Absyn.ALG_FOR(_,ailst),rel,arg)
       equation
         ((ailst_1,arg1_1)) = traverseAlgorithmItemList(ailst,rel,arg);
-        ((ALG_FOR(fis_1,_),arg_1)) = rel((alg,arg1_1));
-      then
-        ((ALG_FOR(fis_1,ailst_1),arg_1));
-    case(alg as ALG_PARFOR(_,ailst),rel,arg)
+        ((Absyn.ALG_FOR(fis_1,_),arg_1)) = rel((alg,arg1_1));
+      then
+        ((Absyn.ALG_FOR(fis_1,ailst_1),arg_1));
+    case(alg as Absyn.ALG_PARFOR(_,ailst),rel,arg)
       equation
         ((ailst_1,arg1_1)) = traverseAlgorithmItemList(ailst,rel,arg);
-        ((ALG_PARFOR(fis_1,_),arg_1)) = rel((alg,arg1_1));
-      then
-        ((ALG_PARFOR(fis_1,ailst_1),arg_1));
-    case(alg as ALG_WHILE(_,ailst),rel,arg)
+        ((Absyn.ALG_PARFOR(fis_1,_),arg_1)) = rel((alg,arg1_1));
+      then
+        ((Absyn.ALG_PARFOR(fis_1,ailst_1),arg_1));
+    case(alg as Absyn.ALG_WHILE(_,ailst),rel,arg)
       equation
         ((ailst_1,arg1_1)) = traverseAlgorithmItemList(ailst,rel,arg);
-        ((ALG_WHILE(e_1,_),arg_1)) = rel((alg,arg1_1));
-      then
-        ((ALG_WHILE(e_1,ailst_1),arg_1));
-    case(alg as ALG_WHEN_A(_,ailst,eaitlst),rel,arg)
+        ((Absyn.ALG_WHILE(e_1,_),arg_1)) = rel((alg,arg1_1));
+      then
+        ((Absyn.ALG_WHILE(e_1,ailst_1),arg_1));
+    case(alg as Absyn.ALG_WHEN_A(_,ailst,eaitlst),rel,arg)
       equation
         ((ailst_1,arg1_1)) = traverseAlgorithmItemList(ailst,rel,arg);
         ((eaitlst_1,arg2_1)) = traverseExpAlgItemTupleList(eaitlst,rel,arg1_1);
-        ((ALG_WHEN_A(e_1,_,_),arg_1)) = rel((alg,arg2_1));
-      then
-        ((ALG_WHEN_A(e_1,ailst_1,eaitlst_1),arg_1));
+        ((Absyn.ALG_WHEN_A(e_1,_,_),arg_1)) = rel((alg,arg2_1));
+      then
+        ((Absyn.ALG_WHEN_A(e_1,ailst_1,eaitlst_1),arg_1));
     case(alg,rel,arg)
       equation
@@ -251 +251 @@
 // stefan
 public function traverseAlgorithmItem
-"traverses the Algorithm contained in an AlgorithmItem, if any
+"traverses the Absyn.Algorithm contained in an Absyn.AlgorithmItem, if any
   see traverseAlgorithm"
-  input AlgorithmItem inAlgorithmItem;
+  input Absyn.AlgorithmItem inAlgorithmItem;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<AlgorithmItem, TypeA> outTpl;
+  output tuple<Absyn.AlgorithmItem, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Algorithm, TypeA> inTpl;
-    output tuple<Algorithm, TypeA> outTpl;
+    input tuple<Absyn.Algorithm, TypeA> inTpl;
+    output tuple<Absyn.Algorithm, TypeA> outTpl;
   end FuncTplToTpl;
 algorithm
@@ -266 +266 @@
       FuncTplToTpl rel;
       TypeA arg,arg_1;
-      Algorithm alg,alg_1;
-      Option<Comment> oc;
-      AlgorithmItem ai;
-      Info info;
-    case(ALGORITHMITEM(alg,oc,info),rel,arg)
+      Absyn.Algorithm alg,alg_1;
+      Option<Absyn.Comment> oc;
+      Absyn.AlgorithmItem ai;
+      Absyn.Info info;
+    case(Absyn.ALGORITHMITEM(alg,oc,info),rel,arg)
       equation
         ((alg_1,arg_1)) = traverseAlgorithm(alg,rel,arg);
       then
-        ((ALGORITHMITEM(alg_1,oc,info),arg_1));
+        ((Absyn.ALGORITHMITEM(alg_1,oc,info),arg_1));
     case(ai,_,arg) then ((ai,arg));
   end matchcontinue;
@@ -282 +282 @@
 public function traverseAlgorithmItemList
 "calls traverseAlgorithmItem on each item in a list of AlgorithmItems"
-  input list<AlgorithmItem> inAlgorithmItemList;
+  input list<Absyn.AlgorithmItem> inAlgorithmItemList;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<list<AlgorithmItem>, TypeA> outTpl;
+  output tuple<list<Absyn.AlgorithmItem>, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Algorithm, TypeA> inTpl;
-    output tuple<Algorithm, TypeA> outTpl;
+    input tuple<Absyn.Algorithm, TypeA> inTpl;
+    output tuple<Absyn.Algorithm, TypeA> outTpl;
   end FuncTplToTpl;
 algorithm
@@ -295 +295 @@
       FuncTplToTpl rel;
       TypeA arg,arg_1,arg_2;
-      AlgorithmItem ai,ai_1;
-      list<AlgorithmItem> cdr,cdr_1;
+      Absyn.AlgorithmItem ai,ai_1;
+      list<Absyn.AlgorithmItem> cdr,cdr_1;
     case({},_,arg) then (({},arg));
     case(ai :: cdr,rel,arg)
@@ -309 +309 @@
 // stefan
 public function traverseExpAlgItemTupleList
-"traverses a list of Exp * AlgorithmItem list tuples
+"traverses a list of Absyn.Exp * Absyn.AlgorithmItem list tuples
   mostly used for else-if blocks"
-  input list<tuple<Exp, list<AlgorithmItem>>> inList;
+  input list<tuple<Absyn.Exp, list<Absyn.AlgorithmItem>>> inList;
   input FuncTplToTpl inFunc;
   input TypeA inTypeA;
-  output tuple<list<tuple<Exp, list<AlgorithmItem>>>, TypeA> outTpl;
+  output tuple<list<tuple<Absyn.Exp, list<Absyn.AlgorithmItem>>>, TypeA> outTpl;
   partial function FuncTplToTpl
-    input tuple<Algorithm, TypeA> inTpl;
-    output tuple<Algorithm, TypeA> outTpl;
+    input tuple<Absyn.Algorithm, TypeA> inTpl;
+    output tuple<Absyn.Algorithm, TypeA> outTpl;
   end FuncTplToTpl;
 algorithm
@@ -324 +324 @@
       FuncTplToTpl rel;
       TypeA arg,arg_1,arg_2;
-      list<tuple<Exp, list<AlgorithmItem>>> cdr,cdr_1;
-      Exp e;
-      list<AlgorithmItem> ailst,ailst_1;
+      list<tuple<Absyn.Exp, list<Absyn.AlgorithmItem>>> cdr,cdr_1;
+      Absyn.Exp e;
+      list<Absyn.AlgorithmItem> ailst,ailst_1;
     case({},_,arg) then (({},arg));
     case((e,ailst) :: cdr,rel,arg)
@@ -338 +338 @@
 
 public function traverseExp
-" Traverses all subexpressions of an Exp expression.
+" Traverses all subexpressions of an Absyn.Exp expression.
   Takes a function and an extra argument passed through the traversal.
   NOTE:This function was copied from Expression.traverseExpression."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input FuncType inFunc;
   input Type_a inArg;
-  output Exp outExp;
+  output Absyn.Exp outExp;
   output Type_a outArg;
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Type_a inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Type_a outArg;
   end FuncType;
@@ -357 +357 @@
 
 public function traverseExpTopDown
-" Traverses all subexpressions of an Exp expression.
+" Traverses all subexpressions of an Absyn.Exp expression.
   Takes a function and an extra argument passed through the traversal."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input FuncType inFunc;
   input Type_a inArg;
-  output Exp outExp;
+  output Absyn.Exp outExp;
   output Type_a outArg;
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Type_a inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Type_a outArg;
   end FuncType;
@@ -376 +376 @@
 public function traverseExpList
 "calls traverseExp on each element in the given list"
-  input list<Exp> inExpList;
+  input list<Absyn.Exp> inExpList;
   input FuncTplToTpl inFunc;
   input Type_a inArg;
-  output list<Exp> outExpList;
+  output list<Absyn.Exp> outExpList;
   output Type_a outArg;
   partial function FuncTplToTpl
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Type_a inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Type_a outArg;
   end FuncTplToTpl;
@@ -394 +394 @@
   "Traverses a list of expressions, calling traverseExpBidir on each
   expression."
-  input list<Exp> inExpl;
+  input list<Absyn.Exp> inExpl;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output list<Exp> outExpl;
+  output list<Absyn.Exp> outExpl;
   output Argument outArg;
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -418 +418 @@
   the updated argument. This means that this function is bidirectional, and can
   be used to emulate both top-down and bottom-up traversal."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Exp e;
+  output Absyn.Exp e;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -442 +442 @@
   traverseExpBidir if the option is SOME(), or just returns the input if it's
   NONE()"
-  input Option<Exp> inExp;
+  input Option<Absyn.Exp> inExp;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Option<Exp> outExp;
+  output Option<Absyn.Exp> outExp;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -459 +459 @@
   (outExp, arg) := match(inExp, enterFunc, exitFunc, inArg)
     local
-      Exp e1,e2;
+      Absyn.Exp e1,e2;
       tuple<FuncType, FuncType, Argument> tup;
 
@@ -475 +475 @@
   "Helper function to traverseExpBidir. Traverses the subexpressions of an
   expression and calls traverseExpBidir on them."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Exp e;
+  output Absyn.Exp e;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -492 +492 @@
   (e, arg) := match (inExp, enterFunc, exitFunc, inArg)
     local
-      Exp e1, e1m, e2, e2m, e3, e3m;
-      Option<Exp> oe1, oe1m;
+      Absyn.Exp e1, e1m, e2, e2m, e3, e3m;
+      Option<Absyn.Exp> oe1, oe1m;
       tuple<FuncType, FuncType, Argument> tup;
-      Operator op;
-      ComponentRef cref, crefm;
-      list<tuple<Exp, Exp>> else_ifs1,else_ifs2;
-      list<Exp> expl1,expl2;
-      list<list<Exp>> mat_expl;
-      FunctionArgs fargs1,fargs2;
+      Absyn.Operator op;
+      Absyn.ComponentRef cref, crefm;
+      list<tuple<Absyn.Exp, Absyn.Exp>> else_ifs1,else_ifs2;
+      list<Absyn.Exp> expl1,expl2;
+      list<list<Absyn.Exp>> mat_expl;
+      Absyn.FunctionArgs fargs1,fargs2;
       String error_msg;
-      Ident id, enterName, exitName;
-      MatchType match_ty;
-      list<ElementItem> match_decls;
-      list<Case> match_cases;
+      Absyn.Ident id, enterName, exitName;
+      Absyn.MatchType match_ty;
+      list<Absyn.ElementItem> match_decls;
+      list<Absyn.Case> match_cases;
       Option<String> cmt;
 
-    case (INTEGER(), _, _, _) then (inExp, inArg);
-    case (REAL(), _, _, _) then (inExp, inArg);
-    case (STRING(), _, _, _) then (inExp, inArg);
-    case (BOOL(), _, _, _) then (inExp, inArg);
-
-    case (CREF(componentRef = cref), _, _, arg)
+    case (Absyn.INTEGER(), _, _, _) then (inExp, inArg);
+    case (Absyn.REAL(), _, _, _) then (inExp, inArg);
+    case (Absyn.STRING(), _, _, _) then (inExp, inArg);
+    case (Absyn.BOOL(), _, _, _) then (inExp, inArg);
+
+    case (Absyn.CREF(componentRef = cref), _, _, arg)
       equation
         (crefm, arg) = traverseExpBidirCref(cref, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(cref,crefm) then inExp else CREF(crefm), arg);
-
-    case (BINARY(exp1 = e1, op = op, exp2 = e2), _, _, arg)
+        (if referenceEq(cref,crefm) then inExp else Absyn.CREF(crefm), arg);
+
+    case (Absyn.BINARY(exp1 = e1, op = op, exp2 = e2), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2m, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else BINARY(e1m, op, e2m), arg);
-
-    case (UNARY(op = op, exp = e1), _, _, arg)
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else Absyn.BINARY(e1m, op, e2m), arg);
+
+    case (Absyn.UNARY(op = op, exp = e1), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) then inExp else UNARY(op, e1m), arg);
-
-    case (LBINARY(exp1 = e1, op = op, exp2 = e2), _, _, arg)
+        (if referenceEq(e1,e1m) then inExp else Absyn.UNARY(op, e1m), arg);
+
+    case (Absyn.LBINARY(exp1 = e1, op = op, exp2 = e2), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2m, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else LBINARY(e1m, op, e2m), arg);
-
-    case (LUNARY(op = op, exp = e1), _, _, arg)
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else Absyn.LBINARY(e1m, op, e2m), arg);
+
+    case (Absyn.LUNARY(op = op, exp = e1), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) then inExp else LUNARY(op, e1m), arg);
-
-    case (RELATION(exp1 = e1, op = op, exp2 = e2), _, _, arg)
+        (if referenceEq(e1,e1m) then inExp else Absyn.LUNARY(op, e1m), arg);
+
+    case (Absyn.RELATION(exp1 = e1, op = op, exp2 = e2), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2m, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else RELATION(e1m, op, e2m), arg);
-
-    case (IFEXP(ifExp = e1, trueBranch = e2, elseBranch = e3,
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else Absyn.RELATION(e1m, op, e2m), arg);
+
+    case (Absyn.IFEXP(ifExp = e1, trueBranch = e2, elseBranch = e3,
         elseIfBranch = else_ifs1), _, _, arg)
       equation
@@ -560 +560 @@
         (else_ifs2, arg) = List.map2FoldCheckReferenceEq(else_ifs1, traverseExpBidirElseIf, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) and referenceEq(e3,e3m) and referenceEq(else_ifs1,else_ifs2) then inExp else IFEXP(e1m, e2m, e3m, else_ifs2), arg);
-
-    case (CALL(function_ = cref, functionArgs = fargs1), _, _, arg)
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) and referenceEq(e3,e3m) and referenceEq(else_ifs1,else_ifs2) then inExp else Absyn.IFEXP(e1m, e2m, e3m, else_ifs2), arg);
+
+    case (Absyn.CALL(function_ = cref, functionArgs = fargs1), _, _, arg)
       equation
         (fargs2, arg) = traverseExpBidirFunctionArgs(fargs1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(fargs1,fargs2) then inExp else CALL(cref, fargs2), arg);
-
-    case (PARTEVALFUNCTION(function_ = cref, functionArgs = fargs1), _, _, arg)
+        (if referenceEq(fargs1,fargs2) then inExp else Absyn.CALL(cref, fargs2), arg);
+
+    case (Absyn.PARTEVALFUNCTION(function_ = cref, functionArgs = fargs1), _, _, arg)
       equation
         (fargs2, arg) = traverseExpBidirFunctionArgs(fargs1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(fargs1,fargs2) then inExp else PARTEVALFUNCTION(cref, fargs2), arg);
-
-    case (ARRAY(arrayExp = expl1), _, _, arg)
+        (if referenceEq(fargs1,fargs2) then inExp else Absyn.PARTEVALFUNCTION(cref, fargs2), arg);
+
+    case (Absyn.ARRAY(arrayExp = expl1), _, _, arg)
       equation
         (expl2, arg) = traverseExpListBidir(expl1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(expl1,expl2) then inExp else ARRAY(expl2), arg);
-
-    case (MATRIX(matrix = mat_expl), _, _, arg)
+        (if referenceEq(expl1,expl2) then inExp else Absyn.ARRAY(expl2), arg);
+
+    case (Absyn.MATRIX(matrix = mat_expl), _, _, arg)
       equation
         (mat_expl, arg) = List.map2FoldCheckReferenceEq(mat_expl, traverseExpListBidir, enterFunc, exitFunc, arg);
       then
-        (MATRIX(mat_expl), arg);
-
-    case (RANGE(start = e1, step = oe1, stop = e2), _, _, arg)
+        (Absyn.MATRIX(mat_expl), arg);
+
+    case (Absyn.RANGE(start = e1, step = oe1, stop = e2), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
@@ -592 +592 @@
         (e2m, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) and referenceEq(oe1,oe1m) then inExp else RANGE(e1m, oe1m, e2m), arg);
-
-    case (END(), _, _, _) then (inExp, inArg);
-
-    case (TUPLE(expressions = expl1), _, _, arg)
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) and referenceEq(oe1,oe1m) then inExp else Absyn.RANGE(e1m, oe1m, e2m), arg);
+
+    case (Absyn.END(), _, _, _) then (inExp, inArg);
+
+    case (Absyn.TUPLE(expressions = expl1), _, _, arg)
       equation
         (expl2, arg) = traverseExpListBidir(expl1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(expl1,expl2) then inExp else TUPLE(expl2), arg);
-
-    case (AS(id = id, exp = e1), _, _, arg)
+        (if referenceEq(expl1,expl2) then inExp else Absyn.TUPLE(expl2), arg);
+
+    case (Absyn.AS(id = id, exp = e1), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) then inExp else AS(id, e1m), arg);
-
-    case (CONS(head = e1, rest = e2), _, _, arg)
+        (if referenceEq(e1,e1m) then inExp else Absyn.AS(id, e1m), arg);
+
+    case (Absyn.CONS(head = e1, rest = e2), _, _, arg)
       equation
         (e1m, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2m, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else CONS(e1m, e2m), arg);
-
-    case (MATCHEXP(matchTy = match_ty, inputExp = e1, localDecls = match_decls,
+        (if referenceEq(e1,e1m) and referenceEq(e2,e2m) then inExp else Absyn.CONS(e1m, e2m), arg);
+
+    case (Absyn.MATCHEXP(matchTy = match_ty, inputExp = e1, localDecls = match_decls,
         cases = match_cases, comment = cmt), _, _, arg)
       equation
@@ -621 +621 @@
         (match_cases, arg) = List.map2FoldCheckReferenceEq(match_cases, traverseMatchCase, enterFunc, exitFunc, arg);
       then
-        (MATCHEXP(match_ty, e1, match_decls, match_cases, cmt), arg);
-
-    case (LIST(exps = expl1), _, _, arg)
+        (Absyn.MATCHEXP(match_ty, e1, match_decls, match_cases, cmt), arg);
+
+    case (Absyn.LIST(exps = expl1), _, _, arg)
       equation
         (expl2, arg) = traverseExpListBidir(expl1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(expl1,expl2) then inExp else LIST(expl2), arg);
-
-    case (CODE(), _, _, _)
+        (if referenceEq(expl1,expl2) then inExp else Absyn.LIST(expl2), arg);
+
+    case (Absyn.CODE(), _, _, _)
       then (inExp, inArg);
 
-    case (DOT(), _, _, arg)
+    case (Absyn.DOT(), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(inExp.exp, enterFunc, exitFunc, arg);
         (e2, arg) = traverseExpBidir(inExp.index, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(inExp.exp,e1) and referenceEq(inExp.index,e2) then inExp else DOT(e1, e2), arg);
+        (if referenceEq(inExp.exp,e1) and referenceEq(inExp.index,e2) then inExp else Absyn.DOT(e1, e2), arg);
 
     else
@@ -655 +655 @@
   "Helper function to traverseExpBidirSubExps. Traverses any expressions in a
   component reference (i.e. in it's subscripts)."
-  input ComponentRef inCref;
+  input Absyn.ComponentRef inCref;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output ComponentRef outCref;
+  output Absyn.ComponentRef outCref;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -672 +672 @@
   (outCref, arg) := match(inCref, enterFunc, exitFunc, inArg)
     local
-      Ident name;
-      ComponentRef cr1,cr2;
-      list<Subscript> subs1,subs2;
+      Absyn.Ident name;
+      Absyn.ComponentRef cr1,cr2;
+      list<Absyn.Subscript> subs1,subs2;
       tuple<FuncType, FuncType, Argument> tup;
 
-    case (CREF_FULLYQUALIFIED(componentRef = cr1), _, _, arg)
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr1), _, _, arg)
       equation
         (cr2, arg) = traverseExpBidirCref(cr1, enterFunc, exitFunc, arg);
@@ -683 +683 @@
         (if referenceEq(cr1,cr2) then inCref else crefMakeFullyQualified(cr2), arg);
 
-    case (CREF_QUAL(name = name, subscripts = subs1, componentRef = cr1), _, _, arg)
+    case (Absyn.CREF_QUAL(name = name, subscripts = subs1, componentRef = cr1), _, _, arg)
       equation
         (subs2, arg) = List.map2FoldCheckReferenceEq(subs1, traverseExpBidirSubs, enterFunc, exitFunc, arg);
         (cr2, arg) = traverseExpBidirCref(cr1, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(cr1,cr2) and referenceEq(subs1,subs2) then inCref else CREF_QUAL(name, subs2, cr2), arg);
-
-    case (CREF_IDENT(name = name, subscripts = subs1), _, _, arg)
+        (if referenceEq(cr1,cr2) and referenceEq(subs1,subs2) then inCref else Absyn.CREF_QUAL(name, subs2, cr2), arg);
+
+    case (Absyn.CREF_IDENT(name = name, subscripts = subs1), _, _, arg)
       equation
         (subs2, arg) = List.map2FoldCheckReferenceEq(subs1, traverseExpBidirSubs, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(subs1,subs2) then inCref else CREF_IDENT(name, subs2), arg);
-
-    case (ALLWILD(), _, _, _) then (inCref, inArg);
-    case (WILD(), _, _, _) then (inCref, inArg);
+        (if referenceEq(subs1,subs2) then inCref else Absyn.CREF_IDENT(name, subs2), arg);
+
+    case (Absyn.ALLWILD(), _, _, _) then (inCref, inArg);
+    case (Absyn.WILD(), _, _, _) then (inCref, inArg);
   end match;
 end traverseExpBidirCref;
@@ -704 +704 @@
   "Helper function to traverseExpBidirCref. Traverses expressions in a
   subscript."
-  input Subscript inSubscript;
+  input Absyn.Subscript inSubscript;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Subscript outSubscript;
+  output Absyn.Subscript outSubscript;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -721 +721 @@
   (outSubscript, arg) := match(inSubscript, enterFunc, exitFunc, inArg)
     local
-      Exp e1,e2;
-
-    case (SUBSCRIPT(subscript = e1), _, _, arg)
+      Absyn.Exp e1,e2;
+
+    case (Absyn.SUBSCRIPT(subscript = e1), _, _, arg)
       equation
         (e2, arg) = traverseExpBidir(e1, enterFunc, exitFunc, inArg);
       then
-        (if referenceEq(e1,e2) then inSubscript else SUBSCRIPT(e2), arg);
-
-    case (NOSUB(), _, _, _) then (inSubscript, inArg);
+        (if referenceEq(e1,e2) then inSubscript else Absyn.SUBSCRIPT(e2), arg);
+
+    case (Absyn.NOSUB(), _, _, _) then (inSubscript, inArg);
   end match;
 end traverseExpBidirSubs;
@@ -736 +736 @@
   "Helper function to traverseExpBidirSubExps. Traverses the expressions in an
   elseif branch."
-  input tuple<Exp, Exp> inElseIf;
+  input tuple<Absyn.Exp, Absyn.Exp> inElseIf;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output tuple<Exp, Exp> outElseIf;
+  output tuple<Absyn.Exp, Absyn.Exp> outElseIf;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
 
 protected
-  Exp e1, e2;
+  Absyn.Exp e1, e2;
   tuple<FuncType, FuncType, Argument> tup;
 algorithm
@@ -763 +763 @@
   "Helper function to traverseExpBidirSubExps. Traverses the expressions in a
   list of function argument."
-  input FunctionArgs inArgs;
+  input Absyn.FunctionArgs inArgs;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output FunctionArgs outArgs;
+  output Absyn.FunctionArgs outArgs;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -780 +780 @@
   (outArgs, outArg) := match(inArgs, enterFunc, exitFunc, inArg)
     local
-      Exp e1,e2;
-      list<Exp> expl1,expl2;
-      list<NamedArg> named_args1,named_args2;
-      ForIterators iters1,iters2;
+      Absyn.Exp e1,e2;
+      list<Absyn.Exp> expl1,expl2;
+      list<Absyn.NamedArg> named_args1,named_args2;
+      Absyn.ForIterators iters1,iters2;
       Argument arg;
-      ReductionIterType iterType;
-
-    case (FUNCTIONARGS(args = expl1, argNames = named_args1), _, _, arg)
+      Absyn.ReductionIterType iterType;
+
+    case (Absyn.FUNCTIONARGS(args = expl1, argNames = named_args1), _, _, arg)
       equation
         (expl2, arg) = traverseExpListBidir(expl1, enterFunc, exitFunc, arg);
         (named_args2, arg) = List.map2FoldCheckReferenceEq(named_args1, traverseExpBidirNamedArg, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(expl1,expl2) and referenceEq(named_args1,named_args2) then inArgs else FUNCTIONARGS(expl2, named_args2), arg);
-
-    case (FOR_ITER_FARG(e1, iterType, iters1), _, _, arg)
+        (if referenceEq(expl1,expl2) and referenceEq(named_args1,named_args2) then inArgs else Absyn.FUNCTIONARGS(expl2, named_args2), arg);
+
+    case (Absyn.FOR_ITER_FARG(e1, iterType, iters1), _, _, arg)
       equation
         (e2, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (iters2, arg) = List.map2FoldCheckReferenceEq(iters1, traverseExpBidirIterator, enterFunc, exitFunc, arg);
       then
-        (if referenceEq(e1,e2) and referenceEq(iters1,iters2) then inArgs else FOR_ITER_FARG(e2, iterType, iters2), arg);
+        (if referenceEq(e1,e2) and referenceEq(iters1,iters2) then inArgs else Absyn.FOR_ITER_FARG(e2, iterType, iters2), arg);
   end match;
 end traverseExpBidirFunctionArgs;
@@ -806 +806 @@
   "Helper function to traverseExpBidirFunctionArgs. Traverses the expressions in
   a named function argument."
-  input NamedArg inArg;
+  input Absyn.NamedArg inArg;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inExtra;
-  output NamedArg outArg;
+  output Absyn.NamedArg outArg;
   output Argument outExtra;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
 
 protected
-  Ident name;
-  Exp value1,value2;
-algorithm
-  NAMEDARG(name, value1) := inArg;
+  Absyn.Ident name;
+  Absyn.Exp value1,value2;
+algorithm
+  Absyn.NAMEDARG(name, value1) := inArg;
   (value2, outExtra) := traverseExpBidir(value1, enterFunc, exitFunc, inExtra);
-  outArg := if referenceEq(value1,value2) then inArg else NAMEDARG(name, value2);
+  outArg := if referenceEq(value1,value2) then inArg else Absyn.NAMEDARG(name, value2);
 end traverseExpBidirNamedArg;
 
@@ -832 +832 @@
   "Helper function to traverseExpBidirFunctionArgs. Traverses the expressions in
   an iterator."
-  input ForIterator inIterator;
+  input Absyn.ForIterator inIterator;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output ForIterator outIterator;
+  output Absyn.ForIterator outIterator;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
 
 protected
-  Ident name;
-  Option<Exp> guardExp1,guardExp2,range1,range2;
-algorithm
-  ITERATOR(name=name, guardExp=guardExp1, range=range1) := inIterator;
+  Absyn.Ident name;
+  Option<Absyn.Exp> guardExp1,guardExp2,range1,range2;
+algorithm
+  Absyn.ITERATOR(name=name, guardExp=guardExp1, range=range1) := inIterator;
   (guardExp2, outArg) := traverseExpOptBidir(guardExp1, enterFunc, exitFunc, inArg);
   (range2, outArg) := traverseExpOptBidir(range1, enterFunc, exitFunc, outArg);
-  outIterator := if referenceEq(guardExp1,guardExp2) and referenceEq(range1,range2) then inIterator else ITERATOR(name, guardExp2, range2);
+  outIterator := if referenceEq(guardExp1,guardExp2) and referenceEq(range1,range2) then inIterator else Absyn.ITERATOR(name, guardExp2, range2);
 end traverseExpBidirIterator;
 
 public function traverseMatchCase
-  input Case inMatchCase;
+  input Absyn.Case inMatchCase;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Case outMatchCase;
+  output Absyn.Case outMatchCase;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -875 +875 @@
     local
       Argument arg;
-      Exp pattern, result;
-      Info info, resultInfo, pinfo;
-      list<ElementItem> ldecls;
-      ClassPart cp;
+      Absyn.Exp pattern, result;
+      Absyn.Info info, resultInfo, pinfo;
+      list<Absyn.ElementItem> ldecls;
+      Absyn.ClassPart cp;
       Option<String> cmt;
-      Option<Exp> patternGuard;
-
-    case (CASE(pattern, patternGuard, pinfo, ldecls, cp, result, resultInfo, cmt, info), _, _, arg)
+      Option<Absyn.Exp> patternGuard;
+
+    case (Absyn.CASE(pattern, patternGuard, pinfo, ldecls, cp, result, resultInfo, cmt, info), _, _, arg)
       equation
         (pattern, arg) = traverseExpBidir(pattern, enterFunc, exitFunc, arg);
@@ -889 +889 @@
         (result, arg) = traverseExpBidir(result, enterFunc, exitFunc, arg);
       then
-        (CASE(pattern, patternGuard, pinfo, ldecls, cp, result, resultInfo, cmt, info), arg);
-
-    case (ELSE(localDecls = ldecls, classPart = cp, result = result, resultInfo = resultInfo,
+        (Absyn.CASE(pattern, patternGuard, pinfo, ldecls, cp, result, resultInfo, cmt, info), arg);
+
+    case (Absyn.ELSE(localDecls = ldecls, classPart = cp, result = result, resultInfo = resultInfo,
         comment = cmt, info = info), _, _, arg)
       equation
@@ -897 +897 @@
         (result, arg) = traverseExpBidir(result, enterFunc, exitFunc, arg);
       then
-        (ELSE(ldecls, cp, result, resultInfo, cmt, info), arg);
+        (Absyn.ELSE(ldecls, cp, result, resultInfo, cmt, info), arg);
 
   end match;
@@ -903 +903 @@
 
 protected function traverseClassPartBidir
-  input ClassPart cp;
+  input Absyn.ClassPart cp;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output ClassPart outCp;
+  output Absyn.ClassPart outCp;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -920 +920 @@
   (outCp, outArg) := match (cp,enterFunc,exitFunc,inArg)
     local
-      list<AlgorithmItem> algs;
-      list<EquationItem> eqs;
+      list<Absyn.AlgorithmItem> algs;
+      list<Absyn.EquationItem> eqs;
       Argument arg;
-    case (ALGORITHMS(algs),_,_,arg)
+    case (Absyn.ALGORITHMS(algs),_,_,arg)
       equation
         (algs, arg) = List.map2FoldCheckReferenceEq(algs, traverseAlgorithmItemBidir, enterFunc, exitFunc, arg);
-      then (ALGORITHMS(algs),arg);
-    case (EQUATIONS(eqs),_,_,arg)
+      then (Absyn.ALGORITHMS(algs),arg);
+    case (Absyn.EQUATIONS(eqs),_,_,arg)
       equation
         (eqs, arg) = List.map2FoldCheckReferenceEq(eqs, traverseEquationItemBidir, enterFunc, exitFunc, arg);
-      then (EQUATIONS(eqs),arg);
+      then (Absyn.EQUATIONS(eqs),arg);
   end match;
 end traverseClassPartBidir;
 
 protected function traverseEquationItemListBidir
-  input list<EquationItem> inEquationItems;
+  input list<Absyn.EquationItem> inEquationItems;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output list<EquationItem> outEquationItems;
+  output list<Absyn.EquationItem> outEquationItems;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -954 +954 @@
 
 protected function traverseAlgorithmItemListBidir
-  input list<AlgorithmItem> inAlgs;
+  input list<Absyn.AlgorithmItem> inAlgs;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output list<AlgorithmItem> outAlgs;
+  output list<Absyn.AlgorithmItem> outAlgs;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -973 +973 @@
 
 protected function traverseAlgorithmItemBidir
-  input AlgorithmItem inAlgorithmItem;
+  input Absyn.AlgorithmItem inAlgorithmItem;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output AlgorithmItem outAlgorithmItem;
+  output Absyn.AlgorithmItem outAlgorithmItem;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -991 +991 @@
     local
       Argument arg;
-      Algorithm alg;
-      Option<Comment> cmt;
-      Info info;
-
-    case (ALGORITHMITEM(algorithm_ = alg, comment = cmt, info = info), _, _, arg)
+      Absyn.Algorithm alg;
+      Option<Absyn.Comment> cmt;
+      Absyn.Info info;
+
+    case (Absyn.ALGORITHMITEM(algorithm_ = alg, comment = cmt, info = info), _, _, arg)
       equation
         (alg, arg) = traverseAlgorithmBidir(alg, enterFunc, exitFunc, arg);
       then
-        (ALGORITHMITEM(alg, cmt, info), arg);
-
-    case (ALGORITHMITEMCOMMENT(), _, _, _) then (inAlgorithmItem,inArg);
+        (Absyn.ALGORITHMITEM(alg, cmt, info), arg);
+
+    case (Absyn.ALGORITHMITEMCOMMENT(), _, _, _) then (inAlgorithmItem,inArg);
   end match;
 end traverseAlgorithmItemBidir;
 
 protected function traverseEquationItemBidir
-  input EquationItem inEquationItem;
+  input Absyn.EquationItem inEquationItem;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output EquationItem outEquationItem;
+  output Absyn.EquationItem outEquationItem;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -1024 +1024 @@
     local
       Argument arg;
-      Equation eq;
-      Option<Comment> cmt;
-      Info info;
-
-    case (EQUATIONITEM(equation_ = eq, comment = cmt, info = info), _, _, arg)
+      Absyn.Equation eq;
+      Option<Absyn.Comment> cmt;
+      Absyn.Info info;
+
+    case (Absyn.EQUATIONITEM(equation_ = eq, comment = cmt, info = info), _, _, arg)
       equation
         (eq, arg) = traverseEquationBidir(eq, enterFunc, exitFunc, arg);
       then
-        (EQUATIONITEM(eq, cmt, info), arg);
+        (Absyn.EQUATIONITEM(eq, cmt, info), arg);
 
   end match;
@@ -1038 +1038 @@
 
 public function traverseEquationBidir
-  input Equation inEquation;
+  input Absyn.Equation inEquation;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Equation outEquation;
+  output Absyn.Equation outEquation;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -1056 +1056 @@
     local
       Argument arg;
-      Exp e1, e2;
-      list<EquationItem> eqil1, eqil2;
-      list<tuple<Exp, list<EquationItem>>> else_branch;
-      ComponentRef cref1, cref2;
-      ForIterators iters;
-      FunctionArgs func_args;
-      EquationItem eq;
-
-    case (EQ_IF(ifExp = e1, equationTrueItems = eqil1,
+      Absyn.Exp e1, e2;
+      list<Absyn.EquationItem> eqil1, eqil2;
+      list<tuple<Absyn.Exp, list<Absyn.EquationItem>>> else_branch;
+      Absyn.ComponentRef cref1, cref2;
+      Absyn.ForIterators iters;
+      Absyn.FunctionArgs func_args;
+      Absyn.EquationItem eq;
+
+    case (Absyn.EQ_IF(ifExp = e1, equationTrueItems = eqil1,
         elseIfBranches = else_branch, equationElseItems = eqil2), _, _, arg)
       equation
@@ -1072 +1072 @@
         (eqil2,arg) = traverseEquationItemListBidir(eqil2, enterFunc, exitFunc, arg);
       then
-        (EQ_IF(e1, eqil1, else_branch, eqil2), arg);
-
-    case (EQ_EQUALS(leftSide = e1, rightSide = e2), _, _, arg)
+        (Absyn.EQ_IF(e1, eqil1, else_branch, eqil2), arg);
+
+    case (Absyn.EQ_EQUALS(leftSide = e1, rightSide = e2), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (EQ_EQUALS(e1, e2), arg);
-    case (EQ_PDE(leftSide = e1, rightSide = e2, domain = cref1), _, _, arg)
+        (Absyn.EQ_EQUALS(e1, e2), arg);
+    case (Absyn.EQ_PDE(leftSide = e1, rightSide = e2, domain = cref1), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
@@ -1086 +1086 @@
         cref1 = traverseExpBidirCref(cref1, enterFunc, exitFunc, arg);
       then
-        (EQ_PDE(e1, e2,cref1), arg);
-
-    case (EQ_CONNECT(connector1 = cref1, connector2 = cref2), _, _, arg)
+        (Absyn.EQ_PDE(e1, e2,cref1), arg);
+
+    case (Absyn.EQ_CONNECT(connector1 = cref1, connector2 = cref2), _, _, arg)
       equation
         (cref1, arg) = traverseExpBidirCref(cref1, enterFunc, exitFunc, arg);
         (cref2, arg) = traverseExpBidirCref(cref2, enterFunc, exitFunc, arg);
       then
-        (EQ_CONNECT(cref1, cref2), arg);
-
-    case (EQ_FOR(iterators = iters, forEquations = eqil1), _, _, arg)
+        (Absyn.EQ_CONNECT(cref1, cref2), arg);
+
+    case (Absyn.EQ_FOR(iterators = iters, forEquations = eqil1), _, _, arg)
       equation
         (iters, arg) = List.map2FoldCheckReferenceEq(iters, traverseExpBidirIterator, enterFunc, exitFunc, arg);
         (eqil1, arg) = traverseEquationItemListBidir(eqil1, enterFunc, exitFunc, arg);
       then
-        (EQ_FOR(iters, eqil1), arg);
-
-    case (EQ_WHEN_E(whenExp = e1, whenEquations = eqil1, elseWhenEquations = else_branch), _, _, arg)
+        (Absyn.EQ_FOR(iters, eqil1), arg);
+
+    case (Absyn.EQ_WHEN_E(whenExp = e1, whenEquations = eqil1, elseWhenEquations = else_branch), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
@@ -1108 +1108 @@
         (else_branch, arg) = List.map2FoldCheckReferenceEq(else_branch, traverseEquationBidirElse, enterFunc, exitFunc, arg);
       then
-        (EQ_WHEN_E(e1, eqil1, else_branch), arg);
-
-    case (EQ_NORETCALL(functionName = cref1, functionArgs = func_args), _, _, arg)
+        (Absyn.EQ_WHEN_E(e1, eqil1, else_branch), arg);
+
+    case (Absyn.EQ_NORETCALL(functionName = cref1, functionArgs = func_args), _, _, arg)
       equation
         (cref1, arg) = traverseExpBidirCref(cref1, enterFunc, exitFunc, arg);
         (func_args, arg) = traverseExpBidirFunctionArgs(func_args, enterFunc, exitFunc, arg);
       then
-        (EQ_NORETCALL(cref1, func_args), arg);
-
-    case (EQ_FAILURE(equ = eq), _, _, arg)
+        (Absyn.EQ_NORETCALL(cref1, func_args), arg);
+
+    case (Absyn.EQ_FAILURE(equ = eq), _, _, arg)
       equation
         (eq, arg) = traverseEquationItemBidir(eq, enterFunc, exitFunc, arg);
       then
-        (EQ_FAILURE(eq), arg);
+        (Absyn.EQ_FAILURE(eq), arg);
 
   end match;
@@ -1127 +1127 @@
 
 protected function traverseEquationBidirElse
-  input tuple<Exp, list<EquationItem>> inElse;
+  input tuple<Absyn.Exp, list<Absyn.EquationItem>> inElse;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output tuple<Exp, list<EquationItem>> outElse;
+  output tuple<Absyn.Exp, list<Absyn.EquationItem>> outElse;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
 
 protected
-  Exp e;
-  list<EquationItem> eqil;
+  Absyn.Exp e;
+  list<Absyn.EquationItem> eqil;
 algorithm
   (e, eqil) := inElse;
@@ -1152 +1152 @@
 
 protected function traverseAlgorithmBidirElse
-  input tuple<Exp, list<AlgorithmItem>> inElse;
+  input tuple<Absyn.Exp, list<Absyn.AlgorithmItem>> inElse;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output tuple<Exp, list<AlgorithmItem>> outElse;
+  output tuple<Absyn.Exp, list<Absyn.AlgorithmItem>> outElse;
   output Argument arg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
 
 protected
-  Exp e;
-  list<AlgorithmItem> algs;
+  Absyn.Exp e;
+  list<Absyn.AlgorithmItem> algs;
 algorithm
   (e, algs) := inElse;
@@ -1177 +1177 @@
 
 protected function traverseAlgorithmBidir
-  input Algorithm inAlg;
+  input Absyn.Algorithm inAlg;
   input FuncType enterFunc;
   input FuncType exitFunc;
   input Argument inArg;
-  output Algorithm outAlg;
+  output Absyn.Algorithm outAlg;
   output Argument outArg;
 
   partial function FuncType
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input Argument inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
     output Argument outArg;
   end FuncType;
@@ -1195 +1195 @@
     local
       Argument arg;
-      Exp e1, e2;
-      list<AlgorithmItem> algs1, algs2;
-      list<tuple<Exp, list<AlgorithmItem>>> else_branch;
-      ComponentRef cref1, cref2;
-      ForIterators iters;
-      FunctionArgs func_args;
-      AlgorithmItem alg;
-
-    case (ALG_ASSIGN(e1, e2), _, _, arg)
+      Absyn.Exp e1, e2;
+      list<Absyn.AlgorithmItem> algs1, algs2;
+      list<tuple<Absyn.Exp, list<Absyn.AlgorithmItem>>> else_branch;
+      Absyn.ComponentRef cref1, cref2;
+      Absyn.ForIterators iters;
+      Absyn.FunctionArgs func_args;
+      Absyn.AlgorithmItem alg;
+
+    case (Absyn.ALG_ASSIGN(e1, e2), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (e2, arg) = traverseExpBidir(e2, enterFunc, exitFunc, arg);
       then
-        (ALG_ASSIGN(e1, e2), arg);
-
-    case (ALG_IF(e1, algs1, else_branch, algs2), _, _, arg)
+        (Absyn.ALG_ASSIGN(e1, e2), arg);
+
+    case (Absyn.ALG_IF(e1, algs1, else_branch, algs2), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
@@ -1216 +1216 @@
         (else_branch, arg) = List.map2FoldCheckReferenceEq(else_branch, traverseAlgorithmBidirElse, enterFunc, exitFunc, arg);
         (algs2, arg) = traverseAlgorithmItemListBidir(algs2, enterFunc, exitFunc, arg);
-      then (ALG_IF(e1, algs1, else_branch, algs2), arg);
-
-    case (ALG_FOR(iters, algs1), _, _, arg)
+      then (Absyn.ALG_IF(e1, algs1, else_branch, algs2), arg);
+
+    case (Absyn.ALG_FOR(iters, algs1), _, _, arg)
       equation
         (iters, arg) = List.map2FoldCheckReferenceEq(iters, traverseExpBidirIterator, enterFunc, exitFunc, arg);
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
-      then (ALG_FOR(iters, algs1), arg);
-
-    case (ALG_PARFOR(iters, algs1), _, _, arg)
+      then (Absyn.ALG_FOR(iters, algs1), arg);
+
+    case (Absyn.ALG_PARFOR(iters, algs1), _, _, arg)
       equation
         (iters, arg) = List.map2FoldCheckReferenceEq(iters, traverseExpBidirIterator, enterFunc, exitFunc, arg);
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
-      then (ALG_PARFOR(iters, algs1), arg);
-
-    case (ALG_WHILE(e1, algs1), _, _, arg)
+      then (Absyn.ALG_PARFOR(iters, algs1), arg);
+
+    case (Absyn.ALG_WHILE(e1, algs1), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
-      then (ALG_WHILE(e1, algs1), arg);
-
-    case (ALG_WHEN_A(e1, algs1, else_branch), _, _, arg)
+      then (Absyn.ALG_WHILE(e1, algs1), arg);
+
+    case (Absyn.ALG_WHEN_A(e1, algs1, else_branch), _, _, arg)
       equation
         (e1, arg) = traverseExpBidir(e1, enterFunc, exitFunc, arg);
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
         (else_branch, arg) = List.map2FoldCheckReferenceEq(else_branch, traverseAlgorithmBidirElse, enterFunc, exitFunc, arg);
-      then (ALG_WHEN_A(e1, algs1, else_branch), arg);
-
-    case (ALG_NORETCALL(cref1, func_args), _, _, arg)
+      then (Absyn.ALG_WHEN_A(e1, algs1, else_branch), arg);
+
+    case (Absyn.ALG_NORETCALL(cref1, func_args), _, _, arg)
       equation
         (cref1, arg) = traverseExpBidirCref(cref1, enterFunc, exitFunc, arg);
         (func_args, arg) = traverseExpBidirFunctionArgs(func_args, enterFunc, exitFunc, arg);
       then
-        (ALG_NORETCALL(cref1, func_args), arg);
-
-    case (ALG_RETURN(), _, _, arg)
+        (Absyn.ALG_NORETCALL(cref1, func_args), arg);
+
+    case (Absyn.ALG_RETURN(), _, _, arg)
       then (inAlg, arg);
 
-    case (ALG_BREAK(), _, _, arg)
+    case (Absyn.ALG_BREAK(), _, _, arg)
       then (inAlg, arg);
 
-    case (ALG_CONTINUE(), _, _, arg)
+    case (Absyn.ALG_CONTINUE(), _, _, arg)
       then (inAlg, arg);
 
-    case (ALG_FAILURE(algs1), _, _, arg)
+    case (Absyn.ALG_FAILURE(algs1), _, _, arg)
       equation
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
       then
-        (ALG_FAILURE(algs1), arg);
-
-    case (ALG_TRY(algs1, algs2), _, _, arg)
+        (Absyn.ALG_FAILURE(algs1), arg);
+
+    case (Absyn.ALG_TRY(algs1, algs2), _, _, arg)
       equation
         (algs1, arg) = traverseAlgorithmItemListBidir(algs1, enterFunc, exitFunc, arg);
         (algs2, arg) = traverseAlgorithmItemListBidir(algs2, enterFunc, exitFunc, arg);
       then
-        (ALG_TRY(algs1, algs2), arg);
+        (Absyn.ALG_TRY(algs1, algs2), arg);
 
   end match;
@@ -1277 +1277 @@
 public function makeIdentPathFromString
   input String s;
-  output Path p;
-algorithm
-  p := IDENT(s);
+  output Absyn.Path p;
+algorithm
+  p := Absyn.IDENT(s);
 annotation(__OpenModelica_EarlyInline = true);
 end makeIdentPathFromString;
@@ -1286 +1286 @@
   input String s1;
   input String s2;
-  output Path p;
-algorithm
-  p := QUALIFIED(s1,IDENT(s2));
+  output Absyn.Path p;
+algorithm
+  p := Absyn.QUALIFIED(s1,Absyn.IDENT(s2));
 annotation(__OpenModelica_EarlyInline = true);
 end makeQualifiedPathFromStrings;
 
-public function className "returns the class name of a Class as a Path"
-  input Class cl;
-  output Path name;
+public function className "returns the class name of a Absyn.Class as a Absyn.Path"
+  input Absyn.Class cl;
+  output Absyn.Path name;
 protected
   String id;
 algorithm
-  CLASS(name = id) := cl;
-  name := IDENT(id);
+  Absyn.CLASS(name = id) := cl;
+  name := Absyn.IDENT(id);
 end className;
 
 public function isClassNamed
   input String inName;
-  input Class inClass;
+  input Absyn.Class inClass;
   output Boolean outIsNamed;
 algorithm
   outIsNamed := match inClass
-    case CLASS() then inName == inClass.name;
+    case Absyn.CLASS() then inName == inClass.name;
     else false;
   end match;
@@ -1314 +1314 @@
 
 public function elementSpecName
-  "The ElementSpec type contains the name of the element, and this function
+  "The Absyn.ElementSpec type contains the name of the element, and this function
    extracts this name."
-  input ElementSpec inElementSpec;
-  output Ident outIdent;
+  input Absyn.ElementSpec inElementSpec;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match (inElementSpec)
-    local Ident n;
-
-    case CLASSDEF(class_ = CLASS(name = n)) then n;
-    case COMPONENTS(components = {COMPONENTITEM(component = COMPONENT(name = n))}) then n;
+    local Absyn.Ident n;
+
+    case Absyn.CLASSDEF(class_ = Absyn.CLASS(name = n)) then n;
+    case Absyn.COMPONENTS(components = {Absyn.COMPONENTITEM(component = Absyn.COMPONENT(name = n))}) then n;
   end match;
 end elementSpecName;
 
 public function isClassdef
-  input Element inElement;
+  input Absyn.Element inElement;
   output Boolean b;
 algorithm
   b := match inElement
-    case ELEMENT(specification=CLASSDEF()) then true;
+    case Absyn.ELEMENT(specification=Absyn.CLASSDEF()) then true;
     else false;
   end match;
@@ -1338 +1338 @@
 
 public function printImportString
-  "This function takes a Import and prints it as a flat-string."
-  input Import imp;
+  "This function takes a Absyn.Import and prints it as a flat-string."
+  input Absyn.Import imp;
   output String ostring;
 algorithm
   ostring := match(imp)
     local
-      Path path;
+      Absyn.Path path;
       String name;
 
-    case(NAMED_IMPORT(name,_)) then name;
-    case(QUAL_IMPORT(path))
+    case(Absyn.NAMED_IMPORT(name,_)) then name;
+    case(Absyn.QUAL_IMPORT(path))
       equation
         name = pathString(path);
       then name;
 
-    case(UNQUAL_IMPORT(path))
+    case(Absyn.UNQUAL_IMPORT(path))
       equation
         name = pathString(path);
@@ -1361 +1361 @@
 
 public function expString "returns the string of an expression if it is a string constant."
-  input Exp exp;
+  input Absyn.Exp exp;
   output String str;
 algorithm
-  STRING(str) := exp;
+  Absyn.STRING(str) := exp;
 end expString;
 
 public function expCref "returns the componentRef of an expression if matches."
-  input Exp exp;
-  output ComponentRef cr;
-algorithm
-  CREF(cr) := exp;
+  input Absyn.Exp exp;
+  output Absyn.ComponentRef cr;
+algorithm
+  Absyn.CREF(cr) := exp;
 end expCref;
 
 public function crefExp "returns the componentRef of an expression if matches."
- input ComponentRef cr;
- output Exp exp;
-algorithm
-  exp := CREF(cr);
+ input Absyn.ComponentRef cr;
+ output Absyn.Exp exp;
+algorithm
+  exp := Absyn.CREF(cr);
 annotation(__OpenModelica_EarlyInline = true);
 end crefExp;
 
 public function expComponentRefStr
-  input Exp aexp;
+  input Absyn.Exp aexp;
   output String outString;
 algorithm
@@ -1390 +1390 @@
 
 public function printComponentRefStr
-  input ComponentRef cr;
+  input Absyn.ComponentRef cr;
   output String ostring;
 algorithm
@@ -1396 +1396 @@
     local
       String s1,s2;
-      ComponentRef child;
-    case(CREF_IDENT(s1,_)) then s1;
-    case(CREF_QUAL(s1,_,child))
+      Absyn.ComponentRef child;
+    case(Absyn.CREF_IDENT(s1,_)) then s1;
+    case(Absyn.CREF_QUAL(s1,_,child))
       equation
         s2 = printComponentRefStr(child);
         s1 = s1 + "." + s2;
       then s1;
-    case(CREF_FULLYQUALIFIED(child))
+    case(Absyn.CREF_FULLYQUALIFIED(child))
       equation
         s2 = printComponentRefStr(child);
         s1 = "." + s2;
       then s1;
-    case (ALLWILD()) then "__";
-    case (WILD()) then "_";
+    case (Absyn.ALLWILD()) then "__";
+    case (Absyn.WILD()) then "_";
   end match;
 end printComponentRefStr;
 
 public function pathEqual "Returns true if two paths are equal."
-  input Path inPath1;
-  input Path inPath2;
+  input Absyn.Path inPath1;
+  input Absyn.Path inPath2;
   output Boolean outBoolean;
 algorithm
@@ -1422 +1422 @@
       String id1,id2;
       Boolean res;
-      Path path1,path2;
+      Absyn.Path path1,path2;
     // fully qual vs. path
-    case (FULLYQUALIFIED(path1),path2) then pathEqual(path1,path2);
+    case (Absyn.FULLYQUALIFIED(path1),path2) then pathEqual(path1,path2);
     // path vs. fully qual
-    case (path1,FULLYQUALIFIED(path2)) then pathEqual(path1,path2);
+    case (path1,Absyn.FULLYQUALIFIED(path2)) then pathEqual(path1,path2);
     // ident vs. ident
-    case (IDENT(id1),IDENT(id2))
+    case (Absyn.IDENT(id1),Absyn.IDENT(id2))
       then stringEq(id1, id2);
     // qual ident vs. qual ident
-    case (QUALIFIED(id1, path1),QUALIFIED(id2, path2))
+    case (Absyn.QUALIFIED(id1, path1),Absyn.QUALIFIED(id2, path2))
       equation
         res = if stringEq(id1, id2) then pathEqual(path1, path2) else false;
@@ -1441 +1441 @@
 
 public function pathEqualCaseInsensitive "Returns true if two paths are equal."
-  input Path inPath1;
-  input Path inPath2;
+  input Absyn.Path inPath1;
+  input Absyn.Path inPath2;
   output Boolean outBoolean;
 algorithm
@@ -1449 +1449 @@
       String id1,id2;
       Boolean res;
-      Path path1,path2;
+      Absyn.Path path1,path2;
     // fully qual vs. path
-    case (FULLYQUALIFIED(path1),path2) then pathEqualCaseInsensitive(path1,path2);
+    case (Absyn.FULLYQUALIFIED(path1),path2) then pathEqualCaseInsensitive(path1,path2);
     // path vs. fully qual
-    case (path1,FULLYQUALIFIED(path2)) then pathEqualCaseInsensitive(path1,path2);
+    case (path1,Absyn.FULLYQUALIFIED(path2)) then pathEqualCaseInsensitive(path1,path2);
     // ident vs. ident
-    case (IDENT(id1),IDENT(id2))
+    case (Absyn.IDENT(id1),Absyn.IDENT(id2))
       then stringEq(System.tolower(id1), System.tolower(id2));
     // qual ident vs. qual ident
-    case (QUALIFIED(id1, path1),QUALIFIED(id2, path2))
+    case (Absyn.QUALIFIED(id1, path1),Absyn.QUALIFIED(id2, path2))
       equation
         res = if stringEq(System.tolower(id1), System.tolower(id2)) then pathEqualCaseInsensitive(path1, path2) else false;
@@ -1470 +1470 @@
   "Author BZ 2009-01
    Check whether two type specs are equal or not."
-  input TypeSpec a,b;
+  input Absyn.TypeSpec a,b;
   output Boolean ob;
 algorithm
   ob := matchcontinue(a,b)
     local
-      Path p1,p2;
-      Option<ArrayDim> oad1,oad2;
-      list<TypeSpec> lst1,lst2;
-      Ident i1, i2;
+      Absyn.Path p1,p2;
+      Option<Absyn.ArrayDim> oad1,oad2;
+      list<Absyn.TypeSpec> lst1,lst2;
+      Absyn.Ident i1, i2;
       Integer pos1, pos2;
 
     // first try full equality
-    case(TPATH(p1,oad1), TPATH(p2,oad2))
+    case(Absyn.TPATH(p1,oad1), Absyn.TPATH(p2,oad2))
       equation
         true = pathEqual(p1,p2);
@@ -1488 +1488 @@
       then true;
 
-    case(TCOMPLEX(p1,lst1,oad1),TCOMPLEX(p2,lst2,oad2))
+    case(Absyn.TCOMPLEX(p1,lst1,oad1),Absyn.TCOMPLEX(p2,lst2,oad2))
       equation
         true = pathEqual(p1,p2);
@@ -1502 +1502 @@
   "Author BZ
    helper function for typeSpecEqual"
-  input Option<ArrayDim> oad1,oad2;
+  input Option<Absyn.ArrayDim> oad1,oad2;
   output Boolean b;
 algorithm b:= matchcontinue(oad1,oad2)
   local
-    list<Subscript> ad1,ad2;
+    list<Absyn.Subscript> ad1,ad2;
   case(SOME(ad1),SOME(ad2))
     equation
@@ -1516 +1516 @@
 end optArrayDimEqual;
 
-public function typeSpecPathString "This function simply converts a Path to a string."
-  input TypeSpec tp;
+public function typeSpecPathString "This function simply converts a Absyn.Path to a string."
+  input Absyn.TypeSpec tp;
   output String s;
 algorithm s := match(tp)
-  local Path p;
-  case(TCOMPLEX(path = p)) then pathString(p);
-  case(TPATH(path = p)) then pathString(p);
+  local Absyn.Path p;
+  case(Absyn.TCOMPLEX(path = p)) then pathString(p);
+  case(Absyn.TPATH(path = p)) then pathString(p);
 end match;
 end typeSpecPathString;
 
 public function typeSpecPath
-  "Converts a TypeSpec to Path"
-  input TypeSpec tp;
-  output Path op;
+  "Converts a Absyn.TypeSpec to Absyn.Path"
+  input Absyn.TypeSpec tp;
+  output Absyn.Path op;
 algorithm
   op := match(tp)
-    local Path p;
-    case(TCOMPLEX(path = p)) then p;
-    case(TPATH(path = p)) then p;
+    local Absyn.Path p;
+    case(Absyn.TCOMPLEX(path = p)) then p;
+    case(Absyn.TPATH(path = p)) then p;
   end match;
 end typeSpecPath;
 
 public function typeSpecDimensions
-  "Returns the dimensions of a TypeSpec."
-  input TypeSpec inTypeSpec;
-  output ArrayDim outDimensions;
+  "Returns the dimensions of a Absyn.TypeSpec."
+  input Absyn.TypeSpec inTypeSpec;
+  output Absyn.ArrayDim outDimensions;
 algorithm
   outDimensions := match(inTypeSpec)
     local
-      ArrayDim dim;
-
-    case TPATH(arrayDim = SOME(dim)) then dim;
-    case TCOMPLEX(arrayDim = SOME(dim)) then dim;
+      Absyn.ArrayDim dim;
+
+    case Absyn.TPATH(arrayDim = SOME(dim)) then dim;
+    case Absyn.TCOMPLEX(arrayDim = SOME(dim)) then dim;
     else {};
 
@@ -1554 +1554 @@
 end typeSpecDimensions;
 
-public function pathString "This function simply converts a Path to a string."
-  input Path path;
+public function pathString "This function simply converts a Absyn.Path to a string."
+  input Absyn.Path path;
   input String delimiter=".";
   input Boolean usefq=true;
@@ -1561 +1561 @@
   output String s;
 protected
-  Path p1,p2;
+  Absyn.Path p1,p2;
   Integer count=0, len=0, dlen=stringLength(delimiter);
   Boolean b;
@@ -1568 +1568 @@
   p1 :=  if usefq then path else makeNotFullyQualified(path);
   _ := match p1
-    case IDENT()
+    case Absyn.IDENT()
       algorithm
         // Do not allocate memory if we're just going to copy the only identifier
@@ -1580 +1580 @@
   while b loop
     (p2,len,count,b) := match p2
-      case IDENT() then (p2,len+1,count+stringLength(p2.name),false);
-      case QUALIFIED() then (p2.path,len+1,count+stringLength(p2.name),true);
-      case FULLYQUALIFIED() then (p2.path,len+1,count,true);
+      case Absyn.IDENT() then (p2,len+1,count+stringLength(p2.name),false);
+      case Absyn.QUALIFIED() then (p2.path,len+1,count+stringLength(p2.name),true);
+      case Absyn.FULLYQUALIFIED() then (p2.path,len+1,count,true);
     end match;
   end while;
@@ -1591 +1591 @@
 
 function pathStringWork
-  input Path inPath;
+  input Absyn.Path inPath;
   input Integer len;
   input String delimiter;
@@ -1598 +1598 @@
   output String s="";
 protected
-  Path p=inPath;
+  Absyn.Path p=inPath;
   Boolean b=true;
   Integer count=0;
@@ -1607 +1607 @@
   while b loop
     (p,count,b) := match p
-      case IDENT()
+      case Absyn.IDENT()
         algorithm
           System.stringAllocatorStringCopy(sb, p.name, if reverse then len-count-stringLength(p.name) else count);
         then (p,count+stringLength(p.name),false);
-      case QUALIFIED()
+      case Absyn.QUALIFIED()
         algorithm
           System.stringAllocatorStringCopy(sb, p.name, if reverse then len-count-dlen-stringLength(p.name) else count);
           System.stringAllocatorStringCopy(sb, delimiter, if reverse then len-count-dlen else count+stringLength(p.name));
         then (p.path,count+stringLength(p.name)+dlen,true);
-      case FULLYQUALIFIED()
+      case Absyn.FULLYQUALIFIED()
         algorithm
           System.stringAllocatorStringCopy(sb, delimiter, if reverse then len-count-dlen else count);
@@ -1631 +1631 @@
 
 function pathStringDefault
-  input Path path;
+  input Absyn.Path path;
   output String s = pathString(path);
 end pathStringDefault;
 
 public function classNameCompare
-  input Class c1,c2;
+  input Absyn.Class c1,c2;
   output Integer o;
 algorithm
@@ -1643 +1643 @@
 
 public function classNameGreater
-  input Class c1,c2;
+  input Absyn.Class c1,c2;
   output Boolean b;
 algorithm
@@ -1650 +1650 @@
 
 public function pathCompare
-  input Path ip1;
-  input Path ip2;
+  input Absyn.Path ip1;
+  input Absyn.Path ip2;
   output Integer o;
 algorithm
   o := match (ip1,ip2)
     local
-      Path p1,p2;
+      Absyn.Path p1,p2;
       String i1,i2;
-    case (FULLYQUALIFIED(p1),FULLYQUALIFIED(p2)) then pathCompare(p1,p2);
-    case (FULLYQUALIFIED(),_) then 1;
-    case (_,FULLYQUALIFIED()) then -1;
-    case (QUALIFIED(i1,p1),QUALIFIED(i2,p2))
+    case (Absyn.FULLYQUALIFIED(p1),Absyn.FULLYQUALIFIED(p2)) then pathCompare(p1,p2);
+    case (Absyn.FULLYQUALIFIED(),_) then 1;
+    case (_,Absyn.FULLYQUALIFIED()) then -1;
+    case (Absyn.QUALIFIED(i1,p1),Absyn.QUALIFIED(i2,p2))
       equation
         o = stringCompare(i1,i2);
         o = if o == 0 then pathCompare(p1, p2) else o;
       then o;
-    case (QUALIFIED(),_) then 1;
-    case (_,QUALIFIED()) then -1;
-    case (IDENT(i1),IDENT(i2))
+    case (Absyn.QUALIFIED(),_) then 1;
+    case (_,Absyn.QUALIFIED()) then -1;
+    case (Absyn.IDENT(i1),Absyn.IDENT(i2))
       then stringCompare(i1,i2);
   end match;
@@ -1674 +1674 @@
 
 public function pathCompareNoQual
-  input Path ip1;
-  input Path ip2;
+  input Absyn.Path ip1;
+  input Absyn.Path ip2;
   output Integer o;
 algorithm
   o := match (ip1,ip2)
     local
-      Path p1,p2;
+      Absyn.Path p1,p2;
       String i1,i2;
-    case (FULLYQUALIFIED(p1),p2) then pathCompareNoQual(p1,p2);
-    case (p1,FULLYQUALIFIED(p2)) then pathCompareNoQual(p1,p2);
-    case (QUALIFIED(i1,p1),QUALIFIED(i2,p2))
+    case (Absyn.FULLYQUALIFIED(p1),p2) then pathCompareNoQual(p1,p2);
+    case (p1,Absyn.FULLYQUALIFIED(p2)) then pathCompareNoQual(p1,p2);
+    case (Absyn.QUALIFIED(i1,p1),Absyn.QUALIFIED(i2,p2))
       equation
         o = stringCompare(i1,i2);
         o = if o == 0 then pathCompare(p1, p2) else o;
       then o;
-    case (QUALIFIED(),_) then 1;
-    case (_,QUALIFIED()) then -1;
-    case (IDENT(i1),IDENT(i2))
+    case (Absyn.QUALIFIED(),_) then 1;
+    case (_,Absyn.QUALIFIED()) then -1;
+    case (Absyn.IDENT(i1),Absyn.IDENT(i2))
       then stringCompare(i1,i2);
   end match;
@@ -1697 +1697 @@
 
 public function pathHashMod "Hashes a path."
-  input Path path;
+  input Absyn.Path path;
   input Integer mod;
   output Integer hash;
@@ -1709 +1709 @@
 
 public function pathHashModWork "Hashes a path."
-  input Path path;
+  input Absyn.Path path;
   input Integer acc;
   output Integer hash;
@@ -1715 +1715 @@
   hash := match (path,acc)
     local
-      Path p;
+      Absyn.Path p;
       String s;
       Integer i,i2;
-    case (FULLYQUALIFIED(p),_) then pathHashModWork(p, acc*31 + 46 /* '.' */);
-    case (QUALIFIED(s,p),_) equation i = stringHashDjb2(s); i2 = acc*31+46; then pathHashModWork(p, i2*31 + i);
-    case (IDENT(s),_) equation i = stringHashDjb2(s); i2 = acc*31+46; then i2*31 + i;
+    case (Absyn.FULLYQUALIFIED(p),_) then pathHashModWork(p, acc*31 + 46 /* '.' */);
+    case (Absyn.QUALIFIED(s,p),_) equation i = stringHashDjb2(s); i2 = acc*31+46; then pathHashModWork(p, i2*31 + i);
+    case (Absyn.IDENT(s),_) equation i = stringHashDjb2(s); i2 = acc*31+46; then i2*31 + i;
   end match;
 end pathHashModWork;
 
 public function optPathString "Returns a path converted to string or an empty string if nothing exist"
-  input Option<Path> inPathOption;
+  input Option<Absyn.Path> inPathOption;
   output String outString;
 algorithm
   outString := match (inPathOption)
     local
-      Ident str;
-      Path p;
+      Absyn.Ident str;
+      Absyn.Path p;
     case (NONE()) then "";
     case (SOME(p))
@@ -1747 +1747 @@
   (Replaces dots with that separator). And also unquotes each ident.
 "
-  input Path inPath;
+  input Absyn.Path inPath;
   input String repStr;
   output String outString;
@@ -1764 +1764 @@
   "Converts a string into a qualified path."
   input String str;
-  output Path qualifiedPath;
+  output Absyn.Path qualifiedPath;
 
 protected
@@ -1776 +1776 @@
   "Converts a list of strings into a qualified path."
   input list<String> paths;
-  output Path qualifiedPath;
+  output Absyn.Path qualifiedPath;
 algorithm
   qualifiedPath := matchcontinue(paths)
@@ -1782 +1782 @@
       String str;
       list<String> rest_str;
-      Path p;
+      Absyn.Path p;
     case ({}) then fail();
-    case (str :: {}) then IDENT(str);
+    case (str :: {}) then Absyn.IDENT(str);
     case (str :: rest_str)
       equation
         p = stringListPath(rest_str);
       then
-        QUALIFIED(str, p);
+        Absyn.QUALIFIED(str, p);
   end matchcontinue;
 end stringListPath;
@@ -1797 +1797 @@
    Ex: {'a', 'b', 'c'} => c.b.a"
   input list<String> inStrings;
-  output Path outPath;
+  output Absyn.Path outPath;
 protected
   String id;
   list<String> rest_str;
-  Path path;
+  Absyn.Path path;
 algorithm
   id :: rest_str := inStrings;
-  path := IDENT(id);
+  path := Absyn.IDENT(id);
   outPath := stringListPathReversed2(rest_str, path);
 end stringListPathReversed;
@@ -1810 +1810 @@
 protected function stringListPathReversed2
   input list<String> inStrings;
-  input Path inAccumPath;
-  output Path outPath;
+  input Absyn.Path inAccumPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inStrings, inAccumPath)
@@ -1817 +1817 @@
       String id;
       list<String> rest_str;
-      Path path;
+      Absyn.Path path;
 
     case ({}, _) then inAccumPath;
@@ -1823 +1823 @@
     case (id :: rest_str, _)
       equation
-        path = QUALIFIED(id, inAccumPath);
+        path = Absyn.QUALIFIED(id, inAccumPath);
       then
         stringListPathReversed2(rest_str, path);
@@ -1831 +1831 @@
 
 public function pathTwoLastIdents "Returns the two last idents of a path"
-  input Path inPath;
-  output Path outTwoLast;
+  input Absyn.Path inPath;
+  output Absyn.Path outTwoLast;
 algorithm
   outTwoLast := match(inPath)
     local
-      Path p;
-
-    case QUALIFIED(path = IDENT()) then inPath;
-    case QUALIFIED(path = p) then pathTwoLastIdents(p);
-    case FULLYQUALIFIED(path = p) then pathTwoLastIdents(p);
+      Absyn.Path p;
+
+    case Absyn.QUALIFIED(path = Absyn.IDENT()) then inPath;
+    case Absyn.QUALIFIED(path = p) then pathTwoLastIdents(p);
+    case Absyn.FULLYQUALIFIED(path = p) then pathTwoLastIdents(p);
   end match;
 end pathTwoLastIdents;
@@ -1846 +1846 @@
 public function pathLastIdent
   "Returns the last ident (after last dot) in a path"
-  input Path inPath;
+  input Absyn.Path inPath;
   output String outIdent;
 algorithm
   outIdent := match(inPath)
     local
-      Ident id;
-      Path p;
-
-    case QUALIFIED(path = p) then pathLastIdent(p);
-    case IDENT(name = id) then id;
-    case FULLYQUALIFIED(path = p) then pathLastIdent(p);
+      Absyn.Ident id;
+      Absyn.Path p;
+
+    case Absyn.QUALIFIED(path = p) then pathLastIdent(p);
+    case Absyn.IDENT(name = id) then id;
+    case Absyn.FULLYQUALIFIED(path = p) then pathLastIdent(p);
   end match;
 end pathLastIdent;
@@ -1862 +1862 @@
 public function pathLast
   "Returns the last ident (after last dot) in a path"
-  input output Path path;
+  input output Absyn.Path path;
 algorithm
   path := match path
     local
-      Path p;
-    case QUALIFIED(path = p) then pathLast(p);
-    case IDENT() then path;
-    case FULLYQUALIFIED(path = p) then pathLast(p);
+      Absyn.Path p;
+    case Absyn.QUALIFIED(path = p) then pathLast(p);
+    case Absyn.IDENT() then path;
+    case Absyn.FULLYQUALIFIED(path = p) then pathLast(p);
   end match;
 end pathLast;
 
 public function pathFirstIdent "Returns the first ident (before first dot) in a path"
-  input Path inPath;
-  output Ident outIdent;
+  input Absyn.Path inPath;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match (inPath)
     local
-      Ident n;
-      Path p;
-
-    case (FULLYQUALIFIED(path = p)) then pathFirstIdent(p);
-    case (QUALIFIED(name = n)) then n;
-    case (IDENT(name = n)) then n;
+      Absyn.Ident n;
+      Absyn.Path p;
+
+    case (Absyn.FULLYQUALIFIED(path = p)) then pathFirstIdent(p);
+    case (Absyn.QUALIFIED(name = n)) then n;
+    case (Absyn.IDENT(name = n)) then n;
   end match;
 end pathFirstIdent;
 
 public function pathFirstPath
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match inPath
     local
-      Ident n;
-
-    case IDENT() then inPath;
-    case QUALIFIED(name = n) then IDENT(n);
-    case FULLYQUALIFIED(path = outPath) then pathFirstPath(outPath);
+      Absyn.Ident n;
+
+    case Absyn.IDENT() then inPath;
+    case Absyn.QUALIFIED(name = n) then Absyn.IDENT(n);
+    case Absyn.FULLYQUALIFIED(path = outPath) then pathFirstPath(outPath);
   end match;
 end pathFirstPath;
 
 public function pathSecondIdent
-  input Path inPath;
-  output Ident outIdent;
+  input Absyn.Path inPath;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match(inPath)
     local
-      Ident n;
-      Path p;
-
-    case QUALIFIED(path = QUALIFIED(name = n)) then n;
-    case QUALIFIED(path = IDENT(name = n)) then n;
-    case FULLYQUALIFIED(path = p) then pathSecondIdent(p);
+      Absyn.Ident n;
+      Absyn.Path p;
+
+    case Absyn.QUALIFIED(path = Absyn.QUALIFIED(name = n)) then n;
+    case Absyn.QUALIFIED(path = Absyn.IDENT(name = n)) then n;
+    case Absyn.FULLYQUALIFIED(path = p) then pathSecondIdent(p);
 
   end match;
@@ -1919 +1919 @@
 
 public function pathRest
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match inPath
-    case QUALIFIED(path = outPath) then outPath;
-    case FULLYQUALIFIED(path = outPath) then pathRest(outPath);
+    case Absyn.QUALIFIED(path = outPath) then outPath;
+    case Absyn.FULLYQUALIFIED(path = outPath) then pathRest(outPath);
   end match;
 end pathRest;
@@ -1936 +1936 @@
   outPath := matchcontinue(inPath1, inPath2)
     local
-      Ident ident1, ident2;
+      Absyn.Ident ident1, ident2;
       Absyn.Path path1, path2;
 
@@ -1955 +1955 @@
 public function pathPrefix
   "Returns the prefix of a path, i.e. this.is.a.path => this.is.a"
-  input Path path;
-  output Path prefix;
+  input Absyn.Path path;
+  output Absyn.Path prefix;
 algorithm
   prefix := matchcontinue(path)
     local
-      Path p;
-      Ident n;
-
-    case (FULLYQUALIFIED(path = p)) then pathPrefix(p);
-    case (QUALIFIED(name = n, path = IDENT())) then IDENT(n);
-    case (QUALIFIED(name = n, path = p))
+      Absyn.Path p;
+      Absyn.Ident n;
+
+    case (Absyn.FULLYQUALIFIED(path = p)) then pathPrefix(p);
+    case (Absyn.QUALIFIED(name = n, path = Absyn.IDENT())) then Absyn.IDENT(n);
+    case (Absyn.QUALIFIED(name = n, path = p))
       equation
         p = pathPrefix(p);
       then
-        QUALIFIED(n, p);
+        Absyn.QUALIFIED(n, p);
   end matchcontinue;
 end pathPrefix;
@@ -1975 +1975 @@
 public function prefixPath
   "Prefixes a path with an identifier."
-  input Ident prefix;
-  input Path path;
-  output Path outPath;
-algorithm
-  outPath := QUALIFIED(prefix, path);
+  input Absyn.Ident prefix;
+  input Absyn.Path path;
+  output Absyn.Path outPath;
+algorithm
+  outPath := Absyn.QUALIFIED(prefix, path);
 end prefixPath;
 
 public function prefixOptPath
   "Prefixes an optional path with an identifier."
-  input Ident prefix;
-  input Option<Path> optPath;
-  output Option<Path> outPath;
+  input Absyn.Ident prefix;
+  input Option<Absyn.Path> optPath;
+  output Option<Absyn.Path> outPath;
 algorithm
   outPath := match(prefix, optPath)
     local
-      Path path;
-
-    case (_, NONE()) then SOME(IDENT(prefix));
-    case (_, SOME(path)) then SOME(QUALIFIED(prefix, path));
+      Absyn.Path path;
+
+    case (_, NONE()) then SOME(Absyn.IDENT(prefix));
+    case (_, SOME(path)) then SOME(Absyn.QUALIFIED(prefix, path));
   end match;
 end prefixOptPath;
@@ -2000 +2000 @@
   "Adds a suffix to a path. Ex:
      suffixPath(a.b.c, 'd') => a.b.c.d"
-  input Path inPath;
-  input Ident inSuffix;
-  output Path outPath;
+  input Absyn.Path inPath;
+  input Absyn.Ident inSuffix;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inPath, inSuffix)
     local
-      Ident name;
-      Path path;
-
-    case (IDENT(name), _)
-      then QUALIFIED(name, IDENT(inSuffix));
-
-    case (QUALIFIED(name, path), _)
+      Absyn.Ident name;
+      Absyn.Path path;
+
+    case (Absyn.IDENT(name), _)
+      then Absyn.QUALIFIED(name, Absyn.IDENT(inSuffix));
+
+    case (Absyn.QUALIFIED(name, path), _)
       equation
         path = suffixPath(path, inSuffix);
       then
-        QUALIFIED(name, path);
-
-    case (FULLYQUALIFIED(path), _)
+        Absyn.QUALIFIED(name, path);
+
+    case (Absyn.FULLYQUALIFIED(path), _)
       equation
         path = suffixPath(path, inSuffix);
       then
-        FULLYQUALIFIED(path);
+        Absyn.FULLYQUALIFIED(path);
 
   end match;
@@ -2028 +2028 @@
 
 public function pathSuffixOf "returns true if suffix_path is a suffix of path"
-  input Path suffix_path;
-  input Path path;
+  input Absyn.Path suffix_path;
+  input Absyn.Path path;
   output Boolean res;
 algorithm
   res := matchcontinue(suffix_path,path)
-  local Path p;
+  local Absyn.Path p;
     case(_,_)
       equation
       true = pathEqual(suffix_path,path);
       then true;
-    case(_,FULLYQUALIFIED(path = p))
+    case(_,Absyn.FULLYQUALIFIED(path = p))
       then pathSuffixOf(suffix_path,p);
-    case(_,QUALIFIED(path = p))
+    case(_,Absyn.QUALIFIED(path = p))
       then pathSuffixOf(suffix_path,p);
     else false;
@@ -2047 +2047 @@
 
 public function pathSuffixOfr "returns true if suffix_path is a suffix of path"
-  input Path path;
-  input Path suffix_path;
+  input Absyn.Path path;
+  input Absyn.Path suffix_path;
   output Boolean res;
 algorithm
@@ -2055 +2055 @@
 
 public function pathToStringList
-  input Path path;
+  input Absyn.Path path;
   output list<String> outPaths;
 algorithm
@@ -2062 +2062 @@
 
 protected function pathToStringListWork
-  input Path path;
+  input Absyn.Path path;
   input list<String> acc;
   output list<String> outPaths;
@@ -2069 +2069 @@
     local
       String n;
-      Path p;
+      Absyn.Path p;
       list<String> strings;
 
-    case (IDENT(name = n),_) then n::acc;
-    case (FULLYQUALIFIED(path = p),_) then pathToStringListWork(p,acc);
-    case (QUALIFIED(name = n,path = p),_)
+    case (Absyn.IDENT(name = n),_) then n::acc;
+    case (Absyn.FULLYQUALIFIED(path = p),_) then pathToStringListWork(p,acc);
+    case (Absyn.QUALIFIED(name = n,path = p),_)
       then pathToStringListWork(p,n::acc);
   end match;
@@ -2084 +2084 @@
   (a, b.c.d) => b.c.d
 "
-  input Path path;
-  input Path replPath;
-  output Path outPath;
+  input Absyn.Path path;
+  input Absyn.Path replPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(path,replPath)
     local
-      Path p;
+      Absyn.Path p;
     // Should not be possible to replace FQ paths
-    case (QUALIFIED(path = p), _) then joinPaths(replPath,p);
-    case (IDENT(), _) then replPath;
+    case (Absyn.QUALIFIED(path = p), _) then joinPaths(replPath,p);
+    case (Absyn.IDENT(), _) then replPath;
   end match;
 end pathReplaceFirstIdent;
@@ -2099 +2099 @@
 public function addSubscriptsLast
   "Function for appending subscripts at end of last ident"
-  input ComponentRef icr;
-  input list<Subscript> i;
-  output ComponentRef ocr;
+  input Absyn.ComponentRef icr;
+  input list<Absyn.Subscript> i;
+  output Absyn.ComponentRef ocr;
 algorithm
   ocr := match(icr,i)
     local
-      list<Subscript> subs;
+      list<Absyn.Subscript> subs;
       String id;
-      ComponentRef cr;
-
-    case (CREF_IDENT(id,subs),_)
-      then CREF_IDENT(id, listAppend(subs, i));
-
-    case (CREF_QUAL(id,subs,cr),_)
+      Absyn.ComponentRef cr;
+
+    case (Absyn.CREF_IDENT(id,subs),_)
+      then Absyn.CREF_IDENT(id, listAppend(subs, i));
+
+    case (Absyn.CREF_QUAL(id,subs,cr),_)
       equation
         cr = addSubscriptsLast(cr,i);
       then
-        CREF_QUAL(id,subs,cr);
-    case (CREF_FULLYQUALIFIED(cr),_)
+        Absyn.CREF_QUAL(id,subs,cr);
+    case (Absyn.CREF_FULLYQUALIFIED(cr),_)
       equation
         cr = addSubscriptsLast(cr,i);
@@ -2130 +2130 @@
   (a[3], b.c.d) => b.c.d[3]
 "
-  input ComponentRef icref;
-  input Path replPath;
-  output ComponentRef outCref;
+  input Absyn.ComponentRef icref;
+  input Absyn.Path replPath;
+  output Absyn.ComponentRef outCref;
 algorithm
   outCref := match(icref,replPath)
     local
-      list<Subscript> subs;
-      ComponentRef cr,cref;
-    case (CREF_FULLYQUALIFIED(componentRef = cr),_)
+      list<Absyn.Subscript> subs;
+      Absyn.ComponentRef cr,cref;
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr),_)
       equation
         cr = crefReplaceFirstIdent(cr,replPath);
       then crefMakeFullyQualified(cr);
-    case (CREF_QUAL(componentRef = cr, subscripts = subs),_)
+    case (Absyn.CREF_QUAL(componentRef = cr, subscripts = subs),_)
       equation
         cref = pathToCref(replPath);
         cref = addSubscriptsLast(cref,subs);
       then joinCrefs(cref,cr);
-    case (CREF_IDENT(subscripts = subs),_)
+    case (Absyn.CREF_IDENT(subscripts = subs),_)
       equation
         cref = pathToCref(replPath);
@@ -2157 +2157 @@
 public function pathPrefixOf
   "Returns true if prefixPath is a prefix of path, false otherwise."
-  input Path prefixPath;
-  input Path path;
+  input Absyn.Path prefixPath;
+  input Absyn.Path path;
   output Boolean isPrefix;
 algorithm
   isPrefix := matchcontinue(prefixPath, path)
     local
-      Path p, p2;
+      Absyn.Path p, p2;
       String id, id2;
-    case (FULLYQUALIFIED(p), p2) then pathPrefixOf(p, p2);
-    case (p, FULLYQUALIFIED(p2)) then pathPrefixOf(p, p2);
-    case (IDENT(id), IDENT(id2)) then stringEq(id, id2);
-    case (IDENT(id), QUALIFIED(name = id2)) then stringEq(id, id2);
-    case (QUALIFIED(id, p), QUALIFIED(id2, p2))
+    case (Absyn.FULLYQUALIFIED(p), p2) then pathPrefixOf(p, p2);
+    case (p, Absyn.FULLYQUALIFIED(p2)) then pathPrefixOf(p, p2);
+    case (Absyn.IDENT(id), Absyn.IDENT(id2)) then stringEq(id, id2);
+    case (Absyn.IDENT(id), Absyn.QUALIFIED(name = id2)) then stringEq(id, id2);
+    case (Absyn.QUALIFIED(id, p), Absyn.QUALIFIED(id2, p2))
       equation
         true = stringEq(id, id2);
@@ -2185 +2185 @@
   Returns true if prefixCr is a prefix of cr, i.e., false otherwise.
   Subscripts are NOT checked."
-  input ComponentRef prefixCr;
-  input ComponentRef cr;
+  input Absyn.ComponentRef prefixCr;
+  input Absyn.ComponentRef cr;
   output Boolean out;
 algorithm
@@ -2201 +2201 @@
 
 public function removePrefix "removes the prefix_path from path, and returns the rest of path"
-  input Path prefix_path;
-  input Path path;
-  output Path newPath;
+  input Absyn.Path prefix_path;
+  input Absyn.Path path;
+  output Absyn.Path newPath;
 algorithm
   newPath := match(prefix_path,path)
-    local Path p,p2; Ident id1,id2;
+    local Absyn.Path p,p2; Absyn.Ident id1,id2;
     // fullyqual path
-    case (p,FULLYQUALIFIED(p2)) then removePrefix(p,p2);
+    case (p,Absyn.FULLYQUALIFIED(p2)) then removePrefix(p,p2);
     // qual
-    case (QUALIFIED(name=id1,path=p),QUALIFIED(name=id2,path=p2))
+    case (Absyn.QUALIFIED(name=id1,path=p),Absyn.QUALIFIED(name=id2,path=p2))
       equation
         true = stringEq(id1, id2);
@@ -2216 +2216 @@
         removePrefix(p,p2);
     // ids
-    case(IDENT(id1),QUALIFIED(name=id2,path=p2))
+    case(Absyn.IDENT(id1),Absyn.QUALIFIED(name=id2,path=p2))
       equation
         true = stringEq(id1, id2);
@@ -2229 +2229 @@
     removePartialPrefix(A.B.C, B.C.D.E) => D.E
   "
-  input Path inPrefix;
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPrefix;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := matchcontinue(inPrefix, inPath)
     local
-      Path p;
+      Absyn.Path p;
 
     case (_, _)
@@ -2243 +2243 @@
         p;
 
-    case (QUALIFIED(path = p), _)
+    case (Absyn.QUALIFIED(path = p), _)
       equation
         p = removePrefix(p, inPath);
@@ -2249 +2249 @@
         p;
 
-    case (FULLYQUALIFIED(path = p), _)
+    case (Absyn.FULLYQUALIFIED(path = p), _)
       equation
         p = removePartialPrefix(p, inPath);
@@ -2268 +2268 @@
   otherwise fails. Subscripts are NOT checked.
 "
-  input ComponentRef prefixCr;
-  input ComponentRef cr;
-  output ComponentRef out;
+  input Absyn.ComponentRef prefixCr;
+  input Absyn.ComponentRef cr;
+  output Absyn.ComponentRef out;
 algorithm
   out := match(prefixCr, cr)
     local
-      Ident prefixIdent, ident;
-      ComponentRef prefixRestCr, restCr;
+      Absyn.Ident prefixIdent, ident;
+      Absyn.ComponentRef prefixRestCr, restCr;
     // fqual
-    case(CREF_FULLYQUALIFIED(componentRef = prefixRestCr), CREF_FULLYQUALIFIED(componentRef = restCr))
+    case(Absyn.CREF_FULLYQUALIFIED(componentRef = prefixRestCr), Absyn.CREF_FULLYQUALIFIED(componentRef = restCr))
       then
         crefRemovePrefix(prefixRestCr, restCr);
     // qual
-    case(CREF_QUAL(name = prefixIdent, componentRef = prefixRestCr), CREF_QUAL(name = ident, componentRef = restCr))
+    case(Absyn.CREF_QUAL(name = prefixIdent, componentRef = prefixRestCr), Absyn.CREF_QUAL(name = ident, componentRef = restCr))
       equation
         true = stringEq(prefixIdent, ident);
@@ -2287 +2287 @@
         crefRemovePrefix(prefixRestCr, restCr);
     // id vs. qual
-    case(CREF_IDENT(name = prefixIdent), CREF_QUAL(name = ident, componentRef = restCr))
+    case(Absyn.CREF_IDENT(name = prefixIdent), Absyn.CREF_QUAL(name = ident, componentRef = restCr))
       equation
         true = stringEq(prefixIdent, ident);
       then restCr;
     // id vs. id
-    case(CREF_IDENT(name = prefixIdent), CREF_IDENT(name = ident))
+    case(Absyn.CREF_IDENT(name = prefixIdent), Absyn.CREF_IDENT(name = ident))
       equation
         true = stringEq(prefixIdent, ident);
-      then CREF_IDENT("", {});
+      then Absyn.CREF_IDENT("", {});
   end match;
 end crefRemovePrefix;
@@ -2301 +2301 @@
 public function pathContains
   "Author BZ,
-   checks if one IDENT(..) is contained in path."
-  input Path fullPath;
-  input Path pathId;
+   checks if one Absyn.IDENT(..) is contained in path."
+  input Absyn.Path fullPath;
+  input Absyn.Path pathId;
   output Boolean b;
 algorithm
@@ -2309 +2309 @@
     local
       String str1,str2;
-      Path qp;
+      Absyn.Path qp;
       Boolean b1,b2;
 
-    case(IDENT(str1),IDENT(str2)) then stringEq(str1,str2);
-
-    case(QUALIFIED(str1,qp),IDENT(str2))
+    case(Absyn.IDENT(str1),Absyn.IDENT(str2)) then stringEq(str1,str2);
+
+    case(Absyn.QUALIFIED(str1,qp),Absyn.IDENT(str2))
       equation
         b1 = stringEq(str1,str2);
@@ -2322 +2322 @@
         b1;
 
-    case(FULLYQUALIFIED(qp),_) then pathContains(qp,pathId);
+    case(Absyn.FULLYQUALIFIED(qp),_) then pathContains(qp,pathId);
   end match;
 end pathContains;
@@ -2328 +2328 @@
 public function pathContainsString
   "Author OT,
-   checks if Path contains the given string."
-  input Path p1;
+   checks if Absyn.Path contains the given string."
+  input Absyn.Path p1;
   input String str;
   output Boolean b;
@@ -2336 +2336 @@
     local
       String str1,searchStr;
-      Path qp;
+      Absyn.Path qp;
       Boolean b1,b2,b3;
 
-    case(IDENT(str1),searchStr)
+    case(Absyn.IDENT(str1),searchStr)
       equation
         b1 = System.stringFind(str1,searchStr) <> -1;
       then b1;
 
-    case(QUALIFIED(str1,qp),searchStr)
+    case(Absyn.QUALIFIED(str1,qp),searchStr)
       equation
         b1 = System.stringFind(str1, searchStr) <> -1;
@@ -2352 +2352 @@
         b3;
 
-    case(FULLYQUALIFIED(qp), searchStr) then pathContainsString(qp, searchStr);
+    case(Absyn.FULLYQUALIFIED(qp), searchStr) then pathContainsString(qp, searchStr);
   end match;
 end pathContainsString;
@@ -2364 +2364 @@
      pathContainedIn(A.B.C.D, A.B.C.D) => A.B.C.D
      pathContainedIn(B.C,A.B) => A.B.C"
-  input Path subPath;
-  input Path path;
-  output Path completePath;
+  input Absyn.Path subPath;
+  input Absyn.Path path;
+  output Absyn.Path completePath;
 algorithm
   completePath := matchcontinue(subPath,path)
     local
-      Ident ident;
-      Path newPath,newSubPath;
+      Absyn.Ident ident;
+      Absyn.Path newPath,newSubPath;
 
     // A suffix, e.g. C.D in A.B.C.D
@@ -2385 +2385 @@
         newPath = stripLast(path);
         newPath=pathContainedIn(subPath,newPath);
-      then joinPaths(newPath,IDENT(ident));
+      then joinPaths(newPath,Absyn.IDENT(ident));
 
     // strip last ident of subpath and recursively check if suffix.
@@ -2393 +2393 @@
         newSubPath = stripLast(subPath);
         newSubPath=pathContainedIn(newSubPath,path);
-      then joinPaths(newSubPath,IDENT(ident));
+      then joinPaths(newSubPath,Absyn.IDENT(ident));
 
   end matchcontinue;
@@ -2401 +2401 @@
   "Author BZ 2009-08
    Function for getting ComponentRefs out from Subscripts"
-  input list<Subscript> isubs;
+  input list<Absyn.Subscript> isubs;
   input Boolean includeSubs "include crefs from array subscripts";
   input Boolean includeFunctions "note that if you say includeSubs = false then you won't get the functions from array subscripts";
-  output list<ComponentRef> crefs;
+  output list<Absyn.ComponentRef> crefs;
 algorithm
   crefs := match(isubs,includeSubs,includeFunctions)
     local
-      list<ComponentRef> crefs1;
-      Exp exp;
-      list<Subscript> subs;
+      list<Absyn.ComponentRef> crefs1;
+      Absyn.Exp exp;
+      list<Absyn.Subscript> subs;
 
     case({},_,_) then {};
 
-    case(NOSUB()::subs,_,_) then getCrefsFromSubs(subs,includeSubs,includeFunctions);
-
-    case(SUBSCRIPT(exp)::subs,_,_)
+    case(Absyn.NOSUB()::subs,_,_) then getCrefsFromSubs(subs,includeSubs,includeFunctions);
+
+    case(Absyn.SUBSCRIPT(exp)::subs,_,_)
       equation
         crefs1 = getCrefsFromSubs(subs,includeSubs,includeFunctions);
@@ -2428 +2428 @@
   "Returns a flattened list of the
    component references in an expression"
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input Boolean includeSubs "include crefs from array subscripts";
   input Boolean includeFunctions "note that if you say includeSubs = false then you won't get the functions from array subscripts";
-  output list<ComponentRef> outComponentRefLst;
+  output list<Absyn.ComponentRef> outComponentRefLst;
 algorithm
   outComponentRefLst := match (inExp,includeSubs,includeFunctions)
     local
-      ComponentRef cr;
-      list<ComponentRef> l1,l2,res;
-      ComponentCondition e1,e2,e3;
-      Operator op;
-      list<tuple<ComponentCondition, ComponentCondition>> e4;
-      FunctionArgs farg;
-      list<ComponentCondition> expl;
-      list<list<ComponentCondition>> expll;
-      list<Subscript> subs;
-      list<list<ComponentRef>> lstres1;
-      list<list<ComponentRef>> crefll;
-
-    case (INTEGER(),_,_) then {};
-    case (REAL(),_,_) then {};
-    case (STRING(),_,_) then {};
-    case (BOOL(),_,_) then {};
-    case (CREF(componentRef = ALLWILD()),_,_) then {};
-    case (CREF(componentRef = WILD()),_,_) then {};
-    case (CREF(componentRef = cr),false,_) then {cr};
-
-    case (CREF(componentRef = (cr)),true,_)
+      Absyn.ComponentRef cr;
+      list<Absyn.ComponentRef> l1,l2,res;
+      Absyn.ComponentCondition e1,e2,e3;
+      Absyn.Operator op;
+      list<tuple<Absyn.ComponentCondition, Absyn.ComponentCondition>> e4;
+      Absyn.FunctionArgs farg;
+      list<Absyn.ComponentCondition> expl;
+      list<list<Absyn.ComponentCondition>> expll;
+      list<Absyn.Subscript> subs;
+      list<list<Absyn.ComponentRef>> lstres1;
+      list<list<Absyn.ComponentRef>> crefll;
+
+    case (Absyn.INTEGER(),_,_) then {};
+    case (Absyn.REAL(),_,_) then {};
+    case (Absyn.STRING(),_,_) then {};
+    case (Absyn.BOOL(),_,_) then {};
+    case (Absyn.CREF(componentRef = Absyn.ALLWILD()),_,_) then {};
+    case (Absyn.CREF(componentRef = Absyn.WILD()),_,_) then {};
+    case (Absyn.CREF(componentRef = cr),false,_) then {cr};
+
+    case (Absyn.CREF(componentRef = (cr)),true,_)
       equation
         subs = getSubsFromCref(cr,includeSubs,includeFunctions);
@@ -2461 +2461 @@
       then cr::l1;
 
-    case (BINARY(exp1 = e1,exp2 = e2),_,_)
+    case (Absyn.BINARY(exp1 = e1,exp2 = e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2469 +2469 @@
         res;
 
-    case (UNARY(exp = e1),_,_)
+    case (Absyn.UNARY(exp = e1),_,_)
       equation
         res = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2475 +2475 @@
         res;
 
-    case (LBINARY(exp1 = e1,exp2 = e2),_,_)
+    case (Absyn.LBINARY(exp1 = e1,exp2 = e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2483 +2483 @@
         res;
 
-    case (LUNARY(exp = e1),_,_)
+    case (Absyn.LUNARY(exp = e1),_,_)
       equation
         res = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2489 +2489 @@
         res;
 
-    case (RELATION(exp1 = e1,exp2 = e2),_,_)
+    case (Absyn.RELATION(exp1 = e1,exp2 = e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2498 +2498 @@
 
     // TODO: Handle else if-branches.
-    case (IFEXP(ifExp = e1,trueBranch = e2,elseBranch = e3),_,_)
+    case (Absyn.IFEXP(ifExp = e1,trueBranch = e2,elseBranch = e3),_,_)
       then List.flatten({
         getCrefFromExp(e1, includeSubs, includeFunctions),
@@ -2504 +2504 @@
         getCrefFromExp(e3, includeSubs, includeFunctions)});
 
-    case (CALL(function_ = cr, functionArgs = farg),_,_)
+    case (Absyn.CALL(function_ = cr, functionArgs = farg),_,_)
       equation
         res = getCrefFromFarg(farg,includeSubs,includeFunctions);
@@ -2510 +2510 @@
       then
         res;
-    case (PARTEVALFUNCTION(function_ = cr, functionArgs = farg),_,_)
+    case (Absyn.PARTEVALFUNCTION(function_ = cr, functionArgs = farg),_,_)
       equation
         res = getCrefFromFarg(farg,includeSubs,includeFunctions);
@@ -2516 +2516 @@
       then
         res;
-    case (ARRAY(arrayExp = expl),_,_)
+    case (Absyn.ARRAY(arrayExp = expl),_,_)
       equation
         lstres1 = List.map2(expl, getCrefFromExp, includeSubs, includeFunctions);
@@ -2522 +2522 @@
       then
         res;
-    case (MATRIX(matrix = expll),_,_)
+    case (Absyn.MATRIX(matrix = expll),_,_)
       equation
         res = List.flatten(List.flatten(List.map2List(expll, getCrefFromExp, includeSubs, includeFunctions)));
       then
         res;
-    case (RANGE(start = e1,step = SOME(e3),stop = e2),_,_)
+    case (Absyn.RANGE(start = e1,step = SOME(e3),stop = e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2536 +2536 @@
       then
         res;
-    case (RANGE(start = e1,step = NONE(),stop = e2),_,_)
+    case (Absyn.RANGE(start = e1,step = NONE(),stop = e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2544 +2544 @@
         res;
 
-    case (END(),_,_) then {};
-
-    case (TUPLE(expressions = expl),_,_)
+    case (Absyn.END(),_,_) then {};
+
+    case (Absyn.TUPLE(expressions = expl),_,_)
       equation
         crefll = List.map2(expl,getCrefFromExp,includeSubs,includeFunctions);
@@ -2553 +2553 @@
         res;
 
-    case (CODE(),_,_) then {};
-
-    case (AS(exp = e1),_,_) then getCrefFromExp(e1,includeSubs,includeFunctions);
-
-    case (CONS(e1,e2),_,_)
+    case (Absyn.CODE(),_,_) then {};
+
+    case (Absyn.AS(exp = e1),_,_) then getCrefFromExp(e1,includeSubs,includeFunctions);
+
+    case (Absyn.CONS(e1,e2),_,_)
       equation
         l1 = getCrefFromExp(e1,includeSubs,includeFunctions);
@@ -2565 +2565 @@
         res;
 
-    case (LIST(expl),_,_)
+    case (Absyn.LIST(expl),_,_)
       equation
         crefll = List.map2(expl,getCrefFromExp,includeSubs,includeFunctions);
@@ -2572 +2572 @@
         res;
 
-    case (MATCHEXP(),_,_) then fail();
-
-    case (DOT(),_,_)
+    case (Absyn.MATCHEXP(),_,_) then fail();
+
+    case (Absyn.DOT(),_,_)
       // inExp.index is only allowed to contain names to index the function call; not crefs that are evaluated in any way
       then getCrefFromExp(inExp.exp,includeSubs,includeFunctions);
@@ -2587 +2587 @@
 public function getCrefFromFarg "Returns the flattened list of all component references
   present in a list of function arguments."
-  input FunctionArgs inFunctionArgs;
+  input Absyn.FunctionArgs inFunctionArgs;
   input Boolean includeSubs "include crefs from array subscripts";
   input Boolean includeFunctions "note that if you say includeSubs = false then you won't get the functions from array subscripts";
-  output list<ComponentRef> outComponentRefLst;
+  output list<Absyn.ComponentRef> outComponentRefLst;
 algorithm
   outComponentRefLst := match (inFunctionArgs,includeSubs,includeFunctions)
     local
-      list<list<ComponentRef>> l1,l2;
-      list<ComponentRef> fl1,fl2,fl3,res;
-      list<ComponentCondition> expl;
-      list<NamedArg> nargl;
-      ForIterators iterators;
-      Exp exp;
-
-    case (FUNCTIONARGS(args = expl,argNames = nargl),_,_)
+      list<list<Absyn.ComponentRef>> l1,l2;
+      list<Absyn.ComponentRef> fl1,fl2,fl3,res;
+      list<Absyn.ComponentCondition> expl;
+      list<Absyn.NamedArg> nargl;
+      Absyn.ForIterators iterators;
+      Absyn.Exp exp;
+
+    case (Absyn.FUNCTIONARGS(args = expl,argNames = nargl),_,_)
       equation
         l1 = List.map2(expl, getCrefFromExp, includeSubs, includeFunctions);
@@ -2611 +2611 @@
         res;
 
-    case (FOR_ITER_FARG(exp,_,iterators),_,_)
+    case (Absyn.FOR_ITER_FARG(exp,_,iterators),_,_)
       equation
         l1 = List.map2Option(List.map(iterators,iteratorRange),getCrefFromExp,includeSubs,includeFunctions);
@@ -2626 +2626 @@
 
 public function iteratorName
-  input ForIterator iterator;
+  input Absyn.ForIterator iterator;
   output String name;
 algorithm
-  ITERATOR(name=name) := iterator;
+  Absyn.ITERATOR(name=name) := iterator;
 end iteratorName;
 
 public function iteratorRange
-  input ForIterator iterator;
-  output Option<Exp> range;
-algorithm
-  ITERATOR(range=range) := iterator;
+  input Absyn.ForIterator iterator;
+  output Option<Absyn.Exp> range;
+algorithm
+  Absyn.ITERATOR(range=range) := iterator;
 end iteratorRange;
 
 public function iteratorGuard
-  input ForIterator iterator;
-  output Option<Exp> guardExp;
-algorithm
-  ITERATOR(guardExp=guardExp) := iterator;
+  input Absyn.ForIterator iterator;
+  output Option<Absyn.Exp> guardExp;
+algorithm
+  Absyn.ITERATOR(guardExp=guardExp) := iterator;
 end iteratorGuard;
 
@@ -2649 +2649 @@
 public function getNamedFuncArgNamesAndValues
 "returns the names from a list of NamedArgs as a string list"
-  input list<NamedArg> inNamedArgList;
+  input list<Absyn.NamedArg> inNamedArgList;
   output list<String> outStringList;
-  output list<Exp> outExpList;
+  output list<Absyn.Exp> outExpList;
 algorithm
   (outStringList,outExpList) := match ( inNamedArgList )
     local
-      list<NamedArg> cdr;
+      list<Absyn.NamedArg> cdr;
       String s;
-      Exp e;
+      Absyn.Exp e;
       list<String> slst;
-      list<Exp> elst;
+      list<Absyn.Exp> elst;
 
     case ({})  then ({},{});
-    case (NAMEDARG(argName=s,argValue=e) :: cdr)
+    case (Absyn.NAMEDARG(argName=s,argValue=e) :: cdr)
       equation
         (slst,elst) = getNamedFuncArgNamesAndValues(cdr);
@@ -2672 +2672 @@
 protected function getCrefFromNarg "Returns the flattened list of all component references
   present in a list of named function arguments."
-  input NamedArg inNamedArg;
+  input Absyn.NamedArg inNamedArg;
   input Boolean includeSubs "include crefs from array subscripts";
   input Boolean includeFunctions "note that if you say includeSubs = false then you won't get the functions from array subscripts";
-  output list<ComponentRef> outComponentRefLst;
+  output list<Absyn.ComponentRef> outComponentRefLst;
 algorithm
   outComponentRefLst := match (inNamedArg,includeSubs,includeFunctions)
     local
-      list<ComponentRef> res;
-      ComponentCondition exp;
-    case (NAMEDARG(argValue = exp),_,_)
+      list<Absyn.ComponentRef> res;
+      Absyn.ComponentCondition exp;
+    case (Absyn.NAMEDARG(argValue = exp),_,_)
       equation
         res = getCrefFromExp(exp,includeSubs,includeFunctions);
@@ -2690 +2690 @@
 
 public function joinPaths "This function joins two paths"
-  input Path inPath1;
-  input Path inPath2;
-  output Path outPath;
+  input Absyn.Path inPath1;
+  input Absyn.Path inPath2;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (inPath1,inPath2)
     local
-      Ident str;
-      Path p2,p_1,p;
-    case (IDENT(name = str),p2) then QUALIFIED(str,p2);
-    case (QUALIFIED(name = str,path = p),p2)
+      Absyn.Ident str;
+      Absyn.Path p2,p_1,p;
+    case (Absyn.IDENT(name = str),p2) then Absyn.QUALIFIED(str,p2);
+    case (Absyn.QUALIFIED(name = str,path = p),p2)
       equation
         p_1 = joinPaths(p, p2);
       then
-        QUALIFIED(str,p_1);
-    case(FULLYQUALIFIED(p),p2) then joinPaths(p,p2);
-    case(p,FULLYQUALIFIED(p2)) then joinPaths(p,p2);
+        Absyn.QUALIFIED(str,p_1);
+    case(Absyn.FULLYQUALIFIED(p),p2) then joinPaths(p,p2);
+    case(p,Absyn.FULLYQUALIFIED(p2)) then joinPaths(p,p2);
   end match;
 end joinPaths;
 
 public function joinPathsOpt "This function joins two paths when the first one might be NONE"
-  input Option<Path> inPath1;
-  input Path inPath2;
-  output Path outPath;
+  input Option<Absyn.Path> inPath1;
+  input Absyn.Path inPath2;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (inPath1,inPath2)
-    local Path p;
+    local Absyn.Path p;
     case (NONE(), _) then inPath2;
     case (SOME(p), _) then joinPaths(p, inPath2);
@@ -2722 +2722 @@
 
 public function joinPathsOptSuffix
-  input Path inPath1;
-  input Option<Path> inPath2;
-  output Path outPath;
+  input Absyn.Path inPath1;
+  input Option<Absyn.Path> inPath2;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inPath1, inPath2)
     local
-      Path p;
+      Absyn.Path p;
 
     case (_, SOME(p)) then joinPaths(inPath1, p);
@@ -2738 +2738 @@
 public function selectPathsOpt "This function selects the second path when the first one
   is NONE() otherwise it will select the first one."
-  input Option<Path> inPath1;
-  input Path inPath2;
-  output Path outPath;
+  input Option<Absyn.Path> inPath1;
+  input Absyn.Path inPath2;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (inPath1,inPath2)
     local
-      Path p;
+      Absyn.Path p;
     case (NONE(), p) then p;
     case (SOME(p),_) then p;
@@ -2752 +2752 @@
 public function pathAppendList "author Lucian
   This function joins a path list"
-  input list<Path> inPathLst;
-  output Path outPath;
+  input list<Absyn.Path> inPathLst;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (inPathLst)
     local
-      Path path,res_path,first;
-      list<Path> rest;
-    case ({}) then IDENT("");
+      Absyn.Path path,res_path,first;
+      list<Absyn.Path> rest;
+    case ({}) then Absyn.IDENT("");
     case ((path :: {})) then path;
     case ((first :: rest))
@@ -2772 +2772 @@
 public function stripLast "Returns the path given as argument to
   the function minus the last ident."
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (inPath)
     local
-      Ident str;
-      Path p;
-
-    case QUALIFIED(name = str, path = IDENT())
-      then IDENT(str);
-
-    case QUALIFIED(name = str, path = p)
+      Absyn.Ident str;
+      Absyn.Path p;
+
+    case Absyn.QUALIFIED(name = str, path = Absyn.IDENT())
+      then Absyn.IDENT(str);
+
+    case Absyn.QUALIFIED(name = str, path = p)
       equation
         p = stripLast(p);
       then
-        QUALIFIED(str, p);
-
-    case FULLYQUALIFIED(p)
+        Absyn.QUALIFIED(str, p);
+
+    case Absyn.FULLYQUALIFIED(p)
       equation
         p = stripLast(p);
       then
-        FULLYQUALIFIED(p);
+        Absyn.FULLYQUALIFIED(p);
 
   end match;
@@ -2799 +2799 @@
 
 public function stripLastOpt
-  input Path inPath;
-  output Option<Path> outPath;
+  input Absyn.Path inPath;
+  output Option<Absyn.Path> outPath;
 algorithm
   outPath := match(inPath)
     local
-      Path p;
-
-    case IDENT() then NONE();
+      Absyn.Path p;
+
+    case Absyn.IDENT() then NONE();
 
     else
@@ -2819 +2819 @@
 public function crefStripLast "Returns the path given as argument to
   the function minus the last ident."
-  input ComponentRef inCref;
-  output ComponentRef outCref;
+  input Absyn.ComponentRef inCref;
+  output Absyn.ComponentRef outCref;
 algorithm
   outCref := match (inCref)
     local
-      Ident str;
-      ComponentRef c_1, c;
-      list<Subscript> subs;
-
-    case (CREF_IDENT()) then fail();
-    case (CREF_QUAL(name = str,subscripts = subs, componentRef = CREF_IDENT())) then CREF_IDENT(str,subs);
-    case (CREF_QUAL(name = str,subscripts = subs,componentRef = c))
+      Absyn.Ident str;
+      Absyn.ComponentRef c_1, c;
+      list<Absyn.Subscript> subs;
+
+    case (Absyn.CREF_IDENT()) then fail();
+    case (Absyn.CREF_QUAL(name = str,subscripts = subs, componentRef = Absyn.CREF_IDENT())) then Absyn.CREF_IDENT(str,subs);
+    case (Absyn.CREF_QUAL(name = str,subscripts = subs,componentRef = c))
       equation
         c_1 = crefStripLast(c);
       then
-        CREF_QUAL(str,subs,c_1);
-    case (CREF_FULLYQUALIFIED(componentRef = c))
+        Absyn.CREF_QUAL(str,subs,c_1);
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = c))
       equation
         c_1 = crefStripLast(c);
@@ -2848 +2848 @@
 qualified part, and ident part (all_but_last, last);
 "
-  input Path inPath;
-  output Path outPath1;
-  output Path outPath2;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath1;
+  output Absyn.Path outPath2;
 algorithm (outPath1,outPath2) := match(inPath)
   local
-    Path qPath,curPath,identPath;
+    Absyn.Path qPath,curPath,identPath;
     String s1,s2;
 
-  case (QUALIFIED(name = s1, path = IDENT(name = s2)))
-    then (IDENT(s1), IDENT(s2));
-
-  case (QUALIFIED(name = s1, path = qPath))
+  case (Absyn.QUALIFIED(name = s1, path = Absyn.IDENT(name = s2)))
+    then (Absyn.IDENT(s1), Absyn.IDENT(s2));
+
+  case (Absyn.QUALIFIED(name = s1, path = qPath))
     equation
       (curPath, identPath) = splitQualAndIdentPath(qPath);
     then
-      (QUALIFIED(s1, curPath), identPath);
-
-  case (FULLYQUALIFIED(qPath))
+      (Absyn.QUALIFIED(s1, curPath), identPath);
+
+  case (Absyn.FULLYQUALIFIED(qPath))
     equation
       (curPath, identPath) = splitQualAndIdentPath(qPath);
@@ -2875 +2875 @@
 public function stripFirst "Returns the path given as argument
   to the function minus the first ident."
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath:=
   match (inPath)
     local
-      Path p;
-    case (QUALIFIED(path = p)) then p;
-    case(FULLYQUALIFIED(p)) then stripFirst(p);
+      Absyn.Path p;
+    case (Absyn.QUALIFIED(path = p)) then p;
+    case(Absyn.FULLYQUALIFIED(p)) then stripFirst(p);
   end match;
 end stripFirst;
 
-public function crefToPath "This function converts a ComponentRef to a Path, if possible.
+public function crefToPath "This function converts a Absyn.ComponentRef to a Absyn.Path, if possible.
   If the component reference contains subscripts, it will silently fail."
-  input ComponentRef inComponentRef;
-  output Path outPath;
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.Path outPath;
 algorithm
   outPath:=
   match (inComponentRef)
     local
-      Ident i;
-      Path p;
-      ComponentRef c;
-    case CREF_IDENT(name = i,subscripts = {}) then IDENT(i);
-    case CREF_QUAL(name = i,subscripts = {},componentRef = c)
+      Absyn.Ident i;
+      Absyn.Path p;
+      Absyn.ComponentRef c;
+    case Absyn.CREF_IDENT(name = i,subscripts = {}) then Absyn.IDENT(i);
+    case Absyn.CREF_QUAL(name = i,subscripts = {},componentRef = c)
       equation
         p = crefToPath(c);
       then
-        QUALIFIED(i,p);
-    case CREF_FULLYQUALIFIED(componentRef = c)
+        Absyn.QUALIFIED(i,p);
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = c)
       equation
         p = crefToPath(c);
       then
-        FULLYQUALIFIED(p);
+        Absyn.FULLYQUALIFIED(p);
   end match;
 end crefToPath;
 
-public function elementSpecToPath "This function converts a ElementSpec to a Path, if possible.
-  If the ElementSpec is not EXTENDS, it will silently fail."
-  input ElementSpec inElementSpec;
-  output Path outPath;
+public function elementSpecToPath "This function converts a Absyn.ElementSpec to a Absyn.Path, if possible.
+  If the Absyn.ElementSpec is not EXTENDS, it will silently fail."
+  input Absyn.ElementSpec inElementSpec;
+  output Absyn.Path outPath;
 algorithm
   outPath:= match (inElementSpec)
     local
-      Path p;
-    case EXTENDS(path = p) then p;
+      Absyn.Path p;
+    case Absyn.EXTENDS(path = p) then p;
   end match;
 end elementSpecToPath;
 
 public function crefToPathIgnoreSubs
-  "Converts a ComponentRef to a Path, ignoring any subscripts."
-  input ComponentRef inComponentRef;
-  output Path outPath;
+  "Converts a Absyn.ComponentRef to a Absyn.Path, ignoring any subscripts."
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inComponentRef)
     local
-      Ident i;
-      Path p;
-      ComponentRef c;
-
-    case CREF_IDENT(name = i) then IDENT(i);
-
-    case CREF_QUAL(name = i, componentRef = c)
+      Absyn.Ident i;
+      Absyn.Path p;
+      Absyn.ComponentRef c;
+
+    case Absyn.CREF_IDENT(name = i) then Absyn.IDENT(i);
+
+    case Absyn.CREF_QUAL(name = i, componentRef = c)
       equation
         p = crefToPathIgnoreSubs(c);
       then
-        QUALIFIED(i, p);
-
-    case CREF_FULLYQUALIFIED(componentRef = c)
+        Absyn.QUALIFIED(i, p);
+
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = c)
       equation
         p = crefToPathIgnoreSubs(c);
       then
-        FULLYQUALIFIED(p);
+        Absyn.FULLYQUALIFIED(p);
   end match;
 end crefToPathIgnoreSubs;
 
-public function pathToCref "This function converts a Path to a ComponentRef."
-  input Path inPath;
-  output ComponentRef outComponentRef;
+public function pathToCref "This function converts a Absyn.Path to a Absyn.ComponentRef."
+  input Absyn.Path inPath;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef:=
   match (inPath)
     local
-      Ident i;
-      ComponentRef c;
-      Path p;
-    case IDENT(name = i) then CREF_IDENT(i,{});
-    case QUALIFIED(name = i,path = p)
+      Absyn.Ident i;
+      Absyn.ComponentRef c;
+      Absyn.Path p;
+    case Absyn.IDENT(name = i) then Absyn.CREF_IDENT(i,{});
+    case Absyn.QUALIFIED(name = i,path = p)
       equation
         c = pathToCref(p);
       then
-        CREF_QUAL(i,{},c);
-    case(FULLYQUALIFIED(p))
+        Absyn.CREF_QUAL(i,{},c);
+    case(Absyn.FULLYQUALIFIED(p))
       equation
         c = pathToCref(p);
@@ -2975 +2975 @@
 
 public function pathToCrefWithSubs
-  "This function converts a Path to a ComponentRef, and applies the given
+  "This function converts a Absyn.Path to a Absyn.ComponentRef, and applies the given
   subscripts to the last identifier."
-  input Path inPath;
-  input list<Subscript> inSubs;
-  output ComponentRef outComponentRef;
+  input Absyn.Path inPath;
+  input list<Absyn.Subscript> inSubs;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef := match(inPath, inSubs)
     local
-      Ident i;
-      ComponentRef c;
-      Path p;
-
-    case (IDENT(name = i), _) then CREF_IDENT(i, inSubs);
-
-    case (QUALIFIED(name = i, path = p), _)
+      Absyn.Ident i;
+      Absyn.ComponentRef c;
+      Absyn.Path p;
+
+    case (Absyn.IDENT(name = i), _) then Absyn.CREF_IDENT(i, inSubs);
+
+    case (Absyn.QUALIFIED(name = i, path = p), _)
       equation
         c = pathToCrefWithSubs(p, inSubs);
       then
-        CREF_QUAL(i, {}, c);
-
-    case (FULLYQUALIFIED(p), _)
+        Absyn.CREF_QUAL(i, {}, c);
+
+    case (Absyn.FULLYQUALIFIED(p), _)
       equation
         c = pathToCrefWithSubs(p, inSubs);
@@ -3005 +3005 @@
 public function crefLastIdent
   "Returns the last identifier in a component reference."
-  input ComponentRef inComponentRef;
-  output Ident outIdent;
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match(inComponentRef)
     local
-      ComponentRef cref;
-      Ident id;
-
-    case CREF_IDENT(name = id) then id;
-    case CREF_QUAL(componentRef = cref) then crefLastIdent(cref);
-    case CREF_FULLYQUALIFIED(componentRef = cref) then crefLastIdent(cref);
+      Absyn.ComponentRef cref;
+      Absyn.Ident id;
+
+    case Absyn.CREF_IDENT(name = id) then id;
+    case Absyn.CREF_QUAL(componentRef = cref) then crefLastIdent(cref);
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = cref) then crefLastIdent(cref);
   end match;
 end crefLastIdent;
@@ -3022 +3022 @@
   "Returns the basename of the component reference, but fails if it encounters
   any subscripts."
-  input ComponentRef inCref;
-  output Ident outIdent;
+  input Absyn.ComponentRef inCref;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match(inCref)
     local
-      Ident id;
-      ComponentRef cr;
-    case CREF_IDENT(name = id, subscripts = {}) then id;
-    case CREF_QUAL(name = id, subscripts = {}) then id;
-    case CREF_FULLYQUALIFIED(componentRef = cr) then crefFirstIdentNoSubs(cr);
+      Absyn.Ident id;
+      Absyn.ComponentRef cr;
+    case Absyn.CREF_IDENT(name = id, subscripts = {}) then id;
+    case Absyn.CREF_QUAL(name = id, subscripts = {}) then id;
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = cr) then crefFirstIdentNoSubs(cr);
   end match;
 end crefFirstIdentNoSubs;
@@ -3037 +3037 @@
 public function crefIsIdent
   "Returns true if the component reference is a simple identifier, otherwise false."
-  input ComponentRef inComponentRef;
+  input Absyn.ComponentRef inComponentRef;
   output Boolean outIsIdent;
 algorithm
   outIsIdent := match(inComponentRef)
-    case CREF_IDENT() then true;
+    case Absyn.CREF_IDENT() then true;
     else false;
   end match;
@@ -3048 +3048 @@
 public function crefIsQual
   "Returns true if the component reference is a qualified identifier, otherwise false."
-  input ComponentRef inComponentRef;
+  input Absyn.ComponentRef inComponentRef;
   output Boolean outIsQual;
 algorithm
   outIsQual := match(inComponentRef)
-    case CREF_QUAL() then true;
-    case CREF_FULLYQUALIFIED() then true;
+    case Absyn.CREF_QUAL() then true;
+    case Absyn.CREF_FULLYQUALIFIED() then true;
     else false;
   end match;
 end crefIsQual;
 
-public function crefLastSubs "Return the last subscripts of an ComponentRef"
-  input ComponentRef inComponentRef;
-  output list<Subscript> outSubscriptLst;
+public function crefLastSubs "Return the last subscripts of an Absyn.ComponentRef"
+  input Absyn.ComponentRef inComponentRef;
+  output list<Absyn.Subscript> outSubscriptLst;
 algorithm
   outSubscriptLst:=
   match (inComponentRef)
     local
-      Ident id;
-      list<Subscript> subs,res;
-      ComponentRef cr;
-    case (CREF_IDENT(subscripts= subs)) then subs;
-    case (CREF_QUAL(componentRef = cr))
+      Absyn.Ident id;
+      list<Absyn.Subscript> subs,res;
+      Absyn.ComponentRef cr;
+    case (Absyn.CREF_IDENT(subscripts= subs)) then subs;
+    case (Absyn.CREF_QUAL(componentRef = cr))
       equation
         res = crefLastSubs(cr);
       then
         res;
-    case (CREF_FULLYQUALIFIED(componentRef = cr))
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr))
       equation
         res = crefLastSubs(cr);
@@ -3083 +3083 @@
 
 public function crefSetLastSubs
-  input ComponentRef inCref;
-  input list<Subscript> inSubscripts;
-  output ComponentRef outCref = inCref;
+  input Absyn.ComponentRef inCref;
+  input list<Absyn.Subscript> inSubscripts;
+  output Absyn.ComponentRef outCref = inCref;
 algorithm
   outCref := match outCref
-    case CREF_IDENT()
+    case Absyn.CREF_IDENT()
       algorithm
         outCref.subscripts := inSubscripts;
@@ -3094 +3094 @@
         outCref;
 
-    case CREF_QUAL()
+    case Absyn.CREF_QUAL()
       algorithm
         outCref.componentRef := crefSetLastSubs(outCref.componentRef, inSubscripts);
@@ -3100 +3100 @@
         outCref;
 
-    case CREF_FULLYQUALIFIED()
+    case Absyn.CREF_FULLYQUALIFIED()
       algorithm
         outCref.componentRef := crefSetLastSubs(outCref.componentRef, inSubscripts);
@@ -3110 +3110 @@
 
 public function crefHasSubscripts "This function finds if a cref has subscripts"
-  input ComponentRef cref;
+  input Absyn.ComponentRef cref;
   output Boolean hasSubscripts;
 algorithm
   hasSubscripts := match cref
-    case CREF_IDENT() then not listEmpty(cref.subscripts);
-    case CREF_QUAL(subscripts = {}) then crefHasSubscripts(cref.componentRef);
-    case CREF_FULLYQUALIFIED() then crefHasSubscripts(cref.componentRef);
-    case WILD() then false;
-    case ALLWILD() then false;
+    case Absyn.CREF_IDENT() then not listEmpty(cref.subscripts);
+    case Absyn.CREF_QUAL(subscripts = {}) then crefHasSubscripts(cref.componentRef);
+    case Absyn.CREF_FULLYQUALIFIED() then crefHasSubscripts(cref.componentRef);
+    case Absyn.WILD() then false;
+    case Absyn.ALLWILD() then false;
     else true;
   end match;
@@ -3126 +3126 @@
 Author: BZ, 2009-09
  Extract subscripts of crefs."
-  input ComponentRef cr;
+  input Absyn.ComponentRef cr;
   input Boolean includeSubs "include crefs from array subscripts";
   input Boolean includeFunctions "note that if you say includeSubs = false then you won't get the functions from array subscripts";
-  output list<Subscript> subscripts;
+  output list<Absyn.Subscript> subscripts;
 algorithm
   subscripts := match(cr,includeSubs,includeFunctions)
     local
-      list<Subscript> subs2;
-      ComponentRef child;
-
-    case(CREF_IDENT(_,subs2), _, _) then subs2;
-
-    case(CREF_QUAL(_,subs2,child), _, _)
+      list<Absyn.Subscript> subs2;
+      Absyn.ComponentRef child;
+
+    case(Absyn.CREF_IDENT(_,subs2), _, _) then subs2;
+
+    case(Absyn.CREF_QUAL(_,subs2,child), _, _)
       equation
         subscripts = getSubsFromCref(child, includeSubs, includeFunctions);
@@ -3145 +3145 @@
         subscripts;
 
-    case(CREF_FULLYQUALIFIED(child), _, _)
+    case(Absyn.CREF_FULLYQUALIFIED(child), _, _)
       equation
         subscripts = getSubsFromCref(child, includeSubs, includeFunctions);
@@ -3155 +3155 @@
 // stefan
 public function crefGetLastIdent
-"Gets the last ident in a ComponentRef"
-  input ComponentRef inComponentRef;
-  output ComponentRef outComponentRef;
+"Gets the last ident in a Absyn.ComponentRef"
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef := match (inComponentRef)
     local
-      ComponentRef cref,cref_1;
-      Ident id;
-      list<Subscript> subs;
-    case(CREF_IDENT(id,subs)) then CREF_IDENT(id,subs);
-    case(CREF_QUAL(_,_,cref))
+      Absyn.ComponentRef cref,cref_1;
+      Absyn.Ident id;
+      list<Absyn.Subscript> subs;
+    case(Absyn.CREF_IDENT(id,subs)) then Absyn.CREF_IDENT(id,subs);
+    case(Absyn.CREF_QUAL(_,_,cref))
       equation
         cref_1 = crefGetLastIdent(cref);
       then
         cref_1;
-    case(CREF_FULLYQUALIFIED(cref))
+    case(Absyn.CREF_FULLYQUALIFIED(cref))
       equation
         cref_1 = crefGetLastIdent(cref);
@@ -3178 +3178 @@
 end crefGetLastIdent;
 
-public function crefStripLastSubs "Strips the last subscripts of a ComponentRef"
-  input ComponentRef inComponentRef;
-  output ComponentRef outComponentRef;
+public function crefStripLastSubs "Strips the last subscripts of a Absyn.ComponentRef"
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef:=
   match (inComponentRef)
     local
-      Ident id;
-      list<Subscript> subs,s;
-      ComponentRef cr_1,cr;
-    case (CREF_IDENT(name = id)) then CREF_IDENT(id,{});
-    case (CREF_QUAL(name= id,subscripts= s,componentRef = cr))
+      Absyn.Ident id;
+      list<Absyn.Subscript> subs,s;
+      Absyn.ComponentRef cr_1,cr;
+    case (Absyn.CREF_IDENT(name = id)) then Absyn.CREF_IDENT(id,{});
+    case (Absyn.CREF_QUAL(name= id,subscripts= s,componentRef = cr))
       equation
         cr_1 = crefStripLastSubs(cr);
       then
-        CREF_QUAL(id,s,cr_1);
-    case (CREF_FULLYQUALIFIED(componentRef = cr))
+        Absyn.CREF_QUAL(id,s,cr_1);
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr))
       equation
         cr_1 = crefStripLastSubs(cr);
@@ -3203 +3203 @@
 
 public function joinCrefs "This function joins two ComponentRefs."
-  input ComponentRef inComponentRef1;
-  input ComponentRef inComponentRef2;
-  output ComponentRef outComponentRef;
+  input Absyn.ComponentRef inComponentRef1;
+  input Absyn.ComponentRef inComponentRef2;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef:=
   match (inComponentRef1,inComponentRef2)
     local
-      Ident id;
-      list<Subscript> sub;
-      ComponentRef cr2,cr_1,cr;
-    case (CREF_IDENT(name = id,subscripts = sub),cr2)
-      equation
-        failure(CREF_FULLYQUALIFIED() = cr2);
-      then CREF_QUAL(id,sub,cr2);
-    case (CREF_QUAL(name = id,subscripts = sub,componentRef = cr),cr2)
+      Absyn.Ident id;
+      list<Absyn.Subscript> sub;
+      Absyn.ComponentRef cr2,cr_1,cr;
+    case (Absyn.CREF_IDENT(name = id,subscripts = sub),cr2)
+      equation
+        failure(Absyn.CREF_FULLYQUALIFIED() = cr2);
+      then Absyn.CREF_QUAL(id,sub,cr2);
+    case (Absyn.CREF_QUAL(name = id,subscripts = sub,componentRef = cr),cr2)
       equation
         cr_1 = joinCrefs(cr, cr2);
       then
-        CREF_QUAL(id,sub,cr_1);
-    case (CREF_FULLYQUALIFIED(componentRef = cr),cr2)
+        Absyn.CREF_QUAL(id,sub,cr_1);
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr),cr2)
       equation
         cr_1 = joinCrefs(cr, cr2);
@@ -3230 +3230 @@
 end joinCrefs;
 
-public function crefFirstIdent "Returns first ident from a ComponentRef"
-  input ComponentRef inCref;
-  output Ident outIdent;
+public function crefFirstIdent "Returns first ident from a Absyn.ComponentRef"
+  input Absyn.ComponentRef inCref;
+  output Absyn.Ident outIdent;
 algorithm
   outIdent := match inCref
-    case CREF_IDENT() then inCref.name;
-    case CREF_QUAL() then inCref.name;
-    case CREF_FULLYQUALIFIED() then crefFirstIdent(inCref.componentRef);
+    case Absyn.CREF_IDENT() then inCref.name;
+    case Absyn.CREF_QUAL() then inCref.name;
+    case Absyn.CREF_FULLYQUALIFIED() then crefFirstIdent(inCref.componentRef);
   end match;
 end crefFirstIdent;
 
 public function crefSecondIdent
-  input ComponentRef cref;
-  output Ident ident;
+  input Absyn.ComponentRef cref;
+  output Absyn.Ident ident;
 algorithm
   ident := match cref
-    case CREF_QUAL() then crefFirstIdent(cref.componentRef);
-    case CREF_FULLYQUALIFIED() then crefSecondIdent(cref.componentRef);
+    case Absyn.CREF_QUAL() then crefFirstIdent(cref.componentRef);
+    case Absyn.CREF_FULLYQUALIFIED() then crefSecondIdent(cref.componentRef);
   end match;
 end crefSecondIdent;
@@ -3253 +3253 @@
 public function crefFirstCref
   "Returns the first part of a cref."
-  input ComponentRef inCref;
-  output ComponentRef outCref;
+  input Absyn.ComponentRef inCref;
+  output Absyn.ComponentRef outCref;
 algorithm
   outCref := match inCref
-    case CREF_QUAL() then CREF_IDENT(inCref.name, inCref.subscripts);
-    case CREF_FULLYQUALIFIED() then crefFirstCref(inCref.componentRef);
+    case Absyn.CREF_QUAL() then Absyn.CREF_IDENT(inCref.name, inCref.subscripts);
+    case Absyn.CREF_FULLYQUALIFIED() then crefFirstCref(inCref.componentRef);
     else inCref;
   end match;
 end crefFirstCref;
 
-public function crefStripFirst "Strip the first ident from a ComponentRef"
-  input ComponentRef inComponentRef;
-  output ComponentRef outComponentRef;
+public function crefStripFirst "Strip the first ident from a Absyn.ComponentRef"
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef:=
   match (inComponentRef)
-    local ComponentRef cr;
-    case CREF_QUAL(componentRef = cr) then cr;
-    case CREF_FULLYQUALIFIED(componentRef = cr) then crefStripFirst(cr);
+    local Absyn.ComponentRef cr;
+    case Absyn.CREF_QUAL(componentRef = cr) then cr;
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = cr) then crefStripFirst(cr);
   end match;
 end crefStripFirst;
 
 public function crefIsFullyQualified
-  input ComponentRef inCref;
+  input Absyn.ComponentRef inCref;
   output Boolean outIsFullyQualified;
 algorithm
   outIsFullyQualified := match inCref
-    case CREF_FULLYQUALIFIED() then true;
+    case Absyn.CREF_FULLYQUALIFIED() then true;
     else false;
   end match;
@@ -3287 +3287 @@
 public function crefMakeFullyQualified
   "Makes a component reference fully qualified unless it already is."
-  input ComponentRef inComponentRef;
-  output ComponentRef outComponentRef;
+  input Absyn.ComponentRef inComponentRef;
+  output Absyn.ComponentRef outComponentRef;
 algorithm
   outComponentRef := match(inComponentRef)
-    case CREF_FULLYQUALIFIED() then inComponentRef;
-    else CREF_FULLYQUALIFIED(inComponentRef);
+    case Absyn.CREF_FULLYQUALIFIED() then inComponentRef;
+    else Absyn.CREF_FULLYQUALIFIED(inComponentRef);
   end match;
 end crefMakeFullyQualified;
 
 public function restrString "Maps a class restriction to the corresponding string for printing"
-  input Restriction inRestriction;
+  input Absyn.Restriction inRestriction;
   output String outString;
 algorithm
   outString:=
   match (inRestriction)
-    case R_CLASS() then "CLASS";
-    case R_OPTIMIZATION() then "OPTIMIZATION";
-    case R_MODEL() then "MODEL";
-    case R_RECORD() then "RECORD";
-    case R_BLOCK() then "BLOCK";
-    case R_CONNECTOR() then "CONNECTOR";
-    case R_EXP_CONNECTOR() then "EXPANDABLE CONNECTOR";
-    case R_TYPE() then "TYPE";
-    case R_PACKAGE() then "PACKAGE";
-    case R_FUNCTION(FR_NORMAL_FUNCTION(PURE())) then "PURE FUNCTION";
-    case R_FUNCTION(FR_NORMAL_FUNCTION(IMPURE())) then "IMPURE FUNCTION";
-    case R_FUNCTION(FR_NORMAL_FUNCTION(NO_PURITY())) then "FUNCTION";
-    case R_FUNCTION(FR_OPERATOR_FUNCTION()) then "OPERATOR FUNCTION";
-    case R_PREDEFINED_INTEGER() then "PREDEFINED_INT";
-    case R_PREDEFINED_REAL() then "PREDEFINED_REAL";
-    case R_PREDEFINED_STRING() then "PREDEFINED_STRING";
-    case R_PREDEFINED_BOOLEAN() then "PREDEFINED_BOOL";
+    case Absyn.R_CLASS() then "CLASS";
+    case Absyn.R_OPTIMIZATION() then "OPTIMIZATION";
+    case Absyn.R_MODEL() then "MODEL";
+    case Absyn.R_RECORD() then "RECORD";
+    case Absyn.R_BLOCK() then "BLOCK";
+    case Absyn.R_CONNECTOR() then "CONNECTOR";
+    case Absyn.R_EXP_CONNECTOR() then "EXPANDABLE CONNECTOR";
+    case Absyn.R_TYPE() then "TYPE";
+    case Absyn.R_PACKAGE() then "PACKAGE";
+    case Absyn.R_FUNCTION(Absyn.FR_NORMAL_FUNCTION(Absyn.PURE())) then "PURE FUNCTION";
+    case Absyn.R_FUNCTION(Absyn.FR_NORMAL_FUNCTION(Absyn.IMPURE())) then "IMPURE FUNCTION";
+    case Absyn.R_FUNCTION(Absyn.FR_NORMAL_FUNCTION(Absyn.NO_PURITY())) then "FUNCTION";
+    case Absyn.R_FUNCTION(Absyn.FR_OPERATOR_FUNCTION()) then "OPERATOR FUNCTION";
+    case Absyn.R_PREDEFINED_INTEGER() then "PREDEFINED_INT";
+    case Absyn.R_PREDEFINED_REAL() then "PREDEFINED_REAL";
+    case Absyn.R_PREDEFINED_STRING() then "PREDEFINED_STRING";
+    case Absyn.R_PREDEFINED_BOOLEAN() then "PREDEFINED_BOOL";
     // BTH
-    case R_PREDEFINED_CLOCK() then "PREDEFINED_CLOCK";
+    case Absyn.R_PREDEFINED_CLOCK() then "PREDEFINED_CLOCK";
 
     /* MetaModelica restriction */
-    case R_UNIONTYPE() then "UNIONTYPE";
+    case Absyn.R_UNIONTYPE() then "UNIONTYPE";
     else "* Unknown restriction *";
   end match;
@@ -3329 +3329 @@
 
 public function lastClassname "Returns the path (=name) of the last class in a program"
-  input Program inProgram;
-  output Path outPath;
+  input Absyn.Program inProgram;
+  output Absyn.Path outPath;
 protected
-  list<Class> lst;
-  Ident id;
-algorithm
-  PROGRAM(classes = lst) := inProgram;
-  CLASS(name = id) := List.last(lst);
-  outPath := IDENT(id);
+  list<Absyn.Class> lst;
+  Absyn.Ident id;
+algorithm
+  Absyn.PROGRAM(classes = lst) := inProgram;
+  Absyn.CLASS(name = id) := List.last(lst);
+  outPath := Absyn.IDENT(id);
 end lastClassname;
 
 public function classFilename
   "Retrieves the filename where the class is stored."
-  input Class inClass;
+  input Absyn.Class inClass;
   output String outFilename;
 algorithm
-  CLASS(info = SOURCEINFO(fileName = outFilename)) := inClass;
+  Absyn.CLASS(info = SOURCEINFO(fileName = outFilename)) := inClass;
 end classFilename;
 
 public function setClassFilename "Sets the filename where the class is stored."
-  input Class inClass;
+  input Absyn.Class inClass;
   input String fileName;
-  output Class outClass;
+  output Absyn.Class outClass;
 algorithm
   outClass := match inClass
     local
       SourceInfo info;
-      Class cl;
-    case cl as CLASS(info=info as SOURCEINFO())
+      Absyn.Class cl;
+    case cl as Absyn.CLASS(info=info as SOURCEINFO())
       equation
         info.fileName = fileName;
@@ -3367 +3367 @@
 public function setClassName "author: BZ
   Sets the name of the class"
-  input Class inClass;
+  input Absyn.Class inClass;
   input String newName;
-  output Class outClass = inClass;
+  output Absyn.Class outClass = inClass;
 algorithm
   outClass := match outClass
-    case CLASS()
+    case Absyn.CLASS()
       algorithm
         outClass.name := newName;
@@ -3381 +3381 @@
 
 public function setClassBody
-  input Class inClass;
-  input ClassDef inBody;
-  output Class outClass = inClass;
+  input Absyn.Class inClass;
+  input Absyn.ClassDef inBody;
+  output Absyn.Class outClass = inClass;
 algorithm
   outClass := match outClass
-    case CLASS()
+    case Absyn.CLASS()
       algorithm
         outClass.body := inBody;
@@ -3394 +3394 @@
 end setClassBody;
 
-public function crefEqual " Checks if the name of a ComponentRef is
- equal to the name of another ComponentRef, including subscripts.
+public function crefEqual " Checks if the name of a Absyn.ComponentRef is
+ equal to the name of another Absyn.ComponentRef, including subscripts.
  See also crefEqualNoSubs."
-  input ComponentRef iCr1;
-  input ComponentRef iCr2;
+  input Absyn.ComponentRef iCr1;
+  input Absyn.ComponentRef iCr2;
   output Boolean outBoolean;
 algorithm
   outBoolean := matchcontinue (iCr1,iCr2)
     local
-      Ident id,id2;
-      list<Subscript> ss1,ss2;
-      ComponentRef cr1,cr2;
-
-    case (CREF_IDENT(name = id,subscripts=ss1),CREF_IDENT(name = id2,subscripts = ss2))
+      Absyn.Ident id,id2;
+      list<Absyn.Subscript> ss1,ss2;
+      Absyn.ComponentRef cr1,cr2;
+
+    case (Absyn.CREF_IDENT(name = id,subscripts=ss1),Absyn.CREF_IDENT(name = id2,subscripts = ss2))
       equation
         true = stringEq(id, id2);
@@ -3414 +3414 @@
         true;
 
-    case (CREF_QUAL(name = id,subscripts = ss1, componentRef = cr1),CREF_QUAL(name = id2,subscripts = ss2, componentRef = cr2))
+    case (Absyn.CREF_QUAL(name = id,subscripts = ss1, componentRef = cr1),Absyn.CREF_QUAL(name = id2,subscripts = ss2, componentRef = cr2))
       equation
         true = stringEq(id, id2);
@@ -3422 +3422 @@
         true;
 
-    case (CREF_FULLYQUALIFIED(componentRef = cr1),CREF_FULLYQUALIFIED(componentRef = cr2))
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = cr1),Absyn.CREF_FULLYQUALIFIED(componentRef = cr2))
       then
         crefEqual(cr1, cr2);
@@ -3434 +3434 @@
    a.b, a -> true
    b.c, a -> false"
-  input ComponentRef iCr1;
-  input ComponentRef iCr2;
+  input Absyn.ComponentRef iCr1;
+  input Absyn.ComponentRef iCr2;
   output Boolean outBoolean;
 algorithm
@@ -3442 +3442 @@
 
 public function subscriptEqual
-  input Subscript inSubscript1;
-  input Subscript inSubscript2;
+  input Absyn.Subscript inSubscript1;
+  input Absyn.Subscript inSubscript2;
   output Boolean outIsEqual;
 algorithm
   outIsEqual := match(inSubscript1, inSubscript2)
     local
-      Exp e1, e2;
-
-    case (NOSUB(), NOSUB()) then true;
-    case (SUBSCRIPT(e1), SUBSCRIPT(e2)) then expEqual(e1, e2);
+      Absyn.Exp e1, e2;
+
+    case (Absyn.NOSUB(), Absyn.NOSUB()) then true;
+    case (Absyn.SUBSCRIPT(e1), Absyn.SUBSCRIPT(e2)) then expEqual(e1, e2);
     else false;
   end match;
@@ -3458 +3458 @@
 public function subscriptsEqual
   "Checks if two subscript lists are equal."
-  input list<Subscript> inSubList1;
-  input list<Subscript> inSubList2;
+  input list<Absyn.Subscript> inSubList1;
+  input list<Absyn.Subscript> inSubList2;
   output Boolean outIsEqual;
 algorithm
@@ -3466 +3466 @@
 
 public function crefEqualNoSubs
-  "Checks if the name of a ComponentRef is equal to the name
-   of another ComponentRef without checking subscripts.
+  "Checks if the name of a Absyn.ComponentRef is equal to the name
+   of another Absyn.ComponentRef without checking subscripts.
    See also crefEqual."
-  input ComponentRef cr1;
-  input ComponentRef cr2;
+  input Absyn.ComponentRef cr1;
+  input Absyn.ComponentRef cr2;
   output Boolean outBoolean;
 algorithm
   outBoolean := matchcontinue (cr1,cr2)
     local
-      ComponentRef rest1,rest2;
-      Ident id,id2;
-    case (CREF_IDENT(name = id),CREF_IDENT(name = id2))
+      Absyn.ComponentRef rest1,rest2;
+      Absyn.Ident id,id2;
+    case (Absyn.CREF_IDENT(name = id),Absyn.CREF_IDENT(name = id2))
       equation
         true = stringEq(id, id2);
       then
         true;
-    case (CREF_QUAL(name = id,componentRef = rest1),CREF_QUAL(name = id2,componentRef = rest2))
+    case (Absyn.CREF_QUAL(name = id,componentRef = rest1),Absyn.CREF_QUAL(name = id2,componentRef = rest2))
       equation
         true = stringEq(id, id2);
@@ -3488 +3488 @@
       then
         true;
-    case (CREF_FULLYQUALIFIED(componentRef = rest1),CREF_FULLYQUALIFIED(componentRef = rest2))
+    case (Absyn.CREF_FULLYQUALIFIED(componentRef = rest1),Absyn.CREF_FULLYQUALIFIED(componentRef = rest2))
       then crefEqualNoSubs(rest1, rest2);
     else false;
@@ -3495 +3495 @@
 
 public function isPackageRestriction "checks if the provided parameter is a package or not"
-  input Restriction inRestriction;
+  input Absyn.Restriction inRestriction;
   output Boolean outIsPackage;
 algorithm
   outIsPackage := match(inRestriction)
-    case R_PACKAGE() then true;
+    case Absyn.R_PACKAGE() then true;
     else false;
   end match;
@@ -3505 +3505 @@
 
 public function isFunctionRestriction "checks if restriction is a function or not"
-  input Restriction inRestriction;
+  input Absyn.Restriction inRestriction;
   output Boolean outIsFunction;
 algorithm
   outIsFunction := match(inRestriction)
-    case R_FUNCTION() then true;
+    case Absyn.R_FUNCTION() then true;
     else false;
   end match;
@@ -3515 +3515 @@
 
 public function expEqual "Returns true if two expressions are equal"
-  input Exp exp1;
-  input Exp exp2;
+  input Absyn.Exp exp1;
+  input Absyn.Exp exp2;
   output Boolean equal;
 algorithm
@@ -3522 +3522 @@
     local
       Boolean b;
-      Exp x, y;
+      Absyn.Exp x, y;
       Integer i;
       String r;
 
     // real vs. integer
-    case (INTEGER(i), REAL(r))
+    case (Absyn.INTEGER(i), Absyn.REAL(r))
       equation
         b = realEq(intReal(i), System.stringReal(r));
       then b;
 
-    case (REAL(r), INTEGER(i))
+    case (Absyn.REAL(r), Absyn.INTEGER(i))
       equation
         b = realEq(intReal(i), System.stringReal(r));
@@ -3543 +3543 @@
 
 public function eachEqual "Returns true if two each attributes are equal"
-  input Each each1;
-  input Each each2;
+  input Absyn.Each each1;
+  input Absyn.Each each2;
   output Boolean equal;
 algorithm
   equal := match(each1, each2)
-    case(NON_EACH(), NON_EACH()) then true;
-    case(EACH(), EACH()) then true;
+    case(Absyn.NON_EACH(), Absyn.NON_EACH()) then true;
+    case(Absyn.EACH(), Absyn.EACH()) then true;
     else false;
   end match;
 end eachEqual;
 
-protected function functionArgsEqual "Returns true if two FunctionArgs are equal"
-  input FunctionArgs args1;
-  input FunctionArgs args2;
+protected function functionArgsEqual "Returns true if two Absyn.FunctionArgs are equal"
+  input Absyn.FunctionArgs args1;
+  input Absyn.FunctionArgs args2;
   output Boolean equal;
 algorithm
   equal := match(args1,args2)
     local
-      list<Exp> expl1,expl2;
-
-    case (FUNCTIONARGS(args = expl1), FUNCTIONARGS(args = expl2))
+      list<Absyn.Exp> expl1,expl2;
+
+    case (Absyn.FUNCTIONARGS(args = expl1), Absyn.FUNCTIONARGS(args = expl2))
       then List.isEqualOnTrue(expl1, expl2, expEqual);
 
@@ -3572 +3572 @@
 public function getClassName "author: adrpo
   gets the name of the class."
-  input Class inClass;
+  input Absyn.Class inClass;
   output String outName;
 algorithm
-  CLASS(name=outName) := inClass;
+  Absyn.CLASS(name=outName) := inClass;
 end getClassName;
 
-public type IteratorIndexedCref = tuple<ComponentRef, Integer>;
+public type IteratorIndexedCref = tuple<Absyn.ComponentRef, Integer>;
 
 public function findIteratorIndexedCrefs
@@ -3584 +3584 @@
    iterator, and return a list of cref-Integer tuples, where the cref is the
    index of the subscript."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input String inIterator;
   input list<IteratorIndexedCref> inCrefs = {};
@@ -3598 +3598 @@
   "Traversal function used by deduceReductionIterationRange. Used to find crefs
    which are subscripted by a given iterator."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input list<IteratorIndexedCref> inCrefs;
   input String inIterator;
-  output Exp outExp = inExp;
+  output Absyn.Exp outExp = inExp;
   output list<IteratorIndexedCref> outCrefs;
 algorithm
   outCrefs := match inExp
     local
-      ComponentRef cref;
-
-    case CREF(componentRef = cref)
+      Absyn.ComponentRef cref;
+
+    case Absyn.CREF(componentRef = cref)
       then getIteratorIndexedCrefs(cref, inIterator, inCrefs);
 
@@ -3621 +3621 @@
   output Boolean outEqual;
 protected
-  ComponentRef cr1, cr2;
+  Absyn.ComponentRef cr1, cr2;
   Integer idx1, idx2;
 algorithm
@@ -3636 +3636 @@
    iterator i:
      a[i] => (a, 1), b[1, i] => (b, 2), c[i+1] => (), d[2].e[i] => (d[2].e, 1)"
-  input ComponentRef inCref;
+  input Absyn.ComponentRef inCref;
   input String inIterator;
   input list<IteratorIndexedCref> inCrefs;
   output list<IteratorIndexedCref> outCrefs = inCrefs;
 protected
-  list<tuple<ComponentRef, Integer>> crefs;
+  list<tuple<Absyn.ComponentRef, Integer>> crefs;
 algorithm
   outCrefs := match inCref
     local
-      list<Subscript> subs;
+      list<Absyn.Subscript> subs;
       Integer idx;
       String name, id;
-      ComponentRef cref;
-
-    case CREF_IDENT(name = id, subscripts = subs)
+      Absyn.ComponentRef cref;
+
+    case Absyn.CREF_IDENT(name = id, subscripts = subs)
       algorithm
         // For each subscript, check if the subscript consists of only the
@@ -3657 +3657 @@
         for sub in subs loop
           _ := match sub
-            case SUBSCRIPT(subscript = CREF(componentRef =
-                CREF_IDENT(name = name, subscripts = {})))
+            case Absyn.SUBSCRIPT(subscript = Absyn.CREF(componentRef =
+                Absyn.CREF_IDENT(name = name, subscripts = {})))
               algorithm
                 if name == inIterator then
-                  outCrefs := (CREF_IDENT(id, {}), idx) :: outCrefs;
+                  outCrefs := (Absyn.CREF_IDENT(id, {}), idx) :: outCrefs;
                 end if;
               then
@@ -3674 +3674 @@
         outCrefs;
 
-    case CREF_QUAL(name = id, subscripts = subs, componentRef = cref)
+    case Absyn.CREF_QUAL(name = id, subscripts = subs, componentRef = cref)
       algorithm
         crefs := getIteratorIndexedCrefs(cref, inIterator, {});
@@ -3682 +3682 @@
         for cr in crefs loop
           (cref, idx) := cr;
-          outCrefs := (CREF_QUAL(id, subs, cref), idx) :: outCrefs;
+          outCrefs := (Absyn.CREF_QUAL(id, subs, cref), idx) :: outCrefs;
         end for;
       then
-        getIteratorIndexedCrefs(CREF_IDENT(id, subs), inIterator, outCrefs);
-
-    case CREF_FULLYQUALIFIED(componentRef = cref)
+        getIteratorIndexedCrefs(Absyn.CREF_IDENT(id, subs), inIterator, outCrefs);
+
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = cref)
       algorithm
         crefs := getIteratorIndexedCrefs(cref, inIterator, {});
@@ -3694 +3694 @@
         for cr in crefs loop
           (cref, idx) := cr;
-          outCrefs := (CREF_FULLYQUALIFIED(cref), idx) :: outCrefs;
+          outCrefs := (Absyn.CREF_FULLYQUALIFIED(cref), idx) :: outCrefs;
         end for;
       then
@@ -3704 +3704 @@
 
 public function pathReplaceIdent
-  input Path path;
+  input Absyn.Path path;
   input String last;
-  output Path out;
+  output Absyn.Path out;
 algorithm
   out := match (path,last)
-    local Path p; String n,s;
-    case (FULLYQUALIFIED(p),s) equation p = pathReplaceIdent(p,s); then FULLYQUALIFIED(p);
-    case (QUALIFIED(n,p),s) equation p = pathReplaceIdent(p,s); then QUALIFIED(n,p);
-    case (IDENT(),s) then IDENT(s);
+    local Absyn.Path p; String n,s;
+    case (Absyn.FULLYQUALIFIED(p),s) equation p = pathReplaceIdent(p,s); then Absyn.FULLYQUALIFIED(p);
+    case (Absyn.QUALIFIED(n,p),s) equation p = pathReplaceIdent(p,s); then Absyn.QUALIFIED(n,p);
+    case (Absyn.IDENT(),s) then Absyn.IDENT(s);
   end match;
 end pathReplaceIdent;
@@ -3725 +3725 @@
 public function isOuter
 "@author: adrpo
-  this function returns true if the given InnerOuter
-  is one of INNER_OUTER() or OUTER()"
-  input InnerOuter io;
+  this function returns true if the given Absyn.InnerOuter
+  is one of Absyn.INNER_OUTER() or Absyn.OUTER()"
+  input Absyn.InnerOuter io;
   output Boolean isItAnOuter;
 algorithm
   isItAnOuter := match(io)
-    case (INNER_OUTER()) then true;
-    case (OUTER()) then true;
+    case (Absyn.INNER_OUTER()) then true;
+    case (Absyn.OUTER()) then true;
     else false;
   end match;
@@ -3739 +3739 @@
 public function isInner
 "@author: adrpo
-  this function returns true if the given InnerOuter
-  is one of INNER_OUTER() or INNER()"
-  input InnerOuter io;
+  this function returns true if the given Absyn.InnerOuter
+  is one of Absyn.INNER_OUTER() or Absyn.INNER()"
+  input Absyn.InnerOuter io;
   output Boolean isItAnInner;
 algorithm
   isItAnInner := match(io)
-    case (INNER_OUTER()) then true;
-    case (INNER()) then true;
+    case (Absyn.INNER_OUTER()) then true;
+    case (Absyn.INNER()) then true;
     else false;
   end match;
@@ -3752 +3752 @@
 
 public function isOnlyInner
-  "Returns true if the InnerOuter is INNER, false otherwise."
-  input InnerOuter inIO;
+  "Returns true if the Absyn.InnerOuter is Absyn.INNER, false otherwise."
+  input Absyn.InnerOuter inIO;
   output Boolean outOnlyInner;
 algorithm
   outOnlyInner := match(inIO)
-    case (INNER()) then true;
+    case (Absyn.INNER()) then true;
     else false;
   end match;
@@ -3763 +3763 @@
 
 public function isOnlyOuter
-  "Returns true if the InnerOuter is OUTER, false otherwise."
-  input InnerOuter inIO;
+  "Returns true if the Absyn.InnerOuter is Absyn.OUTER, false otherwise."
+  input Absyn.InnerOuter inIO;
   output Boolean outOnlyOuter;
 algorithm
   outOnlyOuter := match(inIO)
-    case (OUTER()) then true;
+    case (Absyn.OUTER()) then true;
     else false;
   end match;
@@ -3774 +3774 @@
 
 public function isInnerOuter
-  input InnerOuter inIO;
+  input Absyn.InnerOuter inIO;
   output Boolean outIsInnerOuter;
 algorithm
   outIsInnerOuter := match(inIO)
-    case (INNER_OUTER()) then true;
+    case (Absyn.INNER_OUTER()) then true;
     else false;
   end match;
@@ -3784 +3784 @@
 
 public function isNotInnerOuter
-  input InnerOuter inIO;
+  input Absyn.InnerOuter inIO;
   output Boolean outIsNotInnerOuter;
 algorithm
   outIsNotInnerOuter := match(inIO)
-    case (NOT_INNER_OUTER()) then true;
+    case (Absyn.NOT_INNER_OUTER()) then true;
     else false;
   end match;
 end isNotInnerOuter;
 
-public function innerOuterEqual "Returns true if two InnerOuter's are equal"
-  input InnerOuter io1;
-  input InnerOuter io2;
+public function innerOuterEqual "Returns true if two Absyn.InnerOuter's are equal"
+  input Absyn.InnerOuter io1;
+  input Absyn.InnerOuter io2;
   output Boolean res;
 algorithm
   res := match(io1,io2)
-    case(INNER(),INNER()) then true;
-    case(OUTER(),OUTER()) then true;
-    case(INNER_OUTER(),INNER_OUTER()) then true;
-    case(NOT_INNER_OUTER(),NOT_INNER_OUTER()) then true;
+    case(Absyn.INNER(),Absyn.INNER()) then true;
+    case(Absyn.OUTER(),Absyn.OUTER()) then true;
+    case(Absyn.INNER_OUTER(),Absyn.INNER_OUTER()) then true;
+    case(Absyn.NOT_INNER_OUTER(),Absyn.NOT_INNER_OUTER()) then true;
     else false;
   end match;
@@ -3809 +3809 @@
 public function makeFullyQualified
 "Makes a path fully qualified unless it already is."
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inPath)
-    case FULLYQUALIFIED() then inPath;
-    else FULLYQUALIFIED(inPath);
+    case Absyn.FULLYQUALIFIED() then inPath;
+    else Absyn.FULLYQUALIFIED(inPath);
   end match;
 end makeFullyQualified;
@@ -3820 +3820 @@
 public function makeNotFullyQualified
 "Makes a path not fully qualified unless it already is."
-  input Path inPath;
-  output Path outPath;
+  input Absyn.Path inPath;
+  output Absyn.Path outPath;
 algorithm
   outPath := match inPath
-    local Path path;
-    case FULLYQUALIFIED(path) then path;
+    local Absyn.Path path;
+    case Absyn.FULLYQUALIFIED(path) then path;
     else inPath;
   end match;
@@ -3831 +3831 @@
 
 public function importEqual "Compares two import elements. "
-  input Import im1;
-  input Import im2;
+  input Absyn.Import im1;
+  input Absyn.Import im2;
   output Boolean outBoolean;
 algorithm
   outBoolean := matchcontinue (im1,im2)
     local
-      Ident id,id2;
-      Path p1,p2;
-    case (NAMED_IMPORT(name = id,path=p1),NAMED_IMPORT(name = id2,path=p2))
+      Absyn.Ident id,id2;
+      Absyn.Path p1,p2;
+    case (Absyn.NAMED_IMPORT(name = id,path=p1),Absyn.NAMED_IMPORT(name = id2,path=p2))
       equation
         true = stringEq(id, id2);
@@ -3845 +3845 @@
       then
         true;
-    case (QUAL_IMPORT(path=p1),QUAL_IMPORT(path=p2))
+    case (Absyn.QUAL_IMPORT(path=p1),Absyn.QUAL_IMPORT(path=p2))
       equation
         true = pathEqual(p1,p2);
       then
         true;
-    case (UNQUAL_IMPORT(path=p1),UNQUAL_IMPORT(path=p2))
+    case (Absyn.UNQUAL_IMPORT(path=p1),Absyn.UNQUAL_IMPORT(path=p2))
       equation
         true = pathEqual(p1,p2);
@@ -3860 +3860 @@
 
 public function canonIfExp "Transforms an if-expression to canonical form (without else-if branches)"
-  input Exp inExp;
-  output Exp outExp;
+  input Absyn.Exp inExp;
+  output Absyn.Exp outExp;
 algorithm
   outExp := match inExp
     local
-      Exp cond,tb,eb,ei_cond,ei_tb,e;
-      list<tuple<Exp,Exp>> eib;
-
-    case IFEXP(elseIfBranch={}) then inExp;
-    case IFEXP(ifExp=cond,trueBranch=tb,elseBranch=eb,elseIfBranch=(ei_cond,ei_tb)::eib)
-      equation
-        e = canonIfExp(IFEXP(ei_cond,ei_tb,eb,eib));
-      then IFEXP(cond,tb,e,{});
+      Absyn.Exp cond,tb,eb,ei_cond,ei_tb,e;
+      list<tuple<Absyn.Exp,Absyn.Exp>> eib;
+
+    case Absyn.IFEXP(elseIfBranch={}) then inExp;
+    case Absyn.IFEXP(ifExp=cond,trueBranch=tb,elseBranch=eb,elseIfBranch=(ei_cond,ei_tb)::eib)
+      equation
+        e = canonIfExp(Absyn.IFEXP(ei_cond,ei_tb,eb,eib));
+      then Absyn.IFEXP(cond,tb,e,{});
   end match;
 end canonIfExp;
@@ -3879 +3879 @@
 "@author: adrpo
   This function checks if a modification only contains literal expressions"
-  input list<ElementArg> inMod;
+  input list<Absyn.ElementArg> inMod;
   output Boolean onlyLiterals;
 algorithm
   onlyLiterals := matchcontinue(inMod)
     local
-      list<ElementArg> dive, rest;
-      EqMod eqMod;
+      list<Absyn.ElementArg> dive, rest;
+      Absyn.EqMod eqMod;
       Boolean b1, b2, b3, b;
 
@@ -3891 +3891 @@
 
     // skip "interaction" annotation!
-    case (MODIFICATION(path = IDENT(name = "interaction")) :: rest)
+    case (Absyn.MODIFICATION(path = Absyn.IDENT(name = "interaction")) :: rest)
       equation
         b = onlyLiteralsInAnnotationMod(rest);
@@ -3899 +3899 @@
 
     // search inside, some(exp)
-    case (MODIFICATION(modification = SOME(CLASSMOD(dive, eqMod))) :: rest)
+    case (Absyn.MODIFICATION(modification = SOME(Absyn.CLASSMOD(dive, eqMod))) :: rest)
       equation
         b1 = onlyLiteralsInEqMod(eqMod);
@@ -3923 +3923 @@
 "@author: adrpo
   This function checks if an optional expression only contains literal expressions"
-  input EqMod eqMod;
+  input Absyn.EqMod eqMod;
   output Boolean onlyLiterals;
 algorithm
   onlyLiterals := match (eqMod)
     local
-      Exp exp;
-      list<Exp> lst;
+      Absyn.Exp exp;
+      list<Absyn.Exp> lst;
       Boolean b;
 
-    case (NOMOD()) then true;
+    case (Absyn.NOMOD()) then true;
 
     // search inside, some(exp)
-    case (EQMOD(exp=exp))
+    case (Absyn.EQMOD(exp=exp))
       equation
          (_, lst::{}) = traverseExpBidir(exp, onlyLiteralsInExpEnter, onlyLiteralsInExpExit, {}::{});
@@ -3946 +3946 @@
 protected function onlyLiteralsInExpEnter
 "@author: adrpo
- Visitor function for checking if Exp contains only literals, NO CREFS!
+ Visitor function for checking if Absyn.Exp contains only literals, NO CREFS!
  It returns an empty list if it doesn't contain any crefs!"
-  input Exp inExp;
-  input list<list<Exp>> inLst;
-  output Exp outExp;
-  output list<list<Exp>> outLst;
+  input Absyn.Exp inExp;
+  input list<list<Absyn.Exp>> inLst;
+  output Absyn.Exp outExp;
+  output list<list<Absyn.Exp>> outLst;
 algorithm
   (outExp,outLst) := match (inExp,inLst)
     local
       Boolean b;
-      Exp e;
-      ComponentRef cr;
-      list<Exp> lst;
-      list<list<Exp>> rest;
+      Absyn.Exp e;
+      Absyn.ComponentRef cr;
+      list<Absyn.Exp> lst;
+      list<list<Absyn.Exp>> rest;
       String name;
-      FunctionArgs fargs;
+      Absyn.FunctionArgs fargs;
 
     // first handle all graphic enumerations!
     // FillPattern.*, Smooth.*, TextAlignment.*, etc!
-    case (e as CREF(CREF_QUAL(name=name)), lst::rest)
+    case (e as Absyn.CREF(Absyn.CREF_QUAL(name=name)), lst::rest)
       equation
         b = listMember(name,{
@@ -3979 +3979 @@
 
     // crefs, add to list
-    case (CREF(), lst::rest) then (inExp,(inExp::lst)::rest);
+    case (Absyn.CREF(), lst::rest) then (inExp,(inExp::lst)::rest);
 
     // anything else, return the same!
@@ -3989 +3989 @@
 protected function onlyLiteralsInExpExit
 "@author: adrpo
- Visitor function for checking if Exp contains only literals, NO CREFS!
+ Visitor function for checking if Absyn.Exp contains only literals, NO CREFS!
  It returns an empty list if it doesn't contain any crefs!"
-  input Exp inExp;
-  input list<list<Exp>> inLst;
-  output Exp outExp;
-  output list<list<Exp>> outLst;
+  input Absyn.Exp inExp;
+  input list<list<Absyn.Exp>> inLst;
+  output Absyn.Exp outExp;
+  output list<list<Absyn.Exp>> outLst;
 algorithm
   (outExp,outLst) := match (inExp,inLst)
     local
-      list<list<Exp>> lst;
+      list<list<Absyn.Exp>> lst;
 
     // first handle DynamicSelect; pop the stack (ignore any crefs inside DynamicSelect)
-    case (CALL(function_ = CREF_IDENT(name = "DynamicSelect")), lst)
+    case (Absyn.CALL(function_ = Absyn.CREF_IDENT(name = "DynamicSelect")), lst)
       then (inExp, lst);
 
@@ -4011 +4011 @@
 
 public function makeCons
-  input Exp e1;
-  input Exp e2;
-  output Exp e;
-algorithm
-  e := CONS(e1,e2);
+  input Absyn.Exp e1;
+  input Absyn.Exp e2;
+  output Absyn.Exp e;
+algorithm
+  e := Absyn.CONS(e1,e2);
 annotation(__OpenModelica_EarlyInline = true);
 end makeCons;
 
 public function crefIdent
-  input ComponentRef cr;
+  input Absyn.ComponentRef cr;
   output String str;
 algorithm
-  CREF_IDENT(str,{}) := cr;
+  Absyn.CREF_IDENT(str,{}) := cr;
 end crefIdent;
 
 public function unqotePathIdents
-  input Path inPath;
-  output Path path;
+  input Absyn.Path inPath;
+  output Absyn.Path path;
 algorithm
   path := stringListPath(List.map(pathToStringList(inPath), System.unquoteIdentifier));
@@ -4036 +4036 @@
   "If the given component reference is fully qualified this function removes the
   fully qualified qualifier, otherwise does nothing."
-  input ComponentRef inCref;
-  output ComponentRef outCref;
+  input Absyn.ComponentRef inCref;
+  output Absyn.ComponentRef outCref;
 algorithm
   outCref := match(inCref)
     local
-      ComponentRef cref;
-
-    case CREF_FULLYQUALIFIED(componentRef = cref) then cref;
+      Absyn.ComponentRef cref;
+
+    case Absyn.CREF_FULLYQUALIFIED(componentRef = cref) then cref;
     else inCref;
   end match;
@@ -4049 +4049 @@
 
 public function pathIsFullyQualified
-  input Path inPath;
+  input Absyn.Path inPath;
   output Boolean outIsQualified;
 algorithm
   outIsQualified := match(inPath)
-    case FULLYQUALIFIED() then true;
+    case Absyn.FULLYQUALIFIED() then true;
     else false;
   end match;
@@ -4059 +4059 @@
 
 public function pathIsIdent
-  input Path inPath;
+  input Absyn.Path inPath;
   output Boolean outIsIdent;
 algorithm
   outIsIdent := match(inPath)
-    case IDENT() then true;
+    case Absyn.IDENT() then true;
     else false;
   end match;
@@ -4069 +4069 @@
 
 public function pathIsQual
-  input Path inPath;
+  input Absyn.Path inPath;
   output Boolean outIsQual;
 algorithm
   outIsQual := match(inPath)
-    case QUALIFIED() then true;
+    case Absyn.QUALIFIED() then true;
     else false;
   end match;
@@ -4079 +4079 @@
 
 public function withinEqual
-  input Within within1;
-  input Within within2;
+  input Absyn.Within within1;
+  input Absyn.Within within2;
   output Boolean b;
 algorithm
   b := match (within1,within2)
     local
-      Path p1,p2;
-    case (TOP(),TOP()) then true;
-    case (WITHIN(p1),WITHIN(p2)) then pathEqual(p1,p2);
+      Absyn.Path p1,p2;
+    case (Absyn.TOP(),Absyn.TOP()) then true;
+    case (Absyn.WITHIN(p1),Absyn.WITHIN(p2)) then pathEqual(p1,p2);
     else false;
   end match;
@@ -4093 +4093 @@
 
 public function withinEqualCaseInsensitive
-  input Within within1;
-  input Within within2;
+  input Absyn.Within within1;
+  input Absyn.Within within2;
   output Boolean b;
 algorithm
   b := match (within1,within2)
     local
-      Path p1,p2;
-    case (TOP(),TOP()) then true;
-    case (WITHIN(p1),WITHIN(p2)) then pathEqualCaseInsensitive(p1,p2);
+      Absyn.Path p1,p2;
+    case (Absyn.TOP(),Absyn.TOP()) then true;
+    case (Absyn.WITHIN(p1),Absyn.WITHIN(p2)) then pathEqualCaseInsensitive(p1,p2);
     else false;
   end match;
@@ -4107 +4107 @@
 
 public function withinString
-  input Within w1;
+  input Absyn.Within w1;
   output String str;
 algorithm
   str := match (w1)
     local
-      Path p1;
-    case (TOP()) then "within ;";
-    case (WITHIN(p1)) then "within " + pathString(p1) + ";";
+      Absyn.Path p1;
+    case (Absyn.TOP()) then "within ;";
+    case (Absyn.WITHIN(p1)) then "within " + pathString(p1) + ";";
   end match;
 end withinString;
 
 public function joinWithinPath
-  input Within within_;
-  input Path path;
-  output Path outPath;
+  input Absyn.Within within_;
+  input Absyn.Path path;
+  output Absyn.Path outPath;
 algorithm
   outPath := match (within_,path)
     local
-      Path path1;
-    case (TOP(),_) then path;
-    case (WITHIN(path1),_) then joinPaths(path1,path);
+      Absyn.Path path1;
+    case (Absyn.TOP(),_) then path;
+    case (Absyn.WITHIN(path1),_) then joinPaths(path1,path);
   end match;
 end joinWithinPath;
 
 public function innerOuterStr
-  input InnerOuter io;
+  input Absyn.InnerOuter io;
   output String str;
 algorithm
   str := match(io)
-    case (INNER_OUTER()) then "inner outer ";
-    case (INNER()) then "inner ";
-    case (OUTER()) then "outer ";
-    case (NOT_INNER_OUTER()) then "";
+    case (Absyn.INNER_OUTER()) then "inner outer ";
+    case (Absyn.INNER()) then "inner ";
+    case (Absyn.OUTER()) then "outer ";
+    case (Absyn.NOT_INNER_OUTER()) then "";
   end match;
 end innerOuterStr;
 
 public function subscriptExpOpt
-  input Subscript inSub;
-  output Option<Exp> outExpOpt;
+  input Absyn.Subscript inSub;
+  output Option<Absyn.Exp> outExpOpt;
 algorithm
   outExpOpt := match(inSub)
     local
-      Exp e;
-
-    case SUBSCRIPT(subscript = e) then SOME(e);
-    case NOSUB() then NONE();
+      Absyn.Exp e;
+
+    case Absyn.SUBSCRIPT(subscript = e) then SOME(e);
+    case Absyn.NOSUB() then NONE();
   end match;
 end subscriptExpOpt;
 
 public function crefInsertSubscriptLstLst
-  input Exp inExp;
-  input list<list<Subscript>> inLst;
-  output Exp outExp;
-  output list<list<Subscript>> outLst;
+  input Absyn.Exp inExp;
+  input list<list<Absyn.Subscript>> inLst;
+  output Absyn.Exp outExp;
+  output list<list<Absyn.Subscript>> outLst;
 algorithm
   (outExp,outLst) := matchcontinue(inExp,inLst)
     local
-      ComponentRef cref,cref2;
-      list<list<Subscript>> subs;
-      Exp e;
-    case (CREF(componentRef=cref),subs)
+      Absyn.ComponentRef cref,cref2;
+      list<list<Absyn.Subscript>> subs;
+      Absyn.Exp e;
+    case (Absyn.CREF(componentRef=cref),subs)
       equation
         cref2 = crefInsertSubscriptLstLst2(cref,subs);
       then
-         (CREF(cref2),subs);
+         (Absyn.CREF(cref2),subs);
     else (inExp,inLst);
   end matchcontinue;
@@ -4178 +4178 @@
 public function crefInsertSubscriptLstLst2
 "Helper function to crefInsertSubscriptLstLst"
-  input ComponentRef inCref;
-  input list<list<Subscript>> inSubs;
-  output ComponentRef outCref;
+  input Absyn.ComponentRef inCref;
+  input list<list<Absyn.Subscript>> inSubs;
+  output Absyn.ComponentRef outCref;
 algorithm
   outCref := matchcontinue(inCref,inSubs)
     local
-      ComponentRef cref, cref2;
-      Ident n;
-      list<list<Subscript>> subs;
-      list<Subscript> s;
+      Absyn.ComponentRef cref, cref2;
+      Absyn.Ident n;
+      list<list<Absyn.Subscript>> subs;
+      list<Absyn.Subscript> s;
       case (cref,{})
         then cref;
-      case (CREF_IDENT(name = n), {s})
-        then CREF_IDENT(n,s);
-      case (CREF_QUAL(name = n, componentRef = cref), s::subs)
+      case (Absyn.CREF_IDENT(name = n), {s})
+        then Absyn.CREF_IDENT(n,s);
+      case (Absyn.CREF_QUAL(name = n, componentRef = cref), s::subs)
         equation
           cref2 = crefInsertSubscriptLstLst2(cref, subs);
         then
-          CREF_QUAL(n,s,cref2);
-      case (CREF_FULLYQUALIFIED(componentRef = cref), subs)
+          Absyn.CREF_QUAL(n,s,cref2);
+      case (Absyn.CREF_FULLYQUALIFIED(componentRef = cref), subs)
         equation
           cref2 = crefInsertSubscriptLstLst2(cref, subs);
@@ -4206 +4206 @@
 
 public function isCref
-  input Exp exp;
+  input Absyn.Exp exp;
   output Boolean b;
 algorithm
   b := match exp
-    case CREF() then true;
+    case Absyn.CREF() then true;
     else false;
   end match;
@@ -4216 +4216 @@
 
 public function isTuple
-  input Exp exp;
+  input Absyn.Exp exp;
   output Boolean b;
 algorithm
   b := match exp
-    case TUPLE(__) then true;
+    case Absyn.TUPLE(__) then true;
     else false;
   end match;
@@ -4228 +4228 @@
   "@author: johti
    Returns true if all fields are crefs"
-  input list<Exp> expLst;
+  input list<Absyn.Exp> expLst;
   output Boolean b;
 algorithm
@@ -4238 +4238 @@
     Returns true if everything contained
     in the tuple or a cons cell is a constant reference."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   output Boolean b;
 algorithm
   b := match inExp
-    case TUPLE(__) then allFieldsAreCrefs(inExp.expressions);
-    case CONS(__) then complexIsCref(inExp.head) and complexIsCref(inExp.rest);
+    case Absyn.TUPLE(__) then allFieldsAreCrefs(inExp.expressions);
+    case Absyn.CONS(__) then complexIsCref(inExp.head) and complexIsCref(inExp.rest);
     case _ then isCref(inExp);
   end match;
@@ -4249 +4249 @@
 
 public function isDerCref
-  input Exp exp;
+  input Absyn.Exp exp;
   output Boolean b;
 algorithm
   b := match exp
-    case CALL(CREF_IDENT("der",{}),FUNCTIONARGS({CREF()},{})) then true;
+    case Absyn.CALL(Absyn.CREF_IDENT("der",{}),Absyn.FUNCTIONARGS({Absyn.CREF()},{})) then true;
     else false;
   end match;
@@ -4259 +4259 @@
 
 public function isDerCrefFail
-  input Exp exp;
-algorithm
-  CALL(CREF_IDENT("der",{}),FUNCTIONARGS({CREF()},{})) := exp;
+  input Absyn.Exp exp;
+algorithm
+  Absyn.CALL(Absyn.CREF_IDENT("der",{}),Absyn.FUNCTIONARGS({Absyn.CREF()},{})) := exp;
 end isDerCrefFail;
 
@@ -4268 +4268 @@
   returns all the expressions from array dimension as a list
   also returns if we have unknown dimensions in the array dimension"
-  input ArrayDim inAd;
+  input Absyn.ArrayDim inAd;
   output Boolean hasUnknownDimensions;
-  output list<Exp> outExps;
+  output list<Absyn.Exp> outExps;
 algorithm
   (hasUnknownDimensions, outExps) := getExpsFromArrayDim_tail(inAd, {});
@@ -4279 +4279 @@
   returns all the expressions from array dimension as a list
   also returns if we have unknown dimensions in the array dimension"
-  input Option<ArrayDim> inAdO;
+  input Option<Absyn.ArrayDim> inAdO;
   output Boolean hasUnknownDimensions;
-  output list<Exp> outExps;
+  output list<Absyn.Exp> outExps;
 algorithm
   (hasUnknownDimensions, outExps) := match(inAdO)
-    local ArrayDim ad;
+    local Absyn.ArrayDim ad;
 
     case (NONE()) then (false, {});
@@ -4301 +4301 @@
   returns all the expressions from array dimension as a list
   also returns if we have unknown dimensions in the array dimension"
-  input ArrayDim inAd;
-  input list<Exp> inAccumulator;
+  input Absyn.ArrayDim inAd;
+  input list<Absyn.Exp> inAccumulator;
   output Boolean hasUnknownDimensions;
-  output list<Exp> outExps;
+  output list<Absyn.Exp> outExps;
 algorithm
   (hasUnknownDimensions, outExps) := match(inAd, inAccumulator)
     local
-      list<Subscript> rest;
-      Exp e;
-      list<Exp> exps, acc;
+      list<Absyn.Subscript> rest;
+      Absyn.Exp e;
+      list<Absyn.Exp> exps, acc;
       Boolean b;
 
@@ -4316 +4316 @@
     case ({}, acc) then (false, listReverse(acc));
 
-    // handle SUBSCRIPT
-    case (SUBSCRIPT(e)::rest, acc)
+    // handle Absyn.SUBSCRIPT
+    case (Absyn.SUBSCRIPT(e)::rest, acc)
       equation
         (b, exps) = getExpsFromArrayDim_tail(rest, e::acc);
@@ -4323 +4323 @@
          (b, exps);
 
-    // handle NOSUB
-    case (NOSUB()::rest, acc)
+    // handle Absyn.NOSUB
+    case (Absyn.NOSUB()::rest, acc)
       equation
         (_, exps) = getExpsFromArrayDim_tail(rest, acc);
@@ -4335 +4335 @@
 "@author: adrpo
  returns true if the given direction is input or output"
- input Direction direction;
+ input Absyn.Direction direction;
  output Boolean isIorO "input or output only";
 algorithm
   isIorO := match(direction)
-    case (INPUT()) then true;
-    case (OUTPUT()) then true;
-    case (INPUT_OUTPUT()) then true;
-    case (BIDIR()) then false;
+    case (Absyn.INPUT()) then true;
+    case (Absyn.OUTPUT()) then true;
+    case (Absyn.INPUT_OUTPUT()) then true;
+    case (Absyn.BIDIR()) then false;
   end match;
 end isInputOrOutput;
 
 public function isInput
-  input Direction inDirection;
+  input Absyn.Direction inDirection;
   output Boolean outIsInput;
 algorithm
   outIsInput := match(inDirection)
-    case INPUT() then true;
-    case INPUT_OUTPUT() then true;
+    case Absyn.INPUT() then true;
+    case Absyn.INPUT_OUTPUT() then true;
     else false;
   end match;
@@ -4358 +4358 @@
 
 public function isOutput
-  input Direction inDirection;
+  input Absyn.Direction inDirection;
   output Boolean outIsOutput;
 algorithm
   outIsOutput := match(inDirection)
-    case OUTPUT() then true;
-    case INPUT_OUTPUT() then true;
+    case Absyn.OUTPUT() then true;
+    case Absyn.INPUT_OUTPUT() then true;
     else false;
   end match;
@@ -4369 +4369 @@
 
 public function directionEqual
-  input Direction inDirection1;
-  input Direction inDirection2;
+  input Absyn.Direction inDirection1;
+  input Absyn.Direction inDirection2;
   output Boolean outEqual;
 algorithm
   outEqual := match(inDirection1, inDirection2)
-    case (BIDIR(), BIDIR()) then true;
-    case (INPUT(), INPUT()) then true;
-    case (OUTPUT(), OUTPUT()) then true;
-    case (INPUT_OUTPUT(), INPUT_OUTPUT()) then true;
+    case (Absyn.BIDIR(), Absyn.BIDIR()) then true;
+    case (Absyn.INPUT(), Absyn.INPUT()) then true;
+    case (Absyn.OUTPUT(), Absyn.OUTPUT()) then true;
+    case (Absyn.INPUT_OUTPUT(), Absyn.INPUT_OUTPUT()) then true;
     else false;
   end match;
@@ -4383 +4383 @@
 
 public function isFieldEqual
-  input IsField isField1;
-  input IsField isField2;
+  input Absyn.IsField isField1;
+  input Absyn.IsField isField2;
   output Boolean outEqual;
 algorithm
   outEqual := match(isField1, isField2)
-    case (NONFIELD(), NONFIELD()) then true;
-    case (FIELD(), FIELD()) then true;
+    case (Absyn.NONFIELD(), Absyn.NONFIELD()) then true;
+    case (Absyn.FIELD(), Absyn.FIELD()) then true;
     else false;
   end match;
@@ -4396 +4396 @@
 
 public function pathLt
-  input Path path1;
-  input Path path2;
+  input Absyn.Path path1;
+  input Absyn.Path path2;
   output Boolean lt;
 algorithm
@@ -4404 +4404 @@
 
 public function pathGe
-  input Path path1;
-  input Path path2;
+  input Absyn.Path path1;
+  input Absyn.Path path2;
   output Boolean ge;
 algorithm
@@ -4412 +4412 @@
 
 public function getShortClass "Strips out long class definitions"
-  input Class cl;
-  output Class o;
+  input Absyn.Class cl;
+  output Absyn.Class o;
 algorithm
   o := match cl
     local
-      Ident name;
+      Absyn.Ident name;
       Boolean pa, fi, en;
-      Restriction re;
-      ClassDef body;
-      Info info;
-    case CLASS(body=PARTS()) then fail();
-    case CLASS(body=CLASS_EXTENDS()) then fail();
-    case CLASS(name,pa,fi,en,re,body,info)
+      Absyn.Restriction re;
+      Absyn.ClassDef body;
+      Absyn.Info info;
+    case Absyn.CLASS(body=Absyn.PARTS()) then fail();
+    case Absyn.CLASS(body=Absyn.CLASS_EXTENDS()) then fail();
+    case Absyn.CLASS(name,pa,fi,en,re,body,info)
       equation
         body = stripClassDefComment(body);
-      then CLASS(name,pa,fi,en,re,body,info);
+      then Absyn.CLASS(name,pa,fi,en,re,body,info);
   end match;
 end getShortClass;
@@ -4433 +4433 @@
 protected function stripClassDefComment
   "Strips out class definition comments."
-  input ClassDef cl;
-  output ClassDef o;
+  input Absyn.ClassDef cl;
+  output Absyn.ClassDef o;
 algorithm
   o := match cl
     local
-      EnumDef enumLiterals;
-      TypeSpec typeSpec;
-      ElementAttributes attributes;
-      list<ElementArg> arguments;
-      list<Path> functionNames;
-      Path functionName;
-      list<Ident> vars;
+      Absyn.EnumDef enumLiterals;
+      Absyn.TypeSpec typeSpec;
+      Absyn.ElementAttributes attributes;
+      list<Absyn.ElementArg> arguments;
+      list<Absyn.Path> functionNames;
+      Absyn.Path functionName;
+      list<Absyn.Ident> vars;
       list<String> typeVars;
-      Ident baseClassName;
-      list<ElementArg> modifications;
-      list<ClassPart> parts;
-      list<NamedArg> classAttrs;
-      list<Annotation> ann;
-    case PARTS(typeVars,classAttrs,parts,ann,_) then PARTS(typeVars,classAttrs,parts,ann,NONE());
-    case CLASS_EXTENDS(baseClassName,modifications,_,parts,ann) then CLASS_EXTENDS(baseClassName,modifications,NONE(),parts,ann);
-    case DERIVED(typeSpec,attributes,arguments,_) then DERIVED(typeSpec,attributes,arguments,NONE());
-    case ENUMERATION(enumLiterals,_) then ENUMERATION(enumLiterals,NONE());
-    case OVERLOAD(functionNames,_) then OVERLOAD(functionNames,NONE());
-    case PDER(functionName,vars,_) then PDER(functionName,vars,NONE());
+      Absyn.Ident baseClassName;
+      list<Absyn.ElementArg> modifications;
+      list<Absyn.ClassPart> parts;
+      list<Absyn.NamedArg> classAttrs;
+      list<Absyn.Annotation> ann;
+    case Absyn.PARTS(typeVars,classAttrs,parts,ann,_) then Absyn.PARTS(typeVars,classAttrs,parts,ann,NONE());
+    case Absyn.CLASS_EXTENDS(baseClassName,modifications,_,parts,ann) then Absyn.CLASS_EXTENDS(baseClassName,modifications,NONE(),parts,ann);
+    case Absyn.DERIVED(typeSpec,attributes,arguments,_) then Absyn.DERIVED(typeSpec,attributes,arguments,NONE());
+    case Absyn.ENUMERATION(enumLiterals,_) then Absyn.ENUMERATION(enumLiterals,NONE());
+    case Absyn.OVERLOAD(functionNames,_) then Absyn.OVERLOAD(functionNames,NONE());
+    case Absyn.PDER(functionName,vars,_) then Absyn.PDER(functionName,vars,NONE());
     else cl;
   end match;
@@ -4462 +4462 @@
 
 public function getFunctionInterface "Strips out the parts of a function definition that are not needed for the interface"
-  input Class cl;
-  output Class o;
+  input Absyn.Class cl;
+  output Absyn.Class o;
 algorithm
   o := match cl
     local
-      Ident name;
+      Absyn.Ident name;
       Boolean partialPrefix, finalPrefix, encapsulatedPrefix;
-      Info info;
+      Absyn.Info info;
       list<String> typeVars;
-      list<ClassPart> classParts;
-      list<ElementItem> elts;
-      FunctionRestriction funcRest;
-      list<NamedArg> classAttr;
-    case CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,R_FUNCTION(funcRest),PARTS(typeVars,classAttr,classParts,_,_),info)
+      list<Absyn.ClassPart> classParts;
+      list<Absyn.ElementItem> elts;
+      Absyn.FunctionRestriction funcRest;
+      list<Absyn.NamedArg> classAttr;
+    case Absyn.CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,Absyn.R_FUNCTION(funcRest),Absyn.PARTS(typeVars,classAttr,classParts,_,_),info)
       equation
         (elts as _::_) = List.fold(listReverse(classParts),getFunctionInterfaceParts,{});
-      then CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,R_FUNCTION(funcRest),PARTS(typeVars,classAttr,PUBLIC(elts)::{},{},NONE()),info);
+      then Absyn.CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,Absyn.R_FUNCTION(funcRest),Absyn.PARTS(typeVars,classAttr,Absyn.PUBLIC(elts)::{},{},NONE()),info);
   end match;
 end getFunctionInterface;
 
 protected function getFunctionInterfaceParts
-  input ClassPart part;
-  input list<ElementItem> elts;
-  output list<ElementItem> oelts;
+  input Absyn.ClassPart part;
+  input list<Absyn.ElementItem> elts;
+  output list<Absyn.ElementItem> oelts;
 algorithm
   oelts := match (part,elts)
     local
-      list<ElementItem> elts1,elts2;
-    case (PUBLIC(elts1),elts2)
+      list<Absyn.ElementItem> elts1,elts2;
+    case (Absyn.PUBLIC(elts1),elts2)
       equation
         elts1 = List.filterOnTrue(elts1,filterAnnotationItem);
@@ -4499 +4499 @@
 
 protected function filterAnnotationItem
-  input ElementItem elt;
+  input Absyn.ElementItem elt;
   output Boolean outB;
 algorithm
   outB := match elt
-    case ELEMENTITEM() then true;
+    case Absyn.ELEMENTITEM() then true;
     else false;
   end match;
@@ -4510 +4510 @@
 public function filterNestedClasses
   "Filter outs the nested classes from the class if any."
-  input Class cl;
-  output Class o;
+  input Absyn.Class cl;
+  output Absyn.Class o;
 algorithm
   o := match cl
     local
-      Ident name;
+      Absyn.Ident name;
       Boolean partialPrefix, finalPrefix, encapsulatedPrefix;
-      Restriction restriction;
+      Absyn.Restriction restriction;
       list<String> typeVars;
-      list<NamedArg> classAttrs;
-      list<ClassPart> classParts;
-      list<Annotation> annotations;
+      list<Absyn.NamedArg> classAttrs;
+      list<Absyn.ClassPart> classParts;
+      list<Absyn.Annotation> annotations;
       Option<String> comment;
-      Info info;
-    case CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,restriction,PARTS(typeVars,classAttrs,classParts,annotations,comment),info)
+      Absyn.Info info;
+    case Absyn.CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,restriction,Absyn.PARTS(typeVars,classAttrs,classParts,annotations,comment),info)
       equation
         (classParts as _::_) = List.fold(listReverse(classParts),filterNestedClassesParts,{});
-      then CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,restriction,PARTS(typeVars,classAttrs,classParts,annotations,comment),info);
+      then Absyn.CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,restriction,Absyn.PARTS(typeVars,classAttrs,classParts,annotations,comment),info);
     else cl;
   end match;
@@ -4534 +4534 @@
 protected function filterNestedClassesParts
   "Helper funciton for filterNestedClassesParts."
-  input ClassPart classPart;
-  input list<ClassPart> inClassParts;
-  output list<ClassPart> outClassPart;
+  input Absyn.ClassPart classPart;
+  input list<Absyn.ClassPart> inClassParts;
+  output list<Absyn.ClassPart> outClassPart;
 algorithm
   outClassPart := match (classPart, inClassParts)
     local
-      list<ClassPart> classParts;
-      list<ElementItem> elts;
-    case (PUBLIC(elts), classParts)
+      list<Absyn.ClassPart> classParts;
+      list<Absyn.ElementItem> elts;
+    case (Absyn.PUBLIC(elts), classParts)
       equation
         classPart.contents = List.filterOnFalse(elts, isElementItemClass);
       then classPart::classParts;
-    case (PROTECTED(elts), classParts)
+    case (Absyn.PROTECTED(elts), classParts)
       equation
         classPart.contents = List.filterOnFalse(elts, isElementItemClass);
@@ -4556 +4556 @@
 public function getExternalDecl
   "@author: adrpo
-   returns the EXTERNAL form parts if there is any.
+   returns the Absyn.EXTERNAL form parts if there is any.
    if there is none, it fails!"
-  input Class inCls;
-  output ClassPart outExternal;
+  input Absyn.Class inCls;
+  output Absyn.ClassPart outExternal;
 protected
-  ClassPart cp;
-  list<ClassPart> class_parts;
-algorithm
-  CLASS(body = PARTS(classParts = class_parts)) := inCls;
+  Absyn.ClassPart cp;
+  list<Absyn.ClassPart> class_parts;
+algorithm
+  Absyn.CLASS(body = Absyn.PARTS(classParts = class_parts)) := inCls;
   outExternal := List.find(class_parts, isExternalPart);
 end getExternalDecl;
 
 protected function isExternalPart
-  input ClassPart inClassPart;
+  input Absyn.ClassPart inClassPart;
   output Boolean outFound;
 algorithm
   outFound := match inClassPart
-    case EXTERNAL() then true;
+    case Absyn.EXTERNAL() then true;
     else false;
   end match;
@@ -4579 +4579 @@
 
 public function isParts
-  input ClassDef cl;
+  input Absyn.ClassDef cl;
   output Boolean b;
 algorithm
   b := match cl
-    case PARTS() then true;
+    case Absyn.PARTS() then true;
     else false;
   end match;
 end isParts;
 
-public function makeClassElement "Makes a class into an ElementItem"
-  input Class cl;
-  output ElementItem el;
+public function makeClassElement "Makes a class into an Absyn.ElementItem"
+  input Absyn.Class cl;
+  output Absyn.ElementItem el;
 protected
-  Info info;
+  Absyn.Info info;
   Boolean fp;
 algorithm
-  CLASS(finalPrefix = fp, info = info) := cl;
-  el := ELEMENTITEM(ELEMENT(fp,NONE(),NOT_INNER_OUTER(),CLASSDEF(false,cl),info,NONE()));
+  Absyn.CLASS(finalPrefix = fp, info = info) := cl;
+  el := Absyn.ELEMENTITEM(Absyn.ELEMENT(fp,NONE(),Absyn.NOT_INNER_OUTER(),Absyn.CLASSDEF(false,cl),info,NONE()));
 end makeClassElement;
 
 public function componentName
-  input ComponentItem c;
+  input Absyn.ComponentItem c;
   output String name;
 algorithm
-  COMPONENTITEM(component=COMPONENT(name=name)) := c;
+  Absyn.COMPONENTITEM(component=Absyn.COMPONENT(name=name)) := c;
 end componentName;
 
 public function pathSetLastIdent
-  input Path inPath;
-  input Path inLastIdent;
-  output Path outPath;
+  input Absyn.Path inPath;
+  input Absyn.Path inLastIdent;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inPath, inLastIdent)
     local
-      Path p;
+      Absyn.Path p;
       String n;
 
-    case (IDENT(), _) then inLastIdent;
-
-    case (QUALIFIED(n, p), _)
+    case (Absyn.IDENT(), _) then inLastIdent;
+
+    case (Absyn.QUALIFIED(n, p), _)
       equation
         p = pathSetLastIdent(p, inLastIdent);
       then
-        QUALIFIED(n, p);
-
-    case (FULLYQUALIFIED(p), _)
+        Absyn.QUALIFIED(n, p);
+
+    case (Absyn.FULLYQUALIFIED(p), _)
       equation
         p = pathSetLastIdent(p, inLastIdent);
       then
-        FULLYQUALIFIED(p);
+        Absyn.FULLYQUALIFIED(p);
 
   end match;
@@ -4636 +4636 @@
 "@author:
   returns true if expression contains initial()"
-  input Exp inExp;
+  input Absyn.Exp inExp;
   output Boolean hasInitial;
 algorithm
@@ -4653 +4653 @@
 "@author:
   returns true if expression is initial()"
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input Boolean inBool;
-  output Exp outExp;
+  output Absyn.Exp outExp;
   output Boolean outBool;
 algorithm
   (outExp,outBool) := match (inExp,inBool)
-    local Exp e; Boolean b;
+    local Absyn.Exp e; Boolean b;
 
     // make sure we don't have not initial()
-    case (UNARY(NOT(), _) , _) then (inExp,inBool);
+    case (Absyn.UNARY(Absyn.NOT(), _) , _) then (inExp,inBool);
     // we have initial
     case (e , _)
@@ -4675 +4675 @@
 "@author:
   returns true if expression is initial()"
-  input Exp inExp;
+  input Absyn.Exp inExp;
   output Boolean hasReinit;
 algorithm
   hasReinit := match(inExp)
-    case (CALL(function_ = CREF_IDENT("initial", _))) then true;
-    case (CALL(function_ = CREF_FULLYQUALIFIED(CREF_IDENT("initial", _)))) then true;
+    case (Absyn.CALL(function_ = Absyn.CREF_IDENT("initial", _))) then true;
+    case (Absyn.CALL(function_ = Absyn.CREF_FULLYQUALIFIED(Absyn.CREF_IDENT("initial", _)))) then true;
     else false;
   end match;
@@ -4687 +4687 @@
 public function importPath
   "Return the path of the given import."
-  input Import inImport;
-  output Path outPath;
+  input Absyn.Import inImport;
+  output Absyn.Path outPath;
 algorithm
   outPath := match(inImport)
     local
-      Path path;
-
-    case NAMED_IMPORT(path = path) then path;
-    case QUAL_IMPORT(path = path) then path;
-    case UNQUAL_IMPORT(path = path) then path;
-    case GROUP_IMPORT(prefix = path) then path;
+      Absyn.Path path;
+
+    case Absyn.NAMED_IMPORT(path = path) then path;
+    case Absyn.QUAL_IMPORT(path = path) then path;
+    case Absyn.UNQUAL_IMPORT(path = path) then path;
+    case Absyn.GROUP_IMPORT(prefix = path) then path;
 
   end match;
@@ -4704 +4704 @@
 public function importName
   "Returns the import name of a named or qualified import."
-  input Import inImport;
-  output Ident outName;
+  input Absyn.Import inImport;
+  output Absyn.Ident outName;
 algorithm
   outName := match(inImport)
     local
-      Ident name;
-      Path path;
+      Absyn.Ident name;
+      Absyn.Path path;
 
     // Named import has a given name, 'import D = A.B.C' => D.
-    case NAMED_IMPORT(name = name) then name;
+    case Absyn.NAMED_IMPORT(name = name) then name;
     // Qualified import uses the last identifier, 'import A.B.C' => C.
-    case QUAL_IMPORT(path = path) then pathLastIdent(path);
+    case Absyn.QUAL_IMPORT(path = path) then pathLastIdent(path);
 
   end match;
@@ -4723 +4723 @@
 " This function takes an old annotation as first argument and a new
    annotation as  second argument and merges the two.
-   Annotation \"parts\" that exist in both the old and the new annotation
+   Absyn.Annotation \"parts\" that exist in both the old and the new annotation
    will be changed according to the new definition. For instance,
    merge_annotations(annotation(x=1,y=2),annotation(x=3))
    => annotation(x=3,y=2)"
-  input Annotation inAnnotation1;
-  input Annotation inAnnotation2;
-  output Annotation outAnnotation;
+  input Absyn.Annotation inAnnotation1;
+  input Absyn.Annotation inAnnotation2;
+  output Absyn.Annotation outAnnotation;
 algorithm
   outAnnotation:=
   match (inAnnotation1,inAnnotation2)
     local
-      list<ElementArg> oldmods,newmods;
-      Annotation a;
-    case (ANNOTATION(elementArgs = {}),a) then a;
-
-    case (ANNOTATION(elementArgs = oldmods),ANNOTATION(elementArgs = newmods))
-      then ANNOTATION(mergeAnnotations2(oldmods, newmods));
+      list<Absyn.ElementArg> oldmods,newmods;
+      Absyn.Annotation a;
+    case (Absyn.ANNOTATION(elementArgs = {}),a) then a;
+
+    case (Absyn.ANNOTATION(elementArgs = oldmods),Absyn.ANNOTATION(elementArgs = newmods))
+      then Absyn.ANNOTATION(mergeAnnotations2(oldmods, newmods));
   end match;
 end mergeAnnotations;
@@ -4746 +4746 @@
 
 function mergeAnnotations2
-  input list<ElementArg> oldmods;
-  input list<ElementArg> newmods;
-  output list<ElementArg> res = listReverse(oldmods);
+  input list<Absyn.ElementArg> oldmods;
+  input list<Absyn.ElementArg> newmods;
+  output list<Absyn.ElementArg> res = listReverse(oldmods);
 protected
-  list<ElementArg> mods;
+  list<Absyn.ElementArg> mods;
   Boolean b;
-  Path p;
-  ElementArg mod1,mod2;
+  Absyn.Path p;
+  Absyn.ElementArg mod1,mod2;
 algorithm
   for mod in newmods loop
-    MODIFICATION(path=p) := mod;
+    Absyn.MODIFICATION(path=p) := mod;
     try
       mod2 := List.find(res, function isModificationOfPath(path=p));
@@ -4769 +4769 @@
 
 public function mergeCommentAnnotation
-  "Merges an annotation into a Comment option."
-  input Annotation inAnnotation;
-  input Option<Comment> inComment;
-  output Option<Comment> outComment;
+  "Merges an annotation into a Absyn.Comment option."
+  input Absyn.Annotation inAnnotation;
+  input Option<Absyn.Comment> inComment;
+  output Option<Absyn.Comment> outComment;
 algorithm
   outComment := match inComment
     local
-      Annotation ann;
+      Absyn.Annotation ann;
       Option<String> cmt;
 
     // No comment, create a new one.
     case NONE()
-      then SOME(COMMENT(SOME(inAnnotation), NONE()));
+      then SOME(Absyn.COMMENT(SOME(inAnnotation), NONE()));
 
     // A comment without annotation, insert the annotation.
-    case SOME(COMMENT(annotation_ = NONE(), comment = cmt))
-      then SOME(COMMENT(SOME(inAnnotation), cmt));
+    case SOME(Absyn.COMMENT(annotation_ = NONE(), comment = cmt))
+      then SOME(Absyn.COMMENT(SOME(inAnnotation), cmt));
 
     // A comment with annotation, merge the annotations.
-    case SOME(COMMENT(annotation_ = SOME(ann), comment = cmt))
-      then SOME(COMMENT(SOME(mergeAnnotations(ann, inAnnotation)), cmt));
+    case SOME(Absyn.COMMENT(annotation_ = SOME(ann), comment = cmt))
+      then SOME(Absyn.COMMENT(SOME(mergeAnnotations(ann, inAnnotation)), cmt));
 
   end match;
@@ -4796 +4796 @@
 function isModificationOfPath
 "returns true or false if the given path is in the list of modifications"
-  input ElementArg mod;
-  input Path path;
+  input Absyn.ElementArg mod;
+  input Absyn.Path path;
   output Boolean yes;
 algorithm
@@ -4803 +4803 @@
     local
       String id1,id2;
-    case (MODIFICATION(path = IDENT(name = id1)),IDENT(name = id2)) then id1==id2;
+    case (Absyn.MODIFICATION(path = Absyn.IDENT(name = id1)),Absyn.IDENT(name = id2)) then id1==id2;
     else false;
   end match;
@@ -4809 +4809 @@
 
 function subModsInSameOrder
-  input ElementArg oldmod;
-  input ElementArg newmod;
-  output ElementArg mod;
+  input Absyn.ElementArg oldmod;
+  input Absyn.ElementArg newmod;
+  output Absyn.ElementArg mod;
 algorithm
   mod := match (oldmod,newmod)
     local
-      list<ElementArg> args1,args2,res;
-      ElementArg arg2;
-      EqMod eq1,eq2;
-      Path p;
+      list<Absyn.ElementArg> args1,args2,res;
+      Absyn.ElementArg arg2;
+      Absyn.EqMod eq1,eq2;
+      Absyn.Path p;
 
     // mod1 or mod2 has no submods
-    case (_, MODIFICATION(modification=NONE())) then newmod;
-    case (MODIFICATION(modification=NONE()), _) then newmod;
+    case (_, Absyn.MODIFICATION(modification=NONE())) then newmod;
+    case (Absyn.MODIFICATION(modification=NONE()), _) then newmod;
     // mod1
-    case (MODIFICATION(modification=SOME(CLASSMOD(args1,_))), arg2 as MODIFICATION(modification=SOME(CLASSMOD(args2,eq2))))
+    case (Absyn.MODIFICATION(modification=SOME(Absyn.CLASSMOD(args1,_))), arg2 as Absyn.MODIFICATION(modification=SOME(Absyn.CLASSMOD(args2,eq2))))
       algorithm
         // Delete all items from args2 that are not in args1
         res := {};
         for arg1 in args1 loop
-          MODIFICATION(path=p) := arg1;
+          Absyn.MODIFICATION(path=p) := arg1;
           if List.exist(args2, function isModificationOfPath(path=p)) then
             res := arg1::res;
@@ -4837 +4837 @@
         // Merge the annotations
         res := mergeAnnotations2(res, args2);
-        arg2.modification := SOME(CLASSMOD(res,eq2));
+        arg2.modification := SOME(Absyn.CLASSMOD(res,eq2));
       then arg2;
   end match;
@@ -4843 +4843 @@
 
 public function annotationToElementArgs
-  input Annotation ann;
-  output list<ElementArg> args;
-algorithm
-  ANNOTATION(args) := ann;
+  input Absyn.Annotation ann;
+  output list<Absyn.ElementArg> args;
+algorithm
+  Absyn.ANNOTATION(args) := ann;
 end annotationToElementArgs;
 
 public function pathToTypeSpec
-  input Path inPath;
-  output TypeSpec outTypeSpec;
-algorithm
-  outTypeSpec := TPATH(inPath, NONE());
+  input Absyn.Path inPath;
+  output Absyn.TypeSpec outTypeSpec;
+algorithm
+  outTypeSpec := Absyn.TPATH(inPath, NONE());
 end pathToTypeSpec;
 
 public function typeSpecString
-  input TypeSpec inTs;
+  input Absyn.TypeSpec inTs;
   output String outStr;
 algorithm
@@ -4864 +4864 @@
 
 public function crefString
-  input ComponentRef inCr;
+  input Absyn.ComponentRef inCr;
   output String outStr;
 algorithm
@@ -4871 +4871 @@
 
 public function typeSpecStringNoQualNoDims
-  input TypeSpec inTs;
+  input Absyn.TypeSpec inTs;
   output String outStr;
 algorithm
   outStr := match (inTs)
     local
-      Ident str,s,str1,str2,str3;
-      Path path;
-      Option<list<Subscript>> adim;
-      list<TypeSpec> typeSpecLst;
-
-    case (TPATH(path = path))
+      Absyn.Ident str,s,str1,str2,str3;
+      Absyn.Path path;
+      Option<list<Absyn.Subscript>> adim;
+      list<Absyn.TypeSpec> typeSpecLst;
+
+    case (Absyn.TPATH(path = path))
       equation
         str = pathString(makeNotFullyQualified(path));
@@ -4887 +4887 @@
         str;
 
-    case (TCOMPLEX(path = path,typeSpecs = typeSpecLst))
+    case (Absyn.TCOMPLEX(path = path,typeSpecs = typeSpecLst))
       equation
         str1 = pathString(makeNotFullyQualified(path));
@@ -4899 +4899 @@
 
 public function typeSpecStringNoQualNoDimsLst
-  input list<TypeSpec> inTypeSpecLst;
+  input list<Absyn.TypeSpec> inTypeSpecLst;
   output String outString;
 algorithm
@@ -4907 +4907 @@
 
 public function crefStringIgnoreSubs
-  input ComponentRef inCr;
+  input Absyn.ComponentRef inCr;
   output String outStr;
 protected
-  Path p;
+  Absyn.Path p;
 algorithm
   p := crefToPathIgnoreSubs(inCr);
@@ -4917 +4917 @@
 
 public function importString
-  input Import inImp;
+  input Absyn.Import inImp;
   output String outStr;
 algorithm
@@ -4925 +4925 @@
 public function refString
 "@author: adrpo
- full Ref -> string
+ full Absyn.Ref -> string
  cref/path full qualified, type dims, subscripts in crefs"
-  input Ref inRef;
+  input Absyn.Ref inRef;
   output String outStr;
 algorithm
   outStr := match(inRef)
-    local ComponentRef cr; TypeSpec ts; Import im;
-    case (RCR(cr)) then crefString(cr);
-    case (RTS(ts)) then typeSpecString(ts);
-    case (RIM(im)) then importString(im);
+    local Absyn.ComponentRef cr; Absyn.TypeSpec ts; Absyn.Import im;
+    case (Absyn.RCR(cr)) then crefString(cr);
+    case (Absyn.RTS(ts)) then typeSpecString(ts);
+    case (Absyn.RIM(im)) then importString(im);
   end match;
 end refString;
@@ -4940 +4940 @@
 public function refStringBrief
 "@author: adrpo
- brief Ref -> string
+ brief Absyn.Ref -> string
  no cref/path full qualified, no type dims, no subscripts in crefs"
-  input Ref inRef;
+  input Absyn.Ref inRef;
   output String outStr;
 algorithm
   outStr := match(inRef)
-    local ComponentRef cr; TypeSpec ts; Import im;
-    case (RCR(cr)) then crefStringIgnoreSubs(cr);
-    case (RTS(ts)) then typeSpecStringNoQualNoDims(ts);
-    case (RIM(im)) then importString(im);
+    local Absyn.ComponentRef cr; Absyn.TypeSpec ts; Absyn.Import im;
+    case (Absyn.RCR(cr)) then crefStringIgnoreSubs(cr);
+    case (Absyn.RTS(ts)) then typeSpecStringNoQualNoDims(ts);
+    case (Absyn.RIM(im)) then importString(im);
   end match;
 end refStringBrief;
 
 public function getArrayDimOptAsList
-  input Option<ArrayDim> inArrayDim;
-  output ArrayDim outArrayDim;
+  input Option<Absyn.ArrayDim> inArrayDim;
+  output Absyn.ArrayDim outArrayDim;
 algorithm
   outArrayDim := match(inArrayDim)
-    local ArrayDim ad;
+    local Absyn.ArrayDim ad;
     case (SOME(ad)) then ad;
     else {};
@@ -4966 +4966 @@
 public function removeCrefFromCrefs
 "Removes a variable from a variable list"
-  input list<ComponentRef> inAbsynComponentRefLst;
-  input ComponentRef inComponentRef;
-  output list<ComponentRef> outAbsynComponentRefLst;
+  input list<Absyn.ComponentRef> inAbsynComponentRefLst;
+  input Absyn.ComponentRef inComponentRef;
+  output list<Absyn.ComponentRef> outAbsynComponentRefLst;
 algorithm
   outAbsynComponentRefLst := matchcontinue (inAbsynComponentRefLst,inComponentRef)
     local
       String n1,n2;
-      list<ComponentRef> rest_1,rest;
-      ComponentRef cr1,cr2;
+      list<Absyn.ComponentRef> rest_1,rest;
+      Absyn.ComponentRef cr1,cr2;
     case ({},_) then {};
     case ((cr1 :: rest),cr2)
       equation
-        CREF_IDENT(name = n1,subscripts = {}) = cr1;
-        CREF_IDENT(name = n2,subscripts = {}) = cr2;
+        Absyn.CREF_IDENT(name = n1,subscripts = {}) = cr1;
+        Absyn.CREF_IDENT(name = n2,subscripts = {}) = cr2;
         true = stringEq(n1, n2);
         rest_1 = removeCrefFromCrefs(rest, cr2);
@@ -4986 +4986 @@
     case ((cr1 :: rest),cr2) // If modifier like on comp like: T t(x=t.y) => t.y must be removed
       equation
-        CREF_QUAL(name = n1) = cr1;
-        CREF_IDENT(name = n2) = cr2;
+        Absyn.CREF_QUAL(name = n1) = cr1;
+        Absyn.CREF_IDENT(name = n2) = cr2;
         true = stringEq(n1, n2);
         rest_1 = removeCrefFromCrefs(rest, cr2);
@@ -5002 +5002 @@
 public function getNamedAnnotationInClass
   "Retrieve e.g. the documentation annotation as a string from the class passed as argument."
-  input Class inClass;
-  input Path id;
+  input Absyn.Class inClass;
+  input Absyn.Path id;
   input ModFunc f;
   output Option<TypeA> outString;
   partial function ModFunc
-    input Option<Modification> mod;
+    input Option<Absyn.Modification> mod;
     output TypeA docStr;
   end ModFunc;
@@ -5014 +5014 @@
     local
       TypeA str,res;
-      list<ClassPart> parts;
-      list<ElementArg> annlst;
-      list<Annotation> ann;
-
-    case (CLASS(body = PARTS(ann = ann)),_,_)
+      list<Absyn.ClassPart> parts;
+      list<Absyn.ElementArg> annlst;
+      list<Absyn.Annotation> ann;
+
+    case (Absyn.CLASS(body = Absyn.PARTS(ann = ann)),_,_)
       equation
         annlst = List.flatten(List.map(ann,annotationToElementArgs));
@@ -5025 +5025 @@
         SOME(str);
 
-    case (CLASS(body = CLASS_EXTENDS(ann = ann)),_,_)
+    case (Absyn.CLASS(body = Absyn.CLASS_EXTENDS(ann = ann)),_,_)
       equation
         annlst = List.flatten(List.map(ann,annotationToElementArgs));
@@ -5032 +5032 @@
         SOME(str);
 
-    case (CLASS(body = DERIVED(comment = SOME(COMMENT(SOME(ANNOTATION(annlst)),_)))),_,_)
+    case (Absyn.CLASS(body = Absyn.DERIVED(comment = SOME(Absyn.COMMENT(SOME(Absyn.ANNOTATION(annlst)),_)))),_,_)
       equation
         SOME(res) = getNamedAnnotationStr(annlst,id,f);
@@ -5038 +5038 @@
         SOME(res);
 
-    case (CLASS(body = ENUMERATION(comment = SOME(COMMENT(SOME(ANNOTATION(annlst)),_)))),_,_)
+    case (Absyn.CLASS(body = Absyn.ENUMERATION(comment = SOME(Absyn.COMMENT(SOME(Absyn.ANNOTATION(annlst)),_)))),_,_)
       equation
         SOME(res) = getNamedAnnotationStr(annlst,id,f);
@@ -5044 +5044 @@
         SOME(res);
 
-    case (CLASS(body = OVERLOAD(comment = SOME(COMMENT(SOME(ANNOTATION(annlst)),_)))),_,_)
+    case (Absyn.CLASS(body = Absyn.OVERLOAD(comment = SOME(Absyn.COMMENT(SOME(Absyn.ANNOTATION(annlst)),_)))),_,_)
       equation
         SOME(res) = getNamedAnnotationStr(annlst,id,f);
@@ -5057 +5057 @@
 protected function getNamedAnnotationStr
 "Helper function to getNamedAnnotationInElementitemlist."
-  input list<ElementArg> inAbsynElementArgLst;
-  input Path id;
+  input list<Absyn.ElementArg> inAbsynElementArgLst;
+  input Absyn.Path id;
   input ModFunc f;
   output Option<TypeA> outString;
   partial function ModFunc
-    input Option<Modification> mod;
+    input Option<Absyn.Modification> mod;
     output TypeA docStr;
   end ModFunc;
@@ -5069 +5069 @@
     local
       TypeA str;
-      ElementArg ann;
-      Option<Modification> mod;
-      list<ElementArg> xs;
-      Ident id1,id2;
-      Path rest;
-
-    case (((MODIFICATION(path = IDENT(name = id1),modification = mod)) :: _),IDENT(id2),_)
+      Absyn.ElementArg ann;
+      Option<Absyn.Modification> mod;
+      list<Absyn.ElementArg> xs;
+      Absyn.Ident id1,id2;
+      Absyn.Path rest;
+
+    case (((Absyn.MODIFICATION(path = Absyn.IDENT(name = id1),modification = mod)) :: _),Absyn.IDENT(id2),_)
       equation
         true = stringEq(id1, id2);
@@ -5082 +5082 @@
         SOME(str);
 
-    case (((MODIFICATION(path = IDENT(name = id1),modification = SOME(CLASSMOD(elementArgLst=xs)))) :: _),QUALIFIED(name=id2,path=rest),_)
+    case (((Absyn.MODIFICATION(path = Absyn.IDENT(name = id1),modification = SOME(Absyn.CLASSMOD(elementArgLst=xs)))) :: _),Absyn.QUALIFIED(name=id2,path=rest),_)
       equation
         true = stringEq(id1, id2);
@@ -5094 +5094 @@
   "This function splits each part of a cref into CREF_IDENTs and applies the
    given function to each part. If the given cref is a qualified cref then the
-   map function is expected to also return CREF_IDENT, so that the split cref
+   map function is expected to also return Absyn.CREF_IDENT, so that the split cref
    can be reconstructed. Otherwise the map function is free to return whatever
    it wants."
-  input ComponentRef inCref;
+  input Absyn.ComponentRef inCref;
   input MapFunc inMapFunc;
-  output ComponentRef outCref;
+  output Absyn.ComponentRef outCref;
 
   partial function MapFunc
-    input ComponentRef inCref;
-    output ComponentRef outCref;
+    input Absyn.ComponentRef inCref;
+    output Absyn.ComponentRef outCref;
   end MapFunc;
 algorithm
   outCref := match(inCref, inMapFunc)
     local
-      Ident name;
-      list<Subscript> subs;
-      ComponentRef rest_cref;
-      ComponentRef cref;
-
-    case (CREF_QUAL(name, subs, rest_cref), _)
-      equation
-        cref = CREF_IDENT(name, subs);
-        CREF_IDENT(name, subs) = inMapFunc(cref);
+      Absyn.Ident name;
+      list<Absyn.Subscript> subs;
+      Absyn.ComponentRef rest_cref;
+      Absyn.ComponentRef cref;
+
+    case (Absyn.CREF_QUAL(name, subs, rest_cref), _)
+      equation
+        cref = Absyn.CREF_IDENT(name, subs);
+        Absyn.CREF_IDENT(name, subs) = inMapFunc(cref);
         rest_cref = mapCrefParts(rest_cref, inMapFunc);
       then
-        CREF_QUAL(name, subs, rest_cref);
-
-    case (CREF_FULLYQUALIFIED(cref), _)
+        Absyn.CREF_QUAL(name, subs, rest_cref);
+
+    case (Absyn.CREF_FULLYQUALIFIED(cref), _)
       equation
         cref = mapCrefParts(cref, inMapFunc);
       then
-        CREF_FULLYQUALIFIED(cref);
+        Absyn.CREF_FULLYQUALIFIED(cref);
 
     else
@@ -5137 +5137 @@
 
 public function opEqual
- input Operator op1;
- input Operator op2;
+ input Absyn.Operator op1;
+ input Absyn.Operator op2;
  output Boolean isEqual;
 algorithm
@@ -5145 +5145 @@
 
 public function opIsElementWise
- input Operator op;
+ input Absyn.Operator op;
  output Boolean isElementWise;
 algorithm
   isElementWise := match op
-    case ADD_EW() then true;
-    case SUB_EW() then true;
-    case MUL_EW() then true;
-    case DIV_EW() then true;
-    case POW_EW() then true;
-    case UPLUS_EW() then true;
-    case UMINUS_EW() then true;
+    case Absyn.ADD_EW() then true;
+    case Absyn.SUB_EW() then true;
+    case Absyn.MUL_EW() then true;
+    case Absyn.DIV_EW() then true;
+    case Absyn.POW_EW() then true;
+    case Absyn.UPLUS_EW() then true;
+    case Absyn.UMINUS_EW() then true;
     else false;
   end match;
@@ -5161 +5161 @@
 
 protected function dummyTraverseExp
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input Arg inArg;
-  output Exp outExp;
+  output Absyn.Exp outExp;
   output Arg outArg;
 algorithm
@@ -5171 +5171 @@
 
 public function getDefineUnitsInElements "retrives defineunit definitions in elements"
-  input list<ElementItem> elts;
-  output list<Element> outElts;
+  input list<Absyn.ElementItem> elts;
+  output list<Absyn.Element> outElts;
 algorithm
   outElts := matchcontinue(elts)
     local
-      Element e;
-      list<ElementItem> rest;
+      Absyn.Element e;
+      list<Absyn.ElementItem> rest;
     case {} then {};
-    case (ELEMENTITEM(e as DEFINEUNIT())::rest)
+    case (Absyn.ELEMENTITEM(e as Absyn.DEFINEUNIT())::rest)
       equation
         outElts = getDefineUnitsInElements(rest);
@@ -5190 +5190 @@
 public function getElementItemsInClass
   "Returns the public and protected elements in a class."
-  input Class inClass;
-  output list<ElementItem> outElements;
+  input Absyn.Class inClass;
+  output list<Absyn.ElementItem> outElements;
 algorithm
   outElements := match(inClass)
     local
-      list<ClassPart> parts;
-
-    case CLASS(body = PARTS(classParts = parts))
+      list<Absyn.ClassPart> parts;
+
+    case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
       then List.mapFlat(parts, getElementItemsInClassPart);
 
-    case CLASS(body = CLASS_EXTENDS(parts = parts))
+    case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
       then List.mapFlat(parts, getElementItemsInClassPart);
 
@@ -5210 +5210 @@
 public function getElementItemsInClassPart
   "Returns the public and protected elements in a class part."
-  input ClassPart inClassPart;
-  output list<ElementItem> outElements;
+  input Absyn.ClassPart inClassPart;
+  output list<Absyn.ElementItem> outElements;
 algorithm
   outElements := match(inClassPart)
     local
-      list<ElementItem> elts;
-
-    case PUBLIC(contents = elts) then elts;
-    case PROTECTED(contents = elts) then elts;
+      list<Absyn.ElementItem> elts;
+
+    case Absyn.PUBLIC(contents = elts) then elts;
+    case Absyn.PROTECTED(contents = elts) then elts;
     else {};
   end match;
@@ -5224 +5224 @@
 
 public function traverseClassComponents<ArgT>
-  input Class inClass;
+  input Absyn.Class inClass;
   input FuncType inFunc;
   input ArgT inArg;
-  output Class outClass = inClass;
+  output Absyn.Class outClass = inClass;
   output ArgT outArg;
 
   partial function FuncType
-    input list<ComponentItem> inComponents;
+    input list<Absyn.ComponentItem> inComponents;
     input ArgT inArg;
-    output list<ComponentItem> outComponents;
+    output list<Absyn.ComponentItem> outComponents;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5240 +5240 @@
   outClass := match(outClass)
     local
-      ClassDef body;
-
-    case CLASS()
+      Absyn.ClassDef body;
+
+    case Absyn.CLASS()
       algorithm
         (body, outArg) := traverseClassDef(outClass.body,
@@ -5290 +5290 @@
 
 protected function traverseClassPartComponents<ArgT>
-  input ClassPart inClassPart;
+  input Absyn.ClassPart inClassPart;
   input FuncType inFunc;
   input ArgT inArg;
-  output ClassPart outClassPart = inClassPart;
+  output Absyn.ClassPart outClassPart = inClassPart;
   output ArgT outArg = inArg;
   output Boolean outContinue = true;
 
   partial function FuncType
-    input list<ComponentItem> inComponents;
+    input list<Absyn.ComponentItem> inComponents;
     input ArgT inArg;
-    output list<ComponentItem> outComponents;
+    output list<Absyn.ComponentItem> outComponents;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5307 +5307 @@
   _ := match(outClassPart)
     local
-      list<ElementItem> items;
-
-    case PUBLIC()
+      list<Absyn.ElementItem> items;
+
+    case Absyn.PUBLIC()
       algorithm
         (items, outArg, outContinue) :=
@@ -5318 +5318 @@
         ();
 
-    case PROTECTED()
+    case Absyn.PROTECTED()
       algorithm
         (items, outArg, outContinue) :=
@@ -5332 +5332 @@
 
 protected function traverseElementItemComponents<ArgT>
-  input ElementItem inItem;
+  input Absyn.ElementItem inItem;
   input FuncType inFunc;
   input ArgT inArg;
-  output ElementItem outItem;
+  output Absyn.ElementItem outItem;
   output ArgT outArg;
   output Boolean outContinue;
 
   partial function FuncType
-    input list<ComponentItem> inComponents;
+    input list<Absyn.ComponentItem> inComponents;
     input ArgT inArg;
-    output list<ComponentItem> outComponents;
+    output list<Absyn.ComponentItem> outComponents;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5349 +5349 @@
   (outItem, outArg, outContinue) := match(inItem)
     local
-      Element elem;
-
-    case ELEMENTITEM()
+      Absyn.Element elem;
+
+    case Absyn.ELEMENTITEM()
       algorithm
         (elem, outArg, outContinue) := traverseElementComponents(inItem.element,
           inFunc, inArg);
-        outItem := if referenceEq(elem, inItem.element) then inItem else ELEMENTITEM(elem);
+        outItem := if referenceEq(elem, inItem.element) then inItem else Absyn.ELEMENTITEM(elem);
       then
         (outItem, outArg, outContinue);
@@ -5364 +5364 @@
 
 protected function traverseElementComponents<ArgT>
-  input Element inElement;
+  input Absyn.Element inElement;
   input FuncType inFunc;
   input ArgT inArg;
-  output Element outElement = inElement;
+  output Absyn.Element outElement = inElement;
   output ArgT outArg;
   output Boolean outContinue;
 
   partial function FuncType
-    input list<ComponentItem> inComponents;
+    input list<Absyn.ComponentItem> inComponents;
     input ArgT inArg;
-    output list<ComponentItem> outComponents;
+    output list<Absyn.ComponentItem> outComponents;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5381 +5381 @@
   (outElement, outArg, outContinue) := match(outElement)
     local
-      ElementSpec spec;
-
-    case ELEMENT()
+      Absyn.ElementSpec spec;
+
+    case Absyn.ELEMENT()
       algorithm
         (spec, outArg, outContinue) := traverseElementSpecComponents(
@@ -5399 +5399 @@
 
 protected function traverseElementSpecComponents<ArgT>
-  input ElementSpec inSpec;
+  input Absyn.ElementSpec inSpec;
   input FuncType inFunc;
   input ArgT inArg;
-  output ElementSpec outSpec = inSpec;
+  output Absyn.ElementSpec outSpec = inSpec;
   output ArgT outArg;
   output Boolean outContinue;
 
   partial function FuncType
-    input list<ComponentItem> inComponents;
+    input list<Absyn.ComponentItem> inComponents;
     input ArgT inArg;
-    output list<ComponentItem> outComponents;
+    output list<Absyn.ComponentItem> outComponents;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5416 +5416 @@
   (outSpec, outArg, outContinue) := match(outSpec)
     local
-      Class cls;
-      list<ComponentItem> comps;
-
-    case COMPONENTS()
+      Absyn.Class cls;
+      list<Absyn.ComponentItem> comps;
+
+    case Absyn.COMPONENTS()
       algorithm
         (comps, outArg, outContinue) := inFunc(outSpec.components, inArg);
@@ -5433 +5433 @@
 
 protected function traverseClassDef<ArgT>
-  input ClassDef inClassDef;
+  input Absyn.ClassDef inClassDef;
   input FuncType inFunc;
   input ArgT inArg;
-  output ClassDef outClassDef = inClassDef;
+  output Absyn.ClassDef outClassDef = inClassDef;
   output ArgT outArg = inArg;
   output Boolean outContinue = true;
 
   partial function FuncType
-    input ClassPart inPart;
+    input Absyn.ClassPart inPart;
     input ArgT inArg;
-    output ClassPart outPart;
+    output Absyn.ClassPart outPart;
     output ArgT outArg;
     output Boolean outContinue;
@@ -5450 +5450 @@
   _ := match(outClassDef)
     local
-      list<ClassPart> parts;
-
-    case PARTS()
+      list<Absyn.ClassPart> parts;
+
+    case Absyn.PARTS()
       algorithm
         (parts, outArg, outContinue) :=
@@ -5460 +5460 @@
         ();
 
-    case CLASS_EXTENDS()
+    case Absyn.CLASS_EXTENDS()
       algorithm
         (parts, outArg, outContinue) :=
@@ -5473 +5473 @@
 
 public function isEmptyMod
-  input Modification inMod;
+  input Absyn.Modification inMod;
   output Boolean outIsEmpty;
 algorithm
   outIsEmpty := match inMod
-    case CLASSMOD({}, NOMOD()) then true;
-    case CLASSMOD({}, EQMOD(exp = TUPLE(expressions = {}))) then true;
+    case Absyn.CLASSMOD({}, Absyn.NOMOD()) then true;
+    case Absyn.CLASSMOD({}, Absyn.EQMOD(exp = Absyn.TUPLE(expressions = {}))) then true;
     else false;
   end match;
@@ -5484 +5484 @@
 
 public function isEmptySubMod
-  input ElementArg inSubMod;
+  input Absyn.ElementArg inSubMod;
   output Boolean outIsEmpty;
 algorithm
   outIsEmpty := match inSubMod
     local
-      Modification mod;
-
-    case MODIFICATION(modification = NONE()) then true;
-    case MODIFICATION(modification = SOME(mod)) then isEmptyMod(mod);
+      Absyn.Modification mod;
+
+    case Absyn.MODIFICATION(modification = NONE()) then true;
+    case Absyn.MODIFICATION(modification = SOME(mod)) then isEmptyMod(mod);
   end match;
 end isEmptySubMod;
 
 public function elementArgName
-  input ElementArg inArg;
-  output Path outName;
+  input Absyn.ElementArg inArg;
+  output Absyn.Path outName;
 algorithm
   outName := match(inArg)
     local
-      ElementSpec e;
-    case MODIFICATION(path = outName) then outName;
-    case REDECLARATION(elementSpec = e) then makeIdentPathFromString(elementSpecName(e));
+      Absyn.ElementSpec e;
+    case Absyn.MODIFICATION(path = outName) then outName;
+    case Absyn.REDECLARATION(elementSpec = e) then makeIdentPathFromString(elementSpecName(e));
   end match;
 end elementArgName;
 
 public function elementArgEqualName
-  input ElementArg inArg1;
-  input ElementArg inArg2;
+  input Absyn.ElementArg inArg1;
+  input Absyn.ElementArg inArg2;
   output Boolean outEqual;
 protected
-  Path name1, name2;
+  Absyn.Path name1, name2;
 algorithm
   outEqual := match(inArg1, inArg2)
-    case (MODIFICATION(path = name1), MODIFICATION(path = name2))
+    case (Absyn.MODIFICATION(path = name1), Absyn.MODIFICATION(path = name2))
       then pathEqual(name1, name2);
 
@@ -5524 +5524 @@
 
 public function optMsg
-  "Creates a Msg based on a boolean value."
+  "Creates a Absyn.Msg based on a boolean value."
   input Boolean inShowMessage;
   input SourceInfo inInfo;
-  output Msg outMsg;
-algorithm
-  outMsg := if inShowMessage then MSG(inInfo) else NO_MSG();
+  output Absyn.Msg outMsg;
+algorithm
+  outMsg := if inShowMessage then Absyn.MSG(inInfo) else Absyn.NO_MSG();
   annotation(__OpenModelica_EarlyInline = true);
 end optMsg;
 
 public function makeSubscript
-  input Exp inExp;
-  output Subscript outSubscript;
-algorithm
-  outSubscript := SUBSCRIPT(inExp);
+  input Absyn.Exp inExp;
+  output Absyn.Subscript outSubscript;
+algorithm
+  outSubscript := Absyn.SUBSCRIPT(inExp);
 end makeSubscript;
 
 public function crefExplode
   "Splits a cref into parts."
-  input ComponentRef inCref;
-  input list<ComponentRef> inAccum = {};
-  output list<ComponentRef> outCrefParts;
+  input Absyn.ComponentRef inCref;
+  input list<Absyn.ComponentRef> inAccum = {};
+  output list<Absyn.ComponentRef> outCrefParts;
 algorithm
   outCrefParts := match inCref
-    case CREF_QUAL() then crefExplode(inCref.componentRef, crefFirstCref(inCref) :: inAccum);
-    case CREF_FULLYQUALIFIED() then crefExplode(inCref.componentRef, inAccum);
+    case Absyn.CREF_QUAL() then crefExplode(inCref.componentRef, crefFirstCref(inCref) :: inAccum);
+    case Absyn.CREF_FULLYQUALIFIED() then crefExplode(inCref.componentRef, inAccum);
     else listReverse(inCref :: inAccum);
   end match;
@@ -5556 +5556 @@
   "Calls the given function on each subexpression (non-recursively) of the given
    expression, sending in the extra argument to each call."
-  input Exp inExp;
+  input Absyn.Exp inExp;
   input ArgT inArg;
   input FuncT inFunc;
-  output Exp outExp = inExp;
+  output Absyn.Exp outExp = inExp;
 
   partial function FuncT
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input ArgT inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
   end FuncT;
 algorithm
   _ := match outExp
     local
-      Exp e1, e2;
-
-    case BINARY()
+      Absyn.Exp e1, e2;
+
+    case Absyn.BINARY()
       algorithm
         outExp.exp1 := inFunc(outExp.exp1, inArg);
@@ -5578 +5578 @@
         ();
 
-    case UNARY()
+    case Absyn.UNARY()
       algorithm
         outExp.exp := inFunc(outExp.exp, inArg);
@@ -5584 +5584 @@
         ();
 
-    case LBINARY()
+    case Absyn.LBINARY()
       algorithm
         outExp.exp1 := inFunc(outExp.exp1, inArg);
@@ -5591 +5591 @@
         ();
 
-    case LUNARY()
+    case Absyn.LUNARY()
       algorithm
         outExp.exp := inFunc(outExp.exp, inArg);
@@ -5597 +5597 @@
         ();
 
-    case RELATION()
+    case Absyn.RELATION()
       algorithm
         outExp.exp1 := inFunc(outExp.exp1, inArg);
@@ -5604 +5604 @@
         ();
 
-    case IFEXP()
+    case Absyn.IFEXP()
       algorithm
         outExp.ifExp := inFunc(outExp.ifExp, inArg);
@@ -5614 +5614 @@
         ();
 
-    case CALL()
+    case Absyn.CALL()
       algorithm
         outExp.functionArgs := traverseExpShallowFuncArgs(outExp.functionArgs,
@@ -5621 +5621 @@
         ();
 
-    case PARTEVALFUNCTION()
+    case Absyn.PARTEVALFUNCTION()
       algorithm
         outExp.functionArgs := traverseExpShallowFuncArgs(outExp.functionArgs,
@@ -5628 +5628 @@
         ();
 
-    case ARRAY()
+    case Absyn.ARRAY()
       algorithm
         outExp.arrayExp := list(inFunc(e, inArg) for e in outExp.arrayExp);
@@ -5634 +5634 @@
         ();
 
-    case MATRIX()
+    case Absyn.MATRIX()
       algorithm
         outExp.matrix := list(list(inFunc(e, inArg) for e in lst) for lst in
@@ -5641 +5641 @@
         ();
 
-    case RANGE()
+    case Absyn.RANGE()
       algorithm
         outExp.start := inFunc(outExp.start, inArg);
@@ -5649 +5649 @@
         ();
 
-    case TUPLE()
+    case Absyn.TUPLE()
       algorithm
         outExp.expressions := list(inFunc(e, inArg) for e in outExp.expressions);
@@ -5655 +5655 @@
         ();
 
-    case AS()
+    case Absyn.AS()
       algorithm
         outExp.exp := inFunc(outExp.exp, inArg);
@@ -5661 +5661 @@
         ();
 
-    case CONS()
+    case Absyn.CONS()
       algorithm
         outExp.head := inFunc(outExp.head, inArg);
@@ -5668 +5668 @@
         ();
 
-    case LIST()
+    case Absyn.LIST()
       algorithm
         outExp.exps := list(inFunc(e, inArg) for e in outExp.exps);
@@ -5674 +5674 @@
         ();
 
-    case DOT()
+    case Absyn.DOT()
       algorithm
         outExp.exp := inFunc(outExp.exp, inArg);
@@ -5686 +5686 @@
 
 protected function traverseExpShallowFuncArgs<ArgT>
-  input FunctionArgs inArgs;
+  input Absyn.FunctionArgs inArgs;
   input ArgT inArg;
   input FuncT inFunc;
-  output FunctionArgs outArgs = inArgs;
+  output Absyn.FunctionArgs outArgs = inArgs;
 
   partial function FuncT
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input ArgT inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
   end FuncT;
 algorithm
   outArgs := match outArgs
-    case FUNCTIONARGS()
+    case Absyn.FUNCTIONARGS()
       algorithm
         outArgs.args := list(inFunc(arg, inArg) for arg in outArgs.args);
@@ -5704 +5704 @@
         outArgs;
 
-    case FOR_ITER_FARG()
+    case Absyn.FOR_ITER_FARG()
       algorithm
         outArgs.exp := inFunc(outArgs.exp, inArg);
@@ -5716 +5716 @@
 
 protected function traverseExpShallowIterator<ArgT>
-  input ForIterator inIterator;
+  input Absyn.ForIterator inIterator;
   input ArgT inArg;
   input FuncT inFunc;
-  output ForIterator outIterator;
+  output Absyn.ForIterator outIterator;
 
   partial function FuncT
-    input Exp inExp;
+    input Absyn.Exp inExp;
     input ArgT inArg;
-    output Exp outExp;
+    output Absyn.Exp outExp;
   end FuncT;
 protected
   String name;
-  Option<Exp> guard_exp, range_exp;
-algorithm
-  ITERATOR(name, guard_exp, range_exp) := inIterator;
+  Option<Absyn.Exp> guard_exp, range_exp;
+algorithm
+  Absyn.ITERATOR(name, guard_exp, range_exp) := inIterator;
   guard_exp := Util.applyOption1(guard_exp, inFunc, inArg);
   range_exp := Util.applyOption1(range_exp, inFunc, inArg);
-  outIterator := ITERATOR(name, guard_exp, range_exp);
+  outIterator := Absyn.ITERATOR(name, guard_exp, range_exp);
 end traverseExpShallowIterator;
 
 public function isElementItemClass
-  input ElementItem inElement;
+  input Absyn.ElementItem inElement;
   output Boolean outIsClass;
 algorithm
   outIsClass := match inElement
-    case ELEMENTITEM(element = ELEMENT(specification = CLASSDEF())) then true;
+    case Absyn.ELEMENTITEM(element = Absyn.ELEMENT(specification = Absyn.CLASSDEF())) then true;
     else false;
   end match;
@@ -5747 +5747 @@
 
 public function isElementItem
-  input ElementItem inElement;
+  input Absyn.ElementItem inElement;
   output Boolean outIsClass;
 algorithm
   outIsClass := match inElement
-    case ELEMENTITEM() then true;
+    case Absyn.ELEMENTITEM() then true;
     else false;
   end match;
@@ -5757 +5757 @@
 
 public function isAlgorithmItem
-  input AlgorithmItem inAlg;
+  input Absyn.AlgorithmItem inAlg;
   output Boolean outIsClass;
 algorithm
   outIsClass := match inAlg
-    case ALGORITHMITEM() then true;
+    case Absyn.ALGORITHMITEM() then true;
     else false;
   end match;
@@ -5768 +5768 @@
 public function isElementItemClassNamed
   input String inName;
-  input ElementItem inElement;
+  input Absyn.ElementItem inElement;
   output Boolean outIsNamed;
 algorithm
@@ -5775 +5775 @@
       String name;
 
-    case ELEMENTITEM(element = ELEMENT(specification = CLASSDEF(
-      class_ = CLASS(name = name)))) then name == inName;
+    case Absyn.ELEMENTITEM(element = Absyn.ELEMENT(specification = Absyn.CLASSDEF(
+      class_ = Absyn.CLASS(name = name)))) then name == inName;
     else false;
   end match;
@@ -5782 +5782 @@
 
 public function isEmptyClassPart
-  input ClassPart inClassPart;
+  input Absyn.ClassPart inClassPart;
   output Boolean outIsEmpty;
 algorithm
   outIsEmpty := match inClassPart
-    case PUBLIC(contents = {}) then true;
-    case PROTECTED(contents = {}) then true;
-    case CONSTRAINTS(contents = {}) then true;
-    case EQUATIONS(contents = {}) then true;
-    case INITIALEQUATIONS(contents = {}) then true;
-    case ALGORITHMS(contents = {}) then true;
-    case INITIALALGORITHMS(contents = {}) then true;
+    case Absyn.PUBLIC(contents = {}) then true;
+    case Absyn.PROTECTED(contents = {}) then true;
+    case Absyn.CONSTRAINTS(contents = {}) then true;
+    case Absyn.EQUATIONS(contents = {}) then true;
+    case Absyn.INITIALEQUATIONS(contents = {}) then true;
+    case Absyn.ALGORITHMS(contents = {}) then true;
+    case Absyn.INITIALALGORITHMS(contents = {}) then true;
     else false;
   end match;
@@ -5805 +5805 @@
   end if;
   b := match e
-    case INTEGER() then true;
-    case REAL() then true;
-    case STRING() then true;
-    case BOOL() then true;
-    case BINARY() then true;
-    case UNARY() then true;
-    case LBINARY() then true;
-    case LUNARY() then true;
-    case RELATION() then true;
-    case IFEXP() then true;
-    // case CREF(CREF_FULLYQUALIFIED()) then true;
-    case CALL(function_=CREF_FULLYQUALIFIED()) then true;
-    case PARTEVALFUNCTION(function_=CREF_FULLYQUALIFIED()) then true;
-    case ARRAY() then true;
-    case MATRIX() then true;
-    case RANGE() then true;
-    case CONS() then true;
-    case LIST() then true;
+    case Absyn.INTEGER() then true;
+    case Absyn.REAL() then true;
+    case Absyn.STRING() then true;
+    case Absyn.BOOL() then true;
+    case Absyn.BINARY() then true;
+    case Absyn.UNARY() then true;
+    case Absyn.LBINARY() then true;
+    case Absyn.LUNARY() then true;
+    case Absyn.RELATION() then true;
+    case Absyn.IFEXP() then true;
+    // case Absyn.CREF(Absyn.CREF_FULLYQUALIFIED()) then true;
+    case Absyn.CALL(function_=Absyn.CREF_FULLYQUALIFIED()) then true;
+    case Absyn.PARTEVALFUNCTION(function_=Absyn.CREF_FULLYQUALIFIED()) then true;
+    case Absyn.ARRAY() then true;
+    case Absyn.MATRIX() then true;
+    case Absyn.RANGE() then true;
+    case Absyn.CONS() then true;
+    case Absyn.LIST() then true;
     else false;
   end match;
@@ -5829 +5829 @@
 function pathPartCount
   "Returns the number of parts a path consists of, e.g. A.B.C gives 3."
-  input Path path;
+  input Absyn.Path path;
   input Integer partsAccum = 0;
   output Integer parts;
 algorithm
   parts := match path
-    case Path.IDENT() then partsAccum + 1;
-    case Path.QUALIFIED() then pathPartCount(path.path, partsAccum + 1);
-    case Path.FULLYQUALIFIED() then pathPartCount(path.path, partsAccum);
+    case Absyn.IDENT() then partsAccum + 1;
+    case Absyn.QUALIFIED() then pathPartCount(path.path, partsAccum + 1);
+    case Absyn.FULLYQUALIFIED() then pathPartCount(path.path, partsAccum);
   end match;
 end pathPartCount;
 
 public function getAnnotationsFromConstraintClass
-  input Option<ConstrainClass> inCC;
-  output list<ElementArg> outElArgLst;
+  input Option<Absyn.ConstrainClass> inCC;
+  output list<Absyn.ElementArg> outElArgLst;
 algorithm
   outElArgLst := match(inCC)
-    local list<ElementArg> elementArgs;
-    case SOME(CONSTRAINCLASS(comment = SOME(COMMENT(annotation_ = SOME(ANNOTATION(elementArgs))))))
+    local list<Absyn.ElementArg> elementArgs;
+    case SOME(Absyn.CONSTRAINCLASS(comment = SOME(Absyn.COMMENT(annotation_ = SOME(Absyn.ANNOTATION(elementArgs))))))
       then elementArgs;
     else {};
@@ -5853 +5853 @@
 
 public function getAnnotationsFromItems
-  input list<ComponentItem> inComponentItems;
-  input list<ElementArg> ccAnnotations;
-  output list<list<ElementArg>> outLst = {};
+  input list<Absyn.ComponentItem> inComponentItems;
+  input list<Absyn.ElementArg> ccAnnotations;
+  output list<list<Absyn.ElementArg>> outLst = {};
 protected
   list<Absyn.ElementArg> annotations;
@@ -5874 +5874 @@
 
 public function stripGraphicsAndInteractionModification
-" This function strips out the `graphics\' modification from an ElementArg
+" This function strips out the `graphics\' modification from an Absyn.ElementArg
    list and return two lists, one with the other modifications and the
    second with the `graphics\' modification"
@@ -6341 +6341 @@
 public function getTypeSpecFromElementItemOpt
 "@auhtor: johti
- Get the typespec path in an ElementItem if it has one"
+ Get the typespec path in an Absyn.ElementItem if it has one"
   input Absyn.ElementItem inElementItem;
   output Option<Absyn.TypeSpec> outTypeSpec;
@@ -6362 +6362 @@
 public function getElementSpecificationFromElementItemOpt
   "@auhtor: johti
-     Get a ComponentItem from an ElementItem if it has one"
+     Get a Absyn.ComponentItem from an Absyn.ElementItem if it has one"
   input Absyn.ElementItem inElementItem;
   output Option<Absyn.ElementSpec> outSpec;
@@ -6406 +6406 @@
 public function getDirection
 "@author johti
-  Get the direction if one exists otherwise returns BIDIR()"
+  Get the direction if one exists otherwise returns Absyn.BIDIR()"
   input Absyn.ElementItem elementItem;
-  output Direction oDirection;
+  output Absyn.Direction oDirection;
 algorithm
   oDirection:= matchcontinue elementItem
-    local Element element;
-    case ELEMENTITEM(element = element) then match element
-      local ElementSpec specification;
-      case ELEMENT(specification=specification) then match specification
-        local ElementAttributes attributes;
-        case COMPONENTS(attributes=attributes) then match attributes
-          local Direction direction;
-          case ATTR(direction=direction) then direction;
+    local Absyn.Element element;
+    case Absyn.ELEMENTITEM(element = element) then match element
+      local Absyn.ElementSpec specification;
+      case Absyn.ELEMENT(specification=specification) then match specification
+        local Absyn.ElementAttributes attributes;
+        case Absyn.COMPONENTS(attributes=attributes) then match attributes
+          local Absyn.Direction direction;
+          case Absyn.ATTR(direction=direction) then direction;
         end match;
       end match;
     end match;
-    else BIDIR();
+    else Absyn.BIDIR();
   end matchcontinue;
 end getDirection;
@@ -6432 +6432 @@
 algorithm
   res := match path
-    case IDENT() then path.name == name;
+    case Absyn.IDENT() then path.name == name;
     else false;
   end match;
@@ -6444 +6444 @@
 algorithm
   b := match cls.restriction
-    case R_UNIONTYPE(__) then true;
+    case Absyn.R_UNIONTYPE(__) then true;
     else false;
  end match;
@@ -6450 +6450 @@
 
 public function traverseClassElements<ArgT>
-  input Class inClass;
+  input Absyn.Class inClass;
   input FuncType inFunc;
   input ArgT inArg;
-  output Class outClass = inClass;
+  output Absyn.Class outClass = inClass;
   output ArgT outArg;
 
   partial function FuncType
-    input Element inElement;
+    input Absyn.Element inElement;
     input ArgT inArg;
-    output Element outElement;
+    output Absyn.Element outElement;
     output ArgT outArg;
     output Boolean outContinue;
@@ -6466 +6466 @@
   outClass := match(outClass)
     local
-      ClassDef body;
-
-    case CLASS()
+      Absyn.ClassDef body;
+
+    case Absyn.CLASS()
       algorithm
         (body, outArg) := traverseClassDef(outClass.body,
@@ -6480 +6480 @@
 
 protected function traverseClassPartElements<ArgT>
-  input ClassPart inClassPart;
+  input Absyn.ClassPart inClassPart;
   input FuncType inFunc;
   input ArgT inArg;
-  output ClassPart outClassPart = inClassPart;
+  output Absyn.ClassPart outClassPart = inClassPart;
   output ArgT outArg = inArg;
   output Boolean outContinue = true;
 
   partial function FuncType
-    input Element inElement;
+    input Absyn.Element inElement;
     input ArgT inArg;
-    output Element outElement;
+    output Absyn.Element outElement;
     output ArgT outArg;
     output Boolean outContinue;
@@ -6497 +6497 @@
   _ := match(outClassPart)
     local
-      list<ElementItem> items;
-
-    case PUBLIC()
+      list<Absyn.ElementItem> items;
+
+    case Absyn.PUBLIC()
       algorithm
         (items, outArg, outContinue) :=
@@ -6508 +6508 @@
         ();
 
-    case PROTECTED()
+    case Absyn.PROTECTED()
       algorithm
         (items, outArg, outContinue) :=
@@ -6522 +6522 @@
 
 protected function traverseElementItem<ArgT>
-  input ElementItem inItem;
+  input Absyn.ElementItem inItem;
   input FuncType inFunc;
   input ArgT inArg;
-  output ElementItem outItem;
+  output Absyn.ElementItem outItem;
   output ArgT outArg;
   output Boolean outContinue;
 
   partial function FuncType
-    input Element inElement;
+    input Absyn.Element inElement;
     input ArgT inArg;
-    output Element outElement;
+    output Absyn.Element outElement;
     output ArgT outArg;
     output Boolean outContinue;
@@ -6539 +6539 @@
   (outItem, outArg, outContinue) := match(inItem)
     local
-      Element elem;
-
-    case ELEMENTITEM()
+      Absyn.Element elem;
+
+    case Absyn.ELEMENTITEM()
       algorithm
         (elem, outArg, outContinue) := inFunc(inItem.element, inArg);
-        outItem := if referenceEq(elem, inItem.element) then inItem else ELEMENTITEM(elem);
+        outItem := if referenceEq(elem, inItem.element) then inItem else Absyn.ELEMENTITEM(elem);
       then
         (outItem, outArg, outContinue);
@@ -6553 +6553 @@
 
 public function elementSpec
-  input Element el;
-  output ElementSpec elSpec;
-algorithm
-  ELEMENT(specification = elSpec) := el;
+  input Absyn.Element el;
+  output Absyn.ElementSpec elSpec;
+algorithm
+  Absyn.ELEMENT(specification = elSpec) := el;
 end elementSpec;
 
 public function isClassOrComponentElementSpec
-  "The ElementSpec type contains the name of the element, and this function
+  "The Absyn.ElementSpec type contains the name of the element, and this function
    extracts this name."
-  input ElementSpec inElementSpec;
+  input Absyn.ElementSpec inElementSpec;
   output Boolean yes = false;
 algorithm
   yes := match (inElementSpec)
-    case CLASSDEF(class_ = CLASS()) then true;
-    case COMPONENTS(components = {COMPONENTITEM()}) then true;
+    case Absyn.CLASSDEF(class_ = Absyn.CLASS()) then true;
+    case Absyn.COMPONENTS(components = {Absyn.COMPONENTITEM()}) then true;
     else false;
   end match;