[BE] Avoid records in remove simple equations

 - #4793

Belonging to [master]:
  - OpenModelica/OpenModelica#167
  - #3077

Author: kabdelhak

Compiler/BackEnd/RemoveSimpleEquations.mo

@@ -1943,7 +1943,7 @@ algorithm
 
     case (_, _, _, _, _, (vars, shared as BackendDAE.SHARED(functionTree=functions), eqns, seqns, index, mT, _))
       guard
-        not Expression.isImpure(exp) and not Expression.containsComplexCall(exp) // lochel: this is at least needed for impure functions
+        not Expression.isImpure(exp) and not Expression.containsRecordType(exp) // lochel: this is at least needed for impure functions
       equation
         //exp2 = Ceval.cevalSimpleWithFunctionTreeReturnExp(exp, functions);
         exp2 = EvaluateFunctions.evaluateConstantFunctionCallExp(exp, functions, false);
@@ -1958,7 +1958,7 @@ algorithm
       // TODO: Remove or fix this case. We do not want to add function calls here as they are inlined in a very bad way sometimes.
     case (_, _, _, _, _, (vars, shared, eqns, seqns, index, mT, _))
       guard
-        not Expression.isImpure(exp) and not Expression.containsComplexCall(exp) // lochel: this is at least needed for impure functions
+        not Expression.isImpure(exp) and not Expression.containsRecordType(exp) // lochel: this is at least needed for impure functions
       equation
         if Flags.isSet(Flags.DEBUG_ALIAS) then
           BackendDump.debugStrCrefStrExpStr("Const Equation (through Ceval, case 2) ", cr, " = ", exp, " found.\n");

Compiler/FrontEnd/DAEDump.mo

@@ -3356,18 +3356,18 @@ public function dumpCallAttr
 "dumps the DAE.CallAttributes"
   input DAE.CallAttributes ca;
 protected
-  Boolean tpl,bi,impure_;
+  Boolean tpl,bi,impure_,isFunc;
   DAE.InlineType iType;
   DAE.Type ty;
   DAE.TailCall tailCall;
   String s1,s2;
 algorithm
-  DAE.CALL_ATTR(ty=ty,tuple_=tpl,builtin=bi,isImpure=impure_,inlineType=iType,tailCall=tailCall) := ca;
+  DAE.CALL_ATTR(ty=ty,tuple_=tpl,builtin=bi,isImpure=impure_,isFunctionPointerCall=isFunc,inlineType=iType,tailCall=tailCall) := ca;
   print("Call attributes: \n----------------------\n");
   (s1,s2) := printTypeStr(ty);
   print("DAE-type: "+s1+"\n");
   print("DAE-type attributes :"+s2+"\n");
-  print("tuple_: "+boolString(tpl)+" builtin: "+boolString(bi)+" impure: "+boolString(impure_)+"\n\n");
+  print("tuple_: "+boolString(tpl)+" builtin: "+boolString(bi)+" impure: "+boolString(impure_)+" isFunctionPointerCall: "+boolString(isFunc)+"\n\n");
 end dumpCallAttr;
 
 public function dumpVarBindingStr

Compiler/FrontEnd/Expression.mo

@@ -49,6 +49,7 @@ encapsulated package Expression
 // public imports
 public import Absyn;
 public import DAE;
+public import DAEDump;
 
 protected
 type ComponentRef = DAE.ComponentRef;
@@ -7857,50 +7858,48 @@ algorithm
   end match;
 end isImpureWork;
 
-public function containsComplexCall "author: kabdelhak
-  Returns true if an expression contains a complex constructor call."
-  input DAE.Exp inExp;
-  output Boolean isCC;
-algorithm
-  (_, isCC) := traverseExpTopDown(inExp, containsComplexCallWork, false);
-end containsComplexCall;
 
-function containsComplexCallWork "author: kabdelhak"
+public function containsRecordType
+  " Returns true if an expression contains a record type."
   input DAE.Exp inExp;
-  input Boolean inCC;
-  output DAE.Exp outExp;
-  output Boolean cont;
-  output Boolean outCC;
+  output Boolean isRec;
 algorithm
-  (outExp,cont,outCC) := match (inExp,inCC)
-    local
-      Absyn.Path path;
-      Boolean isCC;
-    case (_, true) then (inExp,true,true);
-    case (DAE.CALL(path = Absyn.FULLYQUALIFIED(path = path)), _)
-      equation
-        true = isComplexCall(path);
-      then (inExp,false,true);
-    else (inExp,true,false);
-  end match;
-end containsComplexCallWork;
+  (_, isRec) := traverseExpTopDown(inExp, containsRecordTypeWork, false);
+end containsRecordType;
 
-function isComplexCall "author: kabdelhak"
-  input Absyn.Path path;
-  output Boolean isCC;
+protected function containsRecordTypeWork
+  input DAE.Exp inExp;
+  input Boolean inRec;
+  output DAE.Exp outExp = inExp;
+  output Boolean cont = false;
+  output Boolean outRec = inRec;
 algorithm
-  isCC := match path
-    local
-      Absyn.Path innerPath;
-    case (Absyn.FULLYQUALIFIED(path = innerPath))
-      then isComplexCall(innerPath);
-    case (Absyn.QUALIFIED(name=".Complex"))
-      then true;
-    case (Absyn.IDENT(name=".Complex"))
-      then true;
-    else false;
-  end match;
-end isComplexCall;
+  if not inRec then
+    (outExp,cont,outRec) := matchcontinue inExp
+      local
+        DAE.Type ty;
+        list<DAE.Exp> expLst;
+        Boolean subRec;
+        DAE.ComponentRef cr;
+      case DAE.RECORD()
+        algorithm
+        then (inExp,false,true);
+      case DAE.CALL(expLst=expLst, attr=DAE.CALL_ATTR(ty=ty))
+        algorithm
+          subRec := isRecordType(ty);
+          if not subRec then
+            for exp in expLst loop
+              subRec := containsRecordType(exp);
+              if subRec then
+                break;
+              end if;
+            end for;
+          end if;
+        then (inExp,not subRec,subRec);
+      else (inExp,true,false);
+    end matchcontinue;
+  end if;
+end containsRecordTypeWork;
 
 public function isConst
 "Returns true if an expression is constant"