[NF] Handle initial complex equations better.

- Create the appropriate DAE element for initial complex equations.
- Always generate default constructors for operator records, but hide
  them from the function matching if an overloaded constructor exists.

Belonging to [master]:
  - #2526
  - OpenModelica/OpenModelica-testsuite#981

Author: perost

Compiler/NFFrontEnd/NFCall.mo

@@ -900,14 +900,17 @@ protected
     list<Integer> errors;
   algorithm
     ErrorExt.setCheckpoint("NFCall:checkMatchingFunctions");
-    matchedFunctions := {};
-
-    _ := match call
-      case ARG_TYPED_CALL(ref = ComponentRef.CREF(node = fn_node)) algorithm
-        allfuncs := Function.getCachedFuncs(fn_node);
-        matchedFunctions := Function.matchFunctions(allfuncs, call.arguments, call.named_args, info);
-      then
-        ();
+
+    matchedFunctions := match call
+      case ARG_TYPED_CALL(ref = ComponentRef.CREF(node = fn_node))
+        algorithm
+          allfuncs := Function.getCachedFuncs(fn_node);
+
+          if listLength(allfuncs) > 1 then
+            allfuncs := list(fn for fn guard not Function.isDefaultRecordConstructor(fn) in allfuncs);
+          end if;
+        then
+          Function.matchFunctions(allfuncs, call.arguments, call.named_args, info);
     end match;
 
     if listEmpty(matchedFunctions) then
@@ -937,58 +940,28 @@ protected
     // about matching. We have one matching func if we reach here.
     ErrorExt.rollBack("NFCall:checkMatchingFunctions");
 
-    if listLength(matchedFunctions) == 1 then
-      matchedFunc ::_ := matchedFunctions;
-
-      // Overwrite the actuall function name with the overload name
-      // for builtin functions.
-      if Function.isBuiltin(matchedFunc.func) then
-        func := matchedFunc.func;
-        func.path := Function.nameConsiderBuiltin(func);
-        matchedFunc.func := func;
-      end if;
-      return;
-    end if;
-
     if listLength(matchedFunctions) > 1 then
       exactMatches := MatchedFunction.getExactMatches(matchedFunctions);
-      if listLength(exactMatches) == 1 then
-        matchedFunc ::_ := exactMatches;
-
-        // Overwrite the actual function name with the overload name
-        // for builtin functions.
-        if Function.isBuiltin(matchedFunc.func) then
-          func := matchedFunc.func;
-          func.path := Function.nameConsiderBuiltin(func);
-          matchedFunc.func := func;
-        end if;
-        return;
-      else
-        matchedFunctions := resolveOverloadedVsDefaultConstructorAmbigutiy(matchedFunctions);
-        if listLength(matchedFunctions) == 1 then
-          matchedFunc ::_ := matchedFunctions;
-          return;
-        else
-          Error.addSourceMessage(Error.AMBIGUOUS_MATCHING_FUNCTIONS_NFINST,
-            {typedString(call), Function.candidateFuncListString(list(mfn.func for mfn in matchedFunctions))}, info);
+
+      if listLength(exactMatches) > 1 then
+        Error.addSourceMessage(Error.AMBIGUOUS_MATCHING_FUNCTIONS_NFINST,
+          {typedString(call), Function.candidateFuncListString(list(mfn.func for mfn in matchedFunctions))}, info);
           fail();
-        end if;
       end if;
+
+      matchedFunc := listHead(exactMatches);
+    else
+      matchedFunc := listHead(matchedFunctions);
     end if;
 
+    // Overwrite the actual function name with the overload name for builtin functions.
+    if Function.isBuiltin(matchedFunc.func) then
+      func := matchedFunc.func;
+      func.path := Function.nameConsiderBuiltin(func);
+      matchedFunc.func := func;
+    end if;
   end checkMatchingFunctions;
 
-  function resolveOverloadedVsDefaultConstructorAmbigutiy
-    input list<MatchedFunction> matchedFunctions;
-    output list<MatchedFunction> outMatches;
-  algorithm
-    // We have at least two exact matches. find the default constructor (if there is one) and remove it from the list
-    // so that it
-    // - doesn't cause ambiguities if there is only one other match left OR
-    // - it doesn't appear in the error messages in the case of more than one overloaded constructor matches.
-    outMatches := list(m for m guard not Function.isDefaultRecordConstructor(m.func) in matchedFunctions);
-  end resolveOverloadedVsDefaultConstructorAmbigutiy;
-
   function iteratorToDAE
     input tuple<InstNode, Expression> iter;
     output DAE.ReductionIterator diter;

Compiler/NFFrontEnd/NFConvertDAE.mo

@@ -453,19 +453,14 @@ algorithm
       list<DAE.Dimension> dims;
       list<DAE.Element> body;
 
-    case Equation.EQUALITY() guard Type.isComplex(eq.ty)
-      algorithm
-        e1 := Expression.toDAE(eq.lhs);
-        e2 := Expression.toDAE(eq.rhs);
-      then
-        DAE.Element.COMPLEX_EQUATION(e1, e2, eq.source) :: elements;
-
     case Equation.EQUALITY()
       algorithm
         e1 := Expression.toDAE(eq.lhs);
         e2 := Expression.toDAE(eq.rhs);
       then
-        DAE.Element.EQUATION(e1, e2, eq.source) :: elements;
+        (if Type.isComplex(eq.ty) then
+           DAE.Element.COMPLEX_EQUATION(e1, e2, eq.source) else
+           DAE.Element.EQUATION(e1, e2, eq.source)) :: elements;
 
     case Equation.CREF_EQUALITY()
       algorithm
@@ -605,7 +600,9 @@ algorithm
         e1 := Expression.toDAE(eq.lhs);
         e2 := Expression.toDAE(eq.rhs);
       then
-        DAE.Element.INITIALEQUATION(e1, e2, eq.source) :: elements;
+        (if Type.isComplex(eq.ty) then
+           DAE.Element.INITIAL_COMPLEX_EQUATION(e1, e2, eq.source) else
+           DAE.Element.INITIALEQUATION(e1, e2, eq.source)) :: elements;
 
     case Equation.ARRAY_EQUALITY()
       algorithm

Compiler/NFFrontEnd/NFFlatten.mo

@@ -83,6 +83,7 @@ import ElementSource;
 import Ceval = NFCeval;
 import NFTyping.ExpOrigin;
 import SimplifyExp = NFSimplifyExp;
+import Restriction = NFRestriction;
 
 public
 type FunctionTree = FunctionTreeImpl.Tree;

Compiler/NFFrontEnd/NFOperatorOverloading.mo

@@ -72,11 +72,9 @@ public
         checkOperatorConstructorOutput(f, Class.lastBaseClass(recordNode), ctor_path, info);
         recordNode := InstNode.cacheAddFunc(recordNode, f, false);
       end for;
-    else
-      // If it doesn't have an an overloaded constructor, construct a default
-      // record constructor and use that instead.
-      recordNode := Record.instDefaultConstructor(path, recordNode, info);
     end if;
+
+    recordNode := Record.instDefaultConstructor(path, recordNode, info);
   end instConstructor;
 
   function instOperatorFunctions

Compiler/NFFrontEnd/NFRestriction.mo

@@ -125,14 +125,24 @@ public
 
   function isRecord
     input Restriction res;
-    output Boolean isFunction;
+    output Boolean isRecord;
   algorithm
-    isFunction := match res
+    isRecord := match res
       case RECORD() then true;
       else false;
     end match;
   end isRecord;
 
+  function isOperatorRecord
+    input Restriction res;
+    output Boolean isOpRecord;
+  algorithm
+    isOpRecord := match res
+      case RECORD() then res.isOperator;
+      else false;
+    end match;
+  end isOperatorRecord;
+
   function isType
     input Restriction res;
     output Boolean isType;