Changeset 4a72fef for src/Parser/TypeData.cc

Timestamp:

Apr 4, 2024, 11:33:08 AM (3 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

1cfe640

Parents:

2d82999

Message:

General clean-up in the parser. Removed the commented DeclarationNode::name and added some helper functions to remove duplicate code.

File:

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

src/Parser/TypeData.cc

@@ -475 +475 @@
 
 
+// Wrap an aggregate up in an instance. Takes and gives ownership.
+static TypeData * makeInstance( TypeData * type ) {
+        assert( TypeData::Aggregate == type->kind );
+        TypeData * out = new TypeData( TypeData::AggregateInst );
+        out->aggInst.aggregate = type;
+        out->aggInst.params = maybeCopy( type->aggregate.actuals );
+        out->aggInst.hoistType = type->aggregate.body;
+        out->qualifiers |= type->qualifiers;
+        return out;
+}
+
+
 TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) {
         TypeData * type = new TypeData;
@@ -566 +578 @@
 TypeData * addQualifiers( TypeData * ltype, TypeData * rtype ) {
         if ( ltype->forall ) {
-                if ( rtype->forall ) {
-                        rtype->forall->set_last( ltype->forall );
-                } else if ( TypeData::Aggregate != rtype->kind ) {
-                        rtype->forall = ltype->forall;
-                } else if ( rtype->aggregate.params ) {
-                        rtype->aggregate.params->set_last( ltype->forall );
+                if ( rtype->forall || TypeData::Aggregate != rtype->kind ) {
+                        extend( rtype->forall, ltype->forall );
                 } else {
-                        rtype->aggregate.params = ltype->forall;
+                        extend( rtype->aggregate.params, ltype->forall );
                 }
                 ltype->forall = nullptr;
@@ -585 +593 @@
 static void addTypeToType( TypeData *& dst, TypeData *& src ) {
         if ( src->forall && dst->kind == TypeData::Function ) {
-                if ( dst->forall ) {
-                        dst->forall->set_last( src->forall );
-                } else {
-                        dst->forall = src->forall;
-                } // if
+                extend( dst->forall, src->forall );
                 src->forall = nullptr;
         } // if
@@ -641 +645 @@
                 break;
         default:
-                switch ( src->kind ) {
-                case TypeData::Aggregate:
-                        dst->base = new TypeData( TypeData::AggregateInst );
-                        dst->base->aggInst.aggregate = src;
-                        if ( src->kind == TypeData::Aggregate ) {
-                                dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
-                        } // if
-                        dst->base->qualifiers |= src->qualifiers;
-                        src = nullptr;
-                        break;
-                default:
-                        if ( dst->forall ) {
-                                dst->forall->set_last( src->forall );
-                        } else {
-                                dst->forall = src->forall;
-                        } // if
+                if ( TypeData::Aggregate == src->kind ) {
+                        dst->base = makeInstance( src );
+                } else {
+                        extend( dst->forall, src->forall );
                         src->forall = nullptr;
                         dst->base = src;
-                        src = nullptr;
-                } // switch
+                }
+                src = nullptr;
         } // switch
 }
@@ -668 +660 @@
         if ( rtype ) {
                 addTypeToType( rtype, ltype );
-                return rtype;
+        } else if ( ltype->kind == TypeData::Aggregate ) {
+                // Hide type information aggregate instances.
+                rtype = makeInstance( ltype );
+                rtype->aggInst.aggregate->aggregate.attributes.swap( attributes );
         } else {
-                if ( ltype->kind == TypeData::Aggregate ) {
-                        // Hide type information aggregate instances.
-                        rtype = new TypeData( TypeData::AggregateInst );
-                        rtype->aggInst.aggregate = ltype;
-                        rtype->aggInst.aggregate->aggregate.attributes.swap( attributes ); // change ownership
-                        rtype->aggInst.hoistType = ltype->aggregate.body;
-                        rtype->aggInst.params = maybeCopy( ltype->aggregate.actuals );
-                        rtype->qualifiers |= ltype->qualifiers;
-                } else {
-                        rtype = ltype;
-                } // if
-                return rtype;
+                rtype = ltype;
         } // if
+        return rtype;
 }
 
@@ -713 +698 @@
 
 TypeData * makeNewBase( TypeData * type ) {
-        switch ( type->kind ) {
-        case TypeData::Aggregate: {
-                TypeData * out = new TypeData( TypeData::AggregateInst );
-                out->aggInst.aggregate = type;
-                if ( TypeData::Aggregate == type->kind ) {
-                        out->aggInst.params = maybeCopy( type->aggregate.actuals );
-                }
-                out->qualifiers |= type->qualifiers;
-                return out;
-        }
-        default:
-                return type;
-        } // switch
+        return ( TypeData::Aggregate == type->kind ) ? makeInstance( type ) : type;
 }