favour builtin over List functions (OpenModelica#13722)

Author: hkiel

OMCompiler/Compiler/BackEnd/BackendDAECreate.mo

@@ -469,7 +469,7 @@ algorithm
       case 1 then DAE.ARRAY(ComponentReference.crefTypeFull(cref), true, expLst);
       case 2 algorithm
         dims := Types.getDimensions(ComponentReference.crefLastType(cref));
-        firstDim := match List.first(dims)
+        firstDim := match listHead(dims)
           case DAE.DIM_INTEGER(firstDim) then firstDim;
         end match;
         try

OMCompiler/Compiler/BackEnd/DataReconciliation.mo

@@ -2365,7 +2365,7 @@ algorithm
   for blocks in predecessorBlockInfo loop
     (mainBlock, targetBlocks, _, knownBlocks, constantBlocks, _) := blocks;
     if not listEmpty(knownBlocks) then // known Blocks
-      targetBlocksWithKnowns := filterTargetBlocksWithoutRanks(List.rest(targetBlocks), targetBlocksWithKnowns);
+      targetBlocksWithKnowns := filterTargetBlocksWithoutRanks(listRest(targetBlocks), targetBlocksWithKnowns);
     elseif not listEmpty(constantBlocks) then // constant Blocks
       targetBlocksWithConstants := filterTargetBlocksWithoutRanks(targetBlocks, targetBlocksWithConstants);
     else // unknown Blocks
@@ -3090,7 +3090,7 @@ algorithm
     for tmpblocks in blockinfo loop
       (_, tmptargetblocks, _) := tmpblocks;
       if not intEq(count,tmpcount) then
-        if listMember(List.first(targetblocks), tmptargetblocks) then
+        if listMember(listHead(targetblocks), tmptargetblocks) then
           targetexist := true;
         end if;
       end if;

OMCompiler/Compiler/BackEnd/HpcOmMemory.mo

@@ -2517,7 +2517,7 @@ import Util;
           if(boolNot(listEmpty(iVarList))) then
             varHead = listHead(iVarList);
             if(intEq(varHead, varIdx)) then
-              iVarList = List.rest(iVarList);
+              iVarList = listRest(iVarList);
               //print("createMemoryMapTraverse0: Removed variable " + intString(varIdx) + "\n");
             end if;
           end if;

OMCompiler/Compiler/BackEnd/HpcOmScheduler.mo

@@ -5532,8 +5532,8 @@ protected
   array<Real> tdsLevel = tdsLevelIn;
 algorithm
   while not(listEmpty(nodes)) loop
-    if arrayGet(visitedNodes, List.first(nodes)) then
-      nodes := List.rest(nodes);
+    if arrayGet(visitedNodes, listHead(nodes)) then
+      nodes := listRest(nodes);
     else
       nodes := computeGraphValuesTopDown2(nodes,iTaskGraph,iTaskGraphT,iTaskGraphMeta,alap,last,lact,tdsLevel,visitedNodes);
     end if;

OMCompiler/Compiler/BackEnd/ResolveLoops.mo

@@ -1338,9 +1338,9 @@ algorithm
         eqs := List.unique(eqs);
         eqs := List.intersectionOnTrue(eqs,loopIn,intEq);
         if listEmpty(eqs) then
-          next := List.first(loopIn);
+          next := listHead(loopIn);
         else
-          next := List.first(eqs);
+          next := listHead(eqs);
         end if;
         rest := List.deleteMemberOnTrue(next,loopIn,intEq);
       then sortLoop(rest,m,mT,next::sortLoopIn);

OMCompiler/Compiler/BackEnd/SymbolicJacobian.mo

@@ -2646,7 +2646,7 @@ protected
   BackendDAE.EqSystem syst;
 algorithm
   (BackendDAE.DAE(systems, shared), _, _, _, _, _) := jacobian;
-  syst := List.first(systems);  // Only the first system contains directional derivative,
+  syst := listHead(systems);  // Only the first system contains directional derivative,
                                 // the others contain optional constant equations
   dependencies := BackendEquation.getCrefsFromEquations(syst.orderedEqs, syst.orderedVars, shared.globalKnownVars);
 end calcJacobianDependencies;

OMCompiler/Compiler/BackEnd/SynchronousFeatures.mo

@@ -1799,13 +1799,13 @@ protected
   Integer i;
   DAE.Exp e, subclk;
 algorithm
-  DAE.CREF(componentRef = cr) := List.first(inExpLst);
+  DAE.CREF(componentRef = cr) := listHead(inExpLst);
   (_, varIxs) := BackendVariable.getVar(cr, inVars);
-  i := List.first(varIxs);
-  i := List.first(arrayGet(mT, i)) "Equation idx, containing var";
+  i := listHead(varIxs);
+  i := listHead(arrayGet(mT, i)) "Equation idx, containing var";
   i := arrayGet(inPartitions, i) "Partitions, from which var get";
   subclk := DAE.CREF(getSubClkName(i, 1), DAE.T_CLOCK_DEFAULT);
-  e := DAE.CALL(inPath, subclk::List.rest(inExpLst), inAttr);
+  e := DAE.CALL(inPath, subclk::listRest(inExpLst), inAttr);
   (outVar, outEq) := createSubClock(inPartitionIdx, inClkCnt, e);
 end createSubClockVar;
 
@@ -1972,7 +1972,7 @@ protected function createSubClockVarFactor
 protected
   DAE.Exp e;
 algorithm
-  outExp := substGetPartition(List.first(inExpLst));
+  outExp := substGetPartition(listHead(inExpLst));
   //To do this, the eqPartMap has to exclude the subPartition interfaces. Anyway, its not used anymore
   /*
   (outExp, outNewEqs, outNewVars, outClkCnt) := match listGet(inExpLst, 2)
@@ -2415,7 +2415,7 @@ protected
   Boolean create;
   DAE.Exp e;
 algorithm
-  e := List.first(inExps);
+  e := listHead(inExps);
   create := match e
     case DAE.CREF() then false;
     case DAE.RCONST() then false;
@@ -2436,7 +2436,7 @@ algorithm
         ty := Expression.typeof(e);
         cr := DAE.CREF_IDENT("$var" + intString(inCnt), ty, {});
         (var, eq) := createEqVarPair(cr, ty, e);
-      then (DAE.CREF(cr, ty)::List.rest(inExps), eq::inEqs, var::inVars, inCnt + 1);
+      then (DAE.CREF(cr, ty)::listRest(inExps), eq::inEqs, var::inVars, inCnt + 1);
     case false
       then (inExps, inEqs, inVars, inCnt);
   end match;

OMCompiler/Compiler/BackEnd/Uncertainties.mo

@@ -1184,8 +1184,8 @@ algorithm
       (_,tmptargetblocks,_):= tmpblocks;
       if(not intEq(count,tmpcount)) then
         //print("Targets:" + intString(tmpcount) + ": " + anyString(tmptargetblocks) + "\n ");
-        //print("first block:" + anyString(List.first(targetblocks))+ "\n");
-        if(listMember(List.first(targetblocks),tmptargetblocks)) then
+        //print("first block:" + anyString(listHead(targetblocks))+ "\n");
+        if(listMember(listHead(targetblocks),tmptargetblocks)) then
           //print("Predeccsors Block Found:" + anyString(targetblocks) + "\n");
           targetexist:=true;
         end if;
@@ -1285,7 +1285,7 @@ algorithm
    for blocks in blockinfo loop
       (blockitems1,targetblocks,targetblocksvar):= blocks;
       (blockstoupdate,exist,foundblock):=findSquareAndNonSquareBlocksHelper(targetblocks,targetblocksvar);
-      (blockvarlst1,_):=List.first(targetblocksvar);
+      (blockvarlst1,_):=listHead(targetblocksvar);
       outlist1:=(blockitems1,blockvarlst1,exist,foundblock)::outlist1;
       for j in blockstoupdate loop
          (blockitem,_):=j;
@@ -1428,12 +1428,12 @@ algorithm
   print("\nLoop-1\n"+ "========\n");
   for blocks in predecessortargetinfo loop
     (blockitems,targetblocks,targetblocksvar,knownblocks,foundblockranks):= blocks;
-    (dependendblock,_):=listGet(allblockranks,List.first(foundblockranks));
+    (dependendblock,_):=listGet(allblockranks,listHead(foundblockranks));
     targetblocktobeinserted:=List.setDifferenceOnTrue(knownblocks,usedblocks,intEq);
     print("\nExtractEquationsfromNoPredecessorBlocks :" + dumplistInteger(blockitems) + " => " + dumplistInteger(dependendblock) + " => known blocks:" + dumplistInteger(targetblocktobeinserted) + "\n");
     //print("\ntargetblocktobeinserted :" + anyString(targetblocktobeinserted) + "=> SET_S :" + anyString(usedblocks));
     if(not listEmpty(targetblocktobeinserted)) then
-       usedblocks:=List.first(targetblocktobeinserted)::usedblocks;
+       usedblocks:=listHead(targetblocktobeinserted)::usedblocks;
     else
        //print("\n Problem is ill posed because there are two few variables of interest. Boundary condition A is ignored \n");
        blockspostoberemoved:=tmpcount::blockspostoberemoved;
@@ -1451,8 +1451,8 @@ algorithm
         blocksize:=listLength(blockitems)-1;
         sets:=listAppend(List.firstN(blockitems,blocksize),sets);
         // insert 1 equation of targetBlock into set-s
-        //sets:=List.first(dependendblock)::sets;
-        sets:=List.first(targetblocktobeinserted)::sets;
+        //sets:=listHead(dependendblock)::sets;
+        sets:=listHead(targetblocktobeinserted)::sets;
         print("\nAfterinsertion :" + dumplistInteger(targetblocktobeinserted) + "=> SET_S :" + dumplistInteger(sets) + "\n");
     elseif(not List.setEqualOnTrue(blockitems,dependendblock,intEq) and listEmpty(targetblocktobeinserted)) then
        // Block does not exist

OMCompiler/Compiler/FrontEnd/ConnectUtil.mo

@@ -2518,7 +2518,7 @@ algorithm
         inside := removeStreamSetElement(streamCref, inside);
         e := streamSumEquationExp(outside, inside, flowThreshold);
         if not listEmpty(inside) then
-          expr := streamFlowExp(List.first(inside));
+          expr := streamFlowExp(listHead(inside));
           e := Expression.makePureBuiltinCall("$OMC$inStreamDiv", {e, expr}, Expression.typeof(e));
         end if;
         // Evaluate any inStream calls that were generated.

OMCompiler/Compiler/FrontEnd/Expression.mo

@@ -3483,7 +3483,7 @@ public function makeTuple
   input list<DAE.Exp> inExps;
   output DAE.Exp outExp;
 algorithm
-  outExp := if listLength(inExps) > 1 then DAE.TUPLE(inExps) else List.first(inExps);
+  outExp := if listLength(inExps) > 1 then DAE.TUPLE(inExps) else listHead(inExps);
 end makeTuple;