Changeset b2daebd4 for src/ResolvExpr/Unify.cc

Timestamp:

Mar 29, 2017, 4:37:00 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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:

ee68e11

Parents:

95448f1e

Message:

ttype parameters to generic types now bind parameter lists into environment

File:

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

src/ResolvExpr/Unify.cc

@@ -134 +134 @@
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
-                        case TypeDecl::Ttype:
+                  case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
                         return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
@@ -592 +592 @@
                 for ( ; it != params.end() && jt != otherParams.end(); ++it, ++jt ) {
                         TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
-                        assert(param && "Aggregate parameters should be type expressions");
+                        assertf(param, "Aggregate parameters should be type expressions");
                         TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt);
-                        assert(otherParam && "Aggregate parameters should be type expressions");
-
-                        if ( ! unifyExact( param->get_type(), otherParam->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
+                        assertf(otherParam, "Aggregate parameters should be type expressions");
+                        
+                        Type* paramTy = param->get_type();
+                        Type* otherParamTy = otherParam->get_type();
+
+                        bool tupleParam = Tuples::isTtype( paramTy );
+                        bool otherTupleParam = Tuples::isTtype( otherParamTy );
+
+                        if ( tupleParam && otherTupleParam ) {
+                                ++it; ++jt;  // skip ttype parameters for break
+                        } else if ( tupleParam ) {
+                                // bundle other parameters into tuple to match
+                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+
+                                do {
+                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        ++jt;
+
+                                        if ( jt == otherParams.end() ) break;
+
+                                        otherParam = dynamic_cast< TypeExpr* >(*jt);
+                                        assertf(otherParam, "Aggregate parameters should be type expressions");
+                                } while (true);
+
+                                otherParamTy = binder;
+                                ++it;  // skip ttype parameter for break
+                        } else if ( otherTupleParam ) {
+                                // bundle parameters into tuple to match other
+                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+
+                                do {
+                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        ++it;
+
+                                        if ( it == params.end() ) break;
+
+                                        param = dynamic_cast< TypeExpr* >(*it);
+                                        assertf(param, "Aggregate parameters should be type expressions");
+                                } while (true);
+
+                                paramTy = binder;
+                                ++jt;  // skip ttype parameter for break
+                        }
+
+                        if ( ! unifyExact( paramTy, otherParamTy, env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
                                 result = false;
                                 return;
                         }
+
+                        // ttype parameter should be last
+                        if ( tupleParam || otherTupleParam ) break;
                 }
                 result = ( it == params.end() && jt == otherParams.end() );