[NF] Improve functions called through components.

- Clone all classes except operators (because operators are special
  and cloning them causes typing loops) when instantiating a class
  tree, to ensure that classes inside of instantiated components have
  unique caches.
- Remove cloning of extends nodes, since cloning all classes makes
  that unnecessary.
- Implemented Statement.toString for debugging.

Belonging to [master]:
  - #2815
  - OpenModelica/OpenModelica-testsuite#1085

Author: perost

Compiler/NFFrontEnd/NFClassTree.mo

@@ -554,6 +554,10 @@ public
             // Copy the local classes into the new class array, and set the
             // class we're instantiating to be their parent.
             for c in old_clss loop
+              if not InstNode.isOperator(c) then
+                c := InstNode.clone(c);
+              end if;
+
               c := InstNode.setParent(clsNode, c);
 
               // If the class is outer, check that it's valid and link it with

Compiler/NFFrontEnd/NFInst.mo

@@ -431,7 +431,6 @@ algorithm
         checkExtendsLoop(base_node, base_path, info);
         checkReplaceableBaseClass(base_nodes, base_path, info);
         base_node := expand(base_node);
-        base_node := InstNode.clone(base_node);
 
         ext := InstNode.setNodeType(InstNodeType.BASE_CLASS(scope, def), base_node);
 
@@ -657,7 +656,6 @@ algorithm
   end if;
 
   ext_node := expand(ext_node);
-  ext_node := InstNode.clone(ext_node);
 
   // Fetch the needed information from the class definition and construct a EXPANDED_DERIVED.
   cls := InstNode.getClass(node);

Compiler/NFFrontEnd/NFInstNode.mo

@@ -442,6 +442,17 @@ uniontype InstNode
     end while;
   end hasParentExpandableConnector;
 
+  function isOperator
+    input InstNode node;
+    output Boolean op;
+  algorithm
+    op := match node
+      case CLASS_NODE() then SCode.isOperator(node.definition);
+      case INNER_OUTER_NODE() then isOperator(node.innerNode);
+      else false;
+    end match;
+  end isOperator;
+
   function name
     input InstNode node;
     output String name;

Compiler/NFFrontEnd/NFStatement.mo

@@ -418,5 +418,78 @@ public
     end match;
   end foldExp;
 
+  function toString
+    input Statement stmt;
+    output String str;
+  algorithm
+    str := match stmt
+      local
+        String s1, s2;
+
+      case ASSIGNMENT()
+        then Expression.toString(stmt.lhs) + " := " + Expression.toString(stmt.rhs);
+
+      case FUNCTION_ARRAY_INIT()
+        then "array init " + stmt.name;
+
+      case FOR()
+        algorithm
+          s1 := if isSome(stmt.range) then " in " + Expression.toString(Util.getOption(stmt.range)) else "";
+          s2 := toStringList(stmt.body);
+        then
+          "for " + InstNode.name(stmt.iterator) + s1 + " loop\n" + s2 + "end for";
+
+      case IF()
+        then branchString(listHead(stmt.branches), "if", true) +
+             stringDelimitList(list(branchString(b, "if", false) for b in listRest(stmt.branches)), "\n") +
+             "\nend if";
+
+      case WHEN()
+        then branchString(listHead(stmt.branches), "when", true) +
+             stringDelimitList(list(branchString(b, "when", false) for b in listRest(stmt.branches)), "\n") +
+             "\nwhen if";
+
+      case ASSERT()
+        then "assert(" + Expression.toString(stmt.condition) + ", " +
+             Expression.toString(stmt.message) + ", " + Expression.toString(stmt.level) + ")";
+
+      case TERMINATE()
+        then "terminate( " + Expression.toString(stmt.message) + ")";
+
+      case NORETCALL()
+        then Expression.toString(stmt.exp);
+
+      case WHILE()
+        then "while " + Expression.toString(stmt.condition) + " then\n" +
+             toStringList(stmt.body) + "\nend while";
+
+      case RETURN() then "return";
+      case BREAK() then "break";
+      else "#UNKNOWN STATEMENT#";
+    end match;
+  end toString;
+
+  function branchString
+    input tuple<Expression, list<Statement>> branch;
+    input String stmtType;
+    input Boolean firstBranch;
+    output String str;
+  protected
+    Expression cond;
+    list<Statement> body;
+  algorithm
+    (cond, body) := branch;
+
+    str := (if firstBranch then stmtType elseif Expression.isTrue(cond) then "else" else "else" + stmtType) +
+           " " + Expression.toString(cond) + "then\n" + toStringList(body);
+  end branchString;
+
+  function toStringList
+    input list<Statement> stmtl;
+    output String str;
+  algorithm
+    str := List.toString(stmtl, toString, "", " " , "\n  ", "", false) + "\n";
+  end toStringList;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFStatement;