Add element type propagation for anonymous struct literals in ArrayLiteral (#69)

Co-authored-by: io-eric <io-eric@users.noreply.github.com>

Author: io-eric

src/ast/component.cc

@@ -561,6 +561,9 @@ std::string Component::to_webcc(CompilerSession &session)
             {
                 std::string elem_type = var->type.substr(0, var->type.length() - 2);
 
+                // Propagate element type to anonymous struct literals
+                arr_lit->propagate_element_type(elem_type);
+                
                 // Component state arrays with T[] type: always use webcc::vector (even if not mut).
                 //
                 // WHY NOT USE FIXED ARRAYS HERE?

src/ast/expressions.cc

@@ -773,6 +773,19 @@ bool ArrayLiteral::is_static() {
     return true;
 }
 
+void ArrayLiteral::propagate_element_type(const std::string& type) {
+    element_type = type;
+    for (auto& elem : elements) {
+        // If this is an anonymous struct literal (ComponentConstruction with empty name),
+        // fill in the type from the array's element type
+        if (auto comp = dynamic_cast<ComponentConstruction*>(elem.get())) {
+            if (comp->component_name.empty()) {
+                comp->component_name = type;
+            }
+        }
+    }
+}
+
 std::string ArrayRepeatLiteral::to_webcc() {
     // Generate initialization - webcc::array constructor will fill with the value
     // The actual array type and initialization is handled by VarDeclaration::to_webcc

src/ast/expressions.h

@@ -154,6 +154,9 @@ struct ArrayLiteral : Expression {
     std::string to_webcc() override;
     void collect_dependencies(std::set<std::string>& deps) override;
     bool is_static() override;
+    
+    // Propagate element type to anonymous struct literals (ComponentConstruction with empty name)
+    void propagate_element_type(const std::string& type);
 };
 
 // Fixed-size array repeat initializer: [value; count] e.g., [0; 100] or [0; NUM_ITEMS]

src/ast/statements.cc

@@ -73,6 +73,9 @@ std::string VarDeclaration::to_webcc()
         {
             std::string elem_type = type.substr(0, type.length() - 2);
 
+            // Propagate element type to anonymous struct literals
+            arr_lit->propagate_element_type(elem_type);
+            
             // Optimization: If immutable and initialized with literal, use fixed-size array
             // No need for dynamic allocation if we know the size at compile time and can't modify
             if (!is_mutable)

src/frontend/parser/expr.cc

@@ -255,6 +255,20 @@ std::unique_ptr<Expression> Parser::parse_primary()
         return std::make_unique<BoolLiteral>(false);
     }
 
+    // Anonymous struct literal: { field = value, ... }
+    // Type is inferred from context (e.g., array element type)
+    if (current().type == TokenType::LBRACE && allow_brace_init)
+    {
+        advance();
+        auto parsed_args = parse_call_args(TokenType::RBRACE);
+        expect(TokenType::RBRACE, "Expected '}'");
+
+        // Create ComponentConstruction with empty name - type will be inferred
+        auto data_expr = std::make_unique<ComponentConstruction>("");
+        data_expr->args = std::move(parsed_args);
+        return data_expr;
+    }
+
     // Identifer or function call (also allow 'key' and 'data' keywords as identifier)
     if (is_identifier_token())
     {
@@ -372,6 +386,9 @@ std::unique_ptr<Expression> Parser::parse_primary()
             return std::make_unique<ArrayLiteral>();
         }
 
+        // Allow { field = value } syntax for anonymous struct literals in arrays
+        allow_brace_init = true;
+
         // Parse first expression
         auto first_expr = parse_expression();