Changeset c194661

Timestamp:

Jun 20, 2018, 11:23:42 AM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

0b3b2ae

Parents:

9a7a3b6

Message:

Reorganize QualifiedType? node

Location:

src

Files:

• CodeGen/GenType.cc (modified) (3 diffs)
• Common/PassVisitor.impl.h (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (6 diffs)
• Parser/TypeData.h (modified) (3 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)

src/CodeGen/GenType.cc

@@ -48 +48 @@
                 void postvisit( ZeroType * zeroType );
                 void postvisit( OneType * oneType );
+                void postvisit( GlobalScopeType * globalType );
                 void postvisit( TraitInstType * inst );
                 void postvisit( TypeofType * typeof );
+                void postvisit( QualifiedType * qualType );
 
           private:
@@ -291 +293 @@
         }
 
+        void GenType::postvisit( GlobalScopeType * globalType ) {
+                assertf( ! genC, "Global scope type should not reach code generation." );
+                handleQualifiers( globalType );
+        }
+
         void GenType::postvisit( TraitInstType * inst ) {
                 assertf( ! genC, "Trait types should not reach code generation." );
@@ -307 +314 @@
         }
 
+        void GenType::postvisit( QualifiedType * qualType ) {
+                assertf( ! genC, "Qualified types should not reach code generation." );
+                std::ostringstream os;
+                os << genType( qualType->parent, "", pretty, genC, lineMarks ) << "." << genType( qualType->child, "", pretty, genC, lineMarks );
+                typeString = os.str();
+                handleQualifiers( qualType );
+        }
+
         void GenType::handleQualifiers( Type * type ) {
                 if ( type->get_const() ) {

src/Common/PassVisitor.impl.h

@@ -2268 +2268 @@
 
         maybeAccept_impl( node->forall, *this );
-        maybeAccept_impl( node->types, *this );
+        maybeAccept_impl( node->parent, *this );
+        maybeAccept_impl( node->child, *this );
 
         VISIT_END( node );
@@ -2278 +2279 @@
 
         maybeMutate_impl( node->forall, *this );
-        maybeMutate_impl( node->types, *this );
+        maybeMutate_impl( node->parent, *this );
+        maybeMutate_impl( node->child, *this );
 
         MUTATE_END( Type, node );

src/Parser/DeclarationNode.cc

@@ -261 +261 @@
 
 DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
-        return child;
-        // return parent->add_last( child );
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Qualified );
+        newnode->type->qualified.parent = parent->type;
+        newnode->type->qualified.child = child->type;
+        parent->type = nullptr;
+        child->type = nullptr;
+        delete parent;
+        delete child;
+        return newnode;
 }
 

src/Parser/TypeData.cc

@@ -99 +99 @@
           case Builtin:
                 // builtin = new Builtin_t;
+                case Qualified:
+                qualified.parent = nullptr;
+                qualified.child = nullptr;
                 break;
         } // switch
@@ -167 +170 @@
                 // delete builtin;
                 break;
+          case Qualified:
+                delete qualified.parent;
+                delete qualified.child;
         } // switch
 } // TypeData::~TypeData
@@ -240 +246 @@
                 assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
                 newtype->builtintype = builtintype;
+                break;
+                case Qualified:
+                newtype->qualified.parent = maybeClone( qualified.parent );
+                newtype->qualified.child = maybeClone( qualified.child );
                 break;
         } // switch
@@ -468 +478 @@
                 return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
-                return buildSymbolicInst( td );;
+                return buildSymbolicInst( td );
           case TypeData::Tuple:
                 return buildTuple( td );
@@ -483 +493 @@
                         return new VarArgsType( buildQualifiers( td ) );
                 }
+          case TypeData::GlobalScope:
+                return new GlobalScopeType();
+                case TypeData::Qualified:
+                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
@@ -488 +502 @@
                 assert( false );
         } // switch
+
         return nullptr;
 } // typebuild

src/Parser/TypeData.h

@@ -27 +27 @@
 struct TypeData {
         enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
-                                SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Unknown };
+                                SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
 
         struct Aggregate_t {
@@ -75 +75 @@
         };
 
+        struct Qualified_t { // qualified type S.T
+                TypeData * parent;
+                TypeData * child;
+        };
+
         CodeLocation location;
 
@@ -94 +99 @@
         Function_t function;
         Symbolic_t symbolic;
+        Qualified_t qualified;
         DeclarationNode * tuple;
         ExpressionNode * typeexpr;

src/SynTree/Type.cc

@@ -106 +106 @@
 
 
-QualifiedType::QualifiedType( const Type::Qualifiers & tq, const std::list< Type * > & types ) : Type( tq, {} ), types( types ) {
+QualifiedType::QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child ) : Type( tq, {} ), parent( parent ), child( child ) {
 }
 
-QualifiedType::QualifiedType( const QualifiedType & other ) : Type( other ) {
-        cloneAll( other.types, types );
+QualifiedType::QualifiedType( const QualifiedType & other ) : Type( other ), parent( maybeClone( other.parent ) ), child( maybeClone( other.child ) ) {
 }
 
 QualifiedType::~QualifiedType() {
-        deleteAll( types );
+        delete parent;
+        delete child;
 }
 
 void QualifiedType::print( std::ostream & os, Indenter indent ) const {
         os << "Qualified Type: " << endl;
-        printAll( types, os, indent+1 );
+        os << indent+1;
+        parent->print( os, indent+1 );
+        os << endl << indent+1;
+        child->print( os, indent+1 );
+        os << endl;
         Type::print( os, indent+1 );
 }

src/SynTree/Type.h

@@ -317 +317 @@
 class QualifiedType : public Type {
 public:
-        std::list<Type *> types;
-
-        QualifiedType( const Type::Qualifiers & tq, const std::list< Type * > & types );
+        Type * parent;
+        Type * child;
+
+        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
         QualifiedType( const QualifiedType & tq );
         virtual ~QualifiedType();