[NF] Make protected class lookup possible.

- Added a flag to Lookup.lookupClassName that allows lookup of a class
  without checking for access violations, so that e.g. protected
  classes can be instantiated by Inst.instClassInProgram.

Belonging to [master]:
  - #2613

Compiler/NFFrontEnd/NFInst.mo

@@ -118,7 +118,7 @@ algorithm
   name := Absyn.pathString(classPath);
 
   // Look up the class to instantiate and mark it as the root class.
-  cls := Lookup.lookupClassName(classPath, top, Absyn.dummyInfo);
+  cls := Lookup.lookupClassName(classPath, top, Absyn.dummyInfo, checkAccessViolations = false);
   cls := InstNode.setNodeType(InstNodeType.ROOT_CLASS(), cls);
 
   // Initialize the storage for automatically generated inner elements.

Compiler/NFFrontEnd/NFLookup.mo

@@ -62,11 +62,12 @@ function lookupClassName
   input Absyn.Path name;
   input InstNode scope;
   input SourceInfo info;
+  input Boolean checkAccessViolations = true;
   output InstNode node;
 protected
   LookupState state;
 algorithm
-  (node, state) := lookupNameWithError(name, scope, info, Error.LOOKUP_ERROR);
+  (node, state) := lookupNameWithError(name, scope, info, Error.LOOKUP_ERROR, checkAccessViolations);
   LookupState.assertClass(state, node, name, info);
 end lookupClassName;
 
@@ -453,11 +454,12 @@ function lookupNameWithError
   input InstNode scope;
   input SourceInfo info;
   input Error.Message errorType;
+  input Boolean checkAccessViolations = true;
   output InstNode node;
   output LookupState state;
 algorithm
   try
-    (node, state) := lookupName(name, scope);
+    (node, state) := lookupName(name, scope, checkAccessViolations);
   else
     Error.addSourceMessage(errorType, {Absyn.pathString(name), InstNode.scopeName(scope)}, info);
     fail();
@@ -467,6 +469,7 @@ end lookupNameWithError;
 function lookupName
   input Absyn.Path name;
   input InstNode scope;
+  input Boolean checkAccessViolations;
   output InstNode node;
   output LookupState state;
 algorithm
@@ -485,7 +488,7 @@ algorithm
 
     // Fully qualified path, start from top scope.
     case Absyn.Path.FULLYQUALIFIED()
-      then lookupName(name.path, InstNode.topScope(scope));
+      then lookupName(name.path, InstNode.topScope(scope), checkAccessViolations);
 
   end match;
 end lookupName;
@@ -546,6 +549,7 @@ function lookupLocalName
   input Absyn.Path name;
   input output InstNode node;
   input output LookupState state;
+  input Boolean checkAccessViolations = true;
   input Boolean selfReference = false;
 algorithm
   // Looking something up in a component is only legal when the name begins with
@@ -565,15 +569,15 @@ algorithm
     case Absyn.Path.IDENT()
       algorithm
         node := lookupLocalSimpleName(name.name, node);
-        state := LookupState.next(node, state);
+        state := LookupState.next(node, state, checkAccessViolations);
       then
         ();
 
     case Absyn.Path.QUALIFIED()
       algorithm
         node := lookupLocalSimpleName(name.name, node);
-        state := LookupState.next(node, state);
-        (node, state) := lookupLocalName(name.path, node, state);
+        state := LookupState.next(node, state, checkAccessViolations);
+        (node, state) := lookupLocalName(name.path, node, state, checkAccessViolations);
       then
         ();
 

Compiler/NFFrontEnd/NFLookupState.mo

@@ -335,15 +335,19 @@ uniontype LookupState
      print a (hopefully relevant) error message and fail."
     input InstNode node;
     input LookupState currentState;
+    input Boolean checkAccessViolations = true;
     output LookupState nextState;
   protected
     LookupState entry_ty;
     SCode.Element el;
   algorithm
-    // Check that the element is allowed to be accessed given its visibility.
-    checkProtection(node, currentState);
-    // Check that we're allowed to look in the current scope.
-    //checkPackageLikeAccess(inCurrentState, el, inEnv);
+    if checkAccessViolations then
+      // Check that the element is allowed to be accessed given its visibility.
+      checkProtection(node, currentState);
+      // Check that we're allowed to look in the current scope.
+      //checkPackageLikeAccess(inCurrentState, el, inEnv);
+    end if;
+
     // Get the state for the found element, and check that the transition to the
     // new state is valid.
     entry_ty := nodeState(node);