Started using elabExpInExpression instead of elabExp in many places (so functions returning multiple outputs work better)

Note: This interferes slightly with the MetaModelica type system (things RML did not handle; so no changes needed). The changes cause MetaModelica models using equations with tuples to fail (but that is okay; we do not use MetaModelica in models)


git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@21933 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: sjoelund

Compiler/FrontEnd/InstSection.mo

@@ -462,7 +462,7 @@ algorithm
     // equality equations e1 = e2
     case (cache,env,ih,pre,csets,ci_state,SCode.EQ_EQUALS(expLeft = e1,expRight = e2,info = info,comment=comment),initial_,impl,graph,_)
       equation
-         // Do static analysis and constant evaluation of expressions.
+        // Do static analysis and constant evaluation of expressions.
         // Gives expression and properties
         // (Type  bool | (Type  Const as (bool | Const list))).
         // For a function, it checks the funtion name.
@@ -476,6 +476,7 @@ algorithm
         //  Returns the output parameters from the function.
         (cache,e1_1,prop1,_) = Static.elabExp(cache, env, e1, impl, NONE(), true /*do vectorization*/, pre, info);
         (cache,e2_1,prop2,_) = Static.elabExp(cache, env, e2, impl, NONE(), true /*do vectorization*/, pre, info);
+
         (cache, e1_1, prop1) = Ceval.cevalIfConstant(cache, env, e1_1, prop1, impl, info);
         (cache, e2_1, prop2) = Ceval.cevalIfConstant(cache, env, e2_1, prop2, impl, info);
 

Compiler/FrontEnd/Patternm.mo

@@ -1937,6 +1937,7 @@ algorithm
         ((_,useTree)) = Expression.traverseExp(DAE.META_OPTION(dPatternGuard), useLocalCref, useTree);
         (elabPatterns,_) = traversePatternList(elabPatterns, checkDefUsePattern, (localsTree,useTree,patternInfo));
         elabCase = DAE.CASE(elabPatterns, dPatternGuard, caseDecls, body, elabResult, resultInfo, 0, info);
+        (elabResult,resType) = makeTupleFromMetaTuple(elabResult,resType);
       then (cache,elabCase,elabResult,resType,st);
 
       // ELSE is the same as CASE, but without pattern
@@ -2755,4 +2756,24 @@ algorithm
   Error.assertionOrAddSourceMessage(b or not Flags.isSet(Flags.PATTERNM_ALL_INFO),Error.META_DEAD_CODE,{"Statement optimised away"},DAEUtil.getElementSourceFileInfo(Algorithm.getStatementSource(statement)));
 end isNotDummyStatement;
 
+protected function makeTupleFromMetaTuple
+  input Option<DAE.Exp> inExp;
+  input Option<DAE.Type> inType;
+  output Option<DAE.Exp> exp;
+  output Option<DAE.Type> ty;
+algorithm
+  (exp,ty) := match (inExp,inType)
+    local
+      list<DAE.Exp> exps;
+      list<DAE.Type> tys,tys2;
+      list<Absyn.Path> source;
+    case (SOME(DAE.META_TUPLE(exps)),SOME(DAE.T_METATUPLE(types=tys,source=source)))
+      equation
+        tys2 = List.map(tys, Types.unboxedType);
+        (exps,tys2) = Types.matchTypeTuple(exps, tys, tys2, false);
+      then (SOME(DAE.TUPLE(exps)),SOME(DAE.T_TUPLE(tys2,source)));
+    else (inExp,inType);
+  end match;
+end makeTupleFromMetaTuple;
+
 end Patternm;