source: src/ResolvExpr/Unify.cc @ 02ec390

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglergc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newstringwith_gc
Last change on this file since 02ec390 was 02ec390, checked in by Aaron Moss <a3moss@…>, 6 years ago

First attempt at properly resolving functions on generic types

  • Property mode set to 100644
File size: 22.1 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Unify.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 12:27:10 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Jun 26 14:57:05 2015
13// Update Count     : 7
14//
15
16#include <set>
17#include <memory>
18
19#include "Unify.h"
20#include "TypeEnvironment.h"
21#include "typeops.h"
22#include "FindOpenVars.h"
23#include "SynTree/Visitor.h"
24#include "SynTree/Type.h"
25#include "SynTree/Declaration.h"
26#include "SymTab/Indexer.h"
27#include "utility.h"
28
29
30//#define DEBUG
31
32namespace ResolvExpr {
33        struct WidenMode {
34                WidenMode( bool widenFirst, bool widenSecond ): widenFirst( widenFirst ), widenSecond( widenSecond ) {}
35                WidenMode &operator|=( const WidenMode &other ) { widenFirst |= other.widenFirst; widenSecond |= other.widenSecond; return *this; }
36                WidenMode &operator&=( const WidenMode &other ) { widenFirst &= other.widenFirst; widenSecond &= other.widenSecond; return *this; }
37                WidenMode operator|( const WidenMode &other ) { WidenMode newWM( *this ); newWM |= other; return newWM; }
38                WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; }
39                operator bool() { return widenFirst && widenSecond; }
40 
41                bool widenFirst : 1, widenSecond : 1;
42        };
43
44        class Unify : public Visitor {
45          public:
46                Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
47 
48                bool get_result() const { return result; }
49          private:
50                virtual void visit(VoidType *voidType);
51                virtual void visit(BasicType *basicType);
52                virtual void visit(PointerType *pointerType);
53                virtual void visit(ArrayType *arrayType);
54                virtual void visit(FunctionType *functionType);
55                virtual void visit(StructInstType *aggregateUseType);
56                virtual void visit(UnionInstType *aggregateUseType);
57                virtual void visit(EnumInstType *aggregateUseType);
58                virtual void visit(ContextInstType *aggregateUseType);
59                virtual void visit(TypeInstType *aggregateUseType);
60                virtual void visit(TupleType *tupleType);
61
62                template< typename RefType > void handleRefType( RefType *inst, Type *other );
63                template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
64
65                bool result;
66                Type *type2;                            // inherited
67                TypeEnvironment &env;
68                AssertionSet &needAssertions;
69                AssertionSet &haveAssertions;
70                const OpenVarSet &openVars;
71                WidenMode widenMode;
72                Type *commonType;
73                const SymTab::Indexer &indexer;
74        };
75
76        /// Attempts an inexact unification of type1 and type2.
77        /// Returns false if no such unification; if the types can be unified, sets common (unless they unify exactly and have identical type qualifiers)
78        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
79        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
80 
81        bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
82                TypeEnvironment newEnv;
83                OpenVarSet openVars;
84                AssertionSet needAssertions, haveAssertions;
85                Type *newFirst = first->clone(), *newSecond = second->clone();
86                env.apply( newFirst );
87                env.apply( newSecond );
88                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
89                delete newFirst;
90                delete newSecond;
91                return result;
92        }
93
94        bool typesCompatibleIgnoreQualifiers( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
95                TypeEnvironment newEnv;
96                OpenVarSet openVars;
97                AssertionSet needAssertions, haveAssertions;
98                Type *newFirst = first->clone(), *newSecond = second->clone();
99                env.apply( newFirst );
100                env.apply( newSecond );
101                newFirst->get_qualifiers() = Type::Qualifiers();
102                newSecond->get_qualifiers() = Type::Qualifiers();
103///   std::cout << "first is ";
104///   first->print( std::cout );
105///   std::cout << std::endl << "second is ";
106///   second->print( std::cout );
107///   std::cout << std::endl << "newFirst is ";
108///   newFirst->print( std::cout );
109///   std::cout << std::endl << "newSecond is ";
110///   newSecond->print( std::cout );
111///   std::cout << std::endl;
112                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
113                delete newFirst;
114                delete newSecond;
115                return result;
116        }
117
118        bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
119                if ( dynamic_cast< FunctionType* >( type ) ) {
120                        return true;
121                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
122                        return typeInst->get_isFtype();
123                } // if
124                return false;
125        }
126
127        bool tyVarCompatible( TypeDecl::Kind kind, Type *type, const SymTab::Indexer &indexer ) {
128                switch ( kind ) {
129                  case TypeDecl::Any:
130                  case TypeDecl::Dtype:
131                        return ! isFtype( type, indexer );
132 
133                  case TypeDecl::Ftype:
134                        return isFtype( type, indexer );
135                } // switch
136                assert( false );
137                return false;
138        }
139
140        bool bindVar( TypeInstType *typeInst, Type *other, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
141                OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
142                assert( tyvar != openVars.end() );
143                if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
144                        return false;
145                } // if
146                if ( occurs( other, typeInst->get_name(), env ) ) {
147                        return false;
148                } // if
149                EqvClass curClass;
150                if ( env.lookup( typeInst->get_name(), curClass ) ) {
151                        if ( curClass.type ) {
152                                Type *common = 0;
153                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
154                                std::auto_ptr< Type > newType( curClass.type->clone() );
155                                newType->get_qualifiers() = typeInst->get_qualifiers();
156                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
157                                        if ( common ) {
158                                                common->get_qualifiers() = Type::Qualifiers();
159                                                delete curClass.type;
160                                                curClass.type = common;
161                                                env.add( curClass );
162                                        } // if
163                                        return true;
164                                } else {
165                                        return false;
166                                } // if
167                        } else {
168                                curClass.type = other->clone();
169                                curClass.type->get_qualifiers() = Type::Qualifiers();
170                                curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
171                                env.add( curClass );
172                        } // if
173                } else {
174                        EqvClass newClass;
175                        newClass.vars.insert( typeInst->get_name() );
176                        newClass.type = other->clone();
177                        newClass.type->get_qualifiers() = Type::Qualifiers();
178                        newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
179                        newClass.kind = kind;
180                        env.add( newClass );
181                } // if
182                return true;
183        }
184
185        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
186                bool result = true;
187                EqvClass class1, class2;
188                bool hasClass1 = false, hasClass2 = false;
189                bool widen1 = false, widen2 = false;
190                Type *type1 = 0, *type2 = 0;
191 
192                if ( env.lookup( var1->get_name(), class1 ) ) {
193                        hasClass1 = true;
194                        if ( class1.type ) {
195                                if ( occurs( class1.type, var2->get_name(), env ) ) {
196                                        return false;
197                                } // if
198                                type1 = class1.type->clone();
199                        } // if
200                        widen1 = widenMode.widenFirst && class1.allowWidening;
201                } // if
202                if ( env.lookup( var2->get_name(), class2 ) ) {
203                        hasClass2 = true;
204                        if ( class2.type ) {
205                                if ( occurs( class2.type, var1->get_name(), env ) ) {
206                                        return false;
207                                } // if
208                                type2 = class2.type->clone();
209                        } // if
210                        widen2 = widenMode.widenSecond && class2.allowWidening;
211                } // if
212 
213                if ( type1 && type2 ) {
214//    std::cout << "has type1 && type2" << std::endl;
215                        WidenMode newWidenMode ( widen1, widen2 );
216                        Type *common = 0;
217                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
218                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
219                                class1.allowWidening = widen1 && widen2;
220                                if ( common ) {
221                                        common->get_qualifiers() = Type::Qualifiers();
222                                        delete class1.type;
223                                        class1.type = common;
224                                } // if
225                                env.add( class1 );
226                        } else {
227                                result = false;
228                        } // if
229                } else if ( hasClass1 && hasClass2 ) {
230                        if ( type1 ) {
231                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
232                                class1.allowWidening = widen1;
233                                env.add( class1 );
234                        } else {
235                                class2.vars.insert( class1.vars.begin(), class1.vars.end() );
236                                class2.allowWidening = widen2;
237                                env.add( class2 );
238                        } // if
239                } else if ( hasClass1 ) {
240                        class1.vars.insert( var2->get_name() );
241                        class1.allowWidening = widen1;
242                        env.add( class1 );
243                } else if ( hasClass2 ) {
244                        class2.vars.insert( var1->get_name() );
245                        class2.allowWidening = widen2;
246                        env.add( class2 );
247                } else {
248                        EqvClass newClass;
249                        newClass.vars.insert( var1->get_name() );
250                        newClass.vars.insert( var2->get_name() );
251                        newClass.allowWidening = widen1 && widen2;
252                        newClass.kind = kind;
253                        env.add( newClass );
254                } // if
255                delete type1;
256                delete type2;
257                return result;
258        }
259
260        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
261                OpenVarSet closedVars;
262                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
263                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
264                Type *commonType = 0;
265                if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
266                        if ( commonType ) {
267                                delete commonType;
268                        } // if
269                        return true;
270                } else {
271                        return false;
272                } // if
273        }
274
275        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType ) {
276                OpenVarSet closedVars;
277                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
278                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
279                return unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType );
280        }
281
282        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
283#ifdef DEBUG
284                TypeEnvironment debugEnv( env );
285#endif
286                if ( type1->get_qualifiers() != type2->get_qualifiers() ) {
287                        return false;
288                }
289
290                bool result;
291                TypeInstType *var1 = dynamic_cast< TypeInstType* >( type1 );
292                TypeInstType *var2 = dynamic_cast< TypeInstType* >( type2 );
293                OpenVarSet::const_iterator entry1, entry2;
294                if ( var1 ) {
295                        entry1 = openVars.find( var1->get_name() );
296                } // if
297                if ( var2 ) {
298                        entry2 = openVars.find( var2->get_name() );
299                } // if
300                bool isopen1 = var1 && ( entry1 != openVars.end() );
301                bool isopen2 = var2 && ( entry2 != openVars.end() );
302
303                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
304                        result = bindVarToVar( var1, var2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
305                } else if ( isopen1 ) {
306                        result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
307                } else if ( isopen2 ) {
308                        result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
309                } else {
310                        Unify comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
311                        type1->accept( comparator );
312                        result = comparator.get_result();
313                } // if
314#ifdef DEBUG
315                std::cout << "============ unifyExact" << std::endl;
316                std::cout << "type1 is ";
317                type1->print( std::cout );
318                std::cout << std::endl << "type2 is ";
319                type2->print( std::cout );
320                std::cout << std::endl << "openVars are ";
321                printOpenVarSet( openVars, std::cout, 8 );
322                std::cout << std::endl << "input env is " << std::endl;
323                debugEnv.print( std::cout, 8 );
324                std::cout << std::endl << "result env is " << std::endl;
325                env.print( std::cout, 8 );
326                std::cout << "result is " << result << std::endl;
327#endif
328                return result;
329        }
330
331        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
332                return unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
333        }
334
335        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common ) {
336                Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
337                type1->get_qualifiers() = Type::Qualifiers();
338                type2->get_qualifiers() = Type::Qualifiers();
339                bool result;
340#ifdef DEBUG
341                std::cout << "unifyInexact type 1 is ";
342                type1->print( std::cout );
343                std::cout << "type 2 is ";
344                type2->print( std::cout );
345                std::cout << std::endl;
346#endif
347                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
348#ifdef DEBUG
349                        std::cout << "unifyInexact: no exact unification found" << std::endl;
350#endif
351                        if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
352                                common->get_qualifiers() = tq1 + tq2;
353#ifdef DEBUG
354                                std::cout << "unifyInexact: common type is ";
355                                common->print( std::cout );
356                                std::cout << std::endl;
357#endif
358                                result = true;
359                        } else {
360#ifdef DEBUG
361                                std::cout << "unifyInexact: no common type found" << std::endl;
362#endif
363                                result = false;
364                        } // if
365                } else {
366                        if ( tq1 != tq2 ) {
367                                if ( ( tq1 > tq2 || widenMode.widenFirst ) && ( tq2 > tq1 || widenMode.widenSecond ) ) {
368                                        common = type1->clone();
369                                        common->get_qualifiers() = tq1 + tq2;
370                                        result = true;
371                                } else {
372                                        result = false;
373                                } // if
374                        } else {
375                                result = true;
376                        } // if
377                } // if
378                type1->get_qualifiers() = tq1;
379                type2->get_qualifiers() = tq2;
380                return result;
381        }
382
383        Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer )
384                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) {
385        }
386
387        void Unify::visit(VoidType *voidType) {
388                result = dynamic_cast< VoidType* >( type2 );
389        }
390
391        void Unify::visit(BasicType *basicType) {
392                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
393                        result = basicType->get_kind() == otherBasic->get_kind();
394                } // if
395        }
396
397        void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
398///   std::cout << "assertion set is" << std::endl;
399///   printAssertionSet( assertions, std::cout, 8 );
400///   std::cout << "looking for ";
401///   assert->print( std::cout );
402///   std::cout << std::endl;
403                AssertionSet::iterator i = assertions.find( assert );
404                if ( i != assertions.end() ) {
405///     std::cout << "found it!" << std::endl;
406                        i->second = true;
407                } // if
408        }
409
410        void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) {
411                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
412                        for ( std::list< DeclarationWithType* >::const_iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
413                                markAssertionSet( assertion1, *assert );
414                                markAssertionSet( assertion2, *assert );
415                        } // for
416                } // for
417        }
418
419        void Unify::visit(PointerType *pointerType) {
420                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
421                        result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
422                        markAssertions( haveAssertions, needAssertions, pointerType );
423                        markAssertions( haveAssertions, needAssertions, otherPointer );
424                } // if
425        }
426
427        void Unify::visit(ArrayType *arrayType) {
428                // XXX -- compare array dimension
429                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
430                if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
431                        result = unifyExact( arrayType->get_base(), otherArray->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
432                } // if
433        }
434
435        template< typename Iterator1, typename Iterator2 >
436        bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
437                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
438                        if ( ! unifyExact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
439                                return false;
440                        } // if
441                } // for
442                if ( list1Begin != list1End || list2Begin != list2End ) {
443                        return false;
444                } else {
445                        return true;
446                } // if
447        }
448
449        void Unify::visit(FunctionType *functionType) {
450                FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
451                if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
452 
453                        if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
454       
455                                if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
456
457                                        markAssertions( haveAssertions, needAssertions, functionType );
458                                        markAssertions( haveAssertions, needAssertions, otherFunction );
459
460                                        result = true;
461                                } // if
462                        } // if
463                } // if
464        }
465
466        template< typename RefType >
467        void Unify::handleRefType( RefType *inst, Type *other ) {
468                // check that other type is compatible and named the same
469                RefType *otherStruct = dynamic_cast< RefType* >( other );
470                result = otherStruct && inst->get_name() == otherStruct->get_name();
471        }
472
473        template< typename RefType >
474        void Unify::handleGenericRefType( RefType *inst, Type *other ) {
475                // Check that other type is compatible and named the same
476                handleRefType( inst, other );
477                if ( ! result ) return;
478                // Check that parameters of type unify, if any
479                std::list< Expression* > params = inst->get_parameters();
480                if ( ! params.empty() ) {
481                        std::list< TypeDecl* > *baseParams = inst->get_baseParameters();
482                        if ( ! baseParams ) {
483                                result = false;
484                                return;
485                        }
486                        std::list< Expression* >::const_iterator it = params.begin();
487                        std::list< TypeDecl* >::const_iterator baseIt = baseParams->begin();
488                        while ( it != params.end() && baseIt != baseParams->end()) {
489                                TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
490                                assert(param && "Aggregate parameters should be type expressions");
491                                TypeInstType baseType(Type::Qualifiers(), (*baseIt)->get_name(), *baseIt);
492                                if ( ! unifyExact( param->get_type(), &baseType, env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
493                                        result = false;
494                                        return;
495                                }
496                               
497                                ++it;
498                                ++baseIt;
499                        }
500                        if ( it != params.end() || baseIt != baseParams->end() ) {
501                                result = false;
502                        }
503                }
504        }
505
506        void Unify::visit(StructInstType *structInst) {
507                handleGenericRefType( structInst, type2 );
508        }
509
510        void Unify::visit(UnionInstType *unionInst) {
511                handleGenericRefType( unionInst, type2 );
512        }
513
514        void Unify::visit(EnumInstType *enumInst) {
515                handleRefType( enumInst, type2 );
516        }
517
518        void Unify::visit(ContextInstType *contextInst) {
519                handleRefType( contextInst, type2 );
520        }
521
522        void Unify::visit(TypeInstType *typeInst) {
523                assert( openVars.find( typeInst->get_name() ) == openVars.end() );
524                TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
525                if ( otherInst && typeInst->get_name() == otherInst->get_name() ) {
526                        result = true;
527///   } else {
528///     NamedTypeDecl *nt = indexer.lookupType( typeInst->get_name() );
529///     if ( nt ) {
530///       TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
531///       assert( type );
532///       if ( type->get_base() ) {
533///         result = unifyExact( type->get_base(), typeInst, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
534///       }
535///     }
536                } // if
537        }
538
539        template< typename Iterator1, typename Iterator2 >
540        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
541                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
542                        Type *commonType = 0;
543                        if ( ! unifyInexact( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, widenMode, indexer, commonType ) ) {
544                                return false;
545                        }
546                        delete commonType;
547                } // for
548                if ( list1Begin != list1End || list2Begin != list2End ) {
549                        return false;
550                } else {
551                        return true;
552                } //if
553        }
554
555        void Unify::visit(TupleType *tupleType) {
556                if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
557                        result = unifyList( tupleType->get_types().begin(), tupleType->get_types().end(), otherTuple->get_types().begin(), otherTuple->get_types().end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
558                } // if
559        }
560
561} // namespace ResolvExpr
562
563// Local Variables: //
564// tab-width: 4 //
565// mode: c++ //
566// compile-command: "make install" //
567// End: //
Note: See TracBrowser for help on using the repository browser.