- Improvements to element redeclares in the new instantiation.

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

Compiler/FrontEnd/SCode.mo

@@ -833,10 +833,10 @@ algorithm
     local
       Absyn.Info i;
 
-    case(IMPORT(info = i)) then i;
-    case(EXTENDS(info = i)) then i;
-    case(CLASS(info = i)) then i;
     case(COMPONENT(info = i)) then i;
+    case(CLASS(info = i)) then i;
+    case(EXTENDS(info = i)) then i;
+    case(IMPORT(info = i)) then i;
     case(DEFINEUNIT(name = _)) then fail();    
 
   end match;
@@ -852,6 +852,22 @@ algorithm
   end match;
 end elementName;
 
+public function elementNameInfo
+  input Element inElement;
+  output String outName;
+  output Absyn.Info outInfo;
+algorithm
+  (outName, outInfo) := match(inElement)
+    local
+      String name;
+      Absyn.Info info;
+
+    case COMPONENT(name = name, info = info) then (name, info);
+    case CLASS(name = name, info = info) then (name, info);
+
+  end match;
+end elementNameInfo;
+
 public function elementNames "Gets all elements that have an element name from the list"
   input list<Element> elts;
   output list<String> names;

Compiler/FrontEnd/SCodeCheck.mo

@@ -495,9 +495,7 @@ protected
   String el_name;
   Absyn.Info el_info;
 algorithm
-  el := SCodeEnv.getRedeclarationElement(inRedeclare);
-  el_name := SCode.elementName(el);
-  el_info := SCode.elementInfo(el);
+  (el_name, el_info) := SCodeEnv.getRedeclarationNameInfo(inRedeclare);
   false := checkDuplicateRedeclarations2(el_name, el_info, inRedeclarations);
 end checkDuplicateRedeclarations;
 
@@ -521,10 +519,8 @@ algorithm
 
     case (_, _, redecl :: rest_redecls)
       equation
-        el = SCodeEnv.getRedeclarationElement(redecl);
-        el_name = SCode.elementName(el);
+        (el_name, el_info) = SCodeEnv.getRedeclarationNameInfo(redecl);
         true = stringEqual(inRedeclareName, el_name);
-        el_info = SCode.elementInfo(el);
         Error.addSourceMessage(Error.ERROR_FROM_HERE, {}, el_info);
         Error.addSourceMessage(Error.DUPLICATE_REDECLARATION,
           {inRedeclareName}, inRedeclareInfo);

Compiler/FrontEnd/SCodeDependency.mo

@@ -1781,9 +1781,12 @@ algorithm
     case (SCode.CLASS(name, prefixes as SCode.PREFIXES(replaceablePrefix =
         SCode.REPLACEABLE(cc)), ep, pp, res, cdef, info), _, _, _, _, _ , consts)
       equation
+        /*********************************************************************/
+        // TODO: Fix the usage of alias items in this case.
+        /*********************************************************************/
         // Check if the class is used.
         item = SCodeEnv.avlTreeGet(inClsAndVars, name);
-        resolved_item = SCodeEnv.resolveAlias(item, inClsAndVars);
+        (resolved_item, _) = SCodeEnv.resolveAlias(item, inEnv);
         true = checkClassUsed(resolved_item, cdef);
         // The class is used, recursively collect its contents.
         {class_frame} = SCodeEnv.getItemEnv(resolved_item);
@@ -2111,7 +2114,7 @@ protected
   String name;
   Item item;
 algorithm
-  name := SCode.elementName(SCodeEnv.getRedeclarationElement(inRedeclare));
+  (name, _) := SCodeEnv.getRedeclarationNameInfo(inRedeclare);
   (item, _, _) := SCodeLookup.lookupSimpleName(name, inEnv);
   true := SCodeEnv.isItemUsed(item);
 end removeUnusedRedeclares3;

Compiler/FrontEnd/SCodeEnv.mo

@@ -145,7 +145,9 @@ public uniontype Item
 
   record ALIAS 
     "An alias for another Item, see comment in SCodeFlattenRedeclare package."
-    Absyn.Path path;
+    String name;
+    Option<Absyn.Path> path;
+    Absyn.Info info;
   end ALIAS;
 end Item;
 
@@ -186,21 +188,24 @@ public function enterScope
   input Env inEnv;
   input SCode.Ident inName;
   output Env outEnv;
-protected
-  Frame cls_env;
-  AvlTree cls_and_vars;
-  Item item;
 algorithm
   outEnv := matchcontinue(inEnv, inName)
+    local
+      Frame cls_env;
+      AvlTree cls_and_vars;
+      Item item;
+
     case (_, _)
       equation
-        FRAME(clsAndVars = cls_and_vars) :: _ = inEnv;
-        item = avlTreeGet(cls_and_vars, inName);
-        item = resolveAlias(item, cls_and_vars);
+        /*********************************************************************/
+        // TODO: Should we use the environment returned by lookupInClass?
+        /*********************************************************************/
+        (item, _) = SCodeLookup.lookupInClass(inName, inEnv);
         {cls_env} = getItemEnv(item);
         outEnv = enterFrame(cls_env, inEnv);
       then
         outEnv;
+
     case (_, _)
       equation
         print("Failed to enterScope: " +& inName +& " in env: " +& printEnvStr(inEnv) +& "\n");
@@ -209,6 +214,35 @@ algorithm
   end matchcontinue;
 end enterScope;
 
+public function enterScopePath
+  input Env inEnv;
+  input Absyn.Path inPath;
+  output Env outEnv;
+algorithm
+  outEnv := match(inEnv, inPath)
+    local
+      Absyn.Ident name;
+      Absyn.Path path;
+      Env env;
+
+    case (_, Absyn.QUALIFIED(name = name, path = path))
+      equation
+        env = enterScope(inEnv, name);
+      then
+        enterScopePath(env, path);
+
+    case (_, Absyn.IDENT(name = name))
+      then enterScope(inEnv, name);
+
+    case (_, Absyn.FULLYQUALIFIED(path = path))
+      equation
+        env = getEnvTopScope(inEnv);
+      then
+        enterScopePath(env, path);
+
+  end match;
+end enterScopePath;
+
 public function enterFrame
   input Frame inFrame;
   input Env inEnv;
@@ -527,6 +561,8 @@ algorithm
     case VAR(isUsed = SOME(is_used))
       then Util.getStatefulBoolean(is_used);
 
+    case ALIAS(name = _) then true;
+
     else false;
   end match;
 end isItemUsed;
@@ -573,21 +609,22 @@ algorithm
       Env class_env, env;
       SCode.ClassDef cdef;
       ClassType cls_type;
+      Absyn.Info info;
 
     // A class extends.
     case (SCode.CLASS(classDef = SCode.CLASS_EXTENDS(baseClassName = _)), _)
       then
         SCodeFlattenRedeclare.extendEnvWithClassExtends(inClassDefElement, inEnv);
 
-    case (SCode.CLASS(name = cls_name, classDef = cdef, 
-        prefixes = SCode.PREFIXES(replaceablePrefix = SCode.REPLACEABLE(_))), _)
+    case (SCode.CLASS(name = cls_name, classDef = cdef, prefixes = SCode.PREFIXES(
+        replaceablePrefix = SCode.REPLACEABLE(_)), info = info), _)
       equation
         class_env = makeClassEnvironment(inClassDefElement, false);
         cls_type = getClassType(cdef);
         alias_name = cls_name +& BASE_CLASS_SUFFIX;
         env = extendEnvWithItem(newClassItem(inClassDefElement, class_env, cls_type),
           inEnv, alias_name);
-        env = extendEnvWithItem(ALIAS(Absyn.IDENT(alias_name)), env, cls_name);
+        env = extendEnvWithItem(ALIAS(alias_name, NONE(), info), env, cls_name);
       then
         env;
 
@@ -677,29 +714,6 @@ algorithm
   outEnv := FRAME(name, ty, tree, exts, imps, is_used) :: rest;
 end updateItemInEnv;
 
-public function getItemInEnv
-  input String inItemName;
-  input Env inEnv;
-  output Item outItem;
-protected
-  AvlTree tree;
-algorithm
-  outItem := matchcontinue(inItemName, inEnv)
-    case (inItemName, inEnv)
-      equation
-        FRAME(clsAndVars = tree) :: _ = inEnv;
-        outItem = avlTreeGet(tree, inItemName);
-        outItem = resolveAlias(outItem, tree);
-      then
-        outItem;
-    case (inItemName, inEnv)
-      equation
-        print("- SCodeEnv.getItemInEnv failed on: " +& inItemName +& " in env:" +& printEnvStr(inEnv) +& "\n");
-      then
-        fail();
-  end matchcontinue;
-end getItemInEnv;
-
 protected function extendEnvWithImport
   "Extends the environment with an import element."
   input SCode.Element inImport;
@@ -1459,6 +1473,7 @@ algorithm
 
     case VAR(var = SCode.COMPONENT(info = info)) then info;
     case CLASS(cls = SCode.CLASS(info = info)) then info;
+    case ALIAS(info = info) then info;
   end match;
 end getItemInfo;
 
@@ -1489,6 +1504,7 @@ algorithm
 
     case VAR(var = SCode.COMPONENT(name = name)) then name;
     case CLASS(cls = SCode.CLASS(name = name)) then name;
+    case ALIAS(name = name) then name;
   end match;
 end getItemName;
 
@@ -1648,25 +1664,64 @@ algorithm
   end match;
 end getRedeclarationElement;
 
+public function getRedeclarationNameInfo
+  input Redeclaration inRedeclare;
+  output String outName;
+  output Absyn.Info outInfo;
+algorithm
+  (outName, outInfo) := match(inRedeclare)
+    local
+      SCode.Element el;
+      String name;
+      Absyn.Info info;
+
+    case PROCESSED_MODIFIER(modifier = ALIAS(name = name, info = info))
+      then (name, info);
+
+    else
+      equation
+        el = getRedeclarationElement(inRedeclare);
+        (name, info) = SCode.elementNameInfo(el);
+      then
+        (name, info);
+
+  end match;
+end getRedeclarationNameInfo;
+
 public function resolveAlias
-  "Resolved an alias by looking up the aliased item recursively in the AvlTree
-  until a non-alias item is found."
+  "Resolved an alias by looking up the aliased item recursively in the
+   environment until a non-alias item is found."
   input Item inItem;
-  input AvlTree inTree;
+  input Env inEnv;
   output Item outItem;
+  output Env outEnv;
 algorithm
-  outItem := match(inItem, inTree)
+  (outItem, outEnv) := match(inItem, inEnv)
     local
       String name;
       Item item;
+      Absyn.Path path;
+      Env env;
+      AvlTree tree;
 
-    case (ALIAS(path = Absyn.IDENT(name)), _)
+    case (ALIAS(name = name, path = NONE()), FRAME(clsAndVars = tree) :: _)
       equation
-        item = avlTreeGet(inTree, name);
+        item = avlTreeGet(tree, name);
+        (item, env) = resolveAlias(item, inEnv);
       then
-        resolveAlias(item, inTree);
+        (item, env);
 
-    else inItem;
+    case (ALIAS(name = name, path = SOME(path)), _)
+      equation
+        env = getEnvTopScope(inEnv);
+        env = enterScopePath(env, path);
+        FRAME(clsAndVars = tree) :: _ = env;
+        item = avlTreeGet(tree, name);
+        (item, env) = resolveAlias(item, env);
+      then
+        (item, env);
+
+    else (inItem, inEnv);
   end match;
 end resolveAlias;
 
@@ -1824,7 +1879,7 @@ public function printAvlValueStr
 algorithm
   outString := match(inValue)
     local
-      String key_str, alias_str;
+      String key_str, alias_str, name;
       Absyn.Path path;
 
     case (AVLTREEVALUE(key = key_str, value = CLASS(cls = _)))
@@ -1833,12 +1888,15 @@ algorithm
     case (AVLTREEVALUE(key = key_str, value = VAR(var = _)))
       then "\t\tVar " +& key_str +& "\n";
 
-    case (AVLTREEVALUE(key = key_str, value = ALIAS(path = path)))
+    case (AVLTREEVALUE(key = key_str, value = ALIAS(name = name, path = SOME(path))))
       equation
-        alias_str = Absyn.pathString(path);
+        alias_str = Absyn.pathString(path) +& "." +& name;
       then
         "\t\tAlias " +& key_str +& " -> " +& alias_str +& "\n";
 
+    case (AVLTREEVALUE(key = key_str, value = ALIAS(name = name)))
+      then "\t\tAlias " +& key_str +& " -> " +& name +& "\n";
+
   end match;
 end printAvlValueStr;
 

Compiler/FrontEnd/SCodeFlattenImports.mo

@@ -86,7 +86,7 @@ algorithm
 
     case (SCode.CLASS(name = name, classDef = cdef, info = info), _)
       equation
-        SCodeEnv.CLASS(env = {cls_env}, classType = cls_ty) = 
+        (SCodeEnv.CLASS(env = {cls_env}, classType = cls_ty), _) = 
           SCodeLookup.lookupInClass(name, inEnv);
         env = SCodeEnv.enterFrame(cls_env, inEnv);