Fixed field binding bug

Author: christerswahn

proto/autotest/lang/arraybasictest.tx

@@ -8,19 +8,13 @@ ret_array()->&[]UByte {
     s : [4]UByte = FOO_STR;
     t : &[]UByte = FOO_STR;
     #experr 1: u : [4]UByte = t^;  ## TODO: support dynamically checked array initializer assignment
-    puts(s);
     assert s.C == 4;
     assert t.C == 4;
     return t;
 }
 
-puts(cstr : &[]UByte) {
-    tx.c.puts(cstr);
-}
-
 basic_array_syntax()->Int {
     ra := ret_array();
-    puts( ra );
     assert ra.C == 4;
 
     a : ~Array<~UByte,10>;
@@ -30,9 +24,9 @@ basic_array_syntax()->Int {
     b[1] = c[1];
     b[2] = c[0];
     b[3] = UByte(0);
-    puts(b);  ## expect "321"
+    ##puts(b);  ## expect "321"
     a = b;
-    puts(a);  ## expect "321"
+    ##puts(a);  ## expect "321"
     return c[2]-48;  ## 48 is ASCII '0'
 }
 
@@ -53,7 +47,7 @@ array_modifiability() {
     #experr: setelem(crcs, 2, 'C');
     #experr: setelem(mrcs, 2, 'C');
 
-    puts(mrcs);  ## expect "cst"
+    ##puts(mrcs);  ## expect "cst"
 
     ms : ~[4]~UByte = c"mod";
     crms : &~[]UByte = &ms;   ## explicit reference required
@@ -71,16 +65,16 @@ array_modifiability() {
     #experr: mrms = crcs;
     #experr: mrms = mrcs;
 
-    puts(mrms);  ## expect "ABC"
+    ##puts(mrms);  ## expect "ABC"
 
     ms = c"qqq";
-    puts(mrms);  ## expect "qqq"
+    ##puts(mrms);  ## expect "qqq"
 
     ##crms^ = mrcs^;  ## TODO: dynamic concrete type resolution of array sizes?
     crms_ : &~[4]UByte = &ms;
     mrcs_ : ~&[4]UByte = cs;
     crms_^ = mrcs_^;
-    puts(ms);  ## expect "cst"
+    ##puts(ms);  ## expect "cst"
 
     conststr := c"1234567890";
     assert conststr.C == 11;

proto/src/ast/ast_fielddef_codegen.cpp

@@ -39,16 +39,17 @@ void TxLocalFieldDefNode::code_gen_field( LlvmGenerationContext& context, GenSco
     ASSERT( this->declaration, "NULL declaration in " << this );
     ASSERT( this->declaration->get_storage() == TXS_STACK, "Local field gen can only apply to TX_STACK storage fields: " << this );
 
-    // If init expression does a stack allocation of this field's type (instance-equivalent type),
+    // If init expression performs a stack allocation (unbound) of this field's type (instance-equivalent type),
     // this field shall bind to that allocation.
 
     auto acttype = this->qtype();
     Value* fieldPtrV;
     if ( this->initExpression ) {
-        if ( this->initExpression->get_storage() == TXS_STACK ) {
+        if ( this->initExpression->get_storage() == TXS_UNBOUND_STACK ) {
             fieldPtrV = this->initExpression->code_gen_addr( context, scope );
         }
         else {
+            // (if storage is TXS_STACK, we allocate new stack space for making copy of already bound stack value)
             fieldPtrV = acttype->gen_alloca( context, scope, this->declaration->get_symbol()->get_name() );
             // create implicit assignment statement
             if ( this->cachedConstantInitializer )
@@ -184,8 +185,7 @@ void TxNonLocalFieldDefNode::inner_code_gen_field( LlvmGenerationContext& contex
         // just a type definition; field storage isn't created until parent object is allocated
         return;
 
-    case TXS_NOSTORAGE:
-    case TXS_STACK:
+    default:
         THROW_LOGIC( "TxFieldDeclNode can not apply to fields with storage " << fieldDecl->get_storage() << ": " << fieldDecl );
     }
 }

proto/src/ast/expr/ast_exprs.hpp

@@ -275,7 +275,7 @@ class TxStackConstructionNode : public TxMakeObjectNode {
 
     virtual TxFieldStorage get_storage() const override {
         // performs stack allocation unless this is an inlined value expression
-        return ( this->initializationExpression ? TXS_NOSTORAGE : TXS_STACK );
+        return ( this->initializationExpression ? TXS_NOSTORAGE : TXS_UNBOUND_STACK );
     }
 
     virtual llvm::Value* code_gen_dyn_value( LlvmGenerationContext& context, GenScope* scope ) const override;

proto/src/ast/expr/ast_exprs_codegen.cpp

@@ -107,7 +107,8 @@ Value* TxFunctionCallNode::code_gen_dyn_value( LlvmGenerationContext& context, G
 
 Value* TxFunctionCallNode::code_gen_dyn_address( LlvmGenerationContext& context, GenScope* scope ) const {
     TRACE_CODEGEN( this, context );
-    if ( this->get_storage() == TXS_STACK ) {  // only true if there is an inlined expression
+    auto storage = this->get_storage();
+    if ( storage == TXS_STACK || storage == TXS_UNBOUND_STACK ) {  // only true if there is an inlined expression
         return this->inlinedExpression->code_gen_dyn_address( context, scope );
     }
     else {

proto/src/ast/expr/ast_range.hpp

@@ -97,7 +97,7 @@ class TxERangeLitNode final : public TxTypeDefiningValExprNode {
 //    }
 
     virtual TxFieldStorage get_storage() const {
-        return TXS_STACK;
+        return TXS_UNBOUND_STACK;
     }
 
     virtual llvm::Value* code_gen_dyn_address( LlvmGenerationContext& context, GenScope* scope ) const override;

proto/src/ast/expr/ast_string.hpp

@@ -84,7 +84,7 @@ class TxConcatenateStringsNode : public TxExpressionNode {
     }
 
     virtual TxFieldStorage get_storage() const {
-        return TXS_STACK;
+        return TXS_UNBOUND_STACK;
     }
 
     virtual llvm::Value* code_gen_dyn_value( LlvmGenerationContext& context, GenScope* scope ) const override;
@@ -142,7 +142,7 @@ class TxStringFormatNode : public TxExpressionNode {
     }
 
     virtual TxFieldStorage get_storage() const {
-        return TXS_STACK;
+        return TXS_UNBOUND_STACK;
     }
 
     virtual llvm::Value* code_gen_dyn_value( LlvmGenerationContext& context, GenScope* scope ) const override;

proto/src/symbol/declaration.hpp

@@ -81,6 +81,7 @@ class TxFieldDeclaration : public TxEntityDeclaration {
               storage( storage ),
               dataspace( dataspace ) {
         ASSERT( ( declFlags | LEGAL_FIELD_DECL_FLAGS ) == LEGAL_FIELD_DECL_FLAGS, "Illegal field declFlags: " << declFlags );
+        ASSERT( storage != TXS_NOSTORAGE && storage != TXS_UNBOUND_STACK, "Illegal field storage: " << storage );
     }
 
     virtual TxFieldDefiningNode* get_definer() const override {

proto/src/tx_field_storage.hpp

@@ -2,17 +2,18 @@
 
 #include <string>
 
-/** Specifies the storage type for a field entity.
+/** Specifies the storage type for a field entity / value.
  * GLOBAL are globally declared fields, i.e. outside of any type definition.
  * STATIC and VIRTUAL are statically allocated fields within a type definition.
  * VIRTUAL fields are like STATIC but subject to polymorphic lookup.
  * INSTANCEMETHOD is a special case, where the function pointer is static/virtual and the 'self' ref is provided in runtime
  * INSTANCE fields are members of type instances (i.e. object members).
- * STACK fields are regular "auto" variables, including function arguments.
- * GLOBAL, STATIC, VIRTUAL are compile-time-allocated.
+ * STACK fields are regular "auto" variables, including function arguments, bound to a field declaration.
+ * UNBOUND_STACK indicates a value that is allocated on the stack, but not (yet) bound to a field declaration.
+ * NOSTORAGE indicates an unallocated / temporary / register value, also known as rvalue.
  */
 enum TxFieldStorage : int {
-    TXS_NOSTORAGE, TXS_GLOBAL, TXS_STATIC, TXS_VIRTUAL, TXS_INSTANCEMETHOD, TXS_INSTANCE, TXS_STACK
+    TXS_NOSTORAGE, TXS_GLOBAL, TXS_STATIC, TXS_VIRTUAL, TXS_INSTANCEMETHOD, TXS_INSTANCE, TXS_STACK, TXS_UNBOUND_STACK,
 };
 
 inline std::string to_string( TxFieldStorage storage ) {
@@ -31,6 +32,8 @@ inline std::string to_string( TxFieldStorage storage ) {
         return "TXS_INSTANCE";
     case TXS_STACK:
         return "TXS_STACK";
+    case TXS_UNBOUND_STACK:
+        return "TXS_UNBOUND_STACK";
     }
     return "-unknown TxFieldStorage value " + std::to_string((int)storage) + "-";
 }