Changes in src/ResolvExpr/PtrsCastable.cc [3c89751:00ac42e]

File:

• src/ResolvExpr/PtrsCastable.cc (modified) (5 diffs)

src/ResolvExpr/PtrsCastable.cc

@@ -14 +14 @@
 //
 
-#include "AST/Decl.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
@@ -27 +23 @@
 
 namespace ResolvExpr {
-        struct PtrsCastable_old : public WithShortCircuiting  {
+        struct PtrsCastable : public WithShortCircuiting  {
           public:
-                PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+                PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
 
                 int get_result() const { return result; }
@@ -90 +86 @@
                         return objectCast( src, env, indexer );
                 } else {
-                        PassVisitor<PtrsCastable_old> ptrs( dest, env, indexer );
+                        PassVisitor<PtrsCastable> ptrs( dest, env, indexer );
                         src->accept( ptrs );
                         return ptrs.pass.get_result();
@@ -96 +92 @@
         }
 
-        PtrsCastable_old::PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
+        PtrsCastable::PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
                 : dest( dest ), result( 0 ), env( env ), indexer( indexer )     {
         }
 
-        void PtrsCastable_old::postvisit( VoidType * ) {
+        void PtrsCastable::postvisit( VoidType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( BasicType * ) {
+        void PtrsCastable::postvisit( BasicType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( PointerType * ) {
+        void PtrsCastable::postvisit( PointerType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( ArrayType * ) {
+        void PtrsCastable::postvisit( ArrayType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( FunctionType * ) {
+        void PtrsCastable::postvisit( FunctionType * ) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( StructInstType * ) {
+        void PtrsCastable::postvisit( StructInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( UnionInstType * ) {
+        void PtrsCastable::postvisit( UnionInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( EnumInstType * ) {
+        void PtrsCastable::postvisit( EnumInstType * ) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -143 +139 @@
         }
 
-        void PtrsCastable_old::postvisit( TraitInstType * ) {}
+        void PtrsCastable::postvisit( TraitInstType * ) {}
 
-        void PtrsCastable_old::postvisit(TypeInstType *inst ) {
+        void PtrsCastable::postvisit(TypeInstType *inst) {
                 //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
                 result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
         }
 
-        void PtrsCastable_old::postvisit( TupleType * ) {
+        void PtrsCastable::postvisit( TupleType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( VarArgsType * ) {
+        void PtrsCastable::postvisit( VarArgsType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( ZeroType * ) {
+        void PtrsCastable::postvisit( ZeroType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable_old::postvisit( OneType * ) {
+        void PtrsCastable::postvisit( OneType * ) {
                 result = objectCast( dest, env, indexer );
         }
-
-namespace {
-        // can this type be cast to an object (1 for yes, -1 for no)
-        int objectCast( 
-                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
-        ) {
-                if ( dynamic_cast< const ast::FunctionType * >( src ) ) {
-                        return -1;
-                } else if ( auto inst = dynamic_cast< const ast::TypeInstType * >( src ) ) {
-                        if ( const ast::NamedTypeDecl * named = symtab.lookupType( inst->name ) ) {
-                                if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( named ) ) {
-                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
-                                                return -1;
-                                        }
-                                }
-                        } else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
-                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
-                                        return -1;
-                                }
-                        }
-                }
-
-                return 1;
-        }
-
-        // can this type be cast to a function (inverse of objectCast)
-        int functionCast( 
-                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
-        ) {
-                return -1 * objectCast( src, env, symtab );
-        }
-
-        class PtrsCastable_new : public ast::WithShortCircuiting {
-                const ast::Type * dst;
-                const ast::TypeEnvironment & env;
-                const ast::SymbolTable & symtab;
-        public:
-                int result;
-
-                PtrsCastable_new( 
-                        const ast::Type * d, const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
-                : dst( d ), env( e ), symtab( syms ), result( 0 ) {}
-
-                void previsit( const ast::Type * ) { visit_children = false; }
-
-                void postvisit( const ast::VoidType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::BasicType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::PointerType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::ArrayType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::FunctionType * ) {
-                        result = functionCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::StructInstType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::UnionInstType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::EnumInstType * ) {
-                        if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                                result = 1;
-                        } else if ( auto bt = dynamic_cast< const ast::BasicType * >( dst ) ) {
-                                if ( bt->kind == ast::BasicType::SignedInt ) {
-                                        result = 0;
-                                } else {
-                                        result = 1;
-                                }
-                        } else {
-                                result = objectCast( dst, env, symtab );
-                        }
-                }
-
-                void postvisit( const ast::TraitInstType * ) {}
-
-                void postvisit( const ast::TypeInstType * inst ) {
-                        // check trait and destination type are both object or both function
-                        result = objectCast( inst, env, symtab ) == objectCast( dst, env, symtab ) ? 1 : -1;
-                }
-
-                void postvisit( const ast::TupleType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::VarArgsType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::ZeroType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-                void postvisit( const ast::OneType * ) {
-                        result = objectCast( dst, env, symtab );
-                }
-
-        };
-} // anonymous namespace
-
-int ptrsCastable( 
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
-        const ast::TypeEnvironment & env 
-) {
-        if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
-                if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
-                        return ptrsAssignable( src, eqvClass->bound, env );
-                }
-        }
-
-        if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
-                return objectCast( src, env, symtab );
-        } else {
-                ast::Pass< PtrsCastable_new > ptrs{ dst, env, symtab };
-                src->accept( ptrs );
-                return ptrs.pass.result;
-        }
-}
-
 } // namespace ResolvExpr