Changeset 90152a4 for src/ResolvExpr/PtrsAssignable.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

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;
@@ -49 +51 @@
                 // std::cerr << "assignable: " << src << " | " << dest << std::endl;
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        EqvClass eqvClass;
-                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                                return ptrsAssignable( src, eqvClass.type, env );
+                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
+                                return ptrsAssignable( src, eqvClass->type, env );
                         } // if
                 } // if
@@ -59 +60 @@
                         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 +68 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( __attribute((unused)) VoidType *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 +92 @@
         }
 
-        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 );
+        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 );
+                        }
                 } // if
         }
 
-        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