- fixes for bug: #1953

Static.mo
- handle Tuple op nonTuple
- handle op Tuple
- test for it: testsuite/flattening/modelica/operators/OperatorsTuples.mo

Inst.mo
- workaround for Modelica MSL bug: https://trac.modelica.org/Modelica/ticket/627
- remove when fixed



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

Author: adrpo

Compiler/FrontEnd/Inst.mo

@@ -7314,7 +7314,7 @@ algorithm
     local
       SCode.Element oldElt,newElt;
       DAE.Mod oldMod,newMod;
-      String s1,s2;
+      String s1,s2,s;
       SCode.Mod smod1, smod2;
       Env.Env env, env1, env2;
       Env.Cache cache;
@@ -7327,6 +7327,7 @@ algorithm
       String n1, n2;
       Option<Absyn.ArrayDim> ad1, ad2;
       Option<Absyn.Exp> cond1, cond2;
+      Boolean b;
 
     // try equality first!
     case(cache,env,(oldElt,oldMod),(newElt,newMod))
@@ -7362,6 +7363,34 @@ algorithm
         Error.addSourceMessage(Error.DUPLICATE_ELEMENTS_NOT_SYNTACTICALLY_IDENTICAL,{s1,s2}, aInfo);
       then ();
 
+    // adrpo: handle bug: https://trac.modelica.org/Modelica/ticket/627
+    //        TODO! FIXME! REMOVE! remove when the bug is fixed!
+    case (cache,env,(oldElt as SCode.COMPONENT(n1, prefixes1, attr1, tp1 as Absyn.TPATH(tpath1, ad1), smod1, _, cond1, aInfo),oldMod),
+                    (newElt as SCode.COMPONENT(n2, prefixes2, attr2, tp2 as Absyn.TPATH(tpath2, ad2), smod2, _, cond2, _),newMod))
+      equation
+        // see if the most stuff is the same!
+        true = stringEq(n1, n2);
+        true = stringEq(n1, "m_flow");        
+        true = SCode.prefixesEqual(prefixes1, prefixes2);
+        true = SCode.attributesEqual(attr1, attr2);
+        false = SCode.modEqual(smod1, smod2);
+        equality(ad1 = ad2);
+        equality(cond1 = cond2);
+        // if we lookup tpath1 and tpath2 and reach the same class, we're fine!
+        (_, c1, env1) = Lookup.lookupClass(cache, env, tpath1, false);
+        (_, c2, env2) = Lookup.lookupClass(cache, env, tpath2, false);
+        // the class has the same environment
+        true = stringEq(Env.printEnvPathStr(env1), Env.printEnvPathStr(env2));
+        // the classes are the same!
+        true = SCode.elementEqual(c1, c2);
+        // add a warning and let it continue!
+        s1 = SCodeDump.unparseElementStr(oldElt);
+        s2 = SCodeDump.unparseElementStr(newElt);
+        s = "Inherited elements are not identical: bug: https://trac.modelica.org/Modelica/ticket/627\n\tfirst:  " +&
+            s1 +& "\n\tsecond: " +& s2 +& "\nContinue ....";
+        Error.addSourceMessage(Error.COMPILER_WARNING, {s}, aInfo);
+      then ();
+    
     // fail baby and add a source message!
     case (cache, env, (oldElt as SCode.COMPONENT(info=aInfo),oldMod),(newElt,newMod))
       equation

Compiler/FrontEnd/Static.mo

@@ -12590,7 +12590,6 @@ algorithm
   end match;
 end isOpElemWise;
 
-
 public function isFuncWithArrayInput
   input DAE.Type inType;
   output Boolean outBool;
@@ -12912,16 +12911,36 @@ algorithm
        local
          Env.Cache cache;
          Env.Env env;
-          list<tuple<DAE.Operator, list<DAE.Type>, DAE.Type>> opList;
+         list<tuple<DAE.Operator, list<DAE.Type>, DAE.Type>> opList;
          DAE.Type type1,type2, otype;
          DAE.Exp exp1,exp2,exp;
          DAE.Const const1,const2, const;
          DAE.Operator oper;
          Absyn.Operator aboper;
-         DAE.Properties prop;
+         DAE.Properties prop, props1, props2;
          Absyn.Exp  absexp1, absexp2;
-         Boolean lastRound;
+         Boolean lastRound; 
 
+     // handle tuple op non_tuple
+     case (_, _, aboper, props1 as DAE.PROP_TUPLE(type_ = _), exp1, props2 as DAE.PROP(type_ = _), exp2, _, _, _, _, _, _, _) 
+       equation
+         false = Config.acceptMetaModelicaGrammar();
+         (prop as DAE.PROP(type1, const1)) = Types.propTupleFirstProp(props1);
+         exp = DAE.TSUB(inExp1, 1, type1);
+         (cache, exp, prop) = operatorDeoverloadBinary(inCache, inEnv, inOperator1, prop, exp, inProp2, inExp2, AbExp, AbExp1, AbExp2, inImpl, inSymTab, inPre, inInfo);
+       then
+         (inCache, exp, prop);
+
+     // handle non_tuple op tuple
+     case (_, _, aboper, props1 as DAE.PROP(type_ = _), exp1, props2 as DAE.PROP_TUPLE(type_ = _), exp2, _, _, _, _, _, _, _) 
+       equation
+         false = Config.acceptMetaModelicaGrammar();
+         (prop as DAE.PROP(type2, const2)) = Types.propTupleFirstProp(props2);
+         exp = DAE.TSUB(inExp2, 1, type2);
+         (cache, exp, prop) = operatorDeoverloadBinary(inCache, inEnv, inOperator1, inProp1, inExp1, prop, exp, AbExp, AbExp1, AbExp2, inImpl, inSymTab, inPre, inInfo);
+       then
+         (inCache, exp, prop);
+
      case (_, _, aboper, DAE.PROP(type1,const1), exp1, DAE.PROP(type2,const2), exp2, _, _, _, _, _, _, _) 
        equation
          false = typeIsRecord(Types.arrayElementType(type1));
@@ -12934,7 +12953,7 @@ algorithm
          prop = DAE.PROP(otype,const);      
          warnUnsafeRelations(inEnv,AbExp,const, type1,type2,exp1,exp2,oper,inPre);      
        then
-           (inCache,exp, prop);
+         (inCache,exp, prop);
 
       // The order of this two cases determines the priority given to operators
       // Now left has priority for all.
@@ -12950,17 +12969,17 @@ algorithm
          // If the right side is not record then (lastRound is true) which means we should print errors on this round (last one:).
          lastRound = not typeIsRecord(Types.arrayElementType(type2));
 
-        (cache, exp , prop) = userDefOperatorDeoverloadBinary(cache,env,aboper,absexp1,absexp2,type1,type2,inImpl,inSymTab,inPre,inInfo,lastRound /**/);
-        (exp,_) = ExpressionSimplify.simplify(exp);
+         (cache, exp , prop) = userDefOperatorDeoverloadBinary(cache,env,aboper,absexp1,absexp2,type1,type2,inImpl,inSymTab,inPre,inInfo,lastRound /**/);
+         (exp,_) = ExpressionSimplify.simplify(exp);
        then
          (cache, exp, prop);   
 
       // if we have a record on the right side check for overloaded operators   
      case(cache, env, aboper, DAE.PROP(type1, const1), exp1, DAE.PROP(type2, const2), exp2, _, absexp1, absexp2, _, _, _, _)
        equation
          true = typeIsRecord(Types.arrayElementType(type2));
-        (cache, exp , prop) = userDefOperatorDeoverloadBinary(cache,env,aboper,absexp2,absexp1,type2,type1,inImpl,inSymTab,inPre,inInfo, true); /*we have tried left side*/
-        (exp,_) = ExpressionSimplify.simplify(exp);
+         (cache, exp , prop) = userDefOperatorDeoverloadBinary(cache,env,aboper,absexp2,absexp1,type2,type1,inImpl,inSymTab,inPre,inInfo, true); /*we have tried left side*/
+         (exp,_) = ExpressionSimplify.simplify(exp);
        then
          (cache, exp, prop);   
 
@@ -13008,7 +13027,17 @@ algorithm
        Absyn.Operator aboper;
        DAE.Properties prop;
        Absyn.Exp  absexp1;
-         
+
+     // handle op tuple
+     case (_, _, aboper, DAE.PROP_TUPLE(type_ = _), exp1, _, _, _, _, _, _) 
+       equation
+         false = Config.acceptMetaModelicaGrammar();
+         (prop as DAE.PROP(type1, const)) = Types.propTupleFirstProp(inProp1);
+         exp = DAE.TSUB(exp1, 1, type1);
+         (cache, exp, prop) = operatorDeoverloadUnary(inCache, inEnv, inOperator1, prop, exp, AbExp, AbExp1, inImpl, inSymTab, inPre, inInfo);
+       then
+         (cache, exp, prop);
+
      case (_, _, aboper, DAE.PROP(type1,const), exp1, _, _, _, _, _, _) 
        equation
          false = typeIsRecord(Types.arrayElementType(type1));