Changeset 8d182b1 for src/ResolvExpr/PtrsAssignable.cc

Timestamp:

Nov 14, 2023, 12:19:09 PM (23 months ago)

Author:

caparson <caparson@…>

Branches:

master

Children:

1ccae59, 89a8bab

Parents:

df8ba61a (diff), 5625427 (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/ResolvExpr/PtrsAssignable.cc (modified) (2 diffs)

src/ResolvExpr/PtrsAssignable.cc

@@ -19 +19 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
-#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
-#include "SynTree/Visitor.h"             // for Visitor
-
 
 namespace ResolvExpr {
-        struct PtrsAssignable : public WithShortCircuiting {
-                PtrsAssignable( const Type * dest, const TypeEnvironment &env );
 
-                int get_result() const { return result; }
-
-                void previsit( const Type * ) { visit_children = false; }
-
-                void postvisit( const VoidType * voidType );
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-                void postvisit( const ArrayType * arrayType );
-                void postvisit( const FunctionType * functionType );
-                void postvisit( const StructInstType * inst );
-                void postvisit( const UnionInstType * inst );
-                void postvisit( const EnumInstType * inst );
-                void postvisit( const TraitInstType * inst );
-                void postvisit( const TypeInstType * inst );
-                void postvisit( const TupleType * tupleType );
-                void postvisit( const VarArgsType * varArgsType );
-                void postvisit( const ZeroType * zeroType );
-                void postvisit( const OneType * oneType );
-          private:
-                const Type * dest;
-                int result;
-                const TypeEnvironment &env;
-        };
-
-        int ptrsAssignable( const Type *src, const Type * dest, const TypeEnvironment &env ) {
-                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
-                                return ptrsAssignable( src, eqvClass->type, env );
-                        } // if
-                } // if
-                if ( dynamic_cast< const VoidType* >( dest ) ) {
-                        // void * = T * for any T is unsafe
-                        // xxx - this should be safe, but that currently breaks the build
-                        return -1;
-                } else {
-                        PassVisitor<PtrsAssignable> ptrs( dest, env );
-                        src->accept( ptrs );
-                        return ptrs.pass.get_result();
-                } // if
-        }
-
-        PtrsAssignable::PtrsAssignable( const Type * dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
-
-        void PtrsAssignable::postvisit( const 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( const BasicType * ) {}
-        void PtrsAssignable::postvisit( const PointerType * ) {}
-        void PtrsAssignable::postvisit( const ArrayType * ) {}
-        void PtrsAssignable::postvisit( const FunctionType * ) {}
-
-        void PtrsAssignable::postvisit( const StructInstType * ) {}
-        void PtrsAssignable::postvisit( const UnionInstType * ) {}
-
-        void PtrsAssignable::postvisit( const EnumInstType * ) {
-                if ( dynamic_cast< const BasicType* >( dest ) ) {
-                        // int * = E *, etc. is safe. This isn't technically correct, as each
-                        // enum has one basic type that it is compatible with, an that type can
-                        // differ from enum to enum. Without replicating GCC's internal logic,
-                        // there is no way to know which type this particular enum is compatible
-                        // with, so punt on this for now.
-                        result = 1;
-                }
-        }
-
-        void PtrsAssignable::postvisit(  const TraitInstType * ) {}
-        void PtrsAssignable::postvisit( const TypeInstType * inst ) {
-                if ( const EqvClass * eqvClass = env.lookup( inst->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::postvisit( const TupleType * ) {}
-        void PtrsAssignable::postvisit( const VarArgsType * ) {}
-        void PtrsAssignable::postvisit( const ZeroType * ) {}
-        void PtrsAssignable::postvisit( const OneType * ) {}
-
-// TODO: Get rid of the `_new` suffix when the old version is removed.
-struct PtrsAssignable_new : public ast::WithShortCircuiting {
+struct PtrsAssignable : public ast::WithShortCircuiting {
         const ast::Type * dst;
         const ast::TypeEnvironment & typeEnv;
         int result;
 
-        PtrsAssignable_new( const ast::Type * dst, const ast::TypeEnvironment & env ) :
+        PtrsAssignable( const ast::Type * dst, const ast::TypeEnvironment & env ) :
                 dst( dst ), typeEnv( env ), result( 0 ) {}
 
-        void previsit( Type * ) { visit_children = false; }
+        void previsit( ast::Type * ) { visit_children = false; }
 
         void postvisit( const ast::EnumInstType * ) {
@@ -153 +62 @@
                 return -1;
         } else {
-                ast::Pass<PtrsAssignable_new> visitor( dst, env );
+                ast::Pass<PtrsAssignable> visitor( dst, env );
                 src->accept( visitor );
                 return visitor.core.result;