Changes in src/ResolvExpr/PtrsAssignable.cc [5ccb10d:b0837e4]

File:

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

src/ResolvExpr/PtrsAssignable.cc

@@ -14 +14 @@
 //
 
-#include "typeops.h"
-#include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Visitor.h"
+#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
+#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
+#include "SynTree/Visitor.h"             // for Visitor
 
 
@@ -48 +47 @@
 
         int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env ) {
+                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
                         EqvClass eqvClass;
@@ -55 +55 @@
                 } // if
                 if ( dynamic_cast< VoidType* >( dest ) ) {
-                        return 1;
+                        // void * = T * for any T is unsafe
+                        // xxx - this should be safe, but that currently breaks the build
+                        return -1;
                 } else {
                         PtrsAssignable ptrs( dest, env );
@@ -66 +68 @@
 
         void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
-                if ( dynamic_cast< FunctionType* >( dest ) ) {
-                        result = 0;
-                } else {
-                        result = -1;
+                if ( ! dynamic_cast< FunctionType* >( dest ) ) {
+                        // T * = void * is safe for any T that is not a function type.
+                        // xxx - this should be unsafe...
+                        result = 1;
                 } // if
         }
@@ -76 +78 @@
         void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
         void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
-        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
-                result = -1;
-        }
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {}
 
         void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
@@ -84 +84 @@
 
         void PtrsAssignable::visit( EnumInstType * ) {
-                if ( dynamic_cast< EnumInstType* >( dest ) ) {
+                if ( dynamic_cast< 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;
-                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
-                        result = bt->get_kind() == BasicType::SignedInt;
                 }
         }
@@ -95 +98 @@
                 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 );
-                } else {
-                        result = 0;
                 } // if
         }