Adjust array copy initialization to avoid default-init/assign

compiler/AST/AggregateType.cpp

@@ -653,22 +653,7 @@ bool AggregateType::hasInitializers() const {
 }
 
 bool AggregateType::hasPostInitializer() const {
-  bool retval = false;
-
-  // If there is postinit() it is defined on the defining type
-  if (instantiatedFrom == NULL) {
-    int size = methods.n;
-
-    for (int i = 0; i < size && retval == false; i++) {
-      if (methods.v[i] != NULL)
-        retval = methods.v[i]->isPostInitializer();
-    }
-
-  } else {
-    retval = instantiatedFrom->hasPostInitializer();
-  }
-
-  return retval;
+  return symbol->hasFlag(FLAG_HAS_POSTINIT);
 }
 
 bool AggregateType::hasUserDefinedInitEquals() const {
@@ -2312,9 +2297,11 @@ void AggregateType::fieldToArg(FnSymbol*              fn,
 
         if (LoopExpr* fe = toLoopExpr(defPoint->init)) {
           if (field->isType() == false) {
-            CallExpr* copy = new CallExpr("chpl__initCopy");
-            defPoint->init->replace(copy);
-            copy->insertAtTail(fe);
+            if (defPoint->exprType == NULL) {
+              CallExpr* copy = new CallExpr(astr_initCopy);
+              defPoint->init->replace(copy);
+              copy->insertAtTail(fe);
+            }
           }
         }
 
@@ -2366,19 +2353,13 @@ void AggregateType::fieldToArg(FnSymbol*              fn,
             fieldToArgType(defPoint, arg);
 
             arg->defaultExpr = new BlockStmt(defPoint->init->copy());
+            arg->typeExpr = new BlockStmt(defPoint->exprType->copy());
 
           } else {
             fieldToArgType(defPoint, arg);
 
-            CallExpr* def    = new CallExpr(PRIM_DEFAULT_INIT_FIELD,
-                    // It would be easiest to just put 'field' here, however
-                    // it is replaced with 'arg' in buildDefaultInitializer().
-                    new_StringSymbol(field->defPoint->parentSymbol->name),
-                                            new_StringSymbol(field->name),
-                                            defPoint->exprType->copy(),
-                                            defPoint->init->copy());
-
-            arg->defaultExpr = new BlockStmt(def);
+            arg->defaultExpr = new BlockStmt(defPoint->init->copy());
+            arg->typeExpr = new BlockStmt(defPoint->exprType->copy());
           }
         }
 

compiler/AST/CallExpr.cpp

@@ -847,7 +847,6 @@ bool isInitOrReturn(CallExpr* call, SymExpr*& lhsSe, CallExpr*& initOrCtor)
              call->isPrimitive(PRIM_INIT_VAR_SPLIT_DECL) ||
              call->isPrimitive(PRIM_INIT_VAR) ||
              call->isPrimitive(PRIM_INIT_VAR_SPLIT_INIT) ||
-             call->isPrimitive(PRIM_DEFAULT_INIT_FIELD) ||
              call->isPrimitive(PRIM_INIT_FIELD)) {
     lhsSe = toSymExpr(call->get(1));
     initOrCtor = NULL;

compiler/AST/FnSymbol.cpp

@@ -907,11 +907,11 @@ bool FnSymbol::isCompilerGenerated() const {
 }
 
 bool FnSymbol::isInitializer() const {
-  return isMethod() == true && strcmp(name, "init")     == 0;
+  return isMethod() == true && name == astrInit;
 }
 
 bool FnSymbol::isPostInitializer() const {
-  return isMethod() == true && strcmp(name, "postinit") == 0;
+  return isMethod() == true && name == astrPostinit;
 }
 
 bool FnSymbol::isDefaultInit() const {

compiler/AST/primitive.cpp

@@ -654,9 +654,6 @@ initPrimitive() {
   // dst, src. PRIM_MOVE can set a reference.
   prim_def(PRIM_MOVE, "move", returnInfoVoid, false);
 
-  // dst, aggregate name, field name, type to default-init, value to init from
-  prim_def(PRIM_DEFAULT_INIT_FIELD, "default init field", returnInfoVoid);
-
   // dst, type to default-init
   prim_def(PRIM_DEFAULT_INIT_VAR, "default init var", returnInfoVoid);
 
@@ -1081,6 +1078,10 @@ initPrimitive() {
 
   prim_def(PRIM_NEEDS_AUTO_DESTROY, "needs auto destroy", returnInfoBool, false, false);
 
+  // if the argument is a value, mark it with "no auto destroy"
+  // (no effect on a reference)
+  prim_def(PRIM_STEAL, "steal", returnInfoFirst, false, false);
+
   // Indicates the end of a statement. This is important for the
   // deinitialization location for some variables.
   // Any arguments are SymExprs to user variables that should be alive until

compiler/AST/symbol.cpp

@@ -1985,6 +1985,7 @@ const char* astrInit = NULL;
 const char* astrInitEquals = NULL;
 const char* astrNew = NULL;
 const char* astrDeinit = NULL;
+const char* astrPostinit = NULL;
 const char* astrTag = NULL;
 const char* astrThis = NULL;
 const char* astrSuper = NULL;
@@ -1999,6 +2000,10 @@ const char* astr_loopexpr_iter = NULL;
 const char* astrPostfixBang = NULL;
 const char* astrBorrow = NULL;
 const char* astr_init_coerce_tmp = NULL;
+const char* astr_autoCopy = NULL;
+const char* astr_initCopy = NULL;
+const char* astr_coerceCopy = NULL;
+const char* astr_coerceMove = NULL;
 
 void initAstrConsts() {
   astrSassign = astr("=");
@@ -2016,6 +2021,7 @@ void initAstrConsts() {
   astrInitEquals = astr("init=");
   astrNew     = astr("_new");
   astrDeinit  = astr("deinit");
+  astrPostinit  = astr("postinit");
   astrTag     = astr("tag");
   astrThis    = astr("this");
   astrSuper   = astr("super");
@@ -2033,6 +2039,11 @@ void initAstrConsts() {
 
   astrBorrow = astr("borrow");
   astr_init_coerce_tmp = astr("init_coerce_tmp");
+
+  astr_autoCopy = astr("chpl__autoCopy");
+  astr_initCopy = astr("chpl__initCopy");
+  astr_coerceCopy = astr("chpl__coerceCopy");
+  astr_coerceMove = astr("chpl__coerceMove");
 }
 
 /************************************* | **************************************

compiler/include/flags_list.h

@@ -80,6 +80,7 @@ symbolFlag( FLAG_CHPL__ITER_NEWSTYLE , npr, "chpl__iter_newstyle", ncm )
 symbolFlag( FLAG_COBEGIN_OR_COFORALL , npr, "cobegin or coforall" , ncm )
 symbolFlag( FLAG_COBEGIN_OR_COFORALL_BLOCK , npr, "cobegin or coforall block" , ncm )
 symbolFlag( FLAG_COERCE_TEMP , npr, "coerce temp" , "a temporary that was stores the result of a coercion" )
+symbolFlag( FLAG_COERCE_FN,  ypr, "coerce fn" , "coerce copy/move function" )
 symbolFlag( FLAG_CODEGENNED , npr, "codegenned" , "code has been generated for this type" )
 symbolFlag( FLAG_COFORALL_INDEX_VAR , npr, "coforall index var" , ncm )
 symbolFlag( FLAG_COMMAND_LINE_SETTING , ypr, "command line setting" , ncm )
@@ -162,6 +163,7 @@ symbolFlag( FLAG_GET_FUNCTION_NAME, ypr, "get function name", "replace calls to
 symbolFlag( FLAG_GET_MODULE_NAME, ypr, "get module name", "replace calls to this function with the name of the module the call was in" )
 
 symbolFlag( FLAG_GLOBAL_TYPE_SYMBOL, ypr, "global type symbol", "is accessible through a global type variable")
+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" )
 symbolFlag( FLAG_RVV, npr, "RVV", "variable is the return value variable" )
 symbolFlag( FLAG_YVV, npr, "YVV", "variable is a yield value variable" )
@@ -406,6 +408,7 @@ symbolFlag( FLAG_UNCHECKED_THROWS,  ypr, "unchecked throws" , "function throws b
 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)")
 symbolFlag( FLAG_IGNORE_TRANSFER_ERRORS,  ypr, "ignore transfer errors" , "ignore errors for ownership transfer from non-nilable owned" )
+symbolFlag( FLAG_FIND_USER_LINE,  ypr, "find user line" , "report errors with user line number")
 symbolFlag( FLAG_USER_VARIABLE_NAME,  npr, "user variable name" , "temporary uses name of user variable")
 symbolFlag( FLAG_VECTORIZE_YIELDING_LOOPS, ypr, "vectorize yielding loops", "used to explicitly vectorize yielding loops in iterators" )
 symbolFlag( FLAG_VIRTUAL , npr, "virtual" , ncm )

compiler/include/primitive_list.h

@@ -38,7 +38,6 @@
   PRIMITIVE_G(PRIM_NOOP)
   PRIMITIVE_G(PRIM_MOVE)
 
-  PRIMITIVE_R(PRIM_DEFAULT_INIT_FIELD)
   PRIMITIVE_R(PRIM_DEFAULT_INIT_VAR)
   PRIMITIVE_R(PRIM_INIT_FIELD)
   PRIMITIVE_R(PRIM_INIT_VAR)
@@ -270,6 +269,7 @@
   PRIMITIVE_R(PRIM_HAS_DEFAULT_VALUE)
   PRIMITIVE_R(PRIM_NEEDS_AUTO_DESTROY)
   PRIMITIVE_R(PRIM_END_OF_STATEMENT)
+  PRIMITIVE_R(PRIM_STEAL)
   PRIMITIVE_R(PRIM_AUTO_DESTROY_RUNTIME_TYPE)
 
   PRIMITIVE_R(PRIM_GET_RUNTIME_TYPE_FIELD)

compiler/include/resolution.h

@@ -226,6 +226,7 @@ void      getAutoCopyTypeKeys(Vec<Type*>& keys);
 FnSymbol* getAutoCopy(Type* t);             // returns NULL if there are none
 FnSymbol* getAutoDestroy(Type* t);          //  "
 FnSymbol* getUnalias(Type* t);
+FnSymbol* getCoerceMoveFromCoerceCopy(FnSymbol* coerceCopyFn);
 const char* getErroneousCopyError(FnSymbol* fn);
 void markCopyErroneous(FnSymbol* fn, const char* err);
 
@@ -328,4 +329,8 @@ void startGenerousResolutionForErrors();
 bool inGenerousResolutionForErrors();
 void stopGenerousResolutionForErrors();
 
+
+// Return the array element type, or NULL if not an array
+Type* arrayElementType(Type* arrayType);
+
 #endif

compiler/include/symbol.h

@@ -694,6 +694,7 @@ extern const char* astrInit;
 extern const char* astrInitEquals;
 extern const char* astrNew;
 extern const char* astrDeinit;
+extern const char* astrPostinit;
 extern const char* astrTag;
 extern const char* astrThis;
 extern const char* astrSuper;
@@ -708,6 +709,11 @@ extern const char* astr_loopexpr_iter;
 extern const char* astrPostfixBang;
 extern const char* astrBorrow;
 extern const char* astr_init_coerce_tmp;
+extern const char* astr_autoCopy;
+extern const char* astr_initCopy;
+extern const char* astr_coerceCopy;
+extern const char* astr_coerceCopy;
+extern const char* astr_coerceMove;
 
 void initAstrConsts();
 

compiler/optimizations/optimizeForallUnorderedOps.cpp

@@ -196,7 +196,12 @@ static
 bool exprIsOptimizable(BlockStmt* loop, Expr* lastStmt,
                         LifetimeInformation* lifetimeInfo) {
   if (CallExpr* call = toCallExpr(lastStmt)) {
-    if (call->isNamed("=")) {
+    if (call->isPrimitive(PRIM_ASSIGN)) {
+      Symbol* lhs = toSymExpr(call->get(1))->symbol();
+      Expr* rhs = call->get(2);
+      if (lhs->getValType() == rhs->getValType()) // same type
+        return true;
+    } else if (call->isNamed("=")) {
       Symbol* lhs = toSymExpr(call->get(1))->symbol();
       Symbol* rhs = toSymExpr(call->get(2))->symbol();
       if (lhs->getValType() == rhs->getValType()) // same type
@@ -872,16 +877,17 @@ static bool isOptimizableAssignStmt(Expr* stmt, BlockStmt* loop) {
 
 
 static void transformAssignStmt(Expr* stmt) {
+  SET_LINENO(stmt);
+
   CallExpr* call = toCallExpr(stmt);
 
   INT_ASSERT(call->isPrimitive(PRIM_ASSIGN));
 
   Symbol* lhs = toSymExpr(call->get(1))->symbol();
-  Symbol* rhs = toSymExpr(call->get(2))->symbol();
-
+  Expr* rhs = call->get(2);
   CallExpr* callToRemove = NULL;
 
-  if (rhs->isRef() == false) {
+  if (isSymExpr(rhs) && rhs->isRef() == false) {
     // Find a pattern like
     //
     // move rhs PRIM_DEREF rhsRef
@@ -892,13 +898,14 @@ static void transformAssignStmt(Expr* stmt) {
     //
     // PRIM_ASSIGN lhs rhsRef
     //
+    Symbol* rhsSym = toSymExpr(rhs)->symbol();
     Symbol* rhsRef = NULL;
     CallExpr* prevCall = toCallExpr(call->prev);
     if (prevCall != NULL) {
       if (prevCall->isPrimitive(PRIM_MOVE) ||
           prevCall->isPrimitive(PRIM_ASSIGN)) {
         Symbol* prevLhs = toSymExpr(prevCall->get(1))->symbol();
-        if (prevLhs == rhs) {
+        if (prevLhs == rhsSym) {
           if (CallExpr* rhsCall = toCallExpr(prevCall->get(2))) {
             if (rhsCall->isPrimitive(PRIM_DEREF))
               rhsRef = toSymExpr(rhsCall->get(1))->symbol();
@@ -912,20 +919,19 @@ static void transformAssignStmt(Expr* stmt) {
 
     if (rhsRef != NULL && prevCall != NULL) {
       callToRemove = prevCall;
-      rhs = rhsRef;
+      rhs = new SymExpr(rhsRef);
     }
   }
 
   if (lhs->isRef() && rhs->isRef()) {
-    SET_LINENO(call);
     // add the call to getput
     if (fReportOptimizeForallUnordered) {
       if (developer || printsUserLocation(call)) {
         USR_PRINT(call, "Optimized assign to be unordered");
       }
     }
 
-    call->insertBefore(new CallExpr(PRIM_UNORDERED_ASSIGN, lhs, rhs));
+    call->insertBefore(new CallExpr(PRIM_UNORDERED_ASSIGN, lhs, rhs->copy()));
     call->remove();
     if (callToRemove)
       callToRemove->remove();

compiler/passes/InitNormalize.cpp

@@ -493,6 +493,9 @@ Expr* InitNormalize::genericFieldInitTypeInference(Expr*    insertBefore,
 Expr* InitNormalize::fieldInitTypeWoutInit(Expr*    insertBefore,
                                            DefExpr* field) const {
 
+  if (field->sym->hasFlag(FLAG_NO_INIT))
+    return NULL;
+
   SET_LINENO(insertBefore);
 
   Type* type = field->sym->type;

compiler/passes/buildDefaultFunctions.cpp

@@ -1516,7 +1516,7 @@ static void buildUnionAssignmentFunction(AggregateType* ct) {
 ************************************** | *************************************/
 
 static void checkNotPod(AggregateType* at) {
-  if (functionExists("chpl__initCopy", at) == NULL) {
+  if (functionExists(astr_initCopy, at) == NULL) {
 
     if (at->hasUserDefinedInitEquals()) {
       at->symbol->addFlag(FLAG_NOT_POD);

compiler/passes/checkResolved.cpp

@@ -512,6 +512,10 @@ checkBadAddrOf(CallExpr* call)
 
         bool rhsType = rhs->symbol()->hasFlag(FLAG_TYPE_VARIABLE);
         bool rhsParam = rhs->symbol()->isParameter();
+
+        bool rhsExprTemp = rhs->symbol()->hasFlag(FLAG_EXPR_TEMP) &&
+                           !rhs->symbol()->type->symbol->hasFlag(FLAG_ARRAY);
+
         // Also detect runtime type variables
         if (rhs->symbol()->type->symbol->hasFlag(FLAG_RUNTIME_TYPE_VALUE))
           rhsType = true;
@@ -521,8 +525,7 @@ checkBadAddrOf(CallExpr* call)
         } else if (lhsRef && rhsParam) {
           USR_FATAL_CONT(call, "Cannot set a reference to a param variable.");
         } else if (lhsRef && !lhsConst) {
-          if (rhs->symbol()->hasFlag(FLAG_EXPR_TEMP) ||
-              rhs->symbol()->isConstant()) {
+          if (rhsExprTemp || rhs->symbol()->isConstant()) {
             USR_FATAL_CONT(call, "Cannot set a non-const reference to a const variable.");
           }
         }

compiler/passes/initializerRules.cpp

@@ -1135,6 +1135,30 @@ static bool isSymbolThis(Expr* expr) {
   return retval;
 }
 
+// returns true if there is a postinit defined on the type
+// and in that event adds FLAG_HAS_POSTINIT to the type symbol
+static bool findPostinitAndMark(AggregateType* at) {
+  bool retval = false;
+
+  // If there is postinit() it is defined on the defining type
+  if (at->instantiatedFrom == NULL) {
+    int size = at->methods.n;
+
+    for (int i = 0; i < size && retval == false; i++) {
+      if (at->methods.v[i] != NULL)
+        retval = at->methods.v[i]->isPostInitializer();
+    }
+
+  } else {
+    retval = findPostinitAndMark(at->instantiatedFrom);
+  }
+
+  if (retval)
+    at->symbol->addFlag(FLAG_HAS_POSTINIT);
+
+  return retval;
+}
+
 //
 // Builds the list of AggregateTypes in the hierarchy of `at` that have or
 // require a postinit.
@@ -1156,14 +1180,14 @@ static bool buildPostInitChain(AggregateType* at,
   if (at == dtObject) {
     ret = false;
   } else if (at->isRecord()) {
-    if (at->hasPostInitializer()) {
+    if (findPostinitAndMark(at)) {
       chain.push_back(at);
       ret = true;
     }
   } else if (parent != NULL && buildPostInitChain(parent, chain) == true) {
     ret = true;
     chain.push_back(at);
-  } else if (at->hasPostInitializer()) {
+  } else if (findPostinitAndMark(at)) {
     ret = true;
     chain.push_back(at);
   }
@@ -1415,6 +1439,8 @@ static int insertPostInit(AggregateType* at, bool insertSuper) {
     buildPostInit(at);
   }
 
+  at->symbol->addFlag(FLAG_HAS_POSTINIT);
+
   return ret;
 }