- Translate Absyn.ConstrainClass into SCode.ConstrainClass in

  translateAbsyn2SCode.
- Updated some redeclare test cases.


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

Author: perost

Compiler/FrontEnd/Inst.mo

@@ -7004,7 +7004,7 @@ algorithm
       Env.Cache cache;
       InstanceHierarchy ih;
 
-      Option<Absyn.ConstrainClass> cc;
+      Option<SCode.ConstrainClass> cc;
       list<SCode.Element> compsOnConstrain;
       Absyn.InnerOuter io;
       SCode.Attributes at;
@@ -7037,7 +7037,7 @@ algorithm
           SCode.COMPONENT(name = n2,
                           prefixes = SCode.PREFIXES(
                             finalPrefix = SCode.NOT_FINAL(),
-                            replaceablePrefix = repl2 as SCode.REPLACEABLE((cc as SOME(Absyn.CONSTRAINCLASS(elementSpec=_)))),
+                            replaceablePrefix = repl2 as SCode.REPLACEABLE((cc as SOME(_))),
                             visibility = vis2),
                           typeSpec = t2,
                           modifications = old_mod),
@@ -7206,36 +7206,35 @@ protected function extractConstrainingComps
 "Author: BZ, 2009-07
  This function examines a optional Absyn.ConstrainClass argument.
  If there is a constraining class, lookup the class and return its elements."
-  input Option<Absyn.ConstrainClass> cc;
+  input Option<SCode.ConstrainClass> cc;
   input Env.Env env;
   input Prefix.Prefix pre;
   output list<SCode.Element> elems;
 algorithm
   elems := matchcontinue(cc,env,pre)
     local
-      Absyn.Path path,derP;
-      list<Absyn.ElementArg> args;
-      Env.Env clenv;
+      Absyn.Path path;
       SCode.Element cl;
       String name;
       list<SCode.Element> selems,extendselts,compelts,extcompelts,classextendselts;
       list<tuple<SCode.Element, DAE.Mod>> extcomps;
-      Option<Absyn.Annotation> annOpt;
-    
+      SCode.Mod mod;
+      Option<SCode.Comment> cmt;
+
     case(NONE(),_,_) then {};
-    case(SOME(Absyn.CONSTRAINCLASS(elementSpec = Absyn.EXTENDS(path,args,annOpt))),env,pre)
+    case(SOME(SCode.CONSTRAINCLASS(constrainingClass = path)),env,pre)
       equation
-        (_,(cl as SCode.CLASS(name = name, classDef = SCode.PARTS(elementLst=selems))) ,clenv) = Lookup.lookupClass(Env.emptyCache(),env,path,false);
+        (_,(cl as SCode.CLASS(name = name, classDef = SCode.PARTS(elementLst=selems))), _) = Lookup.lookupClass(Env.emptyCache(),env,path,false);
         (_,classextendselts,extendselts,compelts) = splitElts(selems);
         (_,_,_,_,extcomps,_,_,_,_) = InstExtends.instExtendsAndClassExtendsList(Env.emptyCache(), env, InnerOuter.emptyInstHierarchy, DAE.NOMOD(),  pre, extendselts, classextendselts, ClassInf.UNKNOWN(Absyn.IDENT("")), name, true, false);
         extcompelts = Util.listMap(extcomps,Util.tuple21);
         compelts = listAppend(compelts,extcompelts);
       then
         compelts;
-    case(SOME(Absyn.CONSTRAINCLASS(elementSpec = Absyn.EXTENDS(path,args,annOpt))),env,pre)
+    case (SOME(SCode.CONSTRAINCLASS(path, mod, cmt)), _, _)
       equation
-        (_,(cl as SCode.CLASS(classDef = SCode.DERIVED(typeSpec = Absyn.TPATH(path = derP)))) ,clenv) = Lookup.lookupClass(Env.emptyCache(),env,path,false);
-        compelts = extractConstrainingComps(SOME(Absyn.CONSTRAINCLASS(Absyn.EXTENDS(derP,{},annOpt),NONE())),env,pre);
+        (_,(cl as SCode.CLASS(classDef = SCode.DERIVED(typeSpec = Absyn.TPATH(path = path)))),_) = Lookup.lookupClass(Env.emptyCache(),env,path,false);
+        compelts = extractConstrainingComps(SOME(SCode.CONSTRAINCLASS(path, mod, cmt)),env,pre);
       then
         compelts;
   end matchcontinue;

Compiler/FrontEnd/SCode.mo

@@ -425,10 +425,18 @@ uniontype Redeclare "the redeclare prefix"
   record NOT_REDECLARE "a non redeclare prefix" end NOT_REDECLARE;
 end Redeclare;
 
+public uniontype ConstrainClass
+  record CONSTRAINCLASS
+    Absyn.Path constrainingClass;
+    Mod modifier;
+    Option<Comment> comment;
+  end CONSTRAINCLASS;
+end ConstrainClass;
+
 public
 uniontype Replaceable "the replaceable prefix"
   record REPLACEABLE "a replaceable prefix containing an optional constraint"
-    Option<Absyn.ConstrainClass> cc  "the constraint class"; 
+    Option<ConstrainClass> cc  "the constraint class"; 
   end REPLACEABLE;
   record NOT_REPLACEABLE "a non replaceable prefix" end NOT_REPLACEABLE;
 end Replaceable;
@@ -3098,18 +3106,18 @@ end replaceableBool;
 
 public function replaceableOptConstraint
   input Replaceable inReplaceable;
-  output Option<Absyn.ConstrainClass> outOptConstrainClass;
+  output Option<ConstrainClass> outOptConstrainClass;
 algorithm
   outOptConstrainClass := match(inReplaceable)
-    local Option<Absyn.ConstrainClass> cc;
+    local Option<ConstrainClass> cc;
     case (REPLACEABLE(cc)) then cc;
     case (NOT_REPLACEABLE()) then NONE();
   end match;
 end replaceableOptConstraint;
 
 public function boolReplaceable
   input Boolean inBoolReplaceable;
-  input Option<Absyn.ConstrainClass> inOptConstrainClass;
+  input Option<ConstrainClass> inOptConstrainClass;
   output Replaceable outReplaceable;
 algorithm
   outReplaceable := matchcontinue(inBoolReplaceable, inOptConstrainClass)
@@ -3317,13 +3325,16 @@ public function replaceableEqual "Returns true if two replaceable attributes are
 algorithm
   equal := matchcontinue(r1,r2)
     local
-      Absyn.ElementSpec e1, e2;
+      Absyn.Path p1, p2;
+      Mod m1, m2;
 
     case(NOT_REPLACEABLE(),NOT_REPLACEABLE()) then true;  
 
-    case(REPLACEABLE(SOME(Absyn.CONSTRAINCLASS(elementSpec=e1))),REPLACEABLE(SOME(Absyn.CONSTRAINCLASS(elementSpec=e2))))
+    case(REPLACEABLE(SOME(CONSTRAINCLASS(constrainingClass = p1, modifier = m1))),
+         REPLACEABLE(SOME(CONSTRAINCLASS(constrainingClass = p2, modifier = m2))))
       equation
-        true = valueEq(e1, e2);         
+        true = Absyn.pathEqual(p1, p2);
+        true = modEqual(m1, m2);
       then 
         true;
 

Compiler/FrontEnd/SCodeDependency.mo

@@ -699,7 +699,7 @@ algorithm
       Absyn.Info info;
       SCode.Attributes attr;
       Option<Absyn.Exp> cond_exp;
-      Option<Absyn.ConstrainClass> cc;
+      Option<SCode.ConstrainClass> cc;
       SCode.Element cls;
       Item ty_item;
       Env ty_env;
@@ -932,13 +932,25 @@ end analyseRedeclare;
 
 protected function analyseConstrainClass
   "Analyses a constrain class, i.e. given by constrainedby."
-  input Option<Absyn.ConstrainClass> inCC;
+  input Option<SCode.ConstrainClass> inCC;
   input Env inEnv;
   input Absyn.Info inInfo;
 algorithm
   _ := match(inCC, inEnv, inInfo)
-    // TODO Add code here.
-    case (_, _, _) then ();
+    local
+      Absyn.Path path;
+      SCode.Mod mod;
+      Env env;
+
+    case (SOME(SCode.CONSTRAINCLASS(constrainingClass = path, modifier = mod)), _, _)
+      equation
+        analyseClass(path, inEnv, inInfo);
+        (_, _, env) = SCodeLookup.lookupClassName(path, inEnv, inInfo);
+        analyseModifier(mod, inEnv, env, inInfo);
+      then
+        ();
+
+    else ();
   end match;
 end analyseConstrainClass;
 
@@ -1715,7 +1727,7 @@ protected
   SCodeEnv.Frame class_frame;
   Env class_env;
   Absyn.Path cls_path;
-  Option<Absyn.ConstrainClass> cc;
+  Option<SCode.ConstrainClass> cc;
 algorithm
   SCode.CLASS(name, prefixes, ep, pp, res, cdef, info) := inClass;
   // TODO! FIXME! add cc to the used classes!

Compiler/FrontEnd/SCodeDump.mo

@@ -958,8 +958,17 @@ public function replaceableStr
   output String strConstraint;
 algorithm
   (strReplaceable, strConstraint) := match(inReplaceable)
-    local Absyn.ConstrainClass cc;
-    case (SCode.REPLACEABLE(SOME(cc))) then ("replaceable ", Dump.unparseConstrainclassStr(cc));
+    local
+      Absyn.Path path;
+      SCode.Mod mod;
+      String path_str, mod_str;
+
+    case (SCode.REPLACEABLE(SOME(SCode.CONSTRAINCLASS(
+        constrainingClass = path, modifier = mod)))) 
+      equation
+        path_str = Absyn.pathString(path);
+        mod_str = printModStr(mod);
+      then ("replaceable ", path_str +& "(" +& mod_str +& ")");
     case (SCode.REPLACEABLE(NONE())) then ("replaceable ", "");
     case (SCode.NOT_REPLACEABLE()) then ("", "");
   end match;

Compiler/FrontEnd/SCodeFlatDump.mo

@@ -355,8 +355,16 @@ public function replaceableStr
   output String strReplaceable;
 algorithm
   strReplaceable := match(inReplaceable)
-    local Absyn.ConstrainClass cc;
-    case (SCode.REPLACEABLE(SOME(cc))) then "{r:" +& Dump.unparseConstrainclassStr(cc) +& "}";
+    local
+      Absyn.Path cc_path;
+      SCode.Mod cc_mod;
+      String path_str, mod_str;
+
+    case (SCode.REPLACEABLE(SOME(SCode.CONSTRAINCLASS(cc_path, cc_mod, _))))
+      equation
+        path_str = Absyn.pathString(cc_path);
+        mod_str = SCodeDump.printModStr(cc_mod);
+      then "{r:" +& path_str +& "(" +& mod_str +& ")}";
     case (SCode.REPLACEABLE(NONE()))   then "{r:}";
     case (SCode.NOT_REPLACEABLE())     then "{}";
   end match;
@@ -444,4 +452,4 @@ algorithm
   end match;
 end restrictionStr;
 
-end SCodeFlatDump;
+end SCodeFlatDump;

Compiler/FrontEnd/SCodeUtil.mo

@@ -1144,6 +1144,7 @@ algorithm
       SCode.Visibility vis;
       SCode.Flow sFl;
       SCode.Stream sSt;
+      Option<SCode.ConstrainClass> scc;
 
     case (cc,finalPrefix,_,repl,vis, Absyn.CLASSDEF(replaceable_ = rp, class_ = (cl as Absyn.CLASS(name = n,partialPrefix = pa,finalPrefix = fi,encapsulatedPrefix = e,restriction = re,body = de,info = i))),_)
       equation
@@ -1153,7 +1154,8 @@ algorithm
         (_, redecl) = translateRedeclarekeywords(repl);
         sRed = SCode.boolRedeclare(redecl);
         sFin = SCode.boolFinal(finalPrefix);
-        sRep = Util.if_(rp,SCode.REPLACEABLE(cc),SCode.NOT_REPLACEABLE());
+        scc = translateConstrainClass(cc);
+        sRep = Util.if_(rp,SCode.REPLACEABLE(scc),SCode.NOT_REPLACEABLE());
         sEnc = SCode.boolEncapsulated(e);
         sPar = SCode.boolPartial(pa); 
         cls = SCode.CLASS(
@@ -1197,7 +1199,8 @@ algorithm
         comment_1 = translateComment(comment);
         sFin = SCode.boolFinal(finalPrefix);
         sRed = SCode.boolRedeclare(redecl);
-        sRep = Util.if_(repl_1,SCode.REPLACEABLE(cc),SCode.NOT_REPLACEABLE());
+        scc = translateConstrainClass(cc);
+        sRep = Util.if_(repl_1,SCode.REPLACEABLE(scc),SCode.NOT_REPLACEABLE());
         sFl = SCode.boolFlow(fl);
         sSt = SCode.boolStream(st);
       then
@@ -1306,6 +1309,32 @@ algorithm
   end match;
 end translateRedeclarekeywords;
 
+protected function translateConstrainClass
+  input Option<Absyn.ConstrainClass> inConstrainClass;
+  output Option<SCode.ConstrainClass> outConstrainClass;
+algorithm
+  outConstrainClass := match(inConstrainClass)
+    local
+      Absyn.Path cc_path;
+      list<Absyn.ElementArg> eltargs;
+      Option<Absyn.Comment> cmt;
+      Option<SCode.Comment> cc_cmt;
+      Absyn.Modification mod;
+      SCode.Mod cc_mod;
+
+    case SOME(Absyn.CONSTRAINCLASS(elementSpec = 
+        Absyn.EXTENDS(path = cc_path, elementArg = eltargs), comment = cmt))
+      equation
+        mod = Absyn.CLASSMOD(eltargs, Absyn.NOMOD());
+        cc_mod = translateMod(SOME(mod), SCode.NOT_FINAL(), SCode.NOT_EACH());
+        cc_cmt = translateComment(cmt);
+      then
+        SOME(SCode.CONSTRAINCLASS(cc_path, cc_mod, cc_cmt));
+  
+    else NONE();
+  end match;
+end translateConstrainClass;
+
 protected function translateVariability
 "function: translateVariability
   Converts an Absyn.Variability to SCode.Variability."