- Improved name prefixing in new instantiation.

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

Author: perost

Compiler/FrontEnd/Absyn.mo

@@ -3788,20 +3788,45 @@ algorithm
   outPath := match (inPath)
     local
       Ident str;
-      Path p_1,p;
-    case (IDENT(name = _)) then fail();
-    case (QUALIFIED(name = str,path = IDENT(name = _))) then IDENT(str);
-    case (QUALIFIED(name = str,path = p))
+      Path p;
+
+    case QUALIFIED(name = str, path = IDENT(name = _)) 
+      then IDENT(str);
+
+    case QUALIFIED(name = str, path = p)
       equation
-        p_1 = stripLast(p);
+        p = stripLast(p);
       then
-        QUALIFIED(str,p_1);
-    case (FULLYQUALIFIED(p)) equation
-      p_1 = stripLast(p);
-    then FULLYQUALIFIED(p_1);
+        QUALIFIED(str, p);
+
+    case FULLYQUALIFIED(p)
+      equation
+        p = stripLast(p);
+      then
+        FULLYQUALIFIED(p);
+
   end match;
 end stripLast;
 
+public function stripLastOpt
+  input Path inPath;
+  output Option<Path> outPath;
+algorithm
+  outPath := match(inPath)
+    local
+      Path p;
+
+    case IDENT(name = _) then NONE();
+
+    else
+      equation
+        p = stripLast(inPath);
+      then
+        SOME(p);
+
+  end match;
+end stripLastOpt;
+
 public function crefStripLast "Returns the path given as argument to
   the function minus the last ident."
   input ComponentRef inCref;

Compiler/FrontEnd/NFInst.mo

@@ -981,7 +981,7 @@ algorithm
         Absyn.QUALIFIED(name = enum_idx_str, path = tpath) = tpath;
         enum_idx = stringInt(enum_idx_str);
 
-        (cls_entry, env) = NFLookup.lookupClassName(tpath, inEnv, info);
+        (cls_entry, env) = NFLookup.lookupScopeEntry(inEnv);
         prefix = NFEnv.scopePrefix(inEnv);
         path = NFInstPrefix.prefixPath(Absyn.IDENT(name), prefix);
 
@@ -2219,7 +2219,7 @@ algorithm
 
         // If the cref refers to a package constant, make sure it's instantiated
         // and added to the symbol table.
-        opt_prefix = makePackageConstantPrefix(is_class, opt_prefix, env, base_env);
+        opt_prefix = makePackageConstantPrefix(is_class, opt_prefix, inCrefPath, prefix);
         globals = instPackageConstant(cref, entry, env, opt_prefix, inInfo, inGlobals);
       then
         (cref, globals);
@@ -2278,52 +2278,34 @@ protected function makePackageConstantPrefix
    a package constant that needs to be instantiated."
   input Boolean inIsClass;
   input Option<Prefix> inPrefix;
-  input Env inEnv;
-  input Env inBaseEnv;
+  input Absyn.Path inCrefPath;
+  input Prefix inCrefPrefix;
   output Option<Prefix> outPrefix;
 algorithm
-  outPrefix := matchcontinue(inIsClass, inPrefix, inEnv, inBaseEnv)
+  outPrefix :=
+  match(inIsClass, inPrefix, inCrefPath, inCrefPrefix)
     local
       Prefix prefix;
-      list<String> env_strl, base_env_strl;
-
-    // The first part of the cref refers to a class and the scope has a prefix.
-    // This happens when for example a cref refer to a package constant in a
-    // local class. Add the difference of the environment the cref was found in
-    // and the environment where the first identifier of the cref was found in
-    // to the scope's prefix.
-    case (true, SOME(prefix), _, _) 
-      equation
-        env_strl = NFEnv.scopeNames(inEnv);
-        base_env_strl = NFEnv.scopeNames(inBaseEnv);
-        (env_strl, _) =
-          List.removeEqualPrefix(env_strl, base_env_strl, stringEq);
-        prefix = NFInstPrefix.toPackagePrefix(prefix);
-        prefix = NFInstPrefix.addStringList(env_strl, prefix);
-      then
-        SOME(prefix);
 
-    // A component in a scope with a package prefix, i.e. a package constant
-    // which should be instantiated because it's a dependency of another package
-    // constant (due to e.g. a binding or modifier). Use the given prefix.
+    // A component found in a scope with a prefix. If the prefix is a package
+    // prefix then the cref is a package constant which should be instantiated
+    // because it's a dependency of another package constant, in which case the
+    // given prefix should be used. Otherwise it's not a package constant and
+    // will be instantiated normally, in which case NONE() is returned.
     case (false, SOME(prefix), _, _)
+      then Util.if_(NFInstPrefix.isPackagePrefix(prefix), inPrefix, NONE());
+        
+    // Otherwise we have a component without a prefix or a class.
+    else
       equation
-        true = NFInstPrefix.isPackagePrefix(prefix);
-      then
-        inPrefix;
-
-    // A component in a scope with a non-package prefix, not a package constant.
-    case (false, SOME(_), _, _) then NONE();
-
-    // Anything in a scope without a prefix is a package constant that should be
-    // prefixed with the environment path.
-    case (_, NONE(), _, _)
-      equation
-        prefix = NFEnv.envPrefix(inEnv);
+        // If the scope has a prefix, use that. Otherwise use the cref prefix.
+        prefix = Util.getOptionOrDefault(inPrefix, inCrefPrefix);
+        // Add the cref path except for the last identifier to the prefix.
+        prefix = NFInstPrefix.addOptPath(Absyn.stripLastOpt(inCrefPath), prefix);
       then
         SOME(prefix);
 
-  end matchcontinue;
+  end match;
 end makePackageConstantPrefix;
 
 protected function instPackageConstant

Compiler/FrontEnd/NFInstPrefix.mo

@@ -92,6 +92,21 @@ algorithm
   outPrefix := fromPath2(inPath, inPrefix);
 end addPath;
 
+public function addOptPath
+  input Option<Absyn.Path> inOptPath;
+  input Prefix inPrefix;
+  output Prefix outPrefix;
+algorithm
+  outPrefix := match(inOptPath, inPrefix)
+    local
+      Absyn.Path p;
+
+    case (NONE(), _) then inPrefix;
+    case (SOME(p), _) then addPath(p, inPrefix);
+
+  end match;
+end addOptPath;
+    
 public function addString
   "Prefixes the prefix with the given String."
   input String inName;

Compiler/FrontEnd/NFLookup.mo

@@ -241,6 +241,28 @@ algorithm
   end match;
 end lookupTypeSpec;
 
+public function lookupScopeEntry
+  input Env inEnv;
+  output Entry outEntry;
+  output Env outEnv;
+algorithm
+  (outEntry, outEnv) := match(inEnv)
+    local
+      String scope_name;
+      Env env;
+      Entry entry;
+
+    case _
+      equation
+        scope_name = NFEnv.scopeName(inEnv);
+        env = NFEnv.exitScope(inEnv);
+        entry = NFEnv.lookupEntry(scope_name, env);
+      then
+        (entry, env);
+
+  end match;
+end lookupScopeEntry;
+
 protected function makeDummyMetaType
   input String inTypeName;
   output SCode.Element outClass;
@@ -1044,7 +1066,7 @@ algorithm
       inOrigins, inEnv, inSplitFunc, inInfo, inAccumEnv)
     local
       list<SCode.Element> elems, cls_vars, exts, imps;
-      Env env;
+      Env env, der_env;
       list<EntryOrigin> origin;
       Entry entry;
       list<SCode.Enum> enums;
@@ -1056,6 +1078,8 @@ algorithm
       SCode.Mod smod;
       Modifier mod;
       String enum_name;
+      Absyn.ArrayDim ad;
+      Integer dim_count;
 
     case (SCode.PARTS(elementLst = elems), _, _, _, _, _, _, env)
       equation
@@ -1082,22 +1106,25 @@ algorithm
       then
         (env, ext_mods);
 
-    case (SCode.DERIVED(typeSpec = ty, modifications = smod), _, _, _, _, _, _, _)
+    case (SCode.DERIVED(typeSpec = ty, modifications = smod,
+        attributes = SCode.ATTR(arrayDims = ad)), _, _, _, _, _, _, _)
       equation
         // Apply the modifier from the derived declaration.
-        // TODO: The prefix and dimensions are wrong.
-        mod = NFMod.translateMod(smod, "", 0, inEnv);
+        dim_count = listLength(ad);
+        mod = NFMod.translateMod(smod, "", dim_count, inEnv);
         mod = NFMod.mergeMod(inModifier, mod);
 
-        (entry, env) = lookupTypeSpec(ty, inEnv, inInfo);
+        (entry, der_env) = lookupTypeSpec(ty, inEnv, inInfo);
         (el as SCode.CLASS(classDef = cdef)) = NFEnv.entryElement(entry);
         // TODO: Only create this environment if needed, i.e. if the cdef
         // contains extends.
-        env = openClassScope(el, NONE(), env);
-        (env, _) = populateEnvWithClassDef(cdef, mod, inVisibility,
+        env = openClassScope(el, NONE(), der_env);
+        (der_env, _) = populateEnvWithClassDef(cdef, mod, inVisibility,
           inOrigins, env, elementSplitterExtends, inInfo, inAccumEnv);
+
+        env = NFEnv.copyScopePrefix(inEnv, env);
         (env, ext_mods) = populateEnvWithClassDef(cdef, mod,
-          inVisibility, inOrigins, env, inSplitFunc, inInfo, inAccumEnv);
+          inVisibility, inOrigins, der_env, inSplitFunc, inInfo, env);
       then
         (env, ext_mods);
 

Compiler/Util/Util.mo

@@ -2323,11 +2323,12 @@ public function stringOption "author: PA
   input Option<String> inStringOption;
   output String outString;
 algorithm
-  outString:=
-  match (inStringOption)
-    local String s;
-    case (NONE()) then "";
-    case (SOME(s)) then s;
+  outString:= match(inStringOption)
+    local 
+      String s;
+
+    case SOME(s) then s;
+    else "";
   end match;
 end stringOption;
 
@@ -2344,26 +2345,31 @@ end getOption;
 public function getOptionOrDefault
 "Returns an option value if SOME, otherwise the default"
   input Option<Type_a> inOption;
-  input Type_a default;
-  output Type_a unOption;
+  input Type_a inDefault;
+  output Type_a outOption;
   replaceable type Type_a subtypeof Any;
 algorithm
-  unOption := matchcontinue (inOption,default)
-    local Type_a item;
-    case (SOME(item),_) then item;
-    case (_,_) then default;
-  end matchcontinue;
+  outOption := match(inOption, inDefault)
+    local
+      Type_a item;
+
+    case (SOME(item), _) then item;
+    else inDefault;
+  end match;
 end getOptionOrDefault;
 
 public function genericOption "author: BZ
   Returns a list with single value or an empty list if there is no optional value."
   input Option<Type_a> inOption;
-  output list<Type_a> unOption;
+  output list<Type_a> outOption;
   replaceable type Type_a subtypeof Any;
-algorithm unOption := match (inOption)
-    local Type_a item;
-    case (NONE()) then {};
-    case (SOME(item)) then {item};
+algorithm 
+  outOption := match(inOption)
+    local
+      Type_a item;
+
+    case SOME(item) then {item};
+    else {};
   end match;
 end genericOption;