Changeset 69bafd2 for src/AST/Expr.hpp

Timestamp:

May 15, 2019, 3:57:26 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

3648d98

Parents:

9e1d485 (diff), be567e9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/AST/Expr.hpp (modified) (4 diffs)

src/AST/Expr.hpp

@@ -27 +27 @@
 namespace ast {
 
-/// Contains the ID of a declaration and a type that is derived from that declaration, 
+/// Contains the ID of a declaration and a type that is derived from that declaration,
 /// but subject to decay-to-pointer and type parameter renaming
 struct ParamEntry {
@@ -74 +74 @@
                         case Empty:  return;
                         case Slots:  new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return;
-                        case Params: 
+                        case Params:
                                 new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return;
                         }
@@ -121 +121 @@
         Expr * set_extension( bool ex ) { extension = ex; return this; }
 
-        virtual Expr * accept( Visitor & v ) override = 0;
+        virtual const Expr * accept( Visitor & v ) const override = 0;
 private:
         virtual Expr * clone() const override = 0;
@@ -133 +133 @@
         TypeExpr( const CodeLocation & loc, const Type * t ) : Expr(loc), type(t) {}
 
-        Expr * accept( Visitor & v ) override { return v.visit( this ); }
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         TypeExpr * clone() const override { return new TypeExpr{ *this }; }
 };
 
+
+//=================================================================================================
+/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
+/// remove only if there is a better solution
+/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
+/// forward declarations
+inline void increment( const class Expr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class Expr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class ApplicationExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class ApplicationExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class NameExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class NameExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class AddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class AddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class LabelAddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class LabelAddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class CastExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class CastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class KeywordCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class KeywordCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class VirtualCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class VirtualCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class MemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class MemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class VariableExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class VariableExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class ConstantExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class ConstantExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class SizeofExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class SizeofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class AlignofExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class AlignofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class OffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class OffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class OffsetPackExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class OffsetPackExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class AttrExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class AttrExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class LogicalExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class LogicalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class ConditionalExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class ConditionalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class CommaExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class CommaExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class TypeExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class TypeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class ConstructorExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class ConstructorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedValofExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedValofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class RangeExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class RangeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class TupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class TupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class TupleIndexExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class TupleIndexExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class TupleAssignExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class TupleAssignExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class StmtExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class StmtExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UniqueExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UniqueExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class UntypedInitExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class UntypedInitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class InitExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class InitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class DeletedExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class DeletedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class DefaultArgExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class DefaultArgExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+// inline void increment( const class GenericExpr * node, Node::ref_type ref ) { node->increment(ref); }
+// inline void decrement( const class GenericExpr * node, Node::ref_type ref ) { node->decrement(ref); }
 }