Ran the refactoring script

Removed many unused variables and bindings

Compiler/BackEnd/BackendDAECreate.mo

@@ -1935,7 +1935,7 @@ algorithm
         (eqnl, reqnl);
 
     // if a function call includes external functions, it is not allowed to expand the left hand side since the call will be evaluated multiple times. That's an unintended behaviour.
-    case DAE.EQUATION(exp = lhs as DAE.TUPLE(PR=expl), scalar = e as DAE.CALL(_), source = source)::xs
+    case DAE.EQUATION(exp = lhs as DAE.TUPLE(PR=_), scalar = e as DAE.CALL(_), source = source)::xs
       equation
         //print("Do not lower equations with function calls that solve tuples "+DAEDump.dumpEquationStr(listHead(inDAEElementLst))+"\n");
         ty = Expression.typeof(lhs);
@@ -1953,7 +1953,7 @@ algorithm
       then
         (eqnl, reqnl);
 
-    case (el as DAE.EQUATION(exp = (cre as DAE.CREF(componentRef = cr)), scalar = e, source = source))::xs algorithm
+    case (el as DAE.EQUATION(exp = (cre as DAE.CREF(componentRef = _)), scalar = e, source = source))::xs algorithm
       try
         e := ExpressionSolve.solve(cre, e, cre);
       else
@@ -1967,7 +1967,7 @@ algorithm
       (eqnl, reqnl) := lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
     then (eqnl, reqnl);
 
-    case DAE.COMPLEX_EQUATION(lhs = (cre as DAE.CREF(componentRef = cr)), rhs = e, source = source)::xs
+    case DAE.COMPLEX_EQUATION(lhs = (cre as DAE.CREF(componentRef = _)), rhs = e, source = source)::xs
       equation
         (DAE.EQUALITY_EXPS(_,e), source) = ExpressionSimplify.simplifyAddSymbolicOperation(DAE.EQUALITY_EXPS(cre,e),source);
         size = Expression.sizeOf(Expression.typeof(cre));
@@ -2002,7 +2002,7 @@ algorithm
       then
         (eqnl, reqnl);
 
-    case DAE.ARRAY_EQUATION(dimension=ds, exp = (cre as DAE.CREF(componentRef = cr)), array = e, source = source)::xs
+    case DAE.ARRAY_EQUATION(dimension=ds, exp = (cre as DAE.CREF(componentRef = _)), array = e, source = source)::xs
       equation
         (DAE.EQUALITY_EXPS(_,e), source) = ExpressionSimplify.simplifyAddSymbolicOperation(DAE.EQUALITY_EXPS(cre,e),source);
         size = List.fold(Expression.dimensionsSizes(ds), intMul, 1);

Compiler/BackEnd/BackendEquation.mo

@@ -893,7 +893,7 @@ algorithm
     case {} then (listReverse(inAccum),inTypeA);
     case (BackendDAE.ASSIGN(left = e1, right = e2, source = source)::rest)
       equation
-        tp = Expression.typeof(e2);
+        _ = Expression.typeof(e2);
         (e1, extArg) = inFunc(e1, inTypeA);
         (e2, extArg) = inFunc(e2, extArg);
         (outWhenOps, extArg) = traverseExpsOfWhenOps(rest, inFunc, extArg,  BackendDAE.ASSIGN(e1, e2, source)::inAccum);
@@ -1026,7 +1026,7 @@ algorithm
     case {} then (inCont,inTypeA);
     case (BackendDAE.ASSIGN(left = e1, right = e2)::rest)
       equation
-        tp = Expression.typeof(e2);
+        _ = Expression.typeof(e2);
         if inCont then
          (_, b, extArg) = inFunc(e1, inTypeA);
         end if;
@@ -1420,7 +1420,6 @@ algorithm
       rexpandsize = rsize * 0.4;
       expandsize = realInt(rexpandsize);
       expandsize_1 = intMax(expandsize, 1);
-      newsize = expandsize_1 + arrSize;
       arr_1 = Array.expand(expandsize_1, equOptArr, NONE());
       n_1 = numberOfElement + 1;
       arr_2 = arrayUpdate(arr_1, n_1, SOME(inEquation));

Compiler/BackEnd/BackendInline.mo

@@ -575,7 +575,7 @@ algorithm
 
     case BackendDAE.ZERO_CROSSING(e, ilst1)
       equation
-        (e_1, _, b, _) = Inline.inlineExp(e, fns, DAE.emptyElementSource/*TODO: Propagate operation info*/);
+        (e_1, _,_, _) = Inline.inlineExp(e, fns, DAE.emptyElementSource/*TODO: Propagate operation info*/);
       then if not referenceEq(e,e_1) then BackendDAE.ZERO_CROSSING(e_1, ilst1) else zc;
 
     else zc;
@@ -911,13 +911,13 @@ algorithm
       BackendDAE.EqSystem eqSys, newEqSys;
       Boolean insideIfExp;
 
-    case (e1 as DAE.IFEXP(), (fns,eqSys,b,insideIfExp))
+    case (DAE.IFEXP(), (_,_,_,_))
       then fail();
 
     case (DAE.CALL(attr=DAE.CALL_ATTR(builtin=true)),_)
       then (inExp,inTuple);
 
-    case (e1 as DAE.CALL(p,args,DAE.CALL_ATTR(ty=ty,inlineType=inlineType)),(fns,eqSys,b,false))
+    case (DAE.CALL(p,args,DAE.CALL_ATTR(inlineType=inlineType)),(fns,eqSys,_,false))
     guard Inline.checkInlineType(inlineType,fns) and Flags.getConfigEnum(Flags.INLINE_METHOD)==2
       equation
         (fn,comment) = Inline.getFunctionBody(p,fns);
@@ -943,7 +943,7 @@ algorithm
         (newExp,(fns,newEqSys,true,false));
 
     //fallback use old implementation
-    case (e1 as DAE.CALL(p,args,DAE.CALL_ATTR(ty=ty,inlineType=inlineType)),(fns,eqSys,b,insideIfExp))
+    case (DAE.CALL(p,_,DAE.CALL_ATTR(inlineType=inlineType)),(fns,eqSys,b,insideIfExp))
       equation
         //TODO sace assertLst
         (newExp, _) = Inline.inlineCall(inExp, {}, fns);

Compiler/BackEnd/BackendVarTransform.mo

@@ -1945,7 +1945,7 @@ algorithm
       equation
         //cre = Expression.crefExp(cr);
         (cre1,b1) = replaceExp(cre,repl,inFuncTypeExpExpToBooleanOption);
-        (cr1,_) = validWhenLeftHandSide(cre1,cre,cr);
+        (_,_) = validWhenLeftHandSide(cre1,cre,cr);
         source = ElementSource.addSymbolicTransformationSubstitution(b1,source,cre,cre1);
         (exp1,b2) = replaceExp(exp,repl,inFuncTypeExpExpToBooleanOption);
         (exp1,_) = ExpressionSimplify.condsimplify(b2,exp1);

Compiler/BackEnd/CommonSubExpression.mo

@@ -1009,7 +1009,7 @@ algorithm
     then (value, inIndex + 1);
 
     // record types
-    case DAE.T_COMPLEX(varLst=varLst, complexClassType=ClassInf.RECORD(path)) equation
+    case DAE.T_COMPLEX( complexClassType=ClassInf.RECORD(_)) equation
       str = inPrefix + intString(inIndex);
       cr = DAE.CREF_IDENT(str, inType, {});       //inType?
       // crefs = ComponentReference.expandCref(cr, true);
@@ -1772,7 +1772,7 @@ algorithm
       DAE.Type ty;
       DAE.ComponentRef cref;
       list<BackendDAE.Equation> eqLst;
-  case({}, _, _, syst as BackendDAE.EQSYSTEM(orderedVars=vars, orderedEqs=eqs))
+  case({}, _, _, syst as BackendDAE.EQSYSTEM(orderedEqs=_))
     equation
     then (BackendDAEUtil.clearEqSyst(syst));
 
@@ -1821,7 +1821,7 @@ case (SHORTCUT_CSE(eqIdcs={eqIdx1, eqIdx2}, sharedVar=sharedVar)::rest, _, _, sy
       {eq1, eq2} = BackendEquation.getEqns({eqIdx1, eqIdx2}, eqs);
       var = BackendVariable.getVarAt(vars, sharedVar);
       varExp = BackendVariable.varExp(var);
-      ty = Expression.typeof(varExp);
+      _ = Expression.typeof(varExp);
       BackendDAE.EQUATION(exp=lhs1, scalar=rhs1) = eq1;
       BackendDAE.EQUATION(exp=lhs2, scalar=rhs2) = eq2;
 

Compiler/BackEnd/Differentiate.mo

@@ -978,7 +978,7 @@ algorithm
 
       case ((e1, e2)) guard(Expression.isZero(e1))
         equation
-          tp = Expression.typeof(e2);
+          _ = Expression.typeof(e2);
         then NONE();
 
   end match;
@@ -1654,7 +1654,7 @@ algorithm
     /*der(x)/dt*/
     case ("$_DF$DER",_)
       equation
-        (exp_1, funcs) = differentiateExp(exp, inDiffwrtCref, inInputData,inDiffType,inFuncs, maxIter, expStack);
+        (exp_1,_) = differentiateExp(exp, inDiffwrtCref, inInputData,inDiffType,inFuncs, maxIter, expStack);
         exp_2 =  Expression.crefExp(ComponentReference.makeCrefIdent(BackendDAE.symEulerDT, DAE.T_REAL_DEFAULT, {}));
       then
        (Expression.expDiv(exp_1,exp_2), inFuncs);
@@ -1774,7 +1774,7 @@ algorithm
         (DAE.IFEXP(DAE.CALL(Absyn.IDENT("noEvent"),{DAE.RELATION(e1,DAE.LESS(tp),e2,-1,NONE())},DAE.callAttrBuiltinBool), res1, res2), funcs);
 
     // diff(div(e1,e2)) =  diff(if noEvent(e1 > 0) then floor(e1/e2) else ceil(e1/e2)) = 0.0;
-    case ("div", {e1,e2}, DAE.CALL_ATTR(ty=tp))
+    case ("div", {_,_}, DAE.CALL_ATTR(ty=tp))
       equation
         (res1, _) = Expression.makeZeroExpression(Expression.arrayDimension(tp));
       then
@@ -1792,8 +1792,7 @@ algorithm
     // diff(rem(e1,e2)) = diff(e1 -div(e1,e2)*e2)
     case ("rem", {e1,e2}, DAE.CALL_ATTR(ty=tp))
       equation
-        etmp = Expression.makePureBuiltinCall("div", {e1, e2}, tp);
-        e = DAE.BINARY(e1, DAE.SUB(tp), DAE.BINARY(e2, DAE.MUL(tp),  etmp));
+        _ = Expression.makePureBuiltinCall("div", {e1, e2}, tp);
         (res1, funcs) = differentiateExp(e1, inDiffwrtCref, inInputData, inDiffType, inFunctionTree, maxIter, expStack);
       then
         (res1, funcs);
@@ -2661,17 +2660,17 @@ algorithm
     case ({}, _, _, _, _, _, _, _)
     then (MetaModelica.Dangerous.listReverseInPlace(inElementsDer), inFunctionTree, MetaModelica.Dangerous.listReverseInPlace(inElementsNoDer), MetaModelica.Dangerous.listReverseInPlace(inBooleanLst));
 
-    case ((var1 as DAE.VAR(componentRef = cref, ty= (DAE.T_COMPLEX(varLst=varLst,complexClassType=ClassInf.RECORD())),  binding=SOME(binding)))::rest, _, BackendDAE.DIFFINPUTDATA(matrixName=SOME(matrixName)), _, _, _, _, _) equation
+    case ((var1 as DAE.VAR(componentRef = cref, ty= (DAE.T_COMPLEX(complexClassType=ClassInf.RECORD())),  binding=SOME(binding)))::rest, _, BackendDAE.DIFFINPUTDATA(matrixName=SOME(matrixName)), _, _, _, _, _) equation
       dcref = createDiffedCrefName(cref, matrixName);
       var = DAEUtil.replaceCrefInVar(dcref, var1);
-      (dbinding, functions) = differentiateExp(binding, inDiffwrtCref, inInputData, inDiffType, inFunctionTree, maxIter, expStack);
+      (dbinding,_) = differentiateExp(binding, inDiffwrtCref, inInputData, inDiffType, inFunctionTree, maxIter, expStack);
       var = DAEUtil.replaceBindungInVar(dbinding, var);
       vars = var::inElementsDer;
       blst = true::inBooleanLst;
       (vars, functions, elementsNoDer, blst) = differentiateElementVars(rest, inDiffwrtCref, inInputData, inDiffType, inFunctionTree, vars, inElementsNoDer, blst, maxIter, expStack);
     then (vars, functions, elementsNoDer, blst);
 
-    case ((var1 as DAE.VAR(componentRef = cref, ty= (DAE.T_COMPLEX(varLst=varLst,complexClassType=ClassInf.RECORD()))))::rest, _, BackendDAE.DIFFINPUTDATA(matrixName=SOME(matrixName)), _, _, _, _, _) equation
+    case ((var1 as DAE.VAR(componentRef = cref, ty= (DAE.T_COMPLEX(complexClassType=ClassInf.RECORD()))))::rest, _, BackendDAE.DIFFINPUTDATA(matrixName=SOME(matrixName)), _, _, _, _, _) equation
       dcref = createDiffedCrefName(cref, matrixName);
       var = DAEUtil.replaceCrefInVar(dcref, var1);
 

Compiler/BackEnd/EvaluateFunctions.mo

@@ -479,7 +479,7 @@ algorithm
       list<DAE.Exp> exps, exps0, sub, allInputExps, constInputExps, constExps, constComplexExps, constScalarExps;
       list<list<DAE.Exp>> scalarExp;
 
-  case(DAE.CALL(path=path, expLst=exps0, attr=attr1),_)
+  case(DAE.CALL(path=path, expLst=exps0),_)
     equation
         if Flags.isSet(Flags.EVAL_FUNC_DUMP) then
           print("\nStart constant evaluation of expression: "+ExpressionDump.printExpStr(expIn)+"\n\n");
@@ -540,14 +540,13 @@ algorithm
           //BackendVarTransform.dumpReplacements(repl);
 
         // recognize if there are statements we cannot evaluate at the moment
-        hasAssert = List.fold(algs,hasAssertFold,false);
-        hasReturn = List.fold(algs,hasReturnFold,false);
-        hasTerminate = List.fold(algs,hasReturnFold,false);
-        hasReinit = List.fold(algs,hasReinitFold,false);
-        abort = hasReturn or hasTerminate or hasReinit;
+        _ = List.fold(algs,hasAssertFold,false);
+        _ = List.fold(algs,hasReturnFold,false);
+        _ = List.fold(algs,hasReturnFold,false);
+        _ = List.fold(algs,hasReinitFold,false);
 
         // go through all algorithms and replace the variables with constants if possible, extend the ht after each algorithm, consider bindings of protected vars as well
-        (algs,funcs,repl,idx) = List.mapFold3(algs,evaluateFunctions_updateAlgElements,funcsIn,repl,1);
+        (algs,_,repl,_) = List.mapFold3(algs,evaluateFunctions_updateAlgElements,funcsIn,repl,1);
         //print("\nall algs after"+intString(listLength(algs))+"\n"+DAEDump.dumpElementsStr(algs)+"\n");
         //BackendVarTransform.dumpReplacements(repl);
 
@@ -560,7 +559,7 @@ algorithm
           //print("all constant exps:\n"+ExpressionDump.printExpListStr(constExps)+"\n");
 
         // get the completely constant complex outputs, the constant parts of complex outputs and the variable parts of complex outputs and the expressions
-        (constComplexCrefs,varComplexCrefs,constScalarCrefs,varScalarCrefs) = checkIfOutputIsEvaluatedConstant(allOutputs,constCrefs,{},{},{},{});
+        (constComplexCrefs,_,constScalarCrefs,varScalarCrefs) = checkIfOutputIsEvaluatedConstant(allOutputs,constCrefs,{},{},{},{});
         constScalarExps = List.map1r(constScalarCrefs,BackendVarTransform.getReplacement,repl);
         constComplexExps = List.map1r(constComplexCrefs,BackendVarTransform.getReplacement,repl);
         (constScalarCrefs,constScalarExps) = List.filter1OnTrueSync(constCrefs,ComponentReference.crefInLst,constScalarCrefs,constExps);
@@ -2823,7 +2822,7 @@ protected function expandDimension"expands the dimensions. e.g. [3,3] {{1,1},{1,
   input list<list<DAE.Subscript>> subsIn;
   output list<list<DAE.Subscript>> subsOut;
 algorithm
-  subsOut := matchcontinue(dims,subsIn)
+  subsOut := match(dims,subsIn)
     local
       Integer size;
       list<Integer> range;
@@ -2847,7 +2846,7 @@ algorithm
   case({},_)
     equation
     then subsIn;
-  end matchcontinue;
+  end match;
 end expandDimension;
 
 protected function subsLstString
@@ -3090,7 +3089,7 @@ algorithm
          if Flags.isSet(Flags.EVAL_FUNC_DUMP) then
            print("--> the predicted const outputs:\n"+stringDelimitList(List.map(outExps,ExpressionDump.printExpStr),"\n"));
          end if;
-         (constOutExps,_,varOutExps) = List.intersection1OnTrue(outExps,allLHS,Expression.expEqual);
+         (_,_,_) = List.intersection1OnTrue(outExps,allLHS,Expression.expEqual);
 
          //_ = (not listEmpty(constOutExps)) and listEmpty(varOutExps);
          //repl = bcallret3(not predicted, BackendVarTransform.removeReplacements,replIn,varCrefs,NONE(),replIn);

Compiler/BackEnd/FindZeroCrossings.mo

@@ -867,7 +867,7 @@ algorithm
     case (DAE.CALL(path=Absyn.IDENT(name="smooth")), _)
     then (inExp, false, inTpl);
 
-    case (DAE.CALL(path=Absyn.IDENT(name="sample")), ((zeroCrossings, relations, samples, numMathFunctions), tp1 as (eq_count, _, _))) equation
+    case (DAE.CALL(path=Absyn.IDENT(name="sample")), ((_, _, samples, _), (eq_count, _, _))) equation
       zc = createZeroCrossing(inExp, {eq_count});
       mergeZeroCrossings(zc, samples);
       //itmp = (listLength(zc_lst)-listLength(zeroCrossings));
@@ -897,11 +897,11 @@ algorithm
     then (inExp, true, inTpl);
 
     // coditions that are zerocrossings.
-    case (DAE.LUNARY(exp=e1, operator=op), ((zeroCrossings, relations, samples, numMathFunctions), _)) equation
+    case (DAE.LUNARY(exp=e1, operator=op), ((zeroCrossings, relations, _, _), _)) equation
       if Flags.isSet(Flags.RELIDX) then
         print("continues LUNARY: " + intString(DoubleEndedList.length(relations)) + "\n");
       end if;
-      (e1, tpl as ((_, relations, samples, numMathFunctions), tp1 as (eq_count, vars, globalKnownVars))) = Expression.traverseExpTopDown(e1, collectZC, inTpl);
+      (e1, tpl as ((_, _, _, _), (eq_count, _, _))) = Expression.traverseExpTopDown(e1, collectZC, inTpl);
       e_1 = DAE.LUNARY(op, e1);
       zc = createZeroCrossing(e_1, {eq_count});
       empty = not ZeroCrossings.contains(zeroCrossings, zc);
@@ -1108,7 +1108,7 @@ algorithm
     case (DAE.CALL(path=Absyn.IDENT(name="smooth")), _)
     then (inExp, false, inTpl);
 
-    case (DAE.CALL(path=Absyn.IDENT(name="sample")), (iterator, inExpLst, range, (zeroCrossings, relations, samples, numMathFunctions), tp1 as (alg_indx, _, _))) equation
+    case (DAE.CALL(path=Absyn.IDENT(name="sample")), (_, _, _, (_, _, samples, _), (alg_indx, _, _))) equation
       eqs = {alg_indx};
       zc = createZeroCrossing(inExp, eqs);
       ZeroCrossings.add(samples, zc);
@@ -1122,15 +1122,15 @@ algorithm
       then (inExp, true, inTpl);
 
     // conditions that are zerocrossings.
-    case (DAE.LUNARY(exp=e1, operator=op), (iterator, _, DAE.RANGE(), (zeroCrossings, relations, _, numMathFunctions), _))
+    case (DAE.LUNARY(exp=e1, operator=op), (iterator, _, DAE.RANGE(), (zeroCrossings, relations, _, _), _))
       guard Expression.expContains(inExp, iterator)
       equation
       if Flags.isSet(Flags.RELIDX) then
         print("continues LUNARY with Iterator: " + intString(DoubleEndedList.length(relations)) + "\n");
       end if;
-      (e1, tpl as (iterator, inExpLst, range2, (_, relations, samples, numMathFunctions), tp1 as (alg_indx, _, _))) = Expression.traverseExpTopDown(e1, collectZCAlgsFor, inTpl);
+      (e1, tpl as (iterator, inExpLst, _, (_, relations, _, _), (alg_indx, _, _))) = Expression.traverseExpTopDown(e1, collectZCAlgsFor, inTpl);
       e_1 = DAE.LUNARY(op, e1);
-      (explst, itmp) = replaceIteratorWithStaticValues(e_1, iterator, inExpLst, DoubleEndedList.length(relations));
+      (explst,_) = replaceIteratorWithStaticValues(e_1, iterator, inExpLst, DoubleEndedList.length(relations));
       zc_lst = createZeroCrossings(explst, {alg_indx});
       ZeroCrossings.add_list(zeroCrossings, zc_lst);
       if Flags.isSet(Flags.RELIDX) then
@@ -1144,7 +1144,7 @@ algorithm
       if Flags.isSet(Flags.RELIDX) then
         print("continues LUNARY: " + intString(DoubleEndedList.length(relations)) + "\n");
       end if;
-      (e1, tpl as (iterator, inExpLst, range, (_, relations, samples, numMathFunctions), tp1 as (alg_indx, _, _))) = Expression.traverseExpTopDown(e1, collectZCAlgsFor, inTpl);
+      (e1, tpl as (_, _, _, (_, _, _, _), (alg_indx, _, _))) = Expression.traverseExpTopDown(e1, collectZCAlgsFor, inTpl);
       e_1 = DAE.LUNARY(op, e1);
       zc = createZeroCrossing(e_1, {alg_indx});
       ZeroCrossings.add(zeroCrossings, zc);
@@ -1170,7 +1170,7 @@ algorithm
       if intGt(DoubleEndedList.length(relations), oldNumRelations) then
         e_1 := DAE.LBINARY(e_1, op, e_2);
         if Expression.expContains(e1, iterator) or Expression.expContains(e2, iterator) then
-          (explst, itmp) := replaceIteratorWithStaticValues(e_1, iterator, inExpLst, DoubleEndedList.length(relations));
+          (explst,_) := replaceIteratorWithStaticValues(e_1, iterator, inExpLst, DoubleEndedList.length(relations));
           zc_lst := createZeroCrossings(explst, {alg_indx});
           ZeroCrossings.add_list(zeroCrossings, zc_lst);
           if Flags.isSet(Flags.RELIDX) then

Compiler/BackEnd/HpcOmScheduler.mo

@@ -4557,7 +4557,7 @@ algorithm
       array<tuple<HpcOmSimCode.Task,Integer>> allCalcTasks;
       HpcOmSimCode.Schedule schedule;
       list<Integer> order;
-    case(_,HpcOmTaskGraph.TASKGRAPHMETA(commCosts=_),_,_,_)
+    case(_,HpcOmTaskGraph.TASKGRAPHMETA(),_,_,_)
       algorithm
         true := intNe(arrayLength(iTaskGraph),0);
         nTasks := arrayLength(iTaskGraph);

Compiler/BackEnd/HpcOmTaskGraph.mo

@@ -6073,7 +6073,7 @@ algorithm
       array<ComponentInfo> compInformations1, compInformations2;
   case(_,_,_)
     equation
-      BackendDAE.DAE(eqs = _, shared = shared) = dae;
+      BackendDAE.DAE(shared = shared) = dae;
       remEqs = BackendDAEUtil.collapseRemovedEqs(dae);
       TASKGRAPHMETA(varCompMapping=varCompMap) = graphDataIn;
       eqLst = BackendEquation.equationList(remEqs);

Compiler/BackEnd/Initialization.mo

@@ -1491,7 +1491,7 @@ algorithm
     then ({}, {}, {});
 
     case currRedundantEqn::restRedundantEqns equation
-      nVars = BackendVariable.varsSize(inVars);
+      _ = BackendVariable.varsSize(inVars);
       _ = BackendDAEUtil.equationSize(inEqns);
     //BackendDump.dumpMatchingVars(vecVarToEqs);
     //BackendDump.dumpMatchingEqns(vecEqsToVar);
@@ -2502,7 +2502,7 @@ algorithm
     then (DAE.BCONST(false), inUseHomotopy);
 
     // replace homotopy(actual, simplified) with actual
-    case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst=actual::simplified::_), _)
+    case (DAE.CALL(path=Absyn.IDENT(name="homotopy"), expLst=actual::_::_), _)
     then (actual, true);
 
     else (inExp, inUseHomotopy);