Changeset 000178a

Timestamp:

Nov 2, 2017, 2:29:22 PM (7 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:

ddae809

Parents:

6de43b6

Message:

Refactor reference CommonType? code

File:

• src/ResolvExpr/CommonType.cc (modified) (2 diffs)

src/ResolvExpr/CommonType.cc

@@ -61 +61 @@
         };
 
-        Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
-                Type * result = nullptr, * common = nullptr;
+        Type * handleReference( Type * t1, Type * t2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
+                Type * common = nullptr;
                 AssertionSet have, need;
                 OpenVarSet newOpen( openVars );
                 // need unify to bind type variables
-                if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) {
-                        // std::cerr << "unify success" << std::endl;
-                        if ( widenSecond ) {
-                                // std::cerr << "widen second" << std::endl;
-                                if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) {
-                                        result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone();
-                                        result->get_qualifiers() |= other->get_qualifiers();
-                                }
-                        } else if ( widenFirst ) {
-                                // std::cerr << "widen first" << std::endl;
-                                if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) {
-                                        result = common;
-                                        result->get_qualifiers() |= refType->get_qualifiers();
-                                }
-                        }
-                } else {
-                        // std::cerr << "exact unify failed: " << refType << " " << other << std::endl;
-                }
-                // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl;
-                return result;
+                if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
+                        // std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
+                        if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
+                                // std::cerr << "widen okay" << std::endl;
+                                common->get_qualifiers() |= t1->get_qualifiers();
+                                common->get_qualifiers() |= t2->get_qualifiers();
+                                return common;
+                        }
+                }
+                // std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
+                return nullptr;
         }
 
@@ -99 +90 @@
 
                         // special case where one type has a reference depth of 1 larger than the other
-                        if ( diff > 0 ) {
-                                return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
-                        } else if ( diff < 0 ) {
-                                return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+                        if ( diff > 0 || diff < 0 ) {
+                                Type * result = nullptr;
+                                if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) {
+                                        // formal is reference, so result should be reference
+                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
+                                        if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result );
+                                } else {
+                                        // formal is value, so result should be value
+                                        ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 );
+                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                }
+                                // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
+                                return result;
                         }
                         // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.