Changeset e149f77 for src/SynTree/Type.h

Timestamp:

Sep 15, 2017, 10:50:13 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

695e00d

Parents:

310e5b7

Message:

• moved print routine to base syntax node and implementated in code gen.
• added virtual and override where needed in the syntree.

File:

• src/SynTree/Type.h (modified) (19 diffs)

src/SynTree/Type.h

@@ -192 +192 @@
         VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
-        virtual unsigned size() const { return 0; };
-        virtual bool isComplete() const { return false; }
-
-        virtual VoidType *clone() const { return new VoidType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return 0; };
+        virtual bool isComplete() const override { return false; }
+
+        virtual VoidType *clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -235 +235 @@
         void set_kind( Kind newValue ) { kind = newValue; }
 
-        virtual BasicType *clone() const { return new BasicType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual BasicType *clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 
         bool isInteger() const;
@@ -268 +268 @@
         bool is_array() const { return isStatic || isVarLen || dimension; }
 
-        virtual bool isComplete() const { return ! isVarLen; }
-
-        virtual PointerType *clone() const { return new PointerType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+
+        virtual PointerType *clone() const override { return new PointerType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -296 +296 @@
         void set_isStatic( bool newValue ) { isStatic = newValue; }
 
-        virtual bool isComplete() const { return ! isVarLen; }
-
-        virtual ArrayType *clone() const { return new ArrayType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+
+        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -315 +315 @@
         void set_base( Type *newValue ) { base = newValue; }
 
-        virtual int referenceDepth() const;
+        virtual int referenceDepth() const override;
 
         // Since reference types act like value types, their size is the size of the base.
         // This makes it simple to cast the empty tuple to a reference type, since casts that increase
         // the number of values are disallowed.
-        virtual unsigned size() const { return base->size(); }
-
-        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return base->size(); }
+
+        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -349 +349 @@
         bool isTtype() const;
 
-        virtual FunctionType *clone() const { return new FunctionType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -371 +371 @@
         void set_hoistType( bool newValue ) { hoistType = newValue; }
 
-        virtual ReferenceToType *clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Type *acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ReferenceToType *clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
@@ -398 +398 @@
         std::list<TypeDecl*> * get_baseParameters();
 
-        virtual bool isComplete() const;
+        virtual bool isComplete() const override;
 
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-        virtual StructInstType *clone() const { return new StructInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -430 +430 @@
         std::list< TypeDecl * > * get_baseParameters();
 
-        virtual bool isComplete() const;
+        virtual bool isComplete() const override;
 
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
-
-        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+
+        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -459 +459 @@
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
 
-        virtual bool isComplete() const;
-
-        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+
+        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -480 +480 @@
         ~TraitInstType();
 
-        virtual bool isComplete() const;
-
-        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+
+        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -507 +507 @@
         void set_isFtype( bool newValue ) { isFtype = newValue; }
 
-        virtual bool isComplete() const;
-
-        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override;
+
+        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
-        virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 
@@ -530 +530 @@
 
         std::list<Type *> & get_types() { return types; }
-        virtual unsigned size() const { return types.size(); };
+        virtual unsigned size() const override { return types.size(); };
 
         // For now, this is entirely synthetic -- tuple types always have unnamed members.
@@ -539 +539 @@
         iterator end() { return types.end(); }
 
-        virtual Type * getComponent( unsigned i ) {
+        virtual Type * getComponent( unsigned i ) override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
                 return *(begin()+i);
         }
 
-        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
-
-        virtual TupleType *clone() const { return new TupleType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
+
+        virtual TupleType *clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -563 +563 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual bool isComplete() const { assert( false ); return false; }
-
-        virtual TypeofType *clone() const { return new TypeofType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); return false; }
+
+        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -592 +592 @@
         void set_isType( bool newValue ) { isType = newValue; }
 
-        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
-
-        virtual AttrType *clone() const { return new AttrType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
+
+        virtual AttrType *clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -606 +606 @@
         VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual bool isComplete() const{ return true; } // xxx - is this right?
-
-        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override{ return true; } // xxx - is this right?
+
+        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -620 +620 @@
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual ZeroType *clone() const { return new ZeroType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 
@@ -632 +632 @@
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
 
-        virtual OneType *clone() const { return new OneType( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-};
-
-std::ostream & operator<<( std::ostream & out, const Type * type );
+        virtual OneType *clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
+};
 
 // Local Variables: //