Adjust inout to be implemented with a single argument

compiler/AST/primitive.cpp

@@ -1085,6 +1085,8 @@ initPrimitive() {
   prim_def(PRIM_TO_NILABLE_CLASS, "to nilable class", returnInfoToNilable, false, false);
   prim_def(PRIM_TO_NON_NILABLE_CLASS, "to non nilable class", returnInfoToNonNilable, false, false);
 
+  prim_def(PRIM_SET_ALIASING_ARRAY_ON_TYPE, "set aliasing array on type", returnInfoVoid, false, false);
+
   prim_def(PRIM_NEEDS_AUTO_DESTROY, "needs auto destroy", returnInfoBool, false, false);
 
   // if the argument is a value, mark it with "no auto destroy"

compiler/AST/symbol.cpp

@@ -2137,10 +2137,17 @@ const char* toString(ArgSymbol* arg) {
     case INTENT_TYPE:            intent = "type ";      break;
   }
 
+  const char* retval = "";
   if (arg->getValType() == dtAny || arg->getValType() == dtUnknown)
-    return astr(intent, arg->name);
+    retval = astr(intent, arg->name);
   else
-    return astr(intent, arg->name, ": ", toString(arg->getValType()));
+    retval = astr(intent, arg->name, ": ", toString(arg->getValType()));
+
+  if (developer  == true) {
+    retval = astr(retval, " [", istr(arg->id), "]");
+  }
+
+  return retval;
 }
 
 const char* toString(VarSymbol* var) {

compiler/AST/type.cpp

@@ -1236,6 +1236,24 @@ bool isDistImplType(Type* type)
   return isDerivedType(type, FLAG_BASE_DIST);
 }
 
+bool isAliasingArrayImplType(Type* t) {
+  return t->symbol->hasFlag(FLAG_ALIASING_ARRAY);
+}
+
+bool isAliasingArrayType(Type* t) {
+  if (t->symbol->hasFlag(FLAG_ARRAY)) {
+    AggregateType* at = toAggregateType(t);
+    INT_ASSERT(at);
+
+    Symbol* instanceField = at->getField("_instance", false);
+    if (instanceField) {
+      return isAliasingArrayImplType(instanceField->type);
+    }
+  }
+
+  return false;
+}
+
 static bool isDerivedType(Type* type, Flag flag)
 {
   AggregateType* at     =  NULL;

compiler/include/flags_list.h

@@ -145,7 +145,6 @@ symbolFlag( FLAG_FIRST_CLASS_FUNCTION_INVOCATION, npr, "first class function inv
 symbolFlag( FLAG_FN_RETARG, npr, "fn returns via _retArg", ncm )
 symbolFlag( FLAG_FOLLOWER_INDEX, npr, "follower index", "a variable representing a follower loop index" )
 symbolFlag( FLAG_FORMAL_TEMP, npr, "formal temp", "a formal temp requiring write-back for an out or inout argument" )
-symbolFlag( FLAG_FORMAL_TEMP_INOUT, npr, "formal temp inout", "a formal temp to back an inout argument" )
 symbolFlag( FLAG_FORMAL_TEMP_OUT, npr, "formal temp out", "a formal temp to back an out argument" )
 symbolFlag( FLAG_FORWARDING_FN , npr, "forwarding function" , ncm )
 symbolFlag( FLAG_FUNCTION_CLASS , npr, "function class" , "first-class function class representation" )
@@ -167,10 +166,6 @@ symbolFlag( FLAG_GLOBAL_VAR_BUILTIN, ypr, "global var builtin", "is accessible t
 symbolFlag( FLAG_HAS_POSTINIT , ypr, "has postinit" , "type that has a postinit method" )
 symbolFlag( FLAG_HAS_RUNTIME_TYPE , ypr, "has runtime type" , "type that has an associated runtime type" )
 
-// marks a hidden formal that appears after an inout argument.
-// the hidden formal covers the "out" part of the "inout".
-symbolFlag( FLAG_HIDDEN_FORMAL_INOUT , npr, "hidden formal for inout" , "a separate formal to implement the copy-back part of an inout argument" )
-
 symbolFlag( FLAG_IGNORE_RUNTIME_TYPE , ypr, "ignore runtime type" , "use the static type only in the return value" )
 symbolFlag( FLAG_IGNORE_IN_GLOBAL_ANALYSIS , ypr, "ignore in global analysis" , "ignore this function in global use-before-def analysis" )
 symbolFlag( FLAG_RVV, npr, "RVV", "variable is the return value variable" )
@@ -275,6 +270,7 @@ symbolFlag( FLAG_NO_CAPTURE_FOR_TASKING , npr, "no capture for tasking", "does n
 symbolFlag( FLAG_NO_CODEGEN , ypr, "no codegen" , "do not generate e.g. C code defining this symbol" )
 symbolFlag( FLAG_NO_COPY , ypr, "no copy" , "do not apply chpl__initCopy to initialization of a variable" )
 symbolFlag( FLAG_NO_COPY_RETURN, ypr, "no copy return", ncm)
+symbolFlag( FLAG_NO_COPY_RETURNS_OWNED, ypr, "no copy returns owned", ncm)
 symbolFlag( FLAG_NO_DEFAULT_FUNCTIONS , ypr, "no default functions" , ncm )
 symbolFlag( FLAG_NO_DOC, ypr, "no doc", "do not generate chpldoc documentation for this symbol" )
 symbolFlag( FLAG_NO_IMPLICIT_COPY , ypr, "no implicit copy" , "function does not require autoCopy/autoDestroy" )
@@ -450,7 +446,6 @@ symbolFlag( FLAG_TYPE_CUSTOM_ASSIGN , npr, "type uses custom =" , "type has user
 
 symbolFlag( FLAG_TYPE_FORMAL_FOR_OUT , npr, "type formal for out" , "stores the runtime type for an untyped out argument" )
 symbolFlag( FLAG_TYPE_VARIABLE , npr, "type variable" , "contains a type instead of a value" )
-symbolFlag( FLAG_UNALIAS_FN,  ypr, "unalias fn" , "function to copy array slices when assigning to a user variable")
 symbolFlag( FLAG_UNCHECKED_THROWS,  ypr, "unchecked throws" , "function throws but handling the errors is not required even in strict mode")
 symbolFlag( FLAG_UNREF_FN,  ypr, "unref fn" , "function to remove reference fields from tuples or copy array slices when returning")
 symbolFlag( FLAG_UNSAFE,  ypr, "unsafe" , "unsafe (disable lifetime and nilability checking)")

compiler/include/primitive_list.h

@@ -308,6 +308,8 @@
   PRIMITIVE_R(PRIM_TO_NILABLE_CLASS)
   PRIMITIVE_R(PRIM_TO_NON_NILABLE_CLASS)
 
+  PRIMITIVE_R(PRIM_SET_ALIASING_ARRAY_ON_TYPE)
+
   PRIMITIVE_G(PRIM_INVARIANT_START)
   PRIMITIVE_G(PRIM_NO_ALIAS_SET)
   PRIMITIVE_G(PRIM_COPIES_NO_ALIAS_SET)

compiler/include/resolution.h

@@ -226,7 +226,14 @@ FnSymbol* getAutoCopyForType(Type* type);   // requires hasAutoCopyForType()==tr
 void      getAutoCopyTypeKeys(Vec<Type*>& keys);
 FnSymbol* getAutoCopy(Type* t);             // returns NULL if there are none
 FnSymbol* getAutoDestroy(Type* t);          //  "
-FnSymbol* getUnalias(Type* t);
+
+FnSymbol* getInitCopyDuringResolution(Type* t);
+
+// Some types should change to another type when assigned into a variable.
+// This function returns that type.
+// Examples: array view -> array; sync int -> int; iterator -> array
+Type* getCopyTypeDuringResolution(Type* t);
+
 FnSymbol* getCoerceMoveFromCoerceCopy(FnSymbol* coerceCopyFn);
 const char* getErroneousCopyError(FnSymbol* fn);
 void markCopyErroneous(FnSymbol* fn, const char* err);
@@ -312,7 +319,14 @@ Type* getInstantiationType(Type* actualType, Symbol* actualSym,
                            Type* formalType, Symbol* formalSym,
                            Expr* ctx,
                            bool allowCoercion=true,
-                           bool implicitBang=false);
+                           bool implicitBang=false,
+                           bool inOrOtherValue=false);
+
+// in/out/inout but excluding formals to chpl__coerceMove etc
+bool inOrOutFormalNeedingCopyType(ArgSymbol* formal);
+
+bool isCallExprTemporary(Symbol* fromSym);
+bool isTemporaryFromNoCopyReturn(Symbol* fromSym);
 
 void resolveIfExprType(CondStmt* stmt);
 

compiler/include/type.h

@@ -471,6 +471,9 @@ bool isRecordWrappedType(const Type* t);
 bool isDomImplType(Type* t);
 bool isArrayImplType(Type* t);
 bool isDistImplType(Type* t);
+bool isAliasingArrayImplType(Type* t);
+bool isAliasingArrayType(Type* t);
+
 bool isManagedPtrType(const Type* t);
 Type* getManagedPtrBorrowType(const Type* t);
 AggregateType* getManagedPtrManagerType(Type* t);

compiler/optimizations/noAliasSets.cpp

@@ -96,16 +96,7 @@ void addNoAliasSetForFormal(ArgSymbol* arg,
 
 static
 bool isNonAliasingArrayImplType(Type* t) {
-  // Array views are marked with this flag because they
-  // can alias other arrays.
-  if (t->symbol->hasFlag(FLAG_ALIASING_ARRAY))
-    return false;
-
-  // Non-array view array classes
-  if (isArrayImplType(t))
-    return true;
-
-  return false;
+  return isArrayImplType(t) && !isAliasingArrayImplType(t);
 }
 
 static

compiler/passes/normalize.cpp

@@ -63,8 +63,6 @@ static void        makeExportWrapper(FnSymbol* fn);
 
 static void        fixupArrayFormals(FnSymbol* fn);
 
-static void        fixupInoutFormals(FnSymbol* fn);
-
 static bool        includesParameterizedPrimitive(FnSymbol* fn);
 static void        replaceFunctionWithInstantiationsOfPrimitive(FnSymbol* fn);
 static void        fixupQueryFormals(FnSymbol* fn);
@@ -171,8 +169,6 @@ void normalize() {
         updateInitMethod(fn);
       }
     }
-
-    fixupInoutFormals(fn);
   }
 
   normalizeBase(theProgram, true);
@@ -3014,8 +3010,7 @@ static void updateVariableAutoDestroy(DefExpr* defExpr) {
       var->hasFlag(FLAG_PARAM)           == false && // Note 1.
       var->hasFlag(FLAG_REF_VAR)         == false &&
 
-      fn->_this                          != var   && // Note 2.
-      fn->hasFlag(FLAG_INIT_COPY_FN)     == false) { // Note 3.
+      fn->_this                          != var) {   // Note 2.
 
     // Note that if the DefExpr is at module scope, the auto-destroy
     // for it will end up in the module deinit function.
@@ -3031,19 +3026,6 @@ static void updateVariableAutoDestroy(DefExpr* defExpr) {
 // Note 2: "this" should be passed by reference.  Then, no constructor call
 // is made, and therefore no autodestroy call is needed.
 
-// Note 3: If a record arg to an init copy function is passed by value,
-// infinite recursion would ensue.  This is an unreachable case (assuming that
-// magic conversions from R -> ref R are removed and all existing
-// implementations of chpl__initCopy are rewritten using "ref" or "const ref"
-// intent on the record argument).
-
-
-// Note 4: These two cases should be regularized.  Either the copy constructor
-// should *always* be called (and the corresponding destructor always called),
-// or we should ensure that the destructor is called only if a constructor is
-// called on the same variable.  The latter case is an optimization, so the
-// simplest implementation calls the copy-constructor in both cases.
-
 /************************************* | **************************************
 *                                                                             *
 *                                                                             *
@@ -3555,36 +3537,6 @@ static void fixupArrayElementExpr(FnSymbol*                    fn,
   }
 }
 
-/************************************* | **************************************
-*                                                                             *
-* Add a second formal for each inout formal so that later parts of            *
-* compilation can handle the `in` and `out` parts separately.                 *
-*                                                                             *
-************************************** | *************************************/
-static void fixupInoutFormals(FnSymbol* fn) {
-  for_formals(formal, fn) {
-    if (formal->intent == INTENT_INOUT) {
-      if (fn->hasFlag(FLAG_EXTERN)) {
-        formal->originalIntent = INTENT_REF;
-        formal->intent = INTENT_REF;
-      } else if (formal->variableExpr != NULL) {
-        USR_FATAL_CONT(formal, "inout varargs not currently supported");
-        formal->originalIntent = INTENT_REF;
-        formal->intent = INTENT_REF;
-      } else {
-        // Add a hidden out formal after the inout one.
-        ArgSymbol* outFormal = formal->copy();
-        outFormal->name = astr(outFormal->name, "_out");
-        outFormal->originalIntent = INTENT_OUT;
-        outFormal->intent = INTENT_OUT;
-        outFormal->addFlag(FLAG_HIDDEN_FORMAL_INOUT);
-        outFormal->defaultExpr = new BlockStmt(new SymExpr(formal));
-        DefExpr* def = new DefExpr(outFormal);
-        formal->defPoint->insertAfter(def);
-      }
-    }
-  }
-}
 
 /************************************* | **************************************
 *                                                                             *

compiler/passes/splitInit.cpp

@@ -650,7 +650,8 @@ static bool canCopyElideVar(Symbol* rhs) {
 static bool canCopyElideCall(CallExpr* call, Symbol* lhs, Symbol* rhs) {
   return canCopyElideVar(rhs) &&
          rhs->getValType() == lhs->getValType() &&
-         rhs->defPoint->parentSymbol == call->parentSymbol;
+         rhs->defPoint->parentSymbol == call->parentSymbol &&
+         !(isCallExprTemporary(rhs) && isTemporaryFromNoCopyReturn(rhs));
 }
 
 // returns true if there was an unconditional return

compiler/resolution/AutoDestroyScope.cpp

@@ -98,16 +98,14 @@ void AutoDestroyScope::addFormalTemps() {
   if (fn->hasFlag(FLAG_EXTERN))
     return;
 
-  bool anyOutInout = false;
+  bool anyOut = false;
   for_formals(formal, fn) {
     if (formal->intent == INTENT_OUT ||
-        formal->originalIntent == INTENT_OUT ||
-        formal->intent == INTENT_INOUT ||
-        formal->originalIntent == INTENT_INOUT) {
-      anyOutInout = true;
+        formal->originalIntent == INTENT_OUT) {
+      anyOut = true;
     }
   }
-  if (anyOutInout) {
+  if (anyOut) {
     // Go through the function epilogue looking for
     // write-backs to args from FORMAL_TEMP variables
     LabelSymbol* epilogue = fn->getEpilogueLabel();
@@ -118,8 +116,7 @@ void AutoDestroyScope::addFormalTemps() {
       next = cur->next;
       if (VarSymbol* var = findFormalTempAssignBack(cur)) {
         CallExpr* call = toCallExpr(cur);
-        INT_ASSERT(var->hasFlag(FLAG_FORMAL_TEMP_INOUT) ||
-                   var->hasFlag(FLAG_FORMAL_TEMP_OUT));
+        INT_ASSERT(var->hasFlag(FLAG_FORMAL_TEMP_OUT));
         INT_ASSERT(call);
         mFormalTempActions.push_back(call);
         call->remove(); // will be added back in just before destroying
@@ -437,8 +434,7 @@ void AutoDestroyScope::variablesDestroy(Expr*      refStmt,
       if (var != NULL && var != excludeVar && ignored.count(var) == 0) {
         if (startingScope->isVariableInitialized(var)) {
           bool outIntentFormalReturn = forErrorReturn == false &&
-                                       (var->hasFlag(FLAG_FORMAL_TEMP_OUT) ||
-                                        var->hasFlag(FLAG_FORMAL_TEMP_INOUT));
+                                       var->hasFlag(FLAG_FORMAL_TEMP_OUT);
           // No deinit for out formal returns - deinited at call site
           if (outIntentFormalReturn == false)
             deinitialize(insertBeforeStmt, NULL, var);