Changeset 23b6643f for src/ResolvExpr

Timestamp:

Sep 20, 2016, 4:47:34 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1132b62

Parents:

aefcc3b (diff), db46512 (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 tuples

Conflicts:

src/Makefile.in
src/ResolvExpr/Unify.cc
src/SynTree/Type.h

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• CommonType.cc (modified) (5 diffs)
• ConversionCost.cc (modified) (3 diffs)
• ConversionCost.h (modified) (1 diff)
• PtrsAssignable.cc (modified) (2 diffs)
• PtrsCastable.cc (modified) (2 diffs)
• RenameVars.cc (modified) (1 diff)
• RenameVars.h (modified) (1 diff)
• Resolver.cc (modified) (2 diffs)
• Unify.cc (modified) (3 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -37 +37 @@
                 virtual Type* mutate( TupleType *tupleType );
                 virtual Type* mutate( VarArgsType *varArgsType );
+                virtual Type* mutate( ZeroType *zeroType );
+                virtual Type* mutate( OneType *oneType );
 
                 const TypeEnvironment &env;
@@ -117 +119 @@
                 return varArgsType;
         }
+
+        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
+                return zeroType;
+        }
+
+        Type *AdjustExprType::mutate( OneType *oneType ) {
+                return oneType;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/CommonType.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -134 +136 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
-                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
-                        // use signed int in lieu of the enum type
+                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
+                        // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
-                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + type2->get_qualifiers(), newType );
                         } // if
                 } // if
@@ -171 +173 @@
                                 otherPointer->get_base()->get_qualifiers() = tq2;
                         } // if
+                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+                        result = pointerType->clone();
+                        result->get_qualifiers() += type2->get_qualifiers();
                 } // if
         }
@@ -190 +195 @@
 
         void CommonType::visit( EnumInstType *enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) ) {
+                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
@@ -230 +235 @@
         void CommonType::visit( VarArgsType *varArgsType ) {
         }
+
+        void CommonType::visit( ZeroType *zeroType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += zeroType->get_qualifiers();
+                                }
+                        }
+                }
+        }
+
+        void CommonType::visit( OneType *oneType ) {
+                if ( widenFirst ) {
+                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
+                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
+                                        result = type2->clone();
+                                        result->get_qualifiers() += oneType->get_qualifiers();
+                                }
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.cc

@@ -160 +160 @@
                         // xxx - not positive this is correct, but appears to allow casting int => enum
                         cost = Cost( 1, 0, 0 );
-    } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
+                } // if
         }
 
@@ -175 +177 @@
                                 } // if
                         } // if
+                } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                        cost = Cost( 1, 0, 0 );
                 } // if
         }
@@ -256 +260 @@
                 }
         }
+
+        void ConversionCost::visit(ZeroType *zeroType) {
+                if ( dynamic_cast< ZeroType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                } else if ( dynamic_cast< PointerType* >( dest ) ) {
+                        cost = Cost( 0, 0, 1 );
+                }
+        }
+
+        void ConversionCost::visit(OneType *oneType) {
+                if ( dynamic_cast< OneType* >( dest ) ) {
+                        cost = Cost::zero;
+                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
+                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
+                        if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                        }
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.h

@@ -41 +41 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           protected:
                 Type *dest;

src/ResolvExpr/PtrsAssignable.cc

@@ -39 +39 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
           private:
                 Type *dest;
@@ -141 +143 @@
         void PtrsAssignable::visit( VarArgsType *varArgsType ) {
         }
+
+        void PtrsAssignable::visit( ZeroType *zeroType ) {
+        }
+        
+        void PtrsAssignable::visit( OneType *oneType ) {
+        }
+        
 } // namespace ResolvExpr
 

src/ResolvExpr/PtrsCastable.cc

@@ -40 +40 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           private:
                 Type *dest;
@@ -144 +146 @@
                 result = objectCast( dest, env, indexer );
         }
+
+        void PtrsCastable::visit(ZeroType *zeroType) {
+                result = objectCast( dest, env, indexer );
+        }
+
+        void PtrsCastable::visit(OneType *oneType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -110 +110 @@
         }
 
+        void RenameVars::visit( ZeroType *zeroType ) {
+                typeBefore( zeroType );
+                typeAfter( zeroType );
+        }
+
+        void RenameVars::visit( OneType *oneType ) {
+                typeBefore( oneType );
+                typeAfter( oneType );
+        }
+
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {

src/ResolvExpr/RenameVars.h

@@ -44 +44 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 void typeBefore( Type *type );

src/ResolvExpr/Resolver.cc

@@ -134 +134 @@
                         } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
+                        } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
+                                return true;
                         } else {
                                 return false;
@@ -455 +457 @@
                         }
                 } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
                         // basic types are handled here
                         Visitor::visit( listInit );

src/ResolvExpr/Unify.cc

@@ -60 +60 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -588 +590 @@
         }
 
+        void Unify::visit(ZeroType *zeroType) {
+                result = dynamic_cast< ZeroType* >( type2 );
+        }
+
+        void Unify::visit(OneType *oneType) {
+                result = dynamic_cast< OneType* >( type2 );
+        }
+
         // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
@@ -602 +612 @@
                 }
         }
-
 } // namespace ResolvExpr