Changeset f07c1e6 for src/ResolvExpr

Timestamp:

Jan 15, 2018, 3:40:34 PM (7 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, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

ad51cc2

Parents:

12145b9

Message:

Convert PtrsAssignable? to PassVisitor?

File:

• src/ResolvExpr/PtrsAssignable.cc (modified) (6 diffs)

src/ResolvExpr/PtrsAssignable.cc

@@ -14 +14 @@
 //
 
+#include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 #include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
@@ -20 +21 @@
 
 namespace ResolvExpr {
-        class PtrsAssignable : public Visitor {
-          public:
+        struct PtrsAssignable : public WithShortCircuiting {
                 PtrsAssignable( Type *dest, const TypeEnvironment &env );
 
                 int get_result() const { return result; }
 
-                virtual void visit( VoidType *voidType );
-                virtual void visit( BasicType *basicType );
-                virtual void visit( PointerType *pointerType );
-                virtual void visit( ArrayType *arrayType );
-                virtual void visit( FunctionType *functionType );
-                virtual void visit( StructInstType *inst );
-                virtual void visit( UnionInstType *inst );
-                virtual void visit( EnumInstType *inst );
-                virtual void visit( TraitInstType *inst );
-                virtual void visit( TypeInstType *inst );
-                virtual void visit( TupleType *tupleType );
-                virtual void visit( VarArgsType *varArgsType );
-                virtual void visit( ZeroType *zeroType );
-                virtual void visit( OneType *oneType );
+                void previsit( Type * ) { visit_children = false; }
+
+                void postvisit( VoidType * voidType );
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
+                void postvisit( ArrayType * arrayType );
+                void postvisit( FunctionType * functionType );
+                void postvisit( StructInstType * inst );
+                void postvisit( UnionInstType * inst );
+                void postvisit( EnumInstType * inst );
+                void postvisit( TraitInstType * inst );
+                void postvisit( TypeInstType * inst );
+                void postvisit( TupleType * tupleType );
+                void postvisit( VarArgsType * varArgsType );
+                void postvisit( ZeroType * zeroType );
+                void postvisit( OneType * oneType );
           private:
                 Type *dest;
@@ -59 +61 @@
                         return -1;
                 } else {
-                        PtrsAssignable ptrs( dest, env );
+                        PassVisitor<PtrsAssignable> ptrs( dest, env );
                         src->accept( ptrs );
-                        return ptrs.get_result();
+                        return ptrs.pass.get_result();
                 } // if
         }
@@ -67 +69 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( VoidType * ) {
+        void PtrsAssignable::postvisit( VoidType * ) {
                 // T * = void * is disallowed - this is a change from C, where any
                 // void * can be assigned or passed to a non-void pointer without a cast.
         }
 
-        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {}
+        void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {}
+        void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {}
+        void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {}
 
-        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
 
-        void PtrsAssignable::visit( EnumInstType * ) {
+        void PtrsAssignable::postvisit( EnumInstType * ) {
                 if ( dynamic_cast< BasicType* >( dest ) ) {
                         // int * = E *, etc. is safe. This isn't technically correct, as each
@@ -91 +93 @@
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
-        void PtrsAssignable::visit( TypeInstType *inst ) {
+        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsAssignable::postvisit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
@@ -100 +102 @@
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) TupleType *tupleType ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) ZeroType *zeroType ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) OneType *oneType ) {}
 
 } // namespace ResolvExpr