Changeset 4eb3a7c5 for src/Parser/TypeData.cc

Timestamp:

Feb 23, 2024, 6:52:33 PM (4 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

3d5a8cb

Parents:

624ba3a5

Message:

first attempt at correct distribution of attributes for aggregates

File:

• src/Parser/TypeData.cc (modified) (9 diffs)

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 18:59:12 2023
-// Update Count     : 684
+// Last Modified On : Fri Feb 23 08:58:30 2024
+// Update Count     : 734
 //
 
@@ -20 +20 @@
 
 #include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
+#include "AST/Attribute.hpp"       // for Attribute
 #include "AST/Init.hpp"            // for SingleInit, ListInit
 #include "AST/Print.hpp"           // for print
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for splice, spliceBegin
+#include "Common/Iterate.hpp"      // for reverseIterate
 #include "Parser/ExpressionNode.h" // for ExpressionNode
 #include "Parser/StatementNode.h"  // for StatementNode
@@ -199 +201 @@
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
+                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 newtype->aggregate.params = maybeCopy( aggregate.params );
                 newtype->aggregate.actuals = maybeCopy( aggregate.actuals );
                 newtype->aggregate.fields = maybeCopy( aggregate.fields );
+                newtype->aggregate.attributes = aggregate.attributes;
                 newtype->aggregate.body = aggregate.body;
                 newtype->aggregate.anon = aggregate.anon;
                 newtype->aggregate.tagged = aggregate.tagged;
-                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
         case AggregateInst:
@@ -336 +339 @@
                 } // if
                 if ( aggregate.body ) {
-                        os << string( indent + 2, ' ' ) << " with body" << endl;
+                        os << string( indent + 2, ' ' ) << "with body" << endl;
+                } // if
+                if ( ! aggregate.attributes.empty() ) {
+                        os << string( indent + 2, ' ' ) << "with attributes" << endl;
+                        for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( aggregate.attributes ) ) {
+                                os << string( indent + 4, ' ' );
+                                ast::print( os, attr, indent + 2 );
+                        } // for
                 } // if
                 break;
@@ -358 +368 @@
                 } // if
                 if ( enumeration.body ) {
-                        os << string( indent + 2, ' ' ) << " with body" << endl;
+                        os << string( indent + 2, ' ' ) << "with body" << endl;
                 } // if
                 if ( base ) {
@@ -1088 +1098 @@
 
 ast::BaseInstType * buildComAggInst(
-                const TypeData * type,
+                const TypeData * td,
                 std::vector<ast::ptr<ast::Attribute>> && attributes,
                 ast::Linkage::Spec linkage ) {
-        switch ( type->kind ) {
+        switch ( td->kind ) {
         case TypeData::Enum:
-                if ( type->enumeration.body ) {
+                if ( td->enumeration.body ) {
                         ast::EnumDecl * typedecl =
-                                buildEnum( type, std::move( attributes ), linkage );
+                                buildEnum( td, std::move( attributes ), linkage );
                         return new ast::EnumInstType(
                                 typedecl,
-                                buildQualifiers( type )
+                                buildQualifiers( td )
                         );
                 } else {
                         return new ast::EnumInstType(
-                                *type->enumeration.name,
-                                buildQualifiers( type )
+                                *td->enumeration.name,
+                                buildQualifiers( td )
                         );
                 } // if
                 break;
         case TypeData::Aggregate:
-                if ( type->aggregate.body ) {
+                if ( td->aggregate.body ) {
                         ast::AggregateDecl * typedecl =
-                                buildAggregate( type, std::move( attributes ), linkage );
-                        switch ( type->aggregate.kind ) {
+                                buildAggregate( td, std::move( attributes ), linkage );
+                        switch ( td->aggregate.kind ) {
                         case ast::AggregateDecl::Struct:
                         case ast::AggregateDecl::Coroutine:
@@ -1118 +1128 @@
                                 return new ast::StructInstType(
                                         strict_dynamic_cast<ast::StructDecl *>( typedecl ),
-                                        buildQualifiers( type )
+                                        buildQualifiers( td )
                                 );
                         case ast::AggregateDecl::Union:
                                 return new ast::UnionInstType(
                                         strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
-                                        buildQualifiers( type )
+                                        buildQualifiers( td )
                                 );
                         case ast::AggregateDecl::Trait:
@@ -1132 +1142 @@
                         } // switch
                 } else {
-                        switch ( type->aggregate.kind ) {
+                        switch ( td->aggregate.kind ) {
                         case ast::AggregateDecl::Struct:
                         case ast::AggregateDecl::Coroutine:
@@ -1138 +1148 @@
                         case ast::AggregateDecl::Thread:
                                 return new ast::StructInstType(
-                                        *type->aggregate.name,
-                                        buildQualifiers( type )
+                                        *td->aggregate.name,
+                                        buildQualifiers( td )
                                 );
                         case ast::AggregateDecl::Union:
                                 return new ast::UnionInstType(
-                                        *type->aggregate.name,
-                                        buildQualifiers( type )
+                                        *td->aggregate.name,
+                                        buildQualifiers( td )
                                 );
                         case ast::AggregateDecl::Trait:
                                 return new ast::TraitInstType(
-                                        *type->aggregate.name,
-                                        buildQualifiers( type )
+                                        *td->aggregate.name,
+                                        buildQualifiers( td )
                                 );
                         default: