Changes in src/ResolvExpr/PtrsAssignable.cc [00ac42e:4d5e57b]

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
@@ -21 +20 @@
 
 namespace ResolvExpr {
-        struct PtrsAssignable : public WithShortCircuiting {
+        class PtrsAssignable : public Visitor {
+          public:
                 PtrsAssignable( Type *dest, const TypeEnvironment &env );
 
                 int get_result() const { return result; }
 
-                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 );
+                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 );
           private:
                 Type *dest;
@@ -51 +49 @@
                 // std::cerr << "assignable: " << src << " | " << dest << std::endl;
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
-                                return ptrsAssignable( src, eqvClass->type, env );
+                        EqvClass eqvClass;
+                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                return ptrsAssignable( src, eqvClass.type, env );
                         } // if
                 } // if
@@ -60 +59 @@
                         return -1;
                 } else {
-                        PassVisitor<PtrsAssignable> ptrs( dest, env );
+                        PtrsAssignable ptrs( dest, env );
                         src->accept( ptrs );
-                        return ptrs.pass.get_result();
+                        return ptrs.get_result();
                 } // if
         }
@@ -68 +67 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::postvisit( VoidType * ) {
+        void PtrsAssignable::visit( __attribute((unused)) VoidType *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::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)) 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)) StructInstType *inst ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
 
-        void PtrsAssignable::postvisit( EnumInstType * ) {
+        void PtrsAssignable::visit( EnumInstType * ) {
                 if ( dynamic_cast< BasicType* >( dest ) ) {
                         // int * = E *, etc. is safe. This isn't technically correct, as each
@@ -92 +91 @@
         }
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
-        void PtrsAssignable::postvisit( TypeInstType *inst ) {
-                if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) {
-                        if ( eqvClass->type ) {
-                                // T * = S * for any S depends on the type bound to T
-                                result = ptrsAssignable( eqvClass->type, dest, env );
-                        }
+        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsAssignable::visit( TypeInstType *inst ) {
+                EqvClass eqvClass;
+                if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
+                        // T * = S * for any S depends on the type bound to T
+                        result = ptrsAssignable( eqvClass.type, dest, env );
                 } // if
         }
 
-        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 ) {}
+        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 ) {}
 
 } // namespace ResolvExpr